public DocumentNavigatorWindow(DockingManager manager)
     : this()
 {
     _manager = manager;
     Keyboard.AddKeyUpHandler(this, new KeyEventHandler(this.OnKeyUp));
     Keyboard.AddKeyDownHandler(this, new KeyEventHandler(this.OnKeyDown));
 }

        public DocumentFloatingWindow(DockingManager manager, DocumentContent content)
            : this(manager)
        {
            //create a new temporary pane
            FloatingDockablePane pane = new FloatingDockablePane(this);

            //setup window size
            Width = content.ContainerPane.ActualWidth;
            Height = content.ContainerPane.ActualHeight;

            //save current content position in container pane
            _previousPane = content.ContainerPane;
            _arrayIndexPreviousPane = _previousPane.Items.IndexOf(content);
            pane.SetValue(ResizingPanel.ResizeWidthProperty, _previousPane.GetValue(ResizingPanel.ResizeWidthProperty));
            pane.SetValue(ResizingPanel.ResizeHeightProperty, _previousPane.GetValue(ResizingPanel.ResizeHeightProperty));

            //remove content from container pane
            content.ContainerPane.RemoveContent(_arrayIndexPreviousPane);

            //add content to my temporary pane
            pane.Items.Add(content);

            //let templates access this pane
            HostedPane = pane;

            if (IsDocumentFloatingAllowed)
            {
                AllowsTransparency = false;
                WindowStyle = WindowStyle.ToolWindow;
                NotifyPropertyChanged("IsDocumentFloatingAllowed");
            }
        }

 public static DocumentContent GetDocumentContentByName(DockingManager dm, string fullname)
 {
     foreach (DocumentContent dc in dm.Documents)
     {
         if (dc.Tag.ToString().Contains(fullname))
             return dc;
     }
     return null;
 }

 public static TextEditor FindTextEditorByDocumentText(DockingManager dm, TextDocument dt)
 {
     foreach (DocumentContent dc in dm.Documents)
     {
         TextEditor te = Utils.AvalonEdit.GetTextEditorFromContent(dc.Content);
         if (te.Document.Equals(dt)) return te;
     }
     return null;
 }

        public DragPaneServices(DockingManager owner)
        {
            if (DesignerProperties.GetIsInDesignMode(owner))
                throw new NotSupportedException("DragPaneServices not valid in design mode");

            if (owner == null)
                throw new ArgumentNullException("owner");

            _owner = owner;
        }

 void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) {
     switch (connectionId)
     {
     case 1:
     this.dockManager = ((AvalonDock.DockingManager)(target));
     return;
     case 2:
     this.documentsHost = ((AvalonDock.DocumentPane)(target));
     return;
     }
     this._contentLoaded = true;
 }

        public void Load(DockingManager dockingManager)
        {
            var serializer = new XmlLayoutSerializer(dockingManager);
            serializer.LayoutSerializationCallback += (s, args) =>
            {
                args.Content = args.Content;
            };

            if (File.Exists(LayoutFileName))
            {
                serializer.Deserialize(LayoutFileName);
            }
        }

 public void LoadLayout(DockingManager dockingManager)
 {
     var layoutSerializer = new XmlLayoutSerializer(dockingManager);
     layoutSerializer.LayoutSerializationCallback += (s, e) =>
     {
         e.Content = Application.Current.MainWindow.FindName(e.Model.ContentId);
         //if (e.Model.ContentId == FileStatsViewModel.ToolContentId)
         //    e.Content = Workspace.This.FileStats;
         //else if (!string.IsNullOrWhiteSpace(e.Model.ContentId) &&
         //    File.Exists(e.Model.ContentId))
         //    e.Content = Workspace.This.Open(e.Model.ContentId);
     };
     layoutSerializer.Deserialize(LayoutConfigFile);
 }

        protected override void OnManagerChanged(DockingManager oldValue, DockingManager newValue)
        {
            if (oldValue != null)
            {
                oldValue.ActiveDocumentChanged -= new EventHandler(ActiveDocumentChanged);
            }

            if (newValue != null)
            {
                newValue.ActiveDocumentChanged += new EventHandler(ActiveDocumentChanged);
            }

            base.OnManagerChanged(oldValue, newValue);
        }

        public DockableFloatingWindow(DockingManager manager, DockableContent content)
            : this(manager)
        {

            //create a new temporary pane
            FloatingDockablePane pane = new FloatingDockablePane(this);

            //setup window size
            //Width = content.ContainerPane.ActualWidth;
            //Height = content.ContainerPane.ActualHeight;

            if (content.FloatingWindowSize.IsEmpty)
                content.FloatingWindowSize = new Size(content.ContainerPane.ActualWidth, content.ContainerPane.ActualHeight);
            
            Width = content.FloatingWindowSize.Width;
            Height = content.FloatingWindowSize.Height;

            //save current content position in container pane
            _previousPane = content.ContainerPane;
            _arrayIndexPreviousPane = _previousPane.Items.IndexOf(content);
            
            pane.Style = content.ContainerPane.Style;

            //remove content from container pane
            content.ContainerPane.RemoveContent(_arrayIndexPreviousPane);
            
            //add content to my temporary pane
            pane.Items.Add(content);

            //let templates access this pane
            HostedPane = pane;

            //Change state on contents
            IsDockableWindow = true;

            DocumentPane originalDocumentPane = _previousPane as DocumentPane;
            if (originalDocumentPane != null)
                originalDocumentPane.CheckContentsEmpty();
        }

        public WindowManager( RibbonBarPanel rib, StatusBar stat, DockPanel dock, DockingManager dockingManager )
        {
            RibbonBar = rib;
            StatusBar = stat;
            DockWindow = dock;
            DockingManager = dockingManager;
            //TabControl = tab;

            // TODO
            //var ribbonTab = new RibbonTabItem();
            //ribbonTab.Header = "ahoj";

            //var ribGroup = new RibbonGroup();
            //ribGroup.Caption = "Preprocessing";
            //ribbonTab.RibbonGroups.Add(ribGroup);

            //FIXME RibbonBar.Tabs.Add(ribbonTab);

            //var temp = new TabItem();
            //temp.Header = "Pokus";
            //var tabItems = TabControl.Items;

            // TODO: refactor -> RenderWindow
            //var wfh = new WindowsFormsHost();

            //RayCaster rc = new RayCaster();

            //OpenGLWindow glWindow = new OpenGLWindow();
            //glWindow.setRenderingMethod( rc );
            //lstGlWindows.Add( glWindow );

            //wfh.Child = lstGlWindows[ 0 ];

            //temp.Content = wfh;

            //TabControl.Items.Add( temp );
        }

        public FlyoutPaneWindow(DockingManager manager, DockableContent content)
            : this()
        {
            //create a new temporary pane
            _refPane = new FlyoutDockablePane(content);
            _dockingManager = manager;

            _winFormsHost = ReferencedPane.GetLogicalChildContained<WindowsFormsHost>();

            if (_winFormsHost != null)
            {
                AllowsTransparency = false;
            }

            this.Loaded += new RoutedEventHandler(FlyoutPaneWindow_Loaded);
        }

//.........这里部分代码省略.........
     this.DrawPolygonBtn.Checked += new System.Windows.RoutedEventHandler(this.DrawPolygonBtn_Checked);
     
     #line default
     #line hidden
     
     #line 60 "..\..\..\MainWindow.xaml"
     this.DrawPolygonBtn.Unchecked += new System.Windows.RoutedEventHandler(this.DrawPolygonBtn_Unchecked);
     
     #line default
     #line hidden
     return;
     case 32:
     this.RibbonDlgMgrGrp = ((Microsoft.Windows.Controls.Ribbon.RibbonGroup)(target));
     return;
     case 33:
     this.ToggleDlgBtn = ((Microsoft.Windows.Controls.Ribbon.RibbonButton)(target));
     
     #line 66 "..\..\..\MainWindow.xaml"
     this.ToggleDlgBtn.Click += new System.Windows.RoutedEventHandler(this.ToggleDlgBtn_Click);
     
     #line default
     #line hidden
     return;
     case 34:
     this.RibbonSpeechRecGrp = ((Microsoft.Windows.Controls.Ribbon.RibbonGroup)(target));
     return;
     case 35:
     this.ToggleSpeechBtn = ((Microsoft.Windows.Controls.Ribbon.RibbonButton)(target));
     
     #line 69 "..\..\..\MainWindow.xaml"
     this.ToggleSpeechBtn.Click += new System.Windows.RoutedEventHandler(this.ToggleSpeechBtn_Click);
     
     #line default
     #line hidden
     return;
     case 36:
     this.SimSpeechBtn = ((Microsoft.Windows.Controls.Ribbon.RibbonButton)(target));
     
     #line 70 "..\..\..\MainWindow.xaml"
     this.SimSpeechBtn.Click += new System.Windows.RoutedEventHandler(this.SimSpeechBtn_Click);
     
     #line default
     #line hidden
     return;
     case 37:
     this.dockManager = ((AvalonDock.DockingManager)(target));
     return;
     case 38:
     this.LayersPanel = ((AvalonDock.DockableContent)(target));
     return;
     case 39:
     this.tocGrid = ((System.Windows.Controls.Grid)(target));
     return;
     case 40:
     
     #line 84 "..\..\..\MainWindow.xaml"
     ((AvalonDock.DocumentPane)(target)).SelectionChanged += new System.Windows.Controls.SelectionChangedEventHandler(this.DocumentPane_SelectionChanged);
     
     #line default
     #line hidden
     return;
     case 41:
     this.MapPanel = ((AvalonDock.DocumentContent)(target));
     return;
     case 42:
     this.mapGrid = ((System.Windows.Controls.Grid)(target));
     return;
     case 43:
     this.LayoutPanel = ((AvalonDock.DocumentContent)(target));
     return;
     case 44:
     this.layoutGrid = ((System.Windows.Controls.Grid)(target));
     return;
     case 45:
     this.KinectCtrlPanel = ((AvalonDock.DockablePane)(target));
     return;
     case 46:
     this.ColorDisplayPanel = ((AvalonDock.DockableContent)(target));
     return;
     case 47:
     this.colorDisplay = ((System.Windows.Controls.Image)(target));
     return;
     case 48:
     this.skeletonCanvas = ((System.Windows.Controls.Canvas)(target));
     return;
     case 49:
     this.DepthDisplayPanel = ((AvalonDock.DockableContent)(target));
     return;
     case 50:
     this.depthDisplay = ((System.Windows.Controls.Image)(target));
     return;
     case 51:
     this.DevCtrlPanel = ((AvalonDock.DockablePane)(target));
     return;
     case 52:
     this.statusTB = ((System.Windows.Controls.TextBlock)(target));
     return;
     }
     this._contentLoaded = true;
 }

        /// <summary>
        /// Show the content ad floating window
        /// </summary>
        /// <param name="dockableWindow">True if the resulting floating window can the be re-docked to the docking manager.</param>
        public void ShowAsFloatingWindow(DockingManager manager, bool dockableWindow)
        {
            if (Manager != null && Manager != manager)
                throw new InvalidOperationException("Please remove the content from previous DockingManager (using the Close method)");

            //Manager = manager;

            if (manager == null)
            {
                if (dockableWindow &&
                    !CanExecuteCommand(DockableContentCommands.DockableFloatingWindow))
                    throw new InvalidOperationException("This operation can be executed in this state");
                if (!dockableWindow &&
                    !CanExecuteCommand(DockableContentCommands.FloatingWindow))
                    throw new InvalidOperationException("This operation can be executed in this state");
            }

            manager.Show(this, dockableWindow ? DockableContentState.DockableWindow : DockableContentState.FloatingWindow);
        }

 public static TextEditor[] GetListOfTextEditors(DockingManager dm)
 {
     List<TextEditor> ltes = new List<TextEditor>(dm.Documents.Count);
     //TextEditor[] tes = new TextEditor[dm.Documents.Count];
     for (int i = 0; i < dm.Documents.Count; i++)
     {
         var te = Utils.AvalonEdit.GetTextEditorFromContent((dm.Documents[i] as DocumentContent).Content);
         if (te != null) ltes.Add(te);
         //tes[i] = te;
     }
     return ltes.ToArray();
 }

 /// <summary>
 /// Provides derived classes an opportunity to handle changes to the Manager property.
 /// </summary>
 protected virtual void OnManagerChanged(DockingManager oldValue, DockingManager newValue)
 {
 }

        /// <summary>
        /// Show <see cref="DocumentContent"/> as tabbed document inside the provided <see cref="DockingManager"/>
        /// </summary>
        /// <param name="manager">Docking manager target</param>
        /// <param name="showAsFloatingWindow">True if document should be shown inside a floating window (<see cref="DocumentFloatingWindow"/>)</param>
        public void Show(DockingManager manager, bool showAsFloatingWindow)
        {
            if (Manager != null && Manager != manager)
                throw new InvalidOperationException("Please remove the content from previous DockingManager (using the Close method)");

            if (!CanExecuteCommand(ManagedContentCommands.Show))
                throw new InvalidOperationException("This operation can be executed in this state");

            manager.Show(this, showAsFloatingWindow);

            manager.Documents.Add(this);
        }

 internal OverlayWindow(DockingManager manager)
 {
     _manager = manager;
 }

 public static void MoveFirstDocumentToEnd(DockingManager dm)
 {
     var buf = dm.MainDocumentPane.Items[0];
     dm.MainDocumentPane.Items.Remove(buf);
     dm.MainDocumentPane.Items.Add(buf);
 }

 public EditorProvider(DockingManager manager)
 {
     this.manager = manager;
 }