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