726 lines
28 KiB
C#
726 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using DevComponents.DotNetBar.Metro;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Windows.Forms;
|
|
using System.Collections;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
|
|
namespace DevComponents.DotNetBar.Design
|
|
{
|
|
// <summary>
|
|
/// Represents Windows Forms designer for MetroTab control.
|
|
/// </summary>
|
|
public class MetroShellDesigner : BarBaseControlDesigner
|
|
{
|
|
#region Private Variables
|
|
private bool m_QuickAccessToolbarSelected = false;
|
|
#endregion
|
|
|
|
#region Internal Implementation
|
|
|
|
public MetroShellDesigner()
|
|
{
|
|
this.EnableItemDragDrop = true;
|
|
this.AcceptExternalControls = false;
|
|
}
|
|
|
|
public override void Initialize(IComponent component)
|
|
{
|
|
base.Initialize(component);
|
|
if (!component.Site.DesignMode)
|
|
return;
|
|
MetroShell c = component as MetroShell;
|
|
if (c != null)
|
|
{
|
|
c.SetDesignMode();
|
|
//this.Expanded = c.Expanded;
|
|
}
|
|
this.EnableDragDrop(false);
|
|
}
|
|
|
|
public override bool CanParent(Control control)
|
|
{
|
|
if (control is MetroTabPanel && !this.Control.Controls.Contains(control))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override DesignerVerbCollection Verbs
|
|
{
|
|
get
|
|
{
|
|
DesignerVerb[] verbs = null;
|
|
verbs = new DesignerVerb[]
|
|
{
|
|
new DesignerVerb("Create Tab", new EventHandler(CreateMetroTab)),
|
|
new DesignerVerb("Create Button", new EventHandler(CreateButton)),
|
|
new DesignerVerb("Create Text Box", new EventHandler(CreateTextBox)),
|
|
new DesignerVerb("Create Combo Box", new EventHandler(CreateComboBox)),
|
|
new DesignerVerb("Create Label", new EventHandler(CreateLabel)),
|
|
new DesignerVerb("Create Micro-Chart", new EventHandler(CreateMicroChart)),
|
|
new DesignerVerb("Create Switch Button", new EventHandler(CreateSwitch)),
|
|
new DesignerVerb("Create Rating Item", new EventHandler(CreateRatingItem)),};
|
|
|
|
return new DesignerVerbCollection(verbs);
|
|
}
|
|
}
|
|
|
|
private BaseItem GetNewItemContainer()
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (m_QuickAccessToolbarSelected)
|
|
return r.MetroTabStrip.CaptionContainerItem;
|
|
else
|
|
return r.MetroTabStrip.StripContainerItem;
|
|
}
|
|
|
|
protected override void CreateButton(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateButton(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateTextBox(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateTextBox(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateComboBox(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateComboBox(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateLabel(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateLabel(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateColorPicker(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateColorPicker(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateProgressBar(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateProgressBar(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateRatingItem(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateRatingItem(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void CreateSwitch(object sender, EventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
CreateSwitch(GetNewItemContainer());
|
|
}
|
|
}
|
|
|
|
protected override void ComponentChangeComponentAdded(object sender, ComponentEventArgs e)
|
|
{
|
|
if (m_AddingItem)
|
|
{
|
|
m_AddingItem = false;
|
|
IComponentChangeService cc = this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
if (cc != null)
|
|
cc.OnComponentChanging(this.Control, null);
|
|
this.GetNewItemContainer().SubItems.Add(e.Component as BaseItem);
|
|
if (cc != null)
|
|
cc.OnComponentChanged(this.Control, null, null, null);
|
|
m_InsertItemTransaction.Commit();
|
|
m_InsertItemTransaction = null;
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
protected override ArrayList GetAllAssociatedComponents()
|
|
{
|
|
ArrayList c = new ArrayList(base.AssociatedComponents);
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
AddSubItems(r.MetroTabStrip.StripContainerItem, c);
|
|
AddSubItems(r.MetroTabStrip.CaptionContainerItem, c);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
public override System.Collections.ICollection AssociatedComponents
|
|
{
|
|
get
|
|
{
|
|
ArrayList c = new ArrayList(this.BaseAssociatedComponents);
|
|
MetroShell rc = this.Control as MetroShell;
|
|
if (rc != null)
|
|
{
|
|
foreach (BaseItem item in rc.QuickToolbarItems)
|
|
{
|
|
if (!item.SystemItem)
|
|
c.Add(item);
|
|
}
|
|
foreach (BaseItem item in rc.Items)
|
|
{
|
|
if (!item.SystemItem)
|
|
c.Add(item);
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
}
|
|
|
|
#if FRAMEWORK20
|
|
public override void InitializeNewComponent(IDictionary defaultValues)
|
|
{
|
|
base.InitializeNewComponent(defaultValues);
|
|
SetDesignTimeDefaults();
|
|
}
|
|
#else
|
|
public override void OnSetComponentDefaults()
|
|
{
|
|
SetDesignTimeDefaults();
|
|
base.OnSetComponentDefaults();
|
|
}
|
|
#endif
|
|
|
|
private StyleManager CreateStyleManager()
|
|
{
|
|
StyleManager manager = null;
|
|
|
|
IDesignerHost dh = (IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if (dh != null)
|
|
{
|
|
DesignerTransaction trans = dh.CreateTransaction("Create Style Manager");
|
|
try
|
|
{
|
|
manager = dh.CreateComponent(typeof(StyleManager)) as StyleManager;
|
|
}
|
|
finally
|
|
{
|
|
if (!trans.Canceled) trans.Commit();
|
|
}
|
|
}
|
|
|
|
return manager;
|
|
}
|
|
private void SetDesignTimeDefaults()
|
|
{
|
|
CreateMetroTab("&HOME");
|
|
CreateMetroTab("&VIEW");
|
|
StyleManager manager = CreateStyleManager();
|
|
MetroShell c = this.Control as MetroShell;
|
|
if (c != null)
|
|
{
|
|
try
|
|
{
|
|
c.KeyTipsFont = new Font("Tahoma", 7);
|
|
c.TabStripFont = new System.Drawing.Font("Segoe UI", 10.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
|
|
}
|
|
catch { }
|
|
}
|
|
//this.Style = eDotNetBarStyle.StyleManagerControlled;
|
|
this.CanCustomize = true;
|
|
c.Size = new Size(200, 154);
|
|
c.Dock = DockStyle.Top;
|
|
this.CaptionVisible = true;
|
|
|
|
if (manager != null)
|
|
manager.ManagerStyle = eStyle.Metro;
|
|
}
|
|
|
|
protected override BaseItem GetItemContainer()
|
|
{
|
|
MetroShell tab = this.Control as MetroShell;
|
|
if (tab != null)
|
|
return tab.MetroTabStrip.GetBaseItemContainer();
|
|
return null;
|
|
}
|
|
|
|
protected override System.Windows.Forms.Control GetItemContainerControl()
|
|
{
|
|
MetroShell tab = this.Control as MetroShell;
|
|
if (tab != null)
|
|
return tab.MetroTabStrip;
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Support for popup menu closing.
|
|
/// </summary>
|
|
protected override void DesignTimeSelectionChanged(ISelectionService ss)
|
|
{
|
|
if (ss == null)
|
|
return;
|
|
if (this.Control == null || this.Control.IsDisposed)
|
|
return;
|
|
|
|
if (IsApplicationButtonBackstageControl(ss.PrimarySelection))
|
|
return;
|
|
|
|
base.DesignTimeSelectionChanged(ss);
|
|
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r == null) return;
|
|
|
|
BaseItem container = r.MetroTabStrip.StripContainerItem;
|
|
if (container == null) return;
|
|
|
|
if (ss.PrimarySelection is MetroTabItem)
|
|
{
|
|
MetroTabItem item = ss.PrimarySelection as MetroTabItem;
|
|
if (container.SubItems.Contains(item))
|
|
{
|
|
TypeDescriptor.GetProperties(item)["Checked"].SetValue(item, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsApplicationButtonBackstageControl(object primarySelection)
|
|
{
|
|
MetroShell tab = this.Control as MetroShell;
|
|
if (tab == null || !(tab.GetApplicationButton() is MetroAppButton)) return false;
|
|
MetroAppButton appButton = tab.GetApplicationButton() as MetroAppButton;
|
|
if (appButton.BackstageTab == null) return false;
|
|
|
|
SuperTabControl backstageTab = appButton.BackstageTab;
|
|
if (primarySelection is BaseItem)
|
|
{
|
|
BaseItem item = (BaseItem)primarySelection;
|
|
if (backstageTab.Tabs.Contains(item)) return true;
|
|
while (item.Parent != null) item = item.Parent;
|
|
Control parentControl = item.ContainerControl as Control;
|
|
if (parentControl == null) return false;
|
|
return ContainsControl(backstageTab, parentControl);
|
|
}
|
|
else if (primarySelection is Control)
|
|
return ContainsControl(backstageTab, (Control)primarySelection);
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool ContainsControl(Control container, Control childControl)
|
|
{
|
|
Control parent = childControl;
|
|
while (parent != null)
|
|
{
|
|
if (parent == container) return true;
|
|
parent = parent.Parent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggered when some other component on the form is removed.
|
|
/// </summary>
|
|
protected override void OtherComponentRemoving(object sender, ComponentEventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r != null)
|
|
{
|
|
BaseItem container = r.MetroTabStrip.StripContainerItem;
|
|
|
|
if (e.Component is MetroTabItem && container != null && container.SubItems != null &&
|
|
container.SubItems.Contains(((MetroTabItem)e.Component)))
|
|
{
|
|
IDesignerHost dh = this.GetService(typeof(IDesignerHost)) as IDesignerHost;
|
|
if (dh != null)
|
|
dh.DestroyComponent(((MetroTabItem)e.Component).Panel);
|
|
}
|
|
}
|
|
base.OtherComponentRemoving(sender, e);
|
|
}
|
|
|
|
protected override void ComponentRemoved(object sender, ComponentEventArgs e)
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (e.Component is BaseItem && r != null)
|
|
{
|
|
BaseItem item = e.Component as BaseItem;
|
|
if (r.Items.Contains(item))
|
|
r.Items.Remove(item);
|
|
else if (r.QuickToolbarItems.Contains(item))
|
|
r.QuickToolbarItems.Remove(item);
|
|
DestroySubItems(item);
|
|
}
|
|
}
|
|
|
|
protected override bool OnMouseDown(ref Message m, MouseButtons button)
|
|
{
|
|
m_QuickAccessToolbarSelected = false;
|
|
|
|
System.Windows.Forms.Control ctrl = this.GetItemContainerControl();
|
|
MetroTabStrip strip = ctrl as MetroTabStrip;
|
|
|
|
if (strip == null)
|
|
return base.OnMouseDown(ref m, button);
|
|
|
|
Point pos = strip.PointToClient(System.Windows.Forms.Control.MousePosition);
|
|
if (!strip.ClientRectangle.Contains(pos))
|
|
return base.OnMouseDown(ref m, button);
|
|
|
|
if (button == MouseButtons.Right)
|
|
{
|
|
if (strip.QuickToolbarBounds.Contains(pos))
|
|
m_QuickAccessToolbarSelected = true;
|
|
return base.OnMouseDown(ref m, button);
|
|
}
|
|
|
|
bool callBase = true;
|
|
|
|
if (callBase)
|
|
return base.OnMouseDown(ref m, button);
|
|
else
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Design-Time Item Creation
|
|
protected virtual void CreateMetroTab(object sender, EventArgs e)
|
|
{
|
|
CreateMetroTab(string.Empty);
|
|
}
|
|
|
|
private void CreateMetroTab(string text)
|
|
{
|
|
m_QuickAccessToolbarSelected = false;
|
|
IDesignerHost dh = (IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if (dh != null)
|
|
{
|
|
DesignerTransaction trans = dh.CreateTransaction("Creating Metro Tab");
|
|
IComponentChangeService cc = (IComponentChangeService)GetService(typeof(IComponentChangeService));
|
|
MetroShell tab = this.Control as MetroShell;
|
|
try
|
|
{
|
|
m_CreatingItem = true;
|
|
OnSubItemsChanging();
|
|
MetroTabItem item = dh.CreateComponent(typeof(MetroTabItem)) as MetroTabItem;
|
|
if (string.IsNullOrEmpty(text))
|
|
TypeDescriptor.GetProperties(item)["Text"].SetValue(item, item.Name);
|
|
else
|
|
TypeDescriptor.GetProperties(item)["Text"].SetValue(item, text);
|
|
|
|
MetroTabPanel panel = dh.CreateComponent(typeof(MetroTabPanel)) as MetroTabPanel;
|
|
TypeDescriptor.GetProperties(panel)["Dock"].SetValue(panel, DockStyle.Fill);
|
|
//TypeDescriptor.GetProperties(panel)["ColorSchemeStyle"].SetValue(panel, tab.Style);
|
|
tab.SetTabPanelStyle(panel);
|
|
|
|
//panel.Style.BorderBottom = eStyleBorderType.Solid;
|
|
//TypeDescriptor.GetProperties(panel.Style)["BorderBottom"].SetValue(panel.Style, eStyleBorderType.Solid);
|
|
|
|
cc.OnComponentChanging(this.Control, TypeDescriptor.GetProperties(typeof(Control))["Controls"]);
|
|
this.Control.Controls.Add(panel);
|
|
panel.SendToBack();
|
|
cc.OnComponentChanged(this.Control, TypeDescriptor.GetProperties(typeof(Control))["Controls"], null, null);
|
|
|
|
TypeDescriptor.GetProperties(item)["Panel"].SetValue(item, panel);
|
|
|
|
SimpleItemContainer cont = tab.MetroTabStrip.StripContainerItem;
|
|
cc.OnComponentChanging(cont, TypeDescriptor.GetProperties(typeof(BaseItem))["SubItems"]);
|
|
cont.SubItems.Add(item);
|
|
cc.OnComponentChanged(cont, TypeDescriptor.GetProperties(typeof(BaseItem))["SubItems"], null, null);
|
|
if (cont.SubItems.Count == 1)
|
|
TypeDescriptor.GetProperties(item)["Checked"].SetValue(item, true);
|
|
|
|
this.RecalcLayout();
|
|
OnSubItemsChanged();
|
|
}
|
|
catch
|
|
{
|
|
trans.Cancel();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
if (!trans.Canceled)
|
|
trans.Commit();
|
|
m_CreatingItem = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Shadowing
|
|
/// <summary>
|
|
/// Gets or sets whether custom caption and quick access toolbar provided by the control is visible. Default value is false.
|
|
/// This property should be set to true when control is used on MetroForm.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(false), Category("Appearance"), Description("Indicates whether custom caption and quick access toolbar provided by the control is visible.")]
|
|
public bool CaptionVisible
|
|
{
|
|
get
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
return r.CaptionVisible;
|
|
}
|
|
set
|
|
{
|
|
MetroShell r = this.Control as MetroShell;
|
|
if (r.CaptionVisible == value) return;
|
|
r.CaptionVisible = value;
|
|
|
|
if (r.CaptionVisible && (
|
|
r.QuickToolbarItems.Count == 6 && r.QuickToolbarItems[0] is SystemCaptionItem && r.QuickToolbarItems[5] is SystemCaptionItem))
|
|
{
|
|
// Add custom items to the toolbar
|
|
IDesignerHost dh = this.GetService(typeof(IDesignerHost)) as IDesignerHost;
|
|
IComponentChangeService cc = this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
if (dh != null && !dh.Loading && cc != null && dh.TransactionDescription != "Paste components")
|
|
{
|
|
DesignerTransaction trans = dh.CreateTransaction();
|
|
try
|
|
{
|
|
m_CreatingItem = true;
|
|
MetroAppButton sb = dh.CreateComponent(typeof(MetroAppButton)) as MetroAppButton;
|
|
sb.Text = "&File";
|
|
sb.ShowSubItems = false;
|
|
sb.CanCustomize = false;
|
|
sb.AutoExpandOnClick = true;
|
|
cc.OnComponentChanging(r, TypeDescriptor.GetProperties(r)["QuickToolbarItems"]);
|
|
sb.ImageFixedSize = new Size(16, 16);
|
|
r.Items.Insert(0, sb);
|
|
cc.OnComponentChanged(r, TypeDescriptor.GetProperties(r)["QuickToolbarItems"], null, null);
|
|
ButtonItem buttonStart = sb;
|
|
|
|
ButtonItem b = dh.CreateComponent(typeof(ButtonItem)) as ButtonItem;
|
|
b.Text = b.Name;
|
|
cc.OnComponentChanging(r, TypeDescriptor.GetProperties(r)["QuickToolbarItems"]);
|
|
r.QuickToolbarItems.Add(b, 2);
|
|
cc.OnComponentChanged(r, TypeDescriptor.GetProperties(r)["QuickToolbarItems"], null, null);
|
|
|
|
|
|
}
|
|
catch
|
|
{
|
|
trans.Cancel();
|
|
}
|
|
finally
|
|
{
|
|
if (!trans.Canceled) trans.Commit();
|
|
m_CreatingItem = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private ButtonItem CreateFileButton(IDesignerHost dh, string text, Image image)
|
|
{
|
|
ButtonItem button = dh.CreateComponent(typeof(ButtonItem)) as ButtonItem;
|
|
button.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.ImageAndText;
|
|
button.Image = image;
|
|
button.SubItemsExpandWidth = 24;
|
|
button.Text = text;
|
|
|
|
return button;
|
|
}
|
|
|
|
private ButtonItem CreateMRUButton(IDesignerHost dh, string text)
|
|
{
|
|
ButtonItem button = dh.CreateComponent(typeof(ButtonItem)) as ButtonItem;
|
|
button.Text = text;
|
|
|
|
return button;
|
|
}
|
|
|
|
|
|
internal static Bitmap LoadImage(string imageName)
|
|
{
|
|
string imagesFolder = GetImagesFolder();
|
|
if (imagesFolder != "")
|
|
{
|
|
if (File.Exists(imagesFolder + imageName))
|
|
return new Bitmap(imagesFolder + imageName);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static string GetImagesFolder()
|
|
{
|
|
try
|
|
{
|
|
Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.LocalMachine;
|
|
string path = "";
|
|
try
|
|
{
|
|
if (key != null)
|
|
key = key.OpenSubKey("Software\\DevComponents\\DotNetBar");
|
|
if (key != null)
|
|
path = key.GetValue("InstallationFolder", "").ToString();
|
|
}
|
|
finally { if (key != null) key.Close(); }
|
|
|
|
if (path != "")
|
|
{
|
|
if (path.Substring(path.Length - 1, 1) != "\\")
|
|
path += "\\";
|
|
path += "Images\\";
|
|
return path;
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
return "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether control can be customized and items added by end-user using context menu to the quick access toolbar.
|
|
/// Caption of the control must be visible for customization to be enabled. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Browsable(true), Category("Quick Access Toolbar"), Description("Indicates whether control can be customized. Caption must be visible for customization to be fully enabled.")]
|
|
public bool CanCustomize
|
|
{
|
|
get
|
|
{
|
|
MetroShell rc = this.Control as MetroShell;
|
|
return rc.CanCustomize;
|
|
}
|
|
set
|
|
{
|
|
MetroShell rc = this.Control as MetroShell;
|
|
rc.CanCustomize = value;
|
|
|
|
IDesignerHost dh = this.GetService(typeof(IDesignerHost)) as IDesignerHost;
|
|
if (dh != null && !dh.Loading)
|
|
{
|
|
if (value)
|
|
{
|
|
// Make sure that QatCustomizeItem exists
|
|
QatCustomizeItem qatCustom = GetQatCustomizeItem(rc);
|
|
if (qatCustom == null)
|
|
{
|
|
DesignerTransaction dt = dh.CreateTransaction("Creating the QAT");
|
|
try
|
|
{
|
|
// Create QatCustomItem...
|
|
m_CreatingItem = true;
|
|
qatCustom = dh.CreateComponent(typeof(QatCustomizeItem)) as QatCustomizeItem;
|
|
qatCustom.BeginGroup = true;
|
|
IComponentChangeService cc = this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
if (cc != null)
|
|
cc.OnComponentChanging(rc, TypeDescriptor.GetProperties(rc)["QuickToolbarItems"]);
|
|
rc.QuickToolbarItems.Add(qatCustom);
|
|
if (cc != null)
|
|
cc.OnComponentChanged(rc, TypeDescriptor.GetProperties(rc)["QuickToolbarItems"], null, null);
|
|
m_CreatingItem = false;
|
|
this.RecalcLayout();
|
|
}
|
|
catch
|
|
{
|
|
dt.Cancel();
|
|
}
|
|
finally
|
|
{
|
|
if (!dt.Canceled) dt.Commit();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
QatCustomizeItem qatCustom = GetQatCustomizeItem(rc);
|
|
if (qatCustom != null)
|
|
{
|
|
DesignerTransaction dt = dh.CreateTransaction("Removing the QAT");
|
|
try
|
|
{
|
|
IComponentChangeService cc = this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
if (cc != null)
|
|
cc.OnComponentChanging(rc, TypeDescriptor.GetProperties(rc)["QuickToolbarItems"]);
|
|
rc.QuickToolbarItems.Remove(qatCustom);
|
|
if (cc != null)
|
|
cc.OnComponentChanged(rc, TypeDescriptor.GetProperties(rc)["QuickToolbarItems"], null, null);
|
|
dh.DestroyComponent(qatCustom);
|
|
}
|
|
catch
|
|
{
|
|
dt.Cancel();
|
|
}
|
|
finally
|
|
{
|
|
if (!dt.Canceled) dt.Commit();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private QatCustomizeItem GetQatCustomizeItem(MetroShell rc)
|
|
{
|
|
QatCustomizeItem qatCustom = null;
|
|
// Remove QatCustomizeItem if it exists
|
|
foreach (BaseItem item in rc.QuickToolbarItems)
|
|
{
|
|
if (item is QatCustomizeItem)
|
|
{
|
|
qatCustom = item as QatCustomizeItem;
|
|
break;
|
|
}
|
|
}
|
|
return qatCustom;
|
|
}
|
|
|
|
protected override void PreFilterProperties(IDictionary properties)
|
|
{
|
|
base.PreFilterProperties(properties);
|
|
|
|
properties["CaptionVisible"] = TypeDescriptor.CreateProperty(typeof(MetroShellDesigner), (PropertyDescriptor)properties["CaptionVisible"], new Attribute[]
|
|
{
|
|
new DefaultValueAttribute(false),
|
|
new BrowsableAttribute(true),
|
|
new CategoryAttribute("Appearance"),
|
|
new DescriptionAttribute("Indicates whether custom caption and quick access toolbar provided by the control is visible.")});
|
|
|
|
properties["CanCustomize"] = TypeDescriptor.CreateProperty(typeof(MetroShellDesigner), (PropertyDescriptor)properties["CanCustomize"], new Attribute[]
|
|
{
|
|
new DefaultValueAttribute(true),
|
|
new BrowsableAttribute(true),
|
|
new CategoryAttribute("Quick Access Toolbar"),
|
|
new DescriptionAttribute("Indicates whether control can be customized. Caption must be visible for customization to be fully enabled")});
|
|
|
|
//DesignTime.RemoveProperties(properties, new string[] { "AccessibleDescription"
|
|
// ,"AccessibleName","AccessibleRole","AutoScroll", "AutoScrollMargin", "AutoScrollMinSize",
|
|
// "BackColor", "BackgroundImage", "BackgroundImageLayout", "DisplayRectangle", "ForeColor",
|
|
// "MaximumSize", "MinimumSize", "Site","Text","UseWaitCursor", "Cursor","ContextMenuStrip"});
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|