Actually move the kde files that were renamed in the last commit

1 files changed, 3331 insertions, 0 deletions

diff --git a/tdeui/kdockwidget.cpp b/tdeui/kdockwidget.cpp
new file mode 100644
index 000000000..e9cd24014
--- /dev/null
+++ b/tdeui/kdockwidget.cpp
@@ -0,0 +1,3331 @@
+
+/* This file is part of the KDE libraries
+   Copyright (C) 2000 Max Judin <novaprint@mtu-net.ru>
+   Copyright (C) 2002,2003 Joseph Wenninger <jowenn@kde.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#include "kdockwidget.h"
+#include "kdockwidget_private.h"
+#include "kdockwidget_p.h"
+
+#include <tqapplication.h>
+#include <tqlayout.h>
+#include <tqpainter.h>
+#include <tqobjectlist.h>
+#include <tqstrlist.h>
+#include <tqcursor.h>
+#include <tqwidgetlist.h>
+#include <tqtabwidget.h>
+#include <tqtooltip.h>
+#include <tqstyle.h>
+
+#ifndef NO_KDE2
+#include <kconfig.h>
+#include <kglobal.h>
+#include <klocale.h>
+#include <ktoolbar.h>
+#include <kpopupmenu.h>
+#include <kwin.h>
+#include <kdebug.h>
+#include <kglobalsettings.h>
+
+#include "config.h"
+#ifdef Q_WS_X11
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#endif
+
+#else
+#include <tqtoolbar.h>
+#include <tqpopupmenu.h>
+#endif
+
+#include <stdlib.h>
+
+#undef BORDERLESS_WINDOWS
+
+#define DOCK_CONFIG_VERSION "0.0.5"
+
+static const char* const dockback_xpm[]={
+"6 6 2 1",
+"# c black",
+". c None",
+"......",
+".#....",
+"..#..#",
+"...#.#",
+"....##",
+"..####"};
+
+static const char* const todesktop_xpm[]={
+"5 5 2 1",
+"# c black",
+". c None",
+"####.",
+"##...",
+"#.#..",
+"#..#.",
+"....#"};
+
+static const char* const not_close_xpm[]={
+"5 5 2 1",
+"# c black",
+". c None",
+"#####",
+"#...#",
+"#...#",
+"#...#",
+"#####"};
+
+/**
+ * A special kind of KMainWindow that is able to have dockwidget child widgets.
+ *
+ * The main widget should be a dockwidget where other dockwidgets can be docked to
+ * the left, right, top, bottom or to the middle.
+ * Furthermore, the KDockMainWindow has got the KDocManager and some data about the dock states.
+ *
+ * @author Max Judin.
+*/
+KDockMainWindow::KDockMainWindow( TQWidget* parent, const char *name, WFlags f)
+:KMainWindow( parent, name, f )
+{
+  TQString new_name = TQString(name) + TQString("_DockManager");
+  dockManager = new KDockManager( this, new_name.latin1() );
+  mainDockWidget = 0L;
+}
+
+KDockMainWindow::~KDockMainWindow()
+{
+	delete dockManager;
+}
+
+void KDockMainWindow::setMainDockWidget( KDockWidget* mdw )
+{
+  if ( mainDockWidget == mdw ) return;
+  mainDockWidget = mdw;
+  dockManager->setMainDockWidget2(mdw);
+}
+
+void KDockMainWindow::setView( TQWidget *view )
+{
+  if ( view->isA("KDockWidget") ){
+    if ( TQT_BASE_OBJECT(view->parent()) != TQT_BASE_OBJECT(this) ) ((KDockWidget*)view)->applyToWidget( this );
+  }
+
+#ifndef NO_KDE2
+  KMainWindow::setCentralWidget(view);
+#else
+  TQMainWindow::setCentralWidget(view);
+#endif
+}
+
+KDockWidget* KDockMainWindow::createDockWidget( const TQString& name, const TQPixmap &pixmap, TQWidget* parent, const TQString& strCaption, const TQString& strTabPageLabel)
+{
+  return new KDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
+}
+
+void KDockMainWindow::makeDockVisible( KDockWidget* dock )
+{
+  if ( dock )
+    dock->makeDockVisible();
+}
+
+void KDockMainWindow::makeDockInvisible( KDockWidget* dock )
+{
+  if ( dock )
+    dock->undock();
+}
+
+void KDockMainWindow::makeWidgetDockVisible( TQWidget* widget )
+{
+  makeDockVisible( dockManager->findWidgetParentDock(widget) );
+}
+
+void KDockMainWindow::writeDockConfig(TQDomElement &base)
+{
+  dockManager->writeConfig(base);
+}
+
+void KDockMainWindow::readDockConfig(TQDomElement &base)
+{
+  dockManager->readConfig(base);
+}
+
+#ifndef NO_KDE2
+void KDockMainWindow::writeDockConfig( KConfig* c, TQString group )
+{
+  dockManager->writeConfig( c, group );
+}
+
+void KDockMainWindow::readDockConfig( KConfig* c, TQString group )
+{
+  dockManager->readConfig( c, group );
+}
+#endif
+
+void KDockMainWindow::slotDockWidgetUndocked()
+{
+  TQObject* pSender = (TQObject*) sender();
+  if (!pSender->inherits("KDockWidget")) return;
+  KDockWidget* pDW = (KDockWidget*) pSender;
+  emit dockWidgetHasUndocked( pDW);
+}
+
+/*************************************************************************/
+KDockWidgetAbstractHeaderDrag::KDockWidgetAbstractHeaderDrag( KDockWidgetAbstractHeader* parent, KDockWidget* dock, const char* name )
+:TQFrame( parent, name )
+{
+  dw = dock;
+  installEventFilter( dock->dockManager() );
+}
+/*************************************************************************/
+KDockWidgetHeaderDrag::KDockWidgetHeaderDrag( KDockWidgetAbstractHeader* parent, KDockWidget* dock, const char* name )
+:KDockWidgetAbstractHeaderDrag( parent, dock, name )
+{
+}
+
+void KDockWidgetHeaderDrag::paintEvent( TQPaintEvent* )
+{
+  TQPainter paint;
+
+  paint.begin( this );
+
+  tqstyle().tqdrawPrimitive (TQStyle::PE_DockWindowHandle, &paint, TQRect(0,0,width(), height()), tqcolorGroup());
+
+  paint.end();
+}
+/*************************************************************************/
+KDockWidgetAbstractHeader::KDockWidgetAbstractHeader( KDockWidget* parent, const char* name )
+:TQFrame( parent, name )
+{
+}
+/*************************************************************************/
+KDockWidgetHeader::KDockWidgetHeader( KDockWidget* parent, const char* name )
+:KDockWidgetAbstractHeader( parent, name )
+{
+#ifdef BORDERLESS_WINDOWS
+  setCursor(TQCursor(ArrowCursor));
+#endif
+  d = new KDockWidgetHeaderPrivate( TQT_TQOBJECT(this) );
+
+  layout = new TQHBoxLayout( this );
+  layout->setResizeMode( TQLayout::Minimum );
+
+  drag = new KDockWidgetHeaderDrag( this, parent );
+
+  closeButton = new KDockButton_Private( this, "DockCloseButton" );
+  TQToolTip::add( closeButton, i18n("Close") );
+  closeButton->setPixmap( tqstyle().stylePixmap (TQStyle::SP_TitleBarCloseButton , this));
+  closeButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
+  connect( closeButton, TQT_SIGNAL(clicked()), parent, TQT_SIGNAL(headerCloseButtonClicked()));
+  connect( closeButton, TQT_SIGNAL(clicked()), parent, TQT_SLOT(undock()));
+
+  stayButton = new KDockButton_Private( this, "DockStayButton" );
+  TQToolTip::add( stayButton, i18n("Freeze the window geometry", "Freeze") );
+  stayButton->setToggleButton( true );
+  stayButton->setPixmap( const_cast< const char** >(not_close_xpm) );
+  stayButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
+  connect( stayButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotStayClicked()));
+
+  dockbackButton = new KDockButton_Private( this, "DockbackButton" );
+  TQToolTip::add( dockbackButton, i18n("Dock this window", "Dock") );
+  dockbackButton->setPixmap( const_cast< const char** >(dockback_xpm));
+  dockbackButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
+  connect( dockbackButton, TQT_SIGNAL(clicked()), parent, TQT_SIGNAL(headerDockbackButtonClicked()));
+  connect( dockbackButton, TQT_SIGNAL(clicked()), parent, TQT_SLOT(dockBack()));
+
+  d->toDesktopButton = new KDockButton_Private( this, "ToDesktopButton" );
+  TQToolTip::add( d->toDesktopButton, i18n("Detach") );
+  d->toDesktopButton->setPixmap( const_cast< const char** >(todesktop_xpm));
+  d->toDesktopButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
+  connect( d->toDesktopButton, TQT_SIGNAL(clicked()), parent, TQT_SLOT(toDesktop()));
+  stayButton->hide();
+
+  d->dummy = new TQWidget( this );
+  d->dummy->setFixedSize( 1,closeButton->pixmap()->height() );
+
+
+  layout->addWidget( drag );
+  layout->addWidget( dockbackButton );
+  layout->addWidget( d->toDesktopButton );
+  layout->addWidget( d->dummy);
+  layout->addWidget( stayButton );
+  layout->addWidget( closeButton );
+  layout->activate();
+  d->dummy->hide();
+  drag->setFixedHeight( layout->tqminimumSize().height() );
+}
+
+void KDockWidgetHeader::setTopLevel( bool isTopLevel )
+{
+  d->topLevel = isTopLevel;
+  if ( isTopLevel ){
+    KDockWidget* par = (KDockWidget*)parent();
+    if( par && par->isDockBackPossible() )
+        dockbackButton->show();
+    else
+        dockbackButton->hide();
+
+    stayButton->hide();
+    closeButton->hide();
+    d->toDesktopButton->hide();
+    drag->setEnabled( true );
+  } else {
+    dockbackButton->hide();
+    stayButton->hide();
+    if (!d->forceCloseButtonHidden) closeButton->show();
+    if( d->showToDesktopButton )
+      d->toDesktopButton->show();
+  }
+  layout->activate();
+
+   bool dontShowDummy=drag->isVisibleTo(this) || dockbackButton->isVisibleTo(this) ||
+        d->toDesktopButton->isVisibleTo(this) || stayButton->isVisibleTo(this) ||
+        closeButton->isVisibleTo(this);
+   for (TQPtrListIterator<KDockButton_Private> it( d->btns );it.current();++it) {
+        dontShowDummy=dontShowDummy || (it.current()->isVisibleTo(this));
+   }
+   if (dontShowDummy) d->dummy->hide(); else d->dummy->show();
+
+  updateGeometry();
+}
+
+void KDockWidgetHeader::forceCloseButtonHidden(bool hidden) {
+  d->forceCloseButtonHidden=hidden;
+  if (hidden) closeButton->hide();
+  else closeButton->show();
+}
+
+KDockWidgetHeaderDrag *KDockWidgetHeader::dragPanel() {
+	return drag;
+}
+
+void KDockWidgetHeader::setDragPanel( KDockWidgetHeaderDrag* nd )
+{
+  if ( !nd ) return;
+
+  delete layout;
+  layout = new TQHBoxLayout( this );
+  layout->setResizeMode( TQLayout::Minimum );
+
+  delete drag;
+  drag = nd;
+  if (drag->parentWidget()!=this) {
+	drag->reparent(this,TQPoint(0,0));
+  }
+
+
+  layout->addWidget( drag );
+  layout->addWidget( dockbackButton );
+  layout->addWidget( d->dummy );
+  layout->addWidget( d->toDesktopButton );
+  layout->addWidget( stayButton );
+  bool dontShowDummy=drag->isVisibleTo(this) || dockbackButton->isVisibleTo(this) ||
+	d->toDesktopButton->isVisibleTo(this) || stayButton->isVisibleTo(this) ||
+	closeButton->isVisibleTo(this);
+  for (TQPtrListIterator<KDockButton_Private> it( d->btns );it.current();++it) {
+      layout->addWidget(it.current());
+	dontShowDummy=dontShowDummy || (it.current()->isVisibleTo(this));
+  }
+  if (dontShowDummy) d->dummy->hide(); else d->dummy->show();
+  layout->addWidget( closeButton );
+  layout->activate();
+  kdDebug(282)<<"KdockWidgetHeader::setDragPanel:minimum height="<<layout->tqminimumSize().height()<<endl;
+  //FIXME somebody left this here, but we don't know what the hell it's for.
+  drag->setFixedHeight( closeButton->height()); // /*layout->minimumS*/tqsizeHint().height() );
+}
+
+void KDockWidgetHeader::addButton(KDockButton_Private* btn) {
+	if (!btn) return;
+
+	if (btn->parentWidget()!=this) {
+		btn->reparent(this,TQPoint(0,0));
+	}
+	btn->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
+	if (!d->btns.containsRef(btn)) d->btns.append(btn);
+
+	btn->show();
+
+	delete layout;
+	layout = new TQHBoxLayout( this );
+	layout->setResizeMode( TQLayout::Minimum );
+
+	layout->addWidget( drag );
+ 	layout->addWidget( dockbackButton );
+	layout->addWidget( d->toDesktopButton );
+	layout->addWidget( d->dummy);
+	layout->addWidget( stayButton );
+	 bool dontShowDummy=drag->isVisibleTo(this) || dockbackButton->isVisibleTo(this) ||
+	        d->toDesktopButton->isVisibleTo(this) || stayButton->isVisibleTo(this) ||
+        	closeButton->isVisibleTo(this);
+	 for (TQPtrListIterator<KDockButton_Private> it( d->btns );it.current();++it) {
+	        layout->addWidget(it.current());
+		dontShowDummy=dontShowDummy || (it.current()->isVisibleTo(this));
+   	}
+  	if (dontShowDummy) d->dummy->hide(); else d->dummy->show();
+	layout->addWidget( closeButton );
+	layout->activate();
+	drag->setFixedHeight( layout->tqminimumSize().height() );
+}
+
+void KDockWidgetHeader::removeButton(KDockButton_Private* btn) {
+	if (btn->parentWidget()==this) {
+		if (d->btns.containsRef(btn)) d->btns.removeRef(btn);
+		delete btn;
+	}
+}
+
+
+void KDockWidgetHeader::slotStayClicked()
+{
+  setDragEnabled(!stayButton->isOn());
+}
+
+bool KDockWidgetHeader::dragEnabled() const
+{
+  return drag->isEnabled();
+}
+
+void KDockWidgetHeader::showUndockButton(bool show)
+{
+  kdDebug(282)<<"KDockWidgetHeader::showUndockButton("<<show<<")"<<endl;
+  if( d->showToDesktopButton == show )
+    return;
+
+  d->showToDesktopButton = show;
+  if( !show || d->topLevel )
+    d->toDesktopButton->hide( );
+  else
+    d->toDesktopButton->show( );
+}
+
+void KDockWidgetHeader::setDragEnabled(bool b)
+{
+  stayButton->setOn(!b);
+  closeButton->setEnabled(b);
+  drag->setEnabled(b);
+}
+
+#ifndef NO_KDE2
+void KDockWidgetHeader::saveConfig( KConfig* c )
+{
+  c->writeEntry( TQString("%1%2").arg(parent()->name()).arg(":stayButton"), stayButton->isOn() );
+}
+
+void KDockWidgetHeader::loadConfig( KConfig* c )
+{
+  setDragEnabled( !c->readBoolEntry( TQString("%1%2").arg(parent()->name()).arg(":stayButton"), false ) );
+}
+#endif
+
+/*************************************************************************/
+
+class KDockManager::KDockManagerPrivate
+{
+public:
+  /**
+   * This rectangle is used to highlight the current dockposition. It stores global screen coordinates.
+   */
+  TQRect dragRect;
+
+  /**
+   * This rectangle is used to erase the previously highlighted dockposition. It stores global screen coordinates.
+   */
+  TQRect oldDragRect;
+
+  /**
+   * This flag stores the information if dragging is ready to start. Used between mousePress and mouseMove event.
+   */
+  bool readyToDrag;
+
+  /**
+   * This variable stores the offset of the mouse cursor to the upper left edge of the current drag widget.
+   */
+  TQPoint dragOffset;
+
+  /**
+   * These flags store information about the splitter behavior
+   */
+  bool splitterOpaqueResize;
+  bool splitterKeepSize;
+  bool splitterHighResolution;
+
+  TQGuardedPtr<KDockWidget> mainDockWidget;
+
+  TQObjectList containerDocks;
+
+  TQGuardedPtr<KDockWidget> leftContainer;
+  TQGuardedPtr<KDockWidget> topContainer;
+  TQGuardedPtr<KDockWidget> rightContainer;
+  TQGuardedPtr<KDockWidget> bottomContainer;
+  int m_readDockConfigMode;
+};
+
+
+/*************************************************************************/
+KDockWidget::KDockWidget( KDockManager* dockManager, const char* name, const TQPixmap &pixmap, TQWidget* parent, const TQString& strCaption, const TQString& strTabPageLabel, WFlags f)
+#ifdef BORDERLESS_WINDOWS
+: TQWidget( parent, name, f )//| WType_Dialog | WStyle_Customize | WStyle_NoBorder )
+#else
+: TQWidget( parent, name, f )
+#endif
+  ,formerBrotherDockWidget(0L)
+  ,currentDockPos(DockNone)
+  ,formerDockPos(DockNone)
+  ,widget(0L)
+  ,pix(new TQPixmap(pixmap))
+  ,prevSideDockPosBeforeDrag(DockNone)
+  ,isGroup(false)
+{
+  d = new KDockWidgetPrivate();  // create private data
+
+  d->_parent = parent;
+
+  layout = new TQVBoxLayout( this );
+  layout->setResizeMode( TQLayout::Minimum );
+
+  manager = dockManager;
+  manager->childDock->append( TQT_TQOBJECT(this) );
+  installEventFilter( manager );
+
+  eDocking = DockFullDocking;
+  sDocking = DockFullSite;
+
+  header = 0L;
+  setHeader( new KDockWidgetHeader( this, "AutoCreatedDockHeader" ) );
+
+  if( strCaption.isNull() )
+    setCaption( name );
+  else
+    setCaption( strCaption);
+
+  if( strTabPageLabel == " ")
+    setTabPageLabel( caption());
+  else
+    setTabPageLabel( strTabPageLabel);
+
+  isTabGroup = false;
+  d->isContainer =false;
+  setIcon( pixmap);
+  widget = 0L;
+
+  TQObject::connect(this, TQT_SIGNAL(hasUndocked()), manager->main, TQT_SLOT(slotDockWidgetUndocked()) );
+  applyToWidget( parent, TQPoint(0,0) );
+}
+
+void KDockWidget::setPixmap(const TQPixmap& pixmap) {
+	delete pix;
+	pix=new TQPixmap(pixmap);
+	setIcon(*pix);
+	KDockTabGroup *dtg=parentDockTabGroup();
+	if (dtg)
+		dtg->changeTab(this,pixmap,dtg->tabLabel(this));
+	 TQWidget *contWid=parentDockContainer();
+         if (contWid) {
+         	KDockContainer *x = tqt_dynamic_cast<KDockContainer*>(contWid);
+                if (x) {
+                        x->setPixmap(this,pixmap);
+                }
+         }
+}
+
+const TQPixmap& KDockWidget::pixmap() const {
+	return *pix;
+}
+
+KDockWidget::~KDockWidget()
+{
+  d->pendingDtor = true;
+  if ( !manager->undockProcess ){
+    d->blockHasUndockedSignal = true;
+    undock();
+    d->blockHasUndockedSignal = false;
+  }
+
+  if (latestKDockContainer()) {
+    KDockContainer *x = tqt_dynamic_cast<KDockContainer*>(latestKDockContainer());
+    if (x) {
+      x->removeWidget(this);
+    }
+  }
+  emit iMBeingClosed();
+  if (manager->d) manager->d->containerDocks.remove(TQT_TQOBJECT(this));
+  manager->childDock->remove(TQT_TQOBJECT(this));
+  delete pix;
+  delete d; // destroy private data
+  d=0;
+}
+
+void KDockWidget::paintEvent(TQPaintEvent* pe)
+{
+	TQWidget::paintEvent(pe);
+        TQPainter paint;
+        paint.begin( this );
+        tqstyle().tqdrawPrimitive (TQStyle::PE_Panel, &paint, TQRect(0,0,width(), height()), tqcolorGroup());
+        paint.end();
+}
+
+void KDockWidget::leaveEvent(TQEvent *e)
+{
+	TQWidget::leaveEvent(e);
+#ifdef BORDERLESS_WINDOWS
+	if (parent()) return;
+//	setCursor(TQCursor(ArrowCursor));
+#endif
+}
+
+void KDockWidget::mousePressEvent(TQMouseEvent* mme)
+{
+#ifdef BORDERLESS_WINDOWS
+	if (!parent())
+	{
+		kdDebug(282)<<"KDockWidget::mousePressEvent"<<endl;
+
+		bool bbottom;
+		bool bleft;
+		bool bright;
+		bool btop;
+		int styleheight;
+		TQPoint mp;
+		mp=mme->pos();
+      		styleheight=2*tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth,this);
+		bbottom=mp.y()>=height()-styleheight;
+		btop=mp.y()<=styleheight;
+		bleft=mp.x()<=styleheight;
+		bright=mp.x()>=width()-styleheight;
+		kdDebug(282)<<"mousemovevent"<<endl;
+ 		d->resizing=true;
+		if (bright)
+		{
+			if (btop)
+			{
+				d->resizeMode=KDockWidgetPrivate::ResizeTopRight;
+				d->resizePos=TQPoint(width(),0)-mme->pos();
+
+			}
+			else
+			{
+				d->resizePos=TQPoint(width(),height())-mme->pos();
+				if (bbottom) d->resizeMode=KDockWidgetPrivate::ResizeBottomRight;
+				else d->resizeMode=KDockWidgetPrivate::ResizeRight;
+			}
+		}
+		else if (bleft)
+		{
+			if (btop) setCursor(TQCursor(SizeFDiagCursor));
+			else
+			if (bbottom) setCursor(TQCursor(SizeBDiagCursor));
+			else setCursor(TQCursor(SizeHorCursor));
+		}
+		else
+		if (bbottom)
+		{
+			d->resizeMode=KDockWidgetPrivate::ResizeBottom;
+			d->resizePos=TQPoint(0,height())-mme->pos();
+		}
+		else
+		if  (btop) setCursor(TQCursor(SizeVerCursor));
+		else d->resizing=false;
+
+		if (d->resizing) grabMouse(cursor());
+
+	}
+#endif
+	TQWidget::mousePressEvent(mme);
+}
+
+void KDockWidget::mouseReleaseEvent(TQMouseEvent* ev)
+{
+#ifdef BORDERLESS_WINDOWS
+	d->resizing=false;
+	releaseMouse();
+#endif
+	TQWidget::mouseReleaseEvent(ev);
+}
+
+void  KDockWidget::mouseMoveEvent(TQMouseEvent* mme)
+{
+	TQWidget::mouseMoveEvent(mme);
+#ifdef BORDERLESS_WINDOWS
+	if (parent()) return;
+
+	if (d->resizing)
+	{
+		switch (d->resizeMode)
+		{
+			case KDockWidgetPrivate::ResizeRight:
+				resize(mme->pos().x()+d->resizePos.x(),height());
+				break;
+			case KDockWidgetPrivate::ResizeBottomRight:
+				resize(mme->pos().x()+d->resizePos.x(),mme->pos().y()+d->resizePos.y());
+				break;
+			case KDockWidgetPrivate::ResizeBottom:
+				resize(width(),mme->pos().y()+d->resizePos.y());
+				break;
+			default:
+				break;
+		}
+		return;
+	}
+
+
+	bool bbottom;
+	bool bleft;
+	bool bright;
+	bool btop;
+	int styleheight;
+	TQPoint mp;
+	mp=mme->pos();
+      	styleheight=2*tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth,this);
+	bbottom=mp.y()>=height()-styleheight;
+	btop=mp.y()<=styleheight;
+	bleft=mp.x()<=styleheight;
+	bright=mp.x()>=width()-styleheight;
+	kdDebug(282)<<"mousemovevent"<<endl;
+	if (bright)
+	{
+		if (btop) setCursor(TQCursor(SizeBDiagCursor));
+		else
+		if (bbottom) setCursor(TQCursor(SizeFDiagCursor));
+		else setCursor(TQCursor(SizeHorCursor));
+	}
+	else if (bleft)
+	{
+		if (btop) setCursor(TQCursor(SizeFDiagCursor));
+		else
+		if (bbottom) setCursor(TQCursor(SizeBDiagCursor));
+		else setCursor(TQCursor(SizeHorCursor));
+	}
+	else
+	if (bbottom ||  btop) setCursor(TQCursor(SizeVerCursor));
+	else setCursor(TQCursor(ArrowCursor));
+#endif
+}
+
+void KDockWidget::setLatestKDockContainer(TQWidget* container)
+{
+	if (container)
+	{
+		if (tqt_dynamic_cast<KDockContainer*>(container))
+			d->container=container;
+		else
+			d->container=0;
+	}
+}
+
+TQWidget* KDockWidget::latestKDockContainer()
+{
+	if (!(d->container)) return 0;
+	if (tqt_dynamic_cast<KDockContainer*>(d->container.operator->())) return d->container;
+	return 0;
+}
+
+
+
+KDockWidgetAbstractHeader *KDockWidget::getHeader() {
+	return header;
+}
+
+void KDockWidget::setHeader( KDockWidgetAbstractHeader* h )
+{
+  if ( !h ) return;
+
+  if ( header ){
+    delete header;
+    delete layout;
+    header = h;
+    layout = new TQVBoxLayout( this );
+    layout->setResizeMode( TQLayout::Minimum );
+    layout->addWidget( header );
+     setWidget( widget );
+  } else {
+    header = h;
+    layout->addWidget( header );
+  }
+  kdDebug(282)<<caption()<<": KDockWidget::setHeader"<<endl;
+  setEnableDocking(eDocking);
+}
+
+void KDockWidget::setEnableDocking( int pos )
+{
+  eDocking = pos;
+  if( header ) {
+     if (header->inherits( "KDockWidgetHeader" ) )
+         ( ( KDockWidgetHeader* ) header )->showUndockButton( pos & DockDesktop );
+    updateHeader();
+  }
+}
+
+void KDockWidget::updateHeader()
+{
+  if ( parent() ){
+#ifdef BORDERLESS_WINDOWS
+      layout->setMargin(0);
+      setMouseTracking(false);
+      setCursor(TQCursor(ArrowCursor));
+#endif
+
+    if ( (TQT_BASE_OBJECT(parent()) == TQT_BASE_OBJECT(manager->main)) || isGroup || (eDocking == KDockWidget::DockNone) ){
+      header->hide();
+    } else {
+      header->setTopLevel( false );
+      if (widget && tqt_dynamic_cast<KDockContainer*>(widget))
+        header->hide();
+      else
+        header->show();
+    }
+  } else {
+    header->setTopLevel( true );
+    header->show();
+#ifdef BORDERLESS_WINDOWS
+      layout->setMargin(2*tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth,this));
+      setMouseTracking(true);
+#endif
+  }
+}
+
+void KDockWidget::applyToWidget( TQWidget* s, const TQPoint& p )
+{
+  if ( TQT_BASE_OBJECT(parent()) != TQT_BASE_OBJECT(s) )
+  {
+    hide();
+    reparent(s, 0, TQPoint(0,0), false);
+  }
+
+  if ( s && s->inherits("KDockMainWindow") ){
+    ((KDockMainWindow*)s)->setView( this );
+  }
+
+  if ( manager && s == manager->main ){
+      setGeometry( TQRect(TQPoint(0,0), manager->main->geometry().size()) );
+  }
+
+  if ( !s )
+  {
+    move(p);
+
+#ifndef NO_KDE2
+#ifdef Q_WS_X11
+    if (d->transient && d->_parent)
+      XSetTransientForHint( qt_xdisplay(), winId(), d->_parent->winId() );
+
+#ifdef BORDERLESS_WINDOWS
+    KWin::setType( winId(), NET::Override); //d->windowType );
+//      setWFlags(WStyle_Customize | WStyle_NoBorder | WStyle_Tool);
+#else
+    KWin::setType( winId(), d->windowType );
+#endif // BORDERLESS_WINDOW
+#endif // Q_WS_X11
+#endif
+
+  }
+  updateHeader();
+
+  setIcon(*pix);
+}
+
+void KDockWidget::show()
+{
+  if ( parent() || manager->main->isVisible() )
+    if ( !parent() ){
+     emit manager->setDockDefaultPos( this );
+     emit setDockDefaultPos();
+     if ( parent() ){
+        makeDockVisible();
+      } else {
+        TQWidget::show();
+      }
+    } else {
+     TQWidget::show();
+    }
+}
+
+#ifndef NO_KDE2
+
+void KDockWidget::setDockWindowType (NET::WindowType windowType)
+{
+  d->windowType = windowType;
+  applyToWidget( parentWidget(), TQPoint(0,0) );
+}
+
+#endif
+
+void KDockWidget::setDockWindowTransient (TQWidget *parent, bool transientEnabled)
+{
+  d->_parent = parent;
+  d->transient = transientEnabled;
+  applyToWidget( parentWidget(), TQPoint(0,0) );
+}
+
+TQWidget *KDockWidget::transientTo() {
+	if (d->transient && d->_parent) return d->_parent; else return 0;
+}
+
+bool KDockWidget::event( TQEvent *event )
+{
+  switch ( event->type() )
+  {
+    #undef FocusIn
+    case TQEvent::FocusIn:
+      if (widget && !d->pendingFocusInEvent) {
+         d->pendingFocusInEvent = true;
+         widget->setFocus();
+      }
+      d->pendingFocusInEvent = false;
+      break;
+    case TQEvent::ChildRemoved:
+      if ( widget == ((TQChildEvent*)event)->child() ) widget = 0L;
+      break;
+    case TQEvent::Show:
+      if ( widget ) widget->show();
+      emit manager->change();
+      break;
+    case TQEvent::Hide:
+      if ( widget ) widget->hide();
+      emit manager->change();
+      break;
+    case TQEvent::CaptionChange:
+      if ( parentWidget() ){
+        if ( parent()->inherits("KDockSplitter") ){
+          ((KDockSplitter*)(parent()))->updateName();
+        }
+        if ( parentDockTabGroup() ){
+          setDockTabName( parentDockTabGroup() );
+          parentDockTabGroup()->setTabLabel( this, tabPageLabel() );
+        }
+      }
+      break;
+    case TQEvent::Close:
+      emit iMBeingClosed();
+      break;
+    default:
+      break;
+  }
+  return TQWidget::event( event );
+}
+
+KDockWidget *KDockWidget::findNearestDockWidget(DockPosition pos)
+{
+	if (!parent()) return 0;
+	if (!parent()->inherits("KDockSplitter")) return 0;
+	Orientation orientation=((pos==DockLeft) || (pos==DockRight)) ? Qt::Vertical:Qt::Horizontal;
+		if (((KDockSplitter*)(parent()))->orientation()==orientation)
+		{
+			KDockWidget *neighbor=
+				((pos==DockLeft)||(pos==DockTop))?
+				static_cast<KDockWidget*>(((KDockSplitter*)(parent()))->getFirst()):
+				static_cast<KDockWidget*>(((KDockSplitter*)(parent()))->getLast());
+
+			if (neighbor==this)
+			return (static_cast<KDockWidget*>(TQT_TQWIDGET(parent()->parent()))->findNearestDockWidget(pos));
+			else
+			if (neighbor->getWidget() && (::tqqt_cast<KDockTabGroup*>(neighbor->getWidget())))
+				return (KDockWidget*)(((KDockTabGroup*)neighbor->getWidget())->page(0));
+			else
+			return neighbor;
+		}
+		else
+		return (static_cast<KDockWidget*>(TQT_TQWIDGET(parent()->parent()))->findNearestDockWidget(pos));
+
+	return 0;
+}
+
+
+KDockWidget* KDockWidget::manualDock( KDockWidget* target, DockPosition dockPos, int spliPos, TQPoint pos, bool check, int tabIndex )
+{
+  if (this == target)
+    return 0L;  // docking to itself not possible
+
+//  kdDebug(282)<<"manualDock called "<<endl;
+  bool success = true; // tested flag
+
+  // Check to make sure that we can dock in to the position wee
+  // were told to dock in to
+  if ( !(eDocking & (int)dockPos) ){
+    success = false;
+//  kdDebug(282)<<"KDockWidget::manualDock(): success = false (1)"<<endl;
+  }
+
+  // fix for apps which use a value > 100%. The splitter position must be between 0..100
+  // The old behavior on high resolution was 0..10000. So likely the value is >100.
+  if (spliPos > 100) {
+      spliPos = spliPos / 100;
+      kdDebug(282) << "KDockWidget::manualDock(): fix splitter position: " << spliPos << endl;
+  }
+
+  KDockWidget *tmpTarget = 0;
+  switch (dockPos) {
+	case DockLeft:
+		tmpTarget=dockManager()->d->leftContainer;
+		break;
+	case DockRight:
+		tmpTarget=dockManager()->d->rightContainer;
+		break;
+	case DockBottom:
+		tmpTarget=dockManager()->d->bottomContainer;
+		break;
+	case DockTop:
+		tmpTarget=dockManager()->d->topContainer;
+		break;
+	default:
+		tmpTarget = 0;
+  }
+
+  //If we're not the target, and the target is our dock manager's main window
+  //dock into the temp target as chosen above
+  if ( tmpTarget && target && this != tmpTarget && target == dockManager()->d->mainDockWidget )
+    return manualDock(tmpTarget,DockCenter,spliPos,pos,check,tabIndex);
+
+  // check if the target allows us to oock into the requested position
+  if ( target && !(target->sDocking & (int)dockPos) ){
+    success = false;
+//  kdDebug(282)<<"KDockWidget::manualDock(): success = false (2)"<<endl;
+  }
+
+  /* if we have a parent, and it's not a KDockSplitter, and we don't have a parent
+   * dock tab group, and our parent isn't a KDockContainer, and we have no explicit
+   * parent dock container...we can't do much yet */
+  if ( parent() && !parent()->inherits("KDockSplitter") && !parentDockTabGroup() &&
+  	!(tqt_dynamic_cast<KDockContainer*>(parent())) && !parentDockContainer()){
+//  kdDebug(282)<<"KDockWidget::manualDock(): success = false (3)"<<endl;
+//  kdDebug(282)<<parent()->name()<<endl;
+    success = false;
+  }
+
+  /* If all of our attempts to dock back so far have failed and we have a target
+   * and we're not being called recursively (i guess that's what check is for)
+   * then attempt to dock back to ourselves. */
+  if ( !success ){
+    // try to make another manualDock
+    KDockWidget* dock_result = 0L;
+    if ( target && !check ){
+      KDockWidget::DockPosition another__dockPos = KDockWidget::DockNone;
+      switch ( dockPos ){
+        case KDockWidget::DockLeft  : another__dockPos = KDockWidget::DockRight ; break;
+        case KDockWidget::DockRight : another__dockPos = KDockWidget::DockLeft  ; break;
+        case KDockWidget::DockTop   : another__dockPos = KDockWidget::DockBottom; break;
+        case KDockWidget::DockBottom: another__dockPos = KDockWidget::DockTop   ; break;
+        default: break;
+      }
+      dock_result = target->manualDock( this, another__dockPos, spliPos, pos, true, tabIndex );
+    }
+    return dock_result;
+  }
+  // end check block
+
+  d->blockHasUndockedSignal = true;
+  undock();
+  d->blockHasUndockedSignal = false;
+
+  //we have no docking target, so we're undocking
+  if ( !target ){
+    move( pos );
+    show();
+    emit manager->change();
+    return this;
+  }
+
+//  kdDebug(282)<<"Looking for  KDockTabGroup"<<endl;
+  KDockTabGroup* parentTab = target->parentDockTabGroup();
+  if ( parentTab ){
+    // add to existing TabGroup
+    applyToWidget( parentTab );
+    parentTab->insertTab( this, icon() ? *icon() : TQPixmap(),
+                          tabPageLabel(), tabIndex );
+
+    TQWidget *wantTransient=parentTab->transientTo();
+    target->setDockWindowTransient(wantTransient,wantTransient);
+
+    setDockTabName( parentTab );
+    if( !toolTipStr.isEmpty())
+      parentTab->setTabToolTip( this, toolTipStr);
+
+    currentDockPos = KDockWidget::DockCenter;
+    emit manager->change();
+    return (KDockWidget*)parentTab->parent();
+  }
+  else
+  {
+//  	kdDebug(282)<<"Looking for  KDockContainer"<<endl;
+  	TQWidget *contWid=target->parentDockContainer();
+	  if (!contWid) contWid=target->widget;
+	  if (contWid)
+	  {
+	  	KDockContainer *cont=tqt_dynamic_cast<KDockContainer*>(contWid);
+		  if (cont)
+		  {
+			if (latestKDockContainer() && (latestKDockContainer()!=contWid)) {
+				KDockContainer* dc = tqt_dynamic_cast<KDockContainer*>(latestKDockContainer());
+				if (dc) {
+					dc->removeWidget(this);
+				}
+			}
+//			kdDebug(282)<<"KDockContainerFound"<<endl;
+			applyToWidget( contWid );
+			cont->insertWidget( this, icon() ? *icon() : TQPixmap(),
+						tabPageLabel(), tabIndex );
+			setLatestKDockContainer(contWid);
+//			setDockTabName( parentTab );
+			if( !toolTipStr.isEmpty())
+			cont->setToolTip( this, toolTipStr);
+
+			currentDockPos = KDockWidget::DockCenter;
+			emit manager->change();
+			return (KDockWidget*)(cont->parentDockWidget());
+
+		  }
+	  }
+  }
+
+  // create a new dockwidget that will contain the target and this
+  TQWidget* parentDock = target->parentWidget();
+  KDockWidget* newDock = new KDockWidget( manager, "tempName", TQPixmap(TQString("")), parentDock );
+  newDock->currentDockPos = target->currentDockPos;
+
+  if ( dockPos == KDockWidget::DockCenter ){
+    newDock->isTabGroup = true;
+  } else {
+    newDock->isGroup = true;
+  }
+  newDock->eDocking = (target->eDocking & eDocking) & (~(int)KDockWidget::DockCenter);
+
+  newDock->applyToWidget( parentDock );
+
+  if ( !parentDock ){
+    // dock to a toplevel dockwidget means newDock is toplevel now
+    newDock->move( target->frameGeometry().topLeft() );
+    newDock->resize( target->geometry().size() );
+    if ( target->isVisibleToTLW() ) newDock->show();
+  }
+
+  // redirect the dockback button to the new dockwidget
+  if( target->formerBrotherDockWidget ) {
+    newDock->setFormerBrotherDockWidget(target->formerBrotherDockWidget);
+    if( formerBrotherDockWidget )
+      target->loseFormerBrotherDockWidget();
+    }
+  newDock->formerDockPos = target->formerDockPos;
+
+
+ // HERE SOMETING CREATING CONTAINERS SHOULD BE ADDED !!!!!
+  if ( dockPos == KDockWidget::DockCenter )
+  {
+    KDockTabGroup* tab = new KDockTabGroup( newDock, "_dock_tab");
+    TQObject::connect(tab, TQT_SIGNAL(currentChanged(TQWidget*)), d, TQT_SLOT(slotFocusEmbeddedWidget(TQWidget*)));
+    newDock->setWidget( tab );
+
+    target->applyToWidget( tab );
+    applyToWidget( tab );
+
+
+    tab->insertTab( target, target->icon() ? *(target->icon()) : TQPixmap(),
+                    target->tabPageLabel() );
+
+
+
+    if( !target->toolTipString().isEmpty())
+     tab->setTabToolTip( target, target->toolTipString());
+
+    tab->insertTab( this, icon() ? *icon() : TQPixmap(),
+                    tabPageLabel(), tabIndex );
+
+    TQRect geom=newDock->geometry();
+    TQWidget *wantTransient=tab->transientTo();
+    newDock->setDockWindowTransient(wantTransient,wantTransient);
+    newDock->setGeometry(geom);
+
+    if( !toolTipString().isEmpty())
+      tab->setTabToolTip( this, toolTipString());
+
+    setDockTabName( tab );
+    tab->show();
+
+    currentDockPos = DockCenter;
+    target->formerDockPos = target->currentDockPos;
+    target->currentDockPos = DockCenter;
+  }
+  else {
+    // if to dock not to the center of the target dockwidget,
+    // dock to newDock
+    KDockSplitter* panner = 0L;
+    if ( dockPos == KDockWidget::DockTop  || dockPos == KDockWidget::DockBottom ) panner = new KDockSplitter( newDock, "_dock_split_", Qt::Horizontal, spliPos );
+    if ( dockPos == KDockWidget::DockLeft || dockPos == KDockWidget::DockRight  ) panner = new KDockSplitter( newDock, "_dock_split_", Qt::Vertical , spliPos );
+    newDock->setWidget( panner );
+
+    panner->setOpaqueResize(manager->splitterOpaqueResize());
+    panner->setKeepSize(manager->splitterKeepSize());
+    panner->setFocusPolicy( TQ_NoFocus );
+    target->applyToWidget( panner );
+    applyToWidget( panner );
+    target->formerDockPos = target->currentDockPos;
+    if ( dockPos == KDockWidget::DockRight) {
+      panner->activate( target, this );
+      currentDockPos = KDockWidget::DockRight;
+      target->currentDockPos = KDockWidget::DockLeft;
+    }
+    else if( dockPos == KDockWidget::DockBottom) {
+      panner->activate( target, this );
+      currentDockPos = KDockWidget::DockBottom;
+      target->currentDockPos = KDockWidget::DockTop;
+    }
+    else if( dockPos == KDockWidget::DockTop) {
+      panner->activate( this, target );
+      currentDockPos = KDockWidget::DockTop;
+      target->currentDockPos = KDockWidget::DockBottom;
+    }
+    else if( dockPos == KDockWidget::DockLeft) {
+      panner->activate( this, target );
+      currentDockPos = KDockWidget::DockLeft;
+      target->currentDockPos = KDockWidget::DockRight;
+    }
+    target->show();
+    show();
+    panner->show();
+  }
+
+  if ( parentDock ){
+    if ( parentDock->inherits("KDockSplitter") ){
+      KDockSplitter* sp = (KDockSplitter*)parentDock;
+      sp->deactivate();
+      if ( sp->getFirst() == target )
+        sp->activate( newDock, 0L );
+      else
+        sp->activate( 0L, newDock );
+    }
+  }
+
+  newDock->show();
+  emit target->docking( this, dockPos );
+  emit manager->replaceDock( target, newDock );
+  emit manager->change();
+
+  return newDock;
+}
+
+KDockTabGroup* KDockWidget::parentDockTabGroup() const
+{
+  if ( !parent() ) return 0L;
+  TQWidget* candidate = parentWidget()->parentWidget();
+  if ( candidate && candidate->inherits("KDockTabGroup") ) return (KDockTabGroup*)candidate;
+  return 0L;
+}
+
+TQWidget *KDockWidget::parentDockContainer() const
+{
+  if (!parent()) return 0L;
+  TQWidget* candidate = parentWidget()->parentWidget();
+  if (candidate && tqt_dynamic_cast<KDockContainer*>(candidate)) return candidate;
+  return 0L;
+}
+
+
+void KDockWidget::setForcedFixedWidth(int w)
+{
+	d->forcedWidth=w;
+	setFixedWidth(w);
+	if (!parent()) return;
+	if (parent()->inherits("KDockSplitter"))
+		::tqqt_cast<KDockSplitter*>(parent())->setForcedFixedWidth(this,w);
+}
+
+void KDockWidget::setForcedFixedHeight(int h)
+{
+	d->forcedHeight=h;
+	setFixedHeight(h);
+	if (!parent()) return;
+	if (parent()->inherits("KDockSplitter"))
+		::tqqt_cast<KDockSplitter*>(parent())->setForcedFixedHeight(this,h);
+}
+
+int KDockWidget::forcedFixedWidth()
+{
+	return d->forcedWidth;
+}
+
+int KDockWidget::forcedFixedHeight()
+{
+	return d->forcedHeight;
+}
+
+void KDockWidget::restoreFromForcedFixedSize()
+{
+	d->forcedWidth=-1;
+	d->forcedHeight=-1;
+	setMinimumWidth(0);
+	setMaximumWidth(32000);
+	setMinimumHeight(0);
+	setMaximumHeight(32000);
+	if (!parent()) return;
+	if (parent()->inherits("KDockSplitter"))
+		::tqqt_cast<KDockSplitter*>(parent())->restoreFromForcedFixedSize(this);
+}
+
+void KDockWidget::toDesktop()
+{
+   TQPoint p = mapToGlobal( TQPoint( -30, -30 ) );
+   if( p.x( ) < 0 )
+      p.setX( 0 );
+   if( p.y( ) < 0 )
+      p.setY( 0 );
+   manualDock( 0, DockDesktop, 50, p );
+}
+
+KDockWidget::DockPosition KDockWidget::currentDockPosition() const
+{
+	return currentDockPos;
+}
+
+void KDockWidget::undock()
+{
+//  kdDebug(282)<<"KDockWidget::undock()"<<endl;
+
+  manager->d->dragRect = TQRect ();
+  manager->drawDragRectangle ();
+
+  TQWidget* parentW = parentWidget();
+  if ( !parentW ){
+    hide();
+    if (!d->blockHasUndockedSignal)
+      emit hasUndocked();
+    return;
+  }
+
+  formerDockPos = currentDockPos;
+  currentDockPos = KDockWidget::DockDesktop;
+
+  manager->blockSignals(true);
+  manager->undockProcess = true;
+
+  bool isV = parentW->isVisibleToTLW();
+
+  //UNDOCK HAS TO BE IMPLEMENTED CORRECTLY :)
+  KDockTabGroup* parentTab = parentDockTabGroup();
+  if ( parentTab ){
+    d->index = parentTab->indexOf( this); // memorize the page position in the tab widget
+    parentTab->removePage( this );
+/*
+    TQWidget *wantTransient=parentTab->transientTo();
+    target->setDockWindowTransient(wantTransient,wantTransient);
+ */
+    setFormerBrotherDockWidget((KDockWidget*)parentTab->page(0));
+    applyToWidget( 0L );
+    if ( parentTab->count() == 1 ){
+
+      // last subdock widget in the tab control
+      KDockWidget* lastTab = (KDockWidget*)parentTab->page(0);
+      parentTab->removePage( lastTab );
+/*      TQWidget *wantTransient=parentTab->transientTo();
+      target->setDockWindowTransient(wantTransient,wantTransient);*/
+
+      lastTab->applyToWidget( 0L );
+      lastTab->move( parentTab->mapToGlobal(parentTab->frameGeometry().topLeft()) );
+
+      // KDockTabGroup always have a parent that is a KDockWidget
+      KDockWidget* parentOfTab = (KDockWidget*)parentTab->parent();
+      delete parentTab; // KDockTabGroup
+
+      TQWidget* parentOfDockWidget = parentOfTab->parentWidget();
+      if ( !parentOfDockWidget ){
+          if ( isV ) lastTab->show();
+      } else {
+        if ( parentOfDockWidget->inherits("KDockSplitter") ){
+          KDockSplitter* split = (KDockSplitter*)parentOfDockWidget;
+          lastTab->applyToWidget( split );
+          split->deactivate();
+          if ( split->getFirst() == parentOfTab ){
+            split->activate( lastTab );
+            if ( ((KDockWidget*)split->parent())->splitterOrientation == Qt::Vertical )
+              emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockLeft );
+            else
+              emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockTop );
+          } else {
+            split->activate( 0L, lastTab );
+            if ( ((KDockWidget*)split->parent())->splitterOrientation == Qt::Vertical )
+              emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockRight );
+            else
+              emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockBottom );
+          }
+          split->show();
+        } else {
+          lastTab->applyToWidget( parentOfDockWidget );
+        }
+        lastTab->show();
+      }
+      manager->blockSignals(false);
+      emit manager->replaceDock( parentOfTab, lastTab );
+      lastTab->currentDockPos = parentOfTab->currentDockPos;
+      emit parentOfTab->iMBeingClosed();
+      manager->blockSignals(true);
+      delete parentOfTab;
+
+    } else {
+      setDockTabName( parentTab );
+    }
+  } else {
+ /*********************************************************************************************/
+  //TQWidget* containerWidget = (TQWidget*)parent();
+  bool undockedFromContainer=false;
+  if (d->container)
+  {
+//	  kdDebug(282)<<"undocked from dockcontainer"<<endl;
+	  undockedFromContainer=true;
+	  KDockContainer* dc = tqt_dynamic_cast<KDockContainer*>(d->container.operator->());
+	  if (dc) {
+		  dc->undockWidget(this);
+		  setFormerBrotherDockWidget(dc->parentDockWidget());
+	  }
+	  applyToWidget( 0L );
+  }
+   if (!undockedFromContainer) {
+/*********************************************************************************************/
+    if ( parentW->inherits("KDockSplitter") ){
+      KDockSplitter* parentSplitterOfDockWidget = (KDockSplitter*)parentW;
+      d->splitPosInPercent = parentSplitterOfDockWidget->separatorPosInPercent();
+
+      KDockWidget* secondWidget = (KDockWidget*)parentSplitterOfDockWidget->getAnother( this );
+      KDockWidget* group        = (KDockWidget*)parentSplitterOfDockWidget->parentWidget();
+      setFormerBrotherDockWidget(secondWidget);
+      applyToWidget( 0L );
+      group->hide();
+
+      if ( !group->parentWidget() ){
+        secondWidget->applyToWidget( 0L, group->frameGeometry().topLeft() );
+        secondWidget->resize( group->width(), group->height() );
+      } else {
+        TQWidget* obj = group->parentWidget();
+        secondWidget->applyToWidget( obj );
+        if ( obj->inherits("KDockSplitter") ){
+          KDockSplitter* parentOfGroup = (KDockSplitter*)obj;
+          parentOfGroup->deactivate();
+
+          if ( parentOfGroup->getFirst() == group )
+            parentOfGroup->activate( secondWidget );
+          else
+            parentOfGroup->activate( 0L, secondWidget );
+        }
+      }
+      secondWidget->currentDockPos = group->currentDockPos;
+      secondWidget->formerDockPos  = group->formerDockPos;
+      delete parentSplitterOfDockWidget;
+      manager->blockSignals(false);
+      emit manager->replaceDock( group, secondWidget );
+      emit group->iMBeingClosed();
+      manager->blockSignals(true);
+      delete group;
+
+      if ( isV ) secondWidget->show();
+    } else {
+      if (!d->pendingDtor) {
+        // don't reparent in the dtor of this
+        applyToWidget( 0L );
+      }
+    }
+/*********************************************************************************************/
+  }
+  }
+  manager->blockSignals(false);
+  if (!d->blockHasUndockedSignal)
+    emit manager->change();
+  manager->undockProcess = false;
+
+  if (!d->blockHasUndockedSignal)
+    emit hasUndocked();
+}
+
+void KDockWidget::setWidget( TQWidget* mw )
+{
+  if ( !mw ) return;
+
+  if ( TQT_BASE_OBJECT(mw->parent()) != TQT_BASE_OBJECT(this) ){
+    mw->reparent(this, 0, TQPoint(0,0), false);
+  }
+
+#ifdef BORDERLESS_WINDOWS
+  if (!mw->ownCursor()) mw->setCursor(TQCursor(ArrowCursor));
+#endif
+  widget = mw;
+  delete layout;
+
+  layout = new TQVBoxLayout( this );
+  layout->setResizeMode( TQLayout::Minimum );
+
+  KDockContainer* dc = tqt_dynamic_cast<KDockContainer*>(widget);
+  if (dc)
+  {
+    d->isContainer=true;
+    manager->d->containerDocks.append(TQT_TQOBJECT(this));
+  }
+  else
+  {
+  	d->isContainer=false;
+  }
+
+  {
+     header->show();
+     layout->addWidget( header );
+     layout->addWidget( widget,1 );
+  }
+  updateHeader();
+  emit widgetSet(mw);
+}
+
+void KDockWidget::setDockTabName( KDockTabGroup* tab )
+{
+  TQString listOfName;
+  TQString listOfCaption;
+  for ( int i = 0; i < tab->count(); ++i ) {
+    TQWidget *w = tab->page( i );
+    listOfCaption.append( w->caption() ).append(",");
+    listOfName.append( w->name() ).append(",");
+  }
+  listOfCaption.remove( listOfCaption.length()-1, 1 );
+  listOfName.remove( listOfName.length()-1, 1 );
+
+  tab->parentWidget()->setName( listOfName.utf8() );
+  tab->parentWidget()->setCaption( listOfCaption );
+
+  tab->parentWidget()->tqrepaint( false ); // KDockWidget->tqrepaint
+  if ( tab->parentWidget()->parent() )
+    if ( tab->parentWidget()->parent()->inherits("KDockSplitter") )
+      ((KDockSplitter*)(tab->parentWidget()->parent()))->updateName();
+}
+
+bool KDockWidget::mayBeHide() const
+{
+  bool f = (TQT_BASE_OBJECT(parent()) != TQT_BASE_OBJECT(manager->main));
+  return ( !isGroup && !isTabGroup && f && isVisible() && ( eDocking != (int)KDockWidget::DockNone ) );
+}
+
+bool KDockWidget::mayBeShow() const
+{
+  bool f = (TQT_BASE_OBJECT(parent()) != TQT_BASE_OBJECT(manager->main));
+  return ( !isGroup && !isTabGroup && f && !isVisible() );
+}
+
+void KDockWidget::changeHideShowState()
+{
+  if ( mayBeHide() ){
+    undock();
+    return;
+  }
+
+  if ( mayBeShow() ){
+    if ( manager->main->inherits("KDockMainWindow") ){
+      ((KDockMainWindow*)manager->main)->makeDockVisible(this);
+    } else {
+      makeDockVisible();
+    }
+  }
+}
+
+void KDockWidget::makeDockVisible()
+{
+  if ( parentDockTabGroup() ){
+    parentDockTabGroup()->showPage( this );
+  }
+  if (parentDockContainer()) {
+    TQWidget *contWid=parentDockContainer();
+    KDockContainer *x = tqt_dynamic_cast<KDockContainer*>(contWid);
+    if (x) {
+      x->showWidget(this);
+    }
+  }
+  if ( isVisible() ) return;
+
+  TQWidget* p = parentWidget();
+  while ( p ){
+    if ( !p->isVisible() )
+      p->show();
+    p = p->parentWidget();
+  }
+  if( !parent() ) // is undocked
+    dockBack();
+  show();
+}
+
+void KDockWidget::setFormerBrotherDockWidget(KDockWidget *dockWidget)
+{
+  formerBrotherDockWidget = dockWidget;
+  if( formerBrotherDockWidget )
+    TQObject::connect( formerBrotherDockWidget, TQT_SIGNAL(iMBeingClosed()),
+                      this, TQT_SLOT(loseFormerBrotherDockWidget()) );
+}
+
+void KDockWidget::loseFormerBrotherDockWidget()
+{
+  if( formerBrotherDockWidget )
+    TQObject::disconnect( formerBrotherDockWidget, TQT_SIGNAL(iMBeingClosed()),
+                         this, TQT_SLOT(loseFormerBrotherDockWidget()) );
+  formerBrotherDockWidget = 0L;
+  tqrepaint();
+}
+
+void KDockWidget::dockBack()
+{
+  if( formerBrotherDockWidget) {
+    // search all children if it tries to dock back to a child
+    bool found = false;
+    TQObjectList* cl = queryList("KDockWidget");
+    TQObjectListIt it( *cl );
+    TQObject * obj;
+    while ( !found && (obj=it.current()) != 0 ) {
+      ++it;
+      TQWidget* widg = (TQWidget*)obj;
+      if( widg == formerBrotherDockWidget)
+        found = true;
+    }
+    delete cl;
+
+    if( !found) {
+      // can dock back to the former brother dockwidget
+      manualDock( formerBrotherDockWidget, formerDockPos, d->splitPosInPercent, TQPoint(0,0), false, d->index);
+      formerBrotherDockWidget = 0L;
+      makeDockVisible();
+      return;
+    }
+  }
+
+  // else dockback to the dockmainwindow (default behavior)
+  manualDock( ((KDockMainWindow*)manager->main)->getMainDockWidget(), formerDockPos, d->splitPosInPercent, TQPoint(0,0), false, d->index);
+  formerBrotherDockWidget = 0L;
+  if (parent())
+    makeDockVisible();
+}
+
+bool KDockWidget::isDockBackPossible() const
+{
+  if( !(formerBrotherDockWidget) || !(formerBrotherDockWidget->dockSite() & formerDockPos))
+    return false;
+  else
+    return true;
+}
+
+/**************************************************************************************/
+
+
+KDockManager::KDockManager( TQWidget* mainWindow , const char* name )
+:TQObject( mainWindow, name )
+  ,main(mainWindow)
+  ,currentDragWidget(0L)
+  ,currentMoveWidget(0L)
+  ,childDockWidgetList(0L)
+  ,autoCreateDock(0L)
+  ,storeW(0)
+  ,storeH(0)
+  ,dragging(false)
+  ,undockProcess(false)
+  ,dropCancel(true)
+{
+  d = new KDockManagerPrivate;
+
+  d->readyToDrag = false;
+  d->mainDockWidget=0;
+
+#ifndef NO_KDE2
+  d->splitterOpaqueResize = KGlobalSettings::opaqueResize();
+#else
+  d->splitterOpaqueResize = false;
+#endif
+
+  d->splitterKeepSize = false;
+  d->splitterHighResolution = false;
+  d->m_readDockConfigMode = WrapExistingWidgetsOnly; // default as before
+
+  main->installEventFilter( this );
+
+  undockProcess = false;
+
+  menuData = new TQPtrList<MenuDockData>;
+  menuData->setAutoDelete( true );
+  menuData->setAutoDelete( true );
+
+#ifndef NO_KDE2
+  menu = new KPopupMenu();
+#else
+  menu = new TQPopupMenu();
+#endif
+
+  connect( menu, TQT_SIGNAL(aboutToShow()), TQT_SLOT(slotMenuPopup()) );
+  connect( menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotMenuActivated(int)) );
+
+  childDock = new TQObjectList();
+  childDock->setAutoDelete( false );
+}
+
+
+void KDockManager::setMainDockWidget2(KDockWidget *w)
+{
+  d->mainDockWidget=w;
+}
+
+KDockManager::~KDockManager()
+{
+  delete menuData;
+  delete menu;
+
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+
+  while ( (obj=(KDockWidget*)it.current()) ) {
+    delete obj;
+  }
+  delete childDock;
+  delete d;
+  d=0;
+}
+
+void KDockManager::activate()
+{
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+
+  while ( (obj=(KDockWidget*)it.current()) ) {
+    ++it;
+    if ( obj->widget ) obj->widget->show();
+    if ( !obj->parentDockTabGroup() ){
+        obj->show();
+    }
+  }
+  if ( !main->inherits(TQDIALOG_OBJECT_NAME_STRING) ) main->show();
+}
+
+bool KDockManager::eventFilter( TQObject *obj, TQEvent *event )
+{
+
+  if ( obj->inherits("KDockWidgetAbstractHeaderDrag") ){
+    KDockWidget* pDockWdgAtCursor = 0L;
+    KDockWidget* curdw = ((KDockWidgetAbstractHeaderDrag*)obj)->dockWidget();
+    switch ( event->type() ){
+      case TQEvent::MouseButtonDblClick:
+        if (curdw->currentDockPos == KDockWidget::DockDesktop)  curdw->dockBack();
+        else
+	{
+		curdw->toDesktop();
+		// curdw->manualDock (0, KDockWidget::DockDesktop);
+	}
+        break;
+
+      case TQEvent::MouseButtonPress:
+        if ( ((TQMouseEvent*)event)->button() == Qt::LeftButton ){
+          if ( curdw->eDocking != (int)KDockWidget::DockNone ){
+            dropCancel = true;
+            curdw->setFocus();
+            tqApp->processOneEvent();
+
+            currentDragWidget = curdw;
+            currentMoveWidget = 0L;
+            childDockWidgetList = new TQWidgetList();
+            childDockWidgetList->append( curdw );
+            findChildDockWidget( curdw, childDockWidgetList );
+
+            //d->oldDragRect = TQRect(); should fix rectangle not erased problem
+            d->dragRect = TQRect(curdw->geometry());
+            TQPoint p = curdw->mapToGlobal(TQPoint(0,0));
+            d->dragRect.moveTopLeft(p);
+            drawDragRectangle();
+            d->readyToDrag = true;
+
+            d->dragOffset = TQCursor::pos()-currentDragWidget->mapToGlobal(TQPoint(0,0));
+          }
+
+        }
+        break;
+      case TQEvent::MouseButtonRelease:
+        if ( ((TQMouseEvent*)event)->button() == Qt::LeftButton ){
+          if ( dragging ){
+            if ( !dropCancel )
+              drop();
+            else
+              cancelDrop();
+          }
+          if (d->readyToDrag) {
+              d->readyToDrag = false;
+              //d->oldDragRect = TQRect(); should fix rectangle not erased problem
+              d->dragRect = TQRect(curdw->geometry());
+              TQPoint p = curdw->mapToGlobal(TQPoint(0,0));
+              d->dragRect.moveTopLeft(p);
+              drawDragRectangle();
+              currentDragWidget = 0L;
+              delete childDockWidgetList;
+              childDockWidgetList = 0L;
+          }
+          dragging = false;
+          dropCancel = true;
+        }
+        break;
+      case TQEvent::MouseMove:
+        if ( dragging ) {
+
+#ifdef BORDERLESS_WINDOWS
+//BEGIN TEST
+	  KDockWidget *oldMoveWidget;
+	  if (!curdw->parent())
+	  {
+	  	curdw->move(TQCursor::pos()-d->dragOffset);
+   	        pDockWdgAtCursor = findDockWidgetAt( TQCursor::pos()-TQPoint(0,d->dragOffset.y()+3) );
+                oldMoveWidget = currentMoveWidget;
+	  }
+	  else
+	  {
+	        pDockWdgAtCursor = findDockWidgetAt( TQCursor::pos() );
+                oldMoveWidget = currentMoveWidget;
+	  }
+//END TEST
+#else
+	  pDockWdgAtCursor = findDockWidgetAt( TQCursor::pos() );
+          KDockWidget* oldMoveWidget = currentMoveWidget;
+#endif
+
+	  if ( currentMoveWidget  && pDockWdgAtCursor == currentMoveWidget ) { //move
+            dragMove( currentMoveWidget, currentMoveWidget->mapFromGlobal( TQCursor::pos() ) );
+            break;
+          } else {
+            if (dropCancel && curdw) {
+              d->dragRect = TQRect(curdw->geometry());
+              TQPoint p = curdw->mapToGlobal(TQPoint(0,0));
+              d->dragRect.moveTopLeft(p);
+            }else
+              d->dragRect = TQRect();
+
+            drawDragRectangle();
+          }
+
+          if ( !pDockWdgAtCursor && !(curdw->eDocking & (int)KDockWidget::DockDesktop) ){
+              // just moving at the desktop
+              currentMoveWidget = pDockWdgAtCursor;
+              curPos = KDockWidget::DockDesktop;
+          } else {
+            if ( oldMoveWidget && pDockWdgAtCursor != currentMoveWidget ) { //leave
+              currentMoveWidget = pDockWdgAtCursor;
+              curPos = KDockWidget::DockDesktop;
+            }
+          }
+
+          if ( oldMoveWidget != pDockWdgAtCursor && pDockWdgAtCursor ) { //enter pDockWdgAtCursor
+            currentMoveWidget = pDockWdgAtCursor;
+            curPos = KDockWidget::DockDesktop;
+          }
+        } else {
+          if (d->readyToDrag) {
+            d->readyToDrag = false;
+          }
+          if ( (((TQMouseEvent*)event)->state() == Qt::LeftButton) &&
+               (curdw->eDocking != (int)KDockWidget::DockNone) ) {
+            startDrag( curdw);
+          }
+        }
+	break;
+      default:
+        break;
+    }
+  }
+  return TQObject::eventFilter( obj, event );
+}
+
+KDockWidget* KDockManager::findDockWidgetAt( const TQPoint& pos )
+{
+  dropCancel = true;
+
+  if (!currentDragWidget)
+    return 0L; // pointer access safety
+
+  if (currentDragWidget->eDocking == (int)KDockWidget::DockNone ) return 0L;
+
+  TQWidget* p = TQApplication::widgetAt( pos );
+  if ( !p ) {
+    dropCancel = false;
+    return 0L;
+  }
+#if defined(_OS_WIN32_) || defined(Q_OS_WIN32)
+  p = p->tqtopLevelWidget();
+#endif
+  TQWidget* w = 0L;
+  findChildDockWidget( w, p, p->mapFromGlobal(pos) );
+  if ( !w ){
+    if ( !p->inherits("KDockWidget") ) {
+      return 0L;
+    }
+    w = p;
+  }
+  if ( qt_find_obj_child( TQT_TQOBJECT(w), "KDockSplitter", "_dock_split_" ) ) return 0L;
+  if ( qt_find_obj_child( TQT_TQOBJECT(w), "KDockTabGroup", "_dock_tab" ) ) return 0L;
+  if (tqt_dynamic_cast<KDockContainer*>(w)) return 0L;
+
+  if (!childDockWidgetList) return 0L;
+  if ( childDockWidgetList->find(w) != -1 ) return 0L;
+  if ( currentDragWidget->isGroup && ((KDockWidget*)w)->parentDockTabGroup() ) return 0L;
+
+  KDockWidget* www = (KDockWidget*)w;
+  if ( www->sDocking == (int)KDockWidget::DockNone ) return 0L;
+  if( !www->widget )
+    return 0L;
+
+  KDockWidget::DockPosition curPos = KDockWidget::DockDesktop;
+  TQPoint cpos  = www->mapFromGlobal( pos );
+
+  int ww = www->widget->width() / 3;
+  int hh = www->widget->height() / 3;
+
+  if ( cpos.y() <= hh ){
+    curPos = KDockWidget::DockTop;
+  } else
+    if ( cpos.y() >= 2*hh ){
+      curPos = KDockWidget::DockBottom;
+    } else
+      if ( cpos.x() <= ww ){
+        curPos = KDockWidget::DockLeft;
+      } else
+        if ( cpos.x() >= 2*ww ){
+          curPos = KDockWidget::DockRight;
+        } else
+            curPos = KDockWidget::DockCenter;
+
+  if ( !(www->sDocking & (int)curPos) ) return 0L;
+  if ( !(currentDragWidget->eDocking & (int)curPos) ) return 0L;
+  if ( www->manager != this ) return 0L;
+
+  dropCancel = false;
+  return www;
+}
+
+void KDockManager::findChildDockWidget( TQWidget*& ww, const TQWidget* p, const TQPoint& pos )
+{
+  if ( !p->childrenListObject().isEmpty() ) {
+    TQWidget *w;
+    TQObjectListIt it( p->childrenListObject() );
+    it.toLast();
+    while ( it.current() ) {
+      if ( it.current()->isWidgetType() ) {
+        w = (TQWidget*)it.current();
+        if ( w->isVisible() && w->tqgeometry().contains(pos) ) {
+          if ( w->inherits("KDockWidget") ) ww = w;
+          findChildDockWidget( ww, w, w->mapFromParent(pos) );
+          return;
+        }
+      }
+      --it;
+    }
+  }
+  return;
+}
+
+void KDockManager::findChildDockWidget( const TQWidget* p, TQWidgetList*& list )
+{
+  if ( !p->childrenListObject().isEmpty() ) {
+    TQWidget *w;
+    TQObjectListIt it( p->childrenListObject() );
+    it.toLast();
+    while ( it.current() ) {
+      if ( it.current()->isWidgetType() ) {
+        w = (TQWidget*)it.current();
+        if ( w->isVisible() ) {
+          if ( w->inherits("KDockWidget") ) list->append( w );
+          findChildDockWidget( w, list );
+        }
+      }
+      --it;
+    }
+  }
+  return;
+}
+
+void KDockManager::startDrag( KDockWidget* w )
+{
+  if(( w->currentDockPos == KDockWidget::DockLeft) || ( w->currentDockPos == KDockWidget::DockRight)
+   || ( w->currentDockPos == KDockWidget::DockTop) || ( w->currentDockPos == KDockWidget::DockBottom)) {
+    w->prevSideDockPosBeforeDrag = w->currentDockPos;
+
+    if ( w->parentWidget()->inherits("KDockSplitter") ){
+      KDockSplitter* parentSplitterOfDockWidget = (KDockSplitter*)(w->parentWidget());
+      w->d->splitPosInPercent = parentSplitterOfDockWidget->separatorPosInPercent();
+    }
+  }
+
+  curPos = KDockWidget::DockDesktop;
+  dragging = true;
+
+  TQApplication::setOverrideCursor(TQCursor(tqsizeAllCursor));
+}
+
+void KDockManager::dragMove( KDockWidget* dw, TQPoint pos )
+{
+  TQPoint p = dw->mapToGlobal( dw->widget->pos() );
+  KDockWidget::DockPosition oldPos = curPos;
+
+  TQSize r = dw->widget->size();
+  if ( dw->parentDockTabGroup() ){
+    curPos = KDockWidget::DockCenter;
+    if ( oldPos != curPos ) {
+      d->dragRect.setRect( p.x()+2, p.y()+2, r.width()-4, r.height()-4 );
+    }
+    return;
+  }
+
+  int w = r.width() / 3;
+  int h = r.height() / 3;
+
+  if ( pos.y() <= h ){
+    curPos = KDockWidget::DockTop;
+    w = r.width();
+  } else
+    if ( pos.y() >= 2*h ){
+      curPos = KDockWidget::DockBottom;
+      p.setY( p.y() + 2*h );
+      w = r.width();
+    } else
+      if ( pos.x() <= w ){
+        curPos = KDockWidget::DockLeft;
+        h = r.height();
+      } else
+        if ( pos.x() >= 2*w ){
+          curPos = KDockWidget::DockRight;
+          p.setX( p.x() + 2*w );
+          h = r.height();
+        } else
+          {
+            curPos = KDockWidget::DockCenter;
+            p.setX( p.x() + w );
+            p.setY( p.y() + h );
+          }
+
+  if ( oldPos != curPos ) {
+    d->dragRect.setRect( p.x(), p.y(), w, h );
+    drawDragRectangle();
+  }
+}
+
+
+void KDockManager::cancelDrop()
+{
+  TQApplication::restoreOverrideCursor();
+
+  delete childDockWidgetList;
+  childDockWidgetList = 0L;
+
+  d->dragRect = TQRect();  // cancel drawing
+  drawDragRectangle();    // only the old rect will be deleted
+}
+
+
+void KDockManager::drop()
+{
+  d->dragRect = TQRect();  // cancel drawing
+  drawDragRectangle();    // only the old rect will be deleted
+
+  TQApplication::restoreOverrideCursor();
+
+  delete childDockWidgetList;
+  childDockWidgetList = 0L;
+
+  if ( dropCancel ) return;
+  if ( !currentMoveWidget && (!(currentDragWidget->eDocking & (int)KDockWidget::DockDesktop)) ) {
+    d->dragRect = TQRect();  // cancel drawing
+    drawDragRectangle();    // only the old rect will be deleted
+    return;
+  }
+  if ( !currentMoveWidget && !currentDragWidget->parent() ) {
+    currentDragWidget->move( TQCursor::pos() - d->dragOffset );
+  }
+  else {
+    // curPos is the current target DockPosition.
+    // currentDragWidget->prevSideDockPosBeforeDrag is where the dockwidget comes from.
+    // currentDragWidget->formerDockPos is the position *before* the dockwidget was in
+    // position currentDragWidget->prevSideDockPosBeforeDrag.
+    int splitPos = currentDragWidget->d->splitPosInPercent;
+    KDockWidget::DockPosition previousPosition = currentDragWidget->prevSideDockPosBeforeDrag;
+
+//    kdDebug() << splitPos << endl;
+//    kdDebug() << "curPos: " << curPos << endl;
+//    kdDebug() << "formerDockPos: " << currentDragWidget->formerDockPos<< endl;
+//    kdDebug() << "prevSideDockPosBeforeDrag: " << currentDragWidget->prevSideDockPosBeforeDrag<< endl;
+
+    // Now we *need* to "invert" the procentual value, if the dockwidget moves from top/left
+    // to bottom/right or vice versa. This keeps the dockwidget's size on its new position.
+    // A special case is, when the dock position was DockNone, then we have to look for the
+    // formerDockPos to get things right.
+    if( (curPos != previousPosition)
+       && (curPos != KDockWidget::DockCenter) && (curPos != KDockWidget::DockDesktop)) {
+
+      if (previousPosition == KDockWidget::DockNone)
+        previousPosition = currentDragWidget->formerDockPos;
+
+      switch( previousPosition ) {
+      case KDockWidget::DockLeft:
+        if(curPos != KDockWidget::DockTop && curPos != KDockWidget::DockLeft)
+          splitPos = 100 - splitPos;
+        break;
+
+      case KDockWidget::DockRight:
+        if(curPos != KDockWidget::DockBottom && curPos != KDockWidget::DockRight)
+          splitPos = 100 - splitPos;
+        break;
+
+      case KDockWidget::DockTop:
+        if(curPos != KDockWidget::DockLeft && curPos != KDockWidget::DockTop )
+          splitPos = 100 - splitPos;
+        break;
+
+      case KDockWidget::DockBottom:
+        if(curPos != KDockWidget::DockRight && curPos != KDockWidget::DockBottom )
+          splitPos = 100 - splitPos;
+        break;
+
+      default: break;
+      }
+    }
+    // set new prevSideDockPosBeforeDrag
+    currentDragWidget->prevSideDockPosBeforeDrag = curPos;
+    currentDragWidget->manualDock( currentMoveWidget, curPos , splitPos, TQCursor::pos() - d->dragOffset );
+    currentDragWidget->makeDockVisible();
+  }
+}
+
+
+static TQDomElement createStringEntry(TQDomDocument &doc, const TQString &tagName, const TQString &str)
+{
+    TQDomElement el = doc.createElement(tagName);
+
+    el.appendChild(doc.createTextNode(str));
+    return el;
+}
+
+
+static TQDomElement createBoolEntry(TQDomDocument &doc, const TQString &tagName, bool b)
+{
+    return createStringEntry(doc, tagName, TQString::tqfromLatin1(b? "true" : "false"));
+}
+
+
+static TQDomElement createNumberEntry(TQDomDocument &doc, const TQString &tagName, int n)
+{
+    return createStringEntry(doc, tagName, TQString::number(n));
+}
+
+
+static TQDomElement createRectEntry(TQDomDocument &doc, const TQString &tagName, const TQRect &rect)
+{
+    TQDomElement el = doc.createElement(tagName);
+
+    TQDomElement xel = doc.createElement("x");
+    xel.appendChild(doc.createTextNode(TQString::number(rect.x())));
+    el.appendChild(xel);
+    TQDomElement yel = doc.createElement("y");
+    yel.appendChild(doc.createTextNode(TQString::number(rect.y())));
+    el.appendChild(yel);
+    TQDomElement wel = doc.createElement("width");
+    wel.appendChild(doc.createTextNode(TQString::number(rect.width())));
+    el.appendChild(wel);
+    TQDomElement hel = doc.createElement("height");
+    hel.appendChild(doc.createTextNode(TQString::number(rect.height())));
+    el.appendChild(hel);
+
+    return el;
+}
+
+
+static TQDomElement createListEntry(TQDomDocument &doc, const TQString &tagName,
+                                   const TQString &subTagName, const TQStrList &list)
+{
+    TQDomElement el = doc.createElement(tagName);
+
+    TQStrListIterator it(list);
+    for (; it.current(); ++it) {
+        TQDomElement subel = doc.createElement(subTagName);
+        subel.appendChild(doc.createTextNode(TQString::tqfromLatin1(it.current())));
+        el.appendChild(subel);
+    }
+
+    return el;
+}
+
+
+static TQString stringEntry(TQDomElement &base, const TQString &tagName)
+{
+    return base.namedItem(tagName).firstChild().toText().data();
+}
+
+
+static bool boolEntry(TQDomElement &base, const TQString &tagName)
+{
+    return base.namedItem(tagName).firstChild().toText().data() == "true";
+}
+
+
+static int numberEntry(TQDomElement &base, const TQString &tagName)
+{
+    return stringEntry(base, tagName).toInt();
+}
+
+
+static TQRect rectEntry(TQDomElement &base, const TQString &tagName)
+{
+    TQDomElement el = base.namedItem(tagName).toElement();
+
+    int x = numberEntry(el, "x");
+    int y = numberEntry(el, "y");
+    int width = numberEntry(el, "width");
+    int height = numberEntry(el,  "height");
+
+    return TQRect(x, y, width, height);
+}
+
+
+static TQStrList listEntry(TQDomElement &base, const TQString &tagName, const TQString &subTagName)
+{
+    TQStrList list;
+
+    for( TQDomNode n = base.namedItem(tagName).firstChild(); !n.isNull(); n = n.nextSibling() )
+    {
+        TQDomElement subel = n.toElement();
+        if (subel.tagName() == subTagName)
+            list.append(subel.firstChild().toText().data().latin1());
+    }
+
+    return list;
+}
+
+
+void KDockManager::writeConfig(TQDomElement &base)
+{
+    // First of all, clear the tree under base
+    while (!base.firstChild().isNull())
+        base.removeChild(base.firstChild());
+    TQDomDocument doc = base.ownerDocument();
+
+    TQStrList nameList;
+    TQString mainWidgetStr;
+
+    // collect widget names
+    TQStringList nList;
+    TQObjectListIt it(*childDock);
+    KDockWidget *obj1;
+    while ( (obj1=(KDockWidget*)it.current()) ) {
+        if ( TQT_BASE_OBJECT(obj1->parent()) == TQT_BASE_OBJECT(main) )
+            mainWidgetStr = TQString::tqfromLatin1(obj1->name());
+        nList.append(obj1->name());
+        ++it;
+    }
+
+    for (TQObjectListIt it(d->containerDocks);it.current();++it)
+    {
+        KDockContainer* dc = tqt_dynamic_cast<KDockContainer*>(((KDockWidget*)it.current())->widget);
+        if (dc) {
+                dc->prepareSave(nList);
+        }
+    }
+
+    TQStringList::Iterator nListIt=nList.begin();
+    while ( nListIt!=nList.end() ) {
+        KDockWidget *obj = getDockWidgetFromName( *nListIt);
+        if ((obj->isGroup && (!obj->d->isContainer)) && (nameList.find( obj->firstName.latin1() ) == -1
+                             || nameList.find(obj->lastName.latin1()) == -1)) {
+            // Skip until children are saved (why?)
+            ++nListIt;
+//            nList.next();
+//falk?            if ( !nList.current() ) nList.first();
+            continue;
+        }
+
+        TQDomElement groupEl;
+	if (obj->d->isContainer) {
+      		KDockContainer* x = tqt_dynamic_cast<KDockContainer*>(obj->widget);
+       		if (x) {
+			groupEl=doc.createElement("dockContainer");
+          		x->save(groupEl);
+       		}
+    	} else
+        if (obj->isGroup) {
+            //// Save a group
+            groupEl = doc.createElement("splitGroup");
+
+            groupEl.appendChild(createStringEntry(doc, "firstName", obj->firstName));
+            groupEl.appendChild(createStringEntry(doc, "secondName", obj->lastName));
+            groupEl.appendChild(createNumberEntry(doc, "orientation", (int)obj->splitterOrientation));
+            groupEl.appendChild(createNumberEntry(doc, "separatorPos", ((KDockSplitter*)obj->widget)->separatorPosInPercent()));
+        } else if (obj->isTabGroup) {
+            //// Save a tab group
+            groupEl = doc.createElement("tabGroup");
+
+            TQStrList list;
+            for ( int i = 0; i < ((KDockTabGroup*)obj->widget)->count(); ++i )
+                list.append( ((KDockTabGroup*)obj->widget)->page( i )->name() );
+            groupEl.appendChild(createListEntry(doc, "tabs", "tab", list));
+            groupEl.appendChild(createNumberEntry(doc, "currentTab", ((KDockTabGroup*)obj->widget)->currentPageIndex()));
+            if (!obj->parent()) {
+                groupEl.appendChild(createStringEntry(doc, "dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : ""));
+                groupEl.appendChild(createNumberEntry(doc, "dockBackToPos", obj->formerDockPos));
+            }
+        } else {
+            //// Save an ordinary dock widget
+            groupEl = doc.createElement("dock");
+            groupEl.appendChild(createStringEntry(doc, "tabCaption", obj->tabPageLabel()));
+            groupEl.appendChild(createStringEntry(doc, "tabToolTip", obj->toolTipString()));
+            if (!obj->parent()) {
+                groupEl.appendChild(createStringEntry(doc, "dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : ""));
+                groupEl.appendChild(createNumberEntry(doc, "dockBackToPos", obj->formerDockPos));
+            }
+        }
+
+        groupEl.appendChild(createStringEntry(doc, "name", TQString::tqfromLatin1(obj->name())));
+        groupEl.appendChild(createBoolEntry(doc, "hasParent", obj->parent()));
+        if ( !obj->parent() ) {
+            groupEl.appendChild(createRectEntry(doc, "geometry", TQRect(main->frameGeometry().topLeft(), main->size())));
+            groupEl.appendChild(createBoolEntry(doc, "visible", obj->isVisible()));
+        }
+        if (obj->header && obj->header->inherits("KDockWidgetHeader")) {
+            KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
+            groupEl.appendChild(createBoolEntry(doc, "dragEnabled", h->dragEnabled()));
+        }
+
+        base.appendChild(groupEl);
+        nameList.append(obj->name());
+        nList.remove(nListIt);
+        nListIt=nList.begin();
+    }
+
+    if (main->inherits("KDockMainWindow")) {
+        KDockMainWindow *dmain = (KDockMainWindow*)main;
+        TQString centralWidgetStr = TQString(dmain->centralWidget()? dmain->centralWidget()->name() : "");
+        base.appendChild(createStringEntry(doc, "centralWidget", centralWidgetStr));
+        TQString mainDockWidgetStr = TQString(dmain->getMainDockWidget()? dmain->getMainDockWidget()->name() : "");
+        base.appendChild(createStringEntry(doc, "mainDockWidget", mainDockWidgetStr));
+    } else {
+        base.appendChild(createStringEntry(doc, "mainWidget", mainWidgetStr));
+    }
+
+    base.appendChild(createRectEntry(doc, "geometry", TQRect(main->frameGeometry().topLeft(), main->size())));
+}
+
+
+void KDockManager::readConfig(TQDomElement &base)
+{
+    if (base.namedItem("group").isNull()
+        && base.namedItem("tabgroup").isNull()
+        && base.namedItem("dock").isNull()
+	&& base.namedItem("dockContainer").isNull()) {
+        activate();
+        return;
+    }
+
+    autoCreateDock = new TQObjectList();
+    autoCreateDock->setAutoDelete( true );
+
+    bool isMainVisible = main->isVisible();
+    main->hide();
+
+    TQObjectListIt it(*childDock);
+    KDockWidget *obj1;
+    while ( (obj1=(KDockWidget*)it.current()) ) {
+        if ( !obj1->isGroup && !obj1->isTabGroup ) {
+            if ( obj1->parent() )
+                obj1->undock();
+            else
+                obj1->hide();
+        }
+        ++it;
+    }
+
+    // firstly, recreate all common dockwidgets
+    for( TQDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
+    {
+        TQDomElement childEl = n.toElement();
+        if (childEl.tagName() != "dock") continue;
+
+        // Read an ordinary dock widget
+        KDockWidget *obj = getDockWidgetFromName(stringEntry(childEl, "name"));
+        obj->setTabPageLabel(stringEntry(childEl, "tabCaption"));
+        obj->setToolTipString(stringEntry(childEl, "tabToolTip"));
+
+        if (!boolEntry(childEl, "hasParent")) {
+            TQRect r = rectEntry(childEl, "geometry");
+            obj = getDockWidgetFromName(stringEntry(childEl, "name"));
+            obj->applyToWidget(0);
+            obj->setGeometry(r);
+            if (boolEntry(childEl, "visible"))
+                obj->TQWidget::show();
+        }
+
+        if (obj && obj->header && obj->header->inherits("KDockWidgetHeader")) {
+            KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
+            h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
+        }
+    }
+
+    // secondly, now iterate again and create the groups and tabwidgets, apply the dockwidgets to them
+    for( TQDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
+    {
+        TQDomElement childEl = n.toElement();
+        if (childEl.isNull()) continue;
+
+        KDockWidget *obj = 0;
+
+	if (childEl.tagName() == "dockContainer") {
+
+		KDockWidget *cont=getDockWidgetFromName(stringEntry(childEl, "name"));
+		kdDebug(282)<<"dockContainer: "<<stringEntry(childEl,"name")<<endl;
+		if (!(cont->d->isContainer)) {
+			kdDebug(282)<<"restoration of dockContainer is only supported for already existing dock containers"<<endl;
+		} else {
+			KDockContainer *dc=tqt_dynamic_cast<KDockContainer*>(cont->getWidget());
+			if (!dc) kdDebug(282)<<"Error while trying to handle dockcontainer configuration restoration"<<endl;
+				else {
+					dc->load(childEl);
+					removeFromAutoCreateList(cont);
+				}
+
+		}
+	}
+	else
+        if (childEl.tagName() == "splitGroup") {
+            // Read a group
+            TQString name = stringEntry(childEl, "name");
+            TQString firstName = stringEntry(childEl, "firstName");
+            TQString secondName = stringEntry(childEl, "secondName");
+            int orientation = numberEntry(childEl, "orientation");
+            int separatorPos = numberEntry(childEl, "separatorPos");
+
+            KDockWidget *first = getDockWidgetFromName(firstName);
+            KDockWidget *second = getDockWidgetFromName(secondName);
+            if (first && second) {
+                obj = first->manualDock(second,
+                                        (orientation == (int)Qt::Vertical)? KDockWidget::DockLeft : KDockWidget::DockTop,
+                                        separatorPos);
+                if (obj)
+                    obj->setName(name.latin1());
+            }
+        } else if (childEl.tagName() == "tabGroup") {
+            // Read a tab group
+            TQString name = stringEntry(childEl, "name");
+            TQStrList list = listEntry(childEl, "tabs", "tab");
+
+            KDockWidget *d1 = getDockWidgetFromName( list.first() );
+            list.next();
+            KDockWidget *d2 = getDockWidgetFromName( list.current() );
+
+            KDockWidget *obj = d2->manualDock( d1, KDockWidget::DockCenter );
+            if (obj) {
+                KDockTabGroup *tab = (KDockTabGroup*)obj->widget;
+                list.next();
+                while (list.current() && obj) {
+                    KDockWidget *tabDock = getDockWidgetFromName(list.current());
+                    obj = tabDock->manualDock(d1, KDockWidget::DockCenter);
+                    list.next();
+                }
+                if (obj) {
+                    obj->setName(name.latin1());
+                    tab->showPage(tab->page(numberEntry(childEl, "currentTab")));
+                }
+            }
+        } else {
+            continue;
+        }
+
+        if (!boolEntry(childEl, "hasParent")) {
+            TQRect r = rectEntry(childEl, "geometry");
+            obj = getDockWidgetFromName(stringEntry(childEl, "name"));
+            obj->applyToWidget(0);
+            obj->setGeometry(r);
+            if (boolEntry(childEl, "visible"))
+                obj->TQWidget::show();
+        }
+
+        if (obj && obj->header && obj->header->inherits("KDockWidgetHeader")) {
+            KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
+            h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
+        }
+    }
+
+    // thirdly, now that all ordinary dockwidgets are created,
+    // iterate them again and link them with their corresponding dockwidget for the dockback action
+    for( TQDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
+    {
+        TQDomElement childEl = n.toElement();
+
+        if (childEl.tagName() != "dock" && childEl.tagName() != "tabGroup")
+            continue;
+
+        KDockWidget *obj = 0;
+
+        if (!boolEntry(childEl, "hasParent")) {
+            // Read a common toplevel dock widget
+            obj = getDockWidgetFromName(stringEntry(childEl, "name"));
+            TQString name = stringEntry(childEl, "dockBackTo");
+            if (!name.isEmpty()) {
+                obj->setFormerBrotherDockWidget(getDockWidgetFromName(name));
+            }
+            obj->formerDockPos = KDockWidget::DockPosition(numberEntry(childEl, "dockBackToPos"));
+            obj->updateHeader();
+        }
+    }
+
+    if (main->inherits("KDockMainWindow")) {
+        KDockMainWindow *dmain = (KDockMainWindow*)main;
+
+        TQString mv = stringEntry(base, "centralWidget");
+        if (!mv.isEmpty() && getDockWidgetFromName(mv) ) {
+            KDockWidget *mvd  = getDockWidgetFromName(mv);
+            mvd->applyToWidget(dmain);
+            mvd->show();
+            dmain->setCentralWidget(mvd);
+        }
+        TQString md = stringEntry(base, "mainDockWidget");
+        if (!md.isEmpty() && getDockWidgetFromName(md)) {
+            KDockWidget *mvd  = getDockWidgetFromName(md);
+            dmain->setMainDockWidget(mvd);
+        }
+    } else {
+        TQString mv = stringEntry(base, "mainWidget");
+        if (!mv.isEmpty() && getDockWidgetFromName(mv)) {
+            KDockWidget *mvd  = getDockWidgetFromName(mv);
+            mvd->applyToWidget(main);
+            mvd->show();
+        }
+
+        // only resize + move non-mainwindows
+        TQRect mr = rectEntry(base, "geometry");
+        main->move(mr.topLeft());
+        main->resize(mr.size());
+    }
+
+    if (isMainVisible)
+        main->show();
+
+    if (d->m_readDockConfigMode == WrapExistingWidgetsOnly) {
+        finishReadDockConfig(); // remove empty dockwidgets
+    }
+}
+
+void KDockManager::removeFromAutoCreateList(KDockWidget* pDockWidget)
+{
+    if (!autoCreateDock) return;
+    autoCreateDock->setAutoDelete(false);
+    autoCreateDock->removeRef(TQT_TQOBJECT(pDockWidget));
+    autoCreateDock->setAutoDelete(true);
+}
+
+void KDockManager::finishReadDockConfig()
+{
+    delete autoCreateDock;
+    autoCreateDock = 0;
+}
+
+void KDockManager::setReadDockConfigMode(int mode)
+{
+    d->m_readDockConfigMode = mode;
+}
+
+#ifndef NO_KDE2
+void KDockManager::writeConfig( KConfig* c, TQString group )
+{
+  //debug("BEGIN Write Config");
+  if ( !c ) c = KGlobal::config();
+  if ( group.isEmpty() ) group = "dock_setting_default";
+
+  c->setGroup( group );
+  c->writeEntry( "Version", DOCK_CONFIG_VERSION );
+
+  TQStringList nameList;
+  TQStringList findList;
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+
+  // collect KDockWidget's name
+  TQStringList nList;
+  while ( (obj=(KDockWidget*)it.current()) ) {
+    ++it;
+    //debug("  +Add subdock %s", obj->name());
+    nList.append( obj->name() );
+    if ( TQT_BASE_OBJECT(obj->parent()) == TQT_BASE_OBJECT(main) )
+      c->writeEntry( "Main:view", obj->name() );
+  }
+
+//  kdDebug(282)<<TQString("list size: %1").arg(nList.count())<<endl;
+  for (TQObjectListIt it(d->containerDocks);it.current();++it)
+  {
+  	KDockContainer* dc = tqt_dynamic_cast<KDockContainer*>(((KDockWidget*)it.current())->widget);
+	if (dc) {
+		dc->prepareSave(nList);
+	}
+  }
+//  kdDebug(282)<<TQString("new list size: %1").arg(nList.count())<<endl;
+
+  TQStringList::Iterator nListIt=nList.begin();
+  while ( nListIt!=nList.end() ){
+    //debug("  -Try to save %s", nList.current());
+    obj = getDockWidgetFromName( *nListIt );
+    TQString cname = obj->name();
+    if ( obj->header ){
+      obj->header->saveConfig( c );
+    }
+    if (obj->d->isContainer) {
+       KDockContainer* x = tqt_dynamic_cast<KDockContainer*>(obj->widget);
+       if (x) {
+          x->save(c,group);
+       }
+    }
+/*************************************************************************************************/
+    if ( obj->isGroup ){
+      if ( (findList.find( obj->firstName ) != findList.end()) && (findList.find( obj->lastName ) != findList.end() )){
+
+        c->writeEntry( cname+":type", "GROUP");
+        if ( !obj->parent() ){
+          c->writeEntry( cname+":parent", "___null___");
+          c->writeEntry( cname+":geometry", TQRect(obj->frameGeometry().topLeft(), obj->size()) );
+          c->writeEntry( cname+":visible", obj->isVisible());
+        } else {
+          c->writeEntry( cname+":parent", "yes");
+        }
+        c->writeEntry( cname+":first_name", obj->firstName );
+        c->writeEntry( cname+":last_name", obj->lastName );
+        c->writeEntry( cname+":orientation", (int)obj->splitterOrientation );
+        c->writeEntry( cname+":sepPos", ((KDockSplitter*)obj->widget)->separatorPosInPercent() );
+
+        nameList.append( obj->name() );
+        findList.append( obj->name() );
+        //debug("  Save %s", nList.current());
+        nList.remove(nListIt);
+        nListIt=nList.begin(); //nList.first();
+      } else {
+/*************************************************************************************************/
+        //debug("  Skip %s", nList.current());
+        //if ( findList.find( obj->firstName ) == -1 )
+        //  debug("  ? Not found %s", obj->firstName);
+        //if ( findList.find( obj->lastName ) == -1 )
+        //  debug("  ? Not found %s", obj->lastName);
+        ++nListIt;
+        // if ( !nList.current() ) nList.first();
+	if (nListIt==nList.end()) nListIt=nList.begin();
+      }
+    } else {
+/*************************************************************************************************/
+      if ( obj->isTabGroup){
+        c->writeEntry( cname+":type", "TAB_GROUP");
+        if ( !obj->parent() ){
+          c->writeEntry( cname+":parent", "___null___");
+          c->writeEntry( cname+":geometry", TQRect(obj->frameGeometry().topLeft(), obj->size()) );
+          c->writeEntry( cname+":visible", obj->isVisible());
+          c->writeEntry( cname+":dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : "");
+          c->writeEntry( cname+":dockBackToPos", obj->formerDockPos);
+        } else {
+          c->writeEntry( cname+":parent", "yes");
+        }
+        TQStrList list;
+        for ( int i = 0; i < ((KDockTabGroup*)obj->widget)->count(); ++i )
+          list.append( ((KDockTabGroup*)obj->widget)->page( i )->name() );
+        c->writeEntry( cname+":tabNames", list );
+        c->writeEntry( cname+":curTab", ((KDockTabGroup*)obj->widget)->currentPageIndex() );
+
+        nameList.append( obj->name() );
+        findList.append( obj->name() ); // not really need !!!
+        //debug("  Save %s", nList.current());
+        nList.remove(nListIt);
+        nListIt=nList.begin();
+      } else {
+/*************************************************************************************************/
+        c->writeEntry( cname+":tabCaption", obj->tabPageLabel());
+        c->writeEntry( cname+":tabToolTip", obj->toolTipString());
+        if ( !obj->parent() ){
+          c->writeEntry( cname+":type", "NULL_DOCK");
+          c->writeEntry( cname+":geometry", TQRect(obj->frameGeometry().topLeft(), obj->size()) );
+          c->writeEntry( cname+":visible", obj->isVisible());
+          c->writeEntry( cname+":dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : "");
+          c->writeEntry( cname+":dockBackToPos", obj->formerDockPos);
+        } else {
+          c->writeEntry( cname+":type", "DOCK");
+        }
+        nameList.append( cname.latin1() );
+        //debug("  Save %s", nList.current());
+        findList.append( obj->name() );
+        nList.remove(nListIt);
+        nListIt=nList.begin();
+      }
+    }
+  }
+  c->writeEntry( "NameList", nameList );
+
+  c->writeEntry( "Main:Geometry", TQRect(main->frameGeometry().topLeft(), main->size()) );
+  c->writeEntry( "Main:visible", main->isVisible()); // curently nou use
+
+  if ( main->inherits("KDockMainWindow") ){
+    KDockMainWindow* dmain = (KDockMainWindow*)main;
+    // for KDockMainWindow->setView() in readConfig()
+    c->writeEntry( "Main:view", dmain->centralWidget() ? dmain->centralWidget()->name():"" );
+    c->writeEntry( "Main:dock", dmain->getMainDockWidget()     ? dmain->getMainDockWidget()->name()    :"" );
+  }
+
+  c->sync();
+  //debug("END Write Config");
+}
+#include <tqmessagebox.h>
+void KDockManager::readConfig( KConfig* c, TQString group )
+{
+  if ( !c ) c = KGlobal::config();
+  if ( group.isEmpty() ) group = "dock_setting_default";
+
+  c->setGroup( group );
+  TQStrList nameList;
+  c->readListEntry( "NameList", nameList );
+  TQString ver = c->readEntry( "Version", "0.0.1" );
+  nameList.first();
+  if ( !nameList.current() || ver != DOCK_CONFIG_VERSION ){
+    activate();
+    return;
+  }
+
+  autoCreateDock = new TQObjectList();
+  autoCreateDock->setAutoDelete( true );
+
+  bool isMainVisible = main->isVisible();
+ // if (isMainVisible)  // CCC
+  //TQMessageBox::information(0,"","hallo");
+//COMMENTED4TESTING  main->hide();
+
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+
+  while ( (obj=(KDockWidget*)it.current()) ){
+    ++it;
+    if ( !obj->isGroup && !obj->isTabGroup )
+    {
+      if ( obj->parent() ) obj->undock(); else obj->hide();
+    }
+  }
+
+  // firstly, only the common dockwidgets,
+  // they must be restored before e.g. tabgroups are restored
+  nameList.first();
+  while ( nameList.current() ){
+    TQString oname = nameList.current();
+    c->setGroup( group );
+    TQString type = c->readEntry( oname + ":type" );
+    obj = 0L;
+
+    if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
+      TQRect r = c->readRectEntry( oname + ":geometry" );
+      obj = getDockWidgetFromName( oname );
+      obj->applyToWidget( 0L );
+      obj->setGeometry(r);
+
+      c->setGroup( group );
+      obj->setTabPageLabel(c->readEntry( oname + ":tabCaption" ));
+      obj->setToolTipString(c->readEntry( oname + ":tabToolTip" ));
+      if ( c->readBoolEntry( oname + ":visible" ) ){
+        obj->TQWidget::show();
+      }
+    }
+
+    if ( type == "DOCK"  ){
+      obj = getDockWidgetFromName( oname );
+      obj->setTabPageLabel(c->readEntry( oname + ":tabCaption" ));
+      obj->setToolTipString(c->readEntry( oname + ":tabToolTip" ));
+    }
+
+    if (obj && obj->d->isContainer) {
+		tqt_dynamic_cast<KDockContainer*>(obj->widget)->load(c,group);
+		removeFromAutoCreateList(obj);
+    }
+    if ( obj && obj->header){
+      obj->header->loadConfig( c );
+    }
+    nameList.next();
+  }
+
+  // secondly, after the common dockwidgets, restore the groups and tabgroups
+  nameList.first();
+  while ( nameList.current() ){
+    TQString oname = nameList.current();
+    c->setGroup( group );
+    TQString type = c->readEntry( oname + ":type" );
+    obj = 0L;
+
+    if ( type == "GROUP" ){
+      KDockWidget* first = getDockWidgetFromName( c->readEntry( oname + ":first_name" ) );
+      KDockWidget* last  = getDockWidgetFromName( c->readEntry( oname + ":last_name"  ) );
+      int sepPos = c->readNumEntry( oname + ":sepPos" );
+
+      Orientation p = (Orientation)c->readNumEntry( oname + ":orientation" );
+      if ( first  && last ){
+        obj = first->manualDock( last, ( p == Qt::Vertical ) ? KDockWidget::DockLeft : KDockWidget::DockTop, sepPos );
+        if (obj){
+          obj->setName( oname.latin1() );
+        }
+      }
+    }
+
+    if ( type == "TAB_GROUP" ){
+      TQStrList list;
+      KDockWidget* tabDockGroup = 0L;
+      c->readListEntry( oname+":tabNames", list );
+      KDockWidget* d1 = getDockWidgetFromName( list.first() );
+      list.next();
+      KDockWidget* d2 = getDockWidgetFromName( list.current() );
+      tabDockGroup = d2->manualDock( d1, KDockWidget::DockCenter );
+      if ( tabDockGroup ){
+        KDockTabGroup* tab = tqt_dynamic_cast<KDockTabGroup*>(tabDockGroup->widget);
+        list.next();
+        while ( list.current() && tabDockGroup ){
+          KDockWidget* tabDock = getDockWidgetFromName( list.current() );
+          tabDockGroup = tabDock->manualDock( d1, KDockWidget::DockCenter );
+          list.next();
+        }
+        if ( tabDockGroup ){
+          tabDockGroup->setName( oname.latin1() );
+          c->setGroup( group );
+          if (tab)
+            tab->showPage( tab->page( c->readNumEntry( oname+":curTab" ) ) );
+        }
+      }
+      obj = tabDockGroup;
+    }
+
+    if (obj && obj->d->isContainer)  tqt_dynamic_cast<KDockContainer*>(obj->widget)->load(c,group);
+    if ( obj && obj->header){
+      obj->header->loadConfig( c );
+    }
+    nameList.next();
+  }
+
+  // thirdly, now that all ordinary dockwidgets are created,
+  // iterate them again and link the toplevel ones of them with their corresponding dockwidget for the dockback action
+  nameList.first();
+  while ( nameList.current() ){
+    TQString oname = nameList.current();
+    c->setGroup( group );
+    TQString type = c->readEntry( oname + ":type" );
+    obj = 0L;
+
+    if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
+      obj = getDockWidgetFromName( oname );
+      c->setGroup( group );
+      TQString name = c->readEntry( oname + ":dockBackTo" );
+      if (!name.isEmpty()) {
+          obj->setFormerBrotherDockWidget(getDockWidgetFromName( name ));
+      }
+      obj->formerDockPos = KDockWidget::DockPosition(c->readNumEntry( oname + ":dockBackToPos" ));
+    }
+
+    nameList.next();
+  }
+
+  if ( main->inherits("KDockMainWindow") ){
+    KDockMainWindow* dmain = (KDockMainWindow*)main;
+
+    c->setGroup( group );
+    TQString mv = c->readEntry( "Main:view" );
+    if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
+      KDockWidget* mvd  = getDockWidgetFromName( mv );
+      mvd->applyToWidget( dmain );
+      mvd->show();
+      dmain->setView( mvd );
+    }
+    c->setGroup( group );
+    TQString md = c->readEntry( "Main:dock" );
+    if ( !md.isEmpty() && getDockWidgetFromName( md ) ){
+      KDockWidget* mvd  = getDockWidgetFromName( md );
+      dmain->setMainDockWidget( mvd );
+    }
+  } else {
+    c->setGroup( group );
+    TQString mv = c->readEntry( "Main:view" );
+    if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
+      KDockWidget* mvd  = getDockWidgetFromName( mv );
+      mvd->applyToWidget( main );
+      mvd->show();
+    }
+
+  }
+
+  // delete all autocreate dock
+  if (d->m_readDockConfigMode == WrapExistingWidgetsOnly) {
+    finishReadDockConfig(); // remove empty dockwidgets
+  }
+
+  c->setGroup( group );
+
+  TQRect mr = c->readRectEntry("Main:Geometry");
+
+  if (!main->inherits("KDockMainWindow"))
+    main->move(mr.topLeft());
+
+  main->resize(mr.size());
+
+  if ( isMainVisible ) main->show();
+}
+#endif
+
+
+void KDockManager::dumpDockWidgets() {
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+  while ( (obj=(KDockWidget*)it.current()) ) {
+    ++it;
+    kdDebug(282)<<"KDockManager::dumpDockWidgets:"<<obj->name()<<endl;
+  }
+
+}
+
+KDockWidget* KDockManager::getDockWidgetFromName( const TQString& dockName )
+{
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+  while ( (obj=(KDockWidget*)it.current()) ) {
+    ++it;
+    if ( TQString(obj->name()) == dockName ) return obj;
+  }
+
+  KDockWidget* autoCreate = 0L;
+  if ( autoCreateDock ){
+    kdDebug(282)<<"Autocreating dock: "<<dockName<<endl;
+    autoCreate = new KDockWidget( this, dockName.latin1(), TQPixmap(TQString("")) );
+    autoCreateDock->append( TQT_TQOBJECT(autoCreate) );
+  }
+  return autoCreate;
+}
+void KDockManager::setSplitterOpaqueResize(bool b)
+{
+  d->splitterOpaqueResize = b;
+}
+
+bool KDockManager::splitterOpaqueResize() const
+{
+  return d->splitterOpaqueResize;
+}
+
+void KDockManager::setSplitterKeepSize(bool b)
+{
+  d->splitterKeepSize = b;
+}
+
+bool KDockManager::splitterKeepSize() const
+{
+  return d->splitterKeepSize;
+}
+
+void KDockManager::setSplitterHighResolution(bool b)
+{
+  d->splitterHighResolution = b;
+}
+
+bool KDockManager::splitterHighResolution() const
+{
+  return d->splitterHighResolution;
+}
+
+void KDockManager::slotMenuPopup()
+{
+  menu->clear();
+  menuData->clear();
+
+  TQObjectListIt it( *childDock );
+  KDockWidget * obj;
+  int numerator = 0;
+  while ( (obj=(KDockWidget*)it.current()) ) {
+    ++it;
+    if ( obj->mayBeHide() )
+    {
+      menu->insertItem( obj->icon() ? *(obj->icon()) : TQPixmap(), TQString(i18n("Hide %1").arg(obj->caption())), numerator++ );
+      menuData->append( new MenuDockData( obj, true ) );
+    }
+
+    if ( obj->mayBeShow() )
+    {
+      menu->insertItem( obj->icon() ? *(obj->icon()) : TQPixmap(), TQString(i18n("Show %1").arg(obj->caption())), numerator++ );
+      menuData->append( new MenuDockData( obj, false ) );
+    }
+  }
+}
+
+void KDockManager::slotMenuActivated( int id )
+{
+  MenuDockData* data = menuData->tqat( id );
+  data->dock->changeHideShowState();
+}
+
+KDockWidget* KDockManager::findWidgetParentDock( TQWidget* w ) const
+{
+  TQObjectListIt it( *childDock );
+  KDockWidget * dock;
+  KDockWidget * found = 0L;
+
+  while ( (dock=(KDockWidget*)it.current()) ) {
+    ++it;
+    if ( dock->widget == w ){ found  = dock; break; }
+  }
+  return found;
+}
+
+void KDockManager::drawDragRectangle()
+{
+#ifdef BORDERLESS_WINDOWS
+	return
+#endif
+  if (d->oldDragRect == d->dragRect)
+    return;
+
+  int i;
+  TQRect oldAndNewDragRect[2];
+  oldAndNewDragRect[0] = d->oldDragRect;
+  oldAndNewDragRect[1] = d->dragRect;
+
+  // 2 calls, one for the old and one for the new drag rectangle
+  for (i = 0; i <= 1; i++) {
+    if (oldAndNewDragRect[i].isEmpty())
+      continue;
+
+    KDockWidget* pDockWdgAtRect = (KDockWidget*) TQApplication::widgetAt( oldAndNewDragRect[i].topLeft(), true );
+    if (!pDockWdgAtRect)
+      continue;
+
+    bool isOverMainWdg = false;
+    bool unclipped;
+    KDockMainWindow* pMain = 0L;
+    KDockWidget* pTLDockWdg = 0L;
+    TQWidget* topWdg;
+    if (pDockWdgAtRect->tqtopLevelWidget() == main) {
+      isOverMainWdg = true;
+      topWdg = pMain = (KDockMainWindow*) main;
+      unclipped = pMain->testWFlags( WPaintUnclipped );
+      pMain->setWFlags( WPaintUnclipped );
+    }
+    else {
+      topWdg = pTLDockWdg = (KDockWidget*) pDockWdgAtRect->tqtopLevelWidget();
+      unclipped = pTLDockWdg->testWFlags( WPaintUnclipped );
+      pTLDockWdg->setWFlags( WPaintUnclipped );
+    }
+
+    // draw the rectangle unclipped over the main dock window
+    TQPainter p;
+    p.begin( topWdg );
+      if ( !unclipped ) {
+        if (isOverMainWdg)
+          pMain->clearWFlags(WPaintUnclipped);
+        else
+          pTLDockWdg->clearWFlags(WPaintUnclipped);
+      }
+      // draw the rectangle
+      p.setRasterOp(TQt::NotXorROP);
+      TQRect r = oldAndNewDragRect[i];
+      r.moveTopLeft( r.topLeft() - topWdg->mapToGlobal(TQPoint(0,0)) );
+      p.drawRect(r.x(), r.y(), r.width(), r.height());
+    p.end();
+  }
+
+  // memorize the current rectangle for later removing
+  d->oldDragRect = d->dragRect;
+}
+
+void KDockManager::setSpecialLeftDockContainer(KDockWidget* container) {
+	d->leftContainer=container;
+}
+
+void KDockManager::setSpecialTopDockContainer(KDockWidget* container) {
+	d->topContainer=container;
+}
+
+void KDockManager::setSpecialRightDockContainer(KDockWidget* container) {
+	d->rightContainer=container;
+
+}
+
+void KDockManager::setSpecialBottomDockContainer(KDockWidget* container) {
+	d->bottomContainer=container;
+}
+
+
+KDockArea::KDockArea( TQWidget* parent, const char *name)
+:TQWidget( parent, name)
+{
+  TQString new_name = TQString(name) + TQString("_DockManager");
+  dockManager = new KDockManager( this, new_name.latin1() );
+  mainDockWidget = 0L;
+}
+
+KDockArea::~KDockArea()
+{
+	delete dockManager;
+}
+
+KDockWidget* KDockArea::createDockWidget( const TQString& name, const TQPixmap &pixmap, TQWidget* parent, const TQString& strCaption, const TQString& strTabPageLabel)
+{
+  return new KDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
+}
+
+void KDockArea::makeDockVisible( KDockWidget* dock )
+{
+  if ( dock )
+    dock->makeDockVisible();
+}
+
+void KDockArea::makeDockInvisible( KDockWidget* dock )
+{
+  if ( dock )
+    dock->undock();
+}
+
+void KDockArea::makeWidgetDockVisible( TQWidget* widget )
+{
+  makeDockVisible( dockManager->findWidgetParentDock(widget) );
+}
+
+void KDockArea::writeDockConfig(TQDomElement &base)
+{
+  dockManager->writeConfig(base);
+}
+
+void KDockArea::readDockConfig(TQDomElement &base)
+{
+  dockManager->readConfig(base);
+}
+
+void KDockArea::slotDockWidgetUndocked()
+{
+  TQObject* pSender = (TQObject*) sender();
+  if (!pSender->inherits("KDockWidget")) return;
+  KDockWidget* pDW = (KDockWidget*) pSender;
+  emit dockWidgetHasUndocked( pDW);
+}
+
+void KDockArea::resizeEvent(TQResizeEvent *rsize)
+{
+  TQWidget::resizeEvent(rsize);
+  if (!childrenListObject().isEmpty()){
+#ifndef NO_KDE2
+//    kdDebug(282)<<"KDockArea::resize"<<endl;
+#endif
+    TQObjectList *list=queryList(TQWIDGET_OBJECT_NAME_STRING,0,false);
+
+    TQObjectListIt it( *list ); // iterate over the buttons
+    TQObject *obj;
+
+    while ( (obj = it.current()) != 0 ) {
+        // for each found object...
+        ((TQWidget*)obj)->setGeometry(TQRect(TQPoint(0,0),size()));
+	break;
+    }
+    delete list;
+#if 0
+    KDockSplitter *split;
+//    for (unsigned int i=0;i<children()->count();i++)
+    {
+//    	TQPtrList<TQObject> list(children());
+//       TQObject *obj=((TQPtrList<TQObject*>)children())->tqat(i);
+	TQObject *obj=children()->getFirst();
+       if (split = tqt_dynamic_cast<KDockSplitter*>(obj))
+       {
+          split->setGeometry( TQRect(TQPoint(0,0), size() ));
+//	  break;
+       }
+    }
+#endif
+   }
+}
+
+#ifndef NO_KDE2
+void KDockArea::writeDockConfig( KConfig* c, TQString group )
+{
+  dockManager->writeConfig( c, group );
+}
+
+void KDockArea::readDockConfig( KConfig* c, TQString group )
+{
+  dockManager->readConfig( c, group );
+}
+
+void KDockArea::setMainDockWidget( KDockWidget* mdw )
+{
+  if ( mainDockWidget == mdw ) return;
+  mainDockWidget = mdw;
+  mdw->applyToWidget(this);
+}
+#endif
+
+
+
+// KDOCKCONTAINER - AN ABSTRACTION OF THE KDOCKTABWIDGET
+KDockContainer::KDockContainer(){m_overlapMode=false; m_childrenListBegin=0; m_childrenListEnd=0;}
+KDockContainer::~KDockContainer(){
+
+	if (m_childrenListBegin)
+	{
+		struct ListItem *tmp=m_childrenListBegin;
+		while (tmp)
+		{
+			struct ListItem *tmp2=tmp->next;
+			free(tmp->data);
+			delete tmp;
+			tmp=tmp2;
+		}
+		m_childrenListBegin=0;
+		m_childrenListEnd=0;
+	}
+
+}
+
+void KDockContainer::activateOverlapMode(int nonOverlapSize) {
+	m_nonOverlapSize=nonOverlapSize;
+	m_overlapMode=true;
+	if (parentDockWidget() && parentDockWidget()->parent()) {
+		kdDebug(282)<<"KDockContainer::activateOverlapMode: recalculating sizes"<<endl;
+		KDockSplitter *sp= ::tqqt_cast<KDockSplitter*>(parentDockWidget()->
+			parent());
+		if (sp)
+			sp->resizeEvent(0);
+	}
+}
+
+void KDockContainer::deactivateOverlapMode() {
+	if (!m_overlapMode) return;
+	m_overlapMode=false;
+	if (parentDockWidget() && parentDockWidget()->parent()) {
+		kdDebug(282)<<"KDockContainer::deactivateOverlapMode: recalculating sizes"<<endl;
+		KDockSplitter *sp= ::tqqt_cast<KDockSplitter*>(parentDockWidget()->
+			parent());
+		if (sp)
+			sp->resizeEvent(0);
+		}
+}
+
+bool KDockContainer::isOverlapMode() {
+	return m_overlapMode;
+}
+
+
+bool KDockContainer::dockDragEnter(KDockWidget*, TQMouseEvent *) { return false;}
+bool KDockContainer::dockDragMove(KDockWidget*, TQMouseEvent *) { return false;}
+bool KDockContainer::dockDragLeave(KDockWidget*, TQMouseEvent *) { return false;}
+
+
+KDockWidget *KDockContainer::parentDockWidget(){return 0;}
+
+TQStringList KDockContainer::containedWidgets() const {
+	TQStringList tmp;
+	for (struct ListItem *it=m_childrenListBegin;it;it=it->next) {
+		tmp<<TQString(it->data);
+	}
+
+	return tmp;
+}
+
+void KDockContainer::showWidget(KDockWidget *) {
+}
+
+void KDockContainer::insertWidget (KDockWidget *dw, TQPixmap, const TQString &, int &)
+	{
+		struct ListItem *it=new struct ListItem;
+		it->data=strdup(dw->name());
+		it->next=0;
+
+		if (m_childrenListEnd)
+		{
+			m_childrenListEnd->next=it;
+			it->prev=m_childrenListEnd;
+			m_childrenListEnd=it;
+		}
+		else
+		{
+			it->prev=0;
+			m_childrenListEnd=it;
+			m_childrenListBegin=it;
+		}
+	}
+void KDockContainer::removeWidget (KDockWidget *dw){
+	for (struct ListItem *tmp=m_childrenListBegin;tmp;tmp=tmp->next)
+	{
+		if (!strcmp(tmp->data,dw->name()))
+		{
+			free(tmp->data);
+			if (tmp->next) tmp->next->prev=tmp->prev;
+			if (tmp->prev) tmp->prev->next=tmp->next;
+			if (tmp==m_childrenListBegin) m_childrenListBegin=tmp->next;
+			if (tmp==m_childrenListEnd) m_childrenListEnd=tmp->prev;
+			delete tmp;
+			break;
+		}
+	}
+}
+
+//m_children.remove(dw->name());}
+void KDockContainer::undockWidget (KDockWidget *){;}
+void KDockContainer::setToolTip(KDockWidget *, TQString &){;}
+void KDockContainer::setPixmap(KDockWidget*,const TQPixmap&){;}
+void KDockContainer::load (KConfig*, const TQString&){;}
+void KDockContainer::save (KConfig*, const TQString&){;}
+void KDockContainer::load (TQDomElement&){;}
+void KDockContainer::save (TQDomElement&){;}
+void KDockContainer::prepareSave(TQStringList &names)
+{
+
+	for (struct ListItem *tmp=m_childrenListBegin;tmp; tmp=tmp->next)
+		names.remove(tmp->data);
+//	for (uint i=0;i<m_children.count();i++)
+//	{
+//		names.remove(m_children.tqat(i));
+//	}
+}
+
+
+TQWidget *KDockTabGroup::transientTo() {
+	TQWidget *tT=0;
+	for (int i=0;i<count();i++) {
+		KDockWidget *dw=::tqqt_cast<KDockWidget*>(page(i));
+		TQWidget *tmp;
+		if ((tmp=dw->transientTo())) {
+			if (!tT) tT=tmp;
+			else {
+				if (tT!=tmp) {
+					kdDebug(282)<<"KDockTabGroup::transientTo: widget mismatch"<<endl;
+					return 0;
+				}
+			}
+		}
+	}
+
+	kdDebug(282)<<"KDockTabGroup::transientTo: "<<(tT?"YES":"NO")<<endl;
+
+	return tT;
+}
+
+void KDockWidgetAbstractHeader::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KDockWidgetAbstractHeaderDrag::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KDockWidgetHeaderDrag::virtual_hook( int id, void* data )
+{ KDockWidgetAbstractHeaderDrag::virtual_hook( id, data ); }
+
+void KDockWidgetHeader::virtual_hook( int id, void* data )
+{ KDockWidgetAbstractHeader::virtual_hook( id, data ); }
+
+void KDockTabGroup::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KDockWidget::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KDockManager::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KDockMainWindow::virtual_hook( int id, void* data )
+{ KMainWindow::virtual_hook( id, data ); }
+
+void KDockArea::virtual_hook( int, void* )
+{ /*KMainWindow::virtual_hook( id, data );*/ }
+
+
+#ifndef NO_INCLUDE_TQMOCFILES // for Qt-only projects, because tmake doesn't take this name
+#include "kdockwidget.moc"
+#endif