1163 lines
42 KiB
C#
1163 lines
42 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Xml;
|
|
using DevComponents.AdvTree;
|
|
using DevComponents.DotNetBar.Primitives;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
|
|
namespace DevComponents.DotNetBar.Controls
|
|
{
|
|
/// <summary>
|
|
/// Represents Toolbox control to create.
|
|
/// </summary>
|
|
[ToolboxBitmap(typeof(ToolboxControl), "Controls.ToolboxControl.bmp"), ToolboxItem(true), Designer("DevComponents.DotNetBar.Design.ToolboxControlDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf"), System.Runtime.InteropServices.ComVisible(false)]
|
|
public class ToolboxControl : ContainerControl
|
|
{
|
|
#region Implementation
|
|
|
|
private ItemPanel _ItemPanel = null;
|
|
private Bar _TitleBar = null;
|
|
private TextBoxX _SearchBox = null;
|
|
private Bar _MenuBar = null;
|
|
|
|
public ToolboxControl()
|
|
{
|
|
_BackgroundStyle.StyleChanged += new EventHandler(this.VisualPropertyChanged);
|
|
_BackgroundStyle.Class = ElementStyleClassKeys.ToolboxControlKey;
|
|
this.Padding = new System.Windows.Forms.Padding(2);
|
|
|
|
this.SetStyle(ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque |
|
|
ControlStyles.ResizeRedraw | ControlStyles.DoubleBuffer | ControlStyles.Selectable, true);
|
|
|
|
_ItemPanel = CreateItemsPanel();
|
|
this.Controls.Add(_ItemPanel);
|
|
|
|
_MenuBar = CreateMenuBar();
|
|
this.Controls.Add(_MenuBar);
|
|
|
|
_SearchBox = CreateSearchBox();
|
|
this.Controls.Add(_SearchBox);
|
|
|
|
_TitleBar = CreateTitleBar();
|
|
this.Controls.Add(_TitleBar);
|
|
|
|
_SelectedItems = new CustomCollection<ToolboxItem>();
|
|
|
|
_Groups.CollectionChanged += GroupsCollectionChanged;
|
|
}
|
|
|
|
private void GroupsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
if (e.Action == NotifyCollectionChangedAction.Add)
|
|
{
|
|
int index = e.NewStartingIndex;
|
|
foreach (ToolboxGroup group in e.NewItems)
|
|
{
|
|
_ItemPanel.Items.Insert(index, group);
|
|
index++;
|
|
}
|
|
}
|
|
else if (e.Action == NotifyCollectionChangedAction.Remove)
|
|
{
|
|
foreach (ToolboxGroup group in e.OldItems)
|
|
_ItemPanel.Items.Remove(group);
|
|
}
|
|
else if (e.Action == NotifyCollectionChangedAction.Reset)
|
|
{
|
|
_ItemPanel.Items.Clear();
|
|
if (e.NewItems != null)
|
|
{
|
|
foreach (ToolboxGroup group in e.NewItems)
|
|
_ItemPanel.Items.Add(group);
|
|
}
|
|
}
|
|
else if (e.Action == NotifyCollectionChangedAction.Replace)
|
|
{
|
|
_ItemPanel.Items.Remove(e.NewStartingIndex);
|
|
_ItemPanel.Items.Insert(e.NewStartingIndex, (BaseItem)e.NewItems[0]);
|
|
}
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
private ButtonItem _MenuButton = null;
|
|
private Bar CreateMenuBar()
|
|
{
|
|
Bar menuBar = new Bar();
|
|
menuBar.Name = "menuBar";
|
|
menuBar.AntiAlias = true;
|
|
menuBar.BackColor = System.Drawing.Color.Transparent;
|
|
menuBar.Dock = System.Windows.Forms.DockStyle.Top;
|
|
menuBar.Font = new System.Drawing.Font("Segoe UI", 9F);
|
|
menuBar.IsMaximized = false;
|
|
menuBar.Location = new System.Drawing.Point(6, 93);
|
|
menuBar.PaddingBottom = 4;
|
|
menuBar.PaddingTop = 4;
|
|
menuBar.Size = new System.Drawing.Size(365, 61);
|
|
menuBar.Stretch = true;
|
|
menuBar.Style = DevComponents.DotNetBar.eDotNetBarStyle.StyleManagerControlled;
|
|
menuBar.TabIndex = 2;
|
|
menuBar.TabStop = false;
|
|
|
|
ButtonItem menuButton = new ButtonItem("menuButton");
|
|
menuButton.AutoExpandOnClick = true;
|
|
menuButton.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.ImageAndText;
|
|
menuButton.ImagePaddingHorizontal = 30;
|
|
menuButton.ImagePaddingVertical = 12;
|
|
menuButton.ImagePosition = DevComponents.DotNetBar.eImagePosition.Right;
|
|
menuButton.PopupSide = DevComponents.DotNetBar.ePopupSide.Right;
|
|
menuButton.Text = "Menu";
|
|
menuButton.SubItems.Add(new ButtonItem()); // Just placeholder
|
|
menuButton.PopupOpen += MenuButtonPopupOpen;
|
|
menuButton.PopupClose += MenuButtonPopupClose;
|
|
_MenuButton = menuButton;
|
|
|
|
menuBar.Items.AddRange(new DevComponents.DotNetBar.BaseItem[] {
|
|
menuButton});
|
|
|
|
return menuBar;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the Bar control used as menu bar.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public Bar MenuBar
|
|
{
|
|
get { return _MenuBar; }
|
|
}
|
|
|
|
private void MenuButtonPopupClose(object sender, EventArgs e)
|
|
{
|
|
ClearAndDisposeMenuItems();
|
|
_MenuButton.SubItems.Add(new ButtonItem());
|
|
}
|
|
|
|
private void ClearAndDisposeMenuItems()
|
|
{
|
|
foreach (BaseItem item in _MenuButton.SubItems)
|
|
{
|
|
item.Dispose();
|
|
}
|
|
_MenuButton.SubItems.Clear();
|
|
}
|
|
|
|
private void MenuButtonPopupOpen(object sender, PopupOpenEventArgs e)
|
|
{
|
|
ClearAndDisposeMenuItems();
|
|
foreach (BaseItem item in this.Groups)
|
|
{
|
|
ToolboxGroup group = item as ToolboxGroup;
|
|
if (group != null)
|
|
{
|
|
ButtonItem menuItem = new ButtonItem();
|
|
menuItem.Text = group.TitleText;
|
|
menuItem.Click += MenuItemClick;
|
|
menuItem.Tag = group;
|
|
_MenuButton.SubItems.Add(menuItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MenuItemClick(object sender, EventArgs e)
|
|
{
|
|
ToolboxGroup group = ((BaseItem)sender).Tag as ToolboxGroup;
|
|
if (group != null)
|
|
group.Expanded = true;
|
|
}
|
|
|
|
private string _SearchBoxWatermark = "Enter text to search...";
|
|
|
|
/// <summary>
|
|
/// Indicates the search-box watermark text.
|
|
/// </summary>
|
|
[DefaultValue("Enter text to search..."), Category("Appearance"), Description("Indicates the search-box watermark text."), Localizable(true)]
|
|
public string SearchBoxWatermark
|
|
{
|
|
get { return _SearchBoxWatermark; }
|
|
set
|
|
{
|
|
if (_SearchBoxWatermark != value)
|
|
{
|
|
string oldValue = value;
|
|
_SearchBoxWatermark = value;
|
|
OnSearchBoxWatermarkChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnSearchBoxWatermarkChanged(string oldValue, string newValue)
|
|
{
|
|
_SearchBox.WatermarkText = newValue;
|
|
}
|
|
|
|
private TextBoxX CreateSearchBox()
|
|
{
|
|
TextBoxX searchBox = new TextBoxX();
|
|
searchBox.Name = "searchBox";
|
|
searchBox.Border.Class = "TextBoxBorder";
|
|
searchBox.Border.CornerType = DevComponents.DotNetBar.eCornerType.Square;
|
|
searchBox.ButtonCustom.Symbol = "";
|
|
searchBox.ButtonCustom.Visible = true;
|
|
searchBox.ButtonCustomClick += SearchBoxButtonCustomClick;
|
|
searchBox.Dock = System.Windows.Forms.DockStyle.Top;
|
|
searchBox.Location = new System.Drawing.Point(6, 55);
|
|
searchBox.PreventEnterBeep = true;
|
|
searchBox.Size = new System.Drawing.Size(365, 38);
|
|
searchBox.TabIndex = 0;
|
|
searchBox.WatermarkText = "Enter text to search...";
|
|
searchBox.TextChanged += SearchBoxTextChanged;
|
|
searchBox.WordWrap = false;
|
|
|
|
return searchBox;
|
|
}
|
|
/// <summary>
|
|
/// Returns reference to internal search text-box.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public TextBoxX SearchBoxTextBox
|
|
{
|
|
get { return _SearchBox; }
|
|
}
|
|
|
|
void SearchBoxButtonCustomClick(object sender, EventArgs e)
|
|
{
|
|
_SearchBox.Text = string.Empty;
|
|
}
|
|
|
|
private void SearchBoxTextChanged(object sender, EventArgs e)
|
|
{
|
|
if (string.IsNullOrEmpty(_SearchBox.Text))
|
|
_SearchBox.ButtonCustom.Symbol = "\uf002";
|
|
else
|
|
_SearchBox.ButtonCustom.Symbol = "\uf00d";
|
|
Search(_SearchBox.Text);
|
|
}
|
|
|
|
private ButtonItem _ExpandButton = null;
|
|
private LabelItem _TitleLabel = null;
|
|
private Bar CreateTitleBar()
|
|
{
|
|
Bar titleBar = new Bar();
|
|
titleBar.Name = "titleBar";
|
|
titleBar.AntiAlias = true;
|
|
titleBar.BackColor = System.Drawing.Color.Transparent;
|
|
titleBar.Dock = System.Windows.Forms.DockStyle.Top;
|
|
titleBar.IsMaximized = false;
|
|
titleBar.Location = new System.Drawing.Point(6, 6);
|
|
titleBar.PaddingBottom = 4;
|
|
titleBar.PaddingTop = 4;
|
|
titleBar.Size = new System.Drawing.Size(365, 49);
|
|
titleBar.Stretch = true;
|
|
titleBar.Style = DevComponents.DotNetBar.eDotNetBarStyle.StyleManagerControlled;
|
|
titleBar.TabIndex = 0;
|
|
titleBar.TabStop = false;
|
|
|
|
LabelItem toolboxLabel = new LabelItem("toolboxLabel");
|
|
toolboxLabel.Text = "Toolbox";
|
|
_TitleLabel = toolboxLabel;
|
|
|
|
ButtonItem expandButton = new ButtonItem("expandButton");
|
|
expandButton.ItemAlignment = DevComponents.DotNetBar.eItemAlignment.Far;
|
|
expandButton.Symbol = "\uf053";
|
|
expandButton.SymbolSize = 10F;
|
|
expandButton.Click += ExpandButtonClick;
|
|
_ExpandButton = expandButton;
|
|
|
|
titleBar.Items.AddRange(new DevComponents.DotNetBar.BaseItem[] {
|
|
toolboxLabel,
|
|
expandButton});
|
|
|
|
return titleBar;
|
|
}
|
|
|
|
private string _TitleText = "Toolbox";
|
|
|
|
/// <summary>
|
|
/// Indicates the title label text.
|
|
/// </summary>
|
|
[DefaultValue("Toolbox"), Category("Appearance"), Description("Indicates the title label text."), Localizable(true)]
|
|
public string TitleText
|
|
{
|
|
get { return _TitleText; }
|
|
set
|
|
{
|
|
if (_TitleText != value)
|
|
{
|
|
string oldValue = value;
|
|
_TitleText = value;
|
|
OnTitleTextChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnTitleTextChanged(string oldValue, string newValue)
|
|
{
|
|
_TitleLabel.Text = newValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the Bar control used as title bar.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public Bar TitleBar
|
|
{
|
|
get { return _TitleBar; }
|
|
}
|
|
|
|
private void ExpandButtonClick(object sender, EventArgs e)
|
|
{
|
|
this.Expanded = !this.Expanded;
|
|
}
|
|
|
|
private ItemPanel CreateItemsPanel()
|
|
{
|
|
ItemPanel itemPanel = new ItemPanel();
|
|
itemPanel.Dock = DockStyle.Fill;
|
|
itemPanel.LayoutOrientation = eOrientation.Vertical;
|
|
itemPanel.AutoScroll = true;
|
|
#if !TRIAL
|
|
itemPanel.LicenseKey = "F962CEC7-CD8F-4911-A9E9-CAB39962FC1F";
|
|
#endif
|
|
itemPanel.ItemClick += ItemPanelItemClick;
|
|
itemPanel.DragDropSupport = true;
|
|
itemPanel.EnableDragDrop = true;
|
|
itemPanel.UseNativeDragDrop = true;
|
|
itemPanel.AllowDrop = true;
|
|
itemPanel.BeforeItemDrag += ItemsPanelBeforeItemDrag;
|
|
itemPanel.GetBaseItemContainer().SubItemsChanged += ItemsChanged;
|
|
itemPanel.DragDropAllowedContainerTypes.Add(typeof(ToolboxGroup));
|
|
return itemPanel;
|
|
}
|
|
|
|
private void ItemsChanged(object sender, CollectionChangeEventArgs e)
|
|
{
|
|
if (!IsUpdateSuspended)
|
|
this.RecalcLayout();
|
|
}
|
|
|
|
private int _UpdateSuspended = 0;
|
|
/// <summary>
|
|
/// Disables any redrawing of the tree control. To maintain performance while items
|
|
/// are added one at a time to the control, call the BeginUpdate method. The BeginUpdate
|
|
/// method prevents the control from painting until the
|
|
/// <see cref="EndUpdate">EndUpdate</see> method is called.
|
|
/// </summary>
|
|
public void BeginUpdate()
|
|
{
|
|
_UpdateSuspended++;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enables the redrawing of the tree view. To maintain performance while items are
|
|
/// added one at a time to the control, call the <see cref="BeginUpdate">BeginUpdate</see>
|
|
/// method. The BeginUpdate method prevents the control from painting until the EndUpdate
|
|
/// method is called.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Call to EndUpdate will enable the layout and painting in tree control. If there
|
|
/// are any pending layouts the EndUpdate will call
|
|
/// <see cref="RecalcLayout">RecalcLayout</see> method to perform the layout and it will
|
|
/// repaint the control.
|
|
/// </remarks>
|
|
public void EndUpdate()
|
|
{
|
|
EndUpdate(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enables the redrawing of the tree view. To maintain performance while items are
|
|
/// added one at a time to the control, call the <see cref="BeginUpdate">BeginUpdate</see>
|
|
/// method. The BeginUpdate method prevents the control from painting until the EndUpdate
|
|
/// method is called.
|
|
/// </summary>
|
|
/// <param name="performLayoutAndRefresh">Gets or sets whether layout and refresh of control is performed if there are no other update blocks pending.</param>
|
|
public void EndUpdate(bool performLayoutAndRefresh)
|
|
{
|
|
if (_UpdateSuspended > 0) _UpdateSuspended--;
|
|
if (_UpdateSuspended == 0 && performLayoutAndRefresh)
|
|
{
|
|
this.RecalcLayout();
|
|
this.Invalidate(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether layout is suspended for tree control. Layout is suspended after
|
|
/// call to <see cref="BeginUpdate">BeginUpdate</see> method and it is resumed after the
|
|
/// call to <see cref="EndUpdate">EndUpdate</see> method.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public bool IsUpdateSuspended
|
|
{
|
|
get { return (_UpdateSuspended > 0); }
|
|
}
|
|
|
|
public void RecalcLayout()
|
|
{
|
|
_ItemPanel.RecalcLayout();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns reference to internal item panel used to display the toolbox items and groups.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public ItemPanel ItemsPanel
|
|
{
|
|
get { return _ItemPanel; }
|
|
}
|
|
|
|
private void ItemsPanelBeforeItemDrag(object sender, CancelEventArgs e)
|
|
{
|
|
OnBeforeItemDrag(sender, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns collection of toolbox control groups, collection of ToolboxGroup items.
|
|
/// </summary>
|
|
//[DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
|
|
//[System.ComponentModel.Editor("DevComponents.DotNetBar.Design.ToolboxControlGroupsEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
|
|
//public SubItemsCollection Groups
|
|
//{
|
|
// get { return _ItemPanel.GetBaseItemContainer().SubItems; }
|
|
//}
|
|
|
|
private CustomCollection<ToolboxGroup> _Groups = new CustomCollection<ToolboxGroup>();
|
|
/// <summary>
|
|
/// Gets the list of items displayed in list box.
|
|
/// </summary>
|
|
[Category("Appearance"), Description("List of items displayed in list box."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), MergableProperty(false), Localizable(false)]
|
|
public CustomCollection<ToolboxGroup> Groups
|
|
{
|
|
get { return _Groups; }
|
|
}
|
|
|
|
private bool _ExpandSingleGroupOnly = true;
|
|
|
|
/// <summary>
|
|
/// Indicates whether single group only is expanded at a time. When new group is expanded currently expanded group is collapsed.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Behavior"),
|
|
Description("Indicates whether single toolbox group only is expanded at a time")]
|
|
public bool ExpandSingleGroupOnly
|
|
{
|
|
get { return _ExpandSingleGroupOnly; }
|
|
set { _ExpandSingleGroupOnly = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs after Expanded property value has changed
|
|
/// </summary>
|
|
[Description("Occurs after Expanded property value has changed")]
|
|
public event EventHandler ExpandedChanged;
|
|
|
|
/// <summary>
|
|
/// Raises ExpandedChanged event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnExpandedChanged(EventArgs e)
|
|
{
|
|
EventHandler handler = ExpandedChanged;
|
|
if (handler != null)
|
|
handler(this, e);
|
|
}
|
|
|
|
private bool _Expanded = true;
|
|
/// <summary>
|
|
/// Gets or sets whether control is expanded and shows items in full size with image and text. When collapsed
|
|
/// control will show only images for toolbox items and will hide other UI elements to minimize its size.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance"), Description("Indicates whether control is expanded and shows items in full size with images and text")]
|
|
public bool Expanded
|
|
{
|
|
get { return _Expanded; }
|
|
set
|
|
{
|
|
if (_Expanded != value)
|
|
{
|
|
_Expanded = value;
|
|
OnExpandedChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Color _CollapsedSeparatorColor = Color.Gray;
|
|
|
|
/// <summary>
|
|
/// Indicates the collapsed toolbox separator color, the line drawn between the toolbox and menu/expand buttons above.
|
|
/// </summary>
|
|
[Category("Appearance"), Description("Indicates the collapsed toolbox separator color, the line drawn between the toolbox and menu/expand buttons above.")]
|
|
public Color CollapsedSeparatorColor
|
|
{
|
|
get { return _CollapsedSeparatorColor; }
|
|
set
|
|
{
|
|
_CollapsedSeparatorColor = value;
|
|
if (!_Expanded)
|
|
{
|
|
_MenuBar.Invalidate();
|
|
_MenuBar.BorderColors = new Color[] { Color.Empty, Color.Empty, Color.Empty, _CollapsedSeparatorColor };
|
|
}
|
|
}
|
|
}
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeCollapsedSeparatorColor()
|
|
{
|
|
return _CollapsedSeparatorColor != Color.Gray;
|
|
}
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetCollapsedSeparatorColor()
|
|
{
|
|
CollapsedSeparatorColor = Color.Gray;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the expanded width of the control. This property value is valid after control has been collapsed.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public int ExpandedWidth
|
|
{
|
|
get { return _ExpandedWidth; }
|
|
set { _ExpandedWidth = value; }
|
|
}
|
|
|
|
private List<BaseItemAutoSizeBag> _CollapsedList = new List<BaseItemAutoSizeBag>();
|
|
private int _ExpandedWidth = 0;
|
|
protected virtual void OnExpandedChanged()
|
|
{
|
|
OnExpandedChanged(EventArgs.Empty);
|
|
if (!_Expanded)
|
|
{
|
|
_ExpandedWidth = this.Width;
|
|
_ExpandButton.Symbol = "\uf054";
|
|
_MenuButton.ButtonStyle = eButtonStyle.Default;
|
|
_TitleLabel.Visible = false;
|
|
|
|
_MenuButton.Symbol = "\ue037";
|
|
_MenuButton.SymbolSet = eSymbolSet.Material;
|
|
_MenuButton.SymbolSize = 10f;
|
|
_MenuButton.ButtonStyle = eButtonStyle.Default;
|
|
_MenuButton.ImagePaddingHorizontal = 8;
|
|
_MenuButton.ImagePaddingVertical = 6;
|
|
_MenuButton.ImagePosition = eImagePosition.Left;
|
|
_MenuButton.ShowSubItems = false;
|
|
_MenuBar.BorderColors = new Color[] { Color.Empty, Color.Empty, Color.Empty, _CollapsedSeparatorColor };
|
|
|
|
_SearchBox.Visible = false;
|
|
|
|
// Collapse everything
|
|
foreach (BaseItem item in _ItemPanel.Items)
|
|
{
|
|
if (!(item is ToolboxGroup)) continue;
|
|
|
|
ToolboxGroup group = (ToolboxGroup)item;
|
|
BaseItemAutoSizeBag bagGroup = AutoSizeBagFactory.CreateAutoSizeBag(group);
|
|
bagGroup.RecordSetting(item);
|
|
_CollapsedList.Add(bagGroup);
|
|
group.TitleVisible = false;
|
|
group.LayoutOrientation = eOrientation.Vertical;
|
|
group.MultiLine = false;
|
|
foreach (BaseItem ti in group.SubItems)
|
|
{
|
|
ButtonItem tbItem = ti as ButtonItem;
|
|
if (tbItem != null)
|
|
{
|
|
BaseItemAutoSizeBag bagItem = AutoSizeBagFactory.CreateAutoSizeBag(tbItem);
|
|
bagItem.RecordSetting(tbItem);
|
|
_CollapsedList.Add(bagItem);
|
|
tbItem.ButtonStyle = eButtonStyle.Default;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Expand everything
|
|
_ExpandButton.Symbol = "\uf053";
|
|
_MenuBar.BorderColors = new Color[0];
|
|
_MenuButton.ButtonStyle = eButtonStyle.ImageAndText;
|
|
_TitleLabel.Visible = true;
|
|
|
|
_MenuButton.Symbol = string.Empty;
|
|
_MenuButton.ButtonStyle = eButtonStyle.Default;
|
|
_MenuButton.ImagePaddingHorizontal = 30;
|
|
_MenuButton.ImagePaddingVertical = 12;
|
|
_MenuButton.ImagePosition = DevComponents.DotNetBar.eImagePosition.Right;
|
|
_MenuButton.ShowSubItems = true;
|
|
_MenuBar.BorderColors = new Color[0];
|
|
|
|
_SearchBox.Visible = true;
|
|
|
|
BaseItemAutoSizeBag[] bagItems = new BaseItemAutoSizeBag[_CollapsedList.Count];
|
|
_CollapsedList.CopyTo(bagItems);
|
|
foreach (BaseItemAutoSizeBag ab in bagItems)
|
|
ab.RestoreSettings();
|
|
|
|
_CollapsedList.Clear();
|
|
|
|
this.Width = _ExpandedWidth;
|
|
}
|
|
|
|
_ItemPanel.RecalcLayout();
|
|
|
|
if (_Expanded)
|
|
{
|
|
_MenuButton.FixedSize = Size.Empty;
|
|
_ExpandButton.FixedSize = Size.Empty;
|
|
}
|
|
else
|
|
{
|
|
int itemsWidth = UpdateCollapsedWidth();
|
|
_MenuButton.FixedSize = new Size(itemsWidth - Dpi.Width2, _MenuButton.HeightInternal);
|
|
_ExpandButton.FixedSize = new Size(itemsWidth - Dpi.Width2, _ExpandButton.HeightInternal);
|
|
|
|
}
|
|
|
|
_MenuBar.RecalcLayout();
|
|
_TitleBar.RecalcLayout();
|
|
}
|
|
|
|
private int UpdateCollapsedWidth()
|
|
{
|
|
int itemsWidth = GetItemsWidth();
|
|
int width = itemsWidth +
|
|
ElementStyleLayout.LeftWhiteSpace(_ItemPanel.BackgroundStyle, eSpacePart.Margin | eSpacePart.Padding) +
|
|
ElementStyleLayout.RightWhiteSpace(_ItemPanel.BackgroundStyle, eSpacePart.Padding | eSpacePart.Margin) + this.Padding.Horizontal;
|
|
_MenuButton.FixedSize = new Size(itemsWidth - Dpi.Width2, _MenuButton.HeightInternal);
|
|
_ExpandButton.FixedSize = new Size(itemsWidth - Dpi.Width2, _ExpandButton.HeightInternal);
|
|
this.Width = width;
|
|
return itemsWidth;
|
|
}
|
|
|
|
private int GetItemsWidth()
|
|
{
|
|
int width = 0;
|
|
bool scrollBar = false;
|
|
foreach (BaseItem item in _ItemPanel.Items)
|
|
{
|
|
if (item is ToolboxGroup)
|
|
{
|
|
foreach (BaseItem ti in item.SubItems)
|
|
{
|
|
if (ti is ButtonItem && ti.WidthInternal > width)
|
|
width = ti.WidthInternal;
|
|
}
|
|
}
|
|
if (item.Bounds.Bottom > this.ClientRectangle.Height) scrollBar = true;
|
|
}
|
|
|
|
if (scrollBar)
|
|
width += SystemInformation.VerticalScrollBarWidth;
|
|
|
|
if (width == 0)
|
|
width = 32;
|
|
|
|
return width;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs after toolbox group is expanded
|
|
/// </summary>
|
|
[Description("Occurs after toolbox group is expanded")]
|
|
public event EventHandler ToolboxGroupExpanded;
|
|
|
|
/// <summary>
|
|
/// Raises RemovingToken event.
|
|
/// </summary>
|
|
/// <param name="sender">Provides source of the event.</param>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnToolboxGroupExpanded(object sender, EventArgs e)
|
|
{
|
|
EventHandler handler = ToolboxGroupExpanded;
|
|
if (handler != null)
|
|
handler(sender, e);
|
|
}
|
|
internal void InvokeToolboxGroupExpanded(ToolboxGroup toolboxGroup)
|
|
{
|
|
if (!_Expanded)
|
|
{
|
|
// Adjust width of collapsed control if needed
|
|
UpdateCollapsedWidth();
|
|
}
|
|
OnToolboxGroupExpanded(toolboxGroup, EventArgs.Empty);
|
|
}
|
|
|
|
private eToolboxItemSelectionMode _SelectionMode = eToolboxItemSelectionMode.Single;
|
|
|
|
/// <summary>
|
|
/// Indicates toolbox item selection mode.
|
|
/// </summary>
|
|
[DefaultValue(eToolboxItemSelectionMode.Single), Category("Behavior"), Description("Indicates toolbox item selection mode.")]
|
|
public eToolboxItemSelectionMode SelectionMode
|
|
{
|
|
get { return _SelectionMode; }
|
|
set
|
|
{
|
|
if (_SelectionMode != value)
|
|
{
|
|
_SelectionMode = value;
|
|
OnSelectionModeChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnSelectionModeChanged()
|
|
{
|
|
|
|
}
|
|
|
|
void ItemPanelItemClick(object sender, EventArgs e)
|
|
{
|
|
if (_SelectionMode == eToolboxItemSelectionMode.NoSelection) return;
|
|
|
|
ToolboxItem item = sender as ToolboxItem;
|
|
if (item == null || item.AutoCheckOnClick || item.Checked && (Control.ModifierKeys & Keys.Control) == Keys.None) return;
|
|
|
|
if (item.Checked)
|
|
SetSelectedItem(item, false);
|
|
else
|
|
SetSelectedItem(item, true);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects or deselects an item.
|
|
/// </summary>
|
|
/// <param name="item">Item to select or deselect.</param>
|
|
/// <param name="isSelected">Selection state.</param>
|
|
public void SetSelectedItem(ToolboxItem item, bool isSelected)
|
|
{
|
|
if (_SelectionMode == eToolboxItemSelectionMode.Single)
|
|
{
|
|
if (_SelectedItem == item && !isSelected)
|
|
this.SelectedItem = null;
|
|
else if (isSelected)
|
|
this.SelectedItem = item;
|
|
}
|
|
else if (item.Checked != isSelected)
|
|
{
|
|
item.Checked = isSelected;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs after selected item has changed.
|
|
/// </summary>
|
|
[Description("Occurs after selected item has changed. ")]
|
|
public event EventHandler SelectedItemChanged;
|
|
|
|
/// <summary>
|
|
/// Raises RemovingToken event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnSelectedItemChanged(EventArgs e)
|
|
{
|
|
EventHandler handler = SelectedItemChanged;
|
|
if (handler != null)
|
|
handler(this, e);
|
|
}
|
|
|
|
private CustomCollection<ToolboxItem> _SelectedItems;
|
|
/// <summary>
|
|
/// Gets a collection containing the currently selected items in the ToolboxControl. Do not modify items in this collection. To select or deselect list items while in multi-selection mode use SetSelected method.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public CustomCollection<ToolboxItem> SelectedItems
|
|
{
|
|
get
|
|
{
|
|
return _SelectedItems;
|
|
}
|
|
}
|
|
|
|
private ToolboxItem _SelectedItem;
|
|
/// <summary>
|
|
/// Gets or sets selected item in toolbox control.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public ToolboxItem SelectedItem
|
|
{
|
|
get { return _SelectedItem; }
|
|
set
|
|
{
|
|
if (_SelectedItem != value)
|
|
{
|
|
ToolboxItem oldValue = _SelectedItem;
|
|
_SelectedItem = value;
|
|
OnSelectedItemChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _IgnoreCheckedChange = false;
|
|
protected virtual void OnSelectedItemChanged(ToolboxItem oldValue, ToolboxItem newValue)
|
|
{
|
|
if (oldValue != null)
|
|
{
|
|
if (newValue != null) _IgnoreCheckedChange = true;
|
|
oldValue.Checked = false;
|
|
_IgnoreCheckedChange = false;
|
|
}
|
|
if (newValue != null) newValue.Checked = true;
|
|
}
|
|
|
|
internal void ToolboxItemCheckedChanged(ToolboxItem toolboxItem)
|
|
{
|
|
if (_SelectionMode == eToolboxItemSelectionMode.Single)
|
|
{
|
|
_SelectedItems.Clear();
|
|
if (toolboxItem.Checked)
|
|
_SelectedItem = toolboxItem;
|
|
}
|
|
else
|
|
{
|
|
if (!toolboxItem.Checked && _SelectedItems.Contains(toolboxItem))
|
|
_SelectedItems.Remove(toolboxItem);
|
|
else if (toolboxItem.Checked)
|
|
_SelectedItems.Add(toolboxItem);
|
|
}
|
|
if (!_IgnoreCheckedChange)
|
|
OnSelectedItemChanged(EventArgs.Empty);
|
|
}
|
|
|
|
private bool _TitleVisible = true;
|
|
|
|
/// <summary>
|
|
/// Indicates whether title bar of the control is visible, default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance"), Description("Indicates whether title bar of the control is visible.")]
|
|
public bool TitleVisible
|
|
{
|
|
get { return _TitleVisible; }
|
|
set
|
|
{
|
|
if (_TitleVisible != value)
|
|
{
|
|
bool oldValue = value;
|
|
_TitleVisible = value;
|
|
OnTitleVisibleChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnTitleVisibleChanged(bool oldValue, bool newValue)
|
|
{
|
|
_TitleBar.Visible = newValue;
|
|
}
|
|
|
|
private bool _MenuVisible = true;
|
|
|
|
/// <summary>
|
|
/// Indicates whether menu bar of the control is visible, default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance"), Description("Indicates whether menu bar of the control is visible")]
|
|
public bool MenuVisible
|
|
{
|
|
get { return _MenuVisible; }
|
|
set
|
|
{
|
|
if (_MenuVisible != value)
|
|
{
|
|
bool oldValue = value;
|
|
_MenuVisible = value;
|
|
OnMenuVisibleChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnMenuVisibleChanged(bool oldValue, bool newValue)
|
|
{
|
|
_MenuBar.Visible = newValue;
|
|
}
|
|
|
|
private bool _SearchBoxVisible = true;
|
|
/// <summary>
|
|
/// Gets or set whether search text-box which allows searching for the toolbox items is visible. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance"), Description("Indicates whether search text-box which allows searching for the toolbox items is visible.")]
|
|
public bool SearchBoxVisible
|
|
{
|
|
get { return _SearchBoxVisible; }
|
|
set
|
|
{
|
|
if (_SearchBoxVisible != value)
|
|
{
|
|
_SearchBoxVisible = value;
|
|
OnSearchBoxVisibleChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _SearchForEachWord = true;
|
|
|
|
/// <summary>
|
|
/// Indicates whether search text when entered is split into separate words and items returned that match any of the words entered.
|
|
/// </summary>
|
|
[Category("Behavior"), DefaultValue(true), Description("Indicates whether search text when entered is split into separate words and items returned that match any of the words entered.")]
|
|
public bool SearchForEachWord
|
|
{
|
|
get { return _SearchForEachWord; }
|
|
set
|
|
{
|
|
if (_SearchForEachWord != value)
|
|
{
|
|
bool oldValue = value;
|
|
_SearchForEachWord = value;
|
|
OnSearchForEachWordChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnSearchForEachWordChanged(bool oldValue, bool newValue)
|
|
{
|
|
|
|
}
|
|
|
|
private void OnSearchBoxVisibleChanged()
|
|
{
|
|
_SearchBox.Visible = _SearchBoxVisible;
|
|
}
|
|
|
|
private bool _IsSearching = false;
|
|
private List<BaseItem> _HiddenItems = new List<BaseItem>();
|
|
private List<ToolboxGroup> _ExpandedGroups = new List<ToolboxGroup>();
|
|
private string _LastSearchText = string.Empty;
|
|
/// <summary>
|
|
/// Filters control toolbox items based on specified text. To clear last search and show all items pass string.empty or null/nothing as search text.
|
|
/// </summary>
|
|
/// <param name="text">Text to search for</param>
|
|
public void Search(string text)
|
|
{
|
|
_IsSearching = true;
|
|
RestoreHiddenItems();
|
|
|
|
if (!string.IsNullOrEmpty(text))
|
|
{
|
|
text = text.ToLower();
|
|
string[] wordList = text.Split(' ');
|
|
foreach (BaseItem item in _ItemPanel.Items)
|
|
{
|
|
ToolboxGroup group = item as ToolboxGroup;
|
|
if (group == null) continue;
|
|
if (group.Expanded) _ExpandedGroups.Add(group);
|
|
group.Expanded = true;
|
|
foreach (BaseItem groupItem in group.SubItems)
|
|
{
|
|
ToolboxItem ti = groupItem as ToolboxItem;
|
|
if (ti == null)
|
|
{
|
|
ti.Visible = false;
|
|
_HiddenItems.Add(ti);
|
|
continue;
|
|
}
|
|
if (!((!_SearchForEachWord || wordList.Length < 2) && ti.Text.ToLower().Contains(text) ||
|
|
_SearchBoxVisible && ContainsAny(ti.Text.ToLower(), wordList)))
|
|
{
|
|
ti.Visible = false;
|
|
_HiddenItems.Add(ti);
|
|
}
|
|
}
|
|
if (group.VisibleSubItems == 0)
|
|
{
|
|
group.Visible = false;
|
|
_HiddenItems.Add(group);
|
|
}
|
|
}
|
|
}
|
|
_ItemPanel.RecalcLayout();
|
|
_IsSearching = false;
|
|
_LastSearchText = text;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether control is performing search operation.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public bool IsSearching
|
|
{
|
|
get { return _IsSearching; }
|
|
}
|
|
|
|
private void RestoreHiddenItems()
|
|
{
|
|
bool restoreExpanded = _HiddenItems.Count > 0 || !string.IsNullOrEmpty(_LastSearchText);
|
|
if (_HiddenItems.Count > 0)
|
|
{
|
|
foreach (BaseItem item in _HiddenItems)
|
|
{
|
|
item.Visible = true;
|
|
}
|
|
_HiddenItems.Clear();
|
|
}
|
|
|
|
if (restoreExpanded)
|
|
{
|
|
foreach (BaseItem item in _ItemPanel.Items)
|
|
{
|
|
ToolboxGroup group = item as ToolboxGroup;
|
|
if (group == null) continue;
|
|
if (_ExpandedGroups.Contains(group))
|
|
group.Expanded = true;
|
|
else
|
|
group.Expanded = false;
|
|
}
|
|
_ExpandedGroups.Clear();
|
|
}
|
|
}
|
|
|
|
private ElementStyle _BackgroundStyle = new ElementStyle();
|
|
/// <summary>
|
|
/// Specifies the background style of the control.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Style"), Description("Gets or sets bar background style."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ElementStyle BackgroundStyle
|
|
{
|
|
get { return _BackgroundStyle; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets style to default value. Used by windows forms designer.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetBackgroundStyle()
|
|
{
|
|
_BackgroundStyle.StyleChanged -= new EventHandler(this.VisualPropertyChanged);
|
|
_BackgroundStyle = new ElementStyle();
|
|
_BackgroundStyle.StyleChanged += new EventHandler(this.VisualPropertyChanged);
|
|
this.Invalidate();
|
|
}
|
|
|
|
private void VisualPropertyChanged(object sender, EventArgs e)
|
|
{
|
|
OnVisualPropertyChanged();
|
|
}
|
|
|
|
protected virtual void OnVisualPropertyChanged()
|
|
{
|
|
this.Invalidate();
|
|
}
|
|
|
|
private void PaintStyleBackground(Graphics g)
|
|
{
|
|
if (!this.BackColor.IsEmpty)
|
|
{
|
|
using (SolidBrush brush = new SolidBrush(this.BackColor))
|
|
g.FillRectangle(brush, this.ClientRectangle);
|
|
}
|
|
|
|
ElementStyleDisplayInfo info = new ElementStyleDisplayInfo();
|
|
info.Bounds = this.ClientRectangle;
|
|
info.Graphics = g;
|
|
bool disposeStyle = false;
|
|
ElementStyle style = ElementStyleDisplay.GetElementStyle(_BackgroundStyle, out disposeStyle);
|
|
info.Style = style;
|
|
ElementStyleDisplay.Paint(info);
|
|
if (disposeStyle)
|
|
style.Dispose();
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
Graphics g = e.Graphics;
|
|
|
|
PaintStyleBackground(g);
|
|
|
|
base.OnPaint(e);
|
|
}
|
|
|
|
// <summary>
|
|
/// Occurs before an item drag & drop operation is started and allows cancellation.
|
|
/// </summary>
|
|
[Description("Occurs before an item drag & drop operation is started and allows cancellation")]
|
|
public event CancelEventHandler BeforeItemDrag;
|
|
/// <summary>
|
|
/// Raises BeforeItemDrag event.
|
|
/// </summary>
|
|
/// <param name="itemSource">Item being dragged.</param>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnBeforeItemDrag(object itemSource, CancelEventArgs e)
|
|
{
|
|
CancelEventHandler handler = BeforeItemDrag;
|
|
if (handler != null)
|
|
handler(itemSource, e);
|
|
}
|
|
|
|
private static bool ContainsAny(string textToSearch, params string[] wordsList)
|
|
{
|
|
foreach (string word in wordsList)
|
|
{
|
|
if (textToSearch.Contains(word))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates whether item drag and drop is enabled. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Behavior"), Description("Indicates whether item drag and drop is enabled. Default value is true.")]
|
|
public bool ItemDragDropEnabled
|
|
{
|
|
get { return _ItemPanel.EnableDragDrop; }
|
|
set { _ItemPanel.EnableDragDrop = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates whether toolbox items can be rearranged using drag & drop.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Behavior"), Description("Indicates whether toolbox items can be rearranged using drag & drop.")]
|
|
public bool ItemRearrangeEnabled
|
|
{
|
|
get { return _ItemPanel.AllowDrop; }
|
|
set { _ItemPanel.AllowDrop = value; }
|
|
}
|
|
#endregion
|
|
|
|
#region Licensing
|
|
#if !TRIAL
|
|
private string m_LicenseKey = "";
|
|
private bool m_DialogDisplayed = false;
|
|
[Browsable(false), DefaultValue("")]
|
|
public string LicenseKey
|
|
{
|
|
get { return m_LicenseKey; }
|
|
set
|
|
{
|
|
if (NodeOperations.ValidateLicenseKey(value))
|
|
return;
|
|
m_LicenseKey = (!NodeOperations.CheckLicenseKey(value) ? "9dsjkhds7" : value);
|
|
}
|
|
}
|
|
#endif
|
|
#endregion
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines selection modes for toolbox control items.
|
|
/// </summary>
|
|
public enum eToolboxItemSelectionMode
|
|
{
|
|
/// <summary>
|
|
/// No item selection is allowed.
|
|
/// </summary>
|
|
NoSelection,
|
|
/// <summary>
|
|
/// Only single item can be selected.
|
|
/// </summary>
|
|
Single,
|
|
/// <summary>
|
|
/// Multiple items can be selected.
|
|
/// </summary>
|
|
Multiple
|
|
}
|
|
}
|