From d38d643a74d836f523c8ba402fd6c48aeea4fa97 Mon Sep 17 00:00:00 2001
From: cxl <cxl@f0d560ea-af0d-0410-9eb7-867de7ffcac7>
Date: Tue, 6 Sep 2011 06:29:05 +0000
Subject: [PATCH] bazaar: obsoleted DockCtrl moved to archive

git-svn-id: svn://ultimatepp.org/upp/trunk@3826 f0d560ea-af0d-0410-9eb7-867de7ffcac7
---
 archive/DockCtrl/AutoHideBar.cpp            |  226 +++
 archive/DockCtrl/ChangeLog.txt              |  115 ++
 archive/DockCtrl/DockCtrl.cpp               | 1419 +++++++++++++++++++
 archive/DockCtrl/DockCtrl.h                 | 1135 +++++++++++++++
 archive/DockCtrl/DockCtrl.lay               |   31 +
 archive/DockCtrl/DockCtrl.t                 |  999 +++++++++++++
 archive/DockCtrl/DockCtrl.upp               |   30 +
 archive/DockCtrl/DockTabs.cpp               |  890 ++++++++++++
 archive/DockCtrl/DockWindow.cpp             |  979 +++++++++++++
 archive/DockCtrl/DockableCtrl.cpp           |  246 ++++
 archive/DockCtrl/DockableCtrl.iml           |  114 ++
 archive/DockCtrl/PaneFrame.cpp              |  666 +++++++++
 archive/DockCtrl/PaneSplitter.cpp           |  161 +++
 archive/DockCtrl/READMEFIRST.txt            |    5 +
 archive/DockCtrl/TODO.txt                   |   15 +
 archive/DockCtrl/icon.ico                   |  Bin 0 -> 6 bytes
 archive/DockCtrl/init                       |    6 +
 archive/DockCtrlExample/DockCtrlExample.h   |   48 +
 archive/DockCtrlExample/DockCtrlExample.lay |   12 +
 archive/DockCtrlExample/DockCtrlExample.upp |   16 +
 archive/DockCtrlExample/init                |    7 +
 archive/DockCtrlExample/main.cpp            |  211 +++
 22 files changed, 7331 insertions(+)
 create mode 100644 archive/DockCtrl/AutoHideBar.cpp
 create mode 100644 archive/DockCtrl/ChangeLog.txt
 create mode 100644 archive/DockCtrl/DockCtrl.cpp
 create mode 100644 archive/DockCtrl/DockCtrl.h
 create mode 100644 archive/DockCtrl/DockCtrl.lay
 create mode 100644 archive/DockCtrl/DockCtrl.t
 create mode 100644 archive/DockCtrl/DockCtrl.upp
 create mode 100644 archive/DockCtrl/DockTabs.cpp
 create mode 100644 archive/DockCtrl/DockWindow.cpp
 create mode 100644 archive/DockCtrl/DockableCtrl.cpp
 create mode 100644 archive/DockCtrl/DockableCtrl.iml
 create mode 100644 archive/DockCtrl/PaneFrame.cpp
 create mode 100644 archive/DockCtrl/PaneSplitter.cpp
 create mode 100644 archive/DockCtrl/READMEFIRST.txt
 create mode 100644 archive/DockCtrl/TODO.txt
 create mode 100644 archive/DockCtrl/icon.ico
 create mode 100644 archive/DockCtrl/init
 create mode 100644 archive/DockCtrlExample/DockCtrlExample.h
 create mode 100644 archive/DockCtrlExample/DockCtrlExample.lay
 create mode 100644 archive/DockCtrlExample/DockCtrlExample.upp
 create mode 100644 archive/DockCtrlExample/init
 create mode 100644 archive/DockCtrlExample/main.cpp

diff --git a/archive/DockCtrl/AutoHideBar.cpp b/archive/DockCtrl/AutoHideBar.cpp
new file mode 100644
index 000000000..aa8116ab6
--- /dev/null
+++ b/archive/DockCtrl/AutoHideBar.cpp
@@ -0,0 +1,226 @@
+#include "DockCtrl.h"
+
+AutoHideBar& AutoHideBar::Attach(DockableCtrl& ctrl)
+{
+	DockWindow& c = reinterpret_cast<DockWindow&>(ctrl);
+	TabInterface::Add(c.SetOwnerBar(this));
+	childcount++;
+	ShowBar();
+	active = -1;
+	return *this;
+}
+
+void AutoHideBar::Detach(DockableCtrl& ctrl)
+{
+	DockWindow& c = reinterpret_cast<DockWindow&>(ctrl);
+	active = TabInterface::Find(ctrl);
+	if(tabs.GetCount() == 1) 
+	{
+		CloseAll();
+		HideBar();
+	}
+	else Close(active);
+	childcount--;
+	c.SetOwnerBar(NULL);
+	HideWindow();
+}
+
+DockableCtrl* AutoHideBar::GetChild(int position)
+{
+	int i = Find(position);
+	if(i >= 0 && i < this->GetTabs().GetCount())
+		return GetTabs().At(i).dock;
+	return NULL;
+}
+
+int AutoHideBar::GetCount()
+{
+	return childcount;
+}
+
+void AutoHideBar::ShowWindow()
+{
+	DockWindow* hiddenwindow = reinterpret_cast<DockWindow*>(tabs[active].dock);
+	if(!hiddenwindow->IsOpen())
+	{
+		Size s  = hiddenwindow->GetSizeHint();
+		Rect r  = GetScreenRect();
+		Rect rr = r;	
+		switch(layout)
+		{
+			case LAYOUT_LEFT:
+				rr.left	= r.right;
+				s.cy = r.GetHeight();
+#if defined(PLATFORM_X11)				
+				rr.right += 1; 
+#endif
+				break;
+			case LAYOUT_TOP:
+				rr.top = r.bottom;
+				s.cx = r.GetWidth();
+#if defined(PLATFORM_X11)
+				rr.bottom += 1;
+#endif
+				break;
+			case LAYOUT_RIGHT:
+				rr.right = r.left;
+				s.cy = r.GetHeight();
+#if defined(PLATFORM_X11)
+				rr.left -= 1;
+#endif
+				break;
+			case LAYOUT_BOTTOM:
+				rr.bottom = r.top;
+				s.cx = r.GetWidth();
+#if defined(PLATFORM_X11)
+				rr.top -= 1;
+#endif
+				break;			
+				
+		}
+		popup.SetRect(rr);
+		popup.Add(hiddenwindow->SizePos());
+		hiddenwindow->Ctrl::Show();
+		popup.PopUp(GetOwner(), false, true, false, false);
+		ctrl = hiddenwindow;
+		Ctrl::ProcessEvents();
+		AdjustSize(rr, s);
+		Animate(popup, rr, GUIEFFECT_SLIDE);
+	}
+}
+
+void AutoHideBar::HideWindow()
+{
+	if(popup.IsOpen()) 
+		popup.Close();
+	if(ctrl)
+	{	
+		if(ctrl->IsChild()) 
+			ctrl->Remove();
+		ctrl = NULL;
+	}
+	active = -1;
+	highlight = -1;
+	Refresh();
+}
+
+void AutoHideBar::AdjustSize(Rect &r, const Size &sz)
+{
+	switch (layout) 
+	{
+	 	case LAYOUT_LEFT: 
+	 		r.right += sz.cx;
+	 		break;
+	 	case LAYOUT_TOP: 
+	 		r.bottom += sz.cy;
+	 		break;
+	 	case LAYOUT_RIGHT:
+	 		r.left -= sz.cx;
+	 		break;
+	 	case LAYOUT_BOTTOM:
+	 		r.top -= sz.cy;
+	 		break;
+	};		
+}
+
+void AutoHideBar::OnHighlight()
+{
+	DockableCtrl* hiddenwindow = NULL;
+	
+	if(highlight >= 0)
+		hiddenwindow = tabs[highlight].dock;
+	if(!hiddenwindow || hiddenwindow == ctrl)
+		return;
+	else if(ctrl)
+	{
+		if(hiddenwindow)
+		{
+			if(popup.IsOpen())
+				popup.Close();
+			ctrl->Remove();
+			ctrl = NULL;
+		}
+		else HideWindow();
+	}
+	if(hiddenwindow)
+	{
+		TabInterface::SetActiveTab(highlight);
+		ShowWindow();
+	}
+}
+
+void AutoHideBar::OnClose(int id, DockableCtrl& ctrl)
+{
+	ctrl.Shut();
+}
+
+void AutoHideBar::MouseMove(Point p, dword keysflags)
+{
+	TabInterface::MouseMove(p, keysflags);
+}
+
+void AutoHideBar::MouseEnter(Point p, dword keyflags)
+{
+	if (ctrl && ctrl->IsOpen()) KillTimeCallback(2);
+	TabInterface::MouseEnter(p, keyflags);
+}
+
+void AutoHideBar::MouseLeave()
+{
+	if (ctrl && ctrl->IsOpen())
+		KillSetTimeCallback(1000, THISBACK(HideWindow), 2);
+	TabInterface::MouseLeave();
+}
+
+void AutoHideBar::FrameAdd(Ctrl& parent)
+{
+	parent.Add(*this);
+}
+
+void AutoHideBar::FrameRemove()
+{
+	this->Ctrl::Remove();
+}
+
+void AutoHideBar::ShowBar()
+{
+	if(!size) SetSize(GetHeight() + 2);
+}
+
+void AutoHideBar::HideBar()
+{
+	if(size) SetSize(0);
+}
+
+AutoHideBar::AutoHideBar()
+{
+	internalname = "autohidebar";
+	ctrl = NULL;
+	SetStyle(DockCtrlChStyle::StyleDefault());
+	HasScrollBar(false);
+	HasButtons(false);
+	HasIcons(true);
+	Draggable(false);
+	SetSize(0);
+	childcount = 0;
+	
+	TabInterface::WhenHighlight = THISBACK(OnHighlight);
+	TabInterface::WhenClose		= THISBACK(OnClose);
+	
+	popup.WhenEnter = THISBACK2(MouseEnter, Point(0, 0), 0);
+	popup.WhenLeave = THISBACK(MouseLeave);
+}
+
+AutoHideBar::~AutoHideBar()
+{
+	ctrl = NULL;
+}
+
+void AutoHideBar::PopupWindow::ChildMouseEvent(Ctrl *child, int event, Point p, int zdelta, dword keyflags)
+{
+	if(event == MOUSELEAVE)
+		WhenLeave();
+	else if(event == MOUSEENTER) 
+		WhenEnter();
+	Ctrl::ChildMouseEvent(child, event, p, zdelta, keyflags);
+}
diff --git a/archive/DockCtrl/ChangeLog.txt b/archive/DockCtrl/ChangeLog.txt
new file mode 100644
index 000000000..fcfdd30f1
--- /dev/null
+++ b/archive/DockCtrl/ChangeLog.txt
@@ -0,0 +1,115 @@
+//==============================================================================================
+// DockCtrl: A dockable widget framework for U++
+// Author:	 Ismail YILMAZ
+//==============================================================================================
+
+
+[+] - new feature
+[-] - bugfix
+[*] - change
+
+Recent revisions are added to the current versions logs under date/time info.
+
+0.50
+	> First Public Beta - public release name DockCtrl DEV802b.1
+	> Package versioning is synchronised with the main Ultimate++ releases.
+	--------------------------------------------------------------------------------------------
+	+ full featured tabbed dock windows implemented.
+	  optional "Nested tabbing" (a complex, yet very easy to use tabbing mode) introduced.
+	  automatic tab alignment of tabbed windows is made optional.
+	+ autohide feature is implemented.
+	  "tabbed autohiding" introduced.
+	  animated window (Thanks to Mrjtuk).
+	+ introducing "Complex Dockable Framework" concept. namely, numereous and seperate
+	  DockCtrl can be nested in any standard U++ Ctrl derived class.
+	+ unified (mostly...) Chameleon structure "DockCtrlChStyle" added for easy customization.
+	+ internationalization support added. currentyl only Turkish and English languages are supported.
+	+ added settings menu
+	+ added SetLayout() method for easy instatiation of DockCtrl class.
+	+ self-explanatory example code is added to the package.
+	* DockPane helper class renamed to PaneFrame;
+	* removed Splitter ctrl code from DockPane and made into a seperate custom class PaneSplitter.
+	* control panel is heavily improved.
+	  from now on, control panel has full access and control over the docked windows.
+	- Fixed most of the sizing issues by adding size hint methods (see DockableCtrl.cpp).
+	- Many internal bugfix and cleanup.
+	
+0.51
+	> public release name DockCtrl DEV802b.2
+	--------------------------------------------------------------------------------------------
+2/19/2008
+	- fixed a nasty bug in TabWindow Detach() method which led to stack overflow error.
+	  (However, this feature is still in it'a alpha stage. So, it is experimental. There may very well
+	  be bugs... USE IT AT YOUR RISK!)
+	- fixed tab dragging bug which cause to trigger the StartWindowDrag() in tab frame's empty area.
+	- ResetLayout() method fixed and renamed to ResetWidgetLayout(). 
+	- the tabs and tabbed window title showed incorrect info(title, icon) in  "nested tabbing" mode
+	  and in "tabbed autohide" mede. this bug is fixed for both mode by adding 
+	  RefreshTabWindowLabel() method to TabWindow class.
+	- other internal and minor bugfixes.
+	* removed irrelevant packages from the assembly :) (remnants of my early experiments...)
+	* DockCtrlExample is added to the package. now the main package is named DockCtrl Dev802b.2
+	* default and enhanced background skins are polished. now they have more native look.
+
+2/20/2008
+	+ german translation added (Thanks to Masu).
+	- fixed "call by reference errors" under MingW 3.4.2 (Thanks to Masu)
+	- Tab text alignment, close button detection bugs and scrollbar separator line painting are fixed (Thank to Unodgs).
+	- fixed autohide bug which caused the framework fall into an infinite loop when trying to hide a 2+ level nested tabs.
+
+2/21/2008
+	* from now on, default U++ chameleon skins are used for painting the dragbar background (in default and enhanced style)
+	  namely, from now on system colors applies to the Dockctrl dragbar. used skin samples are as following: 
+	  default 	skin = drawed using default TabCtrl style.
+	  enhanced 	skin = drawed using default ToolBar style.
+	  classic	skin = no special draw action (uses current system background).   
+	+ tab repositioning for TabWindow and Autohide (using Ctrl + Left drag or with solely Middle Drag) added;  
+
+2/23/2008
+	+ added partial X11 support (only drag-n-drop at the moment) - thanks to Mrjtuk.
+	* from now on, tab drag-n-drop animation  has transparency effect.
+	- fixed a bug in tab animation which causes to set the active tab to the last tab in the list. now the tabs
+	  correctly set the cursour to the previously active tab if the dnd is cancelled.
+	- fixed a bug in tab animation transparency effect which causes pane's with more than 2 childs to draw the animation
+	  incorrectly.  
+	- Fixed a nasty bug in AlphaHighlight() function to crash the application when compiled under MingW (5.1.3) (Thanks to Masu) 
+	
+2/26/2008
+	+ X11 related dnd issues fixed. DockCtrl now has full X11 docking support (Tested On KUBUNTU).
+	+ Russian translation and more accurate layout file for control panel added to the source (Thanks to Anton).
+
+0.52
+	> public release name DockCtrl DEV803b.1
+	--------------------------------------------------------------------------------------------
+3/21/2008
+	+ added full serialization support.
+	+ added default/custom layout support.
+	* DockableCtrl class reworked (now it is more abstract); 
+	* TabWindow class reworked (no longer uses PaneSplitter() class to control child widgets).
+	* DockCtrl class renamed to DockBase class and added a more generic DockCtrl class.
+	* DockBase class derives from TopWindow. 
+	+ added	InitDockCtrl() method for widget initialization.
+	+ added InitCustomLayouts() method for planned "predefined" layout support.
+	+ added Tabify() method (with 1 overload) to simplify widget tabbing.
+	+ added DockFloat() method to DockableCtrl class.
+	+ added ShowDragBarButtons() method to DockWindow class.
+	+ added ForbidDragAndDrop()/PermitDragAndDrop() methods to DockableCtrl base widget class.
+	  dnd behaviour of each DockableCtrl derived widget can be controlled using this method pair. 
+	+ added layout group to the settings window.
+	+ added HotKey support for Settings window (default is CTRL + HOME).
+	+ added methods to control forbid/permit on window sides.
+	- numerous bugfixes, and improvements.
+
+3/22/2008
+	+ double clicking on a dragbar of a authidden dockwindow will cause it go into docked state.
+	+ added "stdsize" variable to the PaneFrame class.
+	+ added ShowXXXXPane() (X:left/top/right/bottom) public methods to the Dockbase class. 
+
+3/27/2008
+	+ added widget grouping (both predefined/default and user) support. 
+	+ added WidgetGroup() method and defined "%" operator for widget grouping.
+	+ added group manager to the settings window.
+	* tab window creation/managment mechanism changed.
+	
+	 
+	
\ No newline at end of file
diff --git a/archive/DockCtrl/DockCtrl.cpp b/archive/DockCtrl/DockCtrl.cpp
new file mode 100644
index 000000000..fc968ed61
--- /dev/null
+++ b/archive/DockCtrl/DockCtrl.cpp
@@ -0,0 +1,1419 @@
+#include "DockCtrl/DockCtrl.h"
+
+#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
+#define IMAGECLASS DockCtrlImages
+#include <Draw/iml.h>
+
+//===============================================
+// DockCtrl class:
+// Actual Framework.
+//===============================================
+
+DockCtrl::DockCtrl() : DockBase()
+{
+	ctrlinit = false;
+	AllowAll();
+}
+
+DockCtrl::~DockCtrl()
+{
+	ctrlinit = false;
+}
+
+void DockCtrl::State(int reason)
+{
+	if(reason == Ctrl::OPEN)
+	{
+		if(!ctrlinit)
+		{
+			InitFrameWork();
+			InitDockCtrl ();
+			InitDefaultLayout();
+			InitCustomLayouts();
+			InitFrameWorkSettings();
+			ctrlinit = true;
+		}
+	}
+}
+
+//===============================================
+// DockBase class:
+// A dockable widget framework base ctrl.
+//===============================================
+
+Ctrl& DockBase::Dock(DockableCtrl& ctrl)
+{
+    int alignment = ctrl.Alignment();
+    // Register ctrl.
+    ctrl.SetBase(this);
+	AddCtrlRecord(ctrl);
+	// Dock...
+     switch(alignment)
+   	{
+       		case DockableCtrl::DOCK_LEFT:
+          			GetPaneFrame(alignment).Attach(ctrl).Vert();
+  		 		break;  
+            case DockableCtrl::DOCK_TOP:
+                    GetPaneFrame(alignment).Attach(ctrl).Horz();
+                break;
+            case DockableCtrl::DOCK_RIGHT:
+                    GetPaneFrame(alignment).Attach(ctrl).Vert();
+                break;
+            case DockableCtrl::DOCK_BOTTOM:
+                    GetPaneFrame(alignment).Attach(ctrl).Horz();
+                break;
+             default:
+             	if(ctrl.IsFloating())
+             	{
+             		ctrl.CenterOwner();
+             		ctrl.SetSize(panesize);
+             		ctrl.FloatEx(Rect(0, 0, panesize.cx / 4, panesize.cy / 3));
+             		ctrl.NoCenter();
+             	}
+                break;
+   	}
+	RefreshPanel();
+	return *this;
+}
+
+DockableCtrl& DockBase::Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2)
+{
+	// Register Ctrls.
+	AddCtrlRecord(ctrl1);
+	AddCtrlRecord(ctrl2);
+	// By default (if not stated otherwise) create tabwindows from Left PaneFrame. 
+	TabWindow* tabwindow = GetPaneFrame(0).AddTabWindow();
+	ASSERT(tabwindow);
+	tabwindow->Attach(ctrl1);
+	tabwindow->Attach(ctrl2);
+	return (DockableCtrl&) *tabwindow;	
+}
+
+DockableCtrl& DockBase::Tabify(String groupname, DockableCtrl& ctrl1, DockableCtrl& ctrl2)
+{
+	return (DockableCtrl&) dynamic_cast<TabWindow&>(Tabify(ctrl1, ctrl2)).SetGroup(groupname);
+}
+
+DockableCtrl& DockBase::Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2, DockableCtrl& ctrl3, DockableCtrl& ctrl4)
+{
+	return Tabify(Tabify(ctrl1, ctrl2), Tabify(ctrl3, ctrl4));
+}
+
+DockableCtrl& DockBase::Tabify(String groupname, DockableCtrl& ctrl1, DockableCtrl& ctrl2, DockableCtrl& ctrl3, DockableCtrl& ctrl4)
+{
+	return (DockableCtrl&) dynamic_cast<TabWindow&>(Tabify(ctrl1, ctrl2, ctrl3, ctrl4)).SetGroup(groupname);
+}
+
+void DockBase::TabifyGroupAndDock(String groupname, int alignment)
+{
+	Dock(TabifyGroup(groupname).DockingStyle(alignment, DockableCtrl::STATE_SHOW));	
+}
+
+void DockBase::TabifyGroupAndAutoHide(String groupname, int alignment)
+{
+	Dock(TabifyGroup(groupname).DockingStyle(alignment, DockableCtrl::STATE_AUTO));	
+}
+
+void DockBase::TabifyGroupAndFloat(String groupname)
+{
+	Dock(TabifyGroup(groupname).DockFloat());	
+}
+
+DockableCtrl& DockBase::TabifyGroup(String name)
+{
+	DockableCtrl* ctrl = NULL;
+	Vector<int>& ids = groups.Get(name);
+	int ncount = ids.GetCount();
+	ASSERT(ncount);
+	TabWindow* tabwindow = GetPaneFrame(0).AddTabWindow();
+	ASSERT(tabwindow);
+	for(int i = 0; i < ncount; i++) tabwindow->Attach(*GetCtrlRecordFromId(ids[i])->ctrl);
+	tabwindow->SetGroup(name);
+	return (DockableCtrl&) *tabwindow;
+}
+
+DockBase& DockBase::WidgetGroup(String name)
+{
+	NewWidgetGroup(predefinedgroup = name);
+	return *this;
+}
+
+DockBase& DockBase::operator%(DockableCtrl& ctrl)
+{
+	int id = GetCtrlRecord(ctrl)->id;
+	if(!FindWidgetinGroup(predefinedgroup, id))	
+		AddWidgettoGroup(predefinedgroup, id);
+	return *this;
+}
+
+DockBase& DockBase::WidgetLayout(String name)
+{
+	NewWidgetLayout(predefinedgroup = name);
+	return *this;
+}
+
+DockBase& DockBase::operator/(DockableCtrl& ctrl)
+{
+	return *this;
+}
+
+void DockBase::DoDragAndDrop(DockableCtrl& ctrl, Point p, Size sz)
+{
+ 	for(int i = 0; i < 4; i++)
+    {   
+        for(int j = 0; j < 4; j++)
+        {
+         		if(i != j)
+        		{	 
+           	 		if(!GetPaneFrame(j).HasCtrlInRange(ctrl, p)) 
+           	 		{   
+           		   	 	GetPaneFrame(j).DnDSourceoutofRange(); 
+               	 		GetPaneFrame(j).DnDAnimate();
+            		}
+        		}
+        }
+       	if(GetPaneFrame(i).HasCtrlInRange(ctrl, p)) 
+       	{
+      	 	ctrl.SetDropTarget(i, ctrl.GetDropState());
+          	break;
+       	}
+    }
+}
+
+void DockBase::Attach(DockableCtrl& ctrl)
+{
+    GetPaneFrame(ctrl.Alignment()).Attach(ctrl);
+}
+
+void DockBase::Attach(DockableCtrl* ctrl)
+{
+    Attach(*ctrl);
+}
+
+void DockBase::Detach(DockableCtrl& ctrl)
+{
+    GetPaneFrame(ctrl.Alignment()).Detach(ctrl);
+}
+
+void DockBase::Detach(DockableCtrl* ctrl)
+{
+    Detach(*ctrl);
+}
+
+void DockBase::ShowLeftPane(bool b)
+{
+	if(b)	GetPaneFrame(PaneFrame::LEFT).ShowFrame();
+	else	GetPaneFrame(PaneFrame::LEFT).HideFrame();
+}
+
+void DockBase::ShowTopPane(bool b)
+{
+	if(b)	GetPaneFrame(PaneFrame::TOP).ShowFrame();
+	else	GetPaneFrame(PaneFrame::TOP).HideFrame();
+}
+
+void DockBase::ShowRightPane(bool b)
+{
+	if(b)	GetPaneFrame(PaneFrame::RIGHT).ShowFrame();
+	else	GetPaneFrame(PaneFrame::RIGHT).HideFrame();
+}
+
+void DockBase::ShowBottomPane(bool b)
+{
+	if(b)	GetPaneFrame(PaneFrame::BOTTOM).ShowFrame();
+	else	GetPaneFrame(PaneFrame::BOTTOM).HideFrame();
+}
+
+void DockBase::AllowAll()
+{
+	AllowedSides[0] = true;
+	AllowedSides[1] = true;
+	AllowedSides[2] = true;
+	AllowedSides[3] = true;
+}
+
+void DockBase::AllowLeft()
+{
+	AllowedSides[0] = true;
+	AllowedSides[1] = false;
+	AllowedSides[2] = false;
+	AllowedSides[3] = false;
+}
+
+void DockBase::AllowTop()
+{
+	AllowedSides[1] = true;
+	AllowedSides[0] = false;
+	AllowedSides[2] = false;
+	AllowedSides[3] = false;
+}
+
+void DockBase::AllowRight()
+{
+	AllowedSides[2] = true;
+	AllowedSides[0] = false;
+	AllowedSides[1] = false;
+	AllowedSides[3] = false;
+}
+
+void DockBase::AllowBottom()
+{
+	AllowedSides[3] = true;
+	AllowedSides[0] = false;
+	AllowedSides[1] = false;
+	AllowedSides[2] = false;
+}
+
+void DockBase::AllowLeftRight()
+{
+	AllowedSides[0] = true;
+	AllowedSides[2] = true;
+	AllowedSides[1] = false;
+	AllowedSides[3] = false;
+}
+
+void DockBase::AllowTopBottom()
+{
+	AllowedSides[1] = true;
+	AllowedSides[3] = true;
+	AllowedSides[0] = false;
+	AllowedSides[2] = false;
+}
+
+void DockBase::AllowLeftTop()
+{
+	AllowedSides[0] = true;
+	AllowedSides[1] = true;
+	AllowedSides[2] = false;
+	AllowedSides[3] = false;
+}
+
+void DockBase::AllowRightBottom()
+{
+	AllowedSides[2] = true;
+	AllowedSides[3] = true;
+	AllowedSides[0] = false;
+	AllowedSides[1] = false;
+}
+
+void DockBase::AllowLeftBottom()
+{
+	AllowedSides[0] = true;
+	AllowedSides[3] = true;
+	AllowedSides[1] = false;
+	AllowedSides[2] = false;
+}
+
+void DockBase::AllowTopRight()
+{
+	AllowedSides[1] = true;
+	AllowedSides[2] = true;
+	AllowedSides[0] = false;
+	AllowedSides[3] = false;
+}
+
+void DockBase::AllowNestedTabbing(bool b)
+{
+	tabsnested = b;
+	controlpanel.TabOptionNest <<= tabsnested;
+}
+
+void DockBase::ControlPanel()
+{
+    if(controlpanel.IsOpen()) return;
+    controlpanel.Open(GetTopWindow());
+   	RefreshGroups();
+    RefreshPanel(); 
+}
+
+void DockBase::OnPanelAction()
+{
+    CtrlRecord* ctrlrecord = GetCtrlRecordFromIndex(listtab.list.GetClickRow());
+    if(ctrlrecord) 
+    	ctrlrecord->ctrl->Menu();
+}
+
+void DockBase::RefreshPanel()
+{
+    if(!controlpanel.IsOpen() || !controlpanel.IsVisible()) return;
+    listtab.list.Clear();
+    for(int i = 0; i < GetCtrlRecords().GetCount(); i++) 
+    {
+        int 	alignment 	= 0;
+        bool 	tabbed		= false;
+        bool	floating	= false;
+		DockableCtrl* ctrl 	= GetCtrlRecordFromIndex(i)->ctrl;
+		if(ctrl->IsTabbed())
+		{
+			TabWindow* tabwindow = dynamic_cast<DockWindow*>(ctrl)->GetOwnerTab();
+			if(tabwindow) 
+			{
+				alignment = tabwindow->GetBaseTab()->Alignment();
+				floating = tabwindow->GetBaseTab()->IsAutoHidden();
+				tabbed = true;
+			}
+		}
+		else alignment = ctrl->Alignment();
+		String a, s;
+        switch(alignment)
+        {
+			case DockableCtrl::DOCK_LEFT:
+				a = t_("LEFT");
+                break;
+			case DockableCtrl::DOCK_TOP:
+                a = t_("TOP");
+            	break;
+            case DockableCtrl::DOCK_RIGHT:
+                a = t_("RIGHT");
+                break;
+            case DockableCtrl::DOCK_BOTTOM:
+                a = t_("BOTTOM");
+                break;
+            case DockableCtrl::DOCK_NONE:
+                if(ctrl->IsFloating() || tabbed)
+                a = t_("FLOATING");
+                else
+                a = t_("NONE");  	
+                break;     
+		}
+        switch(ctrl->State())
+        {
+            case DockableCtrl::STATE_SHOW:
+                s = t_("SHOWN");
+                break;
+            case DockableCtrl::STATE_HIDE:
+                s = t_("HIDDEN");
+                break;
+            case DockableCtrl::STATE_AUTO:
+                s = t_("AUTO HIDDEN");
+           		break;
+            case DockableCtrl::STATE_SHUT:
+                s = t_("SHUT");
+                break;
+            case DockableCtrl::STATE_TABBED:
+            	floating ?
+            	s = t_("AUTO HIDDEN")
+            	:
+                s = t_("TABBED");
+                break;
+        }
+  
+ 		listtab.list.Add(0, Format("%s",ctrl->GetLabel()), a, s, ctrl->Position());
+		listtab.list.SetCtrl(i, 0, (panelicons.At(i))->SetImage(ctrl->GetIcon().IsNullInstance() ? 
+                   DockCtrlImages::DefaultImage : ctrl->GetIcon()));
+      }
+   controlpanel.Refresh();
+}
+
+void DockBase::Serialize(Stream& s)
+{
+	String 	layout	= "CTRLSLAYOUTS";
+	String	group	= "CTRLGROUPS";
+	String 	settings = "DOCKCTRLSETTINGS";
+	int version = 1;	
+	int n = 0;
+	
+	s.Magic(1234765);
+	
+	if(s.IsStoring())
+	{
+		s / version;
+		SerializePlacement(s);
+		s / settings;
+		s % tabsicons;
+		s % tabsclose;
+		s % tabsautoalign;
+		s % tabsnested;
+		s % autohideicons;
+		s % autohideclose;
+		s / layoutindex;
+		s / skinindex;
+		s / hotkey;
+
+		s / layout;
+		//  Write Layouts.
+		n = layouts.GetCount();
+		s / n;
+		for(int i = 0; i < n; i++)
+		{
+			String key = layouts.GetKey(i);
+			String lay = layouts.Get(key);
+			s / key;
+			s / lay;
+		}
+		// Write Layout List.
+		n = controlpanel.layoutlist.GetCount();
+		s / n;
+		for(int i = 0; i < n; i++)
+		{
+			String lname = controlpanel.layoutlist.GetKey(i);
+			s / lname; 
+		}
+		
+		s / group;
+		// Write Groups.
+		//int j = predefinedgroups + 1;
+		n = groups.GetCount(); 
+		s / n;
+		for(int i = 0; i < n; i++)
+		{
+			String key 	= groups.GetKey(i);
+			Vector<int>& ids = groups.Get(key);
+			s / key;
+			ids.Serialize(s);	
+		}
+	}
+	else
+	{
+		n = 0;
+		s / version;
+		SerializePlacement(s);
+		s / settings;
+		s % tabsicons;
+		s % tabsclose;
+		s % tabsautoalign;
+		s % tabsnested;
+		s % autohideicons;
+		s % autohideclose;
+		s / layoutindex;
+		s / skinindex;
+		s / hotkey;
+		
+		s / layout;
+		// Read Layouts.
+		s / n;
+		for(int i = 0; i < n; i++)
+		{
+			String key, lay;
+			s / key;
+			s / lay;
+			layouts.FindAdd(key, lay);
+		}
+		// Read Layout List.
+		s / n;
+		for(int i = 0; i < n; i++)
+		{
+			String lname;
+			s / lname;
+			controlpanel.layoutlist.Add(lname);
+		}
+		s / group;
+		// Read Groups.
+		s / n;
+		for(int i = 0; i < n; i++)
+		{
+			String key;
+			Vector<int> ids;
+			ids.Clear();
+			s / key;
+			ids.Serialize(s);
+			groups.FindAdd(key, ids);
+		}
+		// Write Ctrl values.
+		controlpanel.TabOptionIcon 		<<= tabsicons;
+		controlpanel.TabOptionClose 	<<= tabsclose;
+		controlpanel.TabOptionNest		<<= tabsnested;
+		controlpanel.TabOptionAlignment <<= tabsautoalign;
+		controlpanel.AutoOptionIcon 	<<= autohideicons;
+		controlpanel.AutoOptionClose 	<<= autohideclose;
+		
+		controlpanel.layoutlist.SetIndex(layoutindex);
+		controlpanel.skinlist.SetIndex(skinindex);
+	}
+	s.Magic();
+}
+
+void DockBase::InitFrameWorkSettings()
+{
+	RefreshWidgetLayout();
+	SetSkin(skinindex);
+	SetWidgetLayout(layoutindex);
+}
+
+void DockBase::InitDefaultLayout()
+{
+	String name = t_("Default");
+	if(layouts.Find(name) < 0) NewWidgetLayout(name);
+	NewWidgetGroup(name);
+}
+
+void DockBase::SetSkin(int index)
+{
+	switch(index)
+	{
+		case 0: style = &(DockCtrlChStyle::StyleDefault()); 	break;
+		case 1:	style = &(DockCtrlChStyle::StyleClassic());		break;
+		case 2: style = &(DockCtrlChStyle::StyleEnhanced());	break;
+		default: break;
+	}
+
+	for(int i = 0; i < GetCtrlRecords().GetCount(); i++)
+		dynamic_cast<DockWindow*>(GetCtrlRecordFromIndex(i)->ctrl)->SetStyle(*style);        
+ 	for(int i = 0; i < GetTabWindowCount(); i++)
+ 		GetTabWindowFromIndex(i)->SetStyle(*style);
+}
+
+DockBase& DockBase::SetStyle(const DockCtrlChStyle::Style& s)
+{
+    style = &s; 
+    Refresh(); 
+    return *this;   
+}
+
+
+void DockBase::OnSelectSkin()
+{
+	int newindex = controlpanel.skinlist.GetIndex();
+	if(skinindex == newindex) return;
+	SetSkin(skinindex = newindex);
+}
+
+void DockBase::OnSelectLayout()
+{
+	int newindex = controlpanel.layoutlist.GetIndex();
+	if(layoutindex == newindex) return;
+	SetWidgetLayout(layoutindex = newindex);
+}
+
+void DockBase::InitFrameWork()
+{
+	panesize = GetSize();
+	int cx = panesize.cx / 4;
+	int cy = panesize.cy / 3;
+	
+	AddFrame(hide[0]);
+	AddFrame(hide[1]);
+	AddFrame(hide[2]);
+	AddFrame(hide[3]);
+
+	hide[0].SetLayout(DockCtrlCustomFrame::LAYOUT_LEFT);
+	hide[2].SetLayout(DockCtrlCustomFrame::LAYOUT_RIGHT);
+	hide[1].SetLayout(DockCtrlCustomFrame::LAYOUT_TOP);
+	hide[3].SetLayout(DockCtrlCustomFrame::LAYOUT_BOTTOM);	
+
+	AddFrame(pane[0]);
+	AddFrame(pane[2]);
+	AddFrame(pane[1]);
+	AddFrame(pane[3]);
+	
+	pane[0].SetLayout(this, PaneFrame::LEFT, cx);
+	pane[2].SetLayout(this, PaneFrame::RIGHT, cx);
+	pane[1].SetLayout(this, PaneFrame::TOP, cy);
+	pane[3].SetLayout(this, PaneFrame::BOTTOM, cy);
+}
+
+DockBase::DockBase()
+{
+	skinindex =	layoutindex = 0;
+	tabsicons =	tabsclose =	tabsautoalign = true;
+	tabsnested = false;
+	autohideicons =	autohideclose = true;
+	isready = false;
+    panesize.Clear();
+    LeftPos(0, 0).TopPos(0,0);
+	CtrlLayout(listtab);
+	CtrlLayout(grouptab);
+    CtrlLayout(controlpanel);
+   	controlpanel.CenterScreen().Sizeable().Zoomable().Title(t_("Settings"));
+    listtab.list.AddColumn();
+    listtab.list.AddColumn(t_("Window Title"));
+    listtab.list.AddColumn(t_("Alignment"));
+    listtab.list.AddColumn(t_("State"));
+    listtab.list.AddColumn(t_("Position"));
+    listtab.list.EvenRowColor();
+    listtab.list.SetLineCy(16);
+
+	grouptab.grouptree.MultiSelect();
+	controlpanel.panel.Add(listtab.SizePos(), t_("Status"));
+	controlpanel.panel.Add(grouptab.SizePos(), t_("Group Manager"));
+
+    controlpanel.skinlist.Add(0, String(t_("Default"))).Add(1, String(t_("Classic"))).Add(2, String(t_("Enhanced"))).SetIndex(skinindex);
+    controlpanel.skinlist.WhenAction 	= THISBACK(OnSelectSkin);
+    controlpanel.layoutlist.WhenAction	= THISBACK(OnSelectLayout);
+    listtab.list.WhenLeftClick 			= THISBACK(OnPanelAction); 
+    grouptab.grouptree.WhenDropInsert	= THISBACK(GroupDrop);
+    grouptab.grouptree.WhenDrag			= THISBACK(GroupDrag);
+    grouptab.grouptree.WhenBar			= THISBACK(GroupMenu);
+	grouptab.grouptree.WhenCursor		= THISBACK(GroupSelect);
+	   
+	grouptab.groupadd					<<= THISBACK(OnAddNewGroup);
+	grouptab.groupdelete				<<= THISBACK(OnDeleteGroup);
+    controlpanel.layoutbutton			<<= THISBACK(ResetWidgetLayout);
+	controlpanel.layoutadd				<<= THISBACK(OnAddNewLayout);
+	controlpanel.layoutdelete			<<= THISBACK(OnDeleteLayout);
+    controlpanel.TabOptionAlignment		<<= THISBACK(RefreshWidgetLayout);
+    controlpanel.TabOptionIcon			<<= THISBACK(RefreshWidgetLayout);
+    controlpanel.TabOptionClose			<<= THISBACK(RefreshWidgetLayout);
+    controlpanel.AutoOptionClose		<<= THISBACK(RefreshWidgetLayout);
+    controlpanel.AutoOptionIcon			<<= THISBACK(RefreshWidgetLayout);
+
+	controlpanel.TabOptionIcon 			<<= tabsicons;
+	controlpanel.TabOptionClose 		<<= tabsclose;
+	controlpanel.TabOptionNest			<<= tabsnested;
+	controlpanel.TabOptionAlignment	 	<<= tabsautoalign;
+
+	controlpanel.AutoOptionIcon 		<<= autohideicons;
+	controlpanel.AutoOptionClose 		<<= autohideclose;
+	
+	grouptab.groupdelete.Disable();
+	SetKey(K_CTRL_HOME);
+}
+
+DockBase::~DockBase()
+{
+ 	CleanUp();
+    panesize.Clear();
+}
+
+void DockBase::CleanUp()
+{
+	for(int i = 0; i < panelicons.GetCount(); i++)
+		delete panelicons.At(i);
+	for(int i = 0; i < layouts.GetCount(); i++)
+		layouts.Remove(i);
+	for(int i = 0; i < groups.GetCount(); i++)
+		groups.Remove(i);
+ 	RemoveTabWindows();
+    DeleteCtrlRecords();	
+}
+
+void DockBase::RefreshWidgetLayout()
+{
+	TabWindow* tabwindow = NULL;
+
+	tabsicons 		= (bool) controlpanel.TabOptionIcon.Get();
+	tabsclose		= (bool) controlpanel.TabOptionClose.Get();
+	tabsnested		= (bool) controlpanel.TabOptionNest.Get();
+	tabsautoalign	= (bool) controlpanel.TabOptionAlignment.Get();
+	autohideicons	= (bool) controlpanel.AutoOptionIcon.Get();
+	autohideclose	= (bool) controlpanel.AutoOptionClose.Get();	
+
+	int n = GetTabWindowCount();
+	for(int i = 0; i < n; i++)
+	{
+		tabwindow = GetTabWindowFromIndex(i);
+		if(tabsautoalign)
+		{
+			switch(tabwindow->GetBaseTab()->Alignment())
+			{
+       			case DockableCtrl::DOCK_LEFT:
+					tabwindow->SetLayout(DockCtrlCustomFrame::LAYOUT_RIGHT);  
+       				break;
+  	     		case DockableCtrl::DOCK_TOP:
+					tabwindow->SetLayout(DockCtrlCustomFrame::LAYOUT_BOTTOM);   
+       				break;
+    	   		case DockableCtrl::DOCK_RIGHT:
+					tabwindow->SetLayout(DockCtrlCustomFrame::LAYOUT_LEFT);  
+      	 			break;
+    	   		case DockableCtrl::DOCK_BOTTOM:
+					tabwindow->SetLayout(DockCtrlCustomFrame::LAYOUT_TOP);  
+       				break;   
+			}
+		}
+		else tabwindow->SetLayout(DockCtrlCustomFrame::LAYOUT_BOTTOM);
+		tabwindow->GetTabs().HasIcons(tabsicons);
+   		tabwindow->GetTabs().HasButtons(tabsclose);		
+	}
+	for(int i = 0; i < 4; i++) GetHideBar(i).HasButtons(autohideclose).HasIcons(autohideicons);
+}
+
+void DockBase::OnAddNewLayout()
+{
+	String name;
+	if(EditText(name, t_("Add new layout"), t_("Layout name:"), 32))
+	{
+		if(IsNull(name)) 
+		{
+			Exclamation(t_("You must enter a name for the new layout"));
+			return;
+		}
+		else if(layouts.Find(name) >= 0)
+		{
+			if(!PromptOKCancel(Format(t_("Layout '%s' adready exists. Do you want to overwrite it?"), name)))
+			return;
+		}
+		NewWidgetLayout(name);
+		RefreshPanel();
+	}
+}
+
+
+void DockBase::OnDeleteLayout()
+{
+	DelWidgetLayout(layouts.GetKey(layoutindex));	
+}
+
+void DockBase::AddCtrlRecord(DockableCtrl& ctrl)
+{
+	CtrlRecord* record 	= NULL;
+	if(GetCtrlRecord(ctrl) || ctrl.IsTabWindow()) return;
+	ctrls.Add((record = new CtrlRecord()));
+	if(record) 
+	{
+		record->ctrl = &ctrl;
+		record->id	 = ctrls.GetCount();
+		ImageCtrl* imagectrl = new ImageCtrl();
+    	panelicons.Add(imagectrl);
+ 	}
+}
+
+void DockBase::RemoveCtrlRecord(DockableCtrl& ctrl)
+{
+	CtrlRecord* record = GetCtrlRecord(ctrl);
+	if(record) delete record;
+}
+
+void DockBase::DeleteCtrlRecords()
+{
+	for(int i = 0; i < ctrls.GetCount(); i++)
+		delete ctrls.At(i);
+}
+
+DockBase::CtrlRecord* DockBase::GetCtrlRecord(DockableCtrl& ctrl)
+{
+	for(int i = 0; i < ctrls.GetCount(); i++)
+	{
+		CtrlRecord* record = ctrls.At(i);
+		if(record->ctrl == &ctrl) return record;
+	}	   
+	return NULL;
+}
+
+DockBase::CtrlRecord* DockBase::GetCtrlRecordFromIndex(int index)
+{
+	if(index >= 0 && index < ctrls.GetCount())
+		return ctrls.At(index);
+	return NULL;
+}
+
+DockBase::CtrlRecord* DockBase::GetCtrlRecordFromId(int id)
+{
+	for(int i = 0; i < ctrls.GetCount(); i++)
+	{
+		CtrlRecord* record = ctrls.At(i);
+		if(record->id == id) return record;
+	}
+	return NULL;
+}
+
+DockBase::CtrlRecord* DockBase::GetCtrlRecordFromGroup(String group)
+{
+	return NULL;
+}
+
+DockableCtrl* DockBase::GetDockedWindowFromIndex(int index)
+{
+	Vector<DockableCtrl*> docks;
+	docks.Clear();
+	for(int i = 0; i < 8; i++)
+	{
+		if(i < 4) 
+		{
+			int n = GetPaneFrame(i).GetCount();
+			if(n) for(int j = 0; j < n; j++) docks.Add(GetPaneFrame(i).GetChild(j + 1));
+		}
+		else
+		{
+			int n = GetHideBar(i - 4).GetCount();
+			if(n) for(int j = 0; j < n; j++) docks.Add(GetHideBar(i - 4).GetChild(j));
+		}
+	}
+	return docks.GetCount() ? docks.At(index) : NULL;
+}
+
+TabWindow* DockBase::GetTabWindowFromIndex(int index)
+{
+	TabWindow* tabwindow = tabwindows.At(index);
+	ASSERT(tabwindow);
+	return tabwindow;
+}
+
+int DockBase::GetTabWindowCount()
+{
+	return tabwindows.GetCount();
+}
+
+int DockBase::GetDockedWindowCount()
+{
+	int dockcount = 0;
+	for(int i = 0; i < 8; i++)
+		if(i < 4) dockcount += GetPaneFrame(i).GetCount();
+		else dockcount += GetHideBar(i - 4).GetCount();
+	return dockcount;
+}
+
+void DockBase::RemoveTabWindows()
+{
+	for(int i = 0 ; i < tabwindows.GetCount(); i++)
+		if(tabwindows.At(i)) delete tabwindows.At(i);	
+}
+
+void DockBase::RefreshTabWindowList()
+{
+	for(int i = 0; i < tabwindows.GetCount(); i++)
+		if(tabwindows.At(i)->IsDestroyed())
+		{
+			TabWindow *t = tabwindows.At(i);
+			tabwindows.Remove(i);
+			delete t;
+		}
+}
+
+Vector<TabWindow*>& DockBase::GetTabWindows()
+{
+	return tabwindows;
+}
+
+void DockBase::NewWidgetLayout(String name)
+{
+	StringStream s;
+	SerializeLayout(s);
+	int id = AddWidgetLayout(name);
+	layouts[id] = (String) s;
+}
+
+int DockBase::AddWidgetLayout(String name)
+{
+	int id = layouts.Find(name);
+	if(id < 0)
+	{
+		id = layouts.FindAdd(name, String());
+		controlpanel.layoutlist.Add(name);
+		int index = controlpanel.layoutlist.GetCount() - 1;
+		controlpanel.layoutlist.SetIndex(layoutindex = index);		
+	}
+	return id;
+}
+
+void DockBase::AddWidgetLayout(String name, DockableCtrl& ctrl, int alignment, int state, int position)
+{
+	
+}
+
+void DockBase::DelWidgetLayout(String name)
+{
+	int id = layouts.Find(name);
+	if(id < 0) return;
+	if(PromptOKCancel(Format(t_("Do you really want to delete layout '%s'"), name)))
+	{
+		layouts.RemoveKey(name);
+		controlpanel.layoutlist.Remove(id);
+		id--;
+		controlpanel.layoutlist.SetIndex(layoutindex = id);
+	}
+}
+
+void DockBase::SetWidgetLayout(String name)
+{
+	int id = layouts.Find(name);
+	if(id < 0) return;
+	SetWidgetLayout(id);
+}
+
+void DockBase::SetWidgetLayout(int index)
+{
+	if(layoutindex != index) controlpanel.layoutlist.SetIndex(layoutindex = index);
+	if(index == 0) 	controlpanel.layoutdelete.Disable();
+	else controlpanel.layoutdelete.Enable();
+	
+	String key = layouts.GetKey(index);
+	String& layout = layouts.Get(key);
+	StringStream s(layout);
+	s.SetLoading();
+	SerializeLayout(s);
+}
+
+void DockBase::SerializeLayout(Stream& s, bool deflay)
+{
+	CtrlRecord* record	= NULL;
+	DockableCtrl* ctrl	= NULL;
+	TreeCtrl& tree		= grouptab.grouptree;	
+	String  name;
+	int		panesize	= 0;
+	int 	type 		= 0;
+	int 	alignment	= 0;
+	int 	state		= 0;
+	int 	position	= 0;
+	int 	id			= 0;
+	int 	childcount	= 0;
+	Size	childsize;
+	
+		if(s.IsStoring())
+		{
+			// Remove unused TabWindows (BugFix).
+			RefreshTabWindowList();
+			// Write Tabbing mode.
+			s % tabsnested;
+			// Write Widgets.
+			// Write Docked (shown or hidden) and AutoHidden widgets.
+			childcount = GetDockedWindowCount();
+			s / childcount;
+			if(childcount)
+				for(int i = 0; i < childcount; i++)
+				{
+					ctrl = GetDockedWindowFromIndex(i);
+					ASSERT(ctrl);
+					ctrl->Serialize(s);
+				}
+			// Write PaneFrame sizes.
+			for(int i = 0; i < 4; i++)  
+			{
+				panesize = GetPaneFrame(i).GetSize();
+				s / panesize;
+			}
+			childcount = 0;
+			int ctrlscount = ctrls.GetCount();
+			// Write Floating Dockwindows.
+			for(int i = 0; i < ctrlscount * 2; i++)
+			{
+				if(i < ctrlscount) childcount += GetCtrlRecordFromIndex(i)->ctrl->IsFloating() ? 1 : 0;
+				if(i >= ctrlscount) 
+				{
+					if(i == ctrlscount) s / childcount;
+					ctrl = GetCtrlRecordFromIndex(i - ctrlscount)->ctrl;
+					ASSERT(ctrl);
+					if(ctrl->IsFloating()) ctrl->Serialize(s);
+				}
+			}
+			childcount = 0;
+			// Write Floating TabWindows.
+			int tabwindowcount = GetTabWindowCount();
+			if(tabwindowcount)
+				for(int i = 0; i < tabwindowcount * 2; i++)
+				{
+					if(i <  tabwindowcount) childcount += GetTabWindowFromIndex(i)->IsFloating() ? 1 : 0;
+					if(i >= tabwindowcount)
+					{
+						if(i == tabwindowcount) s / childcount;
+						TabWindow* tabwindow = GetTabWindowFromIndex(i - tabwindowcount);
+						ASSERT(tabwindow);
+						if(tabwindow->IsFloating()) tabwindow->Serialize(s);
+					}
+				}
+		}
+
+		if(s.IsLoading())
+		{
+			childcount = 0;
+			// Close All widgets.
+			for(int i = 0; i < GetTabWindowCount(); i++)	GetTabWindowFromIndex(i)->DetachAll();
+			for(int i = 0; i < ctrls.GetCount(); i++) 		GetCtrlRecordFromIndex(i)->ctrl->Shut();
+			// Remove unused TabWindows (BugFix).
+			RefreshTabWindowList();
+			// Read Tabbing Mode
+			s % tabsnested;
+			controlpanel.TabOptionNest <<= tabsnested;
+			// Read Docked (shown or hidden) and AutoHidden widgets.
+			s / childcount;
+			if(childcount)
+				for(int i = 0; i < childcount; i++)
+				{
+					s / type / id;
+					if(type == DockableCtrl::TYPE_DOCKWINDOW)
+						GetCtrlRecordFromId(id)->ctrl->Serialize(s);
+					if(type == DockableCtrl::TYPE_TABWINDOW)
+						GetPaneFrame(0).AddTabWindow()->Serialize(s);
+				}
+			// Read PaneFrame sizes.
+			for(int i = 0; i < 4; i++)
+			{
+				s / panesize;
+				GetPaneFrame(i).SetSize(panesize);
+			}
+			childcount = 0;
+			s / childcount;
+			if(childcount)
+				for(int i = 0; i < childcount; i++)
+				{
+					s / type / id;
+					GetCtrlRecordFromId(id)->ctrl->Serialize(s);
+				}
+			
+			childcount = 0;
+			s / childcount;
+			if(childcount)
+				for(int j = 0; j < childcount; j++)
+				{
+					s / type / id;
+					TabWindow* tabwindow = GetPaneFrame(0).AddTabWindow();
+					tabwindow->Serialize(s);
+				}
+		}		
+		s.Close();
+}
+
+void DockBase::ResetWidgetLayout()
+{
+	controlpanel.layoutlist.SetIndex(layoutindex = 0);
+	SetWidgetLayout(layoutindex);
+	RefreshPanel();
+}
+
+void DockBase::NewWidgetGroup(String name, bool predefined)
+{
+	predefined  = true;
+	TreeCtrl& tree = grouptab.grouptree;
+	Vector<int> ids;
+	ids.Clear();
+	int group = groups.FindAdd(name, ids);
+	if(tree.Find(name) < 0) tree.Add(0, DockCtrlImages::DefaultImage(), Value(name));
+
+	if(name != t_("Default")) return; 
+	for(int i = 0; i < ctrls.GetCount(); i++)
+	{
+		DockableCtrl * ctrl = ctrls[i]->ctrl;
+		int id	= ctrls[i]->id;
+		ids.Add(ctrls[i]->id);
+		tree.Add(tree.Find(name), ctrl->GetIcon(), Value(id), Value(ctrl->GetLabel()));
+	}
+	groups[group] = ids;
+}
+
+bool DockBase::AddWidgettoGroup(String name, DockableCtrl& ctrl)
+{
+	CtrlRecord* record = GetCtrlRecord(ctrl);
+	if(!record || name == t_("Default")) return false;
+	NewWidgetGroup(name);
+	Vector<int>& ids = groups.Get(name);
+	for(int i = 0; i < ids.GetCount(); i++)
+	if(ids[i] == record->id)
+	{
+		Exclamation(Format(t_("Error: Widget (%s) is already in the group '%s'"), ctrl.GetLabel(), name));
+		return false;
+	}
+	ids.Add(record->id);
+	grouptab.grouptree.Add(grouptab.grouptree.Find(name), ctrl.GetIcon(), Value(record->id), Value(ctrl.GetLabel()));
+	return true;
+}
+
+bool DockBase::AddWidgettoGroup(String name, int id)
+{
+	CtrlRecord* record = GetCtrlRecordFromId(id);
+	if(!record) return false;
+	return AddWidgettoGroup(name, *record->ctrl);
+}
+
+bool DockBase::DeleteWidgetfromGroup(String name, DockableCtrl& ctrl)
+{
+	CtrlRecord* record = GetCtrlRecord(ctrl);
+	if(groups.Find(name) < 0 || name == t_("Default") || !record) return false;
+	Vector<int>& ids = groups.Get(name);
+	for(int i = 0; i < ids.GetCount(); i++) if(record->id == ids[i]) ids.Remove(i);
+	return true;
+}
+
+bool DockBase::DeleteWidgetfromGroup(String name, int id)
+{
+	CtrlRecord* record = GetCtrlRecordFromId(id);
+	if(!record) return false;
+	return DeleteWidgetfromGroup(name, *record->ctrl);	
+}
+
+int DockBase::AddWidgetGroup(String name)
+{
+	return 1;
+}
+
+void DockBase::DeleteWidgetGroup(String name)
+{
+	TreeCtrl& tree = grouptab.grouptree;
+	if(name == t_("Default")) return;
+	if(PromptOKCancel(Format(t_("Do you really want to delete group '%s'"), name)))
+	{
+		groups.RemoveKey(name);
+		int id = tree.Find(name);
+		if(id >= 0) 
+		{
+			tree.RemoveChildren(id);
+			tree.Remove(id);
+		}
+		tree.Refresh();
+	}
+	
+}
+
+Vector<int>& DockBase::FindWidgetGroup(String name)
+{
+	return groups.Get(name);
+}
+
+bool DockBase::FindWidgetinGroup(String name, int id)
+{
+	Vector<int>& ids = FindWidgetGroup(name);
+	for(int i = 0; i < ids.GetCount(); i++)
+		if(ids[i] == id) return true;
+	return false;
+}
+
+void DockBase::OnAddNewGroup()
+{
+	String name;
+	if(EditText(name, t_("Add new group"), t_("Group name:"), 32))
+	{
+		if(IsNull(name)) 
+		{
+			Exclamation(t_("You must enter a name for the new group"));
+			return;
+		}
+		else if(groups.Find(name) >= 0)
+		{
+			if(!PromptOKCancel(Format(t_("Group '%s' adready exists. Do you want to overwrite it?"), name)))
+			return;
+		}
+		NewWidgetGroup(name);
+		RefreshPanel();
+	}
+}
+
+void DockBase::OnDeleteGroup()
+{
+	TreeCtrl& tree = grouptab.grouptree;
+	int id = tree.GetCursor();
+	if(id == 0) return;
+	DeleteWidgetGroup(tree.GetValue(tree.GetCursor()));
+}
+
+void DockBase::GroupDrop(int parent, int ii, PasteClip& d)
+{
+	if (parent == 0) return d.Reject();
+
+	TreeCtrl& tree = grouptab.grouptree;
+	int p = tree.GetParent(parent);
+	if (p != 0)	parent = p;
+	
+	if(AcceptInternal<TreeCtrl>(d, "DockCtrlGroupTreeDrag")) 
+	{
+		Vector<int> sel = tree.GetSel();
+		for (int i = 0; i < sel.GetCount(); i++) 
+		{
+
+			int id = tree.Get(sel[i]);
+			String group = (String) tree.GetValue(parent);
+			if(group == t_("Default") || FindWidgetinGroup(group, id)) 
+				return d.Reject();
+			AddWidgettoGroup(group, id);
+			tree.Open(parent);
+		}
+		return;
+	}
+	tree.SetFocus();
+}
+
+void DockBase::GroupDrag()
+{
+	TreeCtrl& tree = grouptab.grouptree;
+	int idc = -1;
+	if (tree.GetCursor() >= 0 && tree.GetParent(tree.GetCursor()) <= 0)
+		return;
+	if(tree.DoDragAndDrop(InternalClip(tree, "DockCtrlGroupTreeDrag"), tree.GetDragSample()) == DND_MOVE)
+	{
+		int parent = tree.GetParent(tree.GetCursor());
+		idc = tree.GetCursor();
+		String name = tree.GetValue(idc);
+		String group = (String) tree.GetValue(parent);
+		int id = tree.Get(idc);
+		if(DeleteWidgetfromGroup(group, id)) tree.Remove(idc);
+	}
+	tree.Refresh();
+}
+
+void DockBase::GroupSelect()
+{
+	TreeCtrl& tree = grouptab.grouptree;
+	int root = tree.GetCursor();
+	if(root < 0) return;
+	int id = tree.GetParent(root);
+	String group = (String) tree.GetValue(root);
+	grouptab.groupdelete.Enable(id == 0 && group != t_("Default"));
+}
+
+void DockBase::RefreshGroups()
+{
+	TreeCtrl& tree = grouptab.grouptree;
+	tree.Clear();
+	tree.SetRoot(DockCtrlImages::DefaultImage(), t_("Available Widget Groups"));
+	tree.Open(0);
+	for(int i = 0; i < groups.GetCount(); i++)
+	{
+		String group = groups.GetKey(i);
+		Vector<int>& ids = groups.Get(group);
+		tree.Add(0, DockCtrlImages::DefaultImage(), group);
+		for(int j = 0; j < ids.GetCount(); j++)
+		{	
+			CtrlRecord* record = GetCtrlRecordFromId(ids[j]);
+			ASSERT(record);
+			tree.Add(tree.Find(group), record->ctrl->GetIcon(), Value(record->id), Value(record->ctrl->GetLabel()));		
+		}
+	}
+}
+
+void DockBase::GroupMenu(Bar& bar)
+{
+	TreeCtrl& tree = grouptab.grouptree;
+	int id = tree.GetCursor();
+	if(id < 0) return;
+	id = tree.GetParent(id);
+	activegroup = (String) tree.GetValue(tree.GetCursor());
+	if(id >= 0)
+	{
+		if(id == 0 && tree.GetChildCount(id))
+		{
+			bar.Add(Format(t_("Dock Group '%s'"), activegroup), THISBACK1(GroupDockMenu, 0));
+			bar.Add(Format(t_("AutoHide Group '%s'"), activegroup), THISBACK1(GroupDockMenu, 1));
+			bar.Add(Format(t_("Float Group '%s'"), activegroup), THISBACK3(GroupMenuAction, activegroup, 2, -1));
+			bar.Separator();
+			bar.Add(tree.GetChildCount(tree.GetCursor()) > 1, Format(t_("Tabify Group '%s' and..."), activegroup), THISBACK1(GroupTabifyMenu, 3));
+			bar.Separator();
+			bar.Add(activegroup != t_("Default"), Format(t_("Delete Group '%s'"), activegroup), THISBACK1(DeleteWidgetGroup, activegroup));
+			bar.Separator();
+			bar.Add(Format(t_("Close Group '%s'"), activegroup), DockCtrlImages::CClose(), THISBACK3(GroupMenuAction, activegroup, -1, -1));
+		
+		}
+		if(id > 0)
+		{
+			Vector<int> sel = tree.GetSel();
+			for(int i = 0; i < sel.GetCount(); i++)	id = tree.Get(sel[i]);
+			CtrlRecord* record = GetCtrlRecordFromId(id);
+			ASSERT(record);
+			record->ctrl->Menu();
+		}
+	}
+	else bar.Add(t_("Add New Group..."), THISBACK(OnAddNewGroup));
+}
+
+void DockBase::GroupDockMenu(Bar& bar, int command)
+{
+	if(IsSideAllowed(DockableCtrl::DOCK_TOP)) bar.Add(t_("Top"), THISBACK3(GroupMenuAction, activegroup, (int) command, (int)DockableCtrl::DOCK_TOP));
+	if(IsSideAllowed(DockableCtrl::DOCK_LEFT)) bar.Add(t_("Left"), THISBACK3(GroupMenuAction, activegroup, (int) command, (int)DockableCtrl::DOCK_LEFT));
+	if(IsSideAllowed(DockableCtrl::DOCK_RIGHT)) bar.Add(t_("Right"), THISBACK3(GroupMenuAction, activegroup, (int) command, (int)DockableCtrl::DOCK_RIGHT));
+	if(IsSideAllowed(DockableCtrl::DOCK_BOTTOM)) bar.Add(t_("Bottom"), THISBACK3(GroupMenuAction, activegroup, (int) command, (int)DockableCtrl::DOCK_BOTTOM));
+}
+
+void DockBase::GroupTabifyMenu(Bar& bar, int command)
+{
+	bar.Add(t_("Dock"), THISBACK1(GroupDockMenu, 3));
+	bar.Add(t_("Auto Hide"), THISBACK1(GroupDockMenu, 4));
+	bar.Add(t_("Float"), THISBACK3(GroupMenuAction, activegroup, 5, -1));
+}
+
+void DockBase::GroupMenuAction(String name, int command, int alignment)
+{
+	DockableCtrl* ctrl = NULL;
+	Vector<int>& ids = groups.Get(name);
+	int ncount = ids.GetCount();
+
+	bool aligned = (alignment >= DockableCtrl::DOCK_LEFT && alignment <= DockableCtrl::DOCK_BOTTOM);
+
+	for(int i = 0; i < ncount * 2; i++)
+	{
+		if(i < ncount)
+		{
+			ctrl = GetCtrlRecordFromId(ids[i])->ctrl;
+			ASSERT(ctrl);
+			ctrl->Shut();
+		}
+		else
+		{
+			if(i == ncount) RefreshTabWindowList();
+			ctrl = GetCtrlRecordFromId(ids[i - ncount])->ctrl;
+			ASSERT(ctrl);
+
+			switch(command)
+			{
+				case 0: Dock(ctrl->DockingStyle(alignment, DockableCtrl::STATE_SHOW)); break;
+				case 1: Dock(ctrl->SetSizeHint(Size(0,0)).DockingStyle(alignment, DockableCtrl::STATE_AUTO)); break;
+				case 2: Dock(ctrl->DockFloat()); break;
+				case 3:	if (i - ncount == 0) TabifyGroupAndDock(name, alignment); break;
+				case 4: if (i - ncount == 0) TabifyGroupAndAutoHide(name, alignment); break;
+				case 5: if (i - ncount == 0) TabifyGroupAndFloat(name); break;
+			}
+		}
+	}
+}
+
+bool DockBase::Key(dword key, int count)
+{
+	if(key == hotkey) 
+	 	ControlPanel();
+	 return TopWindow::Key(key, count);
+}
+
+CH_STYLE(DockCtrlChStyle, Style, StyleClassic)
+{
+    font        = StdFont();
+    barmargins  = Rect(2,2,2,2);
+    barheight   = font.Info().GetHeight() + 8;  
+    tabheight   = font.Info().GetHeight() + 8;
+    tabmargin   = 2;
+    tabsel      = Rect(2, 2, 2, 2);
+    tabedge     = Rect(6, 6, 6, 6);
+    tabextendleft = 0;
+    
+    DockCtrlImgsLook(barbackground, DockCtrlImages::I_CBarBackground, 1);
+    DockCtrlImgsLook(barshut, DockCtrlImages::I_CClose, 3);
+    DockCtrlImgsLook(barhide, DockCtrlImages::I_CHide, 3);
+    DockCtrlImgsLook(barmenu, DockCtrlImages::I_CMenu, 3);
+
+ 
+    CtrlsImageLook(tabnormal, ClassicCtrlsImg::I_TAB, 4);
+    CtrlsImageLook(tabfirst, ClassicCtrlsImg::I_FTAB, 4);
+    CtrlsImageLook(tablast, ClassicCtrlsImg::I_LTAB, 4);
+    CtrlsImageLook(tabboth, ClassicCtrlsImg::I_BTAB, 4);        
+}
+
+CH_STYLE(DockCtrlChStyle, Style, StyleEnhanced)
+{
+    font        = StdFont();
+    barmargins  = Rect(2,2,2,2);
+    barheight   = font.Info().GetHeight() + 8;  
+    tabheight   = font.Info().GetHeight() + 8;
+    tabmargin   = 2;
+    tabsel      = Rect(2, 2, 2, 2);
+    tabedge     = Rect(6, 6, 6, 6);
+    tabextendleft = 0;
+
+   	const ToolBar::Style* defguistyle = &ToolBar::StyleDefault();  
+	barbackground[0] = defguistyle->arealook;
+
+    DockCtrlImgsLook(barshut, DockCtrlImages::I_CClose, 3);
+    DockCtrlImgsLook(barhide, DockCtrlImages::I_CHide, 3);
+    DockCtrlImgsLook(barmenu, DockCtrlImages::I_CMenu, 3);
+
+    CtrlsImageLook(tabnormal, CtrlsImg::I_TAB, 4);
+    CtrlsImageLook(tabfirst, CtrlsImg::I_FTAB, 4);
+    CtrlsImageLook(tablast, CtrlsImg::I_LTAB, 4);
+    CtrlsImageLook(tabboth, CtrlsImg::I_BTAB, 4);      
+
+	stdhighlight = 	StandardHighlight(Blend(SColorHighlight, SColorPaper, 90), SColorHighlight);
+	tabhighlight = AlphaHighlight(stdhighlight, 80);     
+
+}
+
+CH_STYLE(DockCtrlChStyle, Style, StyleDefault)
+{
+    font        = StdFont();
+    barmargins  = Rect(2,2,2,2);
+    barheight   = font.Info().GetHeight() + 8;  
+    tabheight   = font.Info().GetHeight() + 8;
+    tabmargin   = 2;
+    tabsel      = Rect(2, 2, 2, 2);
+    tabedge     = Rect(6, 6, 6, 6);
+    tabextendleft = 0;
+    
+    const TabCtrl::Style* defguistyle = &TabCtrl::StyleDefault();  
+	barbackground[0] =  defguistyle->normal[0];
+
+	DockCtrlImgsLook(barshut, DockCtrlImages::I_DClose, 3);
+    DockCtrlImgsLook(barhide, DockCtrlImages::I_DHide, 3);
+    DockCtrlImgsLook(barmenu, DockCtrlImages::I_DMenu, 3);
+  
+    CtrlsImageLook(tabnormal, CtrlsImg::I_TAB, 4);
+    CtrlsImageLook(tabfirst, CtrlsImg::I_FTAB, 4);
+    CtrlsImageLook(tablast, CtrlsImg::I_LTAB, 4);
+    CtrlsImageLook(tabboth, CtrlsImg::I_BTAB, 4);  
+
+
+	stdhighlight = 	StandardHighlight(Blend(SColorHighlight, SColorPaper, 90), SColorHighlight);
+	tabhighlight = AlphaHighlight(stdhighlight, 80);     
+	
+}
diff --git a/archive/DockCtrl/DockCtrl.h b/archive/DockCtrl/DockCtrl.h
new file mode 100644
index 000000000..054a691d1
--- /dev/null
+++ b/archive/DockCtrl/DockCtrl.h
@@ -0,0 +1,1135 @@
+//==============================================================================================
+// DockCtrl: A dockable widget framework for U++
+// Author:	 Ismail YILMAZ
+// Version:	 0.52 (DEV-0803b.2)
+//==============================================================================================
+
+#ifndef DOCKCTRL_H
+#define DOCKCTRL_H
+
+#include <CtrlLib/CtrlLib.h>
+#include <Draw/Draw.h>
+
+using namespace UPP;
+
+#define LAYOUTFILE <DockCtrl/DockCtrl.lay>
+#include <CtrlCore/lay.h>
+
+#define IMAGECLASS DockCtrlImgs
+#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
+#include <Draw/iml_header.h>
+
+#define TFILE <DockCtrl/DockCtrl.t>
+#include <Core/t.h>
+
+#include <CtrlLib/Ch.h>
+
+class PaneSplitter;
+class TabInterface;
+class AutoHideBar;
+class PaneFrame;
+class DockBase;
+class DockCtrl;
+class DockWindow;
+class TabWindow;
+class DockableCtrl;
+
+//----------------------------------------------------------------------------------------------
+// DockCtrl: Chameleon Support.
+//
+struct DockCtrlChStyle : Moveable<DockCtrlChStyle>
+{
+	struct Style : ChStyle<Style>
+	{
+		Font 	font;
+		int 	bartitlesize;
+		int		barheight;
+		Rect	barmargins;
+		Value	barbackground[1];
+		Value	barshut[3];
+		Value	barhide[3];
+		Value	barmenu[3];
+		int		tabheight;
+		int		tabmargin;
+		int		tabextendleft;
+		Rect	tabsel;
+		Rect	tabedge;
+		Value	tabnormal[4];
+		Value	tabfirst[4];
+		Value	tablast[4];
+		Value	tabboth[4];
+		Value	hidebutton[4];	
+		Image	stdhighlight;
+		Image	tabhighlight;
+	};
+	const Style* style;
+	static const Style& StyleDefault();
+	static const Style& StyleClassic();
+	static const Style& StyleEnhanced();
+};
+
+static void DockCtrlImgsLook(Value* look, int i, int n)
+{
+	while(n--)
+		*look++ = DockCtrlImgs::Get(i++);
+}
+
+static Image StandardHighlight(Color inside, Color border)
+{
+	Size sz(5, 5);
+	ImageBuffer ib(sz);
+	RGBA *q = ~ib;
+	for (int i = 0; i < 5; i++)
+		for (int j = 0; j < 5; j++)
+			*(q++) = (i == 4 || j == 4 || !i || !j) ? border : inside;
+	ib.SetHotSpot(Point(1, 1));
+	ib.Set2ndSpot(Point(3, 3));
+	return ib;
+}
+
+static Image AlphaHighlight(const Image &img, int alpha)
+{
+	ImageDraw draw(img.GetSize());
+	draw.Alpha().DrawRect(img.GetSize(), Color(alpha, alpha, alpha));
+	draw.DrawImage(0, 0, img);
+	// MingW (5.1.3) fix - Damn, I hate that ever-complaining compiler.
+	Image dimg = draw;
+	// Is there a better way to set hotspots than this?
+	ImageBuffer ib(dimg);
+	ib.SetHotSpot(Point(1, 1));
+	ib.Set2ndSpot(Point(3, 3));
+	return ib;
+}
+
+//----------------------------------------------------------------------------------------------
+
+struct DockCtrlCustomFrame : FrameCtrl<Ctrl>
+{
+public:
+	enum 	{ LAYOUT_LEFT, LAYOUT_TOP, LAYOUT_RIGHT, LAYOUT_BOTTOM };
+	enum 	{ TAB_MARGIN = 6, TAB_SPACE = 20, TAB_SBHEIGHT = 4, TAB_SBSEPARATOR = 1, TAB_FILEICON = 16, TAB_SPACEICON = 5 };
+	enum 	{ BAR_MARGIN = 6, BAR_SPACE = 20, BAR_SBHEIGHT = 4, BAR_SBSEPARATOR = 1, BAR_FILEICON = 16, BAR_SPACEICON = 5 };
+		
+	void	SetLayout(int l)	{ layout = l; RefreshLayout();			}
+	void	Fix(Size& sz)		{ if(!horizontal) Swap(sz.cx, sz.cy); 	}
+	void	Fix(Point& p)		{ if(!horizontal) Swap(p.x, p.y);		}
+	void	SetSize(int sz)		{ size = sz;							}
+	bool	IsHorz()			{ return layout == LAYOUT_TOP || layout == LAYOUT_BOTTOM; }
+	bool	IsVert()			{ return !IsHorz(); }
+	
+	virtual void FrameLayout(Rect& r);
+	virtual void FrameAddSize(Size& sz);
+
+	DockCtrlCustomFrame& 			SetStyle(const DockCtrlChStyle::Style& s);
+	const DockCtrlChStyle::Style*  	GetStyle();	
+
+	int		layout;
+	int 	size;
+	bool	horizontal;
+	const 	DockCtrlChStyle::Style* style;
+	DockCtrlCustomFrame() : layout(LAYOUT_TOP), size(0), horizontal(true) {}	
+
+};
+
+class TabInterface : public DockCtrlCustomFrame
+{
+private:
+
+
+	class TabScrollBar : public DockCtrlCustomFrame
+	{
+	private:
+		int total;
+		double pos, ps;
+		int new_pos;
+		int old_pos;
+		double start_pos;
+		double size;
+		double cs, ics;
+		void UpdatePos(bool update = true);
+		bool ready;
+		Size sz;
+	
+	public:
+		TabScrollBar();
+
+		virtual void Paint(Draw &w);
+		virtual void LeftDown(Point p, dword keyflags);
+		virtual void LeftUp(Point p, dword keyflags);
+		virtual void MouseMove(Point p, dword keyflags);
+		virtual void MouseWheel(Point p, int zdelta, dword keyflags);
+		virtual void Layout();
+
+		int  GetPos() const;
+		void SetPos(int p, bool dontscale = false);
+		void AddPos(int p, bool dontscale = false);
+		int  GetTotal() const;
+		void AddTotal(int t);
+		void SetTotal(int t);
+		void GoEnd();
+		void GoBegin();
+		void Set(const TabScrollBar& t);
+		TabScrollBar& SetLayout(int l);
+		Callback WhenScroll;
+	};
+
+
+	
+protected:
+	void OnScrollBar() { Refresh(); };
+	int  GetPos() { return scrollbar.GetPos(); }
+	Point mouse, oldp;
+	TabScrollBar scrollbar; 
+	
+public:
+	struct Tab : Moveable<Tab>
+	{
+		DockableCtrl* dock;
+		bool 	active, visible, highlighted;
+		int		id;
+		int 	x, y, cx, cy;
+		Size 	textsize;
+		String	name;
+		Image	icon;
+		int		Right()	 { return x + cx; };
+		int		Bottom() { return y + cy; };
+		bool	IsActive() { return active; }
+		bool	IsVisible()	{ return visible; }
+		bool	IsHighligted()	{ return highlighted; }
+		bool	HasMouse(const Point& p)	{ return visible && Rect(x, y, x + cx, y + cy).Contains(p);}
+		bool	HasMouseButton(const Point& p, int w, int h) 
+		{
+			if(!visible) return false;
+			Size isz = DockCtrlImgs::DClose().GetSize();
+			int iy = (h - isz.cy) / 2;
+			int ix = x + cx - isz.cx - w - TAB_MARGIN;
+			return p.x >= ix && p.x < ix + isz.cx && p.y >= iy && p.y < iy + isz.cy;
+		}
+		Tab() : id(-1), active(false), visible(false), highlighted(false) { dock = NULL; }
+		~Tab() { if(dock) dock = NULL; }
+	};
+	
+protected:
+	Vector<Tab> tabs;
+	int id;
+	int active, highlight, visible;
+	int fileicon, tabbutton;
+	bool hastabbutton, hasfileicon, hasscrollbar, isdraggable;
+	int target, source;
+	bool isctrl;
+	bool isdragged;
+	String	internalname; // not to confuse with different types of ctrls (tabs X autohidebars)
+	
+public:
+	const TabCtrl::Style *style;
+	TabInterface& SetStyle(const TabCtrl::Style& s)  { style = &s; Refresh(); return *this; }
+	static const TabCtrl::Style& StyleDefault();
+
+public:
+	void Add(DockableCtrl& dock, bool activate = false);
+	void Add(String name, bool activate = false);
+	void Remove(DockableCtrl& dock);
+	void Remove(int n);
+	void Close(int n);
+	void CloseAll();
+	
+	void SetActiveTab(int n);
+	void SetActiveTab(DockableCtrl& dock);
+	void SetActiveTabTitle(String name, Image icon);
+	int  GetActiveTab();
+	int  Find(int itemid);
+	int	 Find(DockableCtrl& dock);
+	int  GetNext(int n);
+	int  GetPrev(int n);
+	virtual void ReposTabs();
+	virtual void DrawTab(Draw& w, Size &sz, int i);
+	void DrawLabel(Draw& w, int x, int y, Tab& t, bool isactive);	
+
+	Vector<Tab>& GetTabs()	{return tabs; } 
+	
+	int GetWidth(int n);
+	int GetWidth();
+	int GetHeight();
+	
+	int GetNextId() { return ++id; }
+	
+	TabInterface& HasButtons(bool b) 		{ hastabbutton = b; ReposTabs(); if(IsOpen() && IsChild()) Refresh(); return *this; }
+	TabInterface& HasIcons(bool b)	 		{ hasfileicon  = b;	ReposTabs(); if(IsOpen() && IsChild()) Refresh(); return *this; }
+	TabInterface& HasScrollBar(bool b);	
+	TabInterface& Draggable(bool b = true)	{ isdraggable = b; return *this; }
+		
+	TabInterface& SetLayout(int l);
+		
+protected:
+	virtual void Paint(Draw& d);
+	virtual void LeftDown(Point p, dword keyflags);
+	virtual void LeftUp(Point p, dword keyflags);
+	virtual void LeftDrag(Point p, dword keyflags);
+	virtual void MiddleDrag(Point p, dword keyflags);
+	virtual void RightDown(Point p, dword keyflags);
+	virtual void RightUp(Point p, dword keyflags);
+	virtual void MouseMove(Point p, dword keyflags);
+	virtual void MouseWheel(Point p, int zdelta, dword keyflags);
+	virtual void MouseLeave();
+	virtual void DragAndDrop(Point p, PasteClip& d);
+
+	virtual void DragEnter();
+	virtual void DragLeave();
+	virtual void DragRepeat(Point p);
+	virtual void CancelMode();
+
+	int GetTargetTab(Point p);
+	int	GetSourceTab(Point p);
+
+public:
+	Callback2<int, DockableCtrl&> WhenContext;
+	Callback2<int, DockableCtrl&> WhenClose;
+	Callback2<int, DockableCtrl&> WhenDrag;
+	Callback2<int, DockableCtrl&> WhenActive;
+	Callback WhenHighlight;
+	Callback WhenSelect;
+
+public:
+	typedef TabInterface CLASSNAME;
+	
+	TabInterface();
+	~TabInterface();
+};
+
+//----------------------------------------------------------------------------------------------
+
+class PaneSplitter : public Splitter
+{
+public:
+	typedef PaneSplitter CLASSNAME;
+	
+	enum {PANEANIMATION, TABANIMATION };
+	
+	void 			AddChildDock(DockableCtrl& dock, int position);
+	void 			AddChildDock(DockableCtrl& dock);
+	void 			RemoveChildDock(DockableCtrl& dock);
+	void 			RemoveChildDock(int position);
+	void 			RemoveChilds();
+	void 			ReposChilds();
+	DockableCtrl* 	GetChildAt(int position);
+	int  			GetChildCount();
+	bool 			HasChild();					
+
+	void 			StartAnimation(DockableCtrl& dock, int position);
+	void 			StartAnimation(int position);
+	void 			StopAnimation();
+	inline bool 	IsAnimating() const				{ return animating; }
+	void 			Animate(int position = 0);
+	void 			SetAnimationType(int type)		{ animationctrl.Type(animationtype = type); }
+	Rect 			AnimationArea() 				{ return animationctrl.GetScreenRect();}
+	Ctrl* 			GetAnimationCtrl() 				{ return (Ctrl*) &animationctrl; }		
+
+	virtual void 	Layout();
+
+	
+private:
+	Array<int> 		positions;
+	void 			AnimateCallback();
+
+public:
+	class AnimationCtrl : public Ctrl
+	{
+	public:
+		typedef 	AnimationCtrl CLASSNAME;
+		void 		SetAnimImage(Image& img)		{ image = img;  Refresh(); }
+		Image& 		GetAnimImage()					{ return image;  }
+		void 		ClearAnimImage()				{ image.Clear(); }
+		void 		AnimateVert();
+		void 		AnimateHorz();
+		void 		Paint(Draw& d);
+		void 		Type(int type)					{ ctrltype = type; }
+	public:
+		AnimationCtrl()  { /*SetFrame(FieldFrame()); */ctrltype = PaneSplitter::PANEANIMATION; }
+
+	private:
+		Image 		image;
+		int 		ctrltype;
+	};
+	AnimationCtrl animationctrl;
+private:
+	bool animating;
+	int  animationtype;
+	int pos, x, y;
+
+public:
+	PaneSplitter();
+	~PaneSplitter();
+};
+
+//----------------------------------------------------------------------------------------------
+
+class DockableCtrl : public TopWindow
+{
+public:
+	typedef DockableCtrl CLASSNAME;
+	
+	enum { TYPE_DOCKWINDOW, TYPE_TABWINDOW, TYPE_DOCKBAR };										// Available DockableCtrl types.
+	enum { DOCK_LEFT, DOCK_TOP, DOCK_RIGHT, DOCK_BOTTOM, DOCK_TABBED, DOCK_NONE };				// Possible alignments.
+	enum { STATE_SHUT, STATE_SHOW, STATE_HIDE, STATE_AUTO, STATE_TABBED			};				// Possible states.
+	
+	inline bool		IsDockWindow()				{ return docktype == TYPE_DOCKWINDOW; 	}		
+	inline bool		IsTabWindow()				{ return docktype == TYPE_TABWINDOW;	}		
+	inline bool		IsDockBar()					{ return docktype == TYPE_DOCKBAR;		}		
+
+	DockableCtrl& 	DockTop()					{ dockalignment = DOCK_TOP;		return *this;}
+	DockableCtrl& 	DockLeft()					{ dockalignment = DOCK_LEFT;	return *this;}			
+	DockableCtrl& 	DockRight()					{ dockalignment = DOCK_RIGHT;	return *this;}
+	DockableCtrl& 	DockBottom()				{ dockalignment = DOCK_BOTTOM;	return *this;}
+	DockableCtrl&	DockFloat()					{ dockalignment	= DOCK_NONE; dockstate= STATE_SHOW; return *this; }
+
+	DockableCtrl& 	StateShut()					{ dockstate =  STATE_SHUT;		return *this;}
+	DockableCtrl& 	StateShow()					{ dockstate =  STATE_SHOW;		return *this;}
+	DockableCtrl& 	StateHide()					{ dockstate =  STATE_HIDE;		return *this;}
+	DockableCtrl& 	StateAuto()					{ dockstate =  STATE_AUTO;		return *this;}
+	DockableCtrl& 	StateTabbed()				{ dockstate =  STATE_TABBED;	return *this;}
+
+	DockableCtrl& 	Posit(int position)			{ dockposition = position;		return *this;}
+
+	DockableCtrl& 	DockingStyle(int alignment, int state, int position = 0);
+	
+	inline int 		Alignment() const			{ return dockalignment; }
+	inline int 		State()		const			{ return dockstate;		}
+	inline int 		Position()	const			{ return dockposition;	}
+	
+	inline bool 	IsDocked()					{ return !IsShut() && !IsTabbed() && !IsFloating();					}
+	inline bool		IsHidden()					{ return IsDocked() && dockstate == STATE_HIDE;						}
+	inline bool 	IsAutoHidden()				{ return IsDocked() && dockstate == STATE_AUTO;						}
+	inline bool 	IsShut()					{ return dockalignment == DOCK_NONE && dockstate == STATE_SHUT; 	}
+	inline bool 	IsFloating()				{ return dockalignment == DOCK_NONE && dockstate != STATE_SHUT; 	}
+	inline bool 	IsTabbed()					{ return dockstate == STATE_TABBED;	}
+
+	int 			GetType()					{ return docktype;	}							// Returns the type of the derived dockablectrl class.
+	DockBase&		GetBase()					{ ASSERT(dockbase); return *dockbase;	}		// Returns the owner (base) framework.
+ 	String 			GetLabel() 	const			{ return  dockname; }							// Returns the name of the dockablectrl.
+	Image  			GetIcon () 	const 			{ return  dockicon; }  							// Returns the icon associated with the dockablectrl.
+	Size			GetSizeHint()				{ return docksize;	}							// Returns the absolute (ctrl + frames) size of the dockablectrl.
+
+	DockableCtrl& 	SetLabel(String  title);									
+	DockableCtrl& 	SetIcon(Image icon);
+
+	Callback1<Bar&>	WhenContextMenu;
+	
+protected:
+	DockableCtrl&	SetType(int type)			{ docktype = type;	return *this;}	
+	DockableCtrl&	SetBase(DockBase* c)		{ dockbase = c;		return *this;}
+	DockableCtrl&	SetSizeHint(Size sz)		{ docksize = sz;	return *this;}
+	DockableCtrl&	SetSize(Size sz);
+	void			ReSize();
+
+private:
+	int				dockalignment;
+	int				dockstate;
+	int				dockposition;
+	int				docktype;
+	Size			docksize;
+	DockBase*		dockbase;
+	Image			dockicon;
+	String			dockname;
+	MenuBar			dockmenu;
+	int				dockdroptarget;
+	int				dockdropstate;
+
+protected:
+	bool 			haschildbar;
+	bool			hasdragbar;
+	bool			isdragged;
+	bool			isdraggable;
+
+	friend class 	DockBase;
+	friend class 	PaneFrame;
+	friend class 	TabWindow;
+	friend class	AutoHideBar;
+
+public:
+	const DockCtrlChStyle::Style* style;					
+
+public:
+	virtual void 	Dock(int alignment, int state, int position, bool check = true) = 0;
+	virtual void 	FloatEx(Rect r)	= 0;
+	virtual void 	Float() 		= 0;
+	virtual void 	Show() 			= 0;
+	virtual void 	Hide() 			= 0;
+	virtual void 	AutoHide() 		= 0;
+	virtual void 	Shut() 			= 0;
+	virtual void 	Menu() 			= 0;
+	virtual void 	Settings();
+	
+	virtual void 	Serialize(Stream& s) = 0;	
+
+public:
+	virtual Rect 	GetCtrlRect() = 0;	
+	virtual Size 	GetCtrlSize() = 0;
+
+public:
+	void 			SetDropTarget(int target = DOCK_NONE, int state = STATE_SHUT)	{ dockdroptarget = target, dockdropstate = state; }
+	int				GetDropTarget	()												{ return dockdroptarget;	}
+	int				GetDropState	()												{ return dockdropstate;		}
+	bool			HasDropTarget	()												{ return (dockdroptarget != DOCK_NONE);}
+	bool			IsDropTargetAvailable(Rect r, Point p)							{ return r.Contains(p);		}
+	
+	void			ForbidDragAndDrop()												{ isdraggable = false;	};
+	void			PermitDragAndDrop()												{ isdraggable = true;	};
+
+protected:
+	void 			StartWindowDrag();
+
+#if defined(PLATFORM_WIN32)
+	virtual LRESULT  WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
+#elif defined(PLATFORM_X11)
+	virtual void EventProc(XWindow& w, XEvent *event);
+#endif
+			
+protected:
+	virtual	void 	OpenWindow(Rect& r);
+	virtual void	OpenWindow(int x, int y, int cx, int cy);
+	virtual void 	ShutWindow();
+	virtual void 	ContextMenu();
+	virtual	void 	OnShutWindow();
+	virtual void 	Layout();
+	virtual void	Paint(Draw& d)												{ d.DrawRect(GetSize(), SColorFace()); }	
+public:
+	virtual void 	ShowDragBar()												{ hasdragbar = true; 	}
+	virtual void 	HideDragBar()												{ hasdragbar = false;	}
+	virtual bool 	HasDragBar()												{ return hasdragbar;	}
+	virtual bool 	HasChildBar()												{ return haschildbar;	} 
+
+public:
+	DockableCtrl& 	AddChildBar(CtrlFrame& bar)			{ AddFrame(bar);  haschildbar = true; return *this; }
+	DockableCtrl& 	Add(Ctrl& ctrl)						{ this << ctrl; return *this; }
+	DockableCtrl& 	operator<<(Ctrl& ctrl)				{ Add(ctrl);	return *this; }
+
+	DockableCtrl();
+	~DockableCtrl();	
+};
+
+//----------------------------------------------------------------------------------------------
+
+class DockWindow : public DockableCtrl
+{
+public:
+	typedef DockWindow CLASSNAME;
+	
+	DockWindow&		AddMenuBar(MenuBar& bar);
+	DockWindow&		AddToolBar(ToolBar& bar);
+	DockWindow&		AddStatusBar(StatusBar& bar);
+	
+	inline bool 	HasMenuBar	()		{ return hasmenubar; 	}
+	inline bool 	HasToolBar	()		{ return hastoolbar; 	}
+	inline bool 	HasStatusBar()		{ return hasstatusbar;	}
+
+	virtual Rect 	GetCtrlRect();	
+	virtual Size 	GetCtrlSize();
+	
+	TabWindow*		GetOwnerTab()		{ return ownertab; }
+	AutoHideBar*	GetOwnerBar()		{ return ownerbar; }
+	
+	DockWindow&		SetOwnerTab(TabWindow* tabwindow)	{ ownertab = tabwindow; 	return *this; }
+	DockWindow&		SetOwnerBar(AutoHideBar* hidebar)	{ ownerbar = hidebar;		return *this; }
+
+	virtual void 	Serialize(Stream& s);
+	
+public:
+	virtual void 	Dock(int alignment, int state, int position, bool sizecheck = true);
+	virtual void 	FloatEx(Rect r);
+	virtual void 	Float();
+	virtual void 	Show();
+	virtual void 	Hide();
+	virtual void 	AutoHide();
+	virtual void 	Shut();
+	virtual void 	Menu();
+	
+public:
+	virtual void	ShowDragBar();
+	virtual void	HideDragBar();
+	virtual	DockWindow&	ShowDragBarButtons(bool b = true);
+		
+protected:
+	virtual void 	OnMenuButton	();
+	virtual void	OnShutButton	();
+	virtual void	OnAutoHideButton();
+	virtual void 	ChildMouseEvent(Ctrl *child, int event, Point p, int zdelta, dword keyflags);
+	virtual void 	MouseMove(Point p, dword keyflags);
+	virtual void 	Paint(Draw& d);	
+
+public:
+	virtual void	DockWindowMenu(Bar& bar);
+	virtual void	DockWindowDockMenu(Bar& bar);
+	
+private:
+	class DragBar : public DockCtrlCustomFrame
+	{
+	public:
+		typedef DragBar CLASSNAME;
+		void		ShowButtons(bool b = true)		{ show 	= b;	if(IsVisible()) Refresh(); }
+		void		SetColor (const Color& c)		{ color = c; 	}
+		void		SetOwner (DockWindow* w)		{ owner = w;	}
+		DockWindow&	GetOwner ()						{ ASSERT(owner); return *owner;	}
+		int 		GetWidth ();
+		int 		GetHeight();
+	
+		virtual		void Paint(Draw& d);
+		virtual		void FrameAddSize(Size& sz);
+		
+	private:
+		DockWindow* owner;
+		Color		color;
+		bool		show;		
+
+	public:
+		DragBar();
+	};
+
+	struct DragBarButton : public Button
+	{
+	public:
+		void  		Paint(Draw& d);
+		Ctrl& 		SetImage(const Image& normal, const Image& highlighted, const Image& pushed);
+	private:
+		const 		DockCtrlChStyle::Style* style;
+		Image 		nimage;
+		Image 		himage;
+		Image 		pimage;
+	};
+	
+private:
+	bool 			hasmenubar;
+	bool 			hastoolbar;
+	bool 			hasstatusbar;
+	bool			hasbarbuttons;
+	TabWindow*		ownertab;
+	AutoHideBar*	ownerbar;
+	MenuBar* 		menubar;
+	ToolBar* 		toolbar;
+	StatusBar*		statusbar;
+	DragBar			dragbar;
+	DragBarButton	menubutton;
+	DragBarButton	autohidebutton;
+	DragBarButton	shutbutton;
+	friend class 	TabWindow; 
+
+public:
+	DockWindow& SetStyle(const DockCtrlChStyle::Style& s);
+	const DockCtrlChStyle::Style*  GetStyle();
+
+public:
+	DockWindow();
+	~DockWindow();
+};
+
+
+//----------------------------------------------------------------------------------------------
+
+class TabWindow : public DockWindow
+{
+public:
+	typedef TabWindow CLASSNAME;
+	
+	void 			Attach(DockableCtrl& ctrl, int makeactive = false);
+	void 			Detach(DockableCtrl& ctrl);
+	void 			DetachAll();
+
+	TabWindow&		SetGroup(String name)			{ groupname = name; groupwindow = true; return *this;}
+	void 			SetActive(int index);
+	void 			SetActive(DockableCtrl& ctrl);
+	DockableCtrl* 	GetActiveCtrl();
+	int  			GetActiveTab();
+	int	 			ChildCount();	
+	void 			StartTabAnimation(); 
+	void 			StopTabAnimation();	
+
+	bool 			HasCtrlInRange();
+	bool 			HasTabbedDock();
+	bool			IsGroupWindow()					{ return groupwindow;			}
+	bool 			IsTabAnimating()				{ return animating;		 		}
+	bool 			IsDestroyed()					{ return destroyed;				}	
+
+	TabInterface& 	GetTabs()						{ return tabs;		}
+	DockableCtrl*	GetChildAt(int position);
+	TabWindow*		GetBaseTab();
+	int				GetNestLevel()					{ return nestlevel; }
+
+	void			SetNestLevel(int n);
+	TabWindow&		SetLayout(int n) 				{ if(tabs.IsChild()) RemoveFrame(tabs); AddFrame(tabs.SetLayout(n)); return *this; }
+
+	virtual	void	Serialize(Stream& s);
+
+	virtual void 	FloatEx(Rect r)					{ DockWindow::FloatEx(r); 	RefreshTabWindowLabel(*this); }
+	virtual void 	Float()							{ DockWindow::Float(); 		RefreshTabWindowLabel(*this); }
+		
+protected:
+	void 			OnMenuButton();
+	void 			OnShutButton();
+	void 			OnAutoHideButton();
+	virtual void 	OnShutWindow();
+		
+	virtual void 	OnActiveTab();
+	virtual void 	OnTabClose(int id, DockableCtrl& ctrl);
+	virtual void 	OnTabDrag(int id, DockableCtrl& ctrl);
+	virtual void 	OnTabActive(int id, DockableCtrl& ctrl);
+	virtual void 	OnTabContextMenu(int id, DockableCtrl& ctrl);	
+
+	virtual void 	Paint(Draw& d);
+	
+private:
+	void 			AttachNormal(DockableCtrl& ctrl, int makeactive = false);
+	void 			AttachNested(DockableCtrl& ctrl, int makeactive = false);
+	void 			Attach0(DockableCtrl& ctrl, int makeactive = false);
+		
+	void 			RefreshTabWindowLabel(DockableCtrl& ctrl);
+	bool 			RemoveTabWindow();
+	void			ReposChilds();
+		
+private:
+	int 			position;
+	int 			previous;
+	int				nestlevel;
+	int				childcount;
+	bool 			destroyed;
+	bool			animating;
+	bool			groupwindow;
+	String			groupname;
+	Image			animimage;
+	TabInterface 	tabs;
+	DockableCtrl* 	activectrl;
+
+public:
+	TabWindow();
+	~TabWindow();
+};
+
+//----------------------------------------------------------------------------------------------
+
+class AutoHideBar : public TabInterface
+{
+public:
+	typedef AutoHideBar CLASSNAME;
+
+	AutoHideBar& 	Attach(DockableCtrl& ctrl);
+	void 			Detach(DockableCtrl& ctrl);
+
+	void 			ShowBar();
+	void 			HideBar();
+
+	int	 			GetSize()			{ return DockCtrlCustomFrame::size; }
+	void 			SetSize(int sz) 	{ DockCtrlCustomFrame::size = sz; RefreshParentLayout(); }
+
+	DockableCtrl* 	GetChild(int position);
+	int	  			GetCount();
+
+protected:
+
+	virtual void	FrameRemove();
+	virtual void	FrameAdd(Ctrl& parent);
+	virtual void 	MouseMove(Point p, dword keysflags);
+	virtual void 	MouseLeave();
+	virtual void	MouseEnter(Point p, dword keyflags);
+
+	void 			ShowWindow();
+	void 			HideWindow();
+	
+	void 			OnHighlight();
+	void 			OnClose(int id, DockableCtrl& ctrl);
+	
+	void 			AdjustSize(Rect &r, const Size &sz);
+
+private:	
+	struct PopupWindow : public Ctrl
+	{
+		Callback 		WhenEnter;
+		Callback 		WhenLeave;
+		virtual void 	ChildMouseEvent(Ctrl *child, int event, Point p, int zdelta, dword keyflags); 
+		virtual void 	Paint(Draw& d) { Ctrl::Paint(d); }
+		PopupWindow() { BackPaint();  }
+	};
+
+	PopupWindow 	popup;
+	DockableCtrl* 	ctrl;
+	int				childcount;
+		
+public:
+	const	DockCtrlChStyle::Style* style;
+	AutoHideBar& SetStyle(const DockCtrlChStyle::Style& s)	{ style = &s; Refresh(); return *this; }
+	const DockCtrlChStyle::Style*  GetStyle()				{ return style ? style : &DockCtrlChStyle::StyleDefault(); 	}
+
+public:
+	AutoHideBar();
+    ~AutoHideBar(); 
+};
+
+//----------------------------------------------------------------------------------------------
+class PaneFrame : public CtrlFrame, private Ctrl
+{
+
+public:
+	typedef PaneFrame CLASSNAME;
+
+	PaneFrame& 			Attach(DockableCtrl& ctrl);
+	PaneFrame& 			Detach(DockableCtrl& ctrl);
+
+	void  				ShowFrame();
+ 	void  				ShowFrame(Size sz);
+ 	void  				HideFrame();
+ 	void  				LockFrame();
+ 	void  				UnlockFrame();
+
+	bool  				HasChild(DockableCtrl& ctrl);
+	DockableCtrl* 		GetChild(int position);
+	int	  				GetCount();
+	Vector<TabWindow*>& GetTabWindows();
+
+	TabWindow*			AddTabWindow();
+	void				AddtoTabWindow(DockableCtrl& ctrl);
+	void				RemovefromTabWindow(DockableCtrl& ctrl);
+	void 				RemoveTabWindows();
+
+	void				RefreshTabWindowList();
+			
+private:
+	PaneFrame& 			AttachAsDock(DockableCtrl& ctrl);
+	PaneFrame& 			AttachAsTab(DockableCtrl& ctrl);
+	PaneFrame& 			AttachAsAuto(DockableCtrl& ctrl);
+
+	TabWindow*			AddTabWindow(DockableCtrl& ctrl);
+	void				RemoveTabWindow(TabWindow* tabwindow);
+	void				RemoveTabWindow(int position);
+	void				RemovefromTabWindow(int position);
+	TabWindow*			FindTabWindow(int position);
+	TabWindow*			FindTabWindow(DockableCtrl& ctrl);
+	
+	inline TabWindow* 	GetActiveTabWindow();
+	void				SetActiveTabWindow(TabWindow* tabwindow);
+	bool				HasTabWindow(TabWindow* tabwindow);
+			
+
+private:
+	PaneSplitter 		dockcontainer;
+	AutoHideBar	 		hidebar;
+	TabWindow*	 		activetabwindow;
+	Vector<TabWindow*> 	tabwindows;
+		
+public:
+	virtual void 		FrameAdd(Ctrl& parent);
+	virtual void 		FrameRemove();
+	virtual void 		FrameAddSize(Size& sz);
+	virtual void 		FrameLayout(Rect& r);
+
+	virtual void 		Paint(Draw& draw);
+	virtual void 		LeftDown(Point p, dword keyflags);
+	virtual void 		MouseMove(Point p, dword keyflags);
+	virtual void 		LeftUp(Point p, dword keyflags);
+	virtual Image 		CursorImage(Point p, dword keyflags);
+
+private:
+	Point 				ref;
+	Size  				parentsize;
+	int   				type, minsize, sizemin, maxsize, stdsize;
+	int   				size, size0;
+	int	  				dndpos;
+	bool  				created;
+	bool  				locked;
+	int   				BoundSize();
+	DockBase* 			base;
+	int	  				ncount;
+	
+public:
+	enum { LEFT, TOP, RIGHT, BOTTOM };
+
+	PaneFrame& 			SetLayout(DockBase* basectrl, int alignment, int _maxsize);
+	
+	PaneFrame& 			Set(Ctrl& c, int size, int type);
+	PaneFrame& 			Left(Ctrl& c, int size)    		{ return Set(c, size, LEFT); }
+	PaneFrame& 			Top(Ctrl& c, int size)    	 	{ return Set(c, size, TOP); }
+	PaneFrame& 			Right(Ctrl& c, int size)  	 	{ return Set(c, size, RIGHT); }
+	PaneFrame& 			Bottom(Ctrl& c, int size)  		{ return Set(c, size, BOTTOM); }
+
+	PaneFrame& 			MinSize(int sz)        		    { minsize = sz; return *this; }
+	PaneFrame& 			MaxSize(int sz)					{ maxsize = sz; return *this; }
+	PaneFrame& 			SizeMin(int sz)         		{ sizemin = sz; return *this; }
+
+	PaneFrame& 			Vert()							{ dockcontainer.Vert(); return *this; 	}
+	PaneFrame& 			Horz()							{ dockcontainer.Horz(); return *this; 	}
+	PaneFrame& 			RefreshPaneFrame()				{ RefreshParentLayout(); dockcontainer.Layout(); return *this; }
+	
+	PaneFrame& 			SetBase(DockBase* ctrlbase)		{ base = ctrlbase;	return *this;	}
+	DockBase&  			GetBase()						{ ASSERT(base); return *base; 		}
+	
+	int  				GetType() const                	{ return type; 		}	
+	int  				GetSize() const                	{ return size; 		}
+	int					GetPaneMaxSize() const			{ return maxsize; 	}	
+	void 				SetSize(int sz)                	{ size = sz; RefreshParentLayout(); }
+
+	Rect 				GetScreenView()					{ return Ctrl::GetScreenView(); 	}
+	Rect 				GetScreenRect()					{ return Ctrl::GetScreenRect();		}	
+	
+	void 				Enable()						{ Ctrl::Enable(); 	}
+	void 				Disable()						{ Ctrl::Disable();	}
+	void 				Show(bool show = true)		  	{ Ctrl::Show(show); }
+	void 				Hide()						  	{ Ctrl::Hide(); 	}
+	
+	bool 				IsShown()					  	{ return Ctrl::IsShown(); 	}
+	bool 				IsEnabled()						{ return Ctrl::IsEnabled();	}
+	bool 				IsCreated()						{ return created;			}
+	bool 				IsLocked()						{ return locked;			}
+	         
+public:
+	PaneFrame();
+	~PaneFrame();
+	
+//===============================================
+// DockPane: Drag-n-Drop related methods.
+//===============================================
+
+public:
+	bool				HasCtrlInRange(DockableCtrl&  ctrl, Point p);
+	
+	void				StartPaneFrameAnimation(DockableCtrl& ctrl, int position);
+	void				StartTabWindowAnimation(DockableCtrl& ctrl, int position);
+	void				StopPaneFrameAnimation();
+	void				StopTabWindowAnimation();
+		    	                    
+private:
+	bool				CalculateCtrlRange(DockableCtrl& t, Ctrl& c, Point p);
+	bool				CalculateEmptyRange(Ctrl& c, Point p);
+
+public:		    	               
+	void				DnDSourceinRange()				{ _dndsource = true;  }
+	void				DnDSourceoutofRange()			{ _dndsource = false; }
+	bool				DnDHasSource()	const			{ return _dndsource;  }
+		
+	void				DnDAnimate(int position = dnd_none);
+
+	void				DoDropAnimation(int command = ANIMATE_ALL, int position = dnd_none, DockableCtrl* dock = NULL);	
+	bool				DnDIsAnimating() const			{ return _dndanim;	  }
+	
+	void				DnDAnimStart()					{ _dndanim = true; 	  }
+	void 				DnDAnimStop()					{ _dndanim = false;	  }
+		
+public:
+	enum	{ dnd_first = 1, dnd_last = 2, dnd_tab = 128, dnd_none = -1 };
+	enum	{ TAB_ANIMATION_START, TAB_ANIMATION_STOP, PANE_ANIMATION_START, PANE_ANIMATION_STOP, ANIMATE_ALL};
+		
+private:
+	bool 				_dndsource;
+	bool 				_dndanim;
+	int  				_dndposition;
+	int  				_dndtype;
+};
+
+//----------------------------------------------------------------------------------------------
+
+class DockBase : public TopWindow
+{
+public:
+	typedef DockBase CLASSNAME;
+
+	Ctrl& 				Dock(DockableCtrl& ctrl);
+	DockableCtrl&		Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2);
+	DockableCtrl&		Tabify(String groupname, DockableCtrl& ctrl1, DockableCtrl& ctrl2);
+	DockableCtrl&		Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2, DockableCtrl& ctrl3, DockableCtrl& ctrl4);
+	DockableCtrl&		Tabify(String groupname, DockableCtrl& ctrl1, DockableCtrl& ctrl2, DockableCtrl& ctrl3, DockableCtrl& ctrl4);
+
+	void				TabifyGroupAndDock(String groupname, int alignment);
+	void				TabifyGroupAndAutoHide(String groupname, int alignment);
+	void				TabifyGroupAndFloat(String groupname);
+
+	void				AllowAll();
+	void				AllowLeft();								
+	void				AllowTop();							
+	void				AllowRight();						
+	void				AllowBottom();								
+	void				AllowLeftRight();							
+	void				AllowTopBottom();						
+	void				AllowLeftTop();					
+	void				AllowRightBottom();						
+	void				AllowLeftBottom();						
+	void				AllowTopRight();					
+
+	void				AllowNestedTabbing(bool b = true);
+		
+	void				ShowLeftPane(bool b = true);
+	void				ShowTopPane(bool b = true);
+	void				ShowRightPane(bool b = true);
+	void				ShowBottomPane(bool b = true);
+	
+	Ctrl& 				GetBase()									{ return (Ctrl&) *this;			}
+	PaneFrame& 			GetPaneFrame(int alignment)					{ return pane[alignment]; 		}
+	AutoHideBar& 		GetHideBar(int alignment)					{ return hide[alignment];		}
+	
+	void				ControlPanel();				
+	void 				RefreshWidgetLayout();
+	void 				ResetWidgetLayout();
+
+	void				SetKey(dword key)							{ hotkey = key; }
+	dword				GetKey()									{ return hotkey;}
+
+	void				AddWidgetLayout(String name, DockableCtrl& ctrl, int alignment, int state, int position = 0);
+	void				SetWidgetLayout(String name);
+	void				SetWidgetLayout(int index);
+
+	virtual bool		Key(dword key, int count);
+	virtual	void		Serialize(Stream& s);
+
+protected:
+	void				InitFrameWork();
+	void				InitDefaultLayout();
+	void				InitFrameWorkSettings();
+	
+	void				FrameWorkReady(bool b = true)				{ isready =  b;		}
+	bool				IsFrameWorkReady()							{ return isready; 	}
+	     
+private:
+	void 				Attach(DockableCtrl& ctrl);
+	void 				Attach(DockableCtrl* ctrl);
+	void 				Detach(DockableCtrl& ctrl);
+	void 				Detach(DockableCtrl* ctrl);
+	void 				DoDragAndDrop(DockableCtrl& ctrl, Point p, Size sz);
+
+private:
+	struct CtrlRecord : Moveable<CtrlRecord>
+	{
+		DockableCtrl* 	ctrl;
+		int				id;
+		CtrlRecord()	{ ctrl = NULL; id = 0; }
+	};
+	
+	void				AddCtrlRecord(DockableCtrl& ctrl);
+	void				RemoveCtrlRecord(DockableCtrl& ctrl);
+	void				DeleteCtrlRecords();
+	CtrlRecord*			GetCtrlRecord(DockableCtrl& ctrl);
+	CtrlRecord*			GetCtrlRecordFromIndex(int index);
+	CtrlRecord*			GetCtrlRecordFromGroup(String group);
+	CtrlRecord*			GetCtrlRecordFromId(int id);
+	Vector<CtrlRecord*>& GetCtrlRecords()							{ return ctrls; };
+
+	DockableCtrl*		GetDockedWindowFromIndex(int index);
+	TabWindow*			GetTabWindowFromIndex(int index);
+	int					GetTabWindowCount();
+	int					GetDockedWindowCount();
+
+//	TabWindow*			AddTabWindow();
+//	TabWindow*			AddTabWindow(DockableCtrl ctrl);
+	void				RemoveTabWindows();
+	void				RefreshTabWindowList();
+	Vector<TabWindow*>&	GetTabWindows();
+	
+	void				SerializeLayout(Stream& s, bool deflay = false);
+
+protected:
+	void				NewWidgetLayout(String name);
+	void				DelWidgetLayout(String name);
+	int					AddWidgetLayout(String name);
+
+	void				NewWidgetGroup(String name, bool predefined = false);
+	bool				AddWidgettoGroup(String name, DockableCtrl& ctrl);
+	bool				AddWidgettoGroup(String name, int id);
+	bool				DeleteWidgetfromGroup(String name, DockableCtrl& ctrl);
+	bool				DeleteWidgetfromGroup(String name, int id);	
+	int					AddWidgetGroup(String name);
+	void				DeleteWidgetGroup(String name);
+	Vector<int>&		FindWidgetGroup(String name);
+	bool				FindWidgetinGroup(String name, int id);
+
+private:
+	void				GroupDrop(int parent, int ii, PasteClip& d);	
+	void				GroupDrag();
+	void				GroupSelect();
+	void				GroupMenu(Bar& bar);
+	void				GroupDockMenu(Bar& bar, int command);
+	void				GroupTabifyMenu(Bar& bar, int command);
+	void				GroupMenuAction(String name, int command, int alignment);
+
+	void				RefreshGroups();
+	
+	DockableCtrl&		TabifyGroup(String name);
+			
+	void				SetSkin(int index);
+
+private:
+	int					skinindex;
+	int					layoutindex;
+	bool				tabsicons;
+	bool				tabsclose;
+	bool				tabsnested;
+	bool				tabsautoalign;
+	bool				autohideicons;
+	bool				autohideclose;
+	bool				isready;
+	bool				IsSideAllowed(int i)						{ return AllowedSides[i]; }
+	bool				AllowedSides[4];
+		
+private:
+	void 				OnPanelAction();
+	void 				OnSelectSkin ();
+	void				OnSelectLayout();
+	void				OnAddNewLayout();
+	void				OnDeleteLayout();
+	void				OnAddNewGroup();
+	void				OnDeleteGroup();
+	void 				RefreshPanel();
+	void				CleanUp();
+			
+private:
+	Size 				panesize;
+	PaneFrame 			pane[4];
+	AutoHideBar			hide[4];
+	dword				hotkey;
+	String				predefinedlayout;
+	String				predefinedgroup;
+	String				activegroup;
+
+	WithControlPanelLayout<TopWindow> 	controlpanel;
+	WithWidgetListLayout<ParentCtrl>	listtab;
+	WithWidgetGroupsLayout<ParentCtrl>	grouptab;
+	
+	TreeCtrl							grouptree;
+	TabCtrl								paneltab;
+		
+	Vector<TabWindow*>					tabwindows;
+	Array<ImageCtrl*> 					panelicons;
+	ArrayMap<String, String>			layouts;
+	ArrayMap<String, Vector<int> >		groups;
+	Vector<CtrlRecord*> 				ctrls;
+		
+	friend class 		DockableCtrl;
+	friend class 		DockWindow;
+	friend class 		TabWindow;
+	friend class 		PaneFrame;
+
+public:
+	const DockCtrlChStyle::Style* 	style;
+	DockBase& 						SetStyle(const DockCtrlChStyle::Style& s);
+	const DockCtrlChStyle::Style*  	GetStyle()	{ return style ? style : &DockCtrlChStyle::StyleDefault(); 	}
+
+public:
+	DockBase& WidgetGroup(String name);
+	DockBase& operator%(DockableCtrl& ctrl);
+	DockBase& WidgetLayout(String name);
+	DockBase& operator/(DockableCtrl& ctrl);
+
+public:
+	DockBase();
+	~DockBase();
+};
+
+class DockCtrl : public DockBase
+{
+public:
+	typedef DockCtrl CLASSNAME;
+	virtual void InitDockCtrl() 		{}	
+	virtual void InitCustomLayouts()	{}
+	void	State(int reason);
+	void	Serialize(Stream& s)		{ DockBase::Serialize(s); }
+private:
+	bool ctrlinit;
+	
+public:
+	DockCtrl();
+	~DockCtrl();
+};
+
+#endif
diff --git a/archive/DockCtrl/DockCtrl.lay b/archive/DockCtrl/DockCtrl.lay
new file mode 100644
index 000000000..4a392d393
--- /dev/null
+++ b/archive/DockCtrl/DockCtrl.lay
@@ -0,0 +1,31 @@
+LAYOUT(ControlPanelLayout, 444, 480)
+	ITEM(StaticText, dv___0, SetText(t_("Select skin:")).SetAlign(ALIGN_CENTER).LeftPosZ(8, 168).TopPosZ(8, 22))
+	ITEM(Button, layoutbutton, SetLabel(t_("Reset")).Tip(t_("Press to reset window layout.")).LeftPosZ(16, 82).BottomPosZ(18, 22))
+	ITEM(Button, layoutadd, SetLabel(t_("Add")).RightPosZ(80, 56).BottomPosZ(18, 22))
+	ITEM(Option, TabOptionIcon, SetLabel(t_("Show Icons")).LeftPosZ(20, 188).TopPosZ(64, 16))
+	ITEM(Option, TabOptionClose, SetLabel(t_("Show Buttons")).LeftPosZ(20, 188).TopPosZ(84, 16))
+	ITEM(Option, AutoOptionClose, SetLabel(t_("Show Buttons")).HSizePosZ(240, 16).TopPosZ(84, 16))
+	ITEM(Option, AutoOptionIcon, SetLabel(t_("Show Icons")).HSizePosZ(240, 16).TopPosZ(64, 16))
+	ITEM(DropList, skinlist, HSizePosZ(192, 8).TopPosZ(8, 22))
+	ITEM(LabelBox, TabOptions, SetLabel(t_("Tab Options")).LeftPosZ(8, 208).TopPosZ(44, 108))
+	ITEM(Option, TabOptionNest, SetLabel(t_("Allow Nested Tabs")).LeftPosZ(20, 188).TopPosZ(124, 16))
+	ITEM(Option, TabOptionAlignment, SetLabel(t_("Auto Align Tabs")).LeftPosZ(20, 188).TopPosZ(104, 16))
+	ITEM(LabelBox, AutoOptions, SetLabel(t_("AutoHide Options")).HSizePosZ(228, 8).TopPosZ(44, 108))
+	ITEM(LabelBox, dv___12, SetLabel(t_("Layout Settings")).HSizePosZ(8, 8).BottomPosZ(8, 52))
+	ITEM(DropList, layoutlist, HSizePosZ(104, 148).BottomPosZ(18, 22))
+	ITEM(Button, layoutdelete, SetLabel(t_("Delete")).RightPosZ(16, 56).BottomPosZ(18, 22))
+	ITEM(TabCtrl, panel, HSizePosZ(8, 8).VSizePosZ(160, 72))
+END_LAYOUT
+
+LAYOUT(WidgetListLayout, 376, 236)
+	ITEM(ArrayCtrl, list, HorzGrid(false).VertGrid(false).AskRemove(false).AutoHideSb(true).SetFrame(FieldFrame()).HSizePosZ(10, 10).VSizePosZ(48, 12))
+	ITEM(Label, dv___1, SetLabel(t_("Below are the available dockable window.\nLeft clicking on the items will popup the action menu for the selected item.")).HSizePosZ(10, 10).TopPosZ(8, 36))
+END_LAYOUT
+
+LAYOUT(WidgetGroupsLayout, 404, 300)
+	ITEM(TreeCtrl, grouptree, HSizePosZ(8, 8).VSizePosZ(44, 4))
+	ITEM(Button, groupdelete, SetLabel(t_("Delete")).RightPosZ(8, 56).TopPosZ(12, 22))
+	ITEM(Button, groupadd, SetLabel(t_("Add")).RightPosZ(76, 56).TopPosZ(12, 22))
+	ITEM(Label, dv___3, SetLabel(t_("You can use Drag/Drop to change Widget groups.\nRight click on groups/items for action menu. ")).HSizePosZ(8, 144).TopPosZ(7, 32))
+END_LAYOUT
+
diff --git a/archive/DockCtrl/DockCtrl.t b/archive/DockCtrl/DockCtrl.t
new file mode 100644
index 000000000..f0e57474d
--- /dev/null
+++ b/archive/DockCtrl/DockCtrl.t
@@ -0,0 +1,999 @@
+#ifdef _MSC_VER
+#pragma setlocale("C")
+#endif
+// DockCtrl.cpp
+
+T_("LEFT")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("LINKS")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ЛЕВАЯ ГРАНИЦА")
+srSP("")
+trTR("SOL")
+
+T_("TOP")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("OBEN")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ВЕРХНЯЯ ГРАНИЦА")
+srSP("")
+trTR("ÜST")
+
+T_("RIGHT")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("RECHTS")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ПРАВАЯ ГРАНИЦА")
+srSP("")
+trTR("SAĞ")
+
+T_("BOTTOM")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("UNTEN")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("НИЖНЯЯ ГРАНИЦА")
+srSP("")
+trTR("ALT")
+
+T_("FLOATING")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("GLEITEND")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ОТДЕЛЕНО")
+srSP("")
+trTR("BAĞIMSIZ")
+
+T_("NONE")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("LEER")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("НИ ОДИН")
+srSP("")
+trTR("YOK")
+
+T_("SHOWN")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("SICHTBAR")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ОТОБРАЖЕНО")
+srSP("")
+trTR("GÖRÜNÜR")
+
+T_("HIDDEN")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("VERSTECKT")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("СКРЫТО")
+srSP("")
+trTR("GİZLİ")
+
+T_("AUTO HIDDEN")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("AUTOMATISCH VERSTECKEN")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("АВТОСКРЫТИЕ")
+srSP("")
+trTR("OTOMATİK GİZLİ")
+
+T_("SHUT")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("GESCHLOSSEN")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ЗАКРЫТО")
+srSP("")
+trTR("KAPALI")
+
+T_("TABBED")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("REGISTERKARTE")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("ВЛОЖЕНО")
+srSP("")
+trTR("SEKMELİ")
+
+T_("Default")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Základní")
+deDE("Voreinstellung")
+esES("Por defecto")
+fiFI("Oletus")
+frFR("Par défaut")
+huHU("Alapértelmezett")
+ruRU("По умолчанию")
+srSP("Podrazumevano")
+trTR("Varsayılan")
+
+T_("Settings")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Einstellungen")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Настройки")
+srSP("")
+trTR("Ayarlar")
+
+T_("Window Title")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Fenstername")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Заголовок окна")
+srSP("")
+trTR("Pencere Başlığı")
+
+T_("Alignment")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("&Zarovnat:")
+deDE("Ausrichtung")
+esES("")
+fiFI("Kohdistus")
+frFR("Alignement")
+huHU("Igazítás")
+ruRU("Выравнивание")
+srSP("Poravnanje:")
+trTR("Kenar")
+
+T_("State")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Status")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Статус")
+srSP("")
+trTR("Durum")
+
+T_("Position")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Position")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Позиция")
+srSP("")
+trTR("Konum")
+
+T_("Status")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Durum")
+
+T_("Group Manager")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Grup Yöneticisi")
+
+T_("Classic")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Klassisch")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Классический")
+srSP("")
+trTR("Klasik")
+
+T_("Enhanced")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Erweitert")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Расширенный")
+srSP("")
+trTR("Gelişmiş")
+
+T_("Add new layout")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Сохранить размещение")
+srSP("")
+trTR("Pencere Düzeni ekle")
+
+T_("Layout name:")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Pencere düzeni adı:")
+
+T_("You must enter a name for the new layout")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Вы должны ввести имя для нового размещения")
+srSP("")
+trTR("Yeni pencere düzeni için bir isim girmelisiniz")
+
+T_("Layout '%s' adready exists. Do you want to overwrite it?")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Размещение '%s' уже существует. Переписать?")
+srSP("")
+trTR("'%s' adında pencere düzeni mevcut. Üzerine yazmak ister misiniz?")
+
+T_("Do you really want to delete layout '%s'?")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' adlı pencere düzenini gerçekten silmek istiyor musunuz?")
+
+T_("Error: Widget (%s) is already in the group '%s'.")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Hata: Widget (%s) zaten '%s' grubunun içinde var.")
+
+T_("Do you really want to delete group '%s'")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Gerçekten '%s' grubunu silmek istiyor musunuz?")
+
+T_("Add new group")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Yeni grup ekle")
+
+T_("Group name:")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Grup adı:")
+
+T_("You must enter a name for the new group")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Yeni grup için bir grup adı girmelisiniz")
+
+T_("Group '%s' adready exists. Do you want to overwrite it?")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' grubu zaten mevcut. Üzerine yazmak ister misiniz?")
+
+T_("Available Widget Groups")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Mevcut Widget Grupları")
+
+T_("Dock Group '%s'")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' Grubunu Yasla")
+
+T_("AutoHide Group '%s'")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' Grubunu Otomatik Gizle")
+
+T_("Float Group '%s'")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' Grubunu Kaydır")
+
+T_("Tabify Group '%s' and...")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' Grubunu Sekmeli Yap ve...")
+
+T_("Delete Group '%s'")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' Grubunu Sil")
+
+T_("Close Group '%s'")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("'%s' Grubunu Kapat")
+
+T_("Add New Group...")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Yeni Grup Ekle...")
+
+T_("Top")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Nahoře")
+deDE("Oben")
+esES("")
+fiFI("Ylä")
+frFR("Haut")
+huHU("Felső szél")
+ruRU("Верх")
+srSP("Vrh")
+trTR("Üst")
+
+T_("Left")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Vlevo")
+deDE("Links")
+esES("")
+fiFI("Vasen")
+frFR("Gauche")
+huHU("Bal")
+ruRU("Влево")
+srSP("Levo")
+trTR("Sol")
+
+T_("Right")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Vpravo")
+deDE("Rechts")
+esES("")
+fiFI("Oikea")
+frFR("Droite")
+huHU("Jobb")
+ruRU("Вправо")
+srSP("Desno")
+trTR("Sağ")
+
+T_("Bottom")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Dole")
+deDE("Unten")
+esES("")
+fiFI("Ala")
+frFR("Base")
+huHU("Alsó szél")
+ruRU("Низ")
+srSP("Dno")
+trTR("Alt")
+
+T_("Dock")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Einratsen")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Разместить")
+srSP("")
+trTR("Yasla")
+
+T_("Auto Hide")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Automatisch verstecken")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Автоскрытие")
+srSP("")
+trTR("Otomatik Gizle")
+
+T_("Float")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Gleiten")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Отделить")
+srSP("")
+trTR("Kaydır")
+
+
+// DockTabs.cpp
+
+T_("")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("")
+
+T_("Untitled")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Ohne Namen")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Безымянный")
+srSP("")
+trTR("Adsız")
+
+
+// DockWindow.cpp
+
+T_("Close")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Zavřít")
+deDE("Schließen")
+esES("Cerra")
+fiFI("Sulje")
+frFR("Fermer")
+huHU("Bezár")
+ruRU("Закрыть")
+srSP("Zatvori")
+trTR("Kapat")
+
+T_("Auto Hide")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Automatisch verstecken")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Автоскрытие")
+srSP("")
+trTR("Otomatik Gizle")
+
+T_("Window Position")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Fensterposition")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Позиция окна")
+srSP("")
+trTR("Pencere Konumu")
+
+T_("Show")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Zeigen")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Показать")
+srSP("")
+trTR("Göster")
+
+T_("Hide")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Verstecken")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Скрыть")
+srSP("")
+trTR("Gizle")
+
+T_("Tabbed Window")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Registerkartenfenster")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Окно со вкладками")
+srSP("")
+trTR("Yeni Sekme")
+
+
+// DockCtrl.lay
+
+T_("Select skin:")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Wählen Sie das Erscheinungsbild:")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Выбрать оформление:")
+srSP("")
+trTR("Kaplama:")
+
+T_("Reset")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("Nulovat")
+deDE("Zurücksetzen")
+esES("")
+fiFI("Resetoi")
+frFR("Réinitialiser")
+huHU("Kiinduló állapot")
+ruRU("Сбросить")
+srSP("Vrati")
+trTR("Sıfırla")
+
+T_("Press to reset window layout.")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Bitte betätigen, um Fensteranordnung zurückzusetzen.")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Нажмите для сброса положения элементов.")
+srSP("")
+trTR("Pencere düzenini sıfırlamak için tıklayın")
+
+T_("Add")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Ekle")
+
+T_("Show Icons")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Zeige Icons")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Показывать иконки")
+srSP("")
+trTR("Simgeleri Göster")
+
+T_("Show Buttons")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Zeige Buttons")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Показывать кнопки")
+srSP("")
+trTR("Düğmeleri Göster")
+
+T_("Tab Options")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Registerkertenoptionen")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Опции вкладок")
+srSP("")
+trTR("Sekmeli Pencere Seçenekleri")
+
+T_("Allow Nested Tabs")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("Erlaube verschachtelte Registerkarten")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Разрешить вкладки")
+srSP("")
+trTR("İçiçe Sekmelere İzin Ver")
+
+T_("Auto Align Tabs")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Sekmeleri Otomatik Düzenle")
+
+T_("Auto Hide Options")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Otomatik Gizleme Seçenekleri")
+
+T_("Layout Settings")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Pencere Düzeni Ayarları")
+
+T_("Delete")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Sil")
+
+T_("Below are the available dockable window.\nLeft clicking on the items will "
+     "popup the action menu for the selected item.")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Mevcut yaslanabilir pencereler aşağıdadır.\nİşlemler menüsüne ulaşmak için "
+	"istediğiniz öğenin üzerine sol tıklayın.")
+
+T_("You can use Drag/Drop to change Widget groups.\nRight click on groups/items "
+     "for action menu. ")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("")
+srSP("")
+trTR("Widget gruplarını değiştirmek için Sürükle/Bırak yapabilirsiniz.")
+
+
+// Obsolete
+
+T_("Do you really want to delete layout '%s' ?")
+afZA("")
+beBY("")
+bgBG("")
+csCZ("")
+deDE("")
+esES("")
+fiFI("")
+frFR("")
+huHU("")
+ruRU("Удалить размещение '%s' ?")
+srSP("")
+trTR("'%s' adlı pencere düzenini gerçekten silmek istiyor musunuz?")
diff --git a/archive/DockCtrl/DockCtrl.upp b/archive/DockCtrl/DockCtrl.upp
new file mode 100644
index 000000000..78363d4e6
--- /dev/null
+++ b/archive/DockCtrl/DockCtrl.upp
@@ -0,0 +1,30 @@
+description "Dockable/dynamic widget framework by İsmail Yılmaz";
+
+uses
+	CtrlCore,
+	CtrlLib,
+	Draw;
+
+file
+	READMEFIRST.txt,
+	"Header Files" readonly separator,
+	DockCtrl.h,
+	"Source Files" readonly separator,
+	AutoHideBar.cpp,
+	PaneSplitter.cpp,
+	PaneFrame.cpp,
+	DockCtrl.cpp charset "UTF-8",
+	DockTabs.cpp,
+	DockWindow.cpp,
+	DockableCtrl.cpp,
+	Resources readonly separator,
+	DockableCtrl.iml,
+	DockCtrl.lay,
+	DockCtrl.t charset "UTF-8",
+	"Other Files" readonly separator,
+	TODO.txt,
+	ChangeLog.txt;
+
+mainconfig
+	"" = "GUI";
+
diff --git a/archive/DockCtrl/DockTabs.cpp b/archive/DockCtrl/DockTabs.cpp
new file mode 100644
index 000000000..c2228fc2a
--- /dev/null
+++ b/archive/DockCtrl/DockTabs.cpp
@@ -0,0 +1,890 @@
+#include "DockCtrl/DockCtrl.h"
+
+#define IMAGECLASS DockCtrlImgs
+#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
+#include <Draw/iml_source.h>
+
+
+void DockCtrlCustomFrame::FrameLayout(Rect& r)
+{
+	switch(layout)
+	{
+		case LAYOUT_LEFT:
+			LayoutFrameLeft(r, this, size);
+			break;
+		case LAYOUT_TOP:
+			LayoutFrameTop(r, this, size);
+			break;
+		case LAYOUT_RIGHT:
+			LayoutFrameRight(r, this, size);
+			break;
+		case LAYOUT_BOTTOM:
+			LayoutFrameBottom(r, this, size);
+			break;
+	}
+}
+
+void DockCtrlCustomFrame::FrameAddSize(Size& sz)
+{
+	switch(layout)
+	{
+		case LAYOUT_LEFT:
+			sz.cx += size;
+			break;
+		case LAYOUT_TOP:
+			sz.cy += size;
+			break;
+		case LAYOUT_RIGHT:
+			sz.cx += size;
+			break;
+		case LAYOUT_BOTTOM:
+			sz.cy += size;
+			break;		
+	}	
+}
+
+DockCtrlCustomFrame& DockCtrlCustomFrame::SetStyle(const DockCtrlChStyle::Style& s)
+{ 
+	style = &s;
+	return *this;
+}
+
+const DockCtrlChStyle::Style* DockCtrlCustomFrame::GetStyle()
+{
+ 	return style ? style : &DockCtrlChStyle::StyleDefault(); 	
+}
+
+
+//----------------------------------------------------------------------------------------------
+
+void TabInterface::Add(String name, bool activate)
+{
+	Tab &t = tabs.Add();
+	if(IsNull(name) || name == t_("")) name = t_("Untitled");
+	else t.name 	= name;
+	t.id 			= GetNextId();
+	t.active 		= activate;
+	t.visible 		= true;
+	t.highlighted 	= false;
+	t.icon			= DockCtrlImgs::DefaultImage();
+	ReposTabs();
+	SetActiveTab(tabs.GetCount() - 1);
+}
+
+void TabInterface::Add(DockableCtrl& dock, bool activate)
+{
+	Tab &t = tabs.Add();
+	if(dock.GetLabel().IsVoid() || dock.GetLabel() == t_("")) t.name = t_("Untitled");
+	else t.name 	= dock.GetLabel();
+	t.id 			= GetNextId();
+	t.active 		= activate;
+	t.visible 		= true;
+	t.highlighted 	= false;
+	t.icon			= dock.GetIcon();
+	t.dock			= &dock;
+	ReposTabs();
+	SetActiveTab(tabs.GetCount() - 1);
+}
+
+void TabInterface::Remove(DockableCtrl& dock)
+{
+}
+
+void TabInterface::Remove(int n)
+{
+}
+
+void TabInterface::Close(int n)
+{
+	if(tabs.GetCount() < 1 || n >= tabs.GetCount())			// !!!
+			return;
+	int c 	= Find(tabs[n].id);
+	int nc	= GetNext(c);
+	if(nc < 0)
+		nc = max(0, GetPrev(c));
+
+	if(hasscrollbar) scrollbar.AddTotal(-tabs[n].cx);
+	tabs.Remove(n);
+	ReposTabs();
+	SetActiveTab(nc);
+}
+
+void TabInterface::CloseAll()
+{
+	for(int i = tabs.GetCount() - 1; i >= 0; i--)
+	{
+			tabs.At(i).dock = NULL;
+			tabs.At(i).id	= -1;
+			tabs.Remove(i);
+	}
+	if(hasscrollbar) scrollbar.SetTotal(0);//scrollbar.SetTotal(tabs[0].cx);
+	ReposTabs();
+	SetActiveTab(-1);	
+	id = -1;
+}
+
+void TabInterface::SetActiveTab(int n)
+{
+	int tabcount = tabs.GetCount();
+
+	if(tabcount == 0) 
+		return;
+
+	if(n < 0 || n >= tabcount)
+		n = max(0, tabcount - 1);
+	
+	Tab& t = tabs[active = n];
+	int cx = t.x - (int(hasscrollbar) * scrollbar.GetPos());
+	if(hasscrollbar)
+	{
+		if(cx < 0)
+			scrollbar.AddPos(cx - 10);
+		else
+		{
+			cx = t.x + t.cx - GetSize().cx - scrollbar.GetPos();
+			if(cx > 0)
+				scrollbar.AddPos(cx + 10);
+		}
+	}
+	if(HasMouse())MouseMove(GetMouseViewPos(), 0);
+	UpdateActionRefresh();
+	WhenSelect();
+}
+
+void TabInterface::SetActiveTab(DockableCtrl& dock)
+{
+	SetActiveTab(Find(dock));	
+}
+
+void TabInterface::SetActiveTabTitle(String name, Image icon)
+{
+	if(active < 0) return;
+	Tab& t = tabs.At(active);
+	t.name = name;
+	t.icon = icon;
+	ReposTabs();
+}
+
+TabInterface& TabInterface::HasScrollBar(bool b)
+{
+	if(b)
+	{
+		AddFrame(scrollbar); 
+		scrollbar.WhenScroll = THISBACK(OnScrollBar);
+	}
+	else 
+		RemoveFrame(scrollbar);
+	Refresh();	 
+	hasscrollbar = b;
+	return *this;
+}
+
+int TabInterface::GetActiveTab()
+{
+	return active;
+}
+
+int TabInterface::Find(int itemid)
+{
+	for(int i = 0; i < tabs.GetCount(); i++)
+		if(tabs[i].id == itemid) return i;
+	return -1;
+}
+
+int TabInterface::Find(DockableCtrl& dock)
+{
+	for(int i = 0; i < tabs.GetCount(); i++)
+		if(tabs[i].dock == &dock) return i;
+	return -1;
+}
+
+int TabInterface::GetNext(int n)
+{
+	for(int i = n + 1; i < tabs.GetCount(); i++)
+		if(tabs[i].visible) return i;
+	return -1;
+}
+
+int TabInterface::GetPrev(int n)
+{
+	for(int i = n - 1; i >= 0; i--)
+		if(tabs[i].visible) return i;
+	return -1;
+}
+
+
+int TabInterface::GetWidth(int n)
+{
+	Tab &t = tabs[n];
+	t.textsize  	= GetTextSize(t.name, style->font);
+	return TAB_MARGIN * 2 + t.textsize.cx + ((hasfileicon ? TAB_SPACE : TAB_SPACE / 2) + DockCtrlImgs::DClose().GetSize().cx) * hastabbutton + (TAB_FILEICON + TAB_SPACEICON) * hasfileicon;
+}
+
+int TabInterface::GetWidth()
+{
+	return tabs[tabs.GetCount() - 1].Right() + style->margin * 2;
+}
+
+int TabInterface::GetHeight()
+{
+	return style->tabheight + style->sel.bottom + (int(hasscrollbar) * (TAB_SBHEIGHT + TAB_SBSEPARATOR));
+}
+
+void TabInterface::ReposTabs()
+{
+	if(!tabs.GetCount())
+		return;
+
+	int j = 0;
+	bool first = true;
+	for(int i = 0; i < tabs.GetCount(); i++)
+	{
+		tabs[i].x = first ? 0 : tabs[j].Right();
+		j = i;
+		first = false;
+		tabs[i].visible = true;
+		tabs[i].y = 0;
+		tabs[i].cx = GetWidth(i);
+		tabs[i].cy = style->tabheight + style->sel.top;
+	}
+	if(hasscrollbar) scrollbar.SetTotal(GetWidth());
+}
+
+void TabInterface::DrawLabel(Draw& w, int x, int y, Tab& t, bool isactive)
+{
+	String fn = GetFileName(t.name);
+
+	if(horizontal)
+		DrawFileName(w, x + TAB_MARGIN + (TAB_FILEICON + TAB_SPACEICON) * int(hasfileicon), (y - t.textsize.cy) / 2,
+	             t.textsize.cx, t.textsize.cy, fn.ToWString(),
+	            false, StdFont(), Black, LtBlue, 
+	            Null, Null, false);
+	else
+		w.DrawText((y + t.textsize.cy) / 2 + 1, 
+				x + TAB_MARGIN + (TAB_FILEICON + TAB_SPACEICON) * int(hasfileicon),
+				2700, fn.ToWString(), 
+				style->font);
+}
+
+void TabInterface::DrawTab(Draw& w, Size &sz, int i)
+{
+	Size isz 	= DockCtrlImgs::DClose().GetSize();
+	int cnt 	= tabs.GetCount();
+	Tab &t 		= tabs[i];
+
+	bool ac 	= i == active;
+	bool hl 	= i == highlight;
+		
+	int lx   = i > 0 ? style->extendleft : 0;
+	int x    = t.x - (hasscrollbar ? scrollbar.GetPos() : 0) + style->margin - lx;
+
+	int ndx = !IsEnabled() ? CTRL_DISABLED :
+		       ac ? CTRL_PRESSED :
+		       hl ? CTRL_HOT : CTRL_NORMAL;
+
+	Image nimg;
+	
+	int cx = t.cx + lx + (ac ? style->sel.right + style->sel.left : 0);
+	int cy = ac ? t.cy - style->sel.top + style->sel.bottom : t.cy - style->sel.top;
+	
+	int h = style->sel.top + style->sel.bottom;
+	int hs = ac ? 0 : h;
+	if(layout == LAYOUT_RIGHT || layout == LAYOUT_BOTTOM)
+		hs = -hs;
+	
+	ImageDraw img(cx, cy);
+				
+	img.DrawRect(0, 0, cx, cy, SColorFace);
+
+	               
+	const Value& sv = (cnt == 1 ? style->both : i == 0 ? style->first : i == cnt - 1 ? style->last : style->normal)[ndx];
+
+	ChPaint(img, 0, 0, cx, cy, sv);
+
+	if(hastabbutton && tabs.GetCount())
+		img.DrawImage(t.cx - isz.cx - TAB_MARGIN, 
+				(cy + h - isz.cy) / 2,
+				(ac || hl) ? (tabbutton == i ? DockCtrlImgs::DCloseh : 
+				ac ? DockCtrlImgs::DCloses : DockCtrlImgs::DClose) : 
+				DockCtrlImgs::DClose);
+
+	if(hasfileicon)
+		img.DrawImage(TAB_MARGIN, (cy + h - t.icon.GetSize().cx) / 2, t.icon);
+	
+	int shift = 0;
+	switch(layout)
+	{
+		case LAYOUT_LEFT:
+			nimg = MirrorVert(RotateAntiClockwise(img));
+			break;
+		case LAYOUT_TOP:
+			nimg = img;	
+			break;
+		case LAYOUT_RIGHT:
+			nimg = RotateClockwise(img);
+			shift = TAB_SBSEPARATOR;
+			break;
+		case LAYOUT_BOTTOM:
+			nimg = MirrorVert(img);
+			shift = TAB_SBSEPARATOR;
+			break;
+	}
+
+	if(ac) 
+		w.DrawImage(horizontal ? x - style->sel.left : shift, 
+		            horizontal ? shift : x - style->sel.left, 
+		            nimg);
+	else
+		w.DrawImage(horizontal ? x : style->sel.left - shift, 
+		            horizontal ? style->sel.top - shift : x,
+		            nimg);
+
+	DrawLabel(w, x, cy + hs, t, ac); 	
+}
+
+void TabInterface::Paint(Draw& d)
+{
+	Size sz = GetSize();
+	d.DrawRect(sz, SColorFace());
+
+	if(!horizontal)
+		d.DrawRect(layout == LAYOUT_LEFT ? sz.cx - 1: 0, 0, 
+				1, sz.cy, LtGray());
+	else
+		d.DrawRect(0, layout == LAYOUT_TOP ? sz.cy  - 1 : 0, 
+				sz.cx, 1, LtGray());
+
+	Fix(sz);
+	
+	int tabcount = tabs.GetCount();
+	
+	for(int i = 0; i < tabcount; i++)
+		if(tabs[i].IsVisible() && active != i && i < tabcount)
+			DrawTab(d, sz, i);
+	
+	if(active >= 0 && active < tabcount)
+		DrawTab(d, sz, active);
+
+	if(target >= 0)
+	{
+		int last = tabs.GetCount() - 1;
+		int first = 0;
+
+		if(target != active && target != active + 1)
+		{
+
+			int x = (target == last + 1 ? tabs[last].Right() : tabs[target].x)
+			        - (hasscrollbar ? scrollbar.GetPos() : 0) - (target <= first ? 1 : 2)
+			        + style->margin - (target > 0 ? style->extendleft : 0);
+
+			int y = style->sel.top;
+			
+			int cy = sz.cy - y;
+			
+			Color c(255, 0, 0);
+
+			if(horizontal)
+			{
+				d.DrawRect(x + 1, y, 2, cy, c);
+				d.DrawRect(x, y, 4, 1, c);
+				d.DrawRect(x, y + cy - 1, 4, 1, c);
+			}
+			else
+			{
+				Swap(x, y);
+				d.DrawRect(x, y + 1, cy, 2, c);
+				d.DrawRect(x, y, 1, 4, c);
+				d.DrawRect(x + cy - 1, y, 1, 4, c);				
+			}
+		}
+	}
+}
+
+void TabInterface::LeftDown(Point p, dword keyflags)
+{
+	if(keyflags & K_SHIFT)
+	{
+		highlight = -1;
+		Refresh();
+		SetCapture();
+		oldp = p;
+		return;
+	}
+
+	isctrl = keyflags & K_CTRL;
+	if(isctrl)
+		return;
+
+	if(tabbutton >= 0)
+	{
+		int i = Find(tabbutton);
+		if(i == -1 && active >= 0)
+			i = active;
+		
+		if(i >= 0)
+		{
+			DockableCtrl* dock = tabs[i].dock;
+			if(dock) 
+				WhenClose(tabbutton, *dock);			
+		}
+	}
+	
+	if(highlight >= 0)
+	{
+		SetActiveTab(highlight);
+		if(active >= 0)
+			WhenActive(active, *tabs[active].dock);
+	}
+}
+
+void TabInterface::LeftUp(Point p, dword keyflags)
+{
+	ReleaseCapture();
+}
+
+void TabInterface::MiddleDrag(Point p, dword keyflags)
+{
+	if(!isdraggable) return;
+	isdragged = true;
+	DoDragAndDrop(InternalClip(*this, Format(internalname, this)));
+}
+
+void TabInterface::LeftDrag(Point p, dword keyflags)
+{
+	if(keyflags & K_SHIFT)
+		return;
+	if(highlight < 0)
+		return;
+
+	if(isctrl)
+	{
+		isdragged = true;
+		DoDragAndDrop(InternalClip(*this, Format(internalname, this)));
+		return;
+	}
+	
+	if(highlight >= 0)
+	{
+		Fix(p);
+		SetActiveTab(highlight);
+		p.x += (int(hasscrollbar) * scrollbar.GetPos());
+		if(tabs[active].HasMouse(p))
+			WhenDrag(active, *tabs[active].dock);
+	}
+
+}
+
+
+void TabInterface::RightDown(Point p, dword keyflags)
+{
+	if(highlight >= 0) 
+		SetActiveTab(highlight);
+	WhenContext(active, *tabs[active].dock);
+}
+
+void TabInterface::RightUp(Point p, dword keyflags)
+{
+}
+
+
+void TabInterface::MouseMove(Point p, dword keyflags)
+{
+	Fix(p);
+	if(HasCapture() && hasscrollbar)
+	{
+		scrollbar.AddPos(p.x - oldp.x, true);
+		oldp = p;
+		return;
+	}
+	
+	p.x += (int(hasscrollbar) * scrollbar.GetPos()) - style->margin + style->extendleft;
+	Size sz = GetSize();
+	Fix(sz);	
+	int h = highlight;
+	bool istabbutton = false;
+	bool istab = false;
+	for(int i = 0; i < tabs.GetCount(); i++)
+	{
+		if(tabs[i].HasMouse(p))
+		{
+			istab = true;
+			//int h = sz.cy + (active == i ? 0 : style->sel.top);
+			int h = style->sel.top + style->sel.bottom;
+			int hs = active == i ? style->sel.top : h;
+			if(layout == LAYOUT_RIGHT || layout == LAYOUT_BOTTOM)
+				hs = -hs;
+			hs += sz.cy;
+			int ws = active == i ? style->sel.left : 0;			
+			istabbutton = hastabbutton ? tabs[i].HasMouseButton(p, ws, hs) : false;
+			if(highlight != i || (istabbutton && tabbutton != i))
+			{
+				tabbutton = istabbutton ? i : -1;
+				highlight = i;
+				WhenHighlight();
+				Refresh();
+				return;
+			}
+		}
+	}
+
+	if(!istab && h >= 0)
+	{
+		highlight = -1;
+		WhenHighlight();
+		Refresh();
+	}
+
+	if(!istabbutton && tabbutton >= 0)
+	{
+		tabbutton = -1;
+		Refresh();
+	}
+}
+
+void TabInterface::MouseWheel(Point p, int zdelta, dword keyflags)
+{
+	if(!hasscrollbar) return;
+	scrollbar.AddPos(-zdelta / 4, true);
+	MouseMove(p, 0);
+}
+
+
+void TabInterface::MouseLeave()
+{
+	if(isdragged)
+		return;
+	highlight 	= -1;
+	tabbutton 	= -1;
+	Refresh();
+}
+
+int TabInterface::GetTargetTab(Point p)
+{
+	Fix(p);
+	p.x += (hasscrollbar ? scrollbar.GetPos() : 0);
+
+	int f = 0;
+	int l = tabs.GetCount() - 1;
+
+	if(tabs[f].visible && p.x < tabs[f].x + tabs[f].cx / 2)
+		return f;
+
+	for(int i = l; i >= f; i--)
+		if(tabs[i].visible && p.x >= tabs[i].x + tabs[i].cx / 2)
+			return i == l ? i + 1 : GetNext(i);
+	return -1;
+}
+
+int TabInterface::GetSourceTab(Point p)
+{
+	int cnt = tabs.GetCount();
+	if(((active >= 0 && active < cnt) || (highlight >= 0 && highlight < cnt))) 
+	{
+		for(int i = tabs.GetCount() - 1; i >= 0; i--)
+			if(tabs[i].visible && tabs[i].HasMouse(p))
+				return (source = i);
+	}
+	return (source = highlight);	
+}
+
+void TabInterface::DragAndDrop(Point p, PasteClip& d)
+{
+	int c = GetTargetTab(p);
+	int tab =  isctrl ? highlight : active;
+	if(tab == -1) return;
+		
+	bool sametab = c == tab || c == tab + 1;
+	bool internal = AcceptInternal<TabInterface>(d, internalname);
+
+	if(!sametab && d.IsAccepted())
+	{
+		if(internal)
+		{
+			int id = tabs[active].id;
+			Tab t = tabs[tab];
+			tabs.Insert(c, t);
+			tabs.Remove(tab + int(c < tab));
+			active = Find(id);
+			isdragged = false;
+			ReposTabs();
+			return;
+		}
+		else if(d.IsPaste())
+		{
+			CancelMode();
+			return;
+		}
+	}
+	else
+	{
+		//d.Reject();
+		//unfortunately after Reject DragLeave stops working until d is accepted
+	}
+
+	if(c != target)
+	{
+		target = c;
+		Refresh();
+	}
+}
+
+void TabInterface::DragEnter()
+{
+}
+
+void TabInterface::DragLeave()
+{
+	target = -1;
+	Refresh();
+}
+
+void TabInterface::DragRepeat(Point p)
+{
+	{
+		int dx = GetDragScroll(this, p, 16).x;
+		if(dx != 0 && hasscrollbar)
+			scrollbar.AddPos(dx);
+	}
+}
+
+void TabInterface::CancelMode()
+{
+	isdragged = false;
+	target = -1;
+	Refresh();
+}
+
+
+TabInterface& TabInterface::SetLayout(int l)
+{
+	DockCtrlCustomFrame::SetLayout(l);
+	switch(l)
+	{
+		case LAYOUT_LEFT:
+			horizontal = scrollbar.horizontal = false;
+			scrollbar.SetLayout(LAYOUT_RIGHT);
+			break;
+		case LAYOUT_TOP:
+			horizontal = scrollbar.horizontal = true;
+			scrollbar.SetLayout(LAYOUT_BOTTOM);
+			break;
+		case LAYOUT_RIGHT:
+			horizontal = scrollbar.horizontal = false;
+			scrollbar.SetLayout(LAYOUT_LEFT);
+			break;
+		case LAYOUT_BOTTOM:
+			horizontal = scrollbar.horizontal = true;
+			scrollbar.SetLayout(LAYOUT_TOP);
+			break;
+	}
+	RefreshLayout();
+	return *this;	
+}
+
+TabInterface::TabInterface()
+{
+	internalname = "tabs";
+	
+	id			= -1;
+	active		= -1;
+	highlight	= -1;
+	visible  	= -1;
+	fileicon	= -1;
+	tabbutton	= -1;
+	target 		= -1;	// drag target.
+	source		= -1;	// drag source.
+	
+	hasfileicon		= false;
+	hastabbutton 	= true;
+	isdraggable		= true;
+	isctrl 			= false;
+	isdragged		= false;
+	
+	SetStyle(TabCtrl::StyleDefault());
+	DockCtrlCustomFrame::layout = LAYOUT_BOTTOM;
+	HasScrollBar(true);
+	SetSize(GetHeight() + 2);	
+	BackPaint();
+}
+
+TabInterface::~TabInterface()
+{
+	for(int i = 0; i < tabs.GetCount(); i++)
+		tabs.Remove(i);
+}
+
+//----------------------------------------------------------------------------------------------
+
+TabInterface::TabScrollBar::TabScrollBar()
+{
+	DockCtrlCustomFrame::layout = LAYOUT_TOP;
+	DockCtrlCustomFrame::SetSize(TAB_SBHEIGHT);
+
+	total = 0;
+	pos = 0;
+	ps = 0;
+	start_pos = 0;
+	new_pos = 0;
+	old_pos = 0;
+	ready = false;
+}
+
+void TabInterface::TabScrollBar::Paint(Draw &w)
+{
+	if(!ready)
+	{
+		UpdatePos();
+		ready = true;
+	}
+	Size sz = GetSize();
+	
+	w.DrawRect(sz, SColorFace());
+	
+	if(horizontal)
+	{
+		if(total > sz.cx)
+			w.DrawRect(ffloor(pos), 1, fceil(size), 2, Blue);
+		else
+			w.DrawRect(0, sz.cy - 1, sz.cx, 1,  White);
+	}
+	else
+	{
+		if(total > sz.cy)
+			w.DrawRect(1, ffloor(pos), 2, fceil(size), Blue);
+		else
+			w.DrawRect(sz.cx - 1, 0, 1, sz.cy, White);
+	}
+}
+
+void TabInterface::TabScrollBar::LeftDown(Point p, dword keyflags)
+{
+	SetCapture();
+	Fix(p);
+	old_pos = new_pos = p.x;
+	if(p.x < pos || p.x > pos + size)
+		start_pos = size / 2;
+	else
+		start_pos = UPP::tabs(p.x - pos);
+	UpdatePos();
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::LeftUp(Point p, dword keyflags)
+{
+	ReleaseCapture();
+	Fix(p);
+	old_pos = p.x;
+}
+
+void TabInterface::TabScrollBar::MouseMove(Point p, dword keyflags)
+{
+	if(!HasCapture())
+		return;
+	Fix(p);
+	new_pos = p.x;
+	UpdatePos();
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::MouseWheel(Point p, int zdelta, dword keyflags)
+{
+	AddPos(-zdelta / 4, true);
+}
+
+void TabInterface::TabScrollBar::Layout()
+{
+	UpdatePos(false);
+}
+
+int TabInterface::TabScrollBar::GetPos() const
+{
+	return ffloor(ps);
+}
+
+void TabInterface::TabScrollBar::SetPos(int p, bool dontscale)
+{
+	Fix(sz);
+	pos = total > 0 ? dontscale ? p : iscale(p, sz.cx, total) : 0;
+	UpdatePos(false);
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::AddPos(int p, bool dontscale)
+{
+	Fix(sz);
+	pos += total > 0 ? dontscale ? p : iscale(p, sz.cx, total) : 0;
+	UpdatePos(false);
+	Refresh();
+}
+
+int TabInterface::TabScrollBar::GetTotal() const
+{
+	return total;
+}
+
+void TabInterface::TabScrollBar::AddTotal(int t)
+{
+	total += t;
+	UpdatePos();
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::SetTotal(int t)
+{
+	bool upd = total < t;
+	total = t;
+	UpdatePos(upd);
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::GoEnd()
+{
+	pos = total;
+	UpdatePos(false);
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::GoBegin()
+{
+	pos = 0;
+	UpdatePos(false);
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::Set(const TabScrollBar& t)
+{
+	total = t.total;
+	pos = t.pos;
+	ps = t.ps;
+	Refresh();
+}
+
+void TabInterface::TabScrollBar::UpdatePos(bool update)
+{
+	sz = GetSize();
+	Fix(sz);
+	if(total <= 0 || sz.cx <= 0)
+		cs = ics = 0;
+	else
+	{
+		cs = sz.cx / ((double) total + 0.5);
+		ics = total / ((double) sz.cx);
+	}
+	size = sz.cx * cs;
+	if(update)
+		pos = new_pos - start_pos;
+	if(pos < 0)
+		pos = 0;
+	else if(pos + size > sz.cx)
+		pos = sz.cx - size;
+
+	ps = total > sz.cx ? pos * ics : 0;
+	WhenScroll();
+}
+
+TabInterface::TabScrollBar& TabInterface::TabScrollBar::SetLayout(int l)
+{
+	layout = l;
+	RefreshLayout();
+	return *this;	
+}
diff --git a/archive/DockCtrl/DockWindow.cpp b/archive/DockCtrl/DockWindow.cpp
new file mode 100644
index 000000000..c1b5f8c62
--- /dev/null
+++ b/archive/DockCtrl/DockWindow.cpp
@@ -0,0 +1,979 @@
+#include "DockCtrl/DockCtrl.h"
+
+#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
+#define IMAGECLASS DockWindowImages
+#include <Draw/iml.h>
+
+//===============================================
+// DockWindow class:
+// A dockable window widget.
+//===============================================
+
+DockWindow::DockWindow() : DockableCtrl()
+{
+	SetType(TYPE_DOCKWINDOW);
+
+	ownertab		= NULL;
+	ownerbar		= NULL;	
+	menubar			= NULL;
+	toolbar			= NULL;
+	statusbar		= NULL;
+	hasstatusbar	= false;
+	hasbarbuttons	= false;
+	hastoolbar		= false;
+	hasmenubar		= false;
+
+	shutbutton		<< THISBACK(OnShutButton);
+	autohidebutton	<< THISBACK(OnAutoHideButton);
+	menubutton		<< THISBACK(OnMenuButton);
+	
+	dragbar.SetOwner(this);
+	SetStyle(DockCtrlChStyle::StyleDefault());
+	SetFrame(FieldFrame());
+	ShowDragBar();
+	ShowDragBarButtons(true);
+	Sizeable().Zoomable().ToolWindow().TopMost(false).MinimizeBox().MaximizeBox().BackPaint();
+	WhenContextMenu	= THISBACK(DockWindowMenu);		
+
+}
+
+DockWindow::~DockWindow()
+{
+}
+
+void DockWindow::Dock(int alignment, int state, int position, bool sizecheck)
+{
+	if(Alignment() == alignment && (!IsHidden() && !IsAutoHidden())) return;
+	else if(IsTabbed())	GetOwnerTab()->Detach(*this);
+	else if(IsFloating()) ShutWindow();
+	else if(IsAutoHidden())	GetBase().GetHideBar(Alignment()).Detach(*this);
+	else 
+	{
+		if(sizecheck) ReSize();
+		GetBase().Detach(*this);
+	}
+	DockingStyle(alignment, state, position);
+	ShowDragBar();
+	GetBase().Dock(*this);
+}
+
+void DockWindow::FloatEx(Rect r)
+{
+	if(IsTabbed() && IsChild()) GetOwnerTab()->Detach(*this); 
+	else if(IsAutoHidden())	GetBase().GetHideBar(Alignment()).Detach(*this);
+	else if(!IsShut()) GetBase().Detach(*this);
+	OpenWindow(r.left, r.top, r.right, r.bottom);
+	DockingStyle(DOCK_NONE, STATE_SHOW, 0);
+	GetBase().RefreshPanel();
+}
+
+void DockWindow::Float()
+{
+	if(IsFloating()) return;
+	Rect  r  =  GetScreenView();
+	Point p  = GetMousePos();
+
+	if(IsTabbed())
+	{
+		GetOwnerTab()->Detach(*this); 	
+		Size sizehint = GetSizeHint();
+		r.left 	 = p.x - 4;
+		r.top	 = p.y + 4;
+		r.right  = p.x + sizehint.cx;
+		r.bottom = p.y + sizehint.cy;
+	}
+	else
+	{
+		if(r.top > p.y) r.top -= r.top - p.y - 4;
+		r.right	 = r.left + r.Width();
+		r.bottom = r.top + r.Height();
+	}
+	if(IsAutoHidden())	GetBase().GetHideBar(Alignment()).Detach(*this);
+	if(!IsShut()) GetBase().Detach(*this);
+	OpenWindow(r);
+	DockingStyle(DOCK_NONE, STATE_SHOW, 0);
+	GetBase().RefreshPanel();
+}
+
+void DockWindow::Show()
+{
+	if(!IsHidden() || IsTabbed()) return;
+	Dock(Alignment(), STATE_SHOW, Position());
+	GetBase().RefreshPanel();
+}
+
+void DockWindow::Hide()
+{
+	if(IsTabbed()) return;
+	if(IsHidden())
+	{
+		Show();
+		return;
+	}
+	ShutWindow();
+	GetBase().Detach(*this);
+	DockingStyle(Alignment(), STATE_HIDE, Position());
+	GetBase().RefreshPanel();
+}
+
+void DockWindow::AutoHide()
+{
+	if(IsFloating()) return;
+	if(IsAutoHidden())
+	{
+		GetBase().GetHideBar(Alignment()).Detach(*this);
+		GetBase().Dock(this->DockingStyle(Alignment(), STATE_SHOW, Position()));
+		return;
+	}
+	int alignment 	= Alignment();
+	int state		= STATE_AUTO;
+	int position	= Position();
+	
+	if(IsTabbed())
+	{
+		TabWindow* tabwindow = GetOwnerTab()->GetBaseTab();
+		if(tabwindow->IsFloating()) return;
+		alignment 	= tabwindow->Alignment();
+		position	= tabwindow->Position();
+		GetOwnerTab()->Detach(*this);
+	}
+	else
+	{
+		ReSize();
+		GetBase().Detach(*this);
+	}
+	DockingStyle(alignment, state, position);
+	GetBase().Dock(*this);
+	GetBase().RefreshPanel();
+}
+
+void DockWindow::Shut()
+{
+	if(IsShut()) return;
+	ShutWindow();
+	if(IsTabbed()) GetOwnerTab()->Detach(*this);
+	else if(IsAutoHidden())	GetBase().GetHideBar(Alignment()).Detach(*this);
+	else if(IsFloating()) Remove(); 	
+	else GetBase().Detach(*this);
+	DockingStyle(DOCK_NONE, STATE_SHUT, 0);
+	GetBase().RefreshPanel();
+}
+
+void DockWindow::Menu()
+{
+	ContextMenu();
+}
+
+DockWindow& DockWindow::AddMenuBar(MenuBar& bar)
+{
+	AddChildBar(bar); 
+	menubar = &bar; 
+	hasmenubar = true;
+	return *this;
+}
+
+DockWindow& DockWindow::AddToolBar(ToolBar& bar)
+{
+	AddChildBar(bar); 
+	toolbar = &bar; 
+	hastoolbar = true;
+	return *this;
+}
+
+DockWindow& DockWindow::AddStatusBar(StatusBar& bar)
+{
+	AddChildBar(bar.Height(18)); 
+	statusbar = &bar; 
+	hasstatusbar = true;
+	return *this;
+}
+
+void DockWindow::HideDragBar()
+{
+	if(!HasDragBar()) return;
+	RemoveFrame(dragbar);
+	DockableCtrl::HideDragBar();	
+}
+
+void DockWindow::ShowDragBar()
+{
+	if(HasDragBar()) return;
+	InsertFrame(0, dragbar); 
+	DockableCtrl::ShowDragBar();
+}
+
+Rect DockWindow::GetCtrlRect()
+{
+	if(!HasDragBar()) return GetScreenRect();
+	Rect bar = dragbar.GetScreenRect();
+	Rect wnd = GetScreenRect();
+	wnd.top  = bar.top;
+	return wnd;
+}
+
+Size DockWindow::GetCtrlSize()
+{
+	return GetCtrlRect().GetSize();
+}
+
+void DockWindow::Paint(Draw& d)
+{
+	TopWindow::Paint(d);
+}
+
+DockWindow& DockWindow::SetStyle(const DockCtrlChStyle::Style& st)
+{
+	style = &st;
+	dragbar.SetStyle(st);
+	shutbutton.SetImage(style->barshut[0], style->barshut[1], style->barshut[2]);
+	menubutton.SetImage(style->barmenu[0],style->barmenu[1], style->barmenu[2]);
+	autohidebutton.SetImage(style->barhide[0], style->barhide[1], style->barhide[2]);
+	RefreshLayoutDeep();
+	return *this;
+}
+
+const DockCtrlChStyle::Style* DockWindow::GetStyle()
+{
+	return style ? style : &DockCtrlChStyle::StyleDefault();
+}
+
+void DockWindow::MouseMove(Point p, dword keyflags)
+{
+	TopWindow::MouseMove(p, keyflags);
+}
+
+void DockWindow::ChildMouseEvent(Ctrl *child, int event, Point p, int zdelta, dword keyflags)
+{
+	if(HasDragBar() && child == &dragbar)
+	{
+		if(event == LEFTDRAG) StartWindowDrag();
+		if(event == LEFTDOUBLE && IsAutoHidden()) Dock(Alignment(), STATE_SHOW, Position());
+		if(event == RIGHTDOWN  && !hasbarbuttons) ContextMenu();
+	}
+	TopWindow::ChildMouseEvent(child, event, p, zdelta, keyflags);
+}
+
+void DockWindow::OnMenuButton()
+{
+	ContextMenu();
+}
+
+void DockWindow::OnShutButton()
+{
+	Shut();
+}
+
+void DockWindow::OnAutoHideButton()
+{
+	AutoHide();
+}
+
+DockWindow& DockWindow::ShowDragBarButtons(bool b)
+{
+	if(b && hasbarbuttons) return *this;
+	else if(b && !hasbarbuttons)
+	{
+		hasbarbuttons = b;
+		int cx 	= style->barheight - 8;
+		int cy 	= style->barheight - 8;	
+
+		dragbar	<< shutbutton.RightPos(2, cy).TopPos(2, cy).Tip(t_("Close")); 
+		dragbar	<< autohidebutton.RightPos(cy + 4, cy).TopPos(2, cy).Tip(t_("Auto Hide"));
+		dragbar	<< menubutton.RightPos((2 * cy) + 6, cy).TopPos(2, cy).Tip(t_("Window Position")); 
+	}
+	else if(!b && hasbarbuttons)
+	{
+		hasbarbuttons = b;
+		shutbutton.Remove();
+		autohidebutton.Remove();
+		menubutton.Remove();
+	}
+	dragbar.ShowButtons(b);
+	return *this;
+}
+
+void DockWindow::DockWindowMenu(Bar& bar)
+{
+	bool floatingbase = false;
+	TabWindow* c = GetOwnerTab();
+	if(c) floatingbase = c->GetBaseTab()->IsFloating();
+
+	bar.Add(t_("Dock"),	THISBACK(DockWindowDockMenu));
+	bar.Add(!IsFloating(), t_("Float"),THISBACK(Float));
+	bar.Separator();
+	bar.Add(IsDocked(), IsHidden() ? t_("Show") : t_("Hide"), THISBACK(Hide));
+	bar.Add(!IsFloating() && !floatingbase, t_("Auto Hide"), THISBACK(AutoHide));	
+	bar.Separator();
+	bar.Add(t_("Settings"), THISBACK(Settings));
+	bar.Separator();
+	bar.Add(t_("Close"), DockWindowImages::CClose(), THISBACK(Shut));	
+}
+
+void DockWindow::DockWindowDockMenu(Bar& bar)
+{
+	if(GetBase().IsSideAllowed(DOCK_TOP)) 		bar.Add(Alignment() == DOCK_TOP  ? 0 : 1, t_("Top"), THISBACK4(Dock, (int)DOCK_TOP, (int)STATE_SHOW, Position(), 0));
+	if(GetBase().IsSideAllowed(DOCK_LEFT)) 		bar.Add(Alignment() == DOCK_LEFT  ? 0 : 1, t_("Left"), THISBACK4(Dock, (int)DOCK_LEFT, (int)STATE_SHOW, Position(), 0));
+	if(GetBase().IsSideAllowed(DOCK_RIGHT)) 	bar.Add(Alignment() == DOCK_RIGHT ? 0 : 1, t_("Right"), THISBACK4(Dock, (int)DOCK_RIGHT, (int)STATE_SHOW, Position(), 0));
+	if(GetBase().IsSideAllowed(DOCK_BOTTOM)) 	bar.Add(Alignment() == DOCK_BOTTOM ? 0 : 1, t_("Bottom"), THISBACK4(Dock, (int)DOCK_BOTTOM, (int)STATE_SHOW, Position(), 0));	
+}
+
+void DockWindow::Serialize(Stream& s)
+{
+	int 	type		= GetType();
+	int 	alignment 	= Alignment();
+	int 	state		= State();
+	int 	position	= Position();
+	int 	id 			= -1;
+	Size	sz			= GetSizeHint();
+	Rect	r			= GetRect();
+	
+	if(s.IsStoring())
+	{
+		if(IsAutoHidden()) SetSizeHint(Size(0, 0));
+		id = GetBase().GetCtrlRecord(*this)->id;
+		s / type;
+		s / id;
+		s / alignment / state / position; 
+		sz.Serialize(s);
+		if(IsFloating()) 
+		{	
+			r.Serialize(s);
+			SerializePlacement(s, true);
+		}
+	}
+	if(s.IsLoading())
+	{
+		TabWindow* tabwindow = GetOwnerTab();
+		s / alignment / state / position;
+		sz.Serialize(s);
+		SetSize(sz);
+		if(tabwindow) tabwindow->Attach(*this);
+		else if(alignment == DOCK_NONE && state != STATE_SHUT)
+		{
+			r.Serialize(s);
+			Shut();
+			FloatEx(Rect(r.left, r.top, 10, 10));
+			SerializePlacement(s, true);
+		}
+		else 
+		{
+			Shut();
+			Dock(alignment, state, position, false);
+		}
+	}
+}
+
+//===============================================
+// DockWindow::DragBarButton
+// Nested helper class for DockWindow
+//===============================================
+
+Ctrl& DockWindow::DragBarButton::SetImage(const Image& normal, const Image& highlighted, const Image& pushed)
+{
+	nimage = normal; 
+	himage = highlighted; 
+	pimage = pushed;
+	return *this;
+}
+
+void DockWindow::DragBarButton::Paint(Draw& d)
+{
+	Size sz = GetSize();
+	d.DrawImage(0 , 0, sz.cx, sz.cy, (IsPush() && HasMouse() ? pimage : (!IsPush() && HasMouse() ? himage : nimage)));
+}
+
+//===============================================
+// DockWindow::DragBar
+// Nested helper class for DockWindow
+//===============================================
+
+DockWindow::DragBar::DragBar()
+{
+	SetStyle(DockCtrlChStyle::StyleDefault());
+	SetFrame(FieldFrame());
+	SetSize(style->barheight);
+	ShowButtons();
+}
+
+int DockWindow::DragBar::GetWidth()
+{
+	Size sz = GetTextSize(GetOwner().GetLabel(), style->font);
+	return BAR_MARGIN * 2 + sz.cx;
+}
+
+int DockWindow::DragBar::GetHeight()
+{
+	return style->barheight + 4;
+}
+
+void DockWindow::DragBar::FrameAddSize(Size& sz)
+{
+	sz += GetHeight();
+}
+
+void DockWindow::DragBar::Paint(Draw& d)
+{
+	Size sz = GetSize();
+	
+	Image icon = GetOwner().GetIcon();
+	bool hasicon = false;
+	
+	ImageDraw skin(sz.cx, sz.cy);
+	ChPaint(skin, 0, 0, GetSize().cx, GetSize().cy, style->barbackground[0]);
+	Image imgs = skin;
+	((GUI_GlobalStyle() >= GUISTYLE_XP) && (style != &DockCtrlChStyle::StyleClassic())) ?
+		// See CtrlsImg for proper rectangle value.
+		d.DrawImage(GetRect(), imgs, Rect(4, 4, 2, 14)) :
+		d.DrawRect(GetSize(), SColorFace());
+
+
+	if(!icon.IsNullInstance())
+	{
+		hasicon = true;
+		d.DrawImage(BAR_MARGIN, GetHeight() / icon.GetSize().cy, style->barheight - 8, style->barheight - 8, icon);
+	}
+	d.DrawText(BAR_MARGIN + (BAR_FILEICON + BAR_SPACEICON) * int(hasicon), GetHeight() / 12, GetOwner().GetLabel(), style->font);
+}
+
+//----------------------------------------------------------------------------------------------
+
+TabWindow::TabWindow()
+{
+	SetType(TYPE_TABWINDOW);
+	
+	destroyed	= false;
+	animating	= false;
+	groupwindow = false;
+	position	= -1;
+	previous	= -1;
+	nestlevel	=  0;
+	childcount	=  0;
+	activectrl	= NULL;
+
+	AddFrame(tabs.SetLayout(DockCtrlCustomFrame::LAYOUT_BOTTOM));
+	
+	tabs.WhenSelect 	= THISBACK(OnActiveTab);
+	tabs.WhenClose  	= THISBACK(OnTabClose);
+	tabs.WhenContext 	= THISBACK(OnTabContextMenu);
+	tabs.WhenDrag		= THISBACK(OnTabDrag);
+	tabs.WhenActive		= THISBACK(OnTabActive);
+}
+
+TabWindow::~TabWindow()
+{
+	position 	= -1;
+	previous	= -1;
+	nestlevel	=  0;
+	childcount	=  0;
+	groupwindow = false;
+	activectrl 	= NULL;
+}
+
+void TabWindow::Attach(DockableCtrl& ctrl, int makeactive)
+{
+	if(ctrl.IsTabWindow())
+	{
+		if(GetBase().DockBase::tabsnested || IsGroupWindow()) AttachNested(ctrl, makeactive);				 
+		else AttachNormal(ctrl, makeactive);
+	}
+	else Attach0(ctrl, makeactive);
+}
+
+
+void TabWindow::AttachNormal(DockableCtrl& ctrl, int makeactive)
+{
+	TabWindow& tabwindow = reinterpret_cast<TabWindow&>(ctrl);
+	int ncount =  tabwindow.ChildCount();
+
+	DockableCtrl* lc = tabwindow.GetChildAt(ncount);
+
+	if(lc)
+	{
+		bool transfered = false;
+		for(int i = 0; i < ncount - 1 ; i++)
+		{
+			DockableCtrl* c = tabwindow.GetChildAt(i + 1);
+			if(c) 
+			{
+				Attach(*c);
+				transfered = true;
+			}
+		}
+		if(transfered)
+		{
+			Attach(*lc);
+		}
+		tabwindow.TabWindow::destroyed = true;
+	} 
+}
+
+void TabWindow::AttachNested(DockableCtrl& ctrl, int makeactive)
+{
+	TabWindow& child = reinterpret_cast<TabWindow&>(ctrl);
+	child.SetNestLevel(GetNestLevel() + 1);
+	Attach0(ctrl, makeactive);
+}
+
+void TabWindow::Attach0(DockableCtrl& ctrl, int makeactive)
+{
+	reinterpret_cast<DockWindow&>(ctrl).SetOwnerTab(this);
+	ctrl.HideDragBar();
+	Add(ctrl.DockingStyle(DOCK_TABBED, STATE_TABBED, 0).SetBase(&GetBase()).SizePos());
+	ReposChilds();
+	tabs.Add(ctrl, makeactive);
+	childcount++;
+	
+	SetActive(GetActiveTab());
+	GetBase().AddCtrlRecord(ctrl);
+	RefreshTabWindowLabel(ctrl);
+	GetBase().RefreshWidgetLayout();
+	GetBase().RefreshPanel();
+}
+
+
+void TabWindow::Detach(DockableCtrl& ctrl)
+{
+	Size sz = GetBaseTab()->GetSizeHint();
+	if(!ctrl.IsFloating()) ctrl.ShowDragBar();
+	ctrl.Remove();
+	int id = tabs.Find(ctrl);
+	if(id >= 0) tabs.Close(id);
+	else if(position >= 0) tabs.Close(position);
+	childcount--;
+	ReposChilds();
+	ctrl.SetSizeHint(sz);
+	RemoveTabWindow();
+	reinterpret_cast<DockWindow&>(ctrl).SetOwnerTab(NULL);
+	GetBase().RefreshPanel();
+	position = -1;
+}
+
+void TabWindow::DetachAll()
+{
+	if(IsDestroyed()) return;
+	Shut();
+	DockableCtrl *childctrl = NULL;
+	Vector<DockableCtrl*> childs;
+	childs.Clear();
+	int i = 0;
+	int nest = GetNestLevel();
+	for(i = 0; i < ChildCount(); i++)
+	{
+		childctrl = GetChildAt(i + 1);
+		if(childctrl) childs.Add(childctrl);
+	}
+	int ncount = childs.GetCount();
+	i = 0;
+	for(i = 0; i < (ncount * 2); i++)
+	{
+		if(i < ncount)	
+		{
+			childctrl = childs.At(i);
+			ASSERT(childctrl);
+			if(childctrl->IsTabWindow()) dynamic_cast<TabWindow*>(childctrl)->DetachAll();
+		}
+		else
+		{
+			childctrl = childs.At(i - ncount);
+			ASSERT(childctrl);
+			childctrl->Shut();
+		}
+	}
+	Remove();
+	RemoveFrame(tabs);
+	SetOwnerTab(NULL);
+	childcount = 0;
+	destroyed  = true;
+	GetBase().RefreshPanel();
+}
+
+bool TabWindow::RemoveTabWindow()
+{
+	bool tabbed = false;
+	TabWindow *tabwindow = NULL;
+	ReSize();
+	Size sizehint = GetBaseTab()->GetSizeHint();
+	
+	if(ChildCount() == 1)
+	{
+		DockWindow* lastctrl = reinterpret_cast<DockWindow*>(GetChildAt(1));
+		tabs.CloseAll();
+		RemoveFrame(tabs);
+		if(lastctrl)
+		{
+			int a = Alignment();
+			int s = State();
+			int p = Position();
+			
+			lastctrl->Remove();
+			childcount = 0;
+			if(IsShut()) lastctrl->Shut();
+			if(IsTabbed())
+			{
+				TabInterface& tabs = GetOwnerTab()->GetTabs();
+				GetOwnerTab()->Attach(*lastctrl);
+				Shut();
+			}
+			else if(IsFloating())
+			{
+				lastctrl->Shut();
+				SetRect(GetBaseTab()->GetScreenRect());
+				Rect r = GetRect();
+				lastctrl->OpenWindow(r);
+				lastctrl->DockingStyle(DOCK_NONE, STATE_SHOW, 0);
+				Shut();
+				lastctrl->SetOwnerTab(NULL);
+			}
+			else
+			{
+				Shut();
+				lastctrl->ShowDragBar();
+				lastctrl->SetSizeHint(sizehint);
+				lastctrl->Dock(a, s, p);
+				lastctrl->SetOwnerTab(NULL);
+			}
+			DockingStyle(DOCK_NONE, STATE_SHUT, 0);
+			return destroyed = true;
+		}
+	}
+	if(GetActiveCtrl()) RefreshTabWindowLabel(*GetActiveCtrl());
+return false;
+}
+
+DockableCtrl* TabWindow::GetChildAt(int position)
+{
+	for(Ctrl* c = Ctrl::GetFirstChild(); c; c = c->GetNext())
+	{
+		DockableCtrl* ctrl = dynamic_cast<DockableCtrl*>(c);
+		if(ctrl) if(ctrl->Position() == position)
+			return ctrl; 
+	}
+	return NULL;
+}
+
+void TabWindow::ReposChilds()
+{
+	int i = 0;
+	for(Ctrl* c = Ctrl::GetFirstChild(); c; c = c->GetNext())
+	{
+		DockableCtrl* ctrl = dynamic_cast<DockableCtrl*>(c);
+		if(ctrl) ctrl->Posit(++i);
+	}
+}
+
+TabWindow* TabWindow::GetBaseTab()
+{
+	TabWindow *to = GetOwnerTab();
+	TabWindow *tb = NULL;
+	if(!IsTabbed() || !to) return this;
+	while(to) 
+	{
+		tb = to;
+		to = to->GetOwnerTab();
+	}
+	ASSERT(tb);
+	return tb;
+}
+
+void TabWindow::OnMenuButton()
+{
+	DockWindow::OnMenuButton();
+	if(IsShut()) DetachAll();
+}
+
+void TabWindow::OnShutButton()
+{
+	DetachAll();
+	Shut();
+}
+
+void TabWindow::OnAutoHideButton()
+{
+	DockWindow::OnAutoHideButton();
+}
+
+void TabWindow::OnShutWindow()
+{
+	OnShutButton();
+}
+
+
+void TabWindow::StartTabAnimation()
+{
+	if(IsTabAnimating()) return;
+	childcount++;
+	String title = t_("Tabbed Window");
+
+	Size canvassize = GetSize();
+	ImageDraw canvas(canvassize.cx, canvassize.cy);
+	GetActiveCtrl()->DrawCtrlWithParent(canvas, 0, 0);
+	canvas.DrawImage(canvassize, GetStyle()->tabhighlight);
+	
+	previous = GetActiveTab();
+	GetBase().RefreshWidgetLayout();
+	tabs.Add(title, true);
+	SetLabel(title);
+
+	animimage = canvas;
+	animating = true;
+}
+
+void TabWindow::StopTabAnimation()
+{
+	if(!IsTabAnimating()) return;
+	tabs.Close(tabs.GetActiveTab());
+	childcount--;
+	animating = false;
+	animimage.Clear();
+	if(!RemoveTabWindow())
+	{
+		SetActive(previous);
+		if(GetActiveTab())
+		SetLabel(GetTabs()
+				.GetTabs()
+				.At(GetActiveTab()).dock->GetLabel());
+		return;
+	}
+	position = -1;
+}
+
+
+bool TabWindow::HasCtrlInRange()
+{
+	Rect r = GetCtrlRect();
+	int hrange = r.Width() 	/ 3;
+	int vrange = r.Height()	/ 3;
+	return Rect(r.left + hrange, r.top + vrange, r.right - hrange, r.bottom - vrange).Contains(GetMousePos());
+}
+
+bool TabWindow::HasTabbedDock()
+{
+	return (bool) ChildCount();
+}
+
+int TabWindow::ChildCount()
+{
+	return childcount;
+}
+
+void TabWindow::SetNestLevel(int n)
+{
+	nestlevel = n;
+}
+
+void TabWindow::SetActive(int index)
+{
+	if(index >= ChildCount()) return;
+	if(index != GetActiveTab()) tabs.SetActiveTab(index);
+
+	for(int i = 0; i < tabs.GetTabs().GetCount(); i++)
+	{
+		TabInterface::Tab t = tabs.GetTabs().At(i);
+		if(t.dock)
+		{
+			if(i == index) t.dock->Ctrl::Show();
+			else t.dock->Ctrl::Hide();
+		}
+	}
+	RefreshTabWindowLabel(*this);
+}
+
+void TabWindow::SetActive(DockableCtrl& ctrl)
+{
+}
+
+int TabWindow::GetActiveTab()
+{
+	return tabs.GetActiveTab();
+}
+
+DockableCtrl* TabWindow::GetActiveCtrl()
+{
+	return GetChildAt(GetActiveTab() + 1);
+}
+
+void TabWindow::OnActiveTab()
+{
+	if(!IsTabAnimating()) SetActive(tabs.GetActiveTab());
+}
+
+void TabWindow::OnTabClose(int id, DockableCtrl& ctrl)
+{
+	position = id;
+	ctrl.Shut();
+}
+
+void TabWindow::OnTabDrag(int id, DockableCtrl& ctrl)
+{
+	position = id;
+	ctrl.StartWindowDrag();
+}
+
+void TabWindow::OnTabContextMenu(int id, DockableCtrl& ctrl)
+{
+	position = id;
+	reinterpret_cast<DockWindow&>(ctrl).OnMenuButton();
+}
+
+void TabWindow::OnTabActive(int id, DockableCtrl& ctrl)
+{
+	position = id;
+	RefreshTabWindowLabel(ctrl);
+}
+
+void TabWindow::RefreshTabWindowLabel(DockableCtrl& ctrl)
+{
+	int id = 0;
+	AutoHideBar* hidebar 	= NULL;
+	TabWindow*	 tabwindow	= NULL;
+
+	if(IsTabbed())
+	{
+		TabWindow* tabwindow = GetOwnerTab();
+		while(tabwindow)
+		{
+			int id = tabwindow->GetActiveTab();
+			if(id < 0) break;
+			TabInterface::Tab& sourcetab  = GetTabs().GetTabs().At(GetActiveTab());
+			TabInterface::Tab& targettab  =	tabwindow->GetTabs().GetTabs().At(id);
+			String& label 	= targettab.name = sourcetab.name;
+			Image& icon 	= targettab.icon = sourcetab.icon;
+			tabwindow->GetTabs().ReposTabs();
+			if(!tabwindow->GetOwnerTab())
+			{
+				if(tabwindow->IsAutoHidden())
+				{
+					hidebar = tabwindow->GetOwnerBar();
+					id = hidebar->Find((DockableCtrl&)*tabwindow);
+					if(id >= 0)
+					{
+						TabInterface::Tab& t = hidebar->GetTabs().At(id);
+						t.name = label;
+						t.icon = icon;
+						hidebar->ReposTabs();
+						hidebar->Refresh();
+					}
+						
+				}
+				tabwindow->SetLabel(label);
+				tabwindow->SetIcon (icon);
+			}
+			tabwindow->RefreshLayoutDeep();
+			tabwindow = tabwindow->GetOwnerTab();
+		}
+	}
+	else 
+	{
+		if(IsAutoHidden())
+		{
+			hidebar = GetOwnerBar();
+			id = hidebar->Find((DockableCtrl&)*this);
+			if(id >= 0)
+			{
+				TabInterface::Tab& t = hidebar->GetTabs().At(id);
+				t.name = ctrl.GetLabel();
+				t.icon = ctrl.GetIcon();
+				hidebar->ReposTabs();
+				hidebar->Refresh();
+			}
+		}
+		DockableCtrl::SetLabel(ctrl.GetLabel());
+		DockableCtrl::SetIcon(ctrl.GetIcon());
+		GetTabs().ReposTabs();
+		RefreshLayoutDeep();
+	}
+}
+
+void TabWindow::Paint(Draw& d)
+{
+	IsTabAnimating() ? d.DrawImage(GetSize(), animimage) :	TopWindow::Paint(d);
+}
+
+void TabWindow::Serialize(Stream& s)
+{
+		int type 		= 0;
+		int alignment	= 0;
+		int state		= 0;
+		int position	= 0;
+		int id			= 0;
+		int childcount 	= 0;
+		int activetab	= 0;
+		Size newsize;
+		Rect r			= GetRect();		
+		
+	if(s.IsStoring())
+	{
+		ReSize();
+		type 		= TYPE_TABWINDOW;
+		alignment	= GetBaseTab()->Alignment();
+		state		= GetBaseTab()->State();
+		position	= GetBaseTab()->Position();
+		id			= 0;
+		newsize		= GetBaseTab()->GetSizeHint();
+		childcount 	= ChildCount();
+		activetab	= GetActiveTab();
+		
+		s / type; 
+		s / id;
+		s / alignment / state / position;
+		newsize.Serialize(s);
+		s / childcount;
+		s / activetab;
+		s % groupwindow;
+		s / groupname;
+		if(!GetOwnerTab() && IsFloating()) 
+		{
+			r.Serialize(s);
+			SerializePlacement(s, true);
+		}
+
+		for(int i = 0; i < childcount; i++)
+			GetChildAt(i + 1)->Serialize(s);
+	}
+	if(s.IsLoading())
+	{
+		TabWindow* tabwindow = GetOwnerTab();
+		s / alignment / state / position;
+		newsize.Serialize(s);
+		s / childcount; 
+		s / activetab;
+		s % groupwindow;
+		s / groupname;
+
+		if(!tabwindow)
+		{
+			if(alignment == DOCK_NONE  && state != STATE_SHUT)
+			{
+				r.Serialize(s);
+				FloatEx(Rect(r.left, r.top, 10, 10));
+				SerializePlacement(s, true);
+			}
+			else
+			{
+				Shut();
+				SetSize(newsize);
+				Dock(alignment, state, position, false);
+			}
+		}
+		else tabwindow->Attach(*this);
+		
+		for(int i = 0; i < childcount; i++)
+		{
+			s / type / id;
+			if(type == TYPE_DOCKWINDOW)
+			{
+				DockWindow* child = dynamic_cast<DockWindow*>(GetBase().GetCtrlRecordFromId(id)->ctrl);
+				ASSERT(child);
+				child->SetOwnerTab(this);
+				child->Serialize(s);
+			}
+			if(type == TYPE_TABWINDOW)
+			{
+				TabWindow* tabwindow = GetBase().GetPaneFrame(0).AddTabWindow();
+				tabwindow->SetOwnerTab(this);
+				tabwindow->Serialize(s);
+			}
+		}
+		SetActive(activetab);
+	}
+}
diff --git a/archive/DockCtrl/DockableCtrl.cpp b/archive/DockCtrl/DockableCtrl.cpp
new file mode 100644
index 000000000..d27a778f5
--- /dev/null
+++ b/archive/DockCtrl/DockableCtrl.cpp
@@ -0,0 +1,246 @@
+#include "DockCtrl/DockCtrl.h"
+
+#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
+#define IMAGECLASS DockableCtrlImages
+#include <Draw/iml.h>
+
+//===============================================
+// DockableCtrl class:
+// Base class of all DockCtrl widgets.
+//===============================================
+
+DockableCtrl::DockableCtrl()
+{
+	DockingStyle(DOCK_NONE, STATE_SHUT, 0);
+	PermitDragAndDrop();
+	SetDropTarget();	
+	docksize.Clear();
+	hasdragbar	= false;
+	haschildbar	= false;
+	isdragged	= false;
+	isdraggable = true;
+	dockbase 	= NULL;
+	style		= NULL;
+	WhenClose	= THISBACK(OnShutWindow);
+	NoCenter().BackPaint();
+}
+
+DockableCtrl::~DockableCtrl()
+{
+}
+
+DockableCtrl& DockableCtrl::DockingStyle(int alignment, int state, int position)
+{
+	dockalignment 	= alignment;
+	dockstate		= state;
+	dockposition	= position;
+	return *this;
+}
+
+DockableCtrl& DockableCtrl::SetLabel(String title)
+{
+	IsNull(title) || title == t_("") ? dockname = t_("Untitled") :  dockname = title;
+	Title(title);
+	if(IsVisible()) Refresh();
+	return *this;
+}
+
+DockableCtrl& DockableCtrl::SetIcon(Image icon)
+{
+	dockicon = icon;
+	Icon(dockicon);
+	if(IsVisible()) Refresh();
+	return *this;
+}
+
+DockableCtrl& DockableCtrl::SetSize(Size sz)
+{
+	SetSizeHint(sz);
+	Rect r = GetRect();
+	SetRect(r.left, r.top, r.left + sz.cx, r.top + sz.cy);
+	if(IsFloating()) Refresh();
+	else RefreshParentLayout();
+	return *this;
+}
+
+void DockableCtrl::ReSize()
+{
+	docksize = Ctrl::GetSize();
+	for(int i = 0; i < GetFrameCount(); i++) Ctrl::GetFrame(i).FrameAddSize(docksize);	
+}
+
+void DockableCtrl::Layout()
+{
+	TopWindow::Layout(); 
+	if(IsFloating() && IsOpen()) ReSize();
+}
+
+void DockableCtrl::OpenWindow(Rect& r)
+{
+	if(IsPopUp()) Close();
+	if(IsOpen()) return;
+	ReSize();
+	r.right  = r.left + docksize.cx;
+	r.bottom = r.top  + docksize.cy;
+	HideDragBar();
+	Title(GetLabel());
+	SetRect(r);
+	Ctrl::Hide();
+	Open(GetOwner());
+	Ctrl::Show();
+	Refresh();
+}
+
+void DockableCtrl::OpenWindow(int x, int y, int cx, int cy)
+{
+	if(IsPopUp()) Close();
+	if(IsOpen()) return;
+	HideDragBar();
+	Title(GetLabel());
+	SetRect(x, y, cx, cy);
+	Ctrl::Hide();
+	Open(GetOwner());
+	Ctrl::Show();
+	Refresh();	
+}
+
+void DockableCtrl::ShutWindow()
+{
+	if(IsPopUp()) Close();
+	ReSize();
+	if(!IsOpen() || !IsFloating()) return;
+	Rect r 	 = GetRect();
+	r.right  = r.left + docksize.cx;
+	r.bottom = r.top  + docksize.cy;
+	Close();
+	Remove();
+	SetRect(r);  
+	ShowDragBar();
+}
+
+void DockableCtrl::OnShutWindow()
+{
+	Shut();
+}
+
+void DockableCtrl::ContextMenu()
+{
+	MenuBar::Execute(WhenContextMenu); 
+}
+
+void DockableCtrl::Settings()
+{
+	GetBase().ControlPanel();
+}
+
+void DockableCtrl::Menu()
+{
+	ContextMenu();
+}
+
+void DockableCtrl::StartWindowDrag()
+{
+	if(!isdraggable) return;
+	Point pt = GetMousePos();
+	Float();
+
+// Thanks to mrjt (James Thomas) for the X11 window drag code.	
+#if	defined(PLATFORM_WIN32)
+	SendMessage(GetHWND(), WM_NCLBUTTONDOWN, 2, MAKELONG(pt.x, pt.y));
+#elif defined(PLATFORM_X11)
+	Atom xwndDrag = XAtom("_NET_WM_MOVERESIZE");
+	XEvent e;
+	Zero(e);
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = xwndDrag;
+	e.xclient.window = GetWindow();
+	e.xclient.format = 32;
+	e.xclient.display = Xdisplay;
+	e.xclient.send_event = XTrue;
+	e.xclient.data.l[0] = pt.x;
+	e.xclient.data.l[1] = pt.y;
+	e.xclient.data.l[2] = 8;
+	e.xclient.data.l[3] = 1;
+	e.xclient.data.l[4] = 0;	
+	
+	XUngrabPointer(Xdisplay, CurrentTime);
+	XSendEvent(Xdisplay, RootWindow(Xdisplay, Xscreenno), XFalse, SubstructureNotifyMask, &e);
+	XFlush(Xdisplay);
+#endif
+}
+
+
+#if defined(PLATFORM_WIN32)
+LRESULT  DockableCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
+{
+	if(IsFloating())
+	{
+		switch(message)
+		{
+			case WM_MOVING:
+					if(!isdraggable) break;
+					isdragged = true;
+					SetDropTarget(DOCK_NONE, GetDropState());
+					GetBase().DoDragAndDrop(*this, GetMousePos(), GetCtrlSize());
+					break;
+		
+			case WM_EXITSIZEMOVE:
+					if(!isdraggable) break;
+					if(!GetMouseLeft() && HasDropTarget() && isdragged) 
+					{
+						Dock(GetDropTarget(), GetDropState(), Position());
+						Refresh();
+						SetDropTarget();
+						isdragged = false;
+					}
+				break;
+			
+			case WM_NCRBUTTONDOWN:
+					ContextMenu();
+				return 1L;
+				
+			default:
+				break;
+		}
+	}
+	return TopWindow::WindowProc(message, wParam, lParam);
+}
+#elif defined(PLATFORM_X11)
+void DockableCtrl::EventProc(XWindow& w, XEvent *event)
+{
+	if (IsOpen()) 
+	{
+		switch(event->type) {
+		case ConfigureNotify:
+		{
+			if(!isdraggable) break;
+			XConfigureEvent& e = event->xconfigure;
+			if (Point(e.x, e.y) != GetScreenRect().TopLeft()) 
+			{
+				SetDropTarget(DOCK_NONE, GetDropState());
+				if(!isdragged);
+				{	
+					isdragged = true;
+					GetBase().DoDragAndDrop(*this, GetMousePos(), GetCtrlSize());
+					SetFocus();
+				}
+				break;
+			}
+			break;
+		}
+		case FocusIn:
+			if(!isdraggable) break;
+			XFocusChangeEvent &e = event->xfocus;
+			if (e.mode == NotifyUngrab) 
+			{
+				Dock(GetDropTarget(), GetDropState(), Position());
+				SetDropTarget();
+				isdragged = false;
+				return;
+			}
+			break;
+		}
+	}
+	TopWindow::EventProc(w, event);	
+}
+#endif
diff --git a/archive/DockCtrl/DockableCtrl.iml b/archive/DockCtrl/DockableCtrl.iml
new file mode 100644
index 000000000..3f158d901
--- /dev/null
+++ b/archive/DockCtrl/DockableCtrl.iml
@@ -0,0 +1,114 @@
+PREMULTIPLIED
+IMAGE_ID(DragArrow)
+IMAGE_ID(DBarBackground)
+IMAGE_ID(EBarBackground)
+IMAGE_ID(CBarBackground)
+IMAGE_ID(DefaultImage)
+IMAGE_ID(Logo)
+IMAGE_ID(DClose)
+IMAGE_ID(DCloseh)
+IMAGE_ID(DCloses)
+IMAGE_ID(DMenu)
+IMAGE_ID(DMenuh)
+IMAGE_ID(DMenus)
+IMAGE_ID(DHide)
+IMAGE_ID(DHideh)
+IMAGE_ID(DHides)
+IMAGE_ID(CClose)
+IMAGE_ID(CCloseh)
+IMAGE_ID(CClosep)
+IMAGE_ID(CHide)
+IMAGE_ID(CHideh)
+IMAGE_ID(CHides)
+IMAGE_ID(CMenu)
+IMAGE_ID(CMenuh)
+IMAGE_ID(CMenus)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,155,11,80,84,215,25,199,111,39,73,199,81,90,173,154,210,142,157,106,19,157,118,236,76,212,105,199,36,19)
+IMAGE_DATA(34,129,17,35,58,160,196,71,139,25,197,153,132,40,26,181,145,212,74,170,17,67,170,121,72,53,38,90,235,27,229,37)
+IMAGE_DATA(4,69,64,144,151,203,67,80,16,65,141,8,187,242,92,222,32,239,40,226,163,255,126,231,176,7,151,117,239,189,187,43)
+IMAGE_DATA(70,137,30,230,239,121,125,191,123,206,249,206,185,187,223,189,130,244,156,244,83,201,76,130,105,29,61,109,48,174,195,168)
+IMAGE_DATA(221,144,75,166,185,105,217,108,219,79,164,95,208,191,67,120,169,179,179,19,29,29,29,104,107,107,227,106,105,105,65,115)
+IMAGE_DATA(115,51,154,154,154,184,26,26,26,80,95,95,207,85,91,91,139,154,154,26,84,85,85,113,85,86,86,162,162,162,2,134)
+IMAGE_DATA(11,138,169,2,119,239,222,65,119,247,45,124,127,253,58,218,218,219,209,116,173,25,53,181,245,40,175,212,67,123,181,20)
+IMAGE_DATA(151,10,139,144,87,112,9,217,57,121,208,156,206,70,210,169,12,156,56,153,138,232,184,147,136,60,118,162,239,5,253,253)
+IMAGE_DATA(253,241,160,146,134,209,143,137,191,173,149,9,255,169,21,122,24,188,85,73,137,183,197,23,16,201,198,181,244,51,111,181)
+IMAGE_DATA(47,250,149,183,38,245,23,111,110,47,172,224,251,172,103,160,243,86,235,231,244,163,146,236,73,163,141,52,66,198,110,40)
+IMAGE_DATA(201,209,72,5,227,199,143,199,36,210,132,158,193,18,140,250,134,26,113,142,47,190,248,34,188,188,188,184,236,237,237,17)
+IMAGE_DATA(30,30,142,18,31,31,104,136,99,125,115,230,204,193,168,81,163,96,96,123,57,102,15,104,72,27,224,232,56,26,153,115)
+IMAGE_DATA(231,2,67,37,104,188,36,186,214,4,20,20,108,133,131,131,131,12,183,129,185,144,56,9,229,204,241,145,196,105,24,199)
+IMAGE_DATA(242,55,48,113,226,68,99,142,249,160,128,205,141,141,195,152,161,52,78,121,152,132,58,186,198,4,226,236,237,41,159,48)
+IMAGE_DATA(12,118,118,118,140,43,16,126,99,62,96,235,17,98,245,242,114,9,180,26,72,26,54,190,99,159,62,225,103,54,126,90)
+IMAGE_DATA(90,90,175,248,124,136,147,240,26,113,26,76,159,62,189,111,159,129,27,59,118,44,182,109,219,214,43,86,151,202,95,134)
+IMAGE_DATA(212,69,171,221,170,193,228,201,147,251,246,221,219,211,132,158,125,152,192,125,192,214,35,149,151,67,250,146,29,52,13,237)
+IMAGE_DATA(131,132,55,223,252,21,134,15,31,46,246,82,156,3,71,182,63,204,215,204,111,204,7,210,170,114,242,195,109,154,99,24)
+IMAGE_DATA(103,14,28,88,108,234,79,206,177,61,101,251,195,250,122,252,86,142,141,27,47,243,185,177,113,88,187,97,60,99,238,190)
+IMAGE_DATA(115,38,73,47,115,91,195,122,228,206,153,105,82,63,215,198,55,199,202,21,203,253,119,124,189,61,54,77,147,138,148,228)
+IMAGE_DATA(68,69,105,82,147,193,108,5,147,145,174,129,182,248,10,202,74,175,162,180,68,103,86,172,239,170,174,24,204,182,103,156)
+IMAGE_DATA(20,92,40,200,195,165,139,249,184,120,225,188,162,132,77,106,74,34,23,227,10,242,207,113,157,207,203,225,125,249,231,115)
+IMAGE_DATA(123,219,140,197,108,51,210,79,245,225,152,109,69,121,9,234,106,171,122,217,154,234,74,46,102,35,148,158,150,138,248,248)
+IMAGE_DATA(88,156,167,254,60,26,39,159,216,106,178,169,37,142,229,149,149,101,188,204,148,155,123,6,233,52,206,185,115,103,145,66)
+IMAGE_DATA(99,29,139,138,196,185,156,51,200,57,147,133,179,217,167,121,174,175,40,67,181,190,162,87,204,143,113,49,209,72,56,17)
+IMAGE_DATA(203,21,19,125,20,145,17,97,200,57,155,133,51,217,153,92,217,89,25,228,63,45,244,52,22,19,155,119,114,82,2,18)
+IMAGE_DATA(79,158,224,121,74,242,73,28,59,26,137,208,144,67,220,62,235,116,58,103,174,234,138,200,231,58,46,81,102,215,17,190)
+IMAGE_DATA(208,156,74,70,212,183,71,112,248,208,1,110,127,58,51,141,247,125,119,169,128,219,179,235,198,197,70,211,190,22,114,177)
+IMAGE_DATA(253,98,12,203,217,28,15,7,29,192,233,140,52,100,210,126,38,39,38,240,245,178,156,173,131,229,241,113,49,136,61,126)
+IMAGE_DATA(12,41,73,39,145,118,42,5,233,116,174,190,141,160,15,130,176,96,62,254,169,212,36,36,144,111,79,196,29,71,252,137)
+IMAGE_DATA(24,190,30,54,38,107,103,253,98,60,182,7,33,193,65,252,204,28,9,15,225,117,227,185,176,58,155,119,102,134,166,143)
+IMAGE_DATA(142,71,71,245,57,163,225,161,193,124,189,230,116,52,42,130,43,44,244,112,47,115,223,55,199,154,119,223,241,215,190,179)
+IMAGE_DATA(4,133,110,30,138,42,122,219,11,204,86,48,186,101,43,208,114,58,7,29,133,87,209,113,89,107,94,212,215,150,91,0)
+IMAGE_DATA(157,207,251,156,45,246,94,138,218,195,81,168,139,136,67,109,120,76,143,66,143,223,43,135,25,68,229,186,35,177,148,199)
+IMAGE_DATA(226,202,188,5,184,60,123,30,106,14,71,163,122,223,17,46,253,127,130,201,238,56,170,246,132,161,106,111,56,170,247,71)
+IMAGE_DATA(112,241,50,179,9,138,66,241,210,21,40,156,61,151,184,99,212,71,204,174,96,124,95,86,137,219,55,187,232,186,199,169)
+IMAGE_DATA(126,24,55,219,218,185,170,15,18,127,48,18,213,135,142,66,235,189,28,217,238,179,120,189,106,79,8,170,67,142,162,187)
+IMAGE_DATA(235,6,110,223,190,133,91,148,119,93,187,198,203,76,101,255,61,132,146,21,31,163,122,103,16,242,223,243,65,140,235,12)
+IMAGE_DATA(212,236,14,129,126,199,1,84,108,223,135,194,160,96,220,164,7,136,91,221,221,189,202,216,180,5,249,14,110,208,189,62)
+IMAGE_DATA(31,37,14,115,145,58,195,3,135,92,166,161,246,171,93,208,7,126,77,218,142,202,205,129,104,161,167,148,174,27,93,92)
+IMAGE_DATA(29,173,173,184,178,192,27,85,83,104,61,46,158,104,32,197,186,186,99,187,179,51,234,200,86,31,240,25,244,255,250,28)
+IMAGE_DATA(141,244,112,210,216,212,140,107,205,173,168,171,169,165,167,31,122,10,170,107,192,53,111,95,180,185,204,67,135,171,39,34)
+IMAGE_DATA(166,207,64,192,20,7,212,249,173,135,126,141,31,202,124,215,162,48,255,34,244,100,159,180,46,0,241,127,89,132,178,138)
+IMAGE_DATA(74,148,144,202,188,87,161,221,101,62,58,137,219,63,213,5,254,142,14,104,88,190,18,85,180,159,87,60,22,35,194,197)
+IMAGE_DATA(29,113,126,31,227,146,195,44,62,183,120,175,37,136,92,248,30,170,157,61,208,238,250,215,30,206,197,5,159,207,114,67)
+IMAGE_DATA(153,199,66,232,61,188,112,225,117,79,228,190,234,137,252,215,230,145,15,60,81,227,228,137,102,231,249,104,32,181,211,186)
+IMAGE_DATA(218,72,157,174,11,176,201,201,137,159,153,111,166,57,161,105,174,7,234,151,185,163,102,165,59,26,254,230,142,230,213,238)
+IMAGE_DATA(104,247,117,199,245,191,187,225,134,208,135,179,112,116,142,75,159,51,250,137,171,11,246,206,116,193,238,153,83,177,219,109)
+IMAGE_DATA(42,246,80,190,207,221,25,251,221,122,116,144,202,155,28,157,122,153,251,110,142,157,190,171,67,115,126,55,6,233,20,106)
+IMAGE_DATA(40,41,235,249,231,193,108,5,147,107,55,18,245,161,209,104,201,56,135,22,77,174,121,81,95,83,116,34,114,7,143,224)
+IMAGE_DATA(236,217,49,99,80,226,27,128,210,245,255,70,233,71,95,246,104,237,23,247,202,126,6,177,242,186,64,202,3,145,57,120)
+IMAGE_DATA(48,50,104,252,18,223,205,208,250,172,227,42,242,250,144,236,190,64,177,183,31,221,4,255,132,118,217,122,46,94,166,126)
+IMAGE_DATA(221,7,1,56,59,104,36,50,5,71,125,69,139,255,129,206,139,69,248,31,61,241,178,235,23,45,94,131,91,45,173,92)
+IMAGE_DATA(186,149,254,208,173,218,8,221,234,77,200,125,102,4,162,136,43,165,107,104,151,248,161,100,237,102,220,161,67,205,18,99)
+IMAGE_DATA(187,235,27,123,227,220,75,239,174,193,5,251,87,80,234,229,139,196,231,134,97,43,113,101,62,31,65,187,120,53,138,22)
+IMAGE_DATA(174,64,22,29,62,193,138,20,62,125,54,146,200,142,98,3,92,36,29,32,173,33,85,188,237,13,237,156,69,208,190,181)
+IMAGE_DATA(16,197,174,115,208,92,89,65,55,224,29,174,206,214,118,156,145,6,161,148,93,159,84,67,218,70,90,64,210,187,190,5)
+IMAGE_DATA(173,243,12,104,167,185,161,86,71,223,140,141,205,104,164,53,233,43,171,80,79,229,250,234,90,52,12,26,135,86,178,237)
+IMAGE_DATA(36,109,36,57,145,170,38,189,2,221,31,39,225,187,113,47,33,43,53,29,58,178,223,59,217,25,223,80,223,229,98,29)
+IMAGE_DATA(46,146,10,7,143,70,7,213,175,147,86,145,28,216,216,246,191,69,201,136,95,227,44,149,63,33,125,53,241,85,126,62)
+IMAGE_DATA(216,220,118,72,63,67,128,100,199,203,198,220,204,145,35,112,153,114,29,233,20,41,158,36,124,192,214,211,100,88,19,99)
+IMAGE_DATA(90,13,220,52,18,59,51,139,40,175,39,85,15,39,219,81,100,55,154,236,95,32,219,177,18,110,254,94,66,183,208,56)
+IMAGE_DATA(9,159,25,24,113,70,167,208,217,89,70,109,75,72,75,73,62,164,247,73,43,13,243,90,77,114,49,98,158,200,176,42)
+IMAGE_DATA(38,38,198,34,153,134,85,172,141,133,85,197,197,197,178,98,54,166,97,149,184,30,11,171,228,24,185,176,74,176,121,121)
+IMAGE_DATA(121,220,150,229,76,162,93,41,172,50,102,141,25,181,176,74,206,31,79,195,170,39,40,172,210,71,236,148,149,92,88,165)
+IMAGE_DATA(150,148,194,42,185,148,61,94,82,13,171,204,49,106,97,149,126,195,78,46,99,134,213,213,194,42,193,49,123,193,48,61)
+IMAGE_DATA(13,171,158,160,176,74,108,186,57,201,133,85,106,73,41,172,146,75,250,241,234,97,149,57,70,45,172,138,32,27,38,145)
+IMAGE_DATA(62,48,212,213,194,42,193,153,74,45,172,18,55,147,57,61,13,171,6,72,88,37,222,86,105,52,26,179,82,123,91,37)
+IMAGE_DATA(199,169,189,173,146,11,197,66,66,66,20,223,86,41,113,74,97,21,235,151,147,37,97,149,120,91,245,52,172,26,224,97)
+IMAGE_DATA(21,251,180,183,58,172,82,248,230,144,11,171,148,24,38,91,194,170,64,149,176,74,137,147,13,171,88,56,68,10,148,145)
+IMAGE_DATA(92,88,165,180,54,115,97,149,154,63,184,47,159,134,85,63,158,176,74,237,109,149,210,65,176,37,172,10,84,9,171,148)
+IMAGE_DATA(56,185,176,74,237,230,80,10,171,44,13,143,228,194,42,241,182,74,212,127,20,111,171,6,104,146,251,213,14,181,95,249)
+IMAGE_DATA(128,25,27,115,109,106,172,165,140,28,107,105,234,143,177,172,93,155,82,155,28,103,105,251,227,159,76,111,142,45,91,182)
+IMAGE_DATA(192,26,9,198,218,113,141,249,7,228,44,218,20,5,78,177,77,102,158,170,135,78,97,125,138,7,181,159,57,91,230,105)
+IMAGE_DATA(171,95,108,221,7,139,210,131,112,198,188,53,231,186,207,205,97,55,196,238,141,224,160,176,182,248,152,20,24,75,60,144)
+IMAGE_DATA(153,182,51,91,193,252,102,3,96,141,196,56,214,114,98,108,81,23,201,212,206,180,93,142,51,182,49,215,102,202,153,218)
+IMAGE_DATA(153,99,228,56,115,172,218,250,30,132,179,101,158,230,236,204,181,245,215,62,88,170,160,125,161,109,182,156,179,33,131,6)
+IMAGE_DATA(59,202,157,107,57,237,221,181,191,241,217,103,158,253,195,227,24,86,217,20,62,176,55,48,130,49,42,91,196,9,89,49)
+IMAGE_DATA(230,64,224,228,190,53,44,246,171,21,126,124,164,220,67,75,143,97,88,101,83,248,160,118,115,40,113,74,135,110,0,115)
+IMAGE_DATA(22,221,28,74,225,138,210,97,125,156,56,165,212,111,97,213,0,79,182,126,226,216,250,201,106,246,255,15,204,177,166,253)
+IMAGE_DATA(50,140,234,7,133,21,156,226,250,44,252,132,182,217,47,22,216,12,140,244,152,220,28,182,134,0,252,111,232,204,233,97)
+IMAGE_DATA(114,54,204,183,151,147,253,43,187,126,230,132,172,228,122,249,31,154,83,209,163,73,143,73,88,101,177,115,76,57,75,15)
+IMAGE_DATA(121,127,114,150,204,87,142,83,59,60,253,197,9,89,201,137,244,131,115,86,250,211,226,212,111,97,213,159,39,252,233,211)
+IMAGE_DATA(248,216,196,187,150,190,173,98,182,130,177,250,173,147,97,28,86,86,115,142,220,219,21,181,205,120,88,156,37,243,149,227)
+IMAGE_DATA(148,110,202,254,228,132,172,225,132,30,5,167,230,207,216,168,147,119,109,57,103,47,189,48,126,163,220,185,150,83,236,177)
+IMAGE_DATA(132,219,191,28,62,210,243,255,237,32,181,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(2752, 24)
diff --git a/archive/DockCtrl/PaneFrame.cpp b/archive/DockCtrl/PaneFrame.cpp
new file mode 100644
index 000000000..f099a86f4
--- /dev/null
+++ b/archive/DockCtrl/PaneFrame.cpp
@@ -0,0 +1,666 @@
+#include "DockCtrl.h"
+
+PaneFrame& PaneFrame::Attach(DockableCtrl& ctrl)
+{
+	if(!GetBase().IsSideAllowed(GetType()))
+	{
+		// if not allowed, then find an allowed pane.
+		for(int i = 0; i < 4; i++)
+			if(GetBase().IsSideAllowed(i)) 
+			{
+				GetBase().Dock(ctrl.DockingStyle(i, ctrl.State(), 0));
+				break;
+			}
+	}
+	else if(ctrl.IsTabbed()) 
+		return AttachAsTab(ctrl);
+	else if(ctrl.IsAutoHidden())
+		return AttachAsAuto(ctrl);
+	else if(ctrl.IsDocked())
+		return AttachAsDock(ctrl);
+	return *this;
+}
+
+PaneFrame& PaneFrame::AttachAsDock(DockableCtrl& ctrl)
+{
+	if(DnDHasSource())
+	{
+		int position = dndpos;
+		DnDSourceoutofRange();
+		if(dockcontainer.IsAnimating()) dockcontainer.StopAnimation();
+	}
+	if(ctrl.IsDocked() && !ctrl.IsHidden())	ShowFrame(ctrl.GetSizeHint());
+	dockcontainer.AddChildDock(ctrl, dndpos ? dndpos : ctrl.Position());
+	dndpos = 0;
+	return RefreshPaneFrame();
+}
+
+PaneFrame& PaneFrame::AttachAsTab(DockableCtrl& ctrl)
+{
+	int position = ctrl.Position();
+	if(DnDHasSource())
+	{
+		position = dndpos;
+		DnDSourceoutofRange();
+		if(HasTabWindow(GetActiveTabWindow()))
+			if(GetActiveTabWindow()->IsTabAnimating())
+				GetActiveTabWindow()->StopTabAnimation();
+	}
+	else
+	{
+		DockableCtrl* targetctrl = dockcontainer.GetChildAt(position);
+
+		if(!targetctrl)
+		{
+			int cc = dockcontainer.GetChildCount();
+			if(cc == 0) 
+			{
+				ctrl.DockingStyle(GetType(), DockableCtrl::STATE_SHOW, 0);
+				return AttachAsDock(ctrl);
+			}
+			else
+			{
+				targetctrl = dockcontainer.GetChildAt(cc);
+				if(targetctrl) position = targetctrl->Position();
+				else return *this;
+			}
+		}
+	}
+	
+	AddtoTabWindow(ctrl.Posit(position));
+	SetActiveTabWindow(NULL);
+	dndpos = 0;
+	RefreshTabWindowList();
+	return RefreshPaneFrame();
+}
+
+PaneFrame& PaneFrame::AttachAsAuto(DockableCtrl& ctrl)
+{
+	bool vertical = GetType() == LEFT || GetType() == RIGHT;
+	AutoHideBar& bar = GetBase().GetHideBar(GetType());
+	Size sz = ctrl.GetSizeHint();
+	Size newsz;
+	Size hidesz;
+	hidesz += GetBase().GetHideBar(GetType()).GetHeight() + 4;
+	
+	if(vertical) {
+		if (sz.cx < hidesz.cx) {
+			newsz = Size(maxsize, sz.cy);
+			ctrl.SetSizeHint(newsz);
+		}
+	} else {
+		if (sz.cy < hidesz.cy) {
+			newsz = Size(sz.cx, maxsize);
+			ctrl.SetSizeHint(newsz);
+		}
+	}
+	bar.Attach(ctrl);
+	GetBase().RefreshWidgetLayout();
+	return RefreshPaneFrame();
+}
+
+PaneFrame& PaneFrame::Detach(DockableCtrl& ctrl)
+{
+	if(!ctrl.IsDocked()) return *this;
+	if(HasChild(ctrl) && !ctrl.IsShut()) 
+		dockcontainer.RemoveChildDock(ctrl);
+	if(!dockcontainer.HasChild())  
+		HideFrame(); 
+	return RefreshPaneFrame();		
+}
+
+DockableCtrl* PaneFrame::GetChild(int position)
+{
+	return dockcontainer.GetChildAt(position);
+}
+
+int PaneFrame::GetCount()
+{
+	return dockcontainer.GetChildCount();
+}
+
+bool PaneFrame::HasChild(DockableCtrl& ctrl)
+{
+	if(dockcontainer.HasChild())
+		for(int i = 1; i <= dockcontainer.GetCount(); i++)
+			if(&ctrl == dockcontainer.GetChildAt(i))	
+				return true;
+	return false;
+}
+
+void PaneFrame::ShowFrame()
+{
+	SetSize(stdsize <= 4 ? maxsize : stdsize); 
+	RefreshPaneFrame().Enable();
+}
+
+void PaneFrame::ShowFrame(Size sz)
+{
+	bool horizontal = GetType() == LEFT || GetType() == RIGHT;
+	
+	if(!dockcontainer.HasChild())
+	{
+		if(horizontal)
+			SetSize((sz.cx > 4 && sz.cx < maxsize) ? sz.cx : maxsize);
+		else
+			SetSize((sz.cy > 4 && sz.cy < maxsize) ? sz.cy : maxsize);
+	}
+	else SetSize(size);
+	RefreshPaneFrame();
+	if(!IsEnabled()) Enable();  
+}
+
+void PaneFrame::HideFrame()
+{
+	stdsize = GetSize();
+	SetSize(0);
+	RefreshPaneFrame().Disable();
+}
+
+void PaneFrame::LockFrame()
+{
+	if(IsLocked()) return;
+}
+
+void PaneFrame::UnlockFrame()
+{
+	if(!IsLocked()) return;
+}
+Vector<TabWindow*>& PaneFrame::GetTabWindows()
+{
+	return tabwindows;
+}
+
+TabWindow* PaneFrame::AddTabWindow()
+{
+	Vector<TabWindow*>& tl = GetBase().GetTabWindows();
+	TabWindow* tabwindow = NULL;
+	tl.Add(tabwindow = new TabWindow());
+	tabwindow->SetStyle(*GetBase().GetStyle());
+	tabwindow->SetBase(&GetBase());
+	GetBase().RefreshTabWindowList();
+	return tabwindow;
+}
+
+TabWindow* PaneFrame::AddTabWindow(DockableCtrl& ctrl)
+{
+	Size tabnewsize;
+	Vector<TabWindow*>& tl = GetBase().GetTabWindows();
+	
+	int position = ctrl.Position();
+	if(position == 0) ++position;
+	TabWindow *tabwindow = FindTabWindow(position);
+	if(tabwindow) return activetabwindow = tabwindow;
+	tl.Add(tabwindow = new TabWindow());
+	tabwindow->SetStyle(*GetBase().GetStyle());
+	tabwindow->SetBase(&GetBase()).DockingStyle(GetType(), DockableCtrl::STATE_SHOW, position);
+
+	if(dockcontainer.HasChild())
+	{
+		DockableCtrl* child = dockcontainer.GetChildAt(position);
+		if(child)
+		{
+			child->Shut();
+			tabwindow->Attach(*child);
+			tabnewsize = child->GetSizeHint();
+		}
+	}
+	if(!tabwindow->IsTabbed())
+		if(tabwindow->IsDocked() && !tabwindow->IsHidden()) ShowFrame(tabnewsize);
+		dockcontainer.AddChildDock(*tabwindow, (dndpos == 0 || tabwindow->Position()) ? tabwindow->Position() : dndpos);
+	GetBase().RefreshTabWindowList();
+	return activetabwindow = tabwindow;	
+}
+
+void PaneFrame::RemoveTabWindow(TabWindow* tabwindow)
+{
+	//TODO: Remove.
+}
+
+void PaneFrame::RemoveTabWindow(int position)
+{
+	//TODO: Remove.
+}
+
+void PaneFrame::RemoveTabWindows()
+{
+	//TODO: Remove.
+}
+
+void PaneFrame::RefreshTabWindowList()
+{
+	GetBase().RefreshTabWindowList();
+	SetActiveTabWindow(NULL);
+}
+
+void PaneFrame::AddtoTabWindow(DockableCtrl& ctrl)
+{
+	TabWindow* tabwindow 	=  FindTabWindow(ctrl.Position());
+	if(!tabwindow) tabwindow = AddTabWindow(ctrl);
+	tabwindow->Attach(ctrl);
+}
+
+void PaneFrame::RemovefromTabWindow(DockableCtrl& ctrl)
+{
+	TabWindow* tabwindow = FindTabWindow(ctrl.Position());
+	if(!tabwindow) return;
+	ctrl.Shut();
+	if(tabwindow && tabwindow->IsShut())
+		delete tabwindow;
+}
+
+void PaneFrame::RemovefromTabWindow(int position)
+{
+}
+
+TabWindow* PaneFrame::FindTabWindow(int position)
+{
+	if(position <= 0) return NULL;
+	TabWindow * tabwindow = NULL;
+
+	Vector<TabWindow*>& tl = GetBase().GetTabWindows();	
+		
+	for(int i = 0; i < tl.GetCount(); i++)
+	{
+		tabwindow = tl.At(i);
+		if(tabwindow->Position() == position && 
+		tabwindow->Alignment() == GetType() && 
+		tabwindow->State() != DockableCtrl::STATE_TABBED)
+		return tabwindow;
+	}
+	return NULL;
+}
+
+TabWindow* PaneFrame::FindTabWindow(DockableCtrl& ctrl)
+{
+	return NULL;
+}
+
+TabWindow* PaneFrame::GetActiveTabWindow()
+{
+	return activetabwindow;
+}
+
+void PaneFrame::SetActiveTabWindow(TabWindow* tabwindow)
+{
+	activetabwindow = tabwindow;
+}
+
+bool PaneFrame::HasTabWindow(TabWindow* tabwindow)
+{
+	Vector<TabWindow*>& tl = GetBase().GetTabWindows();
+	for(int i = 0; i < tl.GetCount(); i++)
+		if(tabwindow == tl.At(i)) return true;
+	return false;
+}
+
+
+bool PaneFrame::HasCtrlInRange(DockableCtrl& ctrl, Point p)
+{
+	if(!GetBase().IsSideAllowed(GetType())) return false;
+	Ctrl* first = NULL;
+	Ctrl* last  = NULL;
+
+	if(!dockcontainer.HasChild())
+		return CalculateEmptyRange(ctrl, p);	
+	if(!(first = dockcontainer.GetFirstChild()) || !(last = dockcontainer.GetLastChild())) 
+		return false;
+	if((first == last) && (first != dockcontainer.GetAnimationCtrl()))
+		return CalculateCtrlRange(ctrl, *first, p);
+	else
+	{
+		Ctrl* ctrl0 = first;
+		while(ctrl0)
+		{
+			if(ctrl0 != dockcontainer.GetAnimationCtrl())
+				if(CalculateCtrlRange(ctrl, *ctrl0, p)) return true;
+			ctrl0 = ctrl0->GetNext();
+		}
+	}
+	return false;
+}
+
+bool PaneFrame::CalculateCtrlRange(DockableCtrl& t, Ctrl& c, Point p)
+{
+	DockWindow* ctrl = reinterpret_cast<DockWindow*>(&c);
+	ASSERT(ctrl);
+	Rect r = ctrl->GetCtrlRect();
+	int	 position 	= ctrl->Position();
+	int	 hrange  	= r.GetWidth()  / 3;
+	int	 vrange		= r.GetHeight() / 3;
+
+	if(!DnDHasSource())
+	{
+		if(!GetActiveTabWindow() || 
+			(GetActiveTabWindow() && 
+			!GetActiveTabWindow()->IsTabAnimating()))
+		{
+			if(Rect(r.left + hrange, r.top + vrange, r.right - hrange, r.bottom - vrange).Contains(p))
+			{
+				DnDSourceinRange();
+				StartTabWindowAnimation(*ctrl, position);
+				t.SetDropTarget(GetType(), DockableCtrl::STATE_TABBED);
+				return true;
+			}
+		}
+		if(dockcontainer.IsVert() && 
+			!GetActiveTabWindow() && 
+			!dockcontainer.IsAnimating())
+		{
+			if(Rect(r.left, r.top, r.right, r.top + vrange).Contains(p) || 
+		   	Rect(r.left, r.bottom - vrange, r.right, r.bottom).Contains(p))
+		    {
+				DnDSourceinRange();
+				StartPaneFrameAnimation(*ctrl, p.y > r.bottom - vrange ? ++position : position); 
+				t.SetDropTarget(GetType(), DockableCtrl::STATE_SHOW);
+				return true;
+		    }
+		}
+		if(dockcontainer.IsHorz() && 
+			!GetActiveTabWindow() && 
+			!dockcontainer.IsAnimating())
+		{
+			if(Rect(r.left, r.top, r.left + hrange, r.bottom).Contains(p) || 
+			Rect(r.right - hrange, r.top, r.right, r.bottom).Contains(p))
+			{
+				DnDSourceinRange();
+				StartPaneFrameAnimation(*ctrl, p.x < r.left + hrange ? position : ++position);
+				t.SetDropTarget(GetType(), DockableCtrl::STATE_SHOW);
+		   		return true;
+		  	}
+		}
+		return false;
+	}
+	if(DnDHasSource())
+	{
+		if(dockcontainer.IsHorz() && dockcontainer.IsAnimating() && 
+			dockcontainer.AnimationArea().Contains(p)) return true;
+		if(dockcontainer.IsVert())
+		{
+			r = dockcontainer.AnimationArea();
+			r.bottom += 5;
+			r.top 	 -= 5;
+			if(dockcontainer.IsAnimating() && r.Contains(p)) return true;
+		}
+
+		if(GetActiveTabWindow())
+			if(GetActiveTabWindow()->IsTabAnimating() && 
+				GetActiveTabWindow()->HasCtrlInRange()) return true;
+		DnDSourceoutofRange(); 
+		DnDAnimate(position);
+		return false;
+			
+	}
+	return false;
+}
+
+bool PaneFrame::CalculateEmptyRange(Ctrl& c, Point p)
+{
+	DockWindow* ctrl = reinterpret_cast<DockWindow*>(&c);
+	ASSERT(ctrl);
+	Rect r = GetScreenRect();
+	if(!DnDHasSource() && !dockcontainer.HasChild() && !dockcontainer.IsAnimating())
+	{
+		bool state = false;
+		switch(GetType())
+		{
+			case LEFT:
+				((p.x < r.right + 20) && (p.x > r.left) && (p.y > r.top && p.y < r.bottom)) ?
+					state = true : state = false; break;
+			case RIGHT:
+				((p.x > r.left - 20) && (p.x < r.right) && (p.y > r.top && p.y < r.bottom)) ?
+					state = true : state = false; break;
+			case TOP:
+				((p.y < r.bottom + 20) && (p.y > r.top) && (p.x > r.left && p.x < r.right))  ? 
+					state = true : state = false; break;
+			case BOTTOM:
+				((p.y > r.top - 20) && (p.y < r.bottom) && (p.x > r.left && p.x < r.right)) ?
+					state = true : state = false; break;
+		}
+		if(state) 
+		{
+			ShowFrame(ctrl->GetSizeHint());
+			DnDSourceinRange(); 
+			StartPaneFrameAnimation(reinterpret_cast<DockableCtrl&>(c), 1);
+			ctrl->SetDropTarget(GetType(), DockableCtrl::STATE_SHOW);
+			return true;
+		}
+		return false;
+	}
+
+	if(DnDHasSource())
+	{
+	
+		if(dockcontainer.IsAnimating() && dockcontainer.AnimationArea().Contains(p)) return true;
+		HideFrame();
+		DnDSourceoutofRange(); 
+		StopPaneFrameAnimation();
+		return false;
+	}
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------
+
+void PaneFrame::StartPaneFrameAnimation(DockableCtrl& ctrl, int position)
+{
+	if(DnDHasSource() && !dockcontainer.IsAnimating())
+	{
+		if(HasTabWindow(GetActiveTabWindow()))
+	   		if(GetActiveTabWindow()->IsTabAnimating())
+	   			GetActiveTabWindow()->StopTabAnimation();
+		dockcontainer.StartAnimation(position);
+		dndpos = position;
+	}
+	RefreshPaneFrame();
+}
+
+void PaneFrame::StartTabWindowAnimation(DockableCtrl& ctrl, int position)
+{
+	if(DnDHasSource() && &ctrl && (ctrl.Position() == position)) 
+	{
+		RefreshTabWindowList();
+		if(!HasTabWindow(GetActiveTabWindow())) 
+				activetabwindow = AddTabWindow(ctrl);
+		if(!GetActiveTabWindow()->IsTabAnimating())
+		{
+			if(dockcontainer.IsAnimating())	dockcontainer.StopAnimation();
+			GetActiveTabWindow()->StartTabAnimation();
+		}
+		dndpos = position;
+	}
+	RefreshPaneFrame();
+}
+
+void PaneFrame::StopPaneFrameAnimation()
+{
+	if(!DnDHasSource() && dockcontainer.IsAnimating())
+		dockcontainer.StopAnimation();
+	RefreshPaneFrame();
+}
+
+void PaneFrame::StopTabWindowAnimation()
+{
+	if(!DnDHasSource() && HasTabWindow(GetActiveTabWindow()))
+		if(GetActiveTabWindow()->IsTabAnimating())
+		{
+			GetActiveTabWindow()->StopTabAnimation();
+			RefreshTabWindowList();
+		}
+	RefreshPaneFrame();
+}
+
+
+
+void PaneFrame::DnDAnimate(int position)
+{
+	if(!(dockcontainer.IsAnimating() && dockcontainer.GetAnimationCtrl()->GetScreenRect().Contains(GetMousePos())))
+		StopPaneFrameAnimation();
+	if(HasTabWindow(GetActiveTabWindow()))
+		if(!(GetActiveTabWindow()->IsTabAnimating() && GetActiveTabWindow()->HasCtrlInRange()))
+			StopTabWindowAnimation();
+}
+
+
+//----------------------------------------------------------------------------------------------
+
+PaneFrame& PaneFrame::SetLayout(DockBase* basectrl, int alignment, int _maxsize)
+{
+	ASSERT(basectrl);
+	base = basectrl;
+	MaxSize(_maxsize);
+	
+	switch(alignment)
+	{
+		case LEFT:
+			Left(dockcontainer.SizePos(), 0);
+			break;
+		case TOP:
+			Top(dockcontainer.SizePos(), 0);
+			break;
+		case RIGHT:
+			Right(dockcontainer.SizePos(), 0);
+			break;
+		case BOTTOM:
+			Bottom(dockcontainer.SizePos(), 0);
+			break;
+	}
+	HideFrame();
+	created = true;
+	return *this;
+}
+
+void PaneFrame::FrameAdd(Ctrl& parent)
+{
+	parent.Add(*this);
+}
+
+void PaneFrame::FrameRemove()
+{
+	this->Ctrl::Remove();
+}
+
+void PaneFrame::FrameAddSize(Size& sz)
+{
+	if(IsShown()) 
+		if(type == LEFT || type == RIGHT)  
+		{
+			sz.cx += size;
+			maxsize = sz.cx / 3;
+		}
+		else
+		{
+			sz.cy += size;
+			maxsize = sz.cy / 3;
+		}
+}
+
+int  PaneFrame::BoundSize()
+{
+	int maxsize = max(0, (type == LEFT || type == RIGHT ? parentsize.cx : parentsize.cy) - sizemin);
+	return IsShown() ? max(1, minmax(size, minsize - 1, maxsize)) : 0;
+}
+
+void PaneFrame::FrameLayout(Rect& r)
+{
+	Rect rr = r;
+	parentsize = r.GetSize();
+	int sz = BoundSize();
+	switch(type) {
+	case LEFT:
+		r.left += sz;
+		rr.right = r.left;
+		break;
+	case RIGHT:
+		r.right -= sz;
+		rr.left = r.right;
+		break;
+	case TOP:
+		r.top += sz;
+		rr.bottom = r.top;
+		break;
+	case BOTTOM:
+		r.bottom -= sz;
+		rr.top = r.bottom;
+		break;
+	}
+	SetFrameRect(rr);
+}
+
+void PaneFrame::Paint(Draw& draw)
+{
+	draw.DrawRect(
+		Ctrl::GetSize(),
+		HasCapture() ? GUI_GlobalStyle() >= GUISTYLE_XP ? Blend(SColorHighlight, SColorFace) : SColorShadow
+		             : SColorFace()
+	);
+}
+
+void PaneFrame::LeftDown(Point p, dword)
+{
+	SetCapture();
+	Refresh();
+	ref = GetMousePos();
+	size0 = BoundSize();
+}
+
+void PaneFrame::MouseMove(Point p, dword keyflags)
+{
+	if(!HasCapture())
+		return;
+	p = GetMousePos();
+	switch(type) {
+	case LEFT: size = size0 + p.x - ref.x; break;
+	case RIGHT: size = size0 + ref.x - p.x; break;
+	case TOP: size = size0 + p.y - ref.y; break;
+	case BOTTOM: size = size0 + ref.y - p.y; break;
+	}
+	RefreshParentLayout();
+}
+
+void PaneFrame::LeftUp(Point p, dword keyflags)
+{
+	Refresh();
+}
+
+Image PaneFrame::CursorImage(Point p, dword keyflags)
+{
+	return type == LEFT || type == RIGHT ? Image::SizeHorz() : Image::SizeVert();
+}
+
+PaneFrame& PaneFrame::Set(Ctrl& c, int _size, int _type)
+{
+	while(GetFirstChild())
+		GetFirstChild()->Remove();
+	type = _type;
+	size = _size;
+	Add(c.SizePos());
+	switch(type) {
+	case LEFT: c.HSizePos(0, 4); break;
+	case RIGHT: c.HSizePos(4, 0); break;
+	case TOP: c.VSizePos(0, 4); break;
+	case BOTTOM: c.VSizePos(4, 0); break;
+	}
+	RefreshParentLayout();
+	return *this;
+}
+
+PaneFrame::PaneFrame()
+{
+	type = LEFT;
+	size = size0 = 1;
+	minsize = 0;
+	maxsize = 0;
+	stdsize = 0;
+	sizemin = 0;
+	dndpos	= 0;
+	ncount	= 0;
+	locked 	= false;
+	created = false;
+	activetabwindow = NULL; 
+}
+
+PaneFrame::~PaneFrame()
+{
+}
diff --git a/archive/DockCtrl/PaneSplitter.cpp b/archive/DockCtrl/PaneSplitter.cpp
new file mode 100644
index 000000000..44e5a6166
--- /dev/null
+++ b/archive/DockCtrl/PaneSplitter.cpp
@@ -0,0 +1,161 @@
+#include "DockCtrl/DockCtrl.h"
+
+
+PaneSplitter::PaneSplitter()
+{
+	animating = false;
+	SetAnimationType(PANEANIMATION);		// by default.
+	x = 0;
+	y = 0;
+}
+
+PaneSplitter::~PaneSplitter()
+{
+	animating = false;
+}
+
+void PaneSplitter::AddChildDock(DockableCtrl& dock)
+{
+	Splitter::Add((Ctrl &)dock.SizePos());
+	ReposChilds();
+}
+
+void PaneSplitter::AddChildDock(DockableCtrl& dock, int position)
+{
+	int count = GetCount();
+	if(!HasChild() || position > count) AddChildDock(dock);
+	else AddChildBefore((Ctrl*) &dock, (Ctrl *) GetChildAt(position));
+	ReposChilds();
+}
+
+void PaneSplitter::RemoveChildDock(DockableCtrl& dock)
+{
+	RemoveChildDock(dock.Position());
+}
+
+void PaneSplitter::RemoveChildDock(int position)
+{
+	DockableCtrl* ctrl = GetChildAt(position);
+	if(ctrl) ctrl->Remove();
+	ReposChilds();
+}
+
+void PaneSplitter::RemoveChilds()
+{
+	if(!HasChild()) return;
+	for(int i = 1; i < GetCount(); i++)
+		GetChildAt(i)->Shut();
+}
+
+void PaneSplitter::ReposChilds()
+{
+	if(!HasChild()) return;
+	int i = 1;
+	DockableCtrl* ctrl = (DockableCtrl*) GetFirstChild();
+	ctrl->Posit(i);
+	while(ctrl = (DockableCtrl*) ctrl->GetNext())
+		ctrl->Posit(++i);
+	if(IsOpen()) 
+		Layout();
+}
+
+DockableCtrl* PaneSplitter::GetChildAt(int position)
+{
+	if(HasChild())
+	{
+		Ctrl* ctrl = GetFirstChild();
+		while(ctrl)
+		{
+			if(ctrl != &animationctrl)
+				if(((DockableCtrl*)ctrl)->Position() == position) 
+					return (DockableCtrl*) ctrl;
+			ctrl = ctrl->GetNext();
+		}
+	}
+	return NULL;
+}
+
+int PaneSplitter::GetChildCount()
+{
+	int childcount = GetCount();
+	return IsAnimating() ?  childcount - 1 : childcount;
+}
+
+bool PaneSplitter::HasChild()
+{
+	return GetChildCount();
+}
+
+void PaneSplitter::StartAnimation(int position)
+{	
+	if(animationctrl.IsOpen()) return;
+	if(!HasChild() || position > GetCount()) 
+		Splitter::Add(animationctrl.SizePos());
+	else 
+		AddChildBefore(&animationctrl.SizePos(), (Ctrl *) GetChildAt(position));
+
+	animating = true;
+
+	if(animationtype == TABANIMATION) 
+	{
+		Ctrl* ctrl = GetChildAt(GetZoom() + 1);
+		if(ctrl)
+		{
+			const DockCtrlChStyle::Style& s = DockCtrlChStyle::StyleDefault();
+			Size sz = animationctrl.GetSize();
+			ImageDraw img(sz.cx, sz.cy);
+			ctrl->DrawCtrlWithParent(img, 0, 0);
+			img.DrawImage(sz,s.tabhighlight); 
+			Image i = img;
+			animationctrl.SetAnimImage(i);
+		}
+	}
+	Animate(position);
+}
+
+void PaneSplitter::StartAnimation(DockableCtrl& dock, int position)
+{
+	StartAnimation(position);
+}
+
+void PaneSplitter::StopAnimation()
+{
+   	if(!animationctrl.IsOpen()) return;
+	animationctrl.Type(animationtype);
+   	animationctrl.Remove();
+   	animating = false; 
+}
+
+void PaneSplitter::Animate(int position)
+{
+}
+
+void PaneSplitter::AnimateCallback()
+{
+}
+
+void PaneSplitter::Layout()
+{
+	Splitter::Layout();
+}
+
+void PaneSplitter::AnimationCtrl::Paint(Draw& d)
+{ 
+	if(ctrltype != PaneSplitter::TABANIMATION)
+		d.DrawRect(GetSize(), GUI_GlobalStyle() >= GUISTYLE_XP ? Blend(SColorHighlight, SColorFace) : SColorShadow); 
+	else
+		d.DrawImage(GetSize(), image);
+}
+
+//----------------------------------------------------------------------------------------------
+
+void PaneSplitter::AnimationCtrl::AnimateHorz()
+{
+	if(!IsVisible()) Show();
+	Ctrl::LeftPos(0, 0).Layout();
+}
+void PaneSplitter::AnimationCtrl::AnimateVert()
+{
+	if(!IsVisible()) Show();
+	Ctrl::TopPos(0, 0).Layout();
+}
diff --git a/archive/DockCtrl/READMEFIRST.txt b/archive/DockCtrl/READMEFIRST.txt
new file mode 100644
index 000000000..7092a6eca
--- /dev/null
+++ b/archive/DockCtrl/READMEFIRST.txt
@@ -0,0 +1,5 @@
+********************************************************************************
+			 THIS PACKAGE IS DEPRECEATED.
+		IT IS SUPPLIED ONLY AS AN U++ EXAMPLE
+		PLEASE USE "Docking" Package (by James Thomas - aka. Mrjt) instead.
+********************************************************************************
\ No newline at end of file
diff --git a/archive/DockCtrl/TODO.txt b/archive/DockCtrl/TODO.txt
new file mode 100644
index 000000000..918a77c0c
--- /dev/null
+++ b/archive/DockCtrl/TODO.txt
@@ -0,0 +1,15 @@
+//==============================================================================================
+// DockCtrl: A dockable widget framework for U++
+// Author:	 Ismail YILMAZ
+//==============================================================================================
+
+To Do:
+------------------------------------------
+- add a self-explanatory "Complex Dockable Framework" example to the package.
+- add "stdsize" variable to the PaneFrame class for better size control.
+- add widget grouping support.
+- add drag-n-drop animations.
+- write documentation.
+- fix possible major, and minor bugs.
+- cleaning up the code.
+- bla, bla...
\ No newline at end of file
diff --git a/archive/DockCtrl/icon.ico b/archive/DockCtrl/icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..4012786aaf7d31ccf7f963c14aae96e0b80b9f39
GIT binary patch
literal 6
NcmZQzU}Rum0000A00IC2

literal 0
HcmV?d00001

diff --git a/archive/DockCtrl/init b/archive/DockCtrl/init
new file mode 100644
index 000000000..e558a7926
--- /dev/null
+++ b/archive/DockCtrl/init
@@ -0,0 +1,6 @@
+#ifndef _DockCtrl_icpp_init_stub
+#define _DockCtrl_icpp_init_stub
+#include "CtrlCore/init"
+#include "CtrlLib/init"
+#include "Draw/init"
+#endif
diff --git a/archive/DockCtrlExample/DockCtrlExample.h b/archive/DockCtrlExample/DockCtrlExample.h
new file mode 100644
index 000000000..2e0bd46e7
--- /dev/null
+++ b/archive/DockCtrlExample/DockCtrlExample.h
@@ -0,0 +1,48 @@
+#ifndef _DockCtrlExample_DockCtrlExample_h
+#define _DockCtrlExample_DockCtrlExample_h
+
+#include <DockCtrl/DockCtrl.h>
+#include <RichEdit/RichEdit.h>
+
+using namespace Upp;
+
+#define LAYOUTFILE <DockCtrlExample/DockCtrlExample.lay>
+#include <CtrlCore/lay.h>
+
+// DockCtrlExample class declaration.
+// Derived from DockCtrl.
+
+class DockCtrlExample : public WithDockCtrlExampleLayout<DockCtrl> {
+public:
+	typedef DockCtrlExample CLASSNAME;
+	DockCtrlExample();
+	~DockCtrlExample();
+	
+	DockWindow						dock1, dock2, dock3, dock4, dock5, dock6;					// Actual Widgets 	-	these are the dockable "client" widgets
+	WithDockLayout<DockWindow>		dock7;														// DockWindow with layout.
+	//------------------------------------------------------------------------------------------
+	RichEdit	richedit;																		// Stuff to "wrap"	
+	TabCtrl		tabctrl;																		//
+	Button		button1, button2, button3;														//
+	ArrayCtrl	array1, array2;																	//
+	MenuBar 	menubar, menubar1;																//
+	ToolBar 	toolbar, toolbar1;																//
+	StatusBar 	statusbar;																		//
+	//------------------------------------------------------------------------------------------
+	virtual void InitDockCtrl();																// DockCtrl initialization functions
+	virtual void InitCustomLayouts();															// 
+	
+	// Other methods (not necessary; only for demo purpose...
+
+	void Toolbar	(Bar &bar);
+	void Menubar	(Bar &bar);
+	void WindowsMenu(Bar& bar); 
+	void InfoMenu	(Bar& bar);
+	void EditMenu	(Bar& bar);
+	void Click()	{}
+
+	
+};
+
+#endif
+
diff --git a/archive/DockCtrlExample/DockCtrlExample.lay b/archive/DockCtrlExample/DockCtrlExample.lay
new file mode 100644
index 000000000..c0422d053
--- /dev/null
+++ b/archive/DockCtrlExample/DockCtrlExample.lay
@@ -0,0 +1,12 @@
+LAYOUT(DockCtrlExampleLayout, 200, 100)
+END_LAYOUT
+
+LAYOUT(DockLayout, 248, 200)
+	ITEM(LabelBox, dv___0, SetLabel(t_("DockWindow Layout Example")).HSizePosZ(4, 4).VSizePosZ(4, 8))
+	ITEM(Clock, dv___1, HSizePosZ(96, 12).VSizePosZ(28, 60))
+	ITEM(Button, dv___2, SetLabel(t_("Button 1")).LeftPosZ(12, 56).BottomPosZ(13, 23))
+	ITEM(Button, dv___3, SetLabel(t_("Button 2")).RightPosZ(12, 56).BottomPosZ(13, 23))
+	ITEM(Option, dv___4, SetLabel(t_("Option 1")).LeftPosZ(12, 68).TopPosZ(28, 16))
+	ITEM(Option, dv___5, SetLabel(t_("Option 2")).LeftPosZ(12, 68).TopPosZ(52, 16))
+END_LAYOUT
+
diff --git a/archive/DockCtrlExample/DockCtrlExample.upp b/archive/DockCtrlExample/DockCtrlExample.upp
new file mode 100644
index 000000000..9debe27d9
--- /dev/null
+++ b/archive/DockCtrlExample/DockCtrlExample.upp
@@ -0,0 +1,16 @@
+description "Example code for the DockCtrl package";
+
+uses
+	CtrlLib,
+	DockCtrl,
+	RichEdit;
+
+file
+	DockCtrlExample.h,
+	main.cpp,
+	DockCtrlExample.lay;
+
+mainconfig
+	"" = "GUI",
+	"" = "GUI NOGTK";
+
diff --git a/archive/DockCtrlExample/init b/archive/DockCtrlExample/init
new file mode 100644
index 000000000..4716dd22d
--- /dev/null
+++ b/archive/DockCtrlExample/init
@@ -0,0 +1,7 @@
+#ifndef _DockCtrlExample_icpp_init_stub
+#define _DockCtrlExample_icpp_init_stub
+#include "CtrlLib/init"
+#include "DockCtrl/init"
+#include "RichEdit/init"
+#include "Web/init"
+#endif
diff --git a/archive/DockCtrlExample/main.cpp b/archive/DockCtrlExample/main.cpp
new file mode 100644
index 000000000..9d065e359
--- /dev/null
+++ b/archive/DockCtrlExample/main.cpp
@@ -0,0 +1,211 @@
+#include "DockCtrlExample.h"
+
+void DockCtrlExample::InitDockCtrl()
+{
+	// This is an API change (from DEV 803b.1 on).
+	// IntDockCtrl() method is called by DockCtrl at the application start.
+	// Dock initialization must be done here!
+	
+	// Magic Stuff...
+	// DockableCtrl derived widgets use 3 variable to determine their place: 
+	// -----------------------------------------------------------------------------------------
+	// 1) Alignment: 	As usual, it can be left, top, right, bottom.
+	// 2) State:	 	It can be show, hide, autohide, tab, floating, shut.
+	// 3) Position:		Determines the position of the widget, for example 0 means the widget is 
+	//					on its own (usually, at floating state, or shut). So, any "docked" widget
+	//					is at least in position 1. In normal docking mode (no tabbing) system
+	//					adds the dock automatically to the end of the list, so this variable is
+	//					optional for the user. 
+	// -----------------------------------------------------------------------------------------
+	//	Tabbing styles: While any type of manipulation is possible with the above variables,
+	//					tabbing is a little different. (From DockCtrl version DEV803b.1 on, there
+	//					are two ways to tab two (or more) dockable widgets):
+	//
+	//				1)	MANUAL TABBING: As the name may suggest, in "manual" tabbing method use
+	//					state and position combination to "tab" dockable widgets. 
+	//
+	//					Let's assume that we have 3 widgets docked on the "top" pane. And let's
+	//					say that we want to add two more docks on the top pane. We have three
+	//					alternatives: a) We can add it in usual way, and let the framework
+	//					handle the positioning. b) We can determine the position to dock.
+	//					(e.g. if we want to add it to 2. position, position should be 2). 
+	//					c) We can tab docks. Now, to tab a dock, all we have to do is to set the 
+	//					two variables properly: state and position. "State" should be "tabbed".
+	//					"position" should be the position where we want to tab (e.g. If we want
+	//					to tab the first dock then position should be 1).
+	// 
+	//					This is a framework design issue; because, with this way it is easily possible 
+	//					to tab any number of dockable widgets simultaneously. And since it can be 
+	//					confusing sometimes, it is a DEPRECEATED way. 					
+	//
+	//				2)	TABBING USING TABIFYING METHODS: From DockCtrl version DEV803b.1, Tabify()
+	//					method (has 1 overload) is added to the public API. This is the easy and
+	//					reliable way to create tabbed widgets (either normal or nested).
+	//					The Syntax of Tabify is as following;
+	//					
+	//					DockableCtrl&	Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2);
+	//					DockableCtrl&	Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2, DockableCtrl& ctrl3, DockableCtrl& ctrl4);
+	//				
+	//					As you can see, Tabify method returns DockableCtrl& reference for the created
+	//					tab window, so it's both easy to tab (normal OR nested) numerous widgets simultaneously 
+	//					and the standard docking rules apply to the created tab window (see below).
+						
+
+	Dock(dock1.SetLabel("Dock 1").DockTop().StateShow().SetIcon(CtrlImg::new_doc()));
+	Dock(dock2.SetLabel("Dock 2").DockBottom().StateShow().SetIcon(CtrlImg::new_doc()));
+	Dock(dock4.SetLabel("Dock 4").DockRight().StateTabbed().Posit(1).SetIcon(CtrlImg::new_doc()));			// Manual tabbing example
+	Dock(dock5.SetLabel("Dock 5").DockRight().StateTabbed().Posit(1).SetIcon(CtrlImg::new_doc()));			//
+	Dock(dock6.SetLabel("Dock 6").DockLeft().StateAuto().SetIcon(CtrlImg::new_doc()));						// Manual autohide (no need to set position variable).
+
+	
+
+	// Tabify():
+	// Here is two tabbing examples:
+	// Do not use Dock() for individual widgets when tabifying.
+	// Instead, pass them to the Tabify() method, and then Dock() 
+	// the Tabwindow returned by Tabify().
+	//
+	CtrlLayout(dock7);
+	dock7.SetLabel("Dock 7 - With Layout").SetIcon(CtrlImg::new_doc());										// Layout-ed dock example.
+	dock3.SetLabel("Dock 3").SetIcon(CtrlImg::new_doc());													
+	
+	Dock(Tabify(dock3, dock7).DockFloat());																	// Floating + Tabbing example.
+	
+	// Here is another example. This example is mainly for demostrating
+	// "nested tabbing". In order it to work correctly, you shoud
+	// remove "Dock()" from the widgets passed to the method. and 
+	// uncomment the 2 lines below.
+	// 
+	// AllowNestedTabbing()
+	// Dock(Tabify(dock6, dock7, dock4, dock5).DockFloat()); 
+}
+
+void DockCtrlExample::InitCustomLayouts()
+{
+	// This method is called by DockCtrl for predefined custom layouts/groups.
+	
+	// Predefined Group Example
+	// ------------------------
+	// You need to take two simple steps to add a predefined widget group to DockCtrl based application:
+	// Step 1: Add the group using WidgetGroup() method.
+	// Step 2: Use "%" operator to add ctrls to group. 
+	
+	WidgetGroup("Predefined Group 1") % dock1 % dock2 % dock3 % dock4;
+	WidgetGroup("Predefined Group 2") % dock5 % dock6 % dock7;
+	
+	// Predefined Layout Example
+	// -------------------------
+	// NOT IMPLEMENTED YET. TO BE WRITTEN (SOON)...
+}
+
+
+DockCtrlExample::DockCtrlExample()
+{
+	// DockCtrl is serializable. So, you can load and save it's configuration (layouts, settings, placements, etc.) easily.
+	LoadFromFile(*this, ConfigFile("dockctrlexamplelayout.bin"));
+
+
+	CtrlLayout(*this, "DockCtrl [DEV803b.2] Example - Use 'Settings' menu options to open the control panel");
+	Sizeable().Zoomable().SetRect(GetRect().left, GetRect().top, 1024, 600);
+	
+	// Usual U++ widget preperation.
+	button1.SetLabel("Hello").LeftPos(10, 100).BottomPos(10, 20);
+	button2.SetLabel("Brave New").HCenterPos(90).BottomPos(10, 20);
+	button3.SetLabel("World").RightPos(10, 100).BottomPos(10, 20);
+	
+	tabctrl.Add("Tab 1");
+	tabctrl.Add("Tab 2");
+	
+	array1.AddColumn("Numbers");
+	array2.AddColumn("Roman Numbers");
+	
+	for(int i = 0; i < 100; i++)
+	{
+		array1.Add(Format("%d", i));
+		array2.Add(FormatIntRoman(i, true));
+	}
+
+	// At the moment (this will change in near future!) any default BarCtrl should be added BEFORE DockCtrl. 
+	toolbar1.Set(THISBACK(Toolbar));
+	menubar1.Set(THISBACK(Menubar));	
+
+	// Here (but not necessarily) we "wrap" -or, if you prefer "dock" - the above widgets.
+	dock1 << button1 << button2 << button3;
+	dock2 << tabctrl.SizePos();
+	dock3 << array1.SizePos();
+	dock5 << array2.SizePos();
+	
+	// Currently all DockableCtrl derived classes (e.g. DockWindow, TabWindow) can use 3 traditional "bar" ctrls of U++. 
+	// Namely, MenuBar, ToolBar and StatusBar. The aim of the support for seperate bar controls is to extend the DockableCtrl functionality.
+	// So, you should see and use this "bar" support as a customization support for dockctrl framework itself;
+	dock2.AddMenuBar(menubar);
+	dock2.AddStatusBar(statusbar);
+	dock3.AddToolBar(toolbar); 
+
+	menubar.Set(THISBACK(Menubar));	
+	toolbar.Set(THISBACK(Toolbar));
+	Add(richedit.SizePos());	
+
+	// You can select which sides could be used to dock. See DockBase class 
+	// AllowLeftRight();
+}
+
+DockCtrlExample::~DockCtrlExample()
+{
+	StoreToFile(*this, ConfigFile("dockctrlexamplelayout.bin"));
+}
+
+void DockCtrlExample::Toolbar(Bar &bar)
+{
+	bar.Add(CtrlImg::open(),THISBACK(Click));
+	bar.Add(CtrlImg::new_doc(),THISBACK(Click));
+	bar.Add(CtrlImg::save(),THISBACK(Click));
+	bar.Separator();
+	bar.Add(CtrlImg::undo(),THISBACK(Click));
+	bar.Add(CtrlImg::redo(),THISBACK(Click));
+	bar.Add(CtrlImg::paste(),THISBACK(Click));
+	bar.Add(CtrlImg::remove(),THISBACK(Click));
+	bar.Separator();
+	bar.Add(CtrlImg::print(),THISBACK(Click));
+}
+
+void DockCtrlExample::Menubar(Bar &bar)
+{
+	bar.Add("File",THISBACK(WindowsMenu));
+	bar.Add("Edit",THISBACK(EditMenu));
+	bar.Add("Help",THISBACK(InfoMenu));
+}
+
+void DockCtrlExample::WindowsMenu(Bar& bar)
+{
+	bar.Add("New", CtrlImg::new_doc(), THISBACK(Click));
+	bar.Add("Open", CtrlImg::open(),THISBACK(Click));
+	bar.Add("Save", CtrlImg::save(), THISBACK(Click));
+	bar.Add("Save As...", CtrlImg::save_as(),THISBACK(Click));
+	bar.Separator();
+	bar.Add("Exit", THISBACK(Click));
+}
+
+void DockCtrlExample::InfoMenu(Bar& bar)
+{
+	bar.Add("Help Topics", CtrlImg::help(), THISBACK(Click));
+	bar.Add("About...", THISBACK(Click));
+}
+
+void DockCtrlExample::EditMenu(Bar& bar)
+{
+	bar.Add("Undo", CtrlImg::undo(), THISBACK(Click));
+	bar.Add("Redo", CtrlImg::redo(), THISBACK(Click));
+	bar.Separator();
+	bar.Add("Paste", CtrlImg::paste(), THISBACK(Click));
+	bar.Add("Remove", CtrlImg::remove(), THISBACK(Click));	
+}
+
+
+GUI_APP_MAIN
+{
+	SetLanguage(::GetSystemLNG());
+//	SetDefaultCharset(CHARSET_UTF8);
+	DockCtrlExample().Run();
+}
+