protected override PropertyManagerPageGroupBase Create(PropertyManagerPagePage page, IAttributeSet atts)
{
const int OPTIONS_NOT_USED = 0;
var icon = atts.BoundMemberInfo?.TryGetAttribute <IconAttribute>()?.Icon;
if (icon == null)
{
icon = atts.BoundType?.TryGetAttribute <IconAttribute>()?.Icon;
}
string iconPath = "";
if (icon != null)
{
iconPath = m_IconsConv.ConvertIcon(new TabIcon(IconsConverter.FromXImage(icon))).First();
//NOTE: tab icon must be in 256 color bitmap, otherwise it is not displayed
TryConvertIconTo8bit(iconPath);
}
var tab = page.Page.AddTab(atts.Id, atts.Name,
iconPath, OPTIONS_NOT_USED) as IPropertyManagerPageTab;
return(new PropertyManagerPageTabControl(atts.Id, atts.Tag,
page.Handler, tab, page.App, page));
}
protected PropertyManagerPageBaseControlConstructor(ISldWorks app, swPropertyManagerPageControlType_e type,
IconsConverter iconsConv)
{
m_App = app;
m_IconConv = iconsConv;
m_Type = type;
}
protected override PropertyManagerPageBitmapButtonControl CreateControl(
IPropertyManagerPageBitmapButton swCtrl, IAttributeSet atts, SwPropertyManagerPageHandler handler, short height)
{
var bmpAtt = atts.Get <BitmapButtonAttribute>();
if (bmpAtt.StandardIcon.HasValue)
{
swCtrl.SetStandardBitmaps((int)bmpAtt.StandardIcon.Value);
}
else
{
var bmpWidth = bmpAtt.Width;
var bmpHeight = bmpAtt.Height;
var icon = AdjustIcon(IconsConverter.FromXImage(bmpAtt.Icon ?? Defaults.Icon), bmpWidth, bmpHeight);
if (m_App.IsVersionNewerOrEqual(Enums.SwVersion_e.Sw2016))
{
var icons = m_IconsConv.ConvertIcon(new BitmapButtonHighResIcon(icon, bmpWidth, bmpHeight));
var imgList = icons.Take(6).ToArray();
var maskImgList = icons.Skip(6).ToArray();
swCtrl.SetBitmapsByName3(imgList, maskImgList);
}
else
{
var icons = m_IconsConv.ConvertIcon(new BitmapButtonIcon(icon, bmpWidth, bmpHeight));
swCtrl.SetBitmapsByName2(icons[0], icons[1]);
}
}
return(new PropertyManagerPageBitmapButtonControl(atts.Id, atts.Tag, swCtrl, handler));
}
public void ReplaceColor()
{
var bmp = new Bitmap(2, 2);
bmp.SetPixel(0, 0, Color.FromArgb(255, 100, 50));
bmp.SetPixel(0, 1, Color.FromArgb(255, 1, 1));
bmp.SetPixel(1, 0, Color.FromArgb(255, 100, 50));
bmp.SetPixel(1, 1, Color.FromArgb(255, 2, 2));
var res = IconsConverter.ReplaceColor(bmp,
new IconsConverter.ColorReplacerDelegate((ref byte r, ref byte g, ref byte b, ref byte a) =>
{
if (r == 255 && g == 100 && b == 50)
{
r = 10;
g = 20;
b = 30;
}
})) as Bitmap;
Assert.AreNotEqual(bmp, res);
Assert.AreEqual(Color.FromArgb(10, 20, 30), res.GetPixel(0, 0));
Assert.AreEqual(Color.FromArgb(255, 1, 1), res.GetPixel(0, 1));
Assert.AreEqual(Color.FromArgb(10, 20, 30), res.GetPixel(1, 0));
Assert.AreEqual(Color.FromArgb(255, 2, 2), res.GetPixel(1, 1));
}
private void CreateIcons(CommandGroup cmdGroup, CommandGroupSpec cmdBar, IconsConverter iconsConv)
{
var mainIcon = cmdBar.Icon;
if (mainIcon == null)
{
mainIcon = Defaults.Icon;
}
Image[] iconList = null;
if (cmdBar.Commands != null)
{
iconList = cmdBar.Commands.Select(c => IconsConverter.FromXImage(c.Icon ?? Defaults.Icon)).ToArray();
}
//NOTE: if commands are not used, main icon will fail if toolbar commands image list is not specified, so it is required to specify it explicitly
if (CompatibilityUtils.SupportsHighResIcons(m_App.Sw, CompatibilityUtils.HighResIconsScope_e.CommandManager))
{
var iconsList = iconsConv.ConvertIcon(new CommandGroupHighResIcon(IconsConverter.FromXImage(mainIcon)));
cmdGroup.MainIconList = iconsList;
if (iconList != null && iconList.Any())
{
cmdGroup.IconList = iconsConv.ConvertIconsGroup(
iconList.Select(i => new CommandGroupHighResIcon(i)).ToArray());
}
else
{
cmdGroup.IconList = iconsList;
}
}
else
{
var mainIconPath = iconsConv.ConvertIcon(new CommandGroupIcon(IconsConverter.FromXImage(mainIcon)));
var smallIcon = mainIconPath[0];
var largeIcon = mainIconPath[1];
cmdGroup.SmallMainIcon = smallIcon;
cmdGroup.LargeMainIcon = largeIcon;
if (iconList != null && iconList.Any())
{
var iconListPath = iconsConv.ConvertIconsGroup(iconList.Select(i => new CommandGroupIcon(i)).ToArray());
var smallIconList = iconListPath[0];
var largeIconList = iconListPath[1];
cmdGroup.SmallIconList = smallIconList;
cmdGroup.LargeIconList = largeIconList;
}
else
{
cmdGroup.SmallIconList = smallIcon;
cmdGroup.LargeIconList = largeIcon;
}
}
}
internal PropertyManagerPageConstructor(ISldWorks app, IconsConverter iconsConv, SwPropertyManagerPageHandler handler)
{
m_App = app;
m_IconsConv = iconsConv;
m_Handler = handler;
handler.Init(m_App);
}
public PropertyManagerPageBitmapEx(IconsConverter iconsConv,
int id, object tag, Size?size,
IPropertyManagerPageBitmap bitmap,
PropertyManagerPageHandlerEx handler) : base(bitmap, id, tag, handler)
{
m_Size = size.HasValue ? size.Value : new Size(18, 18);
m_IconsConv = iconsConv;
}
public PropertyManagerPageEx(ISldWorks app, IPageSpec pageSpec)
{
m_App = app;
m_Logger = LoggerFactory.Create(this);
m_IconsConv = new IconsConverter();
m_Handler = new THandler();
m_PmpBuilder = new PropertyManagerPageBuilder <THandler>(app, m_IconsConv, m_Handler, pageSpec, Logger);
}
private void CreateIcons(CommandGroup cmdGroup, ICommandGroupSpec cmdBar, IconsConverter iconsConv)
{
var mainIcon = cmdBar.Icon;
CommandGroupIcon[] iconList = null;
if (cmdBar.Commands != null)
{
iconList = cmdBar.Commands.Select(c => c.Icon).ToArray();
}
//NOTE: if commands are not used, main icon will fail if toolbar commands image list is not specified, so it is required to specify it explicitly
if (App.SupportsHighResIcons(SldWorksExtension.HighResIconsScope_e.CommandManager))
{
var iconsList = iconsConv.ConvertIcon(mainIcon, true);
cmdGroup.MainIconList = iconsList;
if (iconList != null && iconList.Any())
{
cmdGroup.IconList = iconsConv.ConvertIconsGroup(iconList, true);
}
else
{
cmdGroup.IconList = iconsList;
}
}
else
{
var mainIconPath = iconsConv.ConvertIcon(mainIcon, false);
var smallIcon = mainIconPath[0];
var largeIcon = mainIconPath[1];
cmdGroup.SmallMainIcon = smallIcon;
cmdGroup.LargeMainIcon = largeIcon;
if (iconList != null && iconList.Any())
{
var iconListPath = iconsConv.ConvertIconsGroup(iconList, true);
var smallIconList = iconListPath[0];
var largeIconList = iconListPath[1];
cmdGroup.SmallIconList = smallIconList;
cmdGroup.LargeIconList = largeIconList;
}
else
{
cmdGroup.SmallIconList = smallIcon;
cmdGroup.LargeIconList = largeIcon;
}
}
}
private static Image CreateMask(Image icon)
{
return(IconsConverter.ReplaceColor(icon,
new IconsConverter.ColorReplacerDelegate((ref byte r, ref byte g, ref byte b, ref byte a) =>
{
var mask = (byte)(255 - a);
r = mask;
g = mask;
b = mask;
a = 255;
})));
}
protected override void SetSpecificValue(Image value)
{
if (value == null)
{
value = IconsConverter.FromXImage(Defaults.Icon);
}
var icons = m_IconsConv.ConvertIcon(new ControlIcon(value, m_Size));
SwSpecificControl.SetBitmapByName(icons[0], icons[1]);
m_Image = value;
}
internal PropertyManagerPageBuilder(ISldWorks app, IconsConverter iconsConv, THandler handler, IPageSpec pageSpec, ILogger logger)
: this(new PmpTypeDataBinder(),
new PropertyManagerPageConstructor <THandler>(app, iconsConv, handler),
new PropertyManagerPageGroupConstructor <THandler>(),
new PropertyManagerPageTextBoxConstructor <THandler>(app, iconsConv),
new PropertyManagerPageNumberBoxConstructor <THandler>(app, iconsConv),
new PropertyManagerPageCheckBoxConstructor <THandler>(app, iconsConv),
new PropertyManagerPageComboBoxConstructor <THandler>(app, iconsConv),
new PropertyManagerPageSelectionBoxConstructor <THandler>(app, iconsConv, logger),
new PropertyManagerPageOptionBoxConstructor <THandler>(app, iconsConv),
new PropertyManagerPageButtonConstructor <THandler>(app, iconsConv),
new PropertyManagerPageBitmapConstructor <THandler>(app, iconsConv),
new PropertyManagerPageTabConstructor <THandler>(iconsConv))
{
m_PageSpec = pageSpec;
}
public SwPropertyManagerPage(ISldWorks app, IPageSpec pageSpec, ILogger logger, Type handlerType)
{
m_App = app;
Logger = logger;
m_IconsConv = new IconsConverter();
//TODO: validate that handlerType inherits PropertyManagerPageHandlerEx and it is COM visible with parameterless constructor
Handler = (SwPropertyManagerPageHandler)Activator.CreateInstance(handlerType);
Handler.DataChanged += OnDataChanged;
Handler.Closed += OnClosed;
Handler.Closing += OnClosing;
m_PmpBuilder = new PropertyManagerPageBuilder(app, m_IconsConv, Handler, pageSpec, Logger);
}
public ISwFeatureMgrTab <TControl> CreateFeatureManagerTab <TControl>(ISwDocument doc)
{
var mdlViewMgr = doc.Model.ModelViewManager;
using (var iconsConv = new IconsConverter())
{
return(CustomControlHelper.HostControl <TControl, SwFeatureMgrTab <TControl> >(
(c, h, t, i) =>
{
var imgPath = iconsConv.ConvertIcon(new FeatMgrViewIcon(i)).First();
var featMgr = mdlViewMgr.CreateFeatureMgrWindowFromHandlex64(
imgPath, h.Handle.ToInt64(), t, (int)swFeatMgrPane_e.swFeatMgrPaneBottom) as IFeatMgrView;
if (featMgr != null)
{
return new SwFeatureMgrTab <TControl>(c, featMgr, doc);
}
else
{
throw new NetControlHostException(h.Handle);
}
},
(p, t, i) =>
{
var imgPath = iconsConv.ConvertIcon(new FeatMgrViewIcon(i)).First();
var featMgr = mdlViewMgr.CreateFeatureMgrControl3(imgPath, p, "", t,
(int)swFeatMgrPane_e.swFeatMgrPaneBottom) as IFeatMgrView;
TControl ctrl = default;
if (featMgr != null)
{
ctrl = (TControl)featMgr.GetControl();
}
if (ctrl == null)
{
throw new ComControlHostException(p);
}
return new SwFeatureMgrTab <TControl>(ctrl, featMgr, doc);
}));
}
}
private void TryCreateIcons()
{
var iconsConverter = new IconsConverter(
MacroFeatureIconInfo.GetLocation(this.GetType()), false);
IIcon regIcon = null;
IIcon highIcon = null;
IIcon suppIcon = null;
this.GetType().TryGetAttribute <IconAttribute>(a =>
{
regIcon = a.Regular;
highIcon = a.Highlighted;
suppIcon = a.Suppressed;
});
if (regIcon == null)
{
//TODO: load default
}
if (highIcon == null)
{
highIcon = regIcon;
}
if (suppIcon == null)
{
suppIcon = regIcon;
}
//Creation of icons may fail if user doesn't have write permissions or icon is locked
try
{
iconsConverter.ConvertIcon(regIcon, true);
iconsConverter.ConvertIcon(suppIcon, true);
iconsConverter.ConvertIcon(highIcon, true);
iconsConverter.ConvertIcon(regIcon, false);
iconsConverter.ConvertIcon(suppIcon, false);
iconsConverter.ConvertIcon(highIcon, false);
}
catch
{
}
}
internal PropertyManagerPageBuilder(ISwApplication app, IconsConverter iconsConv, SwPropertyManagerPageHandler handler, IPageSpec pageSpec, IXLogger logger)
: this(app, new PmpTypeDataBinder(),
new PropertyManagerPageConstructor(app.Sw, iconsConv, handler),
new PropertyManagerPageGroupControlConstructor(),
new PropertyManagerPageTextBoxControlConstructor(app.Sw, iconsConv),
new PropertyManagerPageNumberBoxConstructor(app.Sw, iconsConv),
new PropertyManagerPageCheckBoxControlConstructor(app.Sw, iconsConv),
new PropertyManagerPageEnumComboBoxControlConstructor(app.Sw, iconsConv),
new PropertyManagerPageCustomItemsComboBoxControlConstructor(app, iconsConv),
new PropertyManagerPageSelectionBoxControlConstructor(app, iconsConv, logger),
new PropertyManagerPageOptionBoxConstructor(app.Sw, iconsConv),
new PropertyManagerPageButtonControlConstructor(app.Sw, iconsConv),
new PropertyManagerPageBitmapControlConstructor(app.Sw, iconsConv),
new PropertyManagerPageTabConstructor(iconsConv),
new PropertyManagerPageCustomControlConstructor(app.Sw, iconsConv),
new PropertyManagerPageBitmapButtonConstructor(app.Sw, iconsConv))
{
m_PageSpec = pageSpec;
}
internal SwPropertyManagerPage(ISwApplication app, IPageSpec pageSpec, IXLogger logger, Type handlerType)
{
m_App = app;
Logger = logger;
m_IconsConv = new IconsConverter();
//TODO: validate that handlerType inherits PropertyManagerPageHandlerEx and it is COM visible with parameterless constructor
Handler = (SwPropertyManagerPageHandler)Activator.CreateInstance(handlerType);
Handler.DataChanged += OnDataChanged;
Handler.Closed += OnClosed;
Handler.Closing += OnClosing;
m_PmpBuilder = new PropertyManagerPageBuilder(app, m_IconsConv, Handler, pageSpec, Logger);
m_Page = m_PmpBuilder.CreatePage <TModel>();
Controls = m_Page.Binding.Bindings.Select(b => b.Control)
.OfType <IPropertyManagerPageControlEx>().ToArray();
}
internal SwCommandGroup AddCommandGroupOrContextMenu(CommandGroupSpec cmdBar,
bool isContextMenu, swSelectType_e?contextMenuSelectType)
{
m_Logger.Log($"Creating command group: {cmdBar.Id}");
if (m_CommandBars.FirstOrDefault(b => b.Spec.Id == cmdBar.Id) != null)
{
throw new GroupIdAlreadyExistsException(cmdBar);
}
var title = GetMenuPath(cmdBar);
var cmdGroup = CreateCommandGroup(cmdBar.Id, title, cmdBar.Tooltip,
cmdBar.Commands.Select(c => c.UserId).ToArray(), isContextMenu,
contextMenuSelectType);
var bar = new SwCommandGroup(m_App, cmdBar, cmdGroup);
m_CommandBars.Add(bar);
using (var iconsConv = new IconsConverter())
{
CreateIcons(cmdGroup, cmdBar, iconsConv);
var createdCmds = CreateCommandItems(bar, cmdBar.Id, cmdBar.Commands);
var tabGroup = GetRootCommandGroup(cmdBar);
try
{
CreateCommandTabBox(tabGroup, createdCmds);
}
catch (Exception ex)
{
m_Logger.Log(ex);
//not critical error - continue operation
}
}
return(bar);
}
private CommandGroup AddCommandGroupOrContextMenu <TCmdEnum>(Action <TCmdEnum> callback,
EnableMethodDelegate <TCmdEnum> enable, bool isContextMenu, swSelectType_e contextMenuSelectType)
where TCmdEnum : IComparable, IFormattable, IConvertible
{
if (!(typeof(TCmdEnum).IsEnum))
{
throw new ArgumentException($"{typeof(TCmdEnum)} must be an Enum");
}
if (callback == null)
{
throw new CallbackNotSpecifiedException();
}
var cmdGroupType = typeof(TCmdEnum);
int groupId;
string title;
string toolTip;
GetCommandGroupAttribution(cmdGroupType, out groupId, out title, out toolTip);
var cmds = Enum.GetValues(cmdGroupType).Cast <Enum>().ToArray();
var cmdGroup = CreateCommandGroup(groupId, title, toolTip, cmds, isContextMenu, contextMenuSelectType);
using (var iconsConv = new IconsConverter())
{
CreateIcons(cmdGroup, cmdGroupType, cmds, iconsConv);
CreateCommandItems(cmdGroup, groupId, cmds, callback, enable);
cmdGroup.HasToolbar = true;
cmdGroup.HasMenu = true;
cmdGroup.Activate();
}
return(cmdGroup);
}
private void TryCreateIcons()
{
var iconsConverter = new IconsConverter(
MacroFeatureIconInfo.GetLocation(this.GetType()), false);
System.Drawing.Image icon = null;
this.GetType().TryGetAttribute <IconAttribute>(a =>
{
icon = IconsConverter.FromXImage(a.Icon);
});
if (icon == null)
{
icon = IconsConverter.FromXImage(Defaults.Icon);
}
//TODO: create different icons for highlighted and suppressed
var regular = icon;
var highlighted = icon;
var suppressed = icon;
//Creation of icons may fail if user doesn't have write permissions or icon is locked
try
{
iconsConverter.ConvertIcon(new MacroFeatureIcon(icon, MacroFeatureIconInfo.RegularName));
iconsConverter.ConvertIcon(new MacroFeatureIcon(highlighted, MacroFeatureIconInfo.HighlightedName));
iconsConverter.ConvertIcon(new MacroFeatureIcon(suppressed, MacroFeatureIconInfo.SuppressedName));
iconsConverter.ConvertIcon(new MacroFeatureHighResIcon(icon, MacroFeatureIconInfo.RegularName));
iconsConverter.ConvertIcon(new MacroFeatureHighResIcon(highlighted, MacroFeatureIconInfo.HighlightedName));
iconsConverter.ConvertIcon(new MacroFeatureHighResIcon(suppressed, MacroFeatureIconInfo.SuppressedName));
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public PropertyManagerPageWindowFromHandleConstructor(ISldWorks app, IconsConverter iconsConv) : base(app, swPropertyManagerPageControlType_e.swControlType_WindowFromHandle, iconsConv)
{
}
protected override PropertyManagerPagePage Create(IAttributeSet atts)
{
int err = -1;
swPropertyManagerPageOptions_e opts;
TitleIcon titleIcon = null;
IconAttribute commIconAtt;
if (atts.BoundType.TryGetAttribute(out commIconAtt))
{
if (commIconAtt.Icon != null)
{
titleIcon = new TitleIcon(IconsConverter.FromXImage(commIconAtt.Icon));
}
}
if (atts.Has <PageOptionsAttribute>())
{
var optsAtt = atts.Get <PageOptionsAttribute>();
//TODO: implement conversion
opts = (swPropertyManagerPageOptions_e)optsAtt.Options;
}
else
{
//TODO: implement conversion
opts = (swPropertyManagerPageOptions_e)(PageOptions_e.OkayButton | PageOptions_e.CancelButton);
}
var helpLink = "";
var whatsNewLink = "";
if (atts.Has <HelpAttribute>())
{
var helpAtt = atts.Get <HelpAttribute>();
if (!string.IsNullOrEmpty(helpAtt.WhatsNewLink))
{
if (!opts.HasFlag(swPropertyManagerPageOptions_e.swPropertyManagerOptions_WhatsNew))
{
opts |= swPropertyManagerPageOptions_e.swPropertyManagerOptions_WhatsNew;
}
}
helpLink = helpAtt.HelpLink;
whatsNewLink = helpAtt.WhatsNewLink;
}
var page = m_App.CreatePropertyManagerPage(atts.Name,
(int)opts,
m_Handler, ref err) as IPropertyManagerPage2;
if (titleIcon != null)
{
var iconPath = m_IconsConv.ConvertIcon(titleIcon).First();
page.SetTitleBitmap2(iconPath);
}
if (atts.Has <MessageAttribute>())
{
var msgAtt = atts.Get <MessageAttribute>();
page.SetMessage3(msgAtt.Text, (int)msgAtt.Visibility,
(int)msgAtt.Expanded, msgAtt.Caption);
}
else if (!string.IsNullOrEmpty(atts.Description))
{
page.SetMessage3(atts.Description, (int)swPropertyManagerPageMessageVisibility.swMessageBoxVisible,
(int)swPropertyManagerPageMessageExpanded.swMessageBoxExpand, "");
}
return(new PropertyManagerPagePage(page, m_Handler, m_App, helpLink, whatsNewLink));
}
public PropertyManagerPageCheckBoxConstructor(ISldWorks app, IconsConverter iconsConv)
: base(app, swPropertyManagerPageControlType_e.swControlType_Checkbox, iconsConv)
{
}
public PropertyManagerPageBitmapConstructor(ISldWorks app, IconsConverter iconsConv)
: base(app, swPropertyManagerPageControlType_e.swControlType_Bitmap, iconsConv)
{
m_IconsConv = iconsConv;
}
public PropertyManagerPageOptionBoxConstructor(ISldWorks app, IconsConverter iconsConv)
: base(app, swPropertyManagerPageControlType_e.swControlType_Option, iconsConv)
{
}
public PropertyManagerPageSelectionBoxControlConstructor(ISldWorks app, IconsConverter iconsConv, ILogger logger)
: base(app, swPropertyManagerPageControlType_e.swControlType_Selectionbox, iconsConv)
{
m_Logger = logger;
}
public PropertyManagerPageTabConstructor(IconsConverter iconsConv)
{
m_IconsConv = iconsConv;
}
public PropertyManagerPageSelectionBoxControlConstructor(ISwApplication app, IconsConverter iconsConv, IXLogger logger)
: base(app.Sw, swPropertyManagerPageControlType_e.swControlType_Selectionbox, iconsConv)
{
m_SwApp = app;
m_Logger = logger;
}
/// <inheritdoc/>
public ITaskpaneView CreateTaskPane <TControl, TCmdEnum>(Action <TCmdEnum> cmdHandler, out TControl ctrl)
where TControl : UserControl, new()
where TCmdEnum : IComparable, IFormattable, IConvertible
{
var tooltip = "";
CommandGroupIcon taskPaneIcon = null;
var getTaskPaneDisplayData = new Action <Type, bool>((t, d) =>
{
if (taskPaneIcon == null)
{
taskPaneIcon = DisplayInfoExtractor.ExtractCommandDisplayIcon <TaskPaneIconAttribute, CommandGroupIcon>(
t, i => new TaskPaneMasterIcon(i), a => a.Icon, d);
}
if (string.IsNullOrEmpty(tooltip))
{
if (!t.TryGetAttribute <DisplayNameAttribute>(a => tooltip = a.DisplayName))
{
t.TryGetAttribute <DescriptionAttribute>(a => tooltip = a.Description);
}
}
});
if (typeof(TCmdEnum) != typeof(EmptyTaskPaneCommands_e))
{
getTaskPaneDisplayData.Invoke(typeof(TCmdEnum), false);
}
getTaskPaneDisplayData.Invoke(typeof(TControl), true);
ITaskpaneView taskPaneView = null;
ITaskPaneHandler taskPaneHandler = null;
m_Logger.Log($"Creating task pane for {typeof(TControl).FullName} type");
using (var iconConv = new IconsConverter())
{
if (App.SupportsHighResIcons(SldWorksExtension.HighResIconsScope_e.TaskPane))
{
var taskPaneIconImages = iconConv.ConvertIcon(taskPaneIcon, true);
taskPaneView = App.CreateTaskpaneView3(taskPaneIconImages, tooltip);
}
else
{
var taskPaneIconImage = iconConv.ConvertIcon(taskPaneIcon, false)[0];
taskPaneView = App.CreateTaskpaneView2(taskPaneIconImage, tooltip);
}
taskPaneHandler = new TaskPaneHandler <TCmdEnum>(App, taskPaneView, cmdHandler, iconConv, m_Logger);
}
if (typeof(TControl).IsComVisible())
{
var progId = typeof(TControl).GetProgId();
ctrl = taskPaneView.AddControl(progId, "") as TControl;
if (ctrl == null)
{
throw new NullReferenceException(
$"Failed to create COM control from {progId}. Make sure that COM component is properly registered");
}
}
else
{
ctrl = new TControl();
ctrl.CreateControl();
var handle = ctrl.Handle;
if (!taskPaneView.DisplayWindowFromHandle(handle.ToInt32()))
{
throw new NullReferenceException($"Failed to host .NET control (handle {handle}) in task pane");
}
}
taskPaneHandler.Disposed += OnTaskPaneHandlerDisposed;
m_TaskPanes.Add(taskPaneHandler);
return(taskPaneView);
}
public PropertyManagerPageButtonControlConstructor(ISldWorks app, IconsConverter iconsConv)
: base(app, swPropertyManagerPageControlType_e.swControlType_Button, iconsConv)
{
}
