kdeui Library API Documentation

kdockwidget.cpp

00001 
00002 /* This file is part of the KDE libraries
00003    Copyright (C) 2000 Max Judin <novaprint@mtu-net.ru>
00004    Copyright (C) 2002,2003 Joseph Wenninger <jowenn@kde.org>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License version 2 as published by the Free Software Foundation.
00009 
00010    This library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Library General Public License for more details.
00014 
00015    You should have received a copy of the GNU Library General Public License
00016    along with this library; see the file COPYING.LIB.  If not, write to
00017    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018    Boston, MA 02111-1307, USA.
00019 */
00020 #include "kdockwidget.h"
00021 #include "kdockwidget_private.h"
00022 #include "kdockwidget_p.h"
00023 
00024 #include <qapplication.h>
00025 #include <qlayout.h>
00026 #include <qpainter.h>
00027 #include <qobjectlist.h>
00028 #include <qstrlist.h>
00029 #include <qcursor.h>
00030 #include <qwidgetlist.h>
00031 #include <qtabwidget.h>
00032 #include <qtooltip.h>
00033 #include <qstyle.h>
00034 
00035 #ifndef NO_KDE2
00036 #include <kconfig.h>
00037 #include <kglobal.h>
00038 #include <klocale.h>
00039 #include <ktoolbar.h>
00040 #include <kpopupmenu.h>
00041 #include <kwin.h>
00042 #include <kdebug.h>
00043 #include <kglobalsettings.h>
00044 
00045 #include "config.h"
00046 #ifdef Q_WS_X11
00047 #include <X11/X.h>
00048 #include <X11/Xlib.h>
00049 #endif
00050 
00051 #else
00052 #include <qtoolbar.h>
00053 #include <qpopupmenu.h>
00054 #endif
00055 
00056 #include <stdlib.h>
00057 
00058 #undef BORDERLESS_WINDOWS
00059 
00060 #define DOCK_CONFIG_VERSION "0.0.5"
00061 
00062 static const char* const dockback_xpm[]={
00063 "6 6 2 1",
00064 "# c black",
00065 ". c None",
00066 "......",
00067 ".#....",
00068 "..#..#",
00069 "...#.#",
00070 "....##",
00071 "..####"};
00072 
00073 static const char* const todesktop_xpm[]={
00074 "5 5 2 1",
00075 "# c black",
00076 ". c None",
00077 "####.",
00078 "##...",
00079 "#.#..",
00080 "#..#.",
00081 "....#"};
00082 
00083 static const char* const not_close_xpm[]={
00084 "5 5 2 1",
00085 "# c black",
00086 ". c None",
00087 "#####",
00088 "#...#",
00089 "#...#",
00090 "#...#",
00091 "#####"};
00092 
00102 KDockMainWindow::KDockMainWindow( QWidget* parent, const char *name, WFlags f)
00103 :KMainWindow( parent, name, f )
00104 {
00105   QString new_name = QString(name) + QString("_DockManager");
00106   dockManager = new KDockManager( this, new_name.latin1() );
00107   mainDockWidget = 0L;
00108 }
00109 
00110 KDockMainWindow::~KDockMainWindow()
00111 {
00112     delete dockManager;
00113 }
00114 
00115 void KDockMainWindow::setMainDockWidget( KDockWidget* mdw )
00116 {
00117   if ( mainDockWidget == mdw ) return;
00118   mainDockWidget = mdw;
00119   dockManager->setMainDockWidget2(mdw);
00120 }
00121 
00122 void KDockMainWindow::setView( QWidget *view )
00123 {
00124   if ( view->isA("KDockWidget") ){
00125     if ( view->parent() != this ) ((KDockWidget*)view)->applyToWidget( this );
00126   }
00127 
00128 #ifndef NO_KDE2
00129   KMainWindow::setCentralWidget(view);
00130 #else
00131   QMainWindow::setCentralWidget(view);
00132 #endif
00133 }
00134 
00135 KDockWidget* KDockMainWindow::createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent, const QString& strCaption, const QString& strTabPageLabel)
00136 {
00137   return new KDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
00138 }
00139 
00140 void KDockMainWindow::makeDockVisible( KDockWidget* dock )
00141 {
00142   if ( dock )
00143     dock->makeDockVisible();
00144 }
00145 
00146 void KDockMainWindow::makeDockInvisible( KDockWidget* dock )
00147 {
00148   if ( dock )
00149     dock->undock();
00150 }
00151 
00152 void KDockMainWindow::makeWidgetDockVisible( QWidget* widget )
00153 {
00154   makeDockVisible( dockManager->findWidgetParentDock(widget) );
00155 }
00156 
00157 void KDockMainWindow::writeDockConfig(QDomElement &base)
00158 {
00159   dockManager->writeConfig(base);
00160 }
00161 
00162 void KDockMainWindow::readDockConfig(QDomElement &base)
00163 {
00164   dockManager->readConfig(base);
00165 }
00166 
00167 #ifndef NO_KDE2
00168 void KDockMainWindow::writeDockConfig( KConfig* c, QString group )
00169 {
00170   dockManager->writeConfig( c, group );
00171 }
00172 
00173 void KDockMainWindow::readDockConfig( KConfig* c, QString group )
00174 {
00175   dockManager->readConfig( c, group );
00176 }
00177 #endif
00178 
00179 void KDockMainWindow::slotDockWidgetUndocked()
00180 {
00181   QObject* pSender = (QObject*) sender();
00182   if (!pSender->inherits("KDockWidget")) return;
00183   KDockWidget* pDW = (KDockWidget*) pSender;
00184   emit dockWidgetHasUndocked( pDW);
00185 }
00186 
00187 /*************************************************************************/
00188 KDockWidgetAbstractHeaderDrag::KDockWidgetAbstractHeaderDrag( KDockWidgetAbstractHeader* parent, KDockWidget* dock, const char* name )
00189 :QFrame( parent, name )
00190 {
00191   dw = dock;
00192   installEventFilter( dock->dockManager() );
00193 }
00194 /*************************************************************************/
00195 KDockWidgetHeaderDrag::KDockWidgetHeaderDrag( KDockWidgetAbstractHeader* parent, KDockWidget* dock, const char* name )
00196 :KDockWidgetAbstractHeaderDrag( parent, dock, name )
00197 {
00198 }
00199 
00200 void KDockWidgetHeaderDrag::paintEvent( QPaintEvent* )
00201 {
00202   QPainter paint;
00203 
00204   paint.begin( this );
00205 
00206   style().drawPrimitive (QStyle::PE_DockWindowHandle, &paint, QRect(0,0,width(), height()), colorGroup());
00207 
00208   paint.end();
00209 }
00210 /*************************************************************************/
00211 KDockWidgetAbstractHeader::KDockWidgetAbstractHeader( KDockWidget* parent, const char* name )
00212 :QFrame( parent, name )
00213 {
00214 }
00215 /*************************************************************************/
00216 KDockWidgetHeader::KDockWidgetHeader( KDockWidget* parent, const char* name )
00217 :KDockWidgetAbstractHeader( parent, name )
00218 {
00219 #ifdef BORDERLESS_WINDOWS
00220   setCursor(QCursor(ArrowCursor));
00221 #endif
00222   d = new KDockWidgetHeaderPrivate( this );
00223 
00224   layout = new QHBoxLayout( this );
00225   layout->setResizeMode( QLayout::Minimum );
00226 
00227   drag = new KDockWidgetHeaderDrag( this, parent );
00228 
00229   closeButton = new KDockButton_Private( this, "DockCloseButton" );
00230   QToolTip::add( closeButton, i18n("Close") );
00231   closeButton->setPixmap( style().stylePixmap (QStyle::SP_TitleBarCloseButton , this));
00232   closeButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
00233   connect( closeButton, SIGNAL(clicked()), parent, SIGNAL(headerCloseButtonClicked()));
00234   connect( closeButton, SIGNAL(clicked()), parent, SLOT(undock()));
00235 
00236   stayButton = new KDockButton_Private( this, "DockStayButton" );
00237   QToolTip::add( stayButton, i18n("Freeze the window geometry", "Freeze") );
00238   stayButton->setToggleButton( true );
00239   stayButton->setPixmap( const_cast< const char** >(not_close_xpm) );
00240   stayButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
00241   connect( stayButton, SIGNAL(clicked()), this, SLOT(slotStayClicked()));
00242 
00243   dockbackButton = new KDockButton_Private( this, "DockbackButton" );
00244   QToolTip::add( dockbackButton, i18n("Dock this window", "Dock") );
00245   dockbackButton->setPixmap( const_cast< const char** >(dockback_xpm));
00246   dockbackButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
00247   connect( dockbackButton, SIGNAL(clicked()), parent, SIGNAL(headerDockbackButtonClicked()));
00248   connect( dockbackButton, SIGNAL(clicked()), parent, SLOT(dockBack()));
00249 
00250   d->toDesktopButton = new KDockButton_Private( this, "ToDesktopButton" );
00251   QToolTip::add( d->toDesktopButton, i18n("Detach") );
00252   d->toDesktopButton->setPixmap( const_cast< const char** >(todesktop_xpm));
00253   d->toDesktopButton->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
00254   connect( d->toDesktopButton, SIGNAL(clicked()), parent, SLOT(toDesktop()));
00255   stayButton->hide();
00256 
00257   d->dummy = new QWidget( this );
00258   d->dummy->setFixedSize( 1,closeButton->pixmap()->height() );
00259 
00260 
00261   layout->addWidget( drag );
00262   layout->addWidget( dockbackButton );
00263   layout->addWidget( d->toDesktopButton );
00264   layout->addWidget( d->dummy);
00265   layout->addWidget( stayButton );
00266   layout->addWidget( closeButton );
00267   layout->activate();
00268   d->dummy->hide();
00269   drag->setFixedHeight( layout->minimumSize().height() );
00270 }
00271 
00272 void KDockWidgetHeader::setTopLevel( bool isTopLevel )
00273 {
00274   d->topLevel = isTopLevel;
00275   if ( isTopLevel ){
00276     KDockWidget* par = (KDockWidget*)parent();
00277     if( par) {
00278       if( par->isDockBackPossible())
00279         dockbackButton->show();
00280       else
00281         dockbackButton->hide();
00282     }
00283     stayButton->hide();
00284     closeButton->hide();
00285     d->toDesktopButton->hide();
00286     drag->setEnabled( true );
00287   } else {
00288     dockbackButton->hide();
00289     stayButton->hide();
00290     if (!d->forceCloseButtonHidden) closeButton->show();
00291     if( d->showToDesktopButton )
00292       d->toDesktopButton->show();
00293   }
00294   layout->activate();
00295 
00296    bool dontShowDummy=drag->isVisibleTo(this) || dockbackButton->isVisibleTo(this) ||
00297         d->toDesktopButton->isVisibleTo(this) || stayButton->isVisibleTo(this) ||
00298         closeButton->isVisibleTo(this);
00299    for (QPtrListIterator<KDockButton_Private> it( d->btns );it.current();++it) {
00300         dontShowDummy=dontShowDummy || (it.current()->isVisibleTo(this));
00301    }
00302    if (dontShowDummy) d->dummy->hide(); else d->dummy->show();
00303 
00304   updateGeometry();
00305 }
00306 
00307 void KDockWidgetHeader::forceCloseButtonHidden(bool hidden) {
00308   d->forceCloseButtonHidden=hidden;
00309   if (hidden) closeButton->hide();
00310   else closeButton->show();
00311 }
00312 
00313 KDockWidgetHeaderDrag *KDockWidgetHeader::dragPanel() {
00314     return drag;
00315 }
00316 
00317 void KDockWidgetHeader::setDragPanel( KDockWidgetHeaderDrag* nd )
00318 {
00319   if ( !nd ) return;
00320 
00321   delete layout;
00322   layout = new QHBoxLayout( this );
00323   layout->setResizeMode( QLayout::Minimum );
00324 
00325   delete drag;
00326   drag = nd;
00327   if (drag->parentWidget()!=this) {
00328     drag->reparent(this,QPoint(0,0));
00329   }
00330 
00331 
00332   layout->addWidget( drag );
00333   layout->addWidget( dockbackButton );
00334   layout->addWidget( d->dummy );
00335   layout->addWidget( d->toDesktopButton );
00336   layout->addWidget( stayButton );
00337   bool dontShowDummy=drag->isVisibleTo(this) || dockbackButton->isVisibleTo(this) ||
00338     d->toDesktopButton->isVisibleTo(this) || stayButton->isVisibleTo(this) ||
00339     closeButton->isVisibleTo(this);
00340   for (QPtrListIterator<KDockButton_Private> it( d->btns );it.current();++it) {
00341       layout->addWidget(it.current());
00342     dontShowDummy=dontShowDummy || (it.current()->isVisibleTo(this));
00343   }
00344   if (dontShowDummy) d->dummy->hide(); else d->dummy->show();
00345   layout->addWidget( closeButton );
00346   layout->activate();
00347   kdDebug(282)<<"KdockWidgetHeader::setDragPanel:minimum height="<<layout->minimumSize().height()<<endl;
00348 #ifdef __GNUC__
00349 #warning FIXME
00350 #endif
00351   drag->setFixedHeight( closeButton->height()); // /*layout->minimumS*/sizeHint().height() );
00352 }
00353 
00354 void KDockWidgetHeader::addButton(KDockButton_Private* btn) {
00355     if (!btn) return;
00356 
00357     if (btn->parentWidget()!=this) {
00358         btn->reparent(this,QPoint(0,0));
00359     }
00360     btn->setFixedSize(closeButton->pixmap()->width(),closeButton->pixmap()->height());
00361     if (!d->btns.containsRef(btn)) d->btns.append(btn);
00362 
00363     btn->show();
00364 
00365     delete layout;
00366     layout = new QHBoxLayout( this );
00367     layout->setResizeMode( QLayout::Minimum );
00368 
00369     layout->addWidget( drag );
00370     layout->addWidget( dockbackButton );
00371     layout->addWidget( d->toDesktopButton );
00372     layout->addWidget( d->dummy);
00373     layout->addWidget( stayButton );
00374      bool dontShowDummy=drag->isVisibleTo(this) || dockbackButton->isVisibleTo(this) ||
00375             d->toDesktopButton->isVisibleTo(this) || stayButton->isVisibleTo(this) ||
00376             closeButton->isVisibleTo(this);
00377      for (QPtrListIterator<KDockButton_Private> it( d->btns );it.current();++it) {
00378             layout->addWidget(it.current());
00379         dontShowDummy=dontShowDummy || (it.current()->isVisibleTo(this));
00380     }
00381     if (dontShowDummy) d->dummy->hide(); else d->dummy->show();
00382     layout->addWidget( closeButton );
00383     layout->activate();
00384     drag->setFixedHeight( layout->minimumSize().height() );
00385 }
00386 
00387 void KDockWidgetHeader::removeButton(KDockButton_Private* btn) {
00388     if (btn->parentWidget()==this) {
00389         if (d->btns.containsRef(btn)) d->btns.removeRef(btn);
00390         delete btn;
00391     }
00392 }
00393 
00394 
00395 void KDockWidgetHeader::slotStayClicked()
00396 {
00397   setDragEnabled(!stayButton->isOn());
00398 }
00399 
00400 bool KDockWidgetHeader::dragEnabled() const
00401 {
00402   return drag->isEnabled();
00403 }
00404 
00405 void KDockWidgetHeader::showUndockButton(bool show)
00406 {
00407   kdDebug(282)<<"KDockWidgetHeader::showUndockButton("<<show<<")"<<endl;
00408   if( d->showToDesktopButton == show )
00409     return;
00410 
00411   d->showToDesktopButton = show;
00412   if( !show || d->topLevel )
00413     d->toDesktopButton->hide( );
00414   else
00415     d->toDesktopButton->show( );
00416 }
00417 
00418 void KDockWidgetHeader::setDragEnabled(bool b)
00419 {
00420   stayButton->setOn(!b);
00421   closeButton->setEnabled(b);
00422   drag->setEnabled(b);
00423 }
00424 
00425 #ifndef NO_KDE2
00426 void KDockWidgetHeader::saveConfig( KConfig* c )
00427 {
00428   c->writeEntry( QString("%1%2").arg(parent()->name()).arg(":stayButton"), stayButton->isOn() );
00429 }
00430 
00431 void KDockWidgetHeader::loadConfig( KConfig* c )
00432 {
00433   setDragEnabled( !c->readBoolEntry( QString("%1%2").arg(parent()->name()).arg(":stayButton"), false ) );
00434 }
00435 #endif
00436 
00437 /*************************************************************************/
00438 
00439 class KDockManager::KDockManagerPrivate
00440 {
00441 public:
00445   QRect dragRect;
00446 
00450   QRect oldDragRect;
00451 
00455   bool readyToDrag;
00456 
00460   QPoint dragOffset;
00461 
00465   bool splitterOpaqueResize;
00466   bool splitterKeepSize;
00467   bool splitterHighResolution;
00468 
00469   QGuardedPtr<KDockWidget> mainDockWidget;
00470 
00471   QObjectList containerDocks;
00472 
00473   QGuardedPtr<KDockWidget> leftContainer;
00474   QGuardedPtr<KDockWidget> topContainer;
00475   QGuardedPtr<KDockWidget> rightContainer;
00476   QGuardedPtr<KDockWidget> bottomContainer;
00477   int m_readDockConfigMode;
00478 };
00479 
00480 
00481 /*************************************************************************/
00482 KDockWidget::KDockWidget( KDockManager* dockManager, const char* name, const QPixmap &pixmap, QWidget* parent, const QString& strCaption, const QString& strTabPageLabel, WFlags f)
00483 #ifdef BORDERLESS_WINDOWS
00484 : QWidget( parent, name, f )//| WType_Dialog | WStyle_Customize | WStyle_NoBorder )
00485 #else
00486 : QWidget( parent, name, f )
00487 #endif
00488   ,formerBrotherDockWidget(0L)
00489   ,currentDockPos(DockNone)
00490   ,formerDockPos(DockNone)
00491   ,widget(0L)
00492   ,pix(new QPixmap(pixmap))
00493   ,prevSideDockPosBeforeDrag(DockNone)
00494   ,isGroup(false)
00495 {
00496   d = new KDockWidgetPrivate();  // create private data
00497 
00498   d->_parent = parent;
00499 
00500   layout = new QVBoxLayout( this );
00501   layout->setResizeMode( QLayout::Minimum );
00502 
00503   manager = dockManager;
00504   manager->childDock->append( this );
00505   installEventFilter( manager );
00506 
00507   eDocking = DockFullDocking;
00508   sDocking = DockFullSite;
00509 
00510   header = 0L;
00511   setHeader( new KDockWidgetHeader( this, "AutoCreatedDockHeader" ) );
00512 
00513   if( strCaption.isNull() )
00514     setCaption( name );
00515   else
00516     setCaption( strCaption);
00517 
00518   if( strTabPageLabel == " ")
00519     setTabPageLabel( caption());
00520   else
00521     setTabPageLabel( strTabPageLabel);
00522 
00523   isTabGroup = false;
00524   d->isContainer =false;
00525   setIcon( pixmap);
00526   widget = 0L;
00527 
00528   QObject::connect(this, SIGNAL(hasUndocked()), manager->main, SLOT(slotDockWidgetUndocked()) );
00529   applyToWidget( parent, QPoint(0,0) );
00530 }
00531 
00532 void KDockWidget::setPixmap(const QPixmap& pixmap) {
00533     delete pix;
00534     pix=new QPixmap(pixmap);
00535     setIcon(*pix);
00536     KDockTabGroup *dtg=parentDockTabGroup();
00537     if (dtg)
00538         dtg->changeTab(this,pixmap,dtg->tabLabel(this));
00539      QWidget *contWid=parentDockContainer();
00540          if (contWid) {
00541             KDockContainer *x = dynamic_cast<KDockContainer*>(contWid);
00542                 if (x) {
00543                         x->setPixmap(this,pixmap);
00544                 }
00545          }
00546 }
00547 
00548 const QPixmap& KDockWidget::pixmap() const {
00549     return *pix;
00550 }
00551 
00552 KDockWidget::~KDockWidget()
00553 {
00554   d->pendingDtor = true;
00555   if ( !manager->undockProcess ){
00556     d->blockHasUndockedSignal = true;
00557     undock();
00558     d->blockHasUndockedSignal = false;
00559   }
00560 
00561   if (latestKDockContainer()) {
00562     KDockContainer *x = dynamic_cast<KDockContainer*>(latestKDockContainer());
00563     if (x) {
00564       x->removeWidget(this);
00565     }
00566   }
00567   emit iMBeingClosed();
00568   if (manager->d) manager->d->containerDocks.remove(this);
00569   manager->childDock->remove( this );
00570   delete pix;
00571   delete d; // destroy private data
00572   d=0;
00573 }
00574 
00575 void KDockWidget::paintEvent(QPaintEvent* pe)
00576 {
00577     QWidget::paintEvent(pe);
00578         QPainter paint;
00579         paint.begin( this );
00580         style().drawPrimitive (QStyle::PE_Panel, &paint, QRect(0,0,width(), height()), colorGroup());
00581         paint.end();
00582 }
00583 
00584 void KDockWidget::leaveEvent(QEvent *e)
00585 {
00586     QWidget::leaveEvent(e);
00587 #ifdef BORDERLESS_WINDOWS
00588     if (parent()) return;
00589 //  setCursor(QCursor(ArrowCursor));
00590 #endif
00591 }
00592 
00593 void KDockWidget::mousePressEvent(QMouseEvent* mme)
00594 {
00595 #ifdef BORDERLESS_WINDOWS
00596     if (!parent())
00597     {
00598         kdDebug(282)<<"KDockWidget::mousePressEvent"<<endl;
00599 
00600         bool bbottom;
00601         bool bleft;
00602         bool bright;
00603         bool btop;
00604         int styleheight;
00605         QPoint mp;
00606         mp=mme->pos();
00607             styleheight=2*style().pixelMetric(QStyle::PM_DefaultFrameWidth,this);
00608         bbottom=mp.y()>=height()-styleheight;
00609         btop=mp.y()<=styleheight;
00610         bleft=mp.x()<=styleheight;
00611         bright=mp.x()>=width()-styleheight;
00612         kdDebug(282)<<"mousemovevent"<<endl;
00613         d->resizing=true;
00614         if (bright)
00615         {
00616             if (btop)
00617             {
00618                 d->resizeMode=KDockWidgetPrivate::ResizeTopRight;
00619                 d->resizePos=QPoint(width(),0)-mme->pos();
00620 
00621             }
00622             else
00623             {
00624                 d->resizePos=QPoint(width(),height())-mme->pos();
00625                 if (bbottom) d->resizeMode=KDockWidgetPrivate::ResizeBottomRight;
00626                 else d->resizeMode=KDockWidgetPrivate::ResizeRight;
00627             }
00628         }
00629         else if (bleft)
00630         {
00631             if (btop) setCursor(QCursor(SizeFDiagCursor));
00632             else
00633             if (bbottom) setCursor(QCursor(SizeBDiagCursor));
00634             else setCursor(QCursor(SizeHorCursor));
00635         }
00636         else
00637         if (bbottom)
00638         {
00639             d->resizeMode=KDockWidgetPrivate::ResizeBottom;
00640             d->resizePos=QPoint(0,height())-mme->pos();
00641         }
00642         else
00643         if  (btop) setCursor(QCursor(SizeVerCursor));
00644         else d->resizing=false;
00645 
00646         if (d->resizing) grabMouse(cursor());
00647 
00648     }
00649 #endif
00650     QWidget::mousePressEvent(mme);
00651 }
00652 
00653 void KDockWidget::mouseReleaseEvent(QMouseEvent* ev)
00654 {
00655 #ifdef BORDERLESS_WINDOWS
00656     d->resizing=false;
00657     releaseMouse();
00658 #endif
00659     QWidget::mouseReleaseEvent(ev);
00660 }
00661 
00662 void  KDockWidget::mouseMoveEvent(QMouseEvent* mme)
00663 {
00664     QWidget::mouseMoveEvent(mme);
00665 #ifdef BORDERLESS_WINDOWS
00666     if (parent()) return;
00667 
00668     if (d->resizing)
00669     {
00670         switch (d->resizeMode)
00671         {
00672             case KDockWidgetPrivate::ResizeRight:
00673                 resize(mme->pos().x()+d->resizePos.x(),height());
00674                 break;
00675             case KDockWidgetPrivate::ResizeBottomRight:
00676                 resize(mme->pos().x()+d->resizePos.x(),mme->pos().y()+d->resizePos.y());
00677                 break;
00678             case KDockWidgetPrivate::ResizeBottom:
00679                 resize(width(),mme->pos().y()+d->resizePos.y());
00680                 break;
00681             default:
00682                 break;
00683         }
00684         return;
00685     }
00686 
00687 
00688     bool bbottom;
00689     bool bleft;
00690     bool bright;
00691     bool btop;
00692     int styleheight;
00693     QPoint mp;
00694     mp=mme->pos();
00695         styleheight=2*style().pixelMetric(QStyle::PM_DefaultFrameWidth,this);
00696     bbottom=mp.y()>=height()-styleheight;
00697     btop=mp.y()<=styleheight;
00698     bleft=mp.x()<=styleheight;
00699     bright=mp.x()>=width()-styleheight;
00700     kdDebug(282)<<"mousemovevent"<<endl;
00701     if (bright)
00702     {
00703         if (btop) setCursor(QCursor(SizeBDiagCursor));
00704         else
00705         if (bbottom) setCursor(QCursor(SizeFDiagCursor));
00706         else setCursor(QCursor(SizeHorCursor));
00707     }
00708     else if (bleft)
00709     {
00710         if (btop) setCursor(QCursor(SizeFDiagCursor));
00711         else
00712         if (bbottom) setCursor(QCursor(SizeBDiagCursor));
00713         else setCursor(QCursor(SizeHorCursor));
00714     }
00715     else
00716     if (bbottom ||  btop) setCursor(QCursor(SizeVerCursor));
00717     else setCursor(QCursor(ArrowCursor));
00718 #endif
00719 }
00720 
00721 void KDockWidget::setLatestKDockContainer(QWidget* container)
00722 {
00723     if (container)
00724     {
00725         if (dynamic_cast<KDockContainer*>(container))
00726             d->container=container;
00727         else
00728             d->container=0;
00729     }
00730 }
00731 
00732 QWidget* KDockWidget::latestKDockContainer()
00733 {
00734     if (!(d->container)) return 0;
00735     if (dynamic_cast<KDockContainer*>(d->container.operator->())) return d->container;
00736     return 0;
00737 }
00738 
00739 
00740 
00741 KDockWidgetAbstractHeader *KDockWidget::getHeader() {
00742     return header;
00743 }
00744 
00745 void KDockWidget::setHeader( KDockWidgetAbstractHeader* h )
00746 {
00747   if ( !h ) return;
00748 
00749   if ( header ){
00750     delete header;
00751     delete layout;
00752     header = h;
00753     layout = new QVBoxLayout( this );
00754     layout->setResizeMode( QLayout::Minimum );
00755     layout->addWidget( header );
00756      setWidget( widget );
00757   } else {
00758     header = h;
00759     layout->addWidget( header );
00760   }
00761   kdDebug(282)<<caption()<<": KDockWidget::setHeader"<<endl;
00762   setEnableDocking(eDocking);
00763 }
00764 
00765 void KDockWidget::setEnableDocking( int pos )
00766 {
00767   eDocking = pos;
00768   if( header && header->inherits( "KDockWidgetHeader" ) )
00769      ( ( KDockWidgetHeader* ) header )->showUndockButton( pos & DockDesktop );
00770   updateHeader();
00771 }
00772 
00773 void KDockWidget::updateHeader()
00774 {
00775   if ( parent() ){
00776 #ifdef BORDERLESS_WINDOWS
00777       layout->setMargin(0);
00778       setMouseTracking(false);
00779       setCursor(QCursor(ArrowCursor));
00780 #endif
00781 
00782     if ( (parent() == manager->main) || isGroup || (eDocking == KDockWidget::DockNone) ){
00783       header->hide();
00784     } else {
00785       header->setTopLevel( false );
00786       if (widget && dynamic_cast<KDockContainer*>(widget))
00787         header->hide();
00788       else
00789         header->show();
00790     }
00791   } else {
00792     header->setTopLevel( true );
00793     header->show();
00794 #ifdef BORDERLESS_WINDOWS
00795       layout->setMargin(2*style().pixelMetric(QStyle::PM_DefaultFrameWidth,this));
00796       setMouseTracking(true);
00797 #endif
00798   }
00799 }
00800 
00801 void KDockWidget::applyToWidget( QWidget* s, const QPoint& p )
00802 {
00803   if ( parent() != s )
00804   {
00805     hide();
00806     reparent(s, 0, QPoint(0,0), false);
00807   }
00808 
00809   if ( s && s->inherits("KDockMainWindow") ){
00810     ((KDockMainWindow*)s)->setView( this );
00811   }
00812 
00813   if ( manager && s == manager->main ){
00814       setGeometry( QRect(QPoint(0,0), manager->main->geometry().size()) );
00815   }
00816 
00817   if ( !s )
00818   {
00819     move(p);
00820 
00821 #ifndef NO_KDE2
00822 #ifdef Q_WS_X11
00823     if (d->transient && d->_parent)
00824       XSetTransientForHint( qt_xdisplay(), winId(), d->_parent->winId() );
00825 
00826 #ifdef BORDERLESS_WINDOWS
00827     KWin::setType( winId(), NET::Override); //d->windowType );
00828 //      setWFlags(WStyle_Customize | WStyle_NoBorder | WStyle_Tool);
00829 #else
00830     KWin::setType( winId(), d->windowType );
00831 #endif // BORDERLESS_WINDOW
00832 #endif // Q_WS_X11
00833 #endif
00834 
00835   }
00836   updateHeader();
00837 
00838   setIcon(*pix);
00839 }
00840 
00841 void KDockWidget::show()
00842 {
00843   if ( parent() || manager->main->isVisible() )
00844     if ( !parent() ){
00845      emit manager->setDockDefaultPos( this );
00846      emit setDockDefaultPos();
00847      if ( parent() ){
00848         makeDockVisible();
00849       } else {
00850         QWidget::show();
00851       }
00852     } else {
00853      QWidget::show();
00854     }
00855 }
00856 
00857 #ifndef NO_KDE2
00858 
00859 void KDockWidget::setDockWindowType (NET::WindowType windowType)
00860 {
00861   d->windowType = windowType;
00862   applyToWidget( parentWidget(), QPoint(0,0) );
00863 }
00864 
00865 #endif
00866 
00867 void KDockWidget::setDockWindowTransient (QWidget *parent, bool transientEnabled)
00868 {
00869   d->_parent = parent;
00870   d->transient = transientEnabled;
00871   applyToWidget( parentWidget(), QPoint(0,0) );
00872 }
00873 
00874 QWidget *KDockWidget::transientTo() {
00875     if (d->transient && d->_parent) return d->_parent; else return 0;
00876 }
00877 
00878 bool KDockWidget::event( QEvent *event )
00879 {
00880   switch ( event->type() )
00881   {
00882     #undef FocusIn
00883     case QEvent::FocusIn:
00884       if (widget && !d->pendingFocusInEvent) {
00885          d->pendingFocusInEvent = true;
00886          widget->setFocus();
00887       }
00888       d->pendingFocusInEvent = false;
00889       break;
00890     case QEvent::ChildRemoved:
00891       if ( widget == ((QChildEvent*)event)->child() ) widget = 0L;
00892       break;
00893     case QEvent::Show:
00894       if ( widget ) widget->show();
00895       emit manager->change();
00896       break;
00897     case QEvent::Hide:
00898       if ( widget ) widget->hide();
00899       emit manager->change();
00900       break;
00901     case QEvent::CaptionChange:
00902       if ( parentWidget() ){
00903         if ( parent()->inherits("KDockSplitter") ){
00904           ((KDockSplitter*)(parent()))->updateName();
00905         }
00906         if ( parentDockTabGroup() ){
00907           setDockTabName( parentDockTabGroup() );
00908           parentDockTabGroup()->setTabLabel( this, tabPageLabel() );
00909         }
00910       }
00911       break;
00912     case QEvent::Close:
00913       emit iMBeingClosed();
00914       break;
00915     default:
00916       break;
00917   }
00918   return QWidget::event( event );
00919 }
00920 
00921 KDockWidget *KDockWidget::findNearestDockWidget(DockPosition pos)
00922 {
00923     if (!parent()) return 0;
00924     if (!parent()->inherits("KDockSplitter")) return 0;
00925     Orientation orientation=((pos==DockLeft) || (pos==DockRight)) ? Vertical:Horizontal;
00926         if (((KDockSplitter*)(parent()))->orientation()==orientation)
00927         {
00928             KDockWidget *neighbor=
00929                 ((pos==DockLeft)||(pos==DockTop))?
00930                 static_cast<KDockWidget*>(((KDockSplitter*)(parent()))->getFirst()):
00931                 static_cast<KDockWidget*>(((KDockSplitter*)(parent()))->getLast());
00932 
00933             if (neighbor==this)
00934             return (static_cast<KDockWidget*>(parent()->parent())->findNearestDockWidget(pos));
00935             else
00936             if (neighbor->getWidget() && (neighbor->getWidget()->qt_cast("KDockTabGroup")))
00937                 return (KDockWidget*)(((KDockTabGroup*)neighbor->getWidget())->page(0));
00938             else
00939             return neighbor;
00940         }
00941         else
00942         return (static_cast<KDockWidget*>(parent()->parent())->findNearestDockWidget(pos));
00943 
00944     return 0;
00945 }
00946 
00947 
00948 KDockWidget* KDockWidget::manualDock( KDockWidget* target, DockPosition dockPos, int spliPos, QPoint pos, bool check, int tabIndex )
00949 {
00950   if (this == target)
00951     return 0L;  // docking to itself not possible
00952 //  kdDebug(282)<<"manualDock called "<<endl;
00953   bool succes = true; // tested flag
00954 
00955   // check allowed this dock submit this operations
00956   if ( !(eDocking & (int)dockPos) ){
00957     succes = false;
00958 //  kdDebug(282)<<"KDockWidget::manualDock(): success = false (1)"<<endl;
00959   }
00960 
00961   KDockWidget *tmpTarget;
00962   switch (dockPos) {
00963     case DockLeft:tmpTarget=dockManager()->d->leftContainer;
00964         break;
00965     case DockRight:tmpTarget=dockManager()->d->rightContainer;
00966         break;
00967     case DockBottom:tmpTarget=dockManager()->d->bottomContainer;
00968         break;
00969     case DockTop:tmpTarget=dockManager()->d->topContainer;
00970         break;
00971     default: tmpTarget=0;
00972   }
00973 
00974   if (this!=tmpTarget) {
00975     if (target && (target==dockManager()->d->mainDockWidget) && tmpTarget) {
00976     return manualDock(tmpTarget,DockCenter,spliPos,pos,check,tabIndex);
00977     }
00978   }
00979 
00980   // check allowed target submit this operations
00981   if ( target && !(target->sDocking & (int)dockPos) ){
00982     succes = false;
00983 //  kdDebug(282)<<"KDockWidget::manualDock(): success = false (2)"<<endl;
00984   }
00985 
00986   if ( parent() && !parent()->inherits("KDockSplitter") && !parentDockTabGroup() &&
00987     !(dynamic_cast<KDockContainer*>(parent())) && !parentDockContainer()){
00988 //  kdDebug(282)<<"KDockWidget::manualDock(): success = false (3)"<<endl;
00989 //  kdDebug(282)<<parent()->name()<<endl;
00990     succes = false;
00991   }
00992 
00993 //  kdDebug(282)<<"KDockWidget::manualDock(): success == false "<<endl;
00994   if ( !succes ){
00995     // try to make another manualDock
00996     KDockWidget* dock_result = 0L;
00997     if ( target && !check ){
00998       KDockWidget::DockPosition another__dockPos = KDockWidget::DockNone;
00999       switch ( dockPos ){
01000         case KDockWidget::DockLeft  : another__dockPos = KDockWidget::DockRight ; break;
01001         case KDockWidget::DockRight : another__dockPos = KDockWidget::DockLeft  ; break;
01002         case KDockWidget::DockTop   : another__dockPos = KDockWidget::DockBottom; break;
01003         case KDockWidget::DockBottom: another__dockPos = KDockWidget::DockTop   ; break;
01004         default: break;
01005       }
01006       dock_result = target->manualDock( this, another__dockPos, spliPos, pos, true, tabIndex );
01007     }
01008     return dock_result;
01009   }
01010   // end check block
01011 
01012   d->blockHasUndockedSignal = true;
01013   undock();
01014   d->blockHasUndockedSignal = false;
01015 
01016   if ( !target ){
01017     move( pos );
01018     show();
01019     emit manager->change();
01020     return this;
01021   }
01022 
01023 //  kdDebug(282)<<"Looking for  KDockTabGroup"<<endl;
01024   KDockTabGroup* parentTab = target->parentDockTabGroup();
01025   if ( parentTab ){
01026     // add to existing TabGroup
01027     applyToWidget( parentTab );
01028     parentTab->insertTab( this, icon() ? *icon() : QPixmap(),
01029                           tabPageLabel(), tabIndex );
01030 
01031     QWidget *wantTransient=parentTab->transientTo();
01032     target->setDockWindowTransient(wantTransient,wantTransient);
01033 
01034     setDockTabName( parentTab );
01035     if( !toolTipStr.isEmpty())
01036       parentTab->setTabToolTip( this, toolTipStr);
01037 
01038     currentDockPos = KDockWidget::DockCenter;
01039     emit manager->change();
01040     return (KDockWidget*)parentTab->parent();
01041   }
01042   else
01043   {
01044 //      kdDebug(282)<<"Looking for  KDockContainer"<<endl;
01045     QWidget *contWid=target->parentDockContainer();
01046       if (!contWid) contWid=target->widget;
01047       if (contWid)
01048       {
01049         KDockContainer *cont=dynamic_cast<KDockContainer*>(contWid);
01050           if (cont)
01051           {
01052             if (latestKDockContainer() && (latestKDockContainer()!=contWid)) {
01053                 KDockContainer* dc = dynamic_cast<KDockContainer*>(latestKDockContainer());
01054                 if (dc) {
01055                     dc->removeWidget(this);
01056                 }
01057             }
01058 //          kdDebug(282)<<"KDockContainerFound"<<endl;
01059             applyToWidget( contWid );
01060             cont->insertWidget( this, icon() ? *icon() : QPixmap(),
01061                         tabPageLabel(), tabIndex );
01062             setLatestKDockContainer(contWid);
01063 //          setDockTabName( parentTab );
01064             if( !toolTipStr.isEmpty())
01065             cont->setToolTip( this, toolTipStr);
01066 
01067             currentDockPos = KDockWidget::DockCenter;
01068             emit manager->change();
01069             return (KDockWidget*)(cont->parentDockWidget());
01070 
01071           }
01072       }
01073   }
01074 
01075   // create a new dockwidget that will contain the target and this
01076   QWidget* parentDock = target->parentWidget();
01077   KDockWidget* newDock = new KDockWidget( manager, "tempName", QPixmap(""), parentDock );
01078   newDock->currentDockPos = target->currentDockPos;
01079 
01080   if ( dockPos == KDockWidget::DockCenter ){
01081     newDock->isTabGroup = true;
01082   } else {
01083     newDock->isGroup = true;
01084   }
01085   newDock->eDocking = (target->eDocking & eDocking) & (~(int)KDockWidget::DockCenter);
01086 
01087   newDock->applyToWidget( parentDock );
01088 
01089   if ( !parentDock ){
01090     // dock to a toplevel dockwidget means newDock is toplevel now
01091     newDock->move( target->frameGeometry().topLeft() );
01092     newDock->resize( target->geometry().size() );
01093     if ( target->isVisibleToTLW() ) newDock->show();
01094   }
01095 
01096   // redirect the dockback button to the new dockwidget
01097   if( target->formerBrotherDockWidget ) {
01098     newDock->setFormerBrotherDockWidget(target->formerBrotherDockWidget);
01099     if( formerBrotherDockWidget )
01100       target->loseFormerBrotherDockWidget();
01101     }
01102   newDock->formerDockPos = target->formerDockPos;
01103 
01104 
01105  // HERE SOMETING CREATING CONTAINERS SHOULD BE ADDED !!!!!
01106   if ( dockPos == KDockWidget::DockCenter )
01107   {
01108     KDockTabGroup* tab = new KDockTabGroup( newDock, "_dock_tab");
01109     QObject::connect(tab, SIGNAL(currentChanged(QWidget*)), d, SLOT(slotFocusEmbeddedWidget(QWidget*)));
01110     newDock->setWidget( tab );
01111 
01112     target->applyToWidget( tab );
01113     applyToWidget( tab );
01114 
01115 
01116     tab->insertTab( target, target->icon() ? *(target->icon()) : QPixmap(),
01117                     target->tabPageLabel() );
01118 
01119 
01120 
01121     if( !target->toolTipString().isEmpty())
01122      tab->setTabToolTip( target, target->toolTipString());
01123 
01124     tab->insertTab( this, icon() ? *icon() : QPixmap(),
01125                     tabPageLabel(), tabIndex );
01126 
01127     QRect geom=newDock->geometry();
01128     QWidget *wantTransient=tab->transientTo();
01129     newDock->setDockWindowTransient(wantTransient,wantTransient);
01130     newDock->setGeometry(geom);
01131 
01132     if( !toolTipString().isEmpty())
01133       tab->setTabToolTip( this, toolTipString());
01134 
01135     setDockTabName( tab );
01136     tab->show();
01137 
01138     currentDockPos = DockCenter;
01139     target->formerDockPos = target->currentDockPos;
01140     target->currentDockPos = DockCenter;
01141   }
01142   else {
01143     // if to dock not to the center of the target dockwidget,
01144     // dock to newDock
01145     KDockSplitter* panner = 0L;
01146     if ( dockPos == KDockWidget::DockTop  || dockPos == KDockWidget::DockBottom ) panner = new KDockSplitter( newDock, "_dock_split_", Horizontal, spliPos, manager->splitterHighResolution() );
01147     if ( dockPos == KDockWidget::DockLeft || dockPos == KDockWidget::DockRight  ) panner = new KDockSplitter( newDock, "_dock_split_", Vertical , spliPos, manager->splitterHighResolution() );
01148     newDock->setWidget( panner );
01149 
01150     panner->setOpaqueResize(manager->splitterOpaqueResize());
01151     panner->setKeepSize(manager->splitterKeepSize());
01152     panner->setFocusPolicy( NoFocus );
01153     target->applyToWidget( panner );
01154     applyToWidget( panner );
01155     target->formerDockPos = target->currentDockPos;
01156     if ( dockPos == KDockWidget::DockRight) {
01157       panner->activate( target, this );
01158       currentDockPos = KDockWidget::DockRight;
01159       target->currentDockPos = KDockWidget::DockLeft;
01160     }
01161     else if( dockPos == KDockWidget::DockBottom) {
01162       panner->activate( target, this );
01163       currentDockPos = KDockWidget::DockBottom;
01164       target->currentDockPos = KDockWidget::DockTop;
01165     }
01166     else if( dockPos == KDockWidget::DockTop) {
01167       panner->activate( this, target );
01168       currentDockPos = KDockWidget::DockTop;
01169       target->currentDockPos = KDockWidget::DockBottom;
01170     }
01171     else if( dockPos == KDockWidget::DockLeft) {
01172       panner->activate( this, target );
01173       currentDockPos = KDockWidget::DockLeft;
01174       target->currentDockPos = KDockWidget::DockRight;
01175     }
01176     target->show();
01177     show();
01178     panner->show();
01179   }
01180 
01181   if ( parentDock ){
01182     if ( parentDock->inherits("KDockSplitter") ){
01183       KDockSplitter* sp = (KDockSplitter*)parentDock;
01184       sp->deactivate();
01185       if ( sp->getFirst() == target )
01186         sp->activate( newDock, 0L );
01187       else
01188         sp->activate( 0L, newDock );
01189     }
01190   }
01191 
01192   newDock->show();
01193   emit target->docking( this, dockPos );
01194   emit manager->replaceDock( target, newDock );
01195   emit manager->change();
01196 
01197   return newDock;
01198 }
01199 
01200 KDockTabGroup* KDockWidget::parentDockTabGroup() const
01201 {
01202   if ( !parent() ) return 0L;
01203   QWidget* candidate = parentWidget()->parentWidget();
01204   if ( candidate && candidate->inherits("KDockTabGroup") ) return (KDockTabGroup*)candidate;
01205   return 0L;
01206 }
01207 
01208 QWidget *KDockWidget::parentDockContainer() const
01209 {
01210   if (!parent()) return 0L;
01211   QWidget* candidate = parentWidget()->parentWidget();
01212   if (candidate && dynamic_cast<KDockContainer*>(candidate)) return candidate;
01213   return 0L;
01214 }
01215 
01216 
01217 void KDockWidget::setForcedFixedWidth(int w)
01218 {
01219     d->forcedWidth=w;
01220     setFixedWidth(w);
01221     if (!parent()) return;
01222     if (parent()->inherits("KDockSplitter"))
01223         static_cast<KDockSplitter*>(parent()->qt_cast("KDockSplitter"))->setForcedFixedWidth(this,w);
01224 }
01225 
01226 void KDockWidget::setForcedFixedHeight(int h)
01227 {
01228     d->forcedHeight=h;
01229     setFixedHeight(h);
01230     if (!parent()) return;
01231     if (parent()->inherits("KDockSplitter"))
01232         static_cast<KDockSplitter*>(parent()->qt_cast("KDockSplitter"))->setForcedFixedHeight(this,h);
01233 }
01234 
01235 int KDockWidget::forcedFixedWidth()
01236 {
01237     return d->forcedWidth;
01238 }
01239 
01240 int KDockWidget::forcedFixedHeight()
01241 {
01242     return d->forcedHeight;
01243 }
01244 
01245 void KDockWidget::restoreFromForcedFixedSize()
01246 {
01247     d->forcedWidth=-1;
01248     d->forcedHeight=-1;
01249     setMinimumWidth(0);
01250     setMaximumWidth(32000);
01251     setMinimumHeight(0);
01252     setMaximumHeight(32000);
01253     if (!parent()) return;
01254     if (parent()->inherits("KDockSplitter"))
01255         static_cast<KDockSplitter*>(parent()->qt_cast("KDockSplitter"))->restoreFromForcedFixedSize(this);
01256 }
01257 
01258 void KDockWidget::toDesktop()
01259 {
01260    QPoint p = mapToGlobal( QPoint( -30, -30 ) );
01261    if( p.x( ) < 0 )
01262       p.setX( 0 );
01263    if( p.y( ) < 0 )
01264       p.setY( 0 );
01265    manualDock( 0, DockDesktop, 50, p );
01266 }
01267 
01268 KDockWidget::DockPosition KDockWidget::currentDockPosition() const
01269 {
01270     return currentDockPos;
01271 }
01272 
01273 void KDockWidget::undock()
01274 {
01275 //  kdDebug(282)<<"KDockWidget::undock()"<<endl;
01276 
01277   manager->d->dragRect = QRect ();
01278   manager->drawDragRectangle ();
01279 
01280   QWidget* parentW = parentWidget();
01281   if ( !parentW ){
01282     hide();
01283     if (!d->blockHasUndockedSignal)
01284       emit hasUndocked();
01285     return;
01286   }
01287 
01288   formerDockPos = currentDockPos;
01289   currentDockPos = KDockWidget::DockDesktop;
01290 
01291   manager->blockSignals(true);
01292   manager->undockProcess = true;
01293 
01294   bool isV = parentW->isVisibleToTLW();
01295 
01296   //UNDOCK HAS TO BE IMPLEMENTED CORRECTLY :)
01297   KDockTabGroup* parentTab = parentDockTabGroup();
01298   if ( parentTab ){
01299     d->index = parentTab->indexOf( this); // memorize the page position in the tab widget
01300     parentTab->removePage( this );
01301 /*
01302     QWidget *wantTransient=parentTab->transientTo();
01303     target->setDockWindowTransient(wantTransient,wantTransient);
01304  */
01305     setFormerBrotherDockWidget((KDockWidget*)parentTab->page(0));
01306     applyToWidget( 0L );
01307     if ( parentTab->count() == 1 ){
01308 
01309       // last subdock widget in the tab control
01310       KDockWidget* lastTab = (KDockWidget*)parentTab->page(0);
01311       parentTab->removePage( lastTab );
01312 /*      QWidget *wantTransient=parentTab->transientTo();
01313       target->setDockWindowTransient(wantTransient,wantTransient);*/
01314 
01315       lastTab->applyToWidget( 0L );
01316       lastTab->move( parentTab->mapToGlobal(parentTab->frameGeometry().topLeft()) );
01317 
01318       // KDockTabGroup always have a parent that is a KDockWidget
01319       KDockWidget* parentOfTab = (KDockWidget*)parentTab->parent();
01320       delete parentTab; // KDockTabGroup
01321 
01322       QWidget* parentOfDockWidget = parentOfTab->parentWidget();
01323       if ( !parentOfDockWidget ){
01324           if ( isV ) lastTab->show();
01325       } else {
01326         if ( parentOfDockWidget->inherits("KDockSplitter") ){
01327           KDockSplitter* split = (KDockSplitter*)parentOfDockWidget;
01328           lastTab->applyToWidget( split );
01329           split->deactivate();
01330           if ( split->getFirst() == parentOfTab ){
01331             split->activate( lastTab );
01332             if ( ((KDockWidget*)split->parent())->splitterOrientation == Vertical )
01333               emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockLeft );
01334             else
01335               emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockTop );
01336           } else {
01337             split->activate( 0L, lastTab );
01338             if ( ((KDockWidget*)split->parent())->splitterOrientation == Vertical )
01339               emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockRight );
01340             else
01341               emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockBottom );
01342           }
01343           split->show();
01344         } else {
01345           lastTab->applyToWidget( parentOfDockWidget );
01346         }
01347         lastTab->show();
01348       }
01349       manager->blockSignals(false);
01350       emit manager->replaceDock( parentOfTab, lastTab );
01351       lastTab->currentDockPos = parentOfTab->currentDockPos;
01352       emit parentOfTab->iMBeingClosed();
01353       manager->blockSignals(true);
01354       delete parentOfTab;
01355 
01356     } else {
01357       setDockTabName( parentTab );
01358     }
01359   } else {
01360  /*********************************************************************************************/
01361   //QWidget* containerWidget = (QWidget*)parent();
01362   bool undockedFromContainer=false;
01363   if (d->container)
01364   {
01365 //    kdDebug(282)<<"undocked from dockcontainer"<<endl;
01366       undockedFromContainer=true;
01367       KDockContainer* dc = dynamic_cast<KDockContainer*>(d->container.operator->());
01368       if (dc) {
01369           dc->undockWidget(this);
01370           setFormerBrotherDockWidget(dc->parentDockWidget());
01371       }
01372       applyToWidget( 0L );
01373   }
01374    if (!undockedFromContainer) {
01375 /*********************************************************************************************/
01376     if ( parentW->inherits("KDockSplitter") ){
01377       KDockSplitter* parentSplitterOfDockWidget = (KDockSplitter*)parentW;
01378       d->splitPosInPercent = parentSplitterOfDockWidget->separatorPos();
01379 
01380       KDockWidget* secondWidget = (KDockWidget*)parentSplitterOfDockWidget->getAnother( this );
01381       KDockWidget* group        = (KDockWidget*)parentSplitterOfDockWidget->parentWidget();
01382       setFormerBrotherDockWidget(secondWidget);
01383       applyToWidget( 0L );
01384       group->hide();
01385 
01386       if ( !group->parentWidget() ){
01387         secondWidget->applyToWidget( 0L, group->frameGeometry().topLeft() );
01388         secondWidget->resize( group->width(), group->height() );
01389       } else {
01390         QWidget* obj = group->parentWidget();
01391         secondWidget->applyToWidget( obj );
01392         if ( obj->inherits("KDockSplitter") ){
01393           KDockSplitter* parentOfGroup = (KDockSplitter*)obj;
01394           parentOfGroup->deactivate();
01395 
01396           if ( parentOfGroup->getFirst() == group )
01397             parentOfGroup->activate( secondWidget );
01398           else
01399             parentOfGroup->activate( 0L, secondWidget );
01400         }
01401       }
01402       secondWidget->currentDockPos = group->currentDockPos;
01403       secondWidget->formerDockPos  = group->formerDockPos;
01404       delete parentSplitterOfDockWidget;
01405       manager->blockSignals(false);
01406       emit manager->replaceDock( group, secondWidget );
01407       emit group->iMBeingClosed();
01408       manager->blockSignals(true);
01409       delete group;
01410 
01411       if ( isV ) secondWidget->show();
01412     } else {
01413       if (!d->pendingDtor) {
01414         // don't reparent in the dtor of this
01415         applyToWidget( 0L );
01416       }
01417     }
01418 /*********************************************************************************************/
01419   }
01420   }
01421   manager->blockSignals(false);
01422   if (!d->blockHasUndockedSignal)
01423     emit manager->change();
01424   manager->undockProcess = false;
01425 
01426   if (!d->blockHasUndockedSignal)
01427     emit hasUndocked();
01428 }
01429 
01430 void KDockWidget::setWidget( QWidget* mw )
01431 {
01432   if ( !mw ) return;
01433 
01434   if ( mw->parent() != this ){
01435     mw->reparent(this, 0, QPoint(0,0), false);
01436   }
01437 
01438 #ifdef BORDERLESS_WINDOWS
01439   if (!mw->ownCursor()) mw->setCursor(QCursor(ArrowCursor));
01440 #endif
01441   widget = mw;
01442   delete layout;
01443 
01444   layout = new QVBoxLayout( this );
01445   layout->setResizeMode( QLayout::Minimum );
01446 
01447   KDockContainer* dc = dynamic_cast<KDockContainer*>(widget);
01448   if (dc)
01449   {
01450     d->isContainer=true;
01451     manager->d->containerDocks.append(this);
01452   }
01453   else
01454   {
01455     d->isContainer=false;
01456   }
01457 
01458   {
01459      header->show();
01460      layout->addWidget( header );
01461      layout->addWidget( widget,1 );
01462   }
01463   updateHeader();
01464   emit widgetSet(mw);
01465 }
01466 
01467 void KDockWidget::setDockTabName( KDockTabGroup* tab )
01468 {
01469   QString listOfName;
01470   QString listOfCaption;
01471   for ( int i = 0; i < tab->count(); ++i ) {
01472     QWidget *w = tab->page( i );
01473     listOfCaption.append( w->caption() ).append(",");
01474     listOfName.append( w->name() ).append(",");
01475   }
01476   listOfCaption.remove( listOfCaption.length()-1, 1 );
01477   listOfName.remove( listOfName.length()-1, 1 );
01478 
01479   tab->parentWidget()->setName( listOfName.utf8() );
01480   tab->parentWidget()->setCaption( listOfCaption );
01481 
01482   tab->parentWidget()->repaint( false ); // KDockWidget->repaint
01483   if ( tab->parentWidget()->parent() )
01484     if ( tab->parentWidget()->parent()->inherits("KDockSplitter") )
01485       ((KDockSplitter*)(tab->parentWidget()->parent()))->updateName();
01486 }
01487 
01488 bool KDockWidget::mayBeHide() const
01489 {
01490   bool f = (parent() != manager->main);
01491   return ( !isGroup && !isTabGroup && f && isVisible() && ( eDocking != (int)KDockWidget::DockNone ) );
01492 }
01493 
01494 bool KDockWidget::mayBeShow() const
01495 {
01496   bool f = (parent() != manager->main);
01497   return ( !isGroup && !isTabGroup && f && !isVisible() );
01498 }
01499 
01500 void KDockWidget::changeHideShowState()
01501 {
01502   if ( mayBeHide() ){
01503     undock();
01504     return;
01505   }
01506 
01507   if ( mayBeShow() ){
01508     if ( manager->main->inherits("KDockMainWindow") ){
01509       ((KDockMainWindow*)manager->main)->makeDockVisible(this);
01510     } else {
01511       makeDockVisible();
01512     }
01513   }
01514 }
01515 
01516 void KDockWidget::makeDockVisible()
01517 {
01518   if ( parentDockTabGroup() ){
01519     parentDockTabGroup()->showPage( this );
01520   }
01521   if (parentDockContainer()) {
01522     QWidget *contWid=parentDockContainer();
01523     KDockContainer *x = dynamic_cast<KDockContainer*>(contWid);
01524     if (x) {
01525       x->showWidget(this);
01526     }
01527   }
01528   if ( isVisible() ) return;
01529 
01530   QWidget* p = parentWidget();
01531   while ( p ){
01532     if ( !p->isVisible() )
01533       p->show();
01534     p = p->parentWidget();
01535   }
01536   if( !parent() ) // is undocked
01537     dockBack();
01538   show();
01539 }
01540 
01541 void KDockWidget::setFormerBrotherDockWidget(KDockWidget *dockWidget)
01542 {
01543   formerBrotherDockWidget = dockWidget;
01544   if( formerBrotherDockWidget )
01545     QObject::connect( formerBrotherDockWidget, SIGNAL(iMBeingClosed()),
01546                       this, SLOT(loseFormerBrotherDockWidget()) );
01547 }
01548 
01549 void KDockWidget::loseFormerBrotherDockWidget()
01550 {
01551   if( formerBrotherDockWidget )
01552     QObject::disconnect( formerBrotherDockWidget, SIGNAL(iMBeingClosed()),
01553                          this, SLOT(loseFormerBrotherDockWidget()) );
01554   formerBrotherDockWidget = 0L;
01555   repaint();
01556 }
01557 
01558 void KDockWidget::dockBack()
01559 {
01560   if( formerBrotherDockWidget) {
01561     // search all children if it tries to dock back to a child
01562     bool found = false;
01563     QObjectList* cl = queryList("KDockWidget");
01564     QObjectListIt it( *cl );
01565     QObject * obj;
01566     while ( !found && (obj=it.current()) != 0 ) {
01567       ++it;
01568       QWidget* widg = (QWidget*)obj;
01569       if( widg == formerBrotherDockWidget)
01570         found = true;
01571     }
01572     delete cl;
01573 
01574     if( !found) {
01575       // can dock back to the former brother dockwidget
01576       manualDock( formerBrotherDockWidget, formerDockPos, d->splitPosInPercent, QPoint(0,0), false, d->index);
01577       formerBrotherDockWidget = 0L;
01578       makeDockVisible();
01579       return;
01580     }
01581   }
01582 
01583   // else dockback to the dockmainwindow (default behavior)
01584   manualDock( ((KDockMainWindow*)manager->main)->getMainDockWidget(), formerDockPos, d->splitPosInPercent, QPoint(0,0), false, d->index);
01585   formerBrotherDockWidget = 0L;
01586   if (parent())
01587     makeDockVisible();
01588 }
01589 
01590 bool KDockWidget::isDockBackPossible() const
01591 {
01592   if( !(formerBrotherDockWidget) || !(formerBrotherDockWidget->dockSite() & formerDockPos))
01593     return false;
01594   else
01595     return true;
01596 }
01597 
01598 /**************************************************************************************/
01599 
01600 
01601 KDockManager::KDockManager( QWidget* mainWindow , const char* name )
01602 :QObject( mainWindow, name )
01603   ,main(mainWindow)
01604   ,currentDragWidget(0L)
01605   ,currentMoveWidget(0L)
01606   ,childDockWidgetList(0L)
01607   ,autoCreateDock(0L)
01608   ,storeW(0)
01609   ,storeH(0)
01610   ,dragging(false)
01611   ,undockProcess(false)
01612   ,dropCancel(true)
01613 {
01614   d = new KDockManagerPrivate;
01615 
01616   d->readyToDrag = false;
01617   d->mainDockWidget=0;
01618 
01619 #ifndef NO_KDE2
01620   d->splitterOpaqueResize = KGlobalSettings::opaqueResize();
01621 #else
01622   d->splitterOpaqueResize = false;
01623 #endif
01624 
01625   d->splitterKeepSize = false;
01626   d->splitterHighResolution = false;
01627   d->m_readDockConfigMode = WrapExistingWidgetsOnly; // default as before
01628 
01629   main->installEventFilter( this );
01630 
01631   undockProcess = false;
01632 
01633   menuData = new QPtrList<MenuDockData>;
01634   menuData->setAutoDelete( true );
01635   menuData->setAutoDelete( true );
01636 
01637 #ifndef NO_KDE2
01638   menu = new KPopupMenu();
01639 #else
01640   menu = new QPopupMenu();
01641 #endif
01642 
01643   connect( menu, SIGNAL(aboutToShow()), SLOT(slotMenuPopup()) );
01644   connect( menu, SIGNAL(activated(int)), SLOT(slotMenuActivated(int)) );
01645 
01646   childDock = new QObjectList();
01647   childDock->setAutoDelete( false );
01648 }
01649 
01650 
01651 void KDockManager::setMainDockWidget2(KDockWidget *w)
01652 {
01653   d->mainDockWidget=w;
01654 }
01655 
01656 KDockManager::~KDockManager()
01657 {
01658   delete menuData;
01659   delete menu;
01660 
01661   QObjectListIt it( *childDock );
01662   KDockWidget * obj;
01663 
01664   while ( (obj=(KDockWidget*)it.current()) ) {
01665     delete obj;
01666   }
01667   delete childDock;
01668   delete d;
01669   d=0;
01670 }
01671 
01672 void KDockManager::activate()
01673 {
01674   QObjectListIt it( *childDock );
01675   KDockWidget * obj;
01676 
01677   while ( (obj=(KDockWidget*)it.current()) ) {
01678     ++it;
01679     if ( obj->widget ) obj->widget->show();
01680     if ( !obj->parentDockTabGroup() ){
01681         obj->show();
01682     }
01683   }
01684   if ( !main->inherits("QDialog") ) main->show();
01685 }
01686 
01687 bool KDockManager::eventFilter( QObject *obj, QEvent *event )
01688 {
01689 
01690   if ( obj->inherits("KDockWidgetAbstractHeaderDrag") ){
01691     KDockWidget* pDockWdgAtCursor = 0L;
01692     KDockWidget* curdw = ((KDockWidgetAbstractHeaderDrag*)obj)->dockWidget();
01693     switch ( event->type() ){
01694       case QEvent::MouseButtonDblClick:
01695         if (curdw->currentDockPos == KDockWidget::DockDesktop)  curdw->dockBack();
01696         else
01697     {
01698         curdw->toDesktop();
01699         // curdw->manualDock (0, KDockWidget::DockDesktop);
01700     }
01701         break;
01702 
01703       case QEvent::MouseButtonPress:
01704         if ( ((QMouseEvent*)event)->button() == LeftButton ){
01705           if ( curdw->eDocking != (int)KDockWidget::DockNone ){
01706             dropCancel = true;
01707             curdw->setFocus();
01708             qApp->processOneEvent();
01709 
01710             currentDragWidget = curdw;
01711             currentMoveWidget = 0L;
01712             childDockWidgetList = new QWidgetList();
01713             childDockWidgetList->append( curdw );
01714             findChildDockWidget( curdw, childDockWidgetList );
01715 
01716             //d->oldDragRect = QRect(); should fix rectangle not erased problem
01717             d->dragRect = QRect(curdw->geometry());
01718             QPoint p = curdw->mapToGlobal(QPoint(0,0));
01719             d->dragRect.moveTopLeft(p);
01720             drawDragRectangle();
01721             d->readyToDrag = true;
01722 
01723             d->dragOffset = QCursor::pos()-currentDragWidget->mapToGlobal(QPoint(0,0));
01724           }
01725 
01726         }
01727         break;
01728       case QEvent::MouseButtonRelease:
01729         if ( ((QMouseEvent*)event)->button() == LeftButton ){
01730           if ( dragging ){
01731             if ( !dropCancel )
01732               drop();
01733             else
01734               cancelDrop();
01735           }
01736           if (d->readyToDrag) {
01737               d->readyToDrag = false;
01738               //d->oldDragRect = QRect(); should fix rectangle not erased problem
01739               d->dragRect = QRect(curdw->geometry());
01740               QPoint p = curdw->mapToGlobal(QPoint(0,0));
01741               d->dragRect.moveTopLeft(p);
01742               drawDragRectangle();
01743               currentDragWidget = 0L;
01744               delete childDockWidgetList;
01745               childDockWidgetList = 0L;
01746           }
01747           dragging = false;
01748           dropCancel = true;
01749         }
01750         break;
01751       case QEvent::MouseMove:
01752         if ( dragging ) {
01753 
01754 #ifdef BORDERLESS_WINDOWS
01755 //BEGIN TEST
01756       KDockWidget *oldMoveWidget;
01757       if (!curdw->parent())
01758       {
01759         curdw->move(QCursor::pos()-d->dragOffset);
01760             pDockWdgAtCursor = findDockWidgetAt( QCursor::pos()-QPoint(0,d->dragOffset.y()+3) );
01761                 oldMoveWidget = currentMoveWidget;
01762       }
01763       else
01764       {
01765             pDockWdgAtCursor = findDockWidgetAt( QCursor::pos() );
01766                 oldMoveWidget = currentMoveWidget;
01767       }
01768 //END TEST
01769 #else
01770       pDockWdgAtCursor = findDockWidgetAt( QCursor::pos() );
01771           KDockWidget* oldMoveWidget = currentMoveWidget;
01772 #endif
01773 
01774       if ( currentMoveWidget  && pDockWdgAtCursor == currentMoveWidget ) { //move
01775             dragMove( currentMoveWidget, currentMoveWidget->mapFromGlobal( QCursor::pos() ) );
01776             break;
01777           } else {
01778             if (dropCancel && curdw) {
01779               d->dragRect = QRect(curdw->geometry());
01780               QPoint p = curdw->mapToGlobal(QPoint(0,0));
01781               d->dragRect.moveTopLeft(p);
01782             }else
01783               d->dragRect = QRect();
01784 
01785             drawDragRectangle();
01786           }
01787 
01788           if ( !pDockWdgAtCursor && !(curdw->eDocking & (int)KDockWidget::DockDesktop) ){
01789               // just moving at the desktop
01790               currentMoveWidget = pDockWdgAtCursor;
01791               curPos = KDockWidget::DockDesktop;
01792           } else {
01793             if ( oldMoveWidget && pDockWdgAtCursor != currentMoveWidget ) { //leave
01794               currentMoveWidget = pDockWdgAtCursor;
01795               curPos = KDockWidget::DockDesktop;
01796             }
01797           }
01798 
01799           if ( oldMoveWidget != pDockWdgAtCursor && pDockWdgAtCursor ) { //enter pDockWdgAtCursor
01800             currentMoveWidget = pDockWdgAtCursor;
01801             curPos = KDockWidget::DockDesktop;
01802           }
01803         } else {
01804           if (d->readyToDrag) {
01805             d->readyToDrag = false;
01806           }
01807           if ( (((QMouseEvent*)event)->state() == LeftButton) &&
01808                (curdw->eDocking != (int)KDockWidget::DockNone) ) {
01809             startDrag( curdw);
01810           }
01811         }
01812     break;
01813       default:
01814         break;
01815     }
01816   }
01817   return QObject::eventFilter( obj, event );
01818 }
01819 
01820 KDockWidget* KDockManager::findDockWidgetAt( const QPoint& pos )
01821 {
01822   dropCancel = true;
01823 
01824   if (!currentDragWidget)
01825     return 0L; // pointer access safety
01826 
01827   if (currentDragWidget->eDocking == (int)KDockWidget::DockNone ) return 0L;
01828 
01829   QWidget* p = QApplication::widgetAt( pos );
01830   if ( !p ) {
01831     dropCancel = false;
01832     return 0L;
01833   }
01834 #if defined(_OS_WIN32_) || defined(Q_OS_WIN32)
01835   p = p->topLevelWidget();
01836 #endif
01837   QWidget* w = 0L;
01838   findChildDockWidget( w, p, p->mapFromGlobal(pos) );
01839   if ( !w ){
01840     if ( !p->inherits("KDockWidget") ) {
01841       return 0L;
01842     }
01843     w = p;
01844   }
01845   if ( qt_find_obj_child( w, "KDockSplitter", "_dock_split_" ) ) return 0L;
01846   if ( qt_find_obj_child( w, "KDockTabGroup", "_dock_tab" ) ) return 0L;
01847   if (dynamic_cast<KDockContainer*>(w)) return 0L;
01848 
01849   if (!childDockWidgetList) return 0L;
01850   if ( childDockWidgetList->find(w) != -1 ) return 0L;
01851   if ( currentDragWidget->isGroup && ((KDockWidget*)w)->parentDockTabGroup() ) return 0L;
01852 
01853   KDockWidget* www = (KDockWidget*)w;
01854   if ( www->sDocking == (int)KDockWidget::DockNone ) return 0L;
01855   if( !www->widget )
01856     return 0L;
01857 
01858   KDockWidget::DockPosition curPos = KDockWidget::DockDesktop;
01859   QPoint cpos  = www->mapFromGlobal( pos );
01860 
01861   int ww = www->widget->width() / 3;
01862   int hh = www->widget->height() / 3;
01863 
01864   if ( cpos.y() <= hh ){
01865     curPos = KDockWidget::DockTop;
01866   } else
01867     if ( cpos.y() >= 2*hh ){
01868       curPos = KDockWidget::DockBottom;
01869     } else
01870       if ( cpos.x() <= ww ){
01871         curPos = KDockWidget::DockLeft;
01872       } else
01873         if ( cpos.x() >= 2*ww ){
01874           curPos = KDockWidget::DockRight;
01875         } else
01876             curPos = KDockWidget::DockCenter;
01877 
01878   if ( !(www->sDocking & (int)curPos) ) return 0L;
01879   if ( !(currentDragWidget->eDocking & (int)curPos) ) return 0L;
01880   if ( www->manager != this ) return 0L;
01881 
01882   dropCancel = false;
01883   return www;
01884 }
01885 
01886 void KDockManager::findChildDockWidget( QWidget*& ww, const QWidget* p, const QPoint& pos )
01887 {
01888   if ( p->children() ) {
01889     QWidget *w;
01890     QObjectListIt it( *p->children() );
01891     it.toLast();
01892     while ( it.current() ) {
01893       if ( it.current()->isWidgetType() ) {
01894         w = (QWidget*)it.current();
01895         if ( w->isVisible() && w->geometry().contains(pos) ) {
01896           if ( w->inherits("KDockWidget") ) ww = w;
01897           findChildDockWidget( ww, w, w->mapFromParent(pos) );
01898           return;
01899         }
01900       }
01901       --it;
01902     }
01903   }
01904   return;
01905 }
01906 
01907 void KDockManager::findChildDockWidget( const QWidget* p, QWidgetList*& list )
01908 {
01909   if ( p->children() ) {
01910     QWidget *w;
01911     QObjectListIt it( *p->children() );
01912     it.toLast();
01913     while ( it.current() ) {
01914       if ( it.current()->isWidgetType() ) {
01915         w = (QWidget*)it.current();
01916         if ( w->isVisible() ) {
01917           if ( w->inherits("KDockWidget") ) list->append( w );
01918           findChildDockWidget( w, list );
01919         }
01920       }
01921       --it;
01922     }
01923   }
01924   return;
01925 }
01926 
01927 void KDockManager::startDrag( KDockWidget* w )
01928 {
01929   if(( w->currentDockPos == KDockWidget::DockLeft) || ( w->currentDockPos == KDockWidget::DockRight)
01930    || ( w->currentDockPos == KDockWidget::DockTop) || ( w->currentDockPos == KDockWidget::DockBottom)) {
01931     w->prevSideDockPosBeforeDrag = w->currentDockPos;
01932 
01933     if ( w->parentWidget()->inherits("KDockSplitter") ){
01934       KDockSplitter* parentSplitterOfDockWidget = (KDockSplitter*)(w->parentWidget());
01935       w->d->splitPosInPercent = parentSplitterOfDockWidget->separatorPos();
01936     }
01937   }
01938 
01939   curPos = KDockWidget::DockDesktop;
01940   dragging = true;
01941 
01942   QApplication::setOverrideCursor(QCursor(sizeAllCursor));
01943 }
01944 
01945 void KDockManager::dragMove( KDockWidget* dw, QPoint pos )
01946 {
01947   QPoint p = dw->mapToGlobal( dw->widget->pos() );
01948   KDockWidget::DockPosition oldPos = curPos;
01949 
01950   QSize r = dw->widget->size();
01951   if ( dw->parentDockTabGroup() ){
01952     curPos = KDockWidget::DockCenter;
01953     if ( oldPos != curPos ) {
01954       d->dragRect.setRect( p.x()+2, p.y()+2, r.width()-4, r.height()-4 );
01955     }
01956     return;
01957   }
01958 
01959   int w = r.width() / 3;
01960   int h = r.height() / 3;
01961 
01962   if ( pos.y() <= h ){
01963     curPos = KDockWidget::DockTop;
01964     w = r.width();
01965   } else
01966     if ( pos.y() >= 2*h ){
01967       curPos = KDockWidget::DockBottom;
01968       p.setY( p.y() + 2*h );
01969       w = r.width();
01970     } else
01971       if ( pos.x() <= w ){
01972         curPos = KDockWidget::DockLeft;
01973         h = r.height();
01974       } else
01975         if ( pos.x() >= 2*w ){
01976           curPos = KDockWidget::DockRight;
01977           p.setX( p.x() + 2*w );
01978           h = r.height();
01979         } else
01980           {
01981             curPos = KDockWidget::DockCenter;
01982             p.setX( p.x() + w );
01983             p.setY( p.y() + h );
01984           }
01985 
01986   if ( oldPos != curPos ) {
01987     d->dragRect.setRect( p.x(), p.y(), w, h );
01988     drawDragRectangle();
01989   }
01990 }
01991 
01992 
01993 void KDockManager::cancelDrop()
01994 {
01995   QApplication::restoreOverrideCursor();
01996 
01997   delete childDockWidgetList;
01998   childDockWidgetList = 0L;
01999 
02000   d->dragRect = QRect();  // cancel drawing
02001   drawDragRectangle();    // only the old rect will be deleted
02002 }
02003 
02004 
02005 void KDockManager::drop()
02006 {
02007   d->dragRect = QRect();  // cancel drawing
02008   drawDragRectangle();    // only the old rect will be deleted
02009 
02010   QApplication::restoreOverrideCursor();
02011 
02012   delete childDockWidgetList;
02013   childDockWidgetList = 0L;
02014 
02015   if ( dropCancel ) return;
02016   if ( !currentMoveWidget && (!(currentDragWidget->eDocking & (int)KDockWidget::DockDesktop)) ) {
02017     d->dragRect = QRect();  // cancel drawing
02018     drawDragRectangle();    // only the old rect will be deleted
02019     return;
02020   }
02021   if ( !currentMoveWidget && !currentDragWidget->parent() ) {
02022     currentDragWidget->move( QCursor::pos() - d->dragOffset );
02023   }
02024   else {
02025     // curPos is the current target DockPosition.
02026     // currentDragWidget->prevSideDockPosBeforeDrag is where the dockwidget comes from.
02027     // currentDragWidget->formerDockPos is the position *before* the dockwidget was in
02028     // position currentDragWidget->prevSideDockPosBeforeDrag.
02029     int splitPos = currentDragWidget->d->splitPosInPercent;
02030     KDockWidget::DockPosition previousPosition = currentDragWidget->prevSideDockPosBeforeDrag;
02031 
02032 //    kdDebug() << splitPos << endl;
02033 //    kdDebug() << "curPos: " << curPos << endl;
02034 //    kdDebug() << "formerDockPos: " << currentDragWidget->formerDockPos<< endl;
02035 //    kdDebug() << "prevSideDockPosBeforeDrag: " << currentDragWidget->prevSideDockPosBeforeDrag<< endl;
02036 
02037     // Now we *need* to "invert" the procentual value, if the dockwidget moves from top/left
02038     // to bottom/right or vice versa. This keeps the dockwidget's size on its new position.
02039     // A special case is, when the dock position was DockNone, then we have to look for the
02040     // formerDockPos to get things right.
02041     if( (curPos != previousPosition)
02042        && (curPos != KDockWidget::DockCenter) && (curPos != KDockWidget::DockDesktop)) {
02043 
02044       if (previousPosition == KDockWidget::DockNone)
02045         previousPosition = currentDragWidget->formerDockPos;
02046 
02047       switch( previousPosition ) {
02048       case KDockWidget::DockLeft:
02049         if(curPos != KDockWidget::DockTop && curPos != KDockWidget::DockLeft)
02050           splitPos = 100 - splitPos;
02051         break;
02052 
02053       case KDockWidget::DockRight:
02054         if(curPos != KDockWidget::DockBottom && curPos != KDockWidget::DockRight)
02055           splitPos = 100 - splitPos;
02056         break;
02057 
02058       case KDockWidget::DockTop:
02059         if(curPos != KDockWidget::DockLeft && curPos != KDockWidget::DockTop )
02060           splitPos = 100 - splitPos;
02061         break;
02062 
02063       case KDockWidget::DockBottom:
02064         if(curPos != KDockWidget::DockRight && curPos != KDockWidget::DockBottom )
02065           splitPos = 100 - splitPos;
02066         break;
02067 
02068       default: break;
02069       }
02070     }
02071     // set new prevSideDockPosBeforeDrag
02072     currentDragWidget->prevSideDockPosBeforeDrag = curPos;
02073     currentDragWidget->manualDock( currentMoveWidget, curPos , splitPos, QCursor::pos() - d->dragOffset );
02074     currentDragWidget->makeDockVisible();
02075   }
02076 }
02077 
02078 
02079 static QDomElement createStringEntry(QDomDocument &doc, const QString &tagName, const QString &str)
02080 {
02081     QDomElement el = doc.createElement(tagName);
02082 
02083     el.appendChild(doc.createTextNode(str));
02084     return el;
02085 }
02086 
02087 
02088 static QDomElement createBoolEntry(QDomDocument &doc, const QString &tagName, bool b)
02089 {
02090     return createStringEntry(doc, tagName, QString::fromLatin1(b? "true" : "false"));
02091 }
02092 
02093 
02094 static QDomElement createNumberEntry(QDomDocument &doc, const QString &tagName, int n)
02095 {
02096     return createStringEntry(doc, tagName, QString::number(n));
02097 }
02098 
02099 
02100 static QDomElement createRectEntry(QDomDocument &doc, const QString &tagName, const QRect &rect)
02101 {
02102     QDomElement el = doc.createElement(tagName);
02103 
02104     QDomElement xel = doc.createElement("x");
02105     xel.appendChild(doc.createTextNode(QString::number(rect.x())));
02106     el.appendChild(xel);
02107     QDomElement yel = doc.createElement("y");
02108     yel.appendChild(doc.createTextNode(QString::number(rect.y())));
02109     el.appendChild(yel);
02110     QDomElement wel = doc.createElement("width");
02111     wel.appendChild(doc.createTextNode(QString::number(rect.width())));
02112     el.appendChild(wel);
02113     QDomElement hel = doc.createElement("height");
02114     hel.appendChild(doc.createTextNode(QString::number(rect.height())));
02115     el.appendChild(hel);
02116 
02117     return el;
02118 }
02119 
02120 
02121 static QDomElement createListEntry(QDomDocument &doc, const QString &tagName,
02122                                    const QString &subTagName, const QStrList &list)
02123 {
02124     QDomElement el = doc.createElement(tagName);
02125 
02126     QStrListIterator it(list);
02127     for (; it.current(); ++it) {
02128         QDomElement subel = doc.createElement(subTagName);
02129         subel.appendChild(doc.createTextNode(QString::fromLatin1(it.current())));
02130         el.appendChild(subel);
02131     }
02132 
02133     return el;
02134 }
02135 
02136 
02137 static QString stringEntry(QDomElement &base, const QString &tagName)
02138 {
02139     return base.namedItem(tagName).firstChild().toText().data();
02140 }
02141 
02142 
02143 static bool boolEntry(QDomElement &base, const QString &tagName)
02144 {
02145     return base.namedItem(tagName).firstChild().toText().data() == "true";
02146 }
02147 
02148 
02149 static int numberEntry(QDomElement &base, const QString &tagName)
02150 {
02151     return stringEntry(base, tagName).toInt();
02152 }
02153 
02154 
02155 static QRect rectEntry(QDomElement &base, const QString &tagName)
02156 {
02157     QDomElement el = base.namedItem(tagName).toElement();
02158 
02159     int x = numberEntry(el, "x");
02160     int y = numberEntry(el, "y");
02161     int width = numberEntry(el, "width");
02162     int height = numberEntry(el,  "height");
02163 
02164     return QRect(x, y, width, height);
02165 }
02166 
02167 
02168 static QStrList listEntry(QDomElement &base, const QString &tagName, const QString &subTagName)
02169 {
02170     QStrList list;
02171 
02172     for( QDomNode n = base.namedItem(tagName).firstChild(); !n.isNull(); n = n.nextSibling() )
02173     {
02174         QDomElement subel = n.toElement();
02175         if (subel.tagName() == subTagName)
02176             list.append(subel.firstChild().toText().data().latin1());
02177     }
02178 
02179     return list;
02180 }
02181 
02182 
02183 void KDockManager::writeConfig(QDomElement &base)
02184 {
02185     // First of all, clear the tree under base
02186     while (!base.firstChild().isNull())
02187         base.removeChild(base.firstChild());
02188     QDomDocument doc = base.ownerDocument();
02189 
02190     QStrList nameList;
02191     QString mainWidgetStr;
02192 
02193     // collect widget names
02194     QStringList nList;
02195     QObjectListIt it(*childDock);
02196     KDockWidget *obj1;
02197     while ( (obj1=(KDockWidget*)it.current()) ) {
02198         if ( obj1->parent() == main )
02199             mainWidgetStr = QString::fromLatin1(obj1->name());
02200         nList.append(obj1->name());
02201         ++it;
02202     }
02203 
02204     for (QObjectListIt it(d->containerDocks);it.current();++it)
02205     {
02206         KDockContainer* dc = dynamic_cast<KDockContainer*>(((KDockWidget*)it.current())->widget);
02207         if (dc) {
02208                 dc->prepareSave(nList);
02209         }
02210     }
02211 
02212     QStringList::Iterator nListIt=nList.begin();
02213     while ( nListIt!=nList.end() ) {
02214         KDockWidget *obj = getDockWidgetFromName( *nListIt);
02215         if ((obj->isGroup && (!obj->d->isContainer)) && (nameList.find( obj->firstName.latin1() ) == -1
02216                              || nameList.find(obj->lastName.latin1()) == -1)) {
02217             // Skip until children are saved (why?)
02218             ++nListIt;
02219 //            nList.next();
02220 //falk?            if ( !nList.current() ) nList.first();
02221             continue;
02222         }
02223 
02224         QDomElement groupEl;
02225     if (obj->d->isContainer) {
02226             KDockContainer* x = dynamic_cast<KDockContainer*>(obj->widget);
02227             if (x) {
02228             groupEl=doc.createElement("dockContainer");
02229                 x->save(groupEl);
02230             }
02231         } else
02232         if (obj->isGroup) {
02234             groupEl = doc.createElement("splitGroup");
02235 
02236             groupEl.appendChild(createStringEntry(doc, "firstName", obj->firstName));
02237             groupEl.appendChild(createStringEntry(doc, "secondName", obj->lastName));
02238             groupEl.appendChild(createNumberEntry(doc, "orientation", (int)obj->splitterOrientation));
02239             groupEl.appendChild(createNumberEntry(doc, "separatorPos", ((KDockSplitter*)obj->widget)->separatorPos()));
02240         } else if (obj->isTabGroup) {
02242             groupEl = doc.createElement("tabGroup");
02243 
02244             QStrList list;
02245             for ( int i = 0; i < ((KDockTabGroup*)obj->widget)->count(); ++i )
02246                 list.append( ((KDockTabGroup*)obj->widget)->page( i )->name() );
02247             groupEl.appendChild(createListEntry(doc, "tabs", "tab", list));
02248             groupEl.appendChild(createNumberEntry(doc, "currentTab", ((KDockTabGroup*)obj->widget)->currentPageIndex()));
02249             if (!obj->parent()) {
02250                 groupEl.appendChild(createStringEntry(doc, "dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : ""));
02251                 groupEl.appendChild(createNumberEntry(doc, "dockBackToPos", obj->formerDockPos));
02252             }
02253         } else {
02255             groupEl = doc.createElement("dock");
02256             groupEl.appendChild(createStringEntry(doc, "tabCaption", obj->tabPageLabel()));
02257             groupEl.appendChild(createStringEntry(doc, "tabToolTip", obj->toolTipString()));
02258             if (!obj->parent()) {
02259                 groupEl.appendChild(createStringEntry(doc, "dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : ""));
02260                 groupEl.appendChild(createNumberEntry(doc, "dockBackToPos", obj->formerDockPos));
02261             }
02262         }
02263 
02264         groupEl.appendChild(createStringEntry(doc, "name", QString::fromLatin1(obj->name())));
02265         groupEl.appendChild(createBoolEntry(doc, "hasParent", obj->parent()));
02266         if ( !obj->parent() ) {
02267             groupEl.appendChild(createRectEntry(doc, "geometry", QRect(main->frameGeometry().topLeft(), main->size())));
02268             groupEl.appendChild(createBoolEntry(doc, "visible", obj->isVisible()));
02269         }
02270         if (obj->header && obj->header->inherits("KDockWidgetHeader")) {
02271             KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
02272             groupEl.appendChild(createBoolEntry(doc, "dragEnabled", h->dragEnabled()));
02273         }
02274 
02275         base.appendChild(groupEl);
02276         nameList.append(obj->name());
02277         nList.remove(nListIt);
02278         nListIt=nList.begin();
02279     }
02280 
02281     if (main->inherits("KDockMainWindow")) {
02282         KDockMainWindow *dmain = (KDockMainWindow*)main;
02283         QString centralWidgetStr = QString(dmain->centralWidget()? dmain->centralWidget()->name() : "");
02284         base.appendChild(createStringEntry(doc, "centralWidget", centralWidgetStr));
02285         QString mainDockWidgetStr = QString(dmain->getMainDockWidget()? dmain->getMainDockWidget()->name() : "");
02286         base.appendChild(createStringEntry(doc, "mainDockWidget", mainDockWidgetStr));
02287     } else {
02288         base.appendChild(createStringEntry(doc, "mainWidget", mainWidgetStr));
02289     }
02290 
02291     base.appendChild(createRectEntry(doc, "geometry", QRect(main->frameGeometry().topLeft(), main->size())));
02292 }
02293 
02294 
02295 void KDockManager::readConfig(QDomElement &base)
02296 {
02297     if (base.namedItem("group").isNull()
02298         && base.namedItem("tabgroup").isNull()
02299         && base.namedItem("dock").isNull()
02300     && base.namedItem("dockContainer").isNull()) {
02301         activate();
02302         return;
02303     }
02304 
02305     autoCreateDock = new QObjectList();
02306     autoCreateDock->setAutoDelete( true );
02307 
02308     bool isMainVisible = main->isVisible();
02309     main->hide();
02310 
02311     QObjectListIt it(*childDock);
02312     KDockWidget *obj1;
02313     while ( (obj1=(KDockWidget*)it.current()) ) {
02314         if ( !obj1->isGroup && !obj1->isTabGroup ) {
02315             if ( obj1->parent() )
02316                 obj1->undock();
02317             else
02318                 obj1->hide();
02319         }
02320         ++it;
02321     }
02322 
02323     // firstly, recreate all common dockwidgets
02324     for( QDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
02325     {
02326         QDomElement childEl = n.toElement();
02327         if (childEl.tagName() != "dock") continue;
02328 
02329         // Read an ordinary dock widget
02330         KDockWidget *obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02331         obj->setTabPageLabel(stringEntry(childEl, "tabCaption"));
02332         obj->setToolTipString(stringEntry(childEl, "tabToolTip"));
02333 
02334         if (!boolEntry(childEl, "hasParent")) {
02335             QRect r = rectEntry(childEl, "geometry");
02336             obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02337             obj->applyToWidget(0);
02338             obj->setGeometry(r);
02339             if (boolEntry(childEl, "visible"))
02340                 obj->QWidget::show();
02341         }
02342 
02343         if (obj && obj->header && obj->header->inherits("KDockWidgetHeader")) {
02344             KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
02345             h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
02346         }
02347     }
02348 
02349     // secondly, now iterate again and create the groups and tabwidgets, apply the dockwidgets to them
02350     for( QDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
02351     {
02352         QDomElement childEl = n.toElement();
02353         if (childEl.isNull()) continue;
02354 
02355         KDockWidget *obj = 0;
02356 
02357     if (childEl.tagName() == "dockContainer") {
02358 
02359         KDockWidget *cont=getDockWidgetFromName(stringEntry(childEl, "name"));
02360         kdDebug(282)<<"dockContainer: "<<stringEntry(childEl,"name")<<endl;
02361         if (!(cont->d->isContainer)) {
02362             kdDebug(282)<<"restoration of dockContainer is only supported for already existing dock containers"<<endl;
02363         } else {
02364             KDockContainer *dc=dynamic_cast<KDockContainer*>(cont->getWidget());
02365             if (!dc) kdDebug(282)<<"Error while trying to handle dockcontainer configuration restoration"<<endl;
02366                 else {
02367                     dc->load(childEl);
02368                     removeFromAutoCreateList(cont);
02369                 }
02370 
02371         }
02372     }
02373     else
02374         if (childEl.tagName() == "splitGroup") {
02375             // Read a group
02376             QString name = stringEntry(childEl, "name");
02377             QString firstName = stringEntry(childEl, "firstName");
02378             QString secondName = stringEntry(childEl, "secondName");
02379             int orientation = numberEntry(childEl, "orientation");
02380             int separatorPos = numberEntry(childEl, "separatorPos");
02381 
02382             KDockWidget *first = getDockWidgetFromName(firstName);
02383             KDockWidget *second = getDockWidgetFromName(secondName);
02384             if (first && second) {
02385                 obj = first->manualDock(second,
02386                                         (orientation == (int)Vertical)? KDockWidget::DockLeft : KDockWidget::DockTop,
02387                                         separatorPos);
02388                 if (obj)
02389                     obj->setName(name.latin1());
02390             }
02391         } else if (childEl.tagName() == "tabGroup") {
02392             // Read a tab group
02393             QString name = stringEntry(childEl, "name");
02394             QStrList list = listEntry(childEl, "tabs", "tab");
02395 
02396             KDockWidget *d1 = getDockWidgetFromName( list.first() );
02397             list.next();
02398             KDockWidget *d2 = getDockWidgetFromName( list.current() );
02399 
02400             KDockWidget *obj = d2->manualDock( d1, KDockWidget::DockCenter );
02401             if (obj) {
02402                 KDockTabGroup *tab = (KDockTabGroup*)obj->widget;
02403                 list.next();
02404                 while (list.current() && obj) {
02405                     KDockWidget *tabDock = getDockWidgetFromName(list.current());
02406                     obj = tabDock->manualDock(d1, KDockWidget::DockCenter);
02407                     list.next();
02408                 }
02409                 if (obj) {
02410                     obj->setName(name.latin1());
02411                     tab->showPage(tab->page(numberEntry(childEl, "currentTab")));
02412                 }
02413             }
02414         } else {
02415             continue;
02416         }
02417 
02418         if (!boolEntry(childEl, "hasParent")) {
02419             QRect r = rectEntry(childEl, "geometry");
02420             obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02421             obj->applyToWidget(0);
02422             obj->setGeometry(r);
02423             if (boolEntry(childEl, "visible"))
02424                 obj->QWidget::show();
02425         }
02426 
02427         if (obj && obj->header && obj->header->inherits("KDockWidgetHeader")) {
02428             KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
02429             h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
02430         }
02431     }
02432 
02433     // thirdly, now that all ordinary dockwidgets are created,
02434     // iterate them again and link them with their corresponding dockwidget for the dockback action
02435     for( QDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
02436     {
02437         QDomElement childEl = n.toElement();
02438 
02439         if (childEl.tagName() != "dock" && childEl.tagName() != "tabGroup")
02440             continue;
02441 
02442         KDockWidget *obj = 0;
02443 
02444         if (!boolEntry(childEl, "hasParent")) {
02445             // Read a common toplevel dock widget
02446             obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02447             QString name = stringEntry(childEl, "dockBackTo");
02448             if (!name.isEmpty()) {
02449                 obj->setFormerBrotherDockWidget(getDockWidgetFromName(name));
02450             }
02451             obj->formerDockPos = KDockWidget::DockPosition(numberEntry(childEl, "dockBackToPos"));
02452             obj->updateHeader();
02453         }
02454     }
02455 
02456     if (main->inherits("KDockMainWindow")) {
02457         KDockMainWindow *dmain = (KDockMainWindow*)main;
02458 
02459         QString mv = stringEntry(base, "centralWidget");
02460         if (!mv.isEmpty() && getDockWidgetFromName(mv) ) {
02461             KDockWidget *mvd  = getDockWidgetFromName(mv);
02462             mvd->applyToWidget(dmain);
02463             mvd->show();
02464             dmain->setCentralWidget(mvd);
02465         }
02466         QString md = stringEntry(base, "mainDockWidget");
02467         if (!md.isEmpty() && getDockWidgetFromName(md)) {
02468             KDockWidget *mvd  = getDockWidgetFromName(md);
02469             dmain->setMainDockWidget(mvd);
02470         }
02471     } else {
02472         QString mv = stringEntry(base, "mainWidget");
02473         if (!mv.isEmpty() && getDockWidgetFromName(mv)) {
02474             KDockWidget *mvd  = getDockWidgetFromName(mv);
02475             mvd->applyToWidget(main);
02476             mvd->show();
02477         }
02478 
02479         // only resize + move non-mainwindows
02480         QRect mr = rectEntry(base, "geometry");
02481         main->move(mr.topLeft());
02482         main->resize(mr.size());
02483     }
02484 
02485     if (isMainVisible)
02486         main->show();
02487 
02488     if (d->m_readDockConfigMode == WrapExistingWidgetsOnly) {
02489         finishReadDockConfig(); // remove empty dockwidgets
02490     }
02491 }
02492 
02493 void KDockManager::removeFromAutoCreateList(KDockWidget* pDockWidget)
02494 {
02495     if (!autoCreateDock) return;
02496     autoCreateDock->setAutoDelete(false);
02497     autoCreateDock->removeRef(pDockWidget);
02498     autoCreateDock->setAutoDelete(true);
02499 }
02500 
02501 void KDockManager::finishReadDockConfig()
02502 {
02503     delete autoCreateDock;
02504     autoCreateDock = 0;
02505 }
02506 
02507 void KDockManager::setReadDockConfigMode(int mode)
02508 {
02509     d->m_readDockConfigMode = mode;
02510 }
02511 
02512 #ifndef NO_KDE2
02513 void KDockManager::writeConfig( KConfig* c, QString group )
02514 {
02515   //debug("BEGIN Write Config");
02516   if ( !c ) c = KGlobal::config();
02517   if ( group.isEmpty() ) group = "dock_setting_default";
02518 
02519   c->setGroup( group );
02520   c->writeEntry( "Version", DOCK_CONFIG_VERSION );
02521 
02522   QStringList nameList;
02523   QStringList findList;
02524   QObjectListIt it( *childDock );
02525   KDockWidget * obj;
02526 
02527   // collect KDockWidget's name
02528   QStringList nList;
02529   while ( (obj=(KDockWidget*)it.current()) ) {
02530     ++it;
02531     //debug("  +Add subdock %s", obj->name());
02532     nList.append( obj->name() );
02533     if ( obj->parent() == main )
02534       c->writeEntry( "Main:view", obj->name() );
02535   }
02536 
02537 //  kdDebug(282)<<QString("list size: %1").arg(nList.count())<<endl;
02538   for (QObjectListIt it(d->containerDocks);it.current();++it)
02539   {
02540     KDockContainer* dc = dynamic_cast<KDockContainer*>(((KDockWidget*)it.current())->widget);
02541     if (dc) {
02542         dc->prepareSave(nList);
02543     }
02544   }
02545 //  kdDebug(282)<<QString("new list size: %1").arg(nList.count())<<endl;
02546 
02547   QStringList::Iterator nListIt=nList.begin();
02548   while ( nListIt!=nList.end() ){
02549     //debug("  -Try to save %s", nList.current());
02550     obj = getDockWidgetFromName( *nListIt );
02551     QString cname = obj->name();
02552     if ( obj->header ){
02553       obj->header->saveConfig( c );
02554     }
02555     if (obj->d->isContainer) {
02556        KDockContainer* x = dynamic_cast<KDockContainer*>(obj->widget);
02557        if (x) {
02558           x->save(c,group);
02559        }
02560     }
02561 /*************************************************************************************************/
02562     if ( obj->isGroup ){
02563       if ( (findList.find( obj->firstName ) != findList.end()) && (findList.find( obj->lastName ) != findList.end() )){
02564 
02565         c->writeEntry( cname+":type", "GROUP");
02566         if ( !obj->parent() ){
02567           c->writeEntry( cname+":parent", "___null___");
02568           c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
02569           c->writeEntry( cname+":visible", obj->isVisible());
02570         } else {
02571           c->writeEntry( cname+":parent", "yes");
02572         }
02573         c->writeEntry( cname+":first_name", obj->firstName );
02574         c->writeEntry( cname+":last_name", obj->lastName );
02575         c->writeEntry( cname+":orientation", (int)obj->splitterOrientation );
02576         c->writeEntry( cname+":sepPos", ((KDockSplitter*)obj->widget)->separatorPos() );
02577 
02578         nameList.append( obj->name() );
02579         findList.append( obj->name() );
02580         //debug("  Save %s", nList.current());
02581         nList.remove(nListIt);
02582         nListIt=nList.begin(); //nList.first();
02583       } else {
02584 /*************************************************************************************************/
02585         //debug("  Skip %s", nList.current());
02586         //if ( findList.find( obj->firstName ) == -1 )
02587         //  debug("  ? Not found %s", obj->firstName);
02588         //if ( findList.find( obj->lastName ) == -1 )
02589         //  debug("  ? Not found %s", obj->lastName);
02590         ++nListIt;
02591         // if ( !nList.current() ) nList.first();
02592     if (nListIt==nList.end()) nListIt=nList.begin();
02593       }
02594     } else {
02595 /*************************************************************************************************/
02596       if ( obj->isTabGroup){
02597         c->writeEntry( cname+":type", "TAB_GROUP");
02598         if ( !obj->parent() ){
02599           c->writeEntry( cname+":parent", "___null___");
02600           c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
02601           c->writeEntry( cname+":visible", obj->isVisible());
02602           c->writeEntry( cname+":dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : "");
02603           c->writeEntry( cname+":dockBackToPos", obj->formerDockPos);
02604         } else {
02605           c->writeEntry( cname+":parent", "yes");
02606         }
02607         QStrList list;
02608         for ( int i = 0; i < ((KDockTabGroup*)obj->widget)->count(); ++i )
02609           list.append( ((KDockTabGroup*)obj->widget)->page( i )->name() );
02610         c->writeEntry( cname+":tabNames", list );
02611         c->writeEntry( cname+":curTab", ((KDockTabGroup*)obj->widget)->currentPageIndex() );
02612 
02613         nameList.append( obj->name() );
02614         findList.append( obj->name() ); // not really need !!!
02615         //debug("  Save %s", nList.current());
02616         nList.remove(nListIt);
02617         nListIt=nList.begin();
02618       } else {
02619 /*************************************************************************************************/
02620         c->writeEntry( cname+":tabCaption", obj->tabPageLabel());
02621         c->writeEntry( cname+":tabToolTip", obj->toolTipString());
02622         if ( !obj->parent() ){
02623           c->writeEntry( cname+":type", "NULL_DOCK");
02624           c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
02625           c->writeEntry( cname+":visible", obj->isVisible());
02626           c->writeEntry( cname+":dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : "");
02627           c->writeEntry( cname+":dockBackToPos", obj->formerDockPos);
02628         } else {
02629           c->writeEntry( cname+":type", "DOCK");
02630         }
02631         nameList.append( cname.latin1() );
02632         //debug("  Save %s", nList.current());
02633         findList.append( obj->name() );
02634         nList.remove(nListIt);
02635         nListIt=nList.begin();
02636       }
02637     }
02638   }
02639   c->writeEntry( "NameList", nameList );
02640 
02641   c->writeEntry( "Main:Geometry", QRect(main->frameGeometry().topLeft(), main->size()) );
02642   c->writeEntry( "Main:visible", main->isVisible()); // curently nou use
02643 
02644   if ( main->inherits("KDockMainWindow") ){
02645     KDockMainWindow* dmain = (KDockMainWindow*)main;
02646     // for KDockMainWindow->setView() in readConfig()
02647     c->writeEntry( "Main:view", dmain->centralWidget() ? dmain->centralWidget()->name():"" );
02648     c->writeEntry( "Main:dock", dmain->getMainDockWidget()     ? dmain->getMainDockWidget()->name()    :"" );
02649   }
02650 
02651   c->sync();
02652   //debug("END Write Config");
02653 }
02654 #include <qmessagebox.h>
02655 void KDockManager::readConfig( KConfig* c, QString group )
02656 {
02657   if ( !c ) c = KGlobal::config();
02658   if ( group.isEmpty() ) group = "dock_setting_default";
02659 
02660   c->setGroup( group );
02661   QStrList nameList;
02662   c->readListEntry( "NameList", nameList );
02663   QString ver = c->readEntry( "Version", "0.0.1" );
02664   nameList.first();
02665   if ( !nameList.current() || ver != DOCK_CONFIG_VERSION ){
02666     activate();
02667     return;
02668   }
02669 
02670   autoCreateDock = new QObjectList();
02671   autoCreateDock->setAutoDelete( true );
02672 
02673   bool isMainVisible = main->isVisible();
02674  // if (isMainVisible)  // CCC
02675   //QMessageBox::information(0,"","hallo");
02676 //COMMENTED4TESTING  main->hide();
02677 
02678   QObjectListIt it( *childDock );
02679   KDockWidget * obj;
02680 
02681   while ( (obj=(KDockWidget*)it.current()) ){
02682     ++it;
02683     if ( !obj->isGroup && !obj->isTabGroup )
02684     {
02685       if ( obj->parent() ) obj->undock(); else obj->hide();
02686     }
02687   }
02688 
02689   // firstly, only the common dockwidgets,
02690   // they must be restored before e.g. tabgroups are restored
02691   nameList.first();
02692   while ( nameList.current() ){
02693     QString oname = nameList.current();
02694     c->setGroup( group );
02695     QString type = c->readEntry( oname + ":type" );
02696     obj = 0L;
02697 
02698     if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
02699       QRect r = c->readRectEntry( oname + ":geometry" );
02700       obj = getDockWidgetFromName( oname );
02701       obj->applyToWidget( 0L );
02702       obj->setGeometry(r);
02703 
02704       c->setGroup( group );
02705       obj->setTabPageLabel(c->readEntry( oname + ":tabCaption" ));
02706       obj->setToolTipString(c->readEntry( oname + ":tabToolTip" ));
02707       if ( c->readBoolEntry( oname + ":visible" ) ){
02708         obj->QWidget::show();
02709       }
02710     }
02711 
02712     if ( type == "DOCK"  ){
02713       obj = getDockWidgetFromName( oname );
02714       obj->setTabPageLabel(c->readEntry( oname + ":tabCaption" ));
02715       obj->setToolTipString(c->readEntry( oname + ":tabToolTip" ));
02716     }
02717 
02718     if (obj && obj->d->isContainer) {
02719         dynamic_cast<KDockContainer*>(obj->widget)->load(c,group);
02720         removeFromAutoCreateList(obj);
02721     }
02722     if ( obj && obj->header){
02723       obj->header->loadConfig( c );
02724     }
02725     nameList.next();
02726   }
02727 
02728   // secondly, after the common dockwidgets, restore the groups and tabgroups
02729   nameList.first();
02730   while ( nameList.current() ){
02731     QString oname = nameList.current();
02732     c->setGroup( group );
02733     QString type = c->readEntry( oname + ":type" );
02734     obj = 0L;
02735 
02736     if ( type == "GROUP" ){
02737       KDockWidget* first = getDockWidgetFromName( c->readEntry( oname + ":first_name" ) );
02738       KDockWidget* last  = getDockWidgetFromName( c->readEntry( oname + ":last_name"  ) );
02739       int sepPos = c->readNumEntry( oname + ":sepPos" );
02740 
02741       Orientation p = (Orientation)c->readNumEntry( oname + ":orientation" );
02742       if ( first  && last ){
02743         obj = first->manualDock( last, ( p == Vertical ) ? KDockWidget::DockLeft : KDockWidget::DockTop, sepPos );
02744         if (obj){
02745           obj->setName( oname.latin1() );
02746         }
02747       }
02748     }
02749 
02750     if ( type == "TAB_GROUP" ){
02751       QStrList list;
02752       KDockWidget* tabDockGroup = 0L;
02753       c->readListEntry( oname+":tabNames", list );
02754       KDockWidget* d1 = getDockWidgetFromName( list.first() );
02755       list.next();
02756       KDockWidget* d2 = getDockWidgetFromName( list.current() );
02757       tabDockGroup = d2->manualDock( d1, KDockWidget::DockCenter );
02758       if ( tabDockGroup ){
02759         KDockTabGroup* tab = dynamic_cast<KDockTabGroup*>(tabDockGroup->widget);
02760         list.next();
02761         while ( list.current() && tabDockGroup ){
02762           KDockWidget* tabDock = getDockWidgetFromName( list.current() );
02763           tabDockGroup = tabDock->manualDock( d1, KDockWidget::DockCenter );
02764           list.next();
02765         }
02766         if ( tabDockGroup ){
02767           tabDockGroup->setName( oname.latin1() );
02768           c->setGroup( group );
02769           if (tab)
02770             tab->showPage( tab->page( c->readNumEntry( oname+":curTab" ) ) );
02771         }
02772       }
02773       obj = tabDockGroup;
02774     }
02775 
02776     if (obj && obj->d->isContainer)  dynamic_cast<KDockContainer*>(obj->widget)->load(c,group);
02777     if ( obj && obj->header){
02778       obj->header->loadConfig( c );
02779     }
02780     nameList.next();
02781   }
02782 
02783   // thirdly, now that all ordinary dockwidgets are created,
02784   // iterate them again and link the toplevel ones of them with their corresponding dockwidget for the dockback action
02785   nameList.first();
02786   while ( nameList.current() ){
02787     QString oname = nameList.current();
02788     c->setGroup( group );
02789     QString type = c->readEntry( oname + ":type" );
02790     obj = 0L;
02791 
02792     if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
02793       obj = getDockWidgetFromName( oname );
02794       c->setGroup( group );
02795       QString name = c->readEntry( oname + ":dockBackTo" );
02796       if (!name.isEmpty()) {
02797           obj->setFormerBrotherDockWidget(getDockWidgetFromName( name ));
02798       }
02799       obj->formerDockPos = KDockWidget::DockPosition(c->readNumEntry( oname + ":dockBackToPos" ));
02800     }
02801 
02802     nameList.next();
02803   }
02804 
02805   if ( main->inherits("KDockMainWindow") ){
02806     KDockMainWindow* dmain = (KDockMainWindow*)main;
02807 
02808     c->setGroup( group );
02809     QString mv = c->readEntry( "Main:view" );
02810     if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
02811       KDockWidget* mvd  = getDockWidgetFromName( mv );
02812       mvd->applyToWidget( dmain );
02813       mvd->show();
02814       dmain->setView( mvd );
02815     }
02816     c->setGroup( group );
02817     QString md = c->readEntry( "Main:dock" );
02818     if ( !md.isEmpty() && getDockWidgetFromName( md ) ){
02819       KDockWidget* mvd  = getDockWidgetFromName( md );
02820       dmain->setMainDockWidget( mvd );
02821     }
02822   } else {
02823     c->setGroup( group );
02824     QString mv = c->readEntry( "Main:view" );
02825     if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
02826       KDockWidget* mvd  = getDockWidgetFromName( mv );
02827       mvd->applyToWidget( main );
02828       mvd->show();
02829     }
02830 
02831   }
02832 
02833   // delete all autocreate dock
02834   if (d->m_readDockConfigMode == WrapExistingWidgetsOnly) {
02835     finishReadDockConfig(); // remove empty dockwidgets
02836   }
02837 
02838   c->setGroup( group );
02839   QRect mr = c->readRectEntry("Main:Geometry");
02840   main->move(mr.topLeft());
02841   main->resize(mr.size());
02842   if ( isMainVisible ) main->show();
02843 }
02844 #endif
02845 
02846 
02847 void KDockManager::dumpDockWidgets() {
02848   QObjectListIt it( *childDock );
02849   KDockWidget * obj;
02850   while ( (obj=(KDockWidget*)it.current()) ) {
02851     ++it;
02852     kdDebug(282)<<"KDockManager::dumpDockWidgets:"<<obj->name()<<endl;
02853   }
02854 
02855 }
02856 
02857 KDockWidget* KDockManager::getDockWidgetFromName( const QString& dockName )
02858 {
02859   QObjectListIt it( *childDock );
02860   KDockWidget * obj;
02861   while ( (obj=(KDockWidget*)it.current()) ) {
02862     ++it;
02863     if ( QString(obj->name()) == dockName ) return obj;
02864   }
02865 
02866   KDockWidget* autoCreate = 0L;
02867   if ( autoCreateDock ){
02868     kdDebug(282)<<"Autocreating dock: "<<dockName<<endl;
02869     autoCreate = new KDockWidget( this, dockName.latin1(), QPixmap("") );
02870     autoCreateDock->append( autoCreate );
02871   }
02872   return autoCreate;
02873 }
02874 void KDockManager::setSplitterOpaqueResize(bool b)
02875 {
02876   d->splitterOpaqueResize = b;
02877 }
02878 
02879 bool KDockManager::splitterOpaqueResize() const
02880 {
02881   return d->splitterOpaqueResize;
02882 }
02883 
02884 void KDockManager::setSplitterKeepSize(bool b)
02885 {
02886   d->splitterKeepSize = b;
02887 }
02888 
02889 bool KDockManager::splitterKeepSize() const
02890 {
02891   return d->splitterKeepSize;
02892 }
02893 
02894 void KDockManager::setSplitterHighResolution(bool b)
02895 {
02896   d->splitterHighResolution = b;
02897 }
02898 
02899 bool KDockManager::splitterHighResolution() const
02900 {
02901   return d->splitterHighResolution;
02902 }
02903 
02904 void KDockManager::slotMenuPopup()
02905 {
02906   menu->clear();
02907   menuData->clear();
02908 
02909   QObjectListIt it( *childDock );
02910   KDockWidget * obj;
02911   int numerator = 0;
02912   while ( (obj=(KDockWidget*)it.current()) ) {
02913     ++it;
02914     if ( obj->mayBeHide() )
02915     {
02916       menu->insertItem( obj->icon() ? *(obj->icon()) : QPixmap(), i18n("Hide %1").arg(obj->caption()), numerator++ );
02917       menuData->append( new MenuDockData( obj, true ) );
02918     }
02919 
02920     if ( obj->mayBeShow() )
02921     {
02922       menu->insertItem( obj->icon() ? *(obj->icon()) : QPixmap(), i18n("Show %1").arg(obj->caption()), numerator++ );
02923       menuData->append( new MenuDockData( obj, false ) );
02924     }
02925   }
02926 }
02927 
02928 void KDockManager::slotMenuActivated( int id )
02929 {
02930   MenuDockData* data = menuData->at( id );
02931   data->dock->changeHideShowState();
02932 }
02933 
02934 KDockWidget* KDockManager::findWidgetParentDock( QWidget* w ) const
02935 {
02936   QObjectListIt it( *childDock );
02937   KDockWidget * dock;
02938   KDockWidget * found = 0L;
02939 
02940   while ( (dock=(KDockWidget*)it.current()) ) {
02941     ++it;
02942     if ( dock->widget == w ){ found  = dock; break; }
02943   }
02944   return found;
02945 }
02946 
02947 void KDockManager::drawDragRectangle()
02948 {
02949 #ifdef BORDERLESS_WINDOWS
02950     return
02951 #endif
02952   if (d->oldDragRect == d->dragRect)
02953     return;
02954 
02955   int i;
02956   QRect oldAndNewDragRect[2];
02957   oldAndNewDragRect[0] = d->oldDragRect;
02958   oldAndNewDragRect[1] = d->dragRect;
02959 
02960   // 2 calls, one for the old and one for the new drag rectangle
02961   for (i = 0; i <= 1; i++) {
02962     if (oldAndNewDragRect[i].isEmpty())
02963       continue;
02964 
02965     KDockWidget* pDockWdgAtRect = (KDockWidget*) QApplication::widgetAt( oldAndNewDragRect[i].topLeft(), true );
02966     if (!pDockWdgAtRect)
02967       continue;
02968 
02969     bool isOverMainWdg = false;
02970     bool unclipped;
02971     KDockMainWindow* pMain = 0L;
02972     KDockWidget* pTLDockWdg = 0L;
02973     QWidget* topWdg;
02974     if (pDockWdgAtRect->topLevelWidget() == main) {
02975       isOverMainWdg = true;
02976       topWdg = pMain = (KDockMainWindow*) main;
02977       unclipped = pMain->testWFlags( WPaintUnclipped );
02978       pMain->setWFlags( WPaintUnclipped );
02979     }
02980     else {
02981       topWdg = pTLDockWdg = (KDockWidget*) pDockWdgAtRect->topLevelWidget();
02982       unclipped = pTLDockWdg->testWFlags( WPaintUnclipped );
02983       pTLDockWdg->setWFlags( WPaintUnclipped );
02984     }
02985 
02986     // draw the rectangle unclipped over the main dock window
02987     QPainter p;
02988     p.begin( topWdg );
02989       if ( !unclipped ) {
02990         if (isOverMainWdg)
02991           pMain->clearWFlags(WPaintUnclipped);
02992         else
02993           pTLDockWdg->clearWFlags(WPaintUnclipped);
02994       }
02995       // draw the rectangle
02996       p.setRasterOp(Qt::NotXorROP);
02997       QRect r = oldAndNewDragRect[i];
02998       r.moveTopLeft( r.topLeft() - topWdg->mapToGlobal(QPoint(0,0)) );
02999       p.drawRect(r.x(), r.y(), r.width(), r.height());
03000     p.end();
03001   }
03002 
03003   // memorize the current rectangle for later removing
03004   d->oldDragRect = d->dragRect;
03005 }
03006 
03007 void KDockManager::setSpecialLeftDockContainer(KDockWidget* container) {
03008     d->leftContainer=container;
03009 }
03010 
03011 void KDockManager::setSpecialTopDockContainer(KDockWidget* container) {
03012     d->topContainer=container;
03013 }
03014 
03015 void KDockManager::setSpecialRightDockContainer(KDockWidget* container) {
03016     d->rightContainer=container;
03017 
03018 }
03019 
03020 void KDockManager::setSpecialBottomDockContainer(KDockWidget* container) {
03021     d->bottomContainer=container;
03022 }
03023 
03024 
03025 KDockArea::KDockArea( QWidget* parent, const char *name)
03026 :QWidget( parent, name)
03027 {
03028   QString new_name = QString(name) + QString("_DockManager");
03029   dockManager = new KDockManager( this, new_name.latin1() );
03030   mainDockWidget = 0L;
03031 }
03032 
03033 KDockArea::~KDockArea()
03034 {
03035     delete dockManager;
03036 }
03037 
03038 KDockWidget* KDockArea::createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent, const QString& strCaption, const QString& strTabPageLabel)
03039 {
03040   return new KDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
03041 }
03042 
03043 void KDockArea::makeDockVisible( KDockWidget* dock )
03044 {
03045   if ( dock )
03046     dock->makeDockVisible();
03047 }
03048 
03049 void KDockArea::makeDockInvisible( KDockWidget* dock )
03050 {
03051   if ( dock )
03052     dock->undock();
03053 }
03054 
03055 void KDockArea::makeWidgetDockVisible( QWidget* widget )
03056 {
03057   makeDockVisible( dockManager->findWidgetParentDock(widget) );
03058 }
03059 
03060 void KDockArea::writeDockConfig(QDomElement &base)
03061 {
03062   dockManager->writeConfig(base);
03063 }
03064 
03065 void KDockArea::readDockConfig(QDomElement &base)
03066 {
03067   dockManager->readConfig(base);
03068 }
03069 
03070 void KDockArea::slotDockWidgetUndocked()
03071 {
03072   QObject* pSender = (QObject*) sender();
03073   if (!pSender->inherits("KDockWidget")) return;
03074   KDockWidget* pDW = (KDockWidget*) pSender;
03075   emit dockWidgetHasUndocked( pDW);
03076 }
03077 
03078 void KDockArea::resizeEvent(QResizeEvent *rsize)
03079 {
03080   QWidget::resizeEvent(rsize);
03081   if (children()){
03082 #ifndef NO_KDE2
03083 //    kdDebug(282)<<"KDockArea::resize"<<endl;
03084 #endif
03085     QObjectList *list=queryList("QWidget",0,false);
03086 
03087     QObjectListIt it( *list ); // iterate over the buttons
03088     QObject *obj;
03089 
03090     while ( (obj = it.current()) != 0 ) {
03091         // for each found object...
03092         ((QWidget*)obj)->setGeometry(QRect(QPoint(0,0),size()));
03093     break;
03094     }
03095     delete list;
03096 #if 0
03097     KDockSplitter *split;
03098 //    for (unsigned int i=0;i<children()->count();i++)
03099     {
03100 //      QPtrList<QObject> list(children());
03101 //       QObject *obj=((QPtrList<QObject*>)children())->at(i);
03102     QObject *obj=children()->getFirst();
03103        if (split = dynamic_cast<KDockSplitter*>(obj))
03104        {
03105           split->setGeometry( QRect(QPoint(0,0), size() ));
03106 //    break;
03107        }
03108     }
03109 #endif
03110    }
03111 }
03112 
03113 #ifndef NO_KDE2
03114 void KDockArea::writeDockConfig( KConfig* c, QString group )
03115 {
03116   dockManager->writeConfig( c, group );
03117 }
03118 
03119 void KDockArea::readDockConfig( KConfig* c, QString group )
03120 {
03121   dockManager->readConfig( c, group );
03122 }
03123 
03124 void KDockArea::setMainDockWidget( KDockWidget* mdw )
03125 {
03126   if ( mainDockWidget == mdw ) return;
03127   mainDockWidget = mdw;
03128   mdw->applyToWidget(this);
03129 }
03130 #endif
03131 
03132 
03133 
03134 // KDOCKCONTAINER - AN ABSTRACTION OF THE KDOCKTABWIDGET
03135 KDockContainer::KDockContainer(){m_overlapMode=false; m_childrenListBegin=0; m_childrenListEnd=0;}
03136 KDockContainer::~KDockContainer(){
03137 
03138     if (m_childrenListBegin)
03139     {
03140         struct ListItem *tmp=m_childrenListBegin;
03141         while (tmp)
03142         {
03143             struct ListItem *tmp2=tmp->next;
03144             free(tmp->data);
03145             delete tmp;
03146             tmp=tmp2;
03147         }
03148         m_childrenListBegin=0;
03149         m_childrenListEnd=0;
03150     }
03151 
03152 }
03153 
03154 void KDockContainer::activateOverlapMode(int nonOverlapSize) {
03155     m_nonOverlapSize=nonOverlapSize;
03156     m_overlapMode=true;
03157     if (parentDockWidget()) {
03158         if (parentDockWidget()->parent()) {
03159             kdDebug(282)<<"KDockContainer::activateOverlapMode: recalculating sizes"<<endl;
03160             KDockSplitter *sp= static_cast<KDockSplitter*>(parentDockWidget()->
03161                 parent()->qt_cast("KDockSplitter"));
03162             if (sp) sp->resizeEvent(0);
03163         }
03164     }
03165 }
03166 
03167 void KDockContainer::deactivateOverlapMode() {
03168     if (!m_overlapMode) return;
03169     m_overlapMode=false;
03170     if (parentDockWidget()) {
03171         if (parentDockWidget()->parent()) {
03172             kdDebug(282)<<"KDockContainer::deactivateOverlapMode: recalculating sizes"<<endl;
03173             KDockSplitter *sp= static_cast<KDockSplitter*>(parentDockWidget()->
03174                 parent()->qt_cast("KDockSplitter"));
03175             if (sp) sp->resizeEvent(0);
03176         }
03177     }
03178 
03179 }
03180 
03181 bool KDockContainer::isOverlapMode() {
03182     return m_overlapMode;
03183 }
03184 
03185 
03186 bool KDockContainer::dockDragEnter(KDockWidget*, QMouseEvent *) { return false;}
03187 bool KDockContainer::dockDragMove(KDockWidget*, QMouseEvent *) { return false;}
03188 bool KDockContainer::dockDragLeave(KDockWidget*, QMouseEvent *) { return false;}
03189 
03190 
03191 KDockWidget *KDockContainer::parentDockWidget(){return 0;}
03192 
03193 QStringList KDockContainer::containedWidgets() const {
03194     QStringList tmp;
03195     for (struct ListItem *it=m_childrenListBegin;it;it=it->next) {
03196         tmp<<QString(it->data);
03197     }
03198 
03199     return tmp;
03200 }
03201 
03202 void KDockContainer::showWidget(KDockWidget *) {
03203 }
03204 
03205 void KDockContainer::insertWidget (KDockWidget *dw, QPixmap, const QString &, int &)
03206     {
03207         struct ListItem *it=new struct ListItem;
03208         it->data=strdup(dw->name());
03209         it->next=0;
03210 
03211         if (m_childrenListEnd)
03212         {
03213             m_childrenListEnd->next=it;
03214             it->prev=m_childrenListEnd;
03215             m_childrenListEnd=it;
03216         }
03217         else
03218         {
03219             it->prev=0;
03220             m_childrenListEnd=it;
03221             m_childrenListBegin=it;
03222         }
03223     }
03224 void KDockContainer::removeWidget (KDockWidget *dw){
03225     for (struct ListItem *tmp=m_childrenListBegin;tmp;tmp=tmp->next)
03226     {
03227         if (!strcmp(tmp->data,dw->name()))
03228         {
03229             free(tmp->data);
03230             if (tmp->next) tmp->next->prev=tmp->prev;
03231             if (tmp->prev) tmp->prev->next=tmp->next;
03232             if (tmp==m_childrenListBegin) m_childrenListBegin=tmp->next;
03233             if (tmp==m_childrenListEnd) m_childrenListEnd=tmp->prev;
03234             delete tmp;
03235             break;
03236         }
03237     }
03238 }
03239 
03240 //m_children.remove(dw->name());}
03241 void KDockContainer::undockWidget (KDockWidget *){;}
03242 void KDockContainer::setToolTip(KDockWidget *, QString &){;}
03243 void KDockContainer::setPixmap(KDockWidget*,const QPixmap&){;}
03244 void KDockContainer::load (KConfig*, const QString&){;}
03245 void KDockContainer::save (KConfig*, const QString&){;}
03246 void KDockContainer::load (QDomElement&){;}
03247 void KDockContainer::save (QDomElement&){;}
03248 void KDockContainer::prepareSave(QStringList &names)
03249 {
03250 
03251     for (struct ListItem *tmp=m_childrenListBegin;tmp; tmp=tmp->next)
03252         names.remove(tmp->data);
03253 //  for (uint i=0;i<m_children.count();i++)
03254 //  {
03255 //      names.remove(m_children.at(i));
03256 //  }
03257 }
03258 
03259 
03260 QWidget *KDockTabGroup::transientTo() {
03261     QWidget *tT=0;
03262     for (int i=0;i<count();i++) {
03263         KDockWidget *dw=static_cast<KDockWidget*>(page(i)->qt_cast("KDockWidget"));
03264         QWidget *tmp;
03265         if ((tmp=dw->transientTo())) {
03266             if (!tT) tT=tmp;
03267             else {
03268                 if (tT!=tmp) {
03269                     kdDebug(282)<<"KDockTabGroup::transientTo: widget mismatch"<<endl;
03270                     return 0;
03271                 }
03272             }
03273         }
03274     }
03275 
03276     kdDebug(282)<<"KDockTabGroup::transientTo: "<<(tT?"YES":"NO")<<endl;
03277 
03278     return tT;
03279 }
03280 
03281 void KDockWidgetAbstractHeader::virtual_hook( int, void* )
03282 { /*BASE::virtual_hook( id, data );*/ }
03283 
03284 void KDockWidgetAbstractHeaderDrag::virtual_hook( int, void* )
03285 { /*BASE::virtual_hook( id, data );*/ }
03286 
03287 void KDockWidgetHeaderDrag::virtual_hook( int id, void* data )
03288 { KDockWidgetAbstractHeaderDrag::virtual_hook( id, data ); }
03289 
03290 void KDockWidgetHeader::virtual_hook( int id, void* data )
03291 { KDockWidgetAbstractHeader::virtual_hook( id, data ); }
03292 
03293 void KDockTabGroup::virtual_hook( int, void* )
03294 { /*BASE::virtual_hook( id, data );*/ }
03295 
03296 void KDockWidget::virtual_hook( int, void* )
03297 { /*BASE::virtual_hook( id, data );*/ }
03298 
03299 void KDockManager::virtual_hook( int, void* )
03300 { /*BASE::virtual_hook( id, data );*/ }
03301 
03302 void KDockMainWindow::virtual_hook( int id, void* data )
03303 { KMainWindow::virtual_hook( id, data ); }
03304 
03305 void KDockArea::virtual_hook( int, void* )
03306 { /*KMainWindow::virtual_hook( id, data );*/ }
03307 
03308 
03309 #ifndef NO_INCLUDE_MOCFILES // for Qt-only projects, because tmake doesn't take this name
03310 #include "kdockwidget.moc"
03311 #endif
KDE Logo
This file is part of the documentation for kdeui Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Fri Apr 22 16:01:40 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003