private void OnDockableNavigatorPageDrop(object sender, PageDropEventArgs e) { // Use event to indicate the page is moving to a navigator and allow it to be cancelled KryptonDockingManager dockingManager = DockingManager; if (dockingManager != null) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(e.Page.UniqueName, false); dockingManager.RaisePageNavigatorRequest(args); // Pass back the result of the event e.Cancel = args.Cancel; } }
/// <summary> /// Occurs when a page is dropped on the control. /// </summary> /// <param name="sender">Source of the event.</param> /// <param name="e">A PageDropEventArgs containing the event data.</param> protected override void RaiseSpacePageDrop(object sender, PageDropEventArgs e) { // Use event to indicate the page is moving to a workspace and allow it to be cancelled KryptonDockingManager dockingManager = DockingManager; if (dockingManager != null) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(e.Page.UniqueName, false); dockingManager.RaisePageWorkspaceRequest(args); // Pass back the result of the event e.Cancel = args.Cancel; } }
/// <summary> /// Generate an implementation of the IDragPageNotify class that will be used to handle the drag/drop operation. /// </summary> /// <param name="screenPoint">Screen point of the mouse for the drag operation.</param> /// <param name="elementOffset">Offset from top left of element causing the drag.</param> /// <param name="c">Control that started the drag operation.</param> /// <param name="pages">Set of pages requested to be dragged.</param> public virtual void DoDragDrop(Point screenPoint, Point elementOffset, Control c, KryptonPageCollection pages) { // Cannot drag a null reference if (pages == null) throw new ArgumentNullException("pages"); // Cannot drag an empty collection if (pages.Count == 0) throw new ArgumentOutOfRangeException("pages", "collection cannot be empry"); // Create docking specific drag manager for moving the pages around DockingDragManager dragManager = new DockingDragManager(this, c); dragManager.FloatingWindowOffset = elementOffset; bool atLeastOneFloating = false; KryptonPage firstFloatingPage = null; foreach (KryptonPage page in pages) { // You cannot drag a store page if (!(page is KryptonStorePage)) { // Cannot drag a null page reference if (page == null) throw new ArgumentNullException("pages collection contains a null page reference"); // Remember the first page that is allowed to be made floating if (!atLeastOneFloating && page.AreFlagsSet(KryptonPageFlags.DockingAllowFloating)) { // Use event to indicate the page is becoming floating and allow it to be cancelled CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, false); OnPageFloatingRequest(args); if (!args.Cancel) { firstFloatingPage = page; atLeastOneFloating = true; } } } } // If we have at least one page that is allowed to be floating if (atLeastOneFloating) { // Can we find an existing floating store page... KryptonDockingFloatspace floatspace = FindStorePageElement(DockingLocation.Floating, firstFloatingPage) as KryptonDockingFloatspace; if (floatspace != null) { KryptonDockingFloatingWindow floatingWindow = floatspace.GetParentType(typeof(KryptonDockingFloatingWindow)) as KryptonDockingFloatingWindow; if (floatingWindow != null) { // If the floating window is not currently visible... if (!floatingWindow.FloatingWindow.Visible) { using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { //...then we can use it for dragging. We want the floating window to become visible and show just the set of pages // that are allowed to be floating from the set of pages passed into this function. As the window is not currently // visible it means all the contained pages are hidden and so we can make only the pages we are interested in visible // and it will have the appearance we need. dragManager.FloatingWindow = floatingWindow.FloatingWindow; // Convert the existing page loaction, if any, to store and restore it in this floating window KryptonPage[] firstFloatingPages = new KryptonPage[] { firstFloatingPage }; PropogateAction(DockingPropogateAction.StorePages, firstFloatingPages); floatingWindow.PropogateAction(DockingPropogateAction.RestorePages, firstFloatingPages); // Make a list of all pages that should be appended to the floating window List<string> appendUniqueNames = new List<string>(); List<KryptonPage> appendPages = new List<KryptonPage>(); foreach (KryptonPage page in pages) if (!(page is KryptonStorePage) && (page != firstFloatingPage) && page.AreFlagsSet(KryptonPageFlags.DockingAllowFloating)) { appendUniqueNames.Add(page.UniqueName); appendPages.Add(page); } // Set the window location before it is shown otherwise we see a brief flash as it appears at the // existing location and then it moves to the correct location based on the screen mouse position dragManager.FloatingWindow.Location = new Point(screenPoint.X - elementOffset.X, screenPoint.Y - elementOffset.Y); // Convert the append pages to store pages and then append to the same cell as the just restore page above PropogateAction(DockingPropogateAction.StorePages, appendUniqueNames.ToArray()); KryptonWorkspaceCell cell = floatingWindow.CellForPage(firstFloatingPage.UniqueName); cell.Pages.AddRange(appendPages.ToArray()); } } } } // Do we need to create a new floating window? if (dragManager.FloatingWindow == null) { // Get access to a floating element that allows a new floating window to be created KryptonDockingFloating floating = FindDockingFloating(firstFloatingPage.UniqueName); if (floating != null) { KryptonDockingFloatingWindow floatingWindow = floating.AddFloatingWindow(); if (floatingWindow != null) { using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // This is the window that will be moved during the drag operation dragManager.FloatingWindow = floatingWindow.FloatingWindow; // Make a list of all pages that should be appended to the floating window List<string> appendUniqueNames = new List<string>(); List<KryptonPage> appendPages = new List<KryptonPage>(); foreach (KryptonPage page in pages) if (!(page is KryptonStorePage) && page.AreFlagsSet(KryptonPageFlags.DockingAllowFloating)) { appendUniqueNames.Add(page.UniqueName); appendPages.Add(page); } // Set the window location before it is shown otherwise we see a brief flash as it appears at the // existing location and then it moves to the correct location based on the screen mouse position dragManager.FloatingWindow.Location = new Point(screenPoint.X - elementOffset.X, screenPoint.Y - elementOffset.Y); // Append the pages inside the new window, storing the current locations for later use PropogateAction(DockingPropogateAction.StorePages, appendUniqueNames.ToArray()); floatingWindow.FloatspaceElement.Append(appendPages.ToArray()); floatingWindow.FloatingWindow.Show(); } } } } } // Alow workspace controls to compact and update based on changes from above Application.DoEvents(); // Add ourself as a source of drag targets and then begin the dragging process dragManager.DragTargetProviders.Add(new DockingDragTargetProvider(this, dragManager.FloatingWindow, pages)); dragManager.DragStart(screenPoint, new PageDragEndData(this, pages)); }
/// <summary> /// Occurs when a page is dropped on the control. /// </summary> /// <param name="sender">Source of the event.</param> /// <param name="e">A PageDropEventArgs containing the event data.</param> protected override void RaiseSpacePageDrop(object sender, PageDropEventArgs e) { // Use event to indicate the page is moving to a workspace and allow it to be cancelled KryptonDockingManager dockingManager = DockingManager; if (dockingManager != null) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(e.Page.UniqueName, false); dockingManager.RaisePageDockedRequest(args); // Pass back the result of the event e.Cancel = args.Cancel; } }
/// <summary> /// Raises the PageNavigatorRequest event. /// </summary> /// <param name="e">An CancelUniqueNameEventArgs containing the event args.</param> protected virtual void OnPageNavigatorRequest(CancelUniqueNameEventArgs e) { if (PageNavigatorRequest != null) PageNavigatorRequest(this, e); }
/// <summary> /// Raises the PageWorkspaceRequest event. /// </summary> /// <param name="e">An CancelUniqueNameEventArgs containing the event args.</param> protected virtual void OnPageWorkspaceRequest(CancelUniqueNameEventArgs e) { if (PageWorkspaceRequest != null) PageWorkspaceRequest(this, e); }
internal void RaisePageWorkspaceRequest(CancelUniqueNameEventArgs e) { OnPageWorkspaceRequest(e); }
/// <summary> /// Raises the PageAutoHiddenRequest event. /// </summary> /// <param name="e">An CancelUniqueNameEventArgs containing the event args.</param> protected virtual void OnPageAutoHiddenRequest(CancelUniqueNameEventArgs e) { if (PageAutoHiddenRequest != null) PageAutoHiddenRequest(this, e); }
/// <summary> /// Perform the drop action associated with the target. /// </summary> /// <param name="screenPt">Position in screen coordinates.</param> /// <param name="data">Data to pass to the target to process drop.</param> /// <returns>Drop was performed and the source can perform any removal of pages as required.</returns> public override bool PerformDrop(Point screenPt, PageDragEndData data) { // Find our docking edge KryptonDockingEdge dockingEdge = null; switch (Edge) { case VisualOrientation.Left: dockingEdge = ControlElement["Left"] as KryptonDockingEdge; break; case VisualOrientation.Right: dockingEdge = ControlElement["Right"] as KryptonDockingEdge; break; case VisualOrientation.Top: dockingEdge = ControlElement["Top"] as KryptonDockingEdge; break; case VisualOrientation.Bottom: dockingEdge = ControlElement["Bottom"] as KryptonDockingEdge; break; } if (dockingEdge != null) { // Find the docked edge KryptonDockingEdgeDocked dockedEdge = dockingEdge["Docked"] as KryptonDockingEdgeDocked; if (dockingEdge != null) { KryptonDockingManager manager = dockedEdge.DockingManager; if (manager != null) { // Create a list of pages that are allowed to be transferred into the dockspace List <KryptonPage> transferPages = new List <KryptonPage>(); List <string> transferUniqueNames = new List <string>(); foreach (KryptonPage page in data.Pages) { if (page.AreFlagsSet(KryptonPageFlags.DockingAllowDocked)) { // Use event to indicate the page is becoming docked and allow it to be cancelled CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, false); manager.RaisePageDockedRequest(args); if (!args.Cancel) { transferPages.Add(page); transferUniqueNames.Add(page.UniqueName); } } } // Transfer valid pages into the new dockspace if (transferPages.Count > 0) { // Convert the incoming pages into store pages for restoring later manager.PropogateAction(DockingPropogateAction.StorePages, transferUniqueNames.ToArray()); // Create a new dockspace at the start of the list so it is closest to the control edge KryptonDockingDockspace dockspace = (_outsideEdge ? dockedEdge.InsertDockspace(0) : dockedEdge.AppendDockspace()); // Add pages into the target dockspace.Append(transferPages.ToArray()); return(true); } } } } return(false); }
/// <summary> /// Make the named page workspace tabbed. /// </summary> /// <param name="uniqueName">Unique name of page to become workspace tabbed.</param> public virtual void MakeWorkspaceRequest(string uniqueName) { // Cannot process a null reference if (uniqueName == null) throw new ArgumentNullException("uniqueName"); // Unique names cannot be zero length if (uniqueName.Length == 0) throw new ArgumentException("uniqueName cannot be zero length"); // If the named page exists and is not already workspace tabbed if (ContainsPage(uniqueName) && (FindPageLocation(uniqueName) != DockingLocation.Workspace)) { // If we can find a workspace element appropriate for the named page KryptonDockingWorkspace workspaceElement = FindDockingWorkspace(uniqueName); if (workspaceElement != null) { KryptonPage page = PageForUniqueName(uniqueName); if (page != null) { // Ensure all docking controls have been layed out before the change is processed Application.DoEvents(); CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(uniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowWorkspace)); OnPageWorkspaceRequest(args); if (args.Cancel) return; using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the page to a placeholder so it can be returned to the same location PropogateAction(DockingPropogateAction.StorePages, new string[] { uniqueName }); // Find the target cell, if there is one, that contains a store page KryptonWorkspaceCell cell = workspaceElement.CellForPage(uniqueName); if (cell != null) { // Insert the page at the same index as the restore page int pageIndex = cell.Pages.IndexOf(cell.Pages[uniqueName]); workspaceElement.CellInsert(cell, pageIndex, new KryptonPage[] { page }); workspaceElement.SelectPage(uniqueName); workspaceElement.DockableWorkspaceControl.Select(); } else { // No existing store page so just append to the worksapce workspaceElement.Append(new KryptonPage[] { page }); workspaceElement.SelectPage(uniqueName); workspaceElement.DockableWorkspaceControl.Select(); } } } } } }
/// <summary> /// Perform a switch from floating to docked for the named pages. /// </summary> /// <param name="uniqueNames">Unique name of floating pages that need switching.</param> /// <returns>KryptonDockingDockspace reference if a new dockspace needed to be created; otherwise false.</returns> public virtual KryptonDockingDockspace SwitchFloatingToDockedRequest(string[] uniqueNames) { // Cannot action a null reference if (uniqueNames == null) throw new ArgumentNullException("uniqueNames"); // Cannot action an empty array if (uniqueNames.Length == 0) throw new ArgumentOutOfRangeException("uniqueNames", "array cannot be empry"); // Cannot action a null or zero length unique name foreach (string uniqueName in uniqueNames) { if (uniqueName == null) throw new ArgumentNullException("uniqueNames array contains a null string reference"); if (uniqueName.Length == 0) throw new ArgumentException("uniqueNames array contains a zero length string"); } // Use events to determine which pages should be switched List<string> switchUniqueNames = new List<string>(); List<KryptonPage> switchPages = new List<KryptonPage>(); string selectedPage = null; foreach (string uniqueName in uniqueNames) { // Does the provided unique name exist and is in the required 'floating' state if (FindPageLocation(uniqueName) == DockingLocation.Floating) { KryptonPage page = PageForUniqueName(uniqueName); if (page != null) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowDocked)); OnPageDockedRequest(args); if (!args.Cancel) { switchUniqueNames.Add(page.UniqueName); switchPages.Add(page); // Navigate to the cell that holds the page KryptonDockingFloatspace floatspace = FindPageElement(page) as KryptonDockingFloatspace; if (floatspace != null) { KryptonWorkspaceCell cell = floatspace.CellForPage(uniqueName); if (cell != null) { // Remember the page that is active if (cell.SelectedPage == page) selectedPage = page.UniqueName; } } } } } } // Still any pages to be switched? if (switchUniqueNames.Count > 0) { using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the pages to placeholders so they can be returned to the same location PropogateAction(DockingPropogateAction.StorePages, switchUniqueNames.ToArray()); // Try and restore each page, but make a note of thos that failed to be restore List<string> defaultUniqueNames = new List<string>(); List<KryptonPage> defaultPages = new List<KryptonPage>(); KryptonPage defaultSelectedPage = null; for(int i=0; i<switchUniqueNames.Count; i++) { // Find any dockspace that contains a restore page for this named page string switchUniqueName = switchUniqueNames[i]; KryptonDockingDockspace restoreElement = DockingManager.FindStorePageElement(DockingLocation.Docked, switchUniqueName) as KryptonDockingDockspace; if (restoreElement != null) { // Find the target cell and the index of the restore page KryptonWorkspaceCell cell = restoreElement.CellForPage(switchUniqueName); int pageIndex = cell.Pages.IndexOf(cell.Pages[switchUniqueName]); // Insert the set of pages at the same index as the restore page restoreElement.CellInsert(cell, pageIndex, switchPages[i]); // Make sure the same page is selected as was selected in the floating source if (switchUniqueName == selectedPage) { restoreElement.SelectPage(selectedPage); restoreElement.DockspaceControl.UpdateVisible(true); } } else { defaultUniqueNames.Add(switchUniqueName); defaultPages.Add(switchPages[i]); // Note the default page that should become selected if (switchUniqueName == selectedPage) defaultSelectedPage = switchPages[i]; } } // Any pages that need default positioning because they could not be restored? if (defaultPages.Count > 0) { // Cannot switch to docked unless we can find a docked element as the target KryptonDockingEdgeDocked edgeDocked = FindDockingEdgeDocked(defaultSelectedPage != null ? defaultSelectedPage.UniqueName : defaultPages[0].UniqueName); if (edgeDocked != null) { KryptonDockingDockspace dockspace = edgeDocked.AppendDockspace(); dockspace.Append(defaultPages.ToArray()); // Make sure the same page is selected as was selected in the floating source if (defaultSelectedPage != null) { dockspace.SelectPage(defaultSelectedPage.UniqueName); dockspace.DockspaceControl.UpdateVisible(true); } } } } } return null; }
internal void RaisePageDockedRequest(CancelUniqueNameEventArgs e) { OnPageDockedRequest(e); }
/// <summary> /// Perform a switch from docked pages to floating window for the named pages. /// </summary> /// <param name="uniqueNames">Unique name of pages inside a docked cell that needs switching.</param> /// <returns>KryptonDockingFloatingWindow reference on success; otherwise null.</returns> public virtual KryptonDockingFloatingWindow SwitchDockedToFloatingWindowRequest(string[] uniqueNames) { // Cannot action a null reference if (uniqueNames == null) throw new ArgumentNullException("uniqueNames"); // Cannot action an empty array if (uniqueNames.Length == 0) throw new ArgumentOutOfRangeException("uniqueNames", "array cannot be empry"); // Cannot action a null or zero length unique name foreach (string uniqueName in uniqueNames) { if (uniqueName == null) throw new ArgumentNullException("uniqueNames array contains a null string reference"); if (uniqueName.Length == 0) throw new ArgumentException("uniqueNames array contains a zero length string"); } // Use events to determine which pages should be switched List<string> switchUniqueNames = new List<string>(); List<KryptonPage> switchPages = new List<KryptonPage>(); string selectedPage = null; foreach (string uniqueName in uniqueNames) { // Does the provided unique name exist and is in the required 'docked' state if (FindPageLocation(uniqueName) == DockingLocation.Docked) { KryptonPage page = PageForUniqueName(uniqueName); if (page != null) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowFloating)); OnPageFloatingRequest(args); if (!args.Cancel) { switchUniqueNames.Add(page.UniqueName); switchPages.Add(page); // Navigate to the cell that holds the page KryptonDockingDockspace dockspace = FindPageElement(page) as KryptonDockingDockspace; if (dockspace != null) { KryptonWorkspaceCell cell = dockspace.CellForPage(uniqueName); if (cell != null) { // Remember the page that is active if (cell.SelectedPage == page) selectedPage = page.UniqueName; } } } } } } // Still any pages to be switched? if (switchUniqueNames.Count > 0) { // Find a floating element that is the target for the switching KryptonDockingFloating floating = FindDockingFloating(selectedPage != null ? selectedPage : switchUniqueNames[0]); if (floating != null) { using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the pages to placeholders so they can be returned to the same location PropogateAction(DockingPropogateAction.StorePages, switchUniqueNames.ToArray()); KryptonWorkspaceCell cell = null; foreach (string switchUniqueName in switchUniqueNames) { // Is there a floating window with a restore page for this unique name? KryptonDockingFloatingWindow restoreElement = floating.FloatingWindowForStorePage(switchUniqueName); if (restoreElement != null) { // Find the target cell and the index of the restore page cell = restoreElement.CellForPage(switchUniqueName); int pageIndex = cell.Pages.IndexOf(cell.Pages[switchUniqueName]); // Insert the set of pages at the same index as the restore page restoreElement.FloatspaceElement.CellInsert(cell, pageIndex, switchPages.ToArray()); // Make sure the same page is selected as was selected in the docked source if (selectedPage != null) restoreElement.SelectPage(selectedPage); return restoreElement; } } // No floating window found to restore into, so create a new window KryptonDockingFloatingWindow floatingElement = floating.AddFloatingWindow(); floatingElement.FloatspaceElement.Append(switchPages.ToArray()); // Make sure the same page is selected as was selected in the docked source if (selectedPage != null) floatingElement.SelectPage(selectedPage); floatingElement.FloatingWindow.Show(); return floatingElement; } } } return null; }
/// <summary> /// Perform a switch from docked cell to auto hidden group for the visible pages inside the cell. /// </summary> /// <param name="uniqueName">Unique name of page inside docked cell that needs switching.</param> /// <returns>KryptonDockingAutoHiddenGroup reference on success; otherwise null.</returns> public virtual KryptonDockingAutoHiddenGroup SwitchDockedCellToAutoHiddenGroupRequest(string uniqueName) { // Cannot switch a null reference if (uniqueName == null) throw new ArgumentNullException("uniqueName"); // Unique names cannot be zero length if (uniqueName.Length == 0) throw new ArgumentException("uniqueName cannot be zero length"); // Does the provided unique name exist and is in the required 'docked' state if (FindPageLocation(uniqueName) == DockingLocation.Docked) { // Grab the dockspace element that we expect to contain the target unique name KryptonDockingDockspace dockspace = (KryptonDockingDockspace)ExpectPageElement(uniqueName, typeof(KryptonDockingDockspace)); if (dockspace != null) { // Does the dockspace currently have the focus? bool hadFocus = dockspace.DockspaceControl.ContainsFocus; // Find the sibling auto hidden edge so we can add a new auto hidden group to it later on KryptonDockingEdgeAutoHidden edgeAutoHidden = dockspace.EdgeAutoHiddenElement; if (edgeAutoHidden != null) { // Grab the set of visible pages in the same cell as the target unique name KryptonPage[] visiblePages = dockspace.CellVisiblePages(uniqueName); if (visiblePages.Length > 0) { // Use events to determine which pages in the cell should be switched List<string> switchUniqueNames = new List<string>(); List<KryptonPage> switchPages = new List<KryptonPage>(); foreach (KryptonPage page in visiblePages) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowAutoHidden)); OnPageAutoHiddenRequest(args); if (!args.Cancel) { switchUniqueNames.Add(page.UniqueName); switchPages.Add(page); } } // Any pages that actually need to be switched? if (switchPages.Count > 0) { using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the pages to placeholders so they can be returned to the same location string[] uniqueNames = switchUniqueNames.ToArray(); dockspace.PropogateAction(DockingPropogateAction.StorePages, uniqueNames); // Create a new auto hidden group and add the switch pages into it KryptonDockingAutoHiddenGroup group = edgeAutoHidden.AppendAutoHiddenGroup(); group.Append(switchPages.ToArray()); // If we had the focus at the start of the process and the dockspace no longer has it... if (hadFocus && !dockspace.DockspaceControl.ContainsFocus) { // ...and focus has not moved to another part of the form... Form topForm = dockspace.DockspaceControl.FindForm(); if ((topForm != null) && !topForm.ContainsFocus) { // ...then shift focus to the auto hidden group placeholder, to ensure the form still has the // focus and so hovering the mouse over the auto hidden tabs will correctly get them to slide out KryptonDockingEdgeAutoHidden edge = group.GetParentType(typeof(KryptonDockingEdgeAutoHidden)) as KryptonDockingEdgeAutoHidden; if (edge != null) topForm.Focus(); } } return group; } } } } } } return null; }
/// <summary> /// Perform a switch from auto hidden group to docked cell for the visible pages inside the group. /// </summary> /// <param name="uniqueName">Unique name of page inside auto hidden group that needs switching.</param> /// <returns>KryptonDockingDockspace reference if a new dockspace needed to be created; otherwise false.</returns> public virtual KryptonDockingDockspace SwitchAutoHiddenGroupToDockedCellRequest(string uniqueName) { // Cannot switch a null reference if (uniqueName == null) throw new ArgumentNullException("uniqueName"); // Unique names cannot be zero length if (uniqueName.Length == 0) throw new ArgumentException("uniqueName cannot be zero length"); // Does the provided unique name exist and is in the required 'autohidden' state if (FindPageLocation(uniqueName) == DockingLocation.AutoHidden) { // Grab the auto hidden group docking element that we expect to contain the target unique name KryptonDockingAutoHiddenGroup autoHiddenGroup = (KryptonDockingAutoHiddenGroup)ExpectPageElement(uniqueName, typeof(KryptonDockingAutoHiddenGroup)); if (autoHiddenGroup != null) { // Find the sibling docked edge so we can add/restore pages KryptonDockingEdgeDocked edgeDocked = autoHiddenGroup.EdgeDockedElement; if (edgeDocked != null) { // Grab the set of visible pages in the auto hidden group KryptonPage[] visiblePages = autoHiddenGroup.VisiblePages(); if (visiblePages.Length > 0) { // Use events to determine which pages in the cell should be switched List<string> switchUniqueNames = new List<string>(); List<KryptonPage> switchPages = new List<KryptonPage>(); foreach (KryptonPage page in visiblePages) { CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowDocked)); OnPageDockedRequest(args); if (!args.Cancel) { switchUniqueNames.Add(page.UniqueName); switchPages.Add(page); } } // Any pages that actually need to be switched? if (switchPages.Count > 0) { using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Remove the pages from the auto hidden group string[] uniqueNames = switchUniqueNames.ToArray(); PropogateAction(DockingPropogateAction.RemovePages, uniqueNames); // Attempt to restore each page back to original location on the same edge List<KryptonPage> defaultPages = new List<KryptonPage>(); KryptonPage defaultSelectedPage = null; for(int i=0; i<switchPages.Count; i++) { // If we find a store page then we can simply restore straight back to that position bool? canRestore = edgeDocked.PropogateBoolState(DockingPropogateBoolState.ContainsStorePage, uniqueNames[i]); if (canRestore.HasValue && canRestore.Value) { // Restore page back into a dockspace edgeDocked.PropogateAction(DockingPropogateAction.RestorePages, new KryptonPage[] { switchPages[i] }); // Should this page become the selected and focused page? if (uniqueName == uniqueNames[i]) { // If this restored page was the selected page in the auto hidden group, make it selected in the dockspace KryptonDockingDockspace restoreElement = edgeDocked.FindPageElement(uniqueNames[i]) as KryptonDockingDockspace; if (restoreElement != null) { restoreElement.SelectPage(uniqueNames[i]); restoreElement.DockspaceControl.UpdateVisible(true); } } } else { defaultPages.Add(switchPages[i]); // Note the default page that should become selected if (uniqueName == uniqueNames[i]) defaultSelectedPage = switchPages[i]; } } // Remove any existing placeholders in all the docked edges RemoveControlStorePages(edgeDocked, uniqueNames, false, true); // Do we have some pages that still need adding? if (defaultPages.Count > 0) { // Place them all inside a new dockspace KryptonDockingDockspace newDockspace = edgeDocked.AppendDockspace(); newDockspace.Append(defaultPages.ToArray()); // Make sure the same page is selected as was selected in the auto hidden group if (defaultSelectedPage != null) { newDockspace.SelectPage(defaultSelectedPage.UniqueName); newDockspace.DockspaceControl.UpdateVisible(true); } return newDockspace; } } } } } } } return null; }
/// <summary> /// Perform the drop action associated with the target. /// </summary> /// <param name="screenPt">Position in screen coordinates.</param> /// <param name="data">Data to pass to the target to process drop.</param> /// <returns>Drop was performed and the source can perform any removal of pages as required.</returns> public override bool PerformDrop(Point screenPt, PageDragEndData data) { // Find our docking edge KryptonDockingEdge dockingEdge = null; switch (Edge) { case VisualOrientation.Left: dockingEdge = ControlElement["Left"] as KryptonDockingEdge; break; case VisualOrientation.Right: dockingEdge = ControlElement["Right"] as KryptonDockingEdge; break; case VisualOrientation.Top: dockingEdge = ControlElement["Top"] as KryptonDockingEdge; break; case VisualOrientation.Bottom: dockingEdge = ControlElement["Bottom"] as KryptonDockingEdge; break; } if (dockingEdge != null) { // Find the docked edge KryptonDockingEdgeDocked dockedEdge = dockingEdge["Docked"] as KryptonDockingEdgeDocked; if (dockingEdge != null) { KryptonDockingManager manager = dockedEdge.DockingManager; if (manager != null) { // Create a list of pages that are allowed to be transferred into the dockspace List<KryptonPage> transferPages = new List<KryptonPage>(); List<string> transferUniqueNames = new List<string>(); foreach (KryptonPage page in data.Pages) if (page.AreFlagsSet(KryptonPageFlags.DockingAllowDocked)) { // Use event to indicate the page is becoming docked and allow it to be cancelled CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(page.UniqueName, false); manager.RaisePageDockedRequest(args); if (!args.Cancel) { transferPages.Add(page); transferUniqueNames.Add(page.UniqueName); } } // Transfer valid pages into the new dockspace if (transferPages.Count > 0) { // Convert the incoming pages into store pages for restoring later manager.PropogateAction(DockingPropogateAction.StorePages, transferUniqueNames.ToArray()); // Create a new dockspace at the start of the list so it is closest to the control edge KryptonDockingDockspace dockspace = (_outsideEdge ? dockedEdge.InsertDockspace(0) : dockedEdge.AppendDockspace()); // Add pages into the target dockspace.Append(transferPages.ToArray()); return true; } } } } return false; }
/// <summary> /// Make the named page floating. /// </summary> /// <param name="uniqueName">Unique name of page to become floating.</param> public virtual void MakeFloatingRequest(string uniqueName) { // Cannot process a null reference if (uniqueName == null) throw new ArgumentNullException("uniqueName"); // Unique names cannot be zero length if (uniqueName.Length == 0) throw new ArgumentException("uniqueName cannot be zero length"); // If the named page exists and is not already floating if (ContainsPage(uniqueName) && (FindPageLocation(uniqueName) != DockingLocation.Floating)) { // If we can find a floating element appropriate for the named page KryptonDockingFloating floating = FindDockingFloating(uniqueName); if (floating != null) { KryptonPage page = PageForUniqueName(uniqueName); if (page != null) { // Ensure all docking controls have been layed out before the change is processed Application.DoEvents(); CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(uniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowFloating)); OnPageFloatingRequest(args); if (args.Cancel) return; using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the page to a placeholder so it can be returned to the same location PropogateAction(DockingPropogateAction.StorePages, new string[] { uniqueName }); // Is there a floating window with a restore page for the named page? KryptonDockingFloatingWindow restoreElement = floating.FloatingWindowForStorePage(uniqueName); if (restoreElement != null) { // Find the target cell and the index of the restore page KryptonWorkspaceCell cell = restoreElement.CellForPage(uniqueName); int pageIndex = cell.Pages.IndexOf(cell.Pages[uniqueName]); // Insert the page at the same index as the restore page restoreElement.FloatspaceElement.CellInsert(cell, pageIndex, new KryptonPage[] { page }); restoreElement.SelectPage(uniqueName); restoreElement.FloatingWindow.Select(); } else { // No floating window found to restore into, so create a new window KryptonDockingFloatingWindow floatingElement = floating.AddFloatingWindow(); floatingElement.FloatspaceElement.Append(new KryptonPage[] { page }); floatingElement.SelectPage(uniqueName); floatingElement.FloatingWindow.Show(); } } } } } }
internal void RaisePageFloatingRequest(CancelUniqueNameEventArgs e) { OnPageFloatingRequest(e); }
/// <summary> /// Make the named page navigator tabbed. /// </summary> /// <param name="uniqueName">Unique name of page to become navigator tabbed.</param> public virtual void MakeNavigatorRequest(string uniqueName) { // Cannot process a null reference if (uniqueName == null) throw new ArgumentNullException("uniqueName"); // Unique names cannot be zero length if (uniqueName.Length == 0) throw new ArgumentException("uniqueName cannot be zero length"); // If the named page exists and is not already navigator tabbed if (ContainsPage(uniqueName) && (FindPageLocation(uniqueName) != DockingLocation.Navigator)) { // If we can find a navigator element appropriate for the named page KryptonDockingNavigator navigatorElement = FindDockingNavigator(uniqueName); if (navigatorElement != null) { KryptonPage page = PageForUniqueName(uniqueName); if (page != null) { // Ensure all docking controls have been layed out before the change is processed Application.DoEvents(); CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(uniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowNavigator)); OnPageNavigatorRequest(args); if (args.Cancel) return; using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the page to a placeholder so it can be returned to the same location PropogateAction(DockingPropogateAction.StorePages, new string[] { uniqueName }); // If we can find an existing page in the target navigator with the name we are inserting KryptonDockableNavigator navigatorControl = navigatorElement.DockableNavigatorControl; KryptonPage insertPage = navigatorControl.Pages[uniqueName]; if (insertPage != null) { int pageIndex = navigatorControl.Pages.IndexOf(insertPage); if (pageIndex >= 0) { // Insert the page at the same index as the restore page navigatorControl.Pages.Insert(pageIndex, page); navigatorElement.SelectPage(uniqueName); navigatorControl.Select(); } else { // Append at end of current page collection navigatorControl.Pages.Add(page); navigatorElement.SelectPage(uniqueName); navigatorControl.Select(); } } } } } } }
internal void RaisePageNavigatorRequest(CancelUniqueNameEventArgs e) { OnPageNavigatorRequest(e); }
/// <summary> /// Make the named page auto hidden. /// </summary> /// <param name="uniqueName">Unique name of page to become auto hidden.</param> public virtual void MakeAutoHiddenRequest(string uniqueName) { // Cannot process a null reference if (uniqueName == null) throw new ArgumentNullException("uniqueName"); // Unique names cannot be zero length if (uniqueName.Length == 0) throw new ArgumentException("uniqueName cannot be zero length"); // If the named page exists and is not already auto hidden if (ContainsPage(uniqueName) && (FindPageLocation(uniqueName) != DockingLocation.AutoHidden)) { // If we can find an auto hidden edge element appropriate for the named page KryptonDockingEdgeAutoHidden autoHidden = FindDockingEdgeAutoHidden(uniqueName); if (autoHidden != null) { KryptonPage page = PageForUniqueName(uniqueName); if (page != null) { // Ensure all docking controls have been layed out before the change is processed Application.DoEvents(); CancelUniqueNameEventArgs args = new CancelUniqueNameEventArgs(uniqueName, !page.AreFlagsSet(KryptonPageFlags.DockingAllowAutoHidden)); OnPageAutoHiddenRequest(args); if (args.Cancel) return; using (DockingMultiUpdate update = new DockingMultiUpdate(this)) { // Convert the page to a placeholder so it can be returned to the same location PropogateAction(DockingPropogateAction.StorePages, new string[] { uniqueName }); // Is there a auto hidden group with a restore page for the named page? KryptonDockingAutoHiddenGroup restoreElement = autoHidden.FindStorePageElement(DockingLocation.AutoHidden, uniqueName) as KryptonDockingAutoHiddenGroup; if (restoreElement != null) { // Find the target index of the restore page KryptonAutoHiddenGroup control = restoreElement.AutoHiddenGroupControl; int pageIndex = control.Pages.IndexOf(control.Pages[uniqueName]); // Insert the page at the same index as the restore page control.Pages.Insert(pageIndex, new KryptonAutoHiddenProxyPage(page)); } else { // No existing store page so add as a new group restoreElement = autoHidden.AppendAutoHiddenGroup(); restoreElement.Append(new KryptonPage[] { page }); } } } } } }