/// <summary>
/// Adds a Menu item to the <see cref="T:Habanero.Faces.Base.IMenuItemCollection" />.
/// </summary>
/// <param name="menuItem"></param>
public void Add(IMenuItem menuItem)
{
_list.Add(menuItem);
ICollapsiblePanelGroupControl cpGroupMenuItem = _ownerMenuItem as ICollapsiblePanelGroupControl;
if (cpGroupMenuItem != null && menuItem is CollapsibleSubMenuItemWin)
{
CollapsibleSubMenuItemWin outlookStyleSubMenuItem = (CollapsibleSubMenuItemWin)menuItem;
cpGroupMenuItem.AddControl(outlookStyleSubMenuItem);
return;
}
ICollapsiblePanel cpMenuItem = _ownerMenuItem as ICollapsiblePanel;
if (cpMenuItem != null && menuItem is CollapsibleMenuItemWin)
{
if (cpMenuItem.ContentControl == null)
{
cpMenuItem.ContentControl = this.ControlFactory.CreatePanel();
_columnLayoutManager = new ColumnLayoutManager(cpMenuItem.ContentControl, this.ControlFactory);
// this.ControlFactory.CreateBorderLayoutManager(cpMenuItem);
_columnLayoutManager.HorizontalGapSize = 0;
_columnLayoutManager.VerticalGapSize = 0;
_columnLayoutManager.BorderSize = 0;
}
_columnLayoutManager.AddControl((CollapsibleMenuItemWin)menuItem);
cpMenuItem.Height += ((CollapsibleMenuItemWin)menuItem).Height;
cpMenuItem.ExpandedHeight = cpMenuItem.Height;
}
}
/// <summary>
/// Adds an <see cref="ICollapsiblePanel"/> to this control. The <paramref name="collapsiblePanel"/> is
/// added to this <see cref="ICollapsiblePanelGroupControl"/>
/// </summary>
/// <param name="collapsiblePanel"></param>
/// <returns>The collapsible Panel</returns>
public ICollapsiblePanel AddControl(ICollapsiblePanel collapsiblePanel)
{
ICollapsiblePanel control = _collapsiblePanelGroupManager.AddControl(collapsiblePanel);
control.Uncollapsed += ((sender, e) => FireItemSelected(control));
return(control);
}
public void Test_CreateLeafMenuItems_ShouldCreatePanelWithLeafMenu()
{
//---------------Set up test pack-------------------
HabaneroMenu habaneroMenu = new HabaneroMenu("Main");
string subMenuName = TestUtil.GetRandomString();
HabaneroMenu submenu = habaneroMenu.AddSubMenu(subMenuName);
string menuItemName1 = TestUtil.GetRandomString();
submenu.AddMenuItem(menuItemName1);
submenu.AddMenuItem(TestUtil.GetRandomString());
CollapsibleMenuBuilderWin menuBuilder = (CollapsibleMenuBuilderWin)CreateMenuBuilder();
IMenuItem menuItem = new CollapsibleSubMenuItemWin(GetControlFactory(), "Some Sub Menu");
//---------------Assert Precondition----------------
Assert.AreEqual(0, menuItem.MenuItems.Count);
ICollapsiblePanel menuItemAsControl = (ICollapsiblePanel)menuItem;
Assert.AreEqual(1, menuItemAsControl.Controls.Count);
Assert.AreEqual(2, submenu.MenuItems.Count);
//---------------Execute Test ----------------------
menuBuilder.CreateLeafMenuItems(submenu, menuItem);
//---------------Test Result -----------------------
Assert.AreEqual(2, menuItem.MenuItems.Count);
Assert.AreEqual(2, menuItemAsControl.Controls.Count);
IControlHabanero contentControl = menuItemAsControl.ContentControl;
Assert.AreEqual(2, contentControl.Controls.Count);
IControlHabanero firstControl = contentControl.Controls[0];
IControlHabanero secondControl = contentControl.Controls[1];
Assert.GreaterOrEqual(secondControl.Top, firstControl.Top + firstControl.Height);
}
///<summary>
/// Constructor for <see cref="CollapsiblePanelManager"/>
///</summary>
///<param name="collapsiblePanel"></param>
///<param name="controlFactory"></param>
public CollapsiblePanelManager(ICollapsiblePanel collapsiblePanel, IControlFactory controlFactory)
{
_controlFactory = controlFactory;
_collapsiblePanel = collapsiblePanel;
_collapseButton = _controlFactory.CreateButtonCollapsibleStyle();
_collapseButton.Click += delegate { Collapsed = !Collapsed; };
_pinLabel = controlFactory.CreateLabelPinOffStyle();
_pinLabel.Click += delegate { Pinned = !Pinned; };
IPanel buttonPanel = _controlFactory.CreatePanel();
BorderLayoutManager buttonLayoutManager =
_controlFactory.CreateBorderLayoutManager(buttonPanel);
buttonPanel.Height = _collapseButton.Height;
buttonLayoutManager.AddControl(_collapseButton, BorderLayoutManager.Position.Centre);
buttonLayoutManager.AddControl(_pinLabel, BorderLayoutManager.Position.East);
_layoutManager = _controlFactory.CreateBorderLayoutManager(collapsiblePanel);
_layoutManager.AddControl(buttonPanel, BorderLayoutManager.Position.North);
_collapseButton.BackColor = System.Drawing.Color.Transparent;
_collapseButton.ForeColor = System.Drawing.Color.Transparent;
}
private void FireItemSelected(ICollapsiblePanel collapsiblePanel)
{
if (ItemSelected != null)
{
ItemSelected(collapsiblePanel, new EventArgs());
}
}
private void RemoveBOPanel(IBusinessObject businessObject)
{
ICollapsiblePanel panel = FindCollapsiblePanel(businessObject);
this.Controls.Remove((Control)panel);
this.PanelsList.Remove(panel);
}
public void TestSimpleMenuStructure_AddsCollapsiblePanels()
{
//---------------Set up test pack-------------------
HabaneroMenu habaneroMenu = new HabaneroMenu("Main");
string subMenuName = TestUtil.GetRandomString();
HabaneroMenu submenu = habaneroMenu.AddSubMenu(subMenuName);
string menuItemName = TestUtil.GetRandomString();
submenu.AddMenuItem(menuItemName);
IMenuBuilder menuBuilder = CreateMenuBuilder();
//---------------Assert Preconditions---------------
Assert.AreEqual(1, habaneroMenu.Submenus.Count);
//---------------Execute Test ----------------------
IMainMenuHabanero menu = menuBuilder.BuildMainMenu(habaneroMenu);
//---------------Test Result -----------------------
Assert.IsInstanceOf(typeof(ICollapsiblePanelGroupControl), menu);
ICollapsiblePanelGroupControl menuAsCP = (ICollapsiblePanelGroupControl)menu;
Assert.AreEqual(1, menuAsCP.PanelsList.Count);
ICollapsiblePanel collapsiblePanel = menuAsCP.PanelsList[0];
Assert.IsNotNull(collapsiblePanel);
Assert.IsNotNull(collapsiblePanel.ContentControl);
Assert.AreEqual(1, collapsiblePanel.ContentControl.Controls.Count);
}
/// <summary>
/// Adds an <see cref="ICollapsiblePanel"/> to this control. The <paramref name="collapsiblePanel"/> is
/// added to the CollapsiblePanelGroupControl.
/// </summary>
/// <param name="collapsiblePanel">The collapsiblePanelBeingAdded</param>
/// <returns></returns>
public ICollapsiblePanel AddControl(ICollapsiblePanel collapsiblePanel)
{
int minimumControlHeight = collapsiblePanel.MinimumSize.Height - collapsiblePanel.CollapseButton.Height;
AddCollapsiblePanel(collapsiblePanel, minimumControlHeight);
return(collapsiblePanel);
}
/// <summary>
/// Adds an <see cref="IControlHabanero"/> to this control. The <paramref name="contentControl"/> is
/// wrapped in an <see cref="ICollapsiblePanel"/> control.
/// </summary>
/// <param name="contentControl"></param>
/// <param name="headingText"></param>
/// <param name="minimumControlHeight">The minimum height that the <paramref name="contentControl"/> can be.
/// This height along with the <see cref="ICollapsiblePanel.CollapseButton"/>.Height are give the
/// <see cref="ICollapsiblePanel.ExpandedHeight"/> that the <see cref="ICollapsiblePanel"/> will be when it is
/// expanded </param>
/// <returns></returns>
public ICollapsiblePanel AddControl(IControlHabanero contentControl, string headingText, int minimumControlHeight)
{
ICollapsiblePanel control = _collapsiblePanelGroupManager.AddControl(contentControl, headingText, minimumControlHeight);
control.Uncollapsed += ((sender, e) => FireItemSelected(control));
return(control);
}
///<summary>
/// Constructor for <see cref="CollapsiblePanelManager"/>
///</summary>
///<param name="collapsiblePanel"></param>
///<param name="controlFactory"></param>
public CollapsiblePanelManager(ICollapsiblePanel collapsiblePanel, IControlFactory controlFactory)
{
_controlFactory = controlFactory;
_collapsiblePanel = collapsiblePanel;
_collapseButton = _controlFactory.CreateButtonCollapsibleStyle();
_collapseButton.Click += delegate { Collapsed = !Collapsed; };
_pinLabel = controlFactory.CreateLabelPinOffStyle();
_pinLabel.Click += delegate { Pinned = !Pinned; };
IPanel buttonPanel = _controlFactory.CreatePanel();
BorderLayoutManager buttonLayoutManager =
_controlFactory.CreateBorderLayoutManager(buttonPanel);
buttonPanel.Height = _collapseButton.Height;
buttonLayoutManager.AddControl(_collapseButton, BorderLayoutManager.Position.Centre);
buttonLayoutManager.AddControl(_pinLabel, BorderLayoutManager.Position.East);
_layoutManager = _controlFactory.CreateBorderLayoutManager(collapsiblePanel);
_layoutManager.AddControl(buttonPanel, BorderLayoutManager.Position.North);
_collapseButton.BackColor = System.Drawing.Color.Transparent;
_collapseButton.ForeColor = System.Drawing.Color.Transparent;
}
public void Test_AddControl_WhenControlIsCollapsiblePanel_ShouldAdd()
{
//---------------Set up test pack-------------------
ICollapsiblePanelGroupControl groupControl = CreateCollapsiblePanelGroupControl();
ICollapsiblePanel collapsiblePanel = GetControlFactory().CreateCollapsiblePanel("Name");
collapsiblePanel.MinimumSize = new Size(123, 76);
//---------------Assert Precondition----------------
Assert.AreEqual(0, groupControl.PanelsList.Count);
Assert.AreEqual("Name", collapsiblePanel.Name);
Assert.AreEqual("Name", collapsiblePanel.CollapseButton.Text);
Assert.AreEqual("Name", collapsiblePanel.CollapseButton.Name);
//---------------Execute Test ----------------------
// ICollapsiblePanel collapsiblePanel = groupControl.AddControl(GetControlFactory().CreatePanel(), "", 53);
ICollapsiblePanel returnedCollapsiblePanel = groupControl.AddControl(collapsiblePanel);
//---------------Test Result -----------------------
Assert.AreSame(collapsiblePanel, returnedCollapsiblePanel);
Assert.AreEqual(1, groupControl.PanelsList.Count);
Assert.AreEqual(1, groupControl.Controls.Count);
Assert.AreSame(collapsiblePanel, groupControl.PanelsList[0]);
Assert.AreEqual(53 + collapsiblePanel.CollapseButton.Height, collapsiblePanel.ExpandedHeight);
Assert.AreEqual("Name", collapsiblePanel.CollapseButton.Text);
Assert.AreEqual("Name", collapsiblePanel.CollapseButton.Name);
}
public void Test_UncollapsePanel_FiresItemSelected()
{
//---------------Set up test pack-------------------
ICollapsiblePanelGroupControl control = CreateCollapsiblePanelGroupControl();
IPanel content1 = GetControlFactory().CreatePanel();
IPanel content2 = GetControlFactory().CreatePanel();
IPanel content3 = GetControlFactory().CreatePanel();
control.AddControl(content1, "", 99);
ICollapsiblePanel collapsiblePanel2 = control.AddControl(content2, "", 53);
control.AddControl(content3, "", 53);
control.AllCollapsed = true;
bool itemSelected = false;
control.ItemSelected += delegate { itemSelected = true; };
//---------------Assert Precondition----------------
Assert.AreSame(collapsiblePanel2, control.PanelsList[1]);
Assert.AreNotEqual(collapsiblePanel2.ExpandedHeight, collapsiblePanel2.Height);
Assert.IsFalse(itemSelected);
//---------------Execute Test ----------------------
collapsiblePanel2.Collapsed = false;
//---------------Test Result -----------------------
Assert.IsTrue(itemSelected);
}
public virtual void Test_CreateLeafMenuItems_ShouldCreatePanelWithLeafMenu()
{
//---------------Set up test pack-------------------
HabaneroMenu habaneroMenu = new HabaneroMenu("Main");
string subMenuName = TestUtil.GetRandomString();
HabaneroMenu submenu = habaneroMenu.AddSubMenu(subMenuName);
string menuItemName1 = TestUtil.GetRandomString();
submenu.AddMenuItem(menuItemName1);
submenu.AddMenuItem(TestUtil.GetRandomString());
CollapsibleMenuBuilderVWG menuBuilder = (CollapsibleMenuBuilderVWG)CreateMenuBuilder();
IMenuItem menuItem = new CollapsibleSubMenuItemVWG(GetControlFactory(), "Some Sub Menu");
//---------------Assert Precondition----------------
Assert.AreEqual(0, menuItem.MenuItems.Count);
ICollapsiblePanel menuItemAsControl = (ICollapsiblePanel)menuItem;
Assert.AreEqual(1, menuItemAsControl.Controls.Count);
Assert.AreEqual(2, submenu.MenuItems.Count);
//---------------Execute Test ----------------------
menuBuilder.CreateLeafMenuItems(submenu, menuItem);
//---------------Test Result -----------------------
Assert.AreEqual(2, menuItem.MenuItems.Count);
Assert.AreEqual(2, menuItemAsControl.Controls.Count);
IControlHabanero contentControl = menuItemAsControl.ContentControl;
Assert.AreEqual(2, contentControl.Controls.Count);
//Peter - 04/03/2010 - removed the assert below - the line that sets the Top is not working in this test, but the menu works in practice.
//IControlHabanero firstControl = contentControl.Controls[0];
//IControlHabanero secondControl = contentControl.Controls[1];
//Assert.GreaterOrEqual(secondControl.Top, firstControl.Top + firstControl.Height);
}
private void FireItemSelectedIndexChanged(ICollapsiblePanel collapsiblePanel)
{
if (SelectedIndexChanged != null)
{
SelectedIndexChanged(collapsiblePanel, new EventArgs());
}
}
private void AddBOPanel(IBusinessObject businessObject)
{
IPanel panel = _controlFactory.CreatePanel();
panel.Name = businessObject.ID.ObjectID.ToString();
ICollapsiblePanel control = this.AddControl(panel, businessObject.ToString(), 100);
control.Name = businessObject.ID.ObjectID.ToString();
}
/// <summary>
/// Adds an <see cref="IControlHabanero"/> to this control. The <paramref name="contentControl"/> is
/// wrapped in an <see cref="ICollapsiblePanel"/> control.
/// </summary>
/// <param name="contentControl"></param>
/// <param name="headingText"></param>
/// <param name="minimumControlHeight">The minimum height that the <paramref name="contentControl"/> can be.
/// This height along with the <see cref="ICollapsiblePanel.CollapseButton"/>.Height are give the
/// <see cref="ICollapsiblePanel.ExpandedHeight"/> that the <see cref="ICollapsiblePanel"/> will be when it is
/// expanded </param>
/// <returns></returns>
public ICollapsiblePanel AddControl
(IControlHabanero contentControl, string headingText, int minimumControlHeight)
{
ICollapsiblePanel collapsiblePanel = ControlFactory.CreateCollapsiblePanel();
collapsiblePanel.ContentControl = contentControl;
collapsiblePanel.CollapseButton.Text = headingText;
AddCollapsiblePanel(collapsiblePanel, minimumControlHeight);
return(collapsiblePanel);
}
private void AddCollapsiblePanel(ICollapsiblePanel collapsiblePanel, int minimumControlHeight)
{
ColumnLayoutManager.AddControl(collapsiblePanel);
this.PanelsList.Add(collapsiblePanel);
collapsiblePanel.Height = collapsiblePanel.CollapseButton.Height + minimumControlHeight;
collapsiblePanel.Collapsed = true;
collapsiblePanel.Uncollapsed += delegate
{
CollapseUnpinnedPanels(collapsiblePanel);
};
}
/// <summary>
/// Handles CriteriaCollapsed property change to update the state of Criteria panel
/// </summary>
/// <param name="sender">Model that sent the event</param>
/// <param name="e">Event arguments</param>
protected override void OnModelPropertyChanged(object sender, PropertyChangedEventArgs e)
{
base.OnModelPropertyChanged(sender, e);
ICollapsiblePanel collapsible = ucl_Criteria as ICollapsiblePanel;
if (collapsible != null && SearchViewModel.CriteriaCollapsedProperty.Equals(e.PropertyName))
{
SearchViewModel svm = sender as SearchViewModel;
collapsible.Collapsed = svm != null ? svm.CriteriaCollapsed : false;
}
}
public void Test_SetExpandedHeight_ShouldReturnNewExpandedHeight()
{
//---------------Set up test pack-------------------
ICollapsiblePanel panel = CreateControl();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
panel.ExpandedHeight = 500;
//---------------Test Result -----------------------
Assert.AreEqual(500, panel.ExpandedHeight);
}
public void TestCollapseButton()
{
//---------------Set up test pack-------------------
ICollapsiblePanel panel = CreateControl();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
panel.CollapseButton.PerformClick();
//---------------Test Result -----------------------
Assert.IsTrue(panel.Collapsed);
}
public void TestClickPinButtonPins()
{
//---------------Set up test pack-------------------
ICollapsiblePanel collapsiblePanel = CreateControl();
//---------------Assert Precondition----------------
Assert.IsFalse(collapsiblePanel.Pinned);
//---------------Execute Test ----------------------
// collapsiblePanel.PinLabel.PerformClick();
//---------------Test Result -----------------------
Assert.IsTrue(collapsiblePanel.Pinned);
//---------------Tear down -------------------------
}
public void TestPinWhenUncollapsed()
{
//---------------Set up test pack-------------------
ICollapsiblePanel collapsiblePanel = CreateControl();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
collapsiblePanel.Pinned = true;
//---------------Test Result -----------------------
Assert.IsTrue(collapsiblePanel.Pinned);
//Assert.AreEqual("Unpin", collapsiblePanel.PinLabel.Text);
//---------------Tear down -------------------------
}
public void TestCollapsePanel()
{
//---------------Set up test pack-------------------
ICollapsiblePanel panel = CreateControl();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
panel.Collapsed = true;
//---------------Test Result -----------------------
Assert.AreEqual(panel.CollapseButton.Height, panel.Height);
Assert.AreNotEqual(panel.ExpandedHeight, panel.Height);
//---------------Tear down -------------------------
}
public void TestUncollapsePanel()
{
//---------------Set up test pack-------------------
ICollapsiblePanel panel = CreateControl();
int originalHeight = panel.Height;
panel.Collapsed = true;
//---------------Assert Precondition----------------
Assert.AreEqual(originalHeight, panel.ExpandedHeight);
Assert.AreNotEqual(originalHeight, panel.Height);
//---------------Execute Test ----------------------
panel.Collapsed = false;
//---------------Test Result -----------------------
Assert.AreEqual(originalHeight, panel.Height);
Assert.AreEqual(originalHeight, panel.ExpandedHeight);
}
public void Test_DoClick_ShouldExpandTheCollapsiblePanel()
{
//---------------Set up test pack-------------------
string name = TestUtil.GetRandomString();
HabaneroMenu.Item item = new HabaneroMenu.Item(null, name);
IMenuItem collapsibleMenuItem = CreateControl(item);
ICollapsiblePanel subMenuAsCollapsiblePanel = (ICollapsiblePanel)collapsibleMenuItem;
//---------------Assert Precondition----------------
Assert.IsTrue(subMenuAsCollapsiblePanel.Collapsed);
//---------------Execute Test ----------------------
collapsibleMenuItem.DoClick();
//---------------Test Result -----------------------
Assert.IsFalse(subMenuAsCollapsiblePanel.Collapsed);
}
public void Test_ConstructSubMenu_ShouldBeCollapsed()
{
//---------------Set up test pack-------------------
string name = TestUtil.GetRandomString();
HabaneroMenu.Item item = new HabaneroMenu.Item(null, name);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IMenuItem collapsibleMenuItem = CreateControl(item);
ICollapsiblePanel subMenuAsCollapsiblePanel = (ICollapsiblePanel)collapsibleMenuItem;
//---------------Test Result -----------------------
Assert.IsTrue(subMenuAsCollapsiblePanel.Collapsed);
Assert.AreEqual
(subMenuAsCollapsiblePanel.CollapseButton.Height, subMenuAsCollapsiblePanel.MinimumSize.Height);
}
public void Test_ConstructMenuItem_ShouldSetName()
{
//---------------Set up test pack-------------------
string name = TestUtil.GetRandomString();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IMenuItem collapsibleMenuItem = CreateControl(name);
//---------------Test Result -----------------------
Assert.AreEqual(name, collapsibleMenuItem.Text);
Assert.IsNotNull(collapsibleMenuItem.MenuItems);
Assert.IsInstanceOf(typeof(ICollapsiblePanel), collapsibleMenuItem);
ICollapsiblePanel cp = (ICollapsiblePanel)collapsibleMenuItem;
Assert.AreEqual(name, cp.CollapseButton.Text);
}
public void TestRaisesUncollapsedEvent()
{
//---------------Set up test pack-------------------
ICollapsiblePanel collapsiblePanel = CreateControl();
bool uncollapsedEventFired = false;
collapsiblePanel.Uncollapsed += delegate { uncollapsedEventFired = true; };
collapsiblePanel.Collapsed = true;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
collapsiblePanel.Collapsed = false;
//---------------Test Result -----------------------
Assert.IsTrue(uncollapsedEventFired);
//---------------Tear down -------------------------
}
public void Test_AddControl()
{
//---------------Set up test pack-------------------
ICollapsiblePanelGroupControl control = CreateCollapsiblePanelGroupControl();
//---------------Assert Precondition----------------
Assert.AreEqual(0, control.PanelsList.Count);
//---------------Execute Test ----------------------
ICollapsiblePanel collapsiblePanel = control.AddControl(GetControlFactory().CreatePanel(), "", 53);
//---------------Test Result -----------------------
Assert.AreEqual(1, control.PanelsList.Count);
Assert.AreEqual(1, control.Controls.Count);
Assert.AreSame(collapsiblePanel, control.PanelsList[0]);
Assert.AreEqual(53 + collapsiblePanel.CollapseButton.Height, collapsiblePanel.ExpandedHeight);
}
public void Test_AddControl_TotalExpandedHeightEquals_CP1_ExpandedHeight()
{
//---------------Set up test pack-------------------
ICollapsiblePanelGroupControl control = CreateCollapsiblePanelGroupControl();
IPanel content = GetControlFactory().CreatePanel();
ICollapsiblePanel cp1 = control.AddControl(content, "", 53);
ColumnLayoutManager layoutManager = control.ColumnLayoutManager;
//---------------Assert Precondition----------------
Assert.AreEqual(1, control.PanelsList.Count);
//---------------Execute Test ----------------------
int totalExpandedHeight = control.TotalExpandedHeight;
//---------------Test Result -----------------------
Assert.AreEqual(layoutManager.BorderSize + cp1.ExpandedHeight + layoutManager.VerticalGapSize, totalExpandedHeight);
}
public void Test_AddControl_PlacesTextOnButton()
{
//---------------Set up test pack-------------------
ICollapsiblePanelGroupControl control = CreateCollapsiblePanelGroupControl();
IPanel content = GetControlFactory().CreatePanel();
const string headingText = "some text";
//---------------Assert Precondition----------------
Assert.AreEqual(0, control.PanelsList.Count);
//---------------Execute Test ----------------------
control.AddControl(content, headingText, 53);
//---------------Test Result -----------------------
Assert.AreEqual(1, control.PanelsList.Count);
ICollapsiblePanel cp2 = control.PanelsList[0];
Assert.AreEqual(headingText, cp2.CollapseButton.Text);
}
private void FireItemSelected(ICollapsiblePanel collapsiblePanel)
{
if (ItemSelected != null)
{
ItemSelected(collapsiblePanel, new EventArgs());
}
}
/// <summary>
/// Adds an <see cref="ICollapsiblePanel"/> to this control. The <paramref name="collapsiblePanel"/> is
/// added to the CollapsiblePanelGroupControl.
/// </summary>
/// <param name="collapsiblePanel">The collapsiblePanelBeingAdded</param>
/// <returns></returns>
public ICollapsiblePanel AddControl(ICollapsiblePanel collapsiblePanel)
{
int minimumControlHeight = collapsiblePanel.MinimumSize.Height - collapsiblePanel.CollapseButton.Height;
AddCollapsiblePanel(collapsiblePanel, minimumControlHeight);
return collapsiblePanel;
}
private void CollapseUnpinnedPanels(ICollapsiblePanel collapsiblePanel)
{
PanelsList.ForEach
(delegate(ICollapsiblePanel obj)
{
if (obj != collapsiblePanel)
{
if (!obj.Pinned && !obj.Collapsed) obj.Collapsed = true;
}
});
//Hack to get the layout manager to resize
ColumnLayoutManager.ManagedControl.Height = ColumnLayoutManager.ManagedControl.Height + 1;
ColumnLayoutManager.ManagedControl.Height = ColumnLayoutManager.ManagedControl.Height - 1;
}
private void FireItemSelectedIndexChanged(ICollapsiblePanel collapsiblePanel)
{
if (SelectedIndexChanged != null)
{
SelectedIndexChanged(collapsiblePanel, new EventArgs());
}
}
private void AddCollapsiblePanel(ICollapsiblePanel collapsiblePanel, int minimumControlHeight)
{
ColumnLayoutManager.AddControl(collapsiblePanel);
this.PanelsList.Add(collapsiblePanel);
collapsiblePanel.Height = collapsiblePanel.CollapseButton.Height + minimumControlHeight;
collapsiblePanel.Collapsed = true;
collapsiblePanel.Uncollapsed += delegate
{
CollapseUnpinnedPanels(collapsiblePanel);
};
}
/// <summary>
/// Adds an <see cref="ICollapsiblePanel"/> to this control. The <paramref name="collapsiblePanel"/> is
/// added to this <see cref="ICollapsiblePanelGroupControl"/>
/// </summary>
/// <param name="collapsiblePanel"></param>
/// <returns>The collapsible Panel</returns>
public ICollapsiblePanel AddControl(ICollapsiblePanel collapsiblePanel)
{
ICollapsiblePanel control = _collapsiblePanelGroupManager.AddControl(collapsiblePanel);
control.Uncollapsed += ((sender, e) => FireItemSelected(control));
return control;
}
