Esempio n. 1
0
        public DockControl Open(Type type, object key, bool focus)
        {
            DockControl control;

            if (this.controls.TryGetControl(type, key, out control))
            {
                control.Open();
            }
            else
            {
                control = (DockControl)Activator.CreateInstance(type);
                DockControlSettings settings;
                if (!this.settingsTable.TryGetValue(type, out settings))
                {
                    settings = new DockControlSettings();
                    this.settingsTable.Add(type, settings);
                }
                control.Init(key, settings);
                control.Manager = this;
                if (control.ShowFloating)
                {
                    control.OpenFloating();
                }
                else
                {
                    DockContainer    dockContainer = this.FindDockContainer(control.DefaultDockLocation);
                    WindowOpenMethod openMethod    = focus ? WindowOpenMethod.OnScreenActivate : WindowOpenMethod.OnScreenSelect;
                    if (dockContainer == null)
                    {
                        control.OpenDocked(control.DefaultDockLocation, openMethod);
                    }
                    else
                    {
                        foreach (TD.SandDock.DockControl existingWindow in this.GetDockControls())
                        {
                            if (existingWindow != control && existingWindow.LayoutSystem.DockContainer == dockContainer)
                            {
                                control.DockNextTo(existingWindow);
                                ((TD.SandDock.DockControl)control).Open(openMethod);
                                break;
                            }
                        }
                    }
                }
                this.controls.Add(type, key, control);
            }
            return(control);
        }
Esempio n. 2
0
 public void OpenFloating(Rectangle bounds, WindowOpenMethod openMethod)
 {
     EnsureDockSystemContainerNotNull();
     Remove();
     MetaData.SaveFloatingWindowGuid(Guid.Empty);
     MetaData.FloatingState.Guid = Guid.Empty;
     FloatingLocation = bounds.Location;
     FloatingSize = bounds.Size;
     OpenFloating(openMethod);
 }
Esempio n. 3
0
		public void Float(SandDockManager manager, Rectangle bounds, WindowOpenMethod openMethod)
		{
		    if (Parent != null)
		        LayoutUtilities.smethod_10(this);
		    if (SelectedControl.MetaData.LastFloatingWindowGuid == Guid.Empty)
		        SelectedControl.MetaData.SaveFloatingWindowGuid(Guid.NewGuid());
		    new FloatingContainer(manager, SelectedControl.MetaData.LastFloatingWindowGuid)
			{
				LayoutSystem = 
				{
					LayoutSystems = 
					{
						this
					}
				}
			}.method_19(bounds, true, openMethod == WindowOpenMethod.OnScreenActivate);

		    if (openMethod == WindowOpenMethod.OnScreenActivate)
		        SelectedControl.Activate();
		}
Esempio n. 4
0
        public void OpenFloating(WindowOpenMethod openMethod)
        {
            EnsureDockSystemContainerNotNull();
            method_8();
            if (DockSituation == DockSituation.Floating)
                return;

            Rectangle rectangle_ = method_11();
            Remove();
            ControlLayoutSystem controlLayoutSystem = LayoutUtilities.smethod_4(Manager, DockSituation.Floating, MetaData.FloatingState);
            if (controlLayoutSystem != null)
            {
                controlLayoutSystem.Controls.Insert(Math.Min(MetaData.FloatingState.Int32_1, controlLayoutSystem.Controls.Count), this);
                if (openMethod != WindowOpenMethod.OnScreen)
                {
                    method_12(openMethod == WindowOpenMethod.OnScreenActivate);
                }
                return;
            }
            FloatingContainer @class = Manager.FindFloatingDockContainer(MetaData.LastFloatingWindowGuid);
            if (@class != null)
            {
                Struct0 @struct = LayoutUtilities.smethod_15(@class, MetaData.FloatingState.Int32_0);
                controlLayoutSystem = @struct.SplitLayout.DockContainer.CreateNewLayoutSystem(this, MetaData.FloatingState.Size);
                if (MetaData.FloatingState.Guid == Guid.Empty)
                {
                    MetaData.FloatingState.Guid = Guid.NewGuid();
                }
                controlLayoutSystem.Guid = MetaData.FloatingState.Guid;
                @struct.SplitLayout.LayoutSystems.Insert(@struct.Index, controlLayoutSystem);
                return;
            }
            if (MetaData.LastFloatingWindowGuid == Guid.Empty)
            {
                MetaData.SaveFloatingWindowGuid(Guid.NewGuid());
            }
            @class = new FloatingContainer(Manager, MetaData.LastFloatingWindowGuid);
            controlLayoutSystem = @class.CreateNewLayoutSystem(this, MetaData.FloatingState.Size);
            if (MetaData.FloatingState.Guid == Guid.Empty)
            {
                MetaData.FloatingState.Guid = Guid.NewGuid();
            }
            controlLayoutSystem.Guid = MetaData.FloatingState.Guid;
            @class.LayoutSystem.LayoutSystems.Add(controlLayoutSystem);
            @class.method_19(rectangle_, true, openMethod == WindowOpenMethod.OnScreenActivate);
        }
Esempio n. 5
0
        public void OpenDocument(WindowOpenMethod openMethod)
        {
            EnsureDockSystemContainerNotNull();
            method_8();
            if (DockSituation == DockSituation.Document)
                return;

            Remove();
            ControlLayoutSystem controlLayoutSystem = LayoutUtilities.smethod_4(Manager, DockSituation.Document, MetaData.DocumentState);
            if (controlLayoutSystem != null)
            {
                controlLayoutSystem.Controls.Insert(Math.Min(MetaData.DockedState.Int32_1, controlLayoutSystem.Controls.Count), this);
                if (openMethod != WindowOpenMethod.OnScreen)
                {
                    method_12(openMethod == WindowOpenMethod.OnScreenActivate);
                }
                return;
            }
            DockContainer dockContainer = Manager.FindDockContainer(ContainerDockLocation.Center) ?? Manager.CreateNewDockContainer(ContainerDockLocation.Center, ContainerDockEdge.Inside, MetaData.DockedContentSize);
            controlLayoutSystem = LayoutUtilities.FindControlLayoutSystem(dockContainer);
            if (controlLayoutSystem == null)
            {
                controlLayoutSystem = dockContainer.CreateNewLayoutSystem(this, MetaData.DocumentState.Size);
                dockContainer.LayoutSystem.LayoutSystems.Add(controlLayoutSystem);
            }
            else if (Manager.DocumentOpenPosition != DocumentContainerWindowOpenPosition.First)
            {
                controlLayoutSystem.Controls.Add(this);
            }
            else
            {
                controlLayoutSystem.Controls.Insert(0, this);
            }
            if (openMethod != WindowOpenMethod.OnScreen)
            {
                method_12(openMethod == WindowOpenMethod.OnScreenActivate);
            }
        }
Esempio n. 6
0
        public void OpenDocked(ContainerDockLocation dockLocation, WindowOpenMethod openMethod)
        {
            if (dockLocation == ContainerDockLocation.Center)
            {
                OpenDocument(openMethod);
                return;
            }
            EnsureDockSystemContainerNotNull();
            if (DockSituation == DockSituation.Docked && MetaData.LastFixedDockSide == dockLocation)
                return;

            Remove();
            MetaData.SaveFixedDockSide(dockLocation);
            MetaData.DockedState.Guid = Guid.Empty;
            MetaData.DockedState.Int32_0 = new int[0];
            OpenDocked(openMethod);
        }
Esempio n. 7
0
 public void OpenDocked(WindowOpenMethod openMethod)
 {
     EnsureDockSystemContainerNotNull();
     method_8();
     if (DockSituation == DockSituation.Docked)
         return;
     Remove();
     ControlLayoutSystem controlLayoutSystem = LayoutUtilities.smethod_4(Manager, DockSituation.Docked, MetaData.DockedState);
     if (controlLayoutSystem != null)
     {
         controlLayoutSystem.Controls.Insert(Math.Min(MetaData.DockedState.Int32_1, controlLayoutSystem.Controls.Count), this);
         if (openMethod != WindowOpenMethod.OnScreen)
         {
             method_12(openMethod == WindowOpenMethod.OnScreenActivate);
         }
         return;
     }
     Struct0 @struct = LayoutUtilities.smethod_14(Manager, MetaData);
     controlLayoutSystem = @struct.SplitLayout.DockContainer.CreateNewLayoutSystem(this, MetaData.DockedState.Size);
     if (MetaData.DockedState.Guid == Guid.Empty)
     {
         MetaData.DockedState.Guid = Guid.NewGuid();
     }
     controlLayoutSystem.Guid = MetaData.DockedState.Guid;
     @struct.SplitLayout.LayoutSystems.Insert(@struct.Index, controlLayoutSystem);
     if (openMethod != WindowOpenMethod.OnScreen)
     {
         method_12(openMethod == WindowOpenMethod.OnScreenActivate);
     }
 }
Esempio n. 8
0
 public void Open(WindowOpenMethod openMethod)
 {
     EnsureDockSystemContainerNotNull();
     if (DockSituation == DockSituation.None)
     {
         switch (MetaData.LastOpenDockSituation)
         {
             case DockSituation.Docked:
                 OpenDocked(openMethod);
                 return;
             case DockSituation.Document:
                 OpenDocument(openMethod);
                 return;
             case DockSituation.Floating:
                 OpenFloating(openMethod);
                 return;
         }
     }
     if (openMethod != WindowOpenMethod.OnScreen)
     {
         method_12(openMethod == WindowOpenMethod.OnScreenActivate);
     }
 }