C# DockablePane.Focus方法代码示例

        internal void DropInto(DockablePane paneDragged, DockablePane paneToDropInto)
        {
            //transfer tha contents of dragged pane (conatined in a FloatingWindow)
            //to the pane which user select, taking care of setting contents state
            //to Dock (using Dock() method of class DockablePane).
            while (paneDragged.Items.Count > 0)
            {
                ManagedContent contentToTransfer = paneDragged.RemoveContent(0);
                paneToDropInto.Items.Add(contentToTransfer);


                DockableContent dockContentToTransfer = contentToTransfer as DockableContent;

                if (dockContentToTransfer != null)
                    dockContentToTransfer.SetStateToDock();
            }


            paneToDropInto.SelectedIndex = paneToDropInto.Items.Count - 1;
            paneToDropInto.Focus();
        }

        /// <summary>
        /// Autohides/redock a dockable pane
        /// </summary>
        /// <param name="pane">Pane to auto hide/redock</param>
        internal void ToggleAutoHide(DockablePane pane)
        {
            if (!_OnApplyTemplateFlag)
            {
                Debug.WriteLine("Layout has been restored before creating DockingManager object: force WPF to apply the template...");
                ApplyTemplate();
            }

            //if pane is in auto hide state then is found
            //referenced by a DockablePaneAnchorTabGroup
            //if so redock it in its original position
            if (RemovePaneFromTabGroups(pane))
            {
                #region Pane is present in tab anchor panels
                DockableContent selectedContent =
                    _flyoutWindow != null &&
                    _flyoutWindow.ReferencedPane != null &&
                    _flyoutWindow.ReferencedPane.Items.Count > 0 ? _flyoutWindow.ReferencedPane.Items[0] as DockableContent :
                    pane.Items[0] as DockableContent;

                HideFlyoutWindow();

                ResizingPanel parentPanel = pane.Parent as ResizingPanel;
                if (parentPanel != null && parentPanel.Children.Count >= 3)
                {
                    parentPanel.AdjustPanelSizes();
                }

                //reset content state to docked
                foreach (DockableContent content in pane.Items)
                {
                    content.SetStateToDock();
                }

                pane.Focus();
                pane.SelectedItem = selectedContent;
                ActiveContent = selectedContent;
                #endregion
            }
            else
            {
                #region Pane is not auto hidden
                //Create e new group
                DockablePaneAnchorTabGroup group = new DockablePaneAnchorTabGroup();

                //associate it to the pane
                group.ReferencedPane = pane;

                DockableContent selectedContent = pane.SelectedItem as DockableContent;

                //add contents to it
                foreach (DockableContent content in pane.Items)
                {
                    DockablePaneAnchorTab tab = new DockablePaneAnchorTab();
                    tab.ReferencedContent = content;
                    //tab.Anchor = pane.Anchor;
                    //tab.Icon = content.Icon;

                    group.Children.Add(tab);
                    content.SetStateToAutoHide();
                }

                //place group under correct anchor tabpanel
                switch (pane.Anchor)
                {
                    case AnchorStyle.Left:
                        if (_leftAnchorTabPanel != null)
                            _leftAnchorTabPanel.Children.Add(group);
                        break;
                    case AnchorStyle.Top:
                        if (_topAnchorTabPanel != null)
                            _topAnchorTabPanel.Children.Add(group);
                        break;
                    case AnchorStyle.Right:
                        if (_rightAnchorTabPanel != null)
                            _rightAnchorTabPanel.Children.Add(group);
                        break;
                    case AnchorStyle.Bottom:
                        if (_bottomAnchorTabPanel != null)
                            _bottomAnchorTabPanel.Children.Add(group);
                        break;
                }

                #endregion
            }

            //refresh arrangements traversing bottom-up visual tree
            FrameworkElement parentElement = pane.Parent as FrameworkElement;

            while (parentElement != null)
            {
                parentElement.InvalidateMeasure();
                parentElement = parentElement.Parent as FrameworkElement;
            }
        }

//.........这里部分代码省略.........
            //get a refernce to the resizingpanel container of relativePane
            ResizingPanel relativePaneContainer = LogicalTreeHelper.GetParent(relativePane) as ResizingPanel;
            Orientation requestedOrientation =
                (anchor == AnchorStyle.Bottom || anchor == AnchorStyle.Top) ? Orientation.Vertical : Orientation.Horizontal;

            if (relativePaneContainer == null)
            {
                Debug.Assert(relativePane.Parent == this);

                relativePaneContainer = new ResizingPanel();
                relativePaneContainer.Orientation = requestedOrientation;
                this.Content = relativePaneContainer;
                relativePaneContainer.Children.Add(relativePane);
            }

            Debug.Assert(relativePaneContainer != null, "By now we can't have a pane without a resizing panel containing it");

            #region Create and setup container panel
            if (relativePaneContainer != null)
            {
                //check if orientation is right
                if (relativePaneContainer.Orientation != requestedOrientation)
                {
                    //if the existing panel is not oriented as we want
                    //create a new one
                    ResizingPanel newPanel = new ResizingPanel();
                    newPanel.Orientation = requestedOrientation;

                    if (newPanel.Orientation == Orientation.Horizontal)
                        ResizingPanel.SetResizeHeight(newPanel, ResizingPanel.GetResizeHeight(relativePane));
                    else
                        ResizingPanel.SetResizeWidth(newPanel, ResizingPanel.GetResizeWidth(relativePane));

                    //replace relative pane in its' container panel
                    //with this new panel
                    int indexofRelativePane = relativePaneContainer.Children.IndexOf(relativePane);
                    relativePaneContainer.Children.Remove(relativePane);
                    relativePaneContainer.Children.Insert(indexofRelativePane, newPanel);

                    //now we have a panel correctly placed in the tree
                    newPanel.Children.Add(relativePane);
                    newPanel.InsertChildRelativeTo(
                        paneToAnchor, relativePane, anchor == AnchorStyle.Right || anchor == AnchorStyle.Bottom);

                    relativePaneContainer = newPanel;
                }
                else
                {
                    if (anchor == AnchorStyle.Left ||
                        anchor == AnchorStyle.Top)
                    {
                        //add new child before first (prepend)
                        relativePaneContainer.InsertChildRelativeTo(paneToAnchor,
                            relativePane, false);
                    }
                    else
                    {
                        //add new child after last (append)
                        relativePaneContainer.InsertChildRelativeTo(paneToAnchor,
                            relativePane, true);
                    }
                }


                relativePaneContainer.InvalidateMeasure();
            } 
            #endregion

            //than set the new anchor style for the pane
            paneToAnchor.Anchor = relativePane.Anchor;

            if (anchor == AnchorStyle.Left ||
                anchor == AnchorStyle.Right)
            {
                double w = Math.Min(
                    ResizingPanel.GetEffectiveSize(relativePane).Width / 2.0,
                    ResizingPanel.GetEffectiveSize(paneToAnchor).Width);
                ResizingPanel.SetResizeWidth(paneToAnchor, new GridLength(w, GridUnitType.Pixel));
                ResizingPanel.SetResizeHeight(paneToAnchor, new GridLength(1.0, GridUnitType.Star));
            }
            else
            {
                double h = Math.Min(
                    ResizingPanel.GetEffectiveSize(relativePane).Height / 2.0,
                    ResizingPanel.GetEffectiveSize(paneToAnchor).Height);
                ResizingPanel.SetResizeWidth(paneToAnchor, new GridLength(1.0, GridUnitType.Star));
                ResizingPanel.SetResizeHeight(paneToAnchor, new GridLength(h, GridUnitType.Pixel));
            }

            //refresh contents state
            foreach (DockableContent draggedContent in paneToAnchor.Items)
            {
                draggedContent.SetStateToDock();
            }

            if (relativePaneContainer != null)
                relativePaneContainer.AdjustPanelSizes();

            paneToAnchor.Focus();
        }