# kdeui Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# 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

This file is part of the documentation for kdeui Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:20:16 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003