Наследование: System.Windows.Forms.Panel
Пример #1
0
 internal DockWindowCollection(DockPanel dockPanel)
 {
     InnerList.Add(new DockWindow(dockPanel, DockState.Document));
     InnerList.Add(new DockWindow(dockPanel, DockState.DockLeft));
     InnerList.Add(new DockWindow(dockPanel, DockState.DockRight));
     InnerList.Add(new DockWindow(dockPanel, DockState.DockTop));
     InnerList.Add(new DockWindow(dockPanel, DockState.DockBottom));
 }
Пример #2
0
 internal AutoHidePaneCollection(DockPanel panel, DockState dockState)
 {
     m_dockPanel = panel;
     m_states = new AutoHideStateCollection();
     States[DockState.DockTopAutoHide].Selected = (dockState==DockState.DockTopAutoHide);
     States[DockState.DockBottomAutoHide].Selected = (dockState==DockState.DockBottomAutoHide);
     States[DockState.DockLeftAutoHide].Selected = (dockState==DockState.DockLeftAutoHide);
     States[DockState.DockRightAutoHide].Selected = (dockState==DockState.DockRightAutoHide);
 }
Пример #3
0
 /// <include file='CodeDoc/AutoHideStripVS2003.xml' path='//CodeDoc/Class[@name="AutoHideStripVS2003"]/Construct[@name="(DockPanel)"]/*'/>
 protected internal AutoHideStripVS2003(DockPanel panel)
     : base(panel)
 {
     SetStyle(ControlStyles.ResizeRedraw, true);
     SetStyle(ControlStyles.UserPaint, true);
     SetStyle(ControlStyles.AllPaintingInWmPaint, true);
     SetStyle(ControlStyles.DoubleBuffer, true);
     BackColor = Color.WhiteSmoke;
 }
Пример #4
0
        /// <include file='CodeDoc/AutoHideStripBase.xml' path='//CodeDoc/Class[@name="AutoHideStripBase"]/Construct[@name="(DockPanel)"]/*'/>
        protected internal AutoHideStripBase(DockPanel panel)
        {
            m_dockPanel = panel;
            m_panesTop = new AutoHidePaneCollection(panel, DockState.DockTopAutoHide);
            m_panesBottom = new AutoHidePaneCollection(panel, DockState.DockBottomAutoHide);
            m_panesLeft = new AutoHidePaneCollection(panel, DockState.DockLeftAutoHide);
            m_panesRight = new AutoHidePaneCollection(panel, DockState.DockRightAutoHide);

            SetStyle(ControlStyles.Selectable, false);
        }
Пример #5
0
        public AutoHideWindow(DockPanel dockPanel)
        {
            m_dockPanel = dockPanel;

            m_timerMouseTrack = new Timer();
            m_timerMouseTrack.Tick += new EventHandler(TimerMouseTrack_Tick);

            Visible = false;
            m_splitter = new AutoHideWindowSplitter();
            Controls.Add(m_splitter);
        }
Пример #6
0
 public static void LoadFromXml(DockPanel dockPanel, string filename, DeserializeDockContent deserializeContent)
 {
     FileStream fs = new FileStream(filename, FileMode.Open);
     try
     {
         LoadFromXml(dockPanel, fs, deserializeContent);
     }
     finally
     {
         fs.Close();
     }
 }
Пример #7
0
        internal DockWindow(DockPanel dockPanel, DockState dockState)
        {
            m_dockList = new DockList(this);
            m_dockPanel = dockPanel;
            m_dockState = dockState;
            Visible = false;

            SuspendLayout();

            if (DockState == DockState.DockLeft || DockState == DockState.DockRight ||
                DockState == DockState.DockTop || DockState == DockState.DockBottom)
            {
                m_splitter = new DockWindowSplitter();
                Controls.Add(m_splitter);
            }

            if (DockState == DockState.DockLeft)
            {
                Dock = DockStyle.Left;
                m_splitter.Dock = DockStyle.Right;
            }
            else if (DockState == DockState.DockRight)
            {
                Dock = DockStyle.Right;
                m_splitter.Dock = DockStyle.Left;
            }
            else if (DockState == DockState.DockTop)
            {
                Dock = DockStyle.Top;
                m_splitter.Dock = DockStyle.Bottom;
            }
            else if (DockState == DockState.DockBottom)
            {
                Dock = DockStyle.Bottom;
                m_splitter.Dock = DockStyle.Top;
            }
            else if (DockState == DockState.Document)
                Dock = DockStyle.Fill;

            ResumeLayout();
        }
Пример #8
0
        /// <include file='CodeDoc\DockContent.xml' path='//CodeDoc/Class[@name="DockContent"]/Method[@name="Show(DockPanel)"]/*'/>
        public void Show(DockPanel dockPanel)
        {
            if (dockPanel == null)
                throw(new ArgumentNullException(ResourceHelper.GetString("DockContent.Show.NullDockPanel")));

            if (DockState == DockState.Unknown)
                Show(dockPanel, DefaultShowState);
            else
                Activate();
        }
Пример #9
0
 public AutoHideStripBase CreateAutoHideStrip(DockPanel panel)
 {
     return new AutoHideStripVS2003(panel);
 }
Пример #10
0
 public static void SaveAsXml(DockPanel dockPanel, string filename, Encoding encoding)
 {
     FileStream fs = new FileStream(filename, FileMode.Create);
     try
     {
         SaveAsXml(dockPanel, fs, encoding);
     }
     finally
     {
         fs.Close();
     }
 }
Пример #11
0
        /// <exclude/>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                m_dockState = DockState.Unknown;

                if (DockListContainer != null)
                    DockListContainer.DockList.Remove(this);

                if (DockPanel != null)
                {
                    DockPanel.RemovePane(this);
                    m_dockPanel = null;
                }

                Splitter.Dispose();
                AutoHidePane.Dispose();
            }
            base.Dispose(disposing);
        }
Пример #12
0
 /// <include file='CodeDoc\FloatWindow.xml' path='//CodeDoc/Class[@name="FloatWindow"]/Constructor[@name="(DockPanel, DockPane, Rectangle)"]/*'/>
 public FloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
 {
     InternalConstruct(dockPanel, pane, true, bounds);
 }
Пример #13
0
 /// <include file='CodeDoc\FloatWindow.xml' path='//CodeDoc/Class[@name="FloatWindow"]/Constructor[@name="Overloads"]/*'/>
 /// <include file='CodeDoc\FloatWindow.xml' path='//CodeDoc/Class[@name="FloatWindow"]/Constructor[@name="(DockPanel, DockPane)"]/*'/>
 public FloatWindow(DockPanel dockPanel, DockPane pane)
 {
     InternalConstruct(dockPanel, pane, false, Rectangle.Empty);
 }
Пример #14
0
        private void InternalConstruct(DockPanel dockPanel, DockPane pane, bool boundsSpecified, Rectangle bounds)
        {
            if (dockPanel == null)
                throw(new ArgumentNullException(ResourceHelper.GetString("FloatWindow.Constructor.NullDockPanel")));

            m_dockList = new DockList(this);

            FormBorderStyle = FormBorderStyle.SizableToolWindow;
            ShowInTaskbar = false;

            SuspendLayout();
            if (boundsSpecified)
            {
                Bounds = bounds;
                StartPosition = FormStartPosition.Manual;
            }
            else
                StartPosition = FormStartPosition.WindowsDefaultLocation;

            m_dummyControl = new DummyControl();
            m_dummyControl.Bounds = Rectangle.Empty;
            Controls.Add(m_dummyControl);

            m_dockPanel = dockPanel;
            Owner = DockPanel.FindForm();
            DockPanel.AddFloatWindow(this);
            if (pane != null)
                pane.FloatWindow = this;

            ResumeLayout();
        }
Пример #15
0
 /// <exclude/>
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         if (DockPanel != null)
             DockPanel.RemoveFloatWindow(this);
         m_dockPanel = null;
     }
     base.Dispose(disposing);
 }
Пример #16
0
        /// <include file='CodeDoc\DockContent.xml' path='//CodeDoc/Class[@name="DockContent"]/Method[@name="Show(DockPanel, Rectangle)"]/*'/>
        public void Show(DockPanel dockPanel, Rectangle floatWindowBounds)
        {
            //			if (dockPanel == null)
            //				throw(new ArgumentNullException(ResourceHelper.GetString("DockContent.Show.NullDockPanel")));
            //
            //			DockPanel = dockPanel;
            //			if (FloatPane == null)
            //			{
            //				IsHidden = true;	// to reduce the screen flicker
            //				FloatPane = DockPanel.DockPaneFactory.CreateDockPane(this, DockState.Float, false);
            //				FloatPane.FloatWindow.StartPosition = FormStartPosition.Manual;
            //			}
            //
            //			FloatPane.FloatWindow.Bounds = floatWindowBounds;
            //
            //			Show(dockPanel, DockState.Float);
            //			Activate();
            DockPanel = dockPanel;
            IsHidden = true;
            if (FloatPane == null)
                Pane = DockPanel.DockPaneFactory.CreateDockPane(this, DockState.Float, true);
            else if (PanelPane == null)
            {
                DockPane paneExisting = null;
                foreach (DockPane pane in DockPanel.Panes)
                    if (pane.DockState == DockState.Float)
                    {
                        paneExisting = pane;
                        break;
                    }

                if (paneExisting == null)
                    Pane = DockPanel.DockPaneFactory.CreateDockPane(this, DockState.Float, true);
                else
                    Pane = paneExisting;
            }
            FloatPane.FloatWindow.StartPosition = FormStartPosition.Manual;
            FloatPane.FloatWindow.Bounds = floatWindowBounds;
            Activate();
        }
Пример #17
0
        /// <include file='CodeDoc\DockContent.xml' path='//CodeDoc/Class[@name="DockContent"]/Method[@name="Show(DockPanel, DockState)"]/*'/>
        public void Show(DockPanel dockPanel, DockState dockState)
        {
            if (dockPanel == null)
                throw(new ArgumentNullException(ResourceHelper.GetString("DockContent.Show.NullDockPanel")));

            if (dockState == DockState.Unknown || dockState == DockState.Hidden)
                throw(new ArgumentException(ResourceHelper.GetString("DockContent.Show.InvalidDockState")));

            DockPanel = dockPanel;

            if (dockState == DockState.Float && FloatPane == null)
                Pane = DockPanel.DockPaneFactory.CreateDockPane(this, DockState.Float, true);
            else if (PanelPane == null)
            {
                DockPane paneExisting = null;
                foreach (DockPane pane in DockPanel.Panes)
                    if (pane.DockState == dockState)
                    {
                        paneExisting = pane;
                        break;
                    }

                if (paneExisting == null)
                    Pane = DockPanel.DockPaneFactory.CreateDockPane(this, dockState, true);
                else
                    Pane = paneExisting;
            }

            DockState = dockState;
            Activate();
        }
Пример #18
0
 internal AutoHideTabCollection(DockPane pane)
 {
     m_dockPane = pane;
     m_dockPanel = pane.DockPanel;
 }
Пример #19
0
        private void InternalConstruct(DockContent content, DockState dockState, bool flagBounds, Rectangle floatWindowBounds, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
        {
            if (dockState == DockState.Hidden || dockState == DockState.Unknown)
                throw new ArgumentException(ResourceHelper.GetString("DockPane.DockState.InvalidState"));

            if (content == null)
                throw new ArgumentNullException(ResourceHelper.GetString("DockPane.Constructor.NullContent"));

            if (content.DockPanel == null)
                throw new ArgumentException(ResourceHelper.GetString("DockPane.Constructor.NullDockPanel"));

            SuspendLayout();
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.DoubleBuffer, true);
            SetStyle(ControlStyles.Selectable, true);

            m_isFloat = (dockState == DockState.Float);

            m_contents = new DockContentCollection();
            m_displayingContents = new DockContentCollection(this);
            m_tabs = new DockPaneTabCollection(this);
            m_dockPanel = content.DockPanel;
            m_dockPanel.AddPane(this);

            m_splitter = new DockPaneSplitter(this);

            m_nestedDockingStatus = new NestedDockingStatus(this);

            m_autoHidePane = DockPanel.AutoHidePaneFactory.CreateAutoHidePane(this);
            m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
            m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
            Controls.AddRange(new Control[] {	m_captionControl, m_tabStripControl	});

            if (flagBounds)
                FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
            else if (prevPane != null)
                AddToDockList(prevPane.DockListContainer, prevPane, alignment, proportion);

            SetDockState(dockState);
            if (show)
                content.Pane = this;
            else if (this.IsFloat)
                content.FloatPane = this;
            else
                content.PanelPane = this;

            ResumeLayout();
        }
Пример #20
0
 public void SetDropTarget(DockPanel dockPanel, DockStyle dock)
 {
     m_dropTo = dockPanel;
     m_dock = dock;
     m_contentIndex = -1;
 }
Пример #21
0
 public static void SaveAsXml(DockPanel dockPanel, string filename)
 {
     SaveAsXml(dockPanel, filename, Encoding.Unicode);
 }
Пример #22
0
 public DragHandler(DockPanel dockPanel)
 {
     m_dockPanel = dockPanel;
     m_dropTarget = new DropTarget();
 }
Пример #23
0
        public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding)
        {
            XmlTextWriter xmlOut = new XmlTextWriter(stream, encoding);

            // Use indenting for readability
            xmlOut.Formatting = Formatting.Indented;

            // Always begin file with identification and warning
            xmlOut.WriteStartDocument();
            xmlOut.WriteComment(" DockPanel configuration file. Author: Weifen Luo, all rights reserved. ");
            xmlOut.WriteComment(" !!! AUTOMATICALLY GENERATED FILE. DO NOT MODIFY !!! ");

            // Associate a version number with the root element so that future version of the code
            // will be able to be backwards compatible or at least recognise out of date versions
            xmlOut.WriteStartElement("DockPanel");
            xmlOut.WriteAttributeString("FormatVersion", ConfigFileVersion);
            xmlOut.WriteAttributeString("DockLeftPortion", dockPanel.DockLeftPortion.ToString(CultureInfo.InvariantCulture));
            xmlOut.WriteAttributeString("DockRightPortion", dockPanel.DockRightPortion.ToString(CultureInfo.InvariantCulture));
            xmlOut.WriteAttributeString("DockTopPortion", dockPanel.DockTopPortion.ToString(CultureInfo.InvariantCulture));
            xmlOut.WriteAttributeString("DockBottomPortion", dockPanel.DockBottomPortion.ToString(CultureInfo.InvariantCulture));
            xmlOut.WriteAttributeString("ActiveDocumentPane", dockPanel.Panes.IndexOf(dockPanel.ActiveDocumentPane).ToString());
            xmlOut.WriteAttributeString("ActivePane", dockPanel.Panes.IndexOf(dockPanel.ActivePane).ToString());

            // Contents
            xmlOut.WriteStartElement("Contents");
            xmlOut.WriteAttributeString("Count", dockPanel.Contents.Count.ToString());
            foreach (DockContent content in dockPanel.Contents)
            {
                xmlOut.WriteStartElement("Content");
                xmlOut.WriteAttributeString("ID", dockPanel.Contents.IndexOf(content).ToString());
                xmlOut.WriteAttributeString("PersistString", content.PersistString);
                xmlOut.WriteAttributeString("AutoHidePortion", content.AutoHidePortion.ToString(CultureInfo.InvariantCulture));
                xmlOut.WriteAttributeString("IsHidden", content.IsHidden.ToString());
                xmlOut.WriteAttributeString("IsFloat", content.IsFloat.ToString());
                xmlOut.WriteEndElement();
            }
            xmlOut.WriteEndElement();

            // Panes
            xmlOut.WriteStartElement("Panes");
            xmlOut.WriteAttributeString("Count", dockPanel.Panes.Count.ToString());
            foreach (DockPane pane in dockPanel.Panes)
            {
                xmlOut.WriteStartElement("Pane");
                xmlOut.WriteAttributeString("ID", dockPanel.Panes.IndexOf(pane).ToString());
                xmlOut.WriteAttributeString("DockState", pane.DockState.ToString());
                xmlOut.WriteAttributeString("ActiveContent", dockPanel.Contents.IndexOf(pane.ActiveContent).ToString());
                xmlOut.WriteStartElement("Contents");
                xmlOut.WriteAttributeString("Count", pane.Contents.Count.ToString());
                foreach (DockContent content in pane.Contents)
                {
                    xmlOut.WriteStartElement("Content");
                    xmlOut.WriteAttributeString("ID", pane.Contents.IndexOf(content).ToString());
                    xmlOut.WriteAttributeString("RefID", dockPanel.Contents.IndexOf(content).ToString());
                    xmlOut.WriteEndElement();
                }
                xmlOut.WriteEndElement();
                xmlOut.WriteEndElement();
            }
            xmlOut.WriteEndElement();

            // DockWindows
            xmlOut.WriteStartElement("DockWindows");
            int count = 0;
            foreach (DockWindow dw in dockPanel.DockWindows)
                if (dw.DockList.Count > 0)
                    count++;
            xmlOut.WriteAttributeString("Count", count.ToString());
            int i = 0;
            foreach (DockWindow dw in dockPanel.DockWindows)
            {
                if (dw.DockList.Count == 0)
                    continue;
                xmlOut.WriteStartElement("DockWindow");
                xmlOut.WriteAttributeString("ID", i.ToString());
                xmlOut.WriteAttributeString("DockState", dw.DockState.ToString());
                xmlOut.WriteAttributeString("ZOrderIndex", dockPanel.Controls.IndexOf(dw).ToString());
                xmlOut.WriteStartElement("DockList");
                xmlOut.WriteAttributeString("Count", dw.DockList.Count.ToString());
                foreach (DockPane pane in dw.DockList)
                {
                    xmlOut.WriteStartElement("Pane");
                    xmlOut.WriteAttributeString("ID", dw.DockList.IndexOf(pane).ToString());
                    xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString());
                    NestedDockingStatus status = pane.NestedDockingStatus;
                    xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PrevPane).ToString());
                    xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
                    xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
                    xmlOut.WriteEndElement();
                }
                xmlOut.WriteEndElement();
                xmlOut.WriteEndElement();
                i++;
            }
            xmlOut.WriteEndElement();

            // FloatWindows
            RectangleConverter rectConverter = new RectangleConverter();
            xmlOut.WriteStartElement("FloatWindows");
            xmlOut.WriteAttributeString("Count", dockPanel.FloatWindows.Count.ToString());
            foreach (FloatWindow fw in dockPanel.FloatWindows)
            {
                xmlOut.WriteStartElement("FloatWindow");
                xmlOut.WriteAttributeString("ID", dockPanel.FloatWindows.IndexOf(fw).ToString());
                xmlOut.WriteAttributeString("Bounds", rectConverter.ConvertToInvariantString(fw.Bounds));
                xmlOut.WriteAttributeString("AllowRedocking", fw.AllowRedocking.ToString());
                xmlOut.WriteAttributeString("ZOrderIndex", fw.DockPanel.FloatWindows.IndexOf(fw).ToString());
                xmlOut.WriteStartElement("DockList");
                xmlOut.WriteAttributeString("Count", fw.DockList.Count.ToString());
                foreach (DockPane pane in fw.DockList)
                {
                    xmlOut.WriteStartElement("Pane");
                    xmlOut.WriteAttributeString("ID", fw.DockList.IndexOf(pane).ToString());
                    xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString());
                    NestedDockingStatus status = pane.NestedDockingStatus;
                    xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PrevPane).ToString());
                    xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
                    xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
                    xmlOut.WriteEndElement();
                }
                xmlOut.WriteEndElement();
                xmlOut.WriteEndElement();
            }
            xmlOut.WriteEndElement();	//	</FloatWindows>

            xmlOut.WriteEndElement();
            xmlOut.WriteEndDocument();

            // This should flush all actions and close the file
            xmlOut.Close();
        }
Пример #24
0
 public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane)
 {
     return new FloatWindow(dockPanel, pane);
 }
Пример #25
0
        public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent)
        {
            if (dockPanel.Contents.Count != 0)
                throw new InvalidOperationException(ResourceHelper.GetString("DockPanel.LoadFromXml.AlreadyInitialized"));

            EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
            EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
            RectangleConverter rectConverter = new RectangleConverter();

            XmlTextReader xmlIn = new XmlTextReader(stream);
            xmlIn.WhitespaceHandling = WhitespaceHandling.None;
            xmlIn.MoveToContent();

            if (xmlIn.Name != "DockPanel")
                throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));

            string formatVersion = xmlIn.GetAttribute("FormatVersion");
            if (formatVersion != ConfigFileVersion)
                throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidFormatVersion"));
            DockPanelStruct dockPanelStruct = new DockPanelStruct();
            dockPanelStruct.DockLeftPortion = Convert.ToDouble(xmlIn.GetAttribute("DockLeftPortion"), CultureInfo.InvariantCulture);
            dockPanelStruct.DockRightPortion = Convert.ToDouble(xmlIn.GetAttribute("DockRightPortion"), CultureInfo.InvariantCulture);
            dockPanelStruct.DockTopPortion = Convert.ToDouble(xmlIn.GetAttribute("DockTopPortion"), CultureInfo.InvariantCulture);
            dockPanelStruct.DockBottomPortion = Convert.ToDouble(xmlIn.GetAttribute("DockBottomPortion"), CultureInfo.InvariantCulture);
            dockPanelStruct.IndexActiveDocumentPane = Convert.ToInt32(xmlIn.GetAttribute("ActiveDocumentPane"));
            dockPanelStruct.IndexActivePane = Convert.ToInt32(xmlIn.GetAttribute("ActivePane"));

            // Load Contents
            MoveToNextElement(xmlIn);
            if (xmlIn.Name != "Contents")
                throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
            int countOfContents = Convert.ToInt32(xmlIn.GetAttribute("Count"));
            ContentStruct[] contents = new ContentStruct[countOfContents];
            MoveToNextElement(xmlIn);
            for (int i=0; i<countOfContents; i++)
            {
                int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                if (xmlIn.Name != "Content" || id != i)
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));

                contents[i].PersistString = xmlIn.GetAttribute("PersistString");
                contents[i].AutoHidePortion = Convert.ToDouble(xmlIn.GetAttribute("AutoHidePortion"), CultureInfo.InvariantCulture);
                contents[i].IsHidden = Convert.ToBoolean(xmlIn.GetAttribute("IsHidden"));
                contents[i].IsFloat = Convert.ToBoolean(xmlIn.GetAttribute("IsFloat"));
                MoveToNextElement(xmlIn);
            }

            // Load Panes
            if (xmlIn.Name != "Panes")
                throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
            int countOfPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"));
            PaneStruct[] panes = new PaneStruct[countOfPanes];
            MoveToNextElement(xmlIn);
            for (int i=0; i<countOfPanes; i++)
            {
                int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                if (xmlIn.Name != "Pane" || id != i)
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));

                panes[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
                panes[i].IndexActiveContent = Convert.ToInt32(xmlIn.GetAttribute("ActiveContent"));
                panes[i].ZOrderIndex = -1;

                MoveToNextElement(xmlIn);
                if (xmlIn.Name != "Contents")
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
                int countOfPaneContents = Convert.ToInt32(xmlIn.GetAttribute("Count"));
                panes[i].IndexContents = new int[countOfPaneContents];
                MoveToNextElement(xmlIn);
                for (int j=0; j<countOfPaneContents; j++)
                {
                    int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                    if (xmlIn.Name != "Content" || id2 != j)
                        throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));

                    panes[i].IndexContents[j] = Convert.ToInt32(xmlIn.GetAttribute("RefID"));
                    MoveToNextElement(xmlIn);
                }
            }

            // Load DockWindows
            if (xmlIn.Name != "DockWindows")
                throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
            int countOfDockWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"));
            DockWindowStruct[] dockWindows = new DockWindowStruct[countOfDockWindows];
            MoveToNextElement(xmlIn);
            for (int i=0; i<countOfDockWindows; i++)
            {
                int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                if (xmlIn.Name != "DockWindow" || id != i)
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));

                dockWindows[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
                dockWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"));
                MoveToNextElement(xmlIn);
                if (xmlIn.Name != "DockList")
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
                int countOfDockList = Convert.ToInt32(xmlIn.GetAttribute("Count"));
                dockWindows[i].DockList = new DockListItem[countOfDockList];
                MoveToNextElement(xmlIn);
                for (int j=0; j<countOfDockList; j++)
                {
                    int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                    if (xmlIn.Name != "Pane" || id2 != j)
                        throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
                    dockWindows[i].DockList[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"));
                    dockWindows[i].DockList[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"));
                    dockWindows[i].DockList[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
                    dockWindows[i].DockList[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
                    MoveToNextElement(xmlIn);
                }
            }

            // Load FloatWindows
            if (xmlIn.Name != "FloatWindows")
                throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
            int countOfFloatWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"));
            FloatWindowStruct[] floatWindows = new FloatWindowStruct[countOfFloatWindows];
            MoveToNextElement(xmlIn);
            for (int i=0; i<countOfFloatWindows; i++)
            {
                int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                if (xmlIn.Name != "FloatWindow" || id != i)
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));

                floatWindows[i].Bounds = (Rectangle)rectConverter.ConvertFromInvariantString(xmlIn.GetAttribute("Bounds"));
                floatWindows[i].AllowRedocking = Convert.ToBoolean(xmlIn.GetAttribute("AllowRedocking"));
                floatWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"));
                MoveToNextElement(xmlIn);
                if (xmlIn.Name != "DockList")
                    throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
                int countOfDockList = Convert.ToInt32(xmlIn.GetAttribute("Count"));
                floatWindows[i].DockList = new DockListItem[countOfDockList];
                MoveToNextElement(xmlIn);
                for (int j=0; j<countOfDockList; j++)
                {
                    int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"));
                    if (xmlIn.Name != "Pane" || id2 != j)
                        throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
                    floatWindows[i].DockList[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"));
                    floatWindows[i].DockList[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"));
                    floatWindows[i].DockList[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
                    floatWindows[i].DockList[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
                    MoveToNextElement(xmlIn);
                }
            }
            xmlIn.Close();

            dockPanel.DockLeftPortion = dockPanelStruct.DockLeftPortion;
            dockPanel.DockRightPortion = dockPanelStruct.DockRightPortion;
            dockPanel.DockTopPortion = dockPanelStruct.DockTopPortion;
            dockPanel.DockBottomPortion = dockPanelStruct.DockBottomPortion;

            // Create Contents
            for (int i=0; i<contents.Length; i++)
            {
                DockContent content = deserializeContent(contents[i].PersistString);
                if (content == null)
                    content = new DummyContent();
                content.DockPanel = dockPanel;
                content.AutoHidePortion = contents[i].AutoHidePortion;
                content.IsHidden = true;
                content.IsFloat = contents[i].IsFloat;
            }

            // Create panes
            for (int i=0; i<panes.Length; i++)
            {
                DockPane pane = null;
                for (int j=0; j<panes[i].IndexContents.Length; j++)
                {
                    DockContent content = dockPanel.Contents[panes[i].IndexContents[j]];
                    if (j==0)
                        pane = dockPanel.DockPaneFactory.CreateDockPane(content, panes[i].DockState, false);
                    else if (panes[i].DockState == DockState.Float)
                        content.FloatPane = pane;
                    else
                        content.PanelPane = pane;
                }
            }

            // Assign Panes to DockWindows
            for (int i=0; i<dockWindows.Length; i++)
            {
                for (int j=0; j<dockWindows[i].DockList.Length; j++)
                {
                    DockWindow dw = dockPanel.DockWindows[dockWindows[i].DockState];
                    int indexPane = dockWindows[i].DockList[j].IndexPane;
                    DockPane pane = dockPanel.Panes[indexPane];
                    int indexPrevPane = dockWindows[i].DockList[j].IndexPrevPane;
                    DockPane prevPane = (indexPrevPane == -1) ? dw.DockList.GetDefaultPrevPane(pane) : dockPanel.Panes[indexPrevPane];
                    DockAlignment alignment = dockWindows[i].DockList[j].Alignment;
                    double proportion = dockWindows[i].DockList[j].Proportion;
                    pane.AddToDockList(dw, prevPane, alignment, proportion);
                    if (panes[indexPane].DockState == dw.DockState)
                        panes[indexPane].ZOrderIndex = dockWindows[i].ZOrderIndex;
                }
            }

            // Create float windows
            for (int i=0; i<floatWindows.Length; i++)
            {
                FloatWindow fw = null;
                for (int j=0; j<floatWindows[i].DockList.Length; j++)
                {
                    int indexPane = floatWindows[i].DockList[j].IndexPane;
                    DockPane pane = dockPanel.Panes[indexPane];
                    if (j == 0)
                        fw = dockPanel.FloatWindowFactory.CreateFloatWindow(dockPanel, pane, floatWindows[i].Bounds);
                    else
                    {
                        int indexPrevPane = floatWindows[i].DockList[j].IndexPrevPane;
                        DockPane prevPane = indexPrevPane == -1 ? null : dockPanel.Panes[indexPrevPane];
                        DockAlignment alignment = floatWindows[i].DockList[j].Alignment;
                        double proportion = floatWindows[i].DockList[j].Proportion;
                        pane.AddToDockList(fw, prevPane, alignment, proportion);
                        if (panes[indexPane].DockState == fw.DockState)
                            panes[indexPane].ZOrderIndex = floatWindows[i].ZOrderIndex;
                    }
                }
            }

            // sort DockContent by its Pane's ZOrder
            int[] sortedContents = null;
            if (contents.Length > 0)
            {
                sortedContents = new int[contents.Length];
                for (int i=0; i<contents.Length; i++)
                    sortedContents[i] = i;

                int lastDocument = contents.Length;
                for (int i=0; i<contents.Length - 1; i++)
                {
                    for (int j=i+1; j<contents.Length; j++)
                    {
                        DockPane pane1 = dockPanel.Contents[sortedContents[i]].Pane;
                        int ZOrderIndex1 = pane1 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane1)].ZOrderIndex;
                        DockPane pane2 = dockPanel.Contents[sortedContents[j]].Pane;
                        int ZOrderIndex2 = pane2 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane2)].ZOrderIndex;
                        if (ZOrderIndex1 > ZOrderIndex2)
                        {
                            int temp = sortedContents[i];
                            sortedContents[i] = sortedContents[j];
                            sortedContents[j] = temp;
                        }
                    }
                }
            }

            // show non-document DockContent first to avoid screen flickers
            for (int i=0; i<contents.Length; i++)
            {
                DockContent content = dockPanel.Contents[sortedContents[i]];
                if (content.Pane != null && content.Pane.DockState != DockState.Document)
                    content.IsHidden = contents[sortedContents[i]].IsHidden;
            }

            // after all non-document DockContent, show document DockContent
            for (int i=0; i<contents.Length; i++)
            {
                DockContent content = dockPanel.Contents[sortedContents[i]];
                if (content.Pane != null && content.Pane.DockState == DockState.Document)
                    content.IsHidden = contents[sortedContents[i]].IsHidden;
            }

            for (int i=0; i<panes.Length; i++)
                dockPanel.Panes[i].ActiveContent = panes[i].IndexActiveContent == -1 ? null : dockPanel.Contents[panes[i].IndexActiveContent];

            if (dockPanelStruct.IndexActiveDocumentPane != -1)
                dockPanel.Panes[dockPanelStruct.IndexActiveDocumentPane].Activate();

            if (dockPanelStruct.IndexActivePane != -1)
                dockPanel.Panes[dockPanelStruct.IndexActivePane].Activate();

            for (int i=dockPanel.Contents.Count-1; i>=0; i--)
                if (dockPanel.Contents[i] is DummyContent)
                    dockPanel.Contents[i].Close();
        }
Пример #26
0
        private void Content_OnEndDrag(bool abort)
        {
            User32.SetCursor(DragControl.Cursor.Handle);

            if (abort)
            {
                return;
            }

            DockContent content = ((DockPane)DragControl).ActiveContent;

            if (DropTarget.DropTo is DockPane)
            {
                DockPane paneTo = DropTarget.DropTo as DockPane;

                if (DropTarget.Dock == DockStyle.Fill)
                {
                    bool samePane = (content.Pane == paneTo);
                    if (!samePane)
                    {
                        content.Pane = paneTo;
                    }

                    if (DropTarget.ContentIndex == -1 || !samePane)
                    {
                        paneTo.SetContentIndex(content, DropTarget.ContentIndex);
                    }
                    else
                    {
                        DockContentCollection contents = paneTo.Contents;
                        int oldIndex = contents.IndexOf(content);
                        int newIndex = DropTarget.ContentIndex;
                        if (oldIndex < newIndex)
                        {
                            newIndex += 1;
                            if (newIndex > contents.Count - 1)
                            {
                                newIndex = -1;
                            }
                        }
                        paneTo.SetContentIndex(content, newIndex);
                    }

                    content.Activate();
                }
                else
                {
                    DockPane           pane      = content.DockPanel.DockPaneFactory.CreateDockPane(content, paneTo.DockState, true);
                    IDockListContainer container = paneTo.DockListContainer;
                    if (DropTarget.Dock == DockStyle.Left)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Left, 0.5);
                    }
                    else if (DropTarget.Dock == DockStyle.Right)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Right, 0.5);
                    }
                    else if (DropTarget.Dock == DockStyle.Top)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Top, 0.5);
                    }
                    else if (DropTarget.Dock == DockStyle.Bottom)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Bottom, 0.5);
                    }

                    pane.DockState = paneTo.DockState;
                    pane.Activate();
                }
            }
            else if (DropTarget.DropTo is DockPanel)
            {
                DockPane  pane;
                DockPanel dockPanel = content.DockPanel;
                if (DropTarget.Dock == DockStyle.Top)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockTop, true);
                }
                else if (DropTarget.Dock == DockStyle.Bottom)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockBottom, true);
                }
                else if (DropTarget.Dock == DockStyle.Left)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockLeft, true);
                }
                else if (DropTarget.Dock == DockStyle.Right)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockRight, true);
                }
                else if (DropTarget.Dock == DockStyle.Fill)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.Document, true);
                }
                else
                {
                    return;
                }

                pane.Activate();
            }
            else if (IsDockStateValid(DockState.Float))
            {
                Point ptMouse = Control.MousePosition;

                Size  size = FloatWindow.DefaultWindowSize;
                Point location;
                if (content.DockState == DockState.Document)
                {
                    location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
                }
                else
                {
                    location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y - size.Height);
                }

                if (ptMouse.X > location.X + size.Width)
                {
                    location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
                }

                DockPane pane = content.DockPanel.DockPaneFactory.CreateDockPane(content, new Rectangle(location, size), true);
                pane.Activate();
            }
        }
Пример #27
0
 internal DockPanelExtender(DockPanel dockPanel)
 {
     m_dockPanel = dockPanel;
 }
Пример #28
0
 public void SetDropTarget(DockPanel dockPanel, DockStyle dock)
 {
     m_dropTo       = dockPanel;
     m_dock         = dock;
     m_contentIndex = -1;
 }
Пример #29
0
 public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
 {
     return new FloatWindow(dockPanel, pane, bounds);
 }
Пример #30
0
 public DragHandler(DockPanel dockPanel)
 {
     m_dockPanel  = dockPanel;
     m_dropTarget = new DropTarget();
 }