internal AutoHideGroup GetAutoHideGroup(DockWindow window)
{
int index = this.FindGroupIndex(window);
if (index != -1)
{
return(this.autoHideGroups[index]);
}
return(null);
}
protected override void OnClosed(EventArgs e)
{
base.OnClosed(e);
DockWindow pane = this.SelectedPane;
if (pane != null)
{
this.dockManager.ActiveWindow = pane;
}
}
protected internal override void UpdateAfterControlRemoved(Control value)
{
base.UpdateAfterControlRemoved(value);
DockWindow active = this.ActiveWindow;
if (active != null)
{
this.UpdateActiveWindow(active, false);
}
}
/// <summary>
/// Attempts to restore the state the window to the desired dock state.
/// </summary>
/// <param name="window"></param>
/// <param name="state">The target state which is to be restored.</param>
/// <param name="defaultAction">True to perform default action if no state is recorded for a window, false otherwise.</param>
public void RestoreState(DockWindow window, DockState state, bool defaultAction)
{
if (!this.CanOperate())
{
return;
}
RedockTransaction transaction = new RedockTransaction(state, new DockWindow[] { window }, defaultAction);
this.DockManager.RegisterTransaction(transaction, true);
}
/// <summary>
/// Determines whether a context menu can be displayed for the specified window.
/// </summary>
/// <param name="window"></param>
/// <returns></returns>
protected virtual bool CanDisplayMenu(DockWindow window)
{
//check whether we can display a menu for the specified window
switch (window.DockState)
{
case DockState.TabbedDocument:
return(this.allowDocumentContextMenu);
default:
return(this.allowToolContextMenu);
}
}
/// <summary>
/// Receives a notification for a change in the DockState property of a DockWindow.
/// We may have a situation where a ToolWindow becomes a TabbedDocument and vice-versa.
/// </summary>
/// <param name="window"></param>
internal void OnDockWindowDockStateChanged(DockWindow window)
{
//update the documents collection
if (window.DockState == DockState.TabbedDocument)
{
this.InsertDocument(-1, window);
}
else
{
this.RemoveDocument(-1, window);
}
}
void form_Shown(object sender, EventArgs e)
{
Form form = (Form)sender;
form.Shown -= new EventHandler(form_Shown);
DockWindow host = this.dockManager.GetHostWindow(form);
if (host != null)
{
host.Text = form.Text;
}
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnControlRemoved(System.Windows.Forms.ControlEventArgs e)
{
base.OnControlRemoved(e);
DockWindow window = e.Control as DockWindow;
if (window.TabStripItem == this.boldedItem)
{
this.boldedItem = null;
}
UpdateView();
}
internal void RemoveAutoHideGroup(DockWindow window)
{
int index = this.FindGroupIndex(window);
if (index == -1)
{
return;
}
AutoHideGroup group = this.autoHideGroups[index];
group.Windows.Clear();
this.autoHideGroups.RemoveAt(index);
}
/// <summary>
/// Builds the default list of documents. Called upon initialization completion.
/// </summary>
internal void BuildDocumentList()
{
this.ClearDocuments();
foreach (Control child in ControlHelper.EnumChildControls(this.dockManager.MainDocumentContainer, true))
{
DockWindow document = child as DockWindow;
if (document != null && document.DockManager == this.dockManager)
{
document.InnerDockState = DockState.TabbedDocument;
this.InsertDocument(-1, document);
}
}
}
/// <summary>
/// Saves the current state of the specified window.
/// </summary>
/// <param name="window"></param>
/// <returns></returns>
public virtual bool SaveState(DockWindow window)
{
if (!this.CanOperate())
{
return(false);
}
if (!IsSaveApplicable(window))
{
return(false);
}
return(this.SaveStateCore(window));
}
private void DeactivatePreviousActive(DockWindow newActive)
{
if (this.documents.Count == 0)
{
return;
}
DockWindow currActive = this.documents[0];
if (currActive != null && currActive != newActive)
{
currActive.UpdateActiveState(false);
}
}
/// <summary>
/// Collects all the DockWindow instances, residing on the specified parent, and associated with the provided RadDock instance.
/// </summary>
/// <param name="parent"></param>
/// <param name="recursive"></param>
/// <param name="dockManager"></param>
/// <returns></returns>
public static List <DockWindow> GetDockWindows(Control parent, bool recursive, RadDock dockManager)
{
List <DockWindow> descendants = new List <DockWindow>();
foreach (Control child in ControlHelper.EnumChildControls(parent, recursive))
{
DockWindow window = child as DockWindow;
if (window != null && window.DockManager == dockManager)
{
descendants.Add(window);
}
}
return(descendants);
}
/// <summary>
///
/// </summary>
protected internal override void UpdateAfterTransaction()
{
base.UpdateAfterTransaction();
if (this.DockManager == null)
{
return;
}
DockWindow activeDocument = this.DockManager.DocumentManager.ActiveDocument;
DockWindow active = this.ActiveWindow;
TabStripItem item = active == activeDocument ? active.TabStripItem : null;
this.BoldSelectedDocument(item);
}
private void EnsureActiveDocument()
{
//search all DocumentTabStrip instances and select the first opened document
foreach (Control child in ControlHelper.EnumChildControls(this.dockManager.MainDocumentContainer, true))
{
DocumentTabStrip strip = child as DocumentTabStrip;
if (strip != null && strip.TabPanels.Count > 0 && strip.DockManager == this.dockManager)
{
DockWindow active = strip.ActiveWindow;
this.InsertDocument(-1, active);
strip.UpdateActiveWindow(active, true);
break;
}
}
}
private void CloseAllDocuments(DockWindow toSkip)
{
this.DockManager.BeginTransactionBlock();
foreach (DockWindow docWindow in DockHelper.GetDockWindows(this.DockManager.MainDocumentContainer, true, this.DockManager))
{
if (docWindow == toSkip)
{
continue;
}
docWindow.Close();
}
this.DockManager.EndTransactionBlock();
}
private void OnActiveDocumentMenuItemClick(object sender, EventArgs e)
{
RadMenuItem item = sender as RadMenuItem;
if (item == null)
{
return;
}
DockWindow window = item.Tag as DockWindow;
if (window != null)
{
window.EnsureVisible();
}
}
private int FindGroupIndex(DockWindow window)
{
for (int i = 0; i < this.autoHideGroups.Count; i++)
{
AutoHideGroup group = this.autoHideGroups[i];
for (int j = 0; j < group.Windows.Count; j++)
{
if (group.Windows[j] == window)
{
return(i);
}
}
}
return(-1);
}
private void ApplyDockWindowSettings(DockWindow dockWindow)
{
dockWindow.Text = this.Text;
DockState dockState = XmlDockable.ParseDockState(this.DockState);
if (dockState != Telerik.WinControls.UI.Docking.DockState.TabbedDocument)
{
dockWindow.DockState = dockState;
}
else
{
dockWindow.InnerDockState = dockState;
dockWindow.DesiredDockState = dockState;
}
dockWindow.Size = XmlDockable.ParseSize(this.PreferredDockSize);
}
/// <summary>
/// Performs the core action, depending on the clicked menu item.
/// </summary>
/// <param name="menuItem"></param>
/// <param name="window"></param>
protected virtual void PerformMenuItemAction(DockWindow window, RadMenuItemBase menuItem)
{
switch (menuItem.Name)
{
case ActivateWindow:
this.DockManager.ActiveWindow = window;
window.EnsureVisible();
break;
case DockStateAutoHide:
case DockStateDocked:
case DockStateFloating:
case DockStateHidden:
case DockStateTabbedDocument:
this.DockManager.SetWindowState(window, (DockState)Enum.Parse(typeof(DockState), menuItem.Name));
break;
case CloseAll:
this.CloseAllDocuments(null);
break;
case CloseAllButThis:
this.CloseAllDocuments(window);
break;
case CloseWindow:
window.Close();
break;
case NewHTabGroup:
this.DockManager.AddDocument(window, window.TabStrip as DocumentTabStrip, DockPosition.Bottom);
break;
case NewVTabGroup:
this.DockManager.AddDocument(window, window.TabStrip as DocumentTabStrip, DockPosition.Right);
break;
case MoveToPrevTabGroup:
this.DockManager.MoveToPreviousDocumentTabStrip(window);
break;
case MoveToNextTabGroup:
this.DockManager.MoveToNextDocumentTabStrip(window);
break;
}
}
/// <summary>
/// Updates the currently active window by setting bold if the specified window instance is the currently active document within the owning RadDock instance.
/// </summary>
/// <param name="window"></param>
/// <param name="active"></param>
protected internal override void UpdateActiveWindow(DockWindow window, bool active)
{
base.UpdateActiveWindow(window, active);
if (window == null || this.DockManager == null || ((IComponentTreeHandler)this.DockManager).Initializing)
{
return;
}
TabStripItem item = null;
if (active && window == this.DockManager.DocumentManager.ActiveDocument)
{
item = window.TabStripItem;
}
this.BoldSelectedDocument(item);
}
/// <summary>
///
/// </summary>
protected internal override void UpdateButtons()
{
base.UpdateButtons();
if (this.DockManager == null)
{
return;
}
DockWindow active = this.ActiveWindow;
if (active == null)
{
return;
}
DocumentStripButtons buttons = active.DocumentButtons;
//update close button
if ((buttons & DocumentStripButtons.Close) == 0)
{
this.closeButton.Visibility = ElementVisibility.Collapsed;
}
else
{
if (this.DockManager.CanChangeWindowState(active, DockState.Hidden, false))
{
this.closeButton.Visibility = ElementVisibility.Visible;
}
else
{
this.closeButton.Visibility = ElementVisibility.Collapsed;
}
}
//update active window list button
if ((buttons & DocumentStripButtons.ActiveWindowList) == 0)
{
this.overflowMenuButton.Visibility = ElementVisibility.Collapsed;
}
else
{
this.overflowMenuButton.Visibility = ElementVisibility.Visible;
}
}
private QuickNavigatorListItem CreateListItem(DockWindow pane)
{
QuickNavigatorListItem element = (QuickNavigatorListItem)Activator.CreateInstance(this.settings.ListItemType);
element.ImagePrimitive.ImageLayout = ImageLayout.Zoom;
element.Image = pane.Image;
element.Text = pane.Text;
element.TextElement.TextWrap = false;
element.TextElement.AutoEllipsis = true;
element.TextElement.StretchHorizontally = true;
element.TextElement.StretchVertically = true;
element.TextElement.AutoSize = true;
element.MinSize = this.settings.ListItemSize;
//pass the associated pane as a Tag
element.Tag = pane;
return(element);
}
/// <summary>
/// Gets the menu items, associated with the specified DockWindow.
/// </summary>
/// <param name="window"></param>
/// <param name="defaultAction">True to execute the default action, associated with each item, when an item is clicked.</param>
/// <returns></returns>
public List <RadMenuItemBase> GetContextMenuItems(DockWindow window, bool defaultAction)
{
if (window == null)
{
throw new ArgumentNullException("Window");
}
if (window.DockManager != this.DockManager)
{
throw new ArgumentException("Specified DockWindow is not owned by the DockManager this service is registered with.");
}
this.hookItemClick = defaultAction;
List <RadMenuItemBase> items = this.BuildContextMenuItems(window);
this.hookItemClick = true;
return(items);
}
public override object Execute(params object[] settings)
{
RadDock dockManager = settings[0] as RadDock;
if (dockManager == null)
{
throw new ArgumentNullException("DockManager");
}
DockWindow activeDoc = dockManager.DocumentManager.ActiveDocument;
if (activeDoc != null)
{
dockManager.CloseWindow(activeDoc);
}
return(base.Execute(settings));
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
{
if (!this.ContainsFocus)
{
base.Focus();
}
base.OnMouseDown(e);
if (this.dockManager != null)
{
this.dockManager.ActiveWindow = this.ActiveWindow;
}
if (e.Button == MouseButtons.Left)
{
this.initialMousePosition = e.Location;
}
}
private void UpdateCaptions(bool checkDockManager)
{
List <ToolTabStrip> visibleStrips = new List <ToolTabStrip>();
foreach (Control child in ControlHelper.EnumChildControls(this.dockContainer, true))
{
ToolTabStrip strip = child as ToolTabStrip;
if (strip == null || strip.Collapsed)
{
continue;
}
if (checkDockManager && strip.DockManager != this.dockManager)
{
continue;
}
visibleStrips.Add(strip);
}
bool hasCaption = visibleStrips.Count > 1;
foreach (ToolTabStrip strip in visibleStrips)
{
strip.CanDisplayCaption = hasCaption;
strip.PerformLayout();
}
if (hasCaption)
{
this.Text = string.Empty;
}
else if (visibleStrips.Count == 1)
{
DockWindow window = ((DockTabStrip)visibleStrips[0]).ActiveWindow;
if (window != null)
{
this.Text = window.Text;
}
}
this.dockContainer.PerformLayout();
}
/// <summary>
/// Overrides the method to provide support for instanciating a DragDropService operation.
/// </summary>
/// <param name="mouse"></param>
protected override void OnDragInitialized(Point mouse)
{
if (this.DockManager == null)
{
return;
}
DockWindow activeWindow = this.ActiveWindow;
if (activeWindow == null)
{
return;
}
draggedItem = this.elementTree.GetElementAtPoint(mouse) as TabStripItem;
object dragged = null;
if (draggedItem != null)
{
if (!this.tabStripElement.ItemContainer.ControlBoundingRectangle.Contains(mouse))
{
dragged = activeWindow;
}
if (this.TabPanels.Count == 1 && this.ActiveWindow.DockState == DockState.Floating)
{
dragged = null;
}
}
else
{
if (activeWindow.DockState != DockState.AutoHide && this.IsDragAllowed(this.DragStart))
{
dragged = this;
}
}
if (dragged != null)
{
this.dockManager.BeginDrag(dragged);
}
}
/// <summary>
/// Removes previously saved redock state for the specified window for the specified DockState.
/// </summary>
/// <param name="window"></param>
/// <param name="dockState"></param>
/// <returns></returns>
public bool ClearState(DockWindow window, DockState dockState)
{
RedockState state = this.GetState(window, dockState, true);
if (state == null)
{
return(false);
}
this.RemovePreviousState(state);
//remove from clean-up list
int index = this.oldStates.IndexOf(state);
if (index != -1)
{
this.oldStates.RemoveAt(index);
}
return(true);
}
/// <summary>
/// Preforms the core Save logic.
/// </summary>
/// <param name="window"></param>
/// <returns></returns>
protected virtual bool SaveStateCore(DockWindow window)
{
Dictionary <DockState, RedockState> states;
this.redockStates.TryGetValue(window.Name, out states);
if (states == null)
{
states = new Dictionary <DockState, RedockState>();
this.redockStates[window.Name] = states;
}
RedockState savedState;
if (window.DockState == DockState.Floating)
{
savedState = new RedockFloatingState(window);
}
else
{
savedState = new RedockState(window, window.DockState);
}
//invalid state
if (!savedState.IsValid)
{
return(false);
}
RedockState oldState;
states.TryGetValue(window.DockState, out oldState);
if (oldState != null)
{
oldStates.Add(oldState);
}
states[window.DockState] = savedState;
return(true);
}