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) { }