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 KDockWidget::DockPosition KDockWidget::currentDockPosition() const
01264 {
01265 return currentDockPos;
01266 }
01267
01268 void KDockWidget::undock()
01269 {
01270
01271
01272 manager->d->dragRect = QRect ();
01273 manager->drawDragRectangle ();
01274
01275 QWidget* parentW = parentWidget();
01276 if ( !parentW ){
01277 hide();
01278 if (!d->blockHasUndockedSignal)
01279 emit hasUndocked();
01280 return;
01281 }
01282
01283 formerDockPos = currentDockPos;
01284 currentDockPos = KDockWidget::DockDesktop;
01285
01286 manager->blockSignals(true);
01287 manager->undockProcess = true;
01288
01289 bool isV = parentW->isVisibleToTLW();
01290
01291
01292 KDockTabGroup* parentTab = parentDockTabGroup();
01293 if ( parentTab ){
01294 d->index = parentTab->indexOf( this);
01295 parentTab->removePage( this );
01296
01297
01298
01299
01300 setFormerBrotherDockWidget((KDockWidget*)parentTab->page(0));
01301 applyToWidget( 0L );
01302 if ( parentTab->count() == 1 ){
01303
01304
01305 KDockWidget* lastTab = (KDockWidget*)parentTab->page(0);
01306 parentTab->removePage( lastTab );
01307
01308
01309
01310 lastTab->applyToWidget( 0L );
01311 lastTab->move( parentTab->mapToGlobal(parentTab->frameGeometry().topLeft()) );
01312
01313
01314 KDockWidget* parentOfTab = (KDockWidget*)parentTab->parent();
01315 delete parentTab;
01316
01317 QWidget* parentOfDockWidget = parentOfTab->parentWidget();
01318 if ( parentOfDockWidget == 0L ){
01319 if ( isV ) lastTab->show();
01320 } else {
01321 if ( parentOfDockWidget->inherits("KDockSplitter") ){
01322 KDockSplitter* split = (KDockSplitter*)parentOfDockWidget;
01323 lastTab->applyToWidget( split );
01324 split->deactivate();
01325 if ( split->getFirst() == parentOfTab ){
01326 split->activate( lastTab );
01327 if ( ((KDockWidget*)split->parent())->splitterOrientation == Vertical )
01328 emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockLeft );
01329 else
01330 emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockTop );
01331 } else {
01332 split->activate( 0L, lastTab );
01333 if ( ((KDockWidget*)split->parent())->splitterOrientation == Vertical )
01334 emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockRight );
01335 else
01336 emit ((KDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, KDockWidget::DockBottom );
01337 }
01338 split->show();
01339 } else {
01340 lastTab->applyToWidget( parentOfDockWidget );
01341 }
01342 lastTab->show();
01343 }
01344 manager->blockSignals(false);
01345 emit manager->replaceDock( parentOfTab, lastTab );
01346 lastTab->currentDockPos = parentOfTab->currentDockPos;
01347 emit parentOfTab->iMBeingClosed();
01348 manager->blockSignals(true);
01349 delete parentOfTab;
01350
01351 } else {
01352 setDockTabName( parentTab );
01353 }
01354 } else {
01355
01356
01357 bool undockedFromContainer=false;
01358 if (d->container)
01359 {
01360
01361 undockedFromContainer=true;
01362 KDockContainer* dc = dynamic_cast<KDockContainer*>(d->container.operator->());
01363 if (dc) {
01364 dc->undockWidget(this);
01365 setFormerBrotherDockWidget(dc->parentDockWidget());
01366 }
01367 applyToWidget( 0L );
01368 }
01369 if (!undockedFromContainer) {
01370
01371 if ( parentW->inherits("KDockSplitter") ){
01372 KDockSplitter* parentSplitterOfDockWidget = (KDockSplitter*)parentW;
01373 d->splitPosInPercent = parentSplitterOfDockWidget->separatorPos();
01374
01375 KDockWidget* secondWidget = (KDockWidget*)parentSplitterOfDockWidget->getAnother( this );
01376 KDockWidget* group = (KDockWidget*)parentSplitterOfDockWidget->parentWidget();
01377 setFormerBrotherDockWidget(secondWidget);
01378 applyToWidget( 0L );
01379 group->hide();
01380
01381 if ( !group->parentWidget() ){
01382 secondWidget->applyToWidget( 0L, group->frameGeometry().topLeft() );
01383 secondWidget->resize( group->width(), group->height() );
01384 } else {
01385 QWidget* obj = group->parentWidget();
01386 secondWidget->applyToWidget( obj );
01387 if ( obj->inherits("KDockSplitter") ){
01388 KDockSplitter* parentOfGroup = (KDockSplitter*)obj;
01389 parentOfGroup->deactivate();
01390
01391 if ( parentOfGroup->getFirst() == group )
01392 parentOfGroup->activate( secondWidget );
01393 else
01394 parentOfGroup->activate( 0L, secondWidget );
01395 }
01396 }
01397 secondWidget->currentDockPos = group->currentDockPos;
01398 secondWidget->formerDockPos = group->formerDockPos;
01399 delete parentSplitterOfDockWidget;
01400 manager->blockSignals(false);
01401 emit manager->replaceDock( group, secondWidget );
01402 emit group->iMBeingClosed();
01403 manager->blockSignals(true);
01404 delete group;
01405
01406 if ( isV ) secondWidget->show();
01407 } else {
01408 if (!d->pendingDtor) {
01409
01410 applyToWidget( 0L );
01411 }
01412 }
01413
01414 }
01415 }
01416 manager->blockSignals(false);
01417 if (!d->blockHasUndockedSignal)
01418 emit manager->change();
01419 manager->undockProcess = false;
01420
01421 if (!d->blockHasUndockedSignal)
01422 emit hasUndocked();
01423 }
01424
01425 void KDockWidget::setWidget( QWidget* mw )
01426 {
01427 if ( !mw ) return;
01428
01429 if ( mw->parent() != this ){
01430 mw->reparent(this, 0, QPoint(0,0), false);
01431 }
01432
01433 #ifdef BORDERLESS_WINDOWS
01434 if (!mw->ownCursor()) mw->setCursor(QCursor(ArrowCursor));
01435 #endif
01436 widget = mw;
01437 delete layout;
01438
01439 layout = new QVBoxLayout( this );
01440 layout->setResizeMode( QLayout::Minimum );
01441
01442 KDockContainer* dc = dynamic_cast<KDockContainer*>(widget);
01443 if (dc)
01444 {
01445 d->isContainer=true;
01446 manager->d->containerDocks.append(this);
01447 }
01448 else
01449 {
01450 d->isContainer=false;
01451 }
01452
01453 {
01454 header->show();
01455 layout->addWidget( header );
01456 layout->addWidget( widget,1 );
01457 }
01458 updateHeader();
01459 emit widgetSet(mw);
01460 }
01461
01462 void KDockWidget::setDockTabName( KDockTabGroup* tab )
01463 {
01464 QString listOfName;
01465 QString listOfCaption;
01466 for ( int i = 0; i < tab->count(); ++i ) {
01467 QWidget *w = tab->page( i );
01468 listOfCaption.append( w->caption() ).append(",");
01469 listOfName.append( w->name() ).append(",");
01470 }
01471 listOfCaption.remove( listOfCaption.length()-1, 1 );
01472 listOfName.remove( listOfName.length()-1, 1 );
01473
01474 tab->parentWidget()->setName( listOfName.utf8() );
01475 tab->parentWidget()->setCaption( listOfCaption );
01476
01477 tab->parentWidget()->repaint( false );
01478 if ( tab->parentWidget()->parent() )
01479 if ( tab->parentWidget()->parent()->inherits("KDockSplitter") )
01480 ((KDockSplitter*)(tab->parentWidget()->parent()))->updateName();
01481 }
01482
01483 bool KDockWidget::mayBeHide() const
01484 {
01485 bool f = (parent() != manager->main);
01486 return ( !isGroup && !isTabGroup && f && isVisible() && ( eDocking != (int)KDockWidget::DockNone ) );
01487 }
01488
01489 bool KDockWidget::mayBeShow() const
01490 {
01491 bool f = (parent() != manager->main);
01492 return ( !isGroup && !isTabGroup && f && !isVisible() );
01493 }
01494
01495 void KDockWidget::changeHideShowState()
01496 {
01497 if ( mayBeHide() ){
01498 undock();
01499 return;
01500 }
01501
01502 if ( mayBeShow() ){
01503 if ( manager->main->inherits("KDockMainWindow") ){
01504 ((KDockMainWindow*)manager->main)->makeDockVisible(this);
01505 } else {
01506 makeDockVisible();
01507 }
01508 }
01509 }
01510
01511 void KDockWidget::makeDockVisible()
01512 {
01513 if ( parentDockTabGroup() ){
01514 parentDockTabGroup()->showPage( this );
01515 }
01516 if (parentDockContainer()) {
01517 QWidget *contWid=parentDockContainer();
01518 KDockContainer *x = dynamic_cast<KDockContainer*>(contWid);
01519 if (x) {
01520 x->showWidget(this);
01521 }
01522 }
01523 if ( isVisible() ) return;
01524
01525 QWidget* p = parentWidget();
01526 while ( p ){
01527 if ( !p->isVisible() )
01528 p->show();
01529 p = p->parentWidget();
01530 }
01531 if( parent() == 0L)
01532 dockBack();
01533 show();
01534 }
01535
01536 void KDockWidget::setFormerBrotherDockWidget(KDockWidget *dockWidget)
01537 {
01538 formerBrotherDockWidget = dockWidget;
01539 if( formerBrotherDockWidget != 0L)
01540 QObject::connect( formerBrotherDockWidget, SIGNAL(iMBeingClosed()),
01541 this, SLOT(loseFormerBrotherDockWidget()) );
01542 }
01543
01544 void KDockWidget::loseFormerBrotherDockWidget()
01545 {
01546 if( formerBrotherDockWidget != 0L)
01547 QObject::disconnect( formerBrotherDockWidget, SIGNAL(iMBeingClosed()),
01548 this, SLOT(loseFormerBrotherDockWidget()) );
01549 formerBrotherDockWidget = 0L;
01550 repaint();
01551 }
01552
01553 void KDockWidget::dockBack()
01554 {
01555 if( formerBrotherDockWidget) {
01556
01557 bool found = false;
01558 QObjectList* cl = queryList("KDockWidget");
01559 QObjectListIt it( *cl );
01560 QObject * obj;
01561 while ( !found && (obj=it.current()) != 0 ) {
01562 ++it;
01563 QWidget* widg = (QWidget*)obj;
01564 if( widg == formerBrotherDockWidget)
01565 found = true;
01566 }
01567 delete cl;
01568
01569 if( !found) {
01570
01571 manualDock( formerBrotherDockWidget, formerDockPos, d->splitPosInPercent, QPoint(0,0), false, d->index);
01572 formerBrotherDockWidget = 0L;
01573 makeDockVisible();
01574 return;
01575 }
01576 }
01577
01578
01579 manualDock( ((KDockMainWindow*)manager->main)->getMainDockWidget(), formerDockPos, d->splitPosInPercent, QPoint(0,0), false, d->index);
01580 formerBrotherDockWidget = 0L;
01581 if (parent())
01582 makeDockVisible();
01583 }
01584
01585 bool KDockWidget::isDockBackPossible() const
01586 {
01587 if( (formerBrotherDockWidget == 0L) || !(formerBrotherDockWidget->dockSite() & formerDockPos))
01588 return false;
01589 else
01590 return true;
01591 }
01592
01593
01594
01595
01596 KDockManager::KDockManager( QWidget* mainWindow , const char* name )
01597 :QObject( mainWindow, name )
01598 ,main(mainWindow)
01599 ,currentDragWidget(0L)
01600 ,currentMoveWidget(0L)
01601 ,childDockWidgetList(0L)
01602 ,autoCreateDock(0L)
01603 ,storeW(0)
01604 ,storeH(0)
01605 ,dragging(false)
01606 ,undockProcess(false)
01607 ,dropCancel(true)
01608 {
01609 d = new KDockManagerPrivate;
01610
01611 d->readyToDrag = false;
01612 d->mainDockWidget=0;
01613
01614 #ifndef NO_KDE2
01615 d->splitterOpaqueResize = KGlobalSettings::opaqueResize();
01616 #else
01617 d->splitterOpaqueResize = false;
01618 #endif
01619
01620 d->splitterKeepSize = false;
01621 d->splitterHighResolution = false;
01622 d->m_readDockConfigMode = WrapExistingWidgetsOnly;
01623
01624 main->installEventFilter( this );
01625
01626 undockProcess = false;
01627
01628 menuData = new QPtrList<MenuDockData>;
01629 menuData->setAutoDelete( true );
01630 menuData->setAutoDelete( true );
01631
01632 #ifndef NO_KDE2
01633 menu = new KPopupMenu();
01634 #else
01635 menu = new QPopupMenu();
01636 #endif
01637
01638 connect( menu, SIGNAL(aboutToShow()), SLOT(slotMenuPopup()) );
01639 connect( menu, SIGNAL(activated(int)), SLOT(slotMenuActivated(int)) );
01640
01641 childDock = new QObjectList();
01642 childDock->setAutoDelete( false );
01643 }
01644
01645
01646 void KDockManager::setMainDockWidget2(KDockWidget *w)
01647 {
01648 d->mainDockWidget=w;
01649 }
01650
01651 KDockManager::~KDockManager()
01652 {
01653 delete menuData;
01654 delete menu;
01655
01656 QObjectListIt it( *childDock );
01657 KDockWidget * obj;
01658
01659 while ( (obj=(KDockWidget*)it.current()) ) {
01660 delete obj;
01661 }
01662 delete childDock;
01663 delete d;
01664 d=0;
01665 }
01666
01667 void KDockManager::activate()
01668 {
01669 QObjectListIt it( *childDock );
01670 KDockWidget * obj;
01671
01672 while ( (obj=(KDockWidget*)it.current()) ) {
01673 ++it;
01674 if ( obj->widget ) obj->widget->show();
01675 if ( !obj->parentDockTabGroup() ){
01676 obj->show();
01677 }
01678 }
01679 if ( !main->inherits("QDialog") ) main->show();
01680 }
01681
01682 bool KDockManager::eventFilter( QObject *obj, QEvent *event )
01683 {
01684
01685 if ( obj->inherits("KDockWidgetAbstractHeaderDrag") ){
01686 KDockWidget* pDockWdgAtCursor = 0L;
01687 KDockWidget* curdw = ((KDockWidgetAbstractHeaderDrag*)obj)->dockWidget();
01688 switch ( event->type() ){
01689 case QEvent::MouseButtonDblClick:
01690 if (curdw->currentDockPos == KDockWidget::DockDesktop) curdw->dockBack();
01691 else
01692 {
01693 curdw->toDesktop();
01694
01695 }
01696 break;
01697
01698 case QEvent::MouseButtonPress:
01699 if ( ((QMouseEvent*)event)->button() == LeftButton ){
01700 if ( curdw->eDocking != (int)KDockWidget::DockNone ){
01701 dropCancel = true;
01702 curdw->setFocus();
01703 qApp->processOneEvent();
01704
01705 currentDragWidget = curdw;
01706 currentMoveWidget = 0L;
01707 childDockWidgetList = new QWidgetList();
01708 childDockWidgetList->append( curdw );
01709 findChildDockWidget( curdw, childDockWidgetList );
01710
01711
01712 d->dragRect = QRect(curdw->geometry());
01713 QPoint p = curdw->mapToGlobal(QPoint(0,0));
01714 d->dragRect.moveTopLeft(p);
01715 drawDragRectangle();
01716 d->readyToDrag = true;
01717
01718 d->dragOffset = QCursor::pos()-currentDragWidget->mapToGlobal(QPoint(0,0));
01719 }
01720
01721 }
01722 break;
01723 case QEvent::MouseButtonRelease:
01724 if ( ((QMouseEvent*)event)->button() == LeftButton ){
01725 if ( dragging ){
01726 if ( !dropCancel )
01727 drop();
01728 else
01729 cancelDrop();
01730 }
01731 if (d->readyToDrag) {
01732 d->readyToDrag = false;
01733
01734 d->dragRect = QRect(curdw->geometry());
01735 QPoint p = curdw->mapToGlobal(QPoint(0,0));
01736 d->dragRect.moveTopLeft(p);
01737 drawDragRectangle();
01738 currentDragWidget = 0L;
01739 delete childDockWidgetList;
01740 childDockWidgetList = 0L;
01741 }
01742 dragging = false;
01743 dropCancel = true;
01744 }
01745 break;
01746 case QEvent::MouseMove:
01747 if ( dragging ) {
01748
01749 #ifdef BORDERLESS_WINDOWS
01750
01751 KDockWidget *oldMoveWidget;
01752 if (curdw->parent()==0)
01753 {
01754 curdw->move(QCursor::pos()-d->dragOffset);
01755 pDockWdgAtCursor = findDockWidgetAt( QCursor::pos()-QPoint(0,d->dragOffset.y()+3) );
01756 oldMoveWidget = currentMoveWidget;
01757 }
01758 else
01759 {
01760 pDockWdgAtCursor = findDockWidgetAt( QCursor::pos() );
01761 oldMoveWidget = currentMoveWidget;
01762 }
01763
01764 #else
01765 pDockWdgAtCursor = findDockWidgetAt( QCursor::pos() );
01766 KDockWidget* oldMoveWidget = currentMoveWidget;
01767 #endif
01768
01769 if ( currentMoveWidget && pDockWdgAtCursor == currentMoveWidget ) {
01770 dragMove( currentMoveWidget, currentMoveWidget->mapFromGlobal( QCursor::pos() ) );
01771 break;
01772 } else {
01773 if (dropCancel && curdw) {
01774 d->dragRect = QRect(curdw->geometry());
01775 QPoint p = curdw->mapToGlobal(QPoint(0,0));
01776 d->dragRect.moveTopLeft(p);
01777 }else
01778 d->dragRect = QRect();
01779
01780 drawDragRectangle();
01781 }
01782
01783 if ( !pDockWdgAtCursor && (curdw->eDocking & (int)KDockWidget::DockDesktop) == 0 ){
01784
01785 currentMoveWidget = pDockWdgAtCursor;
01786 curPos = KDockWidget::DockDesktop;
01787 } else {
01788 if ( oldMoveWidget && pDockWdgAtCursor != currentMoveWidget ) {
01789 currentMoveWidget = pDockWdgAtCursor;
01790 curPos = KDockWidget::DockDesktop;
01791 }
01792 }
01793
01794 if ( oldMoveWidget != pDockWdgAtCursor && pDockWdgAtCursor ) {
01795 currentMoveWidget = pDockWdgAtCursor;
01796 curPos = KDockWidget::DockDesktop;
01797 }
01798 } else {
01799 if (d->readyToDrag) {
01800 d->readyToDrag = false;
01801 }
01802 if ( (((QMouseEvent*)event)->state() == LeftButton) &&
01803 (curdw->eDocking != (int)KDockWidget::DockNone) ) {
01804 startDrag( curdw);
01805 }
01806 }
01807 break;
01808 default:
01809 break;
01810 }
01811 }
01812 return QObject::eventFilter( obj, event );
01813 }
01814
01815 KDockWidget* KDockManager::findDockWidgetAt( const QPoint& pos )
01816 {
01817 dropCancel = true;
01818
01819 if (!currentDragWidget)
01820 return 0L;
01821
01822 if (currentDragWidget->eDocking == (int)KDockWidget::DockNone ) return 0L;
01823
01824 QWidget* p = QApplication::widgetAt( pos );
01825 if ( !p ) {
01826 dropCancel = false;
01827 return 0L;
01828 }
01829 #if defined(_OS_WIN32_) || defined(Q_OS_WIN32)
01830 p = p->topLevelWidget();
01831 #endif
01832 QWidget* w = 0L;
01833 findChildDockWidget( w, p, p->mapFromGlobal(pos) );
01834 if ( !w ){
01835 if ( !p->inherits("KDockWidget") ) {
01836 return 0L;
01837 }
01838 w = p;
01839 }
01840 if ( qt_find_obj_child( w, "KDockSplitter", "_dock_split_" ) ) return 0L;
01841 if ( qt_find_obj_child( w, "KDockTabGroup", "_dock_tab" ) ) return 0L;
01842 if (dynamic_cast<KDockContainer*>(w)) return 0L;
01843
01844 if (!childDockWidgetList) return 0L;
01845 if ( childDockWidgetList->find(w) != -1 ) return 0L;
01846 if ( currentDragWidget->isGroup && ((KDockWidget*)w)->parentDockTabGroup() ) return 0L;
01847
01848 KDockWidget* www = (KDockWidget*)w;
01849 if ( www->sDocking == (int)KDockWidget::DockNone ) return 0L;
01850 if( !www->widget )
01851 return 0L;
01852
01853 KDockWidget::DockPosition curPos = KDockWidget::DockDesktop;
01854 QPoint cpos = www->mapFromGlobal( pos );
01855
01856 int ww = www->widget->width() / 3;
01857 int hh = www->widget->height() / 3;
01858
01859 if ( cpos.y() <= hh ){
01860 curPos = KDockWidget::DockTop;
01861 } else
01862 if ( cpos.y() >= 2*hh ){
01863 curPos = KDockWidget::DockBottom;
01864 } else
01865 if ( cpos.x() <= ww ){
01866 curPos = KDockWidget::DockLeft;
01867 } else
01868 if ( cpos.x() >= 2*ww ){
01869 curPos = KDockWidget::DockRight;
01870 } else
01871 curPos = KDockWidget::DockCenter;
01872
01873 if ( !(www->sDocking & (int)curPos) ) return 0L;
01874 if ( !(currentDragWidget->eDocking & (int)curPos) ) return 0L;
01875 if ( www->manager != this ) return 0L;
01876
01877 dropCancel = false;
01878 return www;
01879 }
01880
01881 void KDockManager::findChildDockWidget( QWidget*& ww, const QWidget* p, const QPoint& pos )
01882 {
01883 if ( p->children() ) {
01884 QWidget *w;
01885 QObjectListIt it( *p->children() );
01886 it.toLast();
01887 while ( it.current() ) {
01888 if ( it.current()->isWidgetType() ) {
01889 w = (QWidget*)it.current();
01890 if ( w->isVisible() && w->geometry().contains(pos) ) {
01891 if ( w->inherits("KDockWidget") ) ww = w;
01892 findChildDockWidget( ww, w, w->mapFromParent(pos) );
01893 return;
01894 }
01895 }
01896 --it;
01897 }
01898 }
01899 return;
01900 }
01901
01902 void KDockManager::findChildDockWidget( const QWidget* p, QWidgetList*& list )
01903 {
01904 if ( p->children() ) {
01905 QWidget *w;
01906 QObjectListIt it( *p->children() );
01907 it.toLast();
01908 while ( it.current() ) {
01909 if ( it.current()->isWidgetType() ) {
01910 w = (QWidget*)it.current();
01911 if ( w->isVisible() ) {
01912 if ( w->inherits("KDockWidget") ) list->append( w );
01913 findChildDockWidget( w, list );
01914 }
01915 }
01916 --it;
01917 }
01918 }
01919 return;
01920 }
01921
01922 void KDockManager::startDrag( KDockWidget* w )
01923 {
01924 if(( w->currentDockPos == KDockWidget::DockLeft) || ( w->currentDockPos == KDockWidget::DockRight)
01925 || ( w->currentDockPos == KDockWidget::DockTop) || ( w->currentDockPos == KDockWidget::DockBottom)) {
01926 w->prevSideDockPosBeforeDrag = w->currentDockPos;
01927
01928 if ( w->parentWidget()->inherits("KDockSplitter") ){
01929 KDockSplitter* parentSplitterOfDockWidget = (KDockSplitter*)(w->parentWidget());
01930 w->d->splitPosInPercent = parentSplitterOfDockWidget->separatorPos();
01931 }
01932 }
01933
01934 curPos = KDockWidget::DockDesktop;
01935 dragging = true;
01936
01937 QApplication::setOverrideCursor(QCursor(sizeAllCursor));
01938 }
01939
01940 void KDockManager::dragMove( KDockWidget* dw, QPoint pos )
01941 {
01942 QPoint p = dw->mapToGlobal( dw->widget->pos() );
01943 KDockWidget::DockPosition oldPos = curPos;
01944
01945 QSize r = dw->widget->size();
01946 if ( dw->parentDockTabGroup() ){
01947 curPos = KDockWidget::DockCenter;
01948 if ( oldPos != curPos ) {
01949 d->dragRect.setRect( p.x()+2, p.y()+2, r.width()-4, r.height()-4 );
01950 }
01951 return;
01952 }
01953
01954 int w = r.width() / 3;
01955 int h = r.height() / 3;
01956
01957 if ( pos.y() <= h ){
01958 curPos = KDockWidget::DockTop;
01959 w = r.width();
01960 } else
01961 if ( pos.y() >= 2*h ){
01962 curPos = KDockWidget::DockBottom;
01963 p.setY( p.y() + 2*h );
01964 w = r.width();
01965 } else
01966 if ( pos.x() <= w ){
01967 curPos = KDockWidget::DockLeft;
01968 h = r.height();
01969 } else
01970 if ( pos.x() >= 2*w ){
01971 curPos = KDockWidget::DockRight;
01972 p.setX( p.x() + 2*w );
01973 h = r.height();
01974 } else
01975 {
01976 curPos = KDockWidget::DockCenter;
01977 p.setX( p.x() + w );
01978 p.setY( p.y() + h );
01979 }
01980
01981 if ( oldPos != curPos ) {
01982 d->dragRect.setRect( p.x(), p.y(), w, h );
01983 drawDragRectangle();
01984 }
01985 }
01986
01987
01988 void KDockManager::cancelDrop()
01989 {
01990 QApplication::restoreOverrideCursor();
01991
01992 delete childDockWidgetList;
01993 childDockWidgetList = 0L;
01994
01995 d->dragRect = QRect();
01996 drawDragRectangle();
01997 }
01998
01999
02000 void KDockManager::drop()
02001 {
02002 d->dragRect = QRect();
02003 drawDragRectangle();
02004
02005 QApplication::restoreOverrideCursor();
02006
02007 delete childDockWidgetList;
02008 childDockWidgetList = 0L;
02009
02010 if ( dropCancel ) return;
02011 if ( !currentMoveWidget && ((currentDragWidget->eDocking & (int)KDockWidget::DockDesktop) == 0) ) {
02012 d->dragRect = QRect();
02013 drawDragRectangle();
02014 return;
02015 }
02016 if ( !currentMoveWidget && !currentDragWidget->parent() ) {
02017 currentDragWidget->move( QCursor::pos() - d->dragOffset );
02018 }
02019 else {
02020 int splitPos = currentDragWidget->d->splitPosInPercent;
02021
02022 if( (curPos != currentDragWidget->prevSideDockPosBeforeDrag) && (curPos != KDockWidget::DockCenter) && (curPos != KDockWidget::DockDesktop)) {
02023 switch( currentDragWidget->prevSideDockPosBeforeDrag) {
02024 case KDockWidget::DockLeft: if(curPos != KDockWidget::DockTop) splitPos = 100-splitPos; break;
02025 case KDockWidget::DockRight: if(curPos != KDockWidget::DockBottom) splitPos = 100-splitPos; break;
02026 case KDockWidget::DockTop: if(curPos != KDockWidget::DockLeft) splitPos = 100-splitPos; break;
02027 case KDockWidget::DockBottom: if(curPos != KDockWidget::DockRight) splitPos = 100-splitPos; break;
02028 default: break;
02029 }
02030 }
02031 currentDragWidget->manualDock( currentMoveWidget, curPos , splitPos, QCursor::pos() - d->dragOffset );
02032 currentDragWidget->makeDockVisible();
02033 }
02034 }
02035
02036
02037 static QDomElement createStringEntry(QDomDocument &doc, const QString &tagName, const QString &str)
02038 {
02039 QDomElement el = doc.createElement(tagName);
02040
02041 el.appendChild(doc.createTextNode(str));
02042 return el;
02043 }
02044
02045
02046 static QDomElement createBoolEntry(QDomDocument &doc, const QString &tagName, bool b)
02047 {
02048 return createStringEntry(doc, tagName, QString::fromLatin1(b? "true" : "false"));
02049 }
02050
02051
02052 static QDomElement createNumberEntry(QDomDocument &doc, const QString &tagName, int n)
02053 {
02054 return createStringEntry(doc, tagName, QString::number(n));
02055 }
02056
02057
02058 static QDomElement createRectEntry(QDomDocument &doc, const QString &tagName, const QRect &rect)
02059 {
02060 QDomElement el = doc.createElement(tagName);
02061
02062 QDomElement xel = doc.createElement("x");
02063 xel.appendChild(doc.createTextNode(QString::number(rect.x())));
02064 el.appendChild(xel);
02065 QDomElement yel = doc.createElement("y");
02066 yel.appendChild(doc.createTextNode(QString::number(rect.y())));
02067 el.appendChild(yel);
02068 QDomElement wel = doc.createElement("width");
02069 wel.appendChild(doc.createTextNode(QString::number(rect.width())));
02070 el.appendChild(wel);
02071 QDomElement hel = doc.createElement("height");
02072 hel.appendChild(doc.createTextNode(QString::number(rect.height())));
02073 el.appendChild(hel);
02074
02075 return el;
02076 }
02077
02078
02079 static QDomElement createListEntry(QDomDocument &doc, const QString &tagName,
02080 const QString &subTagName, const QStrList &list)
02081 {
02082 QDomElement el = doc.createElement(tagName);
02083
02084 QStrListIterator it(list);
02085 for (; it.current(); ++it) {
02086 QDomElement subel = doc.createElement(subTagName);
02087 subel.appendChild(doc.createTextNode(QString::fromLatin1(it.current())));
02088 el.appendChild(subel);
02089 }
02090
02091 return el;
02092 }
02093
02094
02095 static QString stringEntry(QDomElement &base, const QString &tagName)
02096 {
02097 return base.namedItem(tagName).firstChild().toText().data();
02098 }
02099
02100
02101 static bool boolEntry(QDomElement &base, const QString &tagName)
02102 {
02103 return base.namedItem(tagName).firstChild().toText().data() == "true";
02104 }
02105
02106
02107 static int numberEntry(QDomElement &base, const QString &tagName)
02108 {
02109 return stringEntry(base, tagName).toInt();
02110 }
02111
02112
02113 static QRect rectEntry(QDomElement &base, const QString &tagName)
02114 {
02115 QDomElement el = base.namedItem(tagName).toElement();
02116
02117 int x = numberEntry(el, "x");
02118 int y = numberEntry(el, "y");
02119 int width = numberEntry(el, "width");
02120 int height = numberEntry(el, "height");
02121
02122 return QRect(x, y, width, height);
02123 }
02124
02125
02126 static QStrList listEntry(QDomElement &base, const QString &tagName, const QString &subTagName)
02127 {
02128 QStrList list;
02129
02130 for( QDomNode n = base.namedItem(tagName).firstChild(); !n.isNull(); n = n.nextSibling() )
02131 {
02132 QDomElement subel = n.toElement();
02133 if (subel.tagName() == subTagName)
02134 list.append(subel.firstChild().toText().data().latin1());
02135 }
02136
02137 return list;
02138 }
02139
02140
02141 void KDockManager::writeConfig(QDomElement &base)
02142 {
02143
02144 while (!base.firstChild().isNull())
02145 base.removeChild(base.firstChild());
02146 QDomDocument doc = base.ownerDocument();
02147
02148 QStrList nameList;
02149 QString mainWidgetStr;
02150
02151
02152 QStringList nList;
02153 QObjectListIt it(*childDock);
02154 KDockWidget *obj1;
02155 while ( (obj1=(KDockWidget*)it.current()) ) {
02156 if ( obj1->parent() == main )
02157 mainWidgetStr = QString::fromLatin1(obj1->name());
02158 nList.append(obj1->name());
02159 ++it;
02160 }
02161
02162 for (QObjectListIt it(d->containerDocks);it.current();++it)
02163 {
02164 KDockContainer* dc = dynamic_cast<KDockContainer*>(((KDockWidget*)it.current())->widget);
02165 if (dc) {
02166 dc->prepareSave(nList);
02167 }
02168 }
02169
02170 QStringList::Iterator nListIt=nList.begin();
02171 while ( nListIt!=nList.end() ) {
02172 KDockWidget *obj = getDockWidgetFromName( *nListIt);
02173 if ((obj->isGroup && (!obj->d->isContainer)) && (nameList.find( obj->firstName.latin1() ) == -1
02174 || nameList.find(obj->lastName.latin1()) == -1)) {
02175
02176 ++nListIt;
02177
02178
02179 continue;
02180 }
02181
02182 QDomElement groupEl;
02183 if (obj->d->isContainer) {
02184 KDockContainer* x = dynamic_cast<KDockContainer*>(obj->widget);
02185 if (x) {
02186 groupEl=doc.createElement("dockContainer");
02187 x->save(groupEl);
02188 }
02189 } else
02190 if (obj->isGroup) {
02192 groupEl = doc.createElement("splitGroup");
02193
02194 groupEl.appendChild(createStringEntry(doc, "firstName", obj->firstName));
02195 groupEl.appendChild(createStringEntry(doc, "secondName", obj->lastName));
02196 groupEl.appendChild(createNumberEntry(doc, "orientation", (int)obj->splitterOrientation));
02197 groupEl.appendChild(createNumberEntry(doc, "separatorPos", ((KDockSplitter*)obj->widget)->separatorPos()));
02198 } else if (obj->isTabGroup) {
02200 groupEl = doc.createElement("tabGroup");
02201
02202 QStrList list;
02203 for ( int i = 0; i < ((KDockTabGroup*)obj->widget)->count(); ++i )
02204 list.append( ((KDockTabGroup*)obj->widget)->page( i )->name() );
02205 groupEl.appendChild(createListEntry(doc, "tabs", "tab", list));
02206 groupEl.appendChild(createNumberEntry(doc, "currentTab", ((KDockTabGroup*)obj->widget)->currentPageIndex()));
02207 if (!obj->parent()) {
02208 groupEl.appendChild(createStringEntry(doc, "dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : ""));
02209 groupEl.appendChild(createNumberEntry(doc, "dockBackToPos", obj->formerDockPos));
02210 }
02211 } else {
02213 groupEl = doc.createElement("dock");
02214 groupEl.appendChild(createStringEntry(doc, "tabCaption", obj->tabPageLabel()));
02215 groupEl.appendChild(createStringEntry(doc, "tabToolTip", obj->toolTipString()));
02216 if (!obj->parent()) {
02217 groupEl.appendChild(createStringEntry(doc, "dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : ""));
02218 groupEl.appendChild(createNumberEntry(doc, "dockBackToPos", obj->formerDockPos));
02219 }
02220 }
02221
02222 groupEl.appendChild(createStringEntry(doc, "name", QString::fromLatin1(obj->name())));
02223 groupEl.appendChild(createBoolEntry(doc, "hasParent", obj->parent()));
02224 if ( !obj->parent() ) {
02225 groupEl.appendChild(createRectEntry(doc, "geometry", QRect(main->frameGeometry().topLeft(), main->size())));
02226 groupEl.appendChild(createBoolEntry(doc, "visible", obj->isVisible()));
02227 }
02228 if (obj->header && obj->header->inherits("KDockWidgetHeader")) {
02229 KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
02230 groupEl.appendChild(createBoolEntry(doc, "dragEnabled", h->dragEnabled()));
02231 }
02232
02233 base.appendChild(groupEl);
02234 nameList.append(obj->name());
02235 nList.remove(nListIt);
02236 nListIt=nList.begin();
02237 }
02238
02239 if (main->inherits("KDockMainWindow")) {
02240 KDockMainWindow *dmain = (KDockMainWindow*)main;
02241 QString centralWidgetStr = QString(dmain->centralWidget()? dmain->centralWidget()->name() : "");
02242 base.appendChild(createStringEntry(doc, "centralWidget", centralWidgetStr));
02243 QString mainDockWidgetStr = QString(dmain->getMainDockWidget()? dmain->getMainDockWidget()->name() : "");
02244 base.appendChild(createStringEntry(doc, "mainDockWidget", mainDockWidgetStr));
02245 } else {
02246 base.appendChild(createStringEntry(doc, "mainWidget", mainWidgetStr));
02247 }
02248
02249 base.appendChild(createRectEntry(doc, "geometry", QRect(main->frameGeometry().topLeft(), main->size())));
02250 }
02251
02252
02253 void KDockManager::readConfig(QDomElement &base)
02254 {
02255 if (base.namedItem("group").isNull()
02256 && base.namedItem("tabgroup").isNull()
02257 && base.namedItem("dock").isNull()
02258 && base.namedItem("dockContainer").isNull()) {
02259 activate();
02260 return;
02261 }
02262
02263 autoCreateDock = new QObjectList();
02264 autoCreateDock->setAutoDelete( true );
02265
02266 bool isMainVisible = main->isVisible();
02267 main->hide();
02268
02269 QObjectListIt it(*childDock);
02270 KDockWidget *obj1;
02271 while ( (obj1=(KDockWidget*)it.current()) ) {
02272 if ( !obj1->isGroup && !obj1->isTabGroup ) {
02273 if ( obj1->parent() )
02274 obj1->undock();
02275 else
02276 obj1->hide();
02277 }
02278 ++it;
02279 }
02280
02281
02282 for( QDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
02283 {
02284 QDomElement childEl = n.toElement();
02285 if (childEl.tagName() != "dock") continue;
02286
02287
02288 KDockWidget *obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02289 obj->setTabPageLabel(stringEntry(childEl, "tabCaption"));
02290 obj->setToolTipString(stringEntry(childEl, "tabToolTip"));
02291
02292 if (!boolEntry(childEl, "hasParent")) {
02293 QRect r = rectEntry(childEl, "geometry");
02294 obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02295 obj->applyToWidget(0);
02296 obj->setGeometry(r);
02297 if (boolEntry(childEl, "visible"))
02298 obj->QWidget::show();
02299 }
02300
02301 if (obj && obj->header && obj->header->inherits("KDockWidgetHeader")) {
02302 KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
02303 h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
02304 }
02305 }
02306
02307
02308 for( QDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
02309 {
02310 QDomElement childEl = n.toElement();
02311 if (childEl.isNull()) continue;
02312
02313 KDockWidget *obj = 0;
02314
02315 if (childEl.tagName() == "dockContainer") {
02316
02317 KDockWidget *cont=getDockWidgetFromName(stringEntry(childEl, "name"));
02318 kdDebug()<<"dockContainer: "<<stringEntry(childEl,"name")<<endl;
02319 if (!(cont->d->isContainer)) {
02320 kdDebug()<<"restoration of dockContainer is only supported for already existing dock containers"<<endl;
02321 } else {
02322 KDockContainer *dc=dynamic_cast<KDockContainer*>(cont->getWidget());
02323 if (!dc) kdDebug()<<"Error while trying to handle dockcontainer configuration restoration"<<endl;
02324 else {
02325 dc->load(childEl);
02326 removeFromAutoCreateList(cont);
02327 }
02328
02329 }
02330 }
02331 else
02332 if (childEl.tagName() == "splitGroup") {
02333
02334 QString name = stringEntry(childEl, "name");
02335 QString firstName = stringEntry(childEl, "firstName");
02336 QString secondName = stringEntry(childEl, "secondName");
02337 int orientation = numberEntry(childEl, "orientation");
02338 int separatorPos = numberEntry(childEl, "separatorPos");
02339
02340 KDockWidget *first = getDockWidgetFromName(firstName);
02341 KDockWidget *second = getDockWidgetFromName(secondName);
02342 if (first && second) {
02343 obj = first->manualDock(second,
02344 (orientation == (int)Vertical)? KDockWidget::DockLeft : KDockWidget::DockTop,
02345 separatorPos);
02346 if (obj)
02347 obj->setName(name.latin1());
02348 }
02349 } else if (childEl.tagName() == "tabGroup") {
02350
02351 QString name = stringEntry(childEl, "name");
02352 QStrList list = listEntry(childEl, "tabs", "tab");
02353
02354 KDockWidget *d1 = getDockWidgetFromName( list.first() );
02355 list.next();
02356 KDockWidget *d2 = getDockWidgetFromName( list.current() );
02357
02358 KDockWidget *obj = d2->manualDock( d1, KDockWidget::DockCenter );
02359 if (obj) {
02360 KDockTabGroup *tab = (KDockTabGroup*)obj->widget;
02361 list.next();
02362 while (list.current() && obj) {
02363 KDockWidget *tabDock = getDockWidgetFromName(list.current());
02364 obj = tabDock->manualDock(d1, KDockWidget::DockCenter);
02365 list.next();
02366 }
02367 if (obj) {
02368 obj->setName(name.latin1());
02369 tab->showPage(tab->page(numberEntry(childEl, "currentTab")));
02370 }
02371 }
02372 } else {
02373 continue;
02374 }
02375
02376 if (!boolEntry(childEl, "hasParent")) {
02377 QRect r = rectEntry(childEl, "geometry");
02378 obj = getDockWidgetFromName(stringEntry(childEl, "name"));
02379 obj->applyToWidget(0);
02380 obj->setGeometry(r);
02381 if (boolEntry(childEl, "visible"))
02382 obj->QWidget::show();
02383 }
02384
02385 if (obj && obj->header && obj->header->inherits("KDockWidgetHeader")) {
02386 KDockWidgetHeader *h = static_cast<KDockWidgetHeader*>(obj->header);
02387 h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
02388 }
02389 }
02390
02391
02392
02393 for( QDomNode n = base.firstChild(); !n.isNull(); n = n.nextSibling() )
02394 {
02395 QDomElement childEl = n.toElement();
02396
02397 if (childEl.tagName() != "dock" && childEl.tagName() != "tabGroup")
02398 continue;
02399
02400 KDockWidget *obj = 0;
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 }
02413
02414 if (main->inherits("KDockMainWindow")) {
02415 KDockMainWindow *dmain = (KDockMainWindow*)main;
02416
02417 QString mv = stringEntry(base, "centralWidget");
02418 if (!mv.isEmpty() && getDockWidgetFromName(mv) ) {
02419 KDockWidget *mvd = getDockWidgetFromName(mv);
02420 mvd->applyToWidget(dmain);
02421 mvd->show();
02422 dmain->setCentralWidget(mvd);
02423 }
02424 QString md = stringEntry(base, "mainDockWidget");
02425 if (!md.isEmpty() && getDockWidgetFromName(md)) {
02426 KDockWidget *mvd = getDockWidgetFromName(md);
02427 dmain->setMainDockWidget(mvd);
02428 }
02429 } else {
02430 QString mv = stringEntry(base, "mainWidget");
02431 if (!mv.isEmpty() && getDockWidgetFromName(mv)) {
02432 KDockWidget *mvd = getDockWidgetFromName(mv);
02433 mvd->applyToWidget(main);
02434 mvd->show();
02435 }
02436
02437
02438 QRect mr = rectEntry(base, "geometry");
02439 main->move(mr.topLeft());
02440 main->resize(mr.size());
02441 }
02442
02443 if (isMainVisible)
02444 main->show();
02445
02446 if (d->m_readDockConfigMode == WrapExistingWidgetsOnly) {
02447 finishReadDockConfig();
02448 }
02449 }
02450
02451 void KDockManager::removeFromAutoCreateList(KDockWidget* pDockWidget)
02452 {
02453 if (!autoCreateDock) return;
02454 autoCreateDock->setAutoDelete(false);
02455 autoCreateDock->removeRef(pDockWidget);
02456 autoCreateDock->setAutoDelete(true);
02457 }
02458
02459 void KDockManager::finishReadDockConfig()
02460 {
02461 delete autoCreateDock;
02462 autoCreateDock = 0;
02463 }
02464
02465 void KDockManager::setReadDockConfigMode(int mode)
02466 {
02467 d->m_readDockConfigMode = mode;
02468 }
02469
02470 #ifndef NO_KDE2
02471 void KDockManager::writeConfig( KConfig* c, QString group )
02472 {
02473
02474 if ( !c ) c = KGlobal::config();
02475 if ( group.isEmpty() ) group = "dock_setting_default";
02476
02477 c->setGroup( group );
02478 c->writeEntry( "Version", DOCK_CONFIG_VERSION );
02479
02480 QStringList nameList;
02481 QStringList findList;
02482 QObjectListIt it( *childDock );
02483 KDockWidget * obj;
02484
02485
02486 QStringList nList;
02487 while ( (obj=(KDockWidget*)it.current()) ) {
02488 ++it;
02489
02490 nList.append( obj->name() );
02491 if ( obj->parent() == main )
02492 c->writeEntry( "Main:view", obj->name() );
02493 }
02494
02495
02496 for (QObjectListIt it(d->containerDocks);it.current();++it)
02497 {
02498 KDockContainer* dc = dynamic_cast<KDockContainer*>(((KDockWidget*)it.current())->widget);
02499 if (dc) {
02500 dc->prepareSave(nList);
02501 }
02502 }
02503
02504
02505 QStringList::Iterator nListIt=nList.begin();
02506 while ( nListIt!=nList.end() ){
02507
02508 obj = getDockWidgetFromName( *nListIt );
02509 QString cname = obj->name();
02510 if ( obj->header ){
02511 obj->header->saveConfig( c );
02512 }
02513 if (obj->d->isContainer) {
02514 KDockContainer* x = dynamic_cast<KDockContainer*>(obj->widget);
02515 if (x) {
02516 x->save(c,group);
02517 }
02518 }
02519
02520 if ( obj->isGroup ){
02521 if ( (findList.find( obj->firstName ) != findList.end()) && (findList.find( obj->lastName ) != findList.end() )){
02522
02523 c->writeEntry( cname+":type", "GROUP");
02524 if ( !obj->parent() ){
02525 c->writeEntry( cname+":parent", "___null___");
02526 c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
02527 c->writeEntry( cname+":visible", obj->isVisible());
02528 } else {
02529 c->writeEntry( cname+":parent", "yes");
02530 }
02531 c->writeEntry( cname+":first_name", obj->firstName );
02532 c->writeEntry( cname+":last_name", obj->lastName );
02533 c->writeEntry( cname+":orientation", (int)obj->splitterOrientation );
02534 c->writeEntry( cname+":sepPos", ((KDockSplitter*)obj->widget)->separatorPos() );
02535
02536 nameList.append( obj->name() );
02537 findList.append( obj->name() );
02538
02539 nList.remove(nListIt);
02540 nListIt=nList.begin();
02541 } else {
02542
02543
02544
02545
02546
02547
02548 ++nListIt;
02549
02550 if (nListIt==nList.end()) nListIt=nList.begin();
02551 }
02552 } else {
02553
02554 if ( obj->isTabGroup){
02555 c->writeEntry( cname+":type", "TAB_GROUP");
02556 if ( !obj->parent() ){
02557 c->writeEntry( cname+":parent", "___null___");
02558 c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
02559 c->writeEntry( cname+":visible", obj->isVisible());
02560 c->writeEntry( cname+":dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : "");
02561 c->writeEntry( cname+":dockBackToPos", obj->formerDockPos);
02562 } else {
02563 c->writeEntry( cname+":parent", "yes");
02564 }
02565 QStrList list;
02566 for ( int i = 0; i < ((KDockTabGroup*)obj->widget)->count(); ++i )
02567 list.append( ((KDockTabGroup*)obj->widget)->page( i )->name() );
02568 c->writeEntry( cname+":tabNames", list );
02569 c->writeEntry( cname+":curTab", ((KDockTabGroup*)obj->widget)->currentPageIndex() );
02570
02571 nameList.append( obj->name() );
02572 findList.append( obj->name() );
02573
02574 nList.remove(nListIt);
02575 nListIt=nList.begin();
02576 } else {
02577
02578 c->writeEntry( cname+":tabCaption", obj->tabPageLabel());
02579 c->writeEntry( cname+":tabToolTip", obj->toolTipString());
02580 if ( !obj->parent() ){
02581 c->writeEntry( cname+":type", "NULL_DOCK");
02582 c->writeEntry( cname+":geometry", QRect(obj->frameGeometry().topLeft(), obj->size()) );
02583 c->writeEntry( cname+":visible", obj->isVisible());
02584 c->writeEntry( cname+":dockBackTo", obj->formerBrotherDockWidget ? obj->formerBrotherDockWidget->name() : "");
02585 c->writeEntry( cname+":dockBackToPos", obj->formerDockPos);
02586 } else {
02587 c->writeEntry( cname+":type", "DOCK");
02588 }
02589 nameList.append( cname.latin1() );
02590
02591 findList.append( obj->name() );
02592 nList.remove(nListIt);
02593 nListIt=nList.begin();
02594 }
02595 }
02596 }
02597 c->writeEntry( "NameList", nameList );
02598
02599 c->writeEntry( "Main:Geometry", QRect(main->frameGeometry().topLeft(), main->size()) );
02600 c->writeEntry( "Main:visible", main->isVisible());
02601
02602 if ( main->inherits("KDockMainWindow") ){
02603 KDockMainWindow* dmain = (KDockMainWindow*)main;
02604
02605 c->writeEntry( "Main:view", dmain->centralWidget() ? dmain->centralWidget()->name():"" );
02606 c->writeEntry( "Main:dock", dmain->getMainDockWidget() ? dmain->getMainDockWidget()->name() :"" );
02607 }
02608
02609 c->sync();
02610
02611 }
02612 #include <qmessagebox.h>
02613 void KDockManager::readConfig( KConfig* c, QString group )
02614 {
02615 if ( !c ) c = KGlobal::config();
02616 if ( group.isEmpty() ) group = "dock_setting_default";
02617
02618 c->setGroup( group );
02619 QStrList nameList;
02620 c->readListEntry( "NameList", nameList );
02621 QString ver = c->readEntry( "Version", "0.0.1" );
02622 nameList.first();
02623 if ( !nameList.current() || ver != DOCK_CONFIG_VERSION ){
02624 activate();
02625 return;
02626 }
02627
02628 autoCreateDock = new QObjectList();
02629 autoCreateDock->setAutoDelete( true );
02630
02631 bool isMainVisible = main->isVisible();
02632
02633
02634
02635
02636 QObjectListIt it( *childDock );
02637 KDockWidget * obj;
02638
02639 while ( (obj=(KDockWidget*)it.current()) ){
02640 ++it;
02641 if ( !obj->isGroup && !obj->isTabGroup )
02642 {
02643 if ( obj->parent() ) obj->undock(); else obj->hide();
02644 }
02645 }
02646
02647
02648
02649 nameList.first();
02650 while ( nameList.current() ){
02651 QString oname = nameList.current();
02652 c->setGroup( group );
02653 QString type = c->readEntry( oname + ":type" );
02654 obj = 0L;
02655
02656 if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
02657 QRect r = c->readRectEntry( oname + ":geometry" );
02658 obj = getDockWidgetFromName( oname );
02659 obj->applyToWidget( 0L );
02660 obj->setGeometry(r);
02661
02662 c->setGroup( group );
02663 obj->setTabPageLabel(c->readEntry( oname + ":tabCaption" ));
02664 obj->setToolTipString(c->readEntry( oname + ":tabToolTip" ));
02665 if ( c->readBoolEntry( oname + ":visible" ) ){
02666 obj->QWidget::show();
02667 }
02668 }
02669
02670 if ( type == "DOCK" ){
02671 obj = getDockWidgetFromName( oname );
02672 obj->setTabPageLabel(c->readEntry( oname + ":tabCaption" ));
02673 obj->setToolTipString(c->readEntry( oname + ":tabToolTip" ));
02674 }
02675
02676 if (obj && obj->d->isContainer) {
02677 dynamic_cast<KDockContainer*>(obj->widget)->load(c,group);
02678 removeFromAutoCreateList(obj);
02679 }
02680 if ( obj && obj->header){
02681 obj->header->loadConfig( c );
02682 }
02683 nameList.next();
02684 }
02685
02686
02687 nameList.first();
02688 while ( nameList.current() ){
02689 QString oname = nameList.current();
02690 c->setGroup( group );
02691 QString type = c->readEntry( oname + ":type" );
02692 obj = 0L;
02693
02694 if ( type == "GROUP" ){
02695 KDockWidget* first = getDockWidgetFromName( c->readEntry( oname + ":first_name" ) );
02696 KDockWidget* last = getDockWidgetFromName( c->readEntry( oname + ":last_name" ) );
02697 int sepPos = c->readNumEntry( oname + ":sepPos" );
02698
02699 Orientation p = (Orientation)c->readNumEntry( oname + ":orientation" );
02700 if ( first && last ){
02701 obj = first->manualDock( last, ( p == Vertical ) ? KDockWidget::DockLeft : KDockWidget::DockTop, sepPos );
02702 if (obj){
02703 obj->setName( oname.latin1() );
02704 }
02705 }
02706 }
02707
02708 if ( type == "TAB_GROUP" ){
02709 QStrList list;
02710 KDockWidget* tabDockGroup = 0L;
02711 c->readListEntry( oname+":tabNames", list );
02712 KDockWidget* d1 = getDockWidgetFromName( list.first() );
02713 list.next();
02714 KDockWidget* d2 = getDockWidgetFromName( list.current() );
02715 tabDockGroup = d2->manualDock( d1, KDockWidget::DockCenter );
02716 if ( tabDockGroup ){
02717 KDockTabGroup* tab = dynamic_cast<KDockTabGroup*>( tabDockGroup->widget );
02718 list.next();
02719 while ( list.current() && tabDockGroup ){
02720 KDockWidget* tabDock = getDockWidgetFromName( list.current() );
02721 tabDockGroup = tabDock->manualDock( d1, KDockWidget::DockCenter );
02722 list.next();
02723 }
02724 if ( tabDockGroup ){
02725 tabDockGroup->setName( oname.latin1() );
02726 c->setGroup( group );
02727 if ( tab )
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
02792 if (d->m_readDockConfigMode == WrapExistingWidgetsOnly) {
02793 finishReadDockConfig();
02794 }
02795
02796 c->setGroup( group );
02797 QRect mr = c->readRectEntry("Main:Geometry");
02798 main->move(mr.topLeft());
02799 main->resize(mr.size());
02800 if ( isMainVisible ) main->show();
02801 }
02802 #endif
02803
02804
02805 void KDockManager::dumpDockWidgets() {
02806 QObjectListIt it( *childDock );
02807 KDockWidget * obj;
02808 while ( (obj=(KDockWidget*)it.current()) ) {
02809 ++it;
02810 kdDebug()<<"KDockManager::dumpDockWidgets:"<<obj->name()<<endl;
02811 }
02812
02813 }
02814
02815 KDockWidget* KDockManager::getDockWidgetFromName( const QString& dockName )
02816 {
02817 QObjectListIt it( *childDock );
02818 KDockWidget * obj;
02819 while ( (obj=(KDockWidget*)it.current()) ) {
02820 ++it;
02821 if ( QString(obj->name()) == dockName ) return obj;
02822 }
02823
02824 KDockWidget* autoCreate = 0L;
02825 if ( autoCreateDock ){
02826 kdDebug()<<"Autocreating dock: "<<dockName<<endl;
02827 autoCreate = new KDockWidget( this, dockName.latin1(), QPixmap("") );
02828 autoCreateDock->append( autoCreate );
02829 }
02830 return autoCreate;
02831 }
02832 void KDockManager::setSplitterOpaqueResize(bool b)
02833 {
02834 d->splitterOpaqueResize = b;
02835 }
02836
02837 bool KDockManager::splitterOpaqueResize() const
02838 {
02839 return d->splitterOpaqueResize;
02840 }
02841
02842 void KDockManager::setSplitterKeepSize(bool b)
02843 {
02844 d->splitterKeepSize = b;
02845 }
02846
02847 bool KDockManager::splitterKeepSize() const
02848 {
02849 return d->splitterKeepSize;
02850 }
02851
02852 void KDockManager::setSplitterHighResolution(bool b)
02853 {
02854 d->splitterHighResolution = b;
02855 }
02856
02857 bool KDockManager::splitterHighResolution() const
02858 {
02859 return d->splitterHighResolution;
02860 }
02861
02862 void KDockManager::slotMenuPopup()
02863 {
02864 menu->clear();
02865 menuData->clear();
02866
02867 QObjectListIt it( *childDock );
02868 KDockWidget * obj;
02869 int numerator = 0;
02870 while ( (obj=(KDockWidget*)it.current()) ) {
02871 ++it;
02872 if ( obj->mayBeHide() )
02873 {
02874 menu->insertItem( obj->icon() ? *(obj->icon()) : QPixmap(), i18n("Hide %1").arg(obj->caption()), numerator++ );
02875 menuData->append( new MenuDockData( obj, true ) );
02876 }
02877
02878 if ( obj->mayBeShow() )
02879 {
02880 menu->insertItem( obj->icon() ? *(obj->icon()) : QPixmap(), i18n("Show %1").arg(obj->caption()), numerator++ );
02881 menuData->append( new MenuDockData( obj, false ) );
02882 }
02883 }
02884 }
02885
02886 void KDockManager::slotMenuActivated( int id )
02887 {
02888 MenuDockData* data = menuData->at( id );
02889 data->dock->changeHideShowState();
02890 }
02891
02892 KDockWidget* KDockManager::findWidgetParentDock( QWidget* w ) const
02893 {
02894 QObjectListIt it( *childDock );
02895 KDockWidget * dock;
02896 KDockWidget * found = 0L;
02897
02898 while ( (dock=(KDockWidget*)it.current()) ) {
02899 ++it;
02900 if ( dock->widget == w ){ found = dock; break; }
02901 }
02902 return found;
02903 }
02904
02905 void KDockManager::drawDragRectangle()
02906 {
02907 if (d->oldDragRect == d->dragRect)
02908 return;
02909
02910 int i;
02911 QRect oldAndNewDragRect[2];
02912 oldAndNewDragRect[0] = d->oldDragRect;
02913 oldAndNewDragRect[1] = d->dragRect;
02914
02915
02916 for (i = 0; i <= 1; i++) {
02917 if (oldAndNewDragRect[i].isEmpty())
02918 continue;
02919
02920 KDockWidget* pDockWdgAtRect = (KDockWidget*) QApplication::widgetAt( oldAndNewDragRect[i].topLeft(), true );
02921 if (!pDockWdgAtRect)
02922 continue;
02923
02924 bool isOverMainWdg = false;
02925 bool unclipped;
02926 KDockMainWindow* pMain = 0L;
02927 KDockWidget* pTLDockWdg = 0L;
02928 QWidget* topWdg;
02929 if (pDockWdgAtRect->topLevelWidget() == main) {
02930 isOverMainWdg = true;
02931 topWdg = pMain = (KDockMainWindow*) main;
02932 unclipped = pMain->testWFlags( WPaintUnclipped );
02933 pMain->setWFlags( WPaintUnclipped );
02934 }
02935 else {
02936 topWdg = pTLDockWdg = (KDockWidget*) pDockWdgAtRect->topLevelWidget();
02937 unclipped = pTLDockWdg->testWFlags( WPaintUnclipped );
02938 pTLDockWdg->setWFlags( WPaintUnclipped );
02939 }
02940
02941
02942 QPainter p;
02943 p.begin( topWdg );
02944 if ( !unclipped ) {
02945 if (isOverMainWdg)
02946 pMain->clearWFlags(WPaintUnclipped);
02947 else
02948 pTLDockWdg->clearWFlags(WPaintUnclipped);
02949 }
02950
02951 p.setRasterOp(Qt::NotXorROP);
02952 QRect r = oldAndNewDragRect[i];
02953 r.moveTopLeft( r.topLeft() - topWdg->mapToGlobal(QPoint(0,0)) );
02954 p.drawRect(r.x(), r.y(), r.width(), r.height());
02955 p.end();
02956 }
02957
02958
02959 d->oldDragRect = d->dragRect;
02960 }
02961
02962 void KDockManager::setSpecialLeftDockContainer(KDockWidget* container) {
02963 d->leftContainer=container;
02964 }
02965
02966 void KDockManager::setSpecialTopDockContainer(KDockWidget* container) {
02967 d->topContainer=container;
02968 }
02969
02970 void KDockManager::setSpecialRightDockContainer(KDockWidget* container) {
02971 d->rightContainer=container;
02972
02973 }
02974
02975 void KDockManager::setSpecialBottomDockContainer(KDockWidget* container) {
02976 d->bottomContainer=container;
02977 }
02978
02979
02980 KDockArea::KDockArea( QWidget* parent, const char *name)
02981 :QWidget( parent, name)
02982 {
02983 QString new_name = QString(name) + QString("_DockManager");
02984 dockManager = new KDockManager( this, new_name.latin1() );
02985 mainDockWidget = 0L;
02986 }
02987
02988 KDockArea::~KDockArea()
02989 {
02990 delete dockManager;
02991 }
02992
02993 KDockWidget* KDockArea::createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent, const QString& strCaption, const QString& strTabPageLabel)
02994 {
02995 return new KDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
02996 }
02997
02998 void KDockArea::makeDockVisible( KDockWidget* dock )
02999 {
03000 if ( dock != 0L)
03001 dock->makeDockVisible();
03002 }
03003
03004 void KDockArea::makeDockInvisible( KDockWidget* dock )
03005 {
03006 if ( dock != 0L)
03007 dock->undock();
03008 }
03009
03010 void KDockArea::makeWidgetDockVisible( QWidget* widget )
03011 {
03012 makeDockVisible( dockManager->findWidgetParentDock(widget) );
03013 }
03014
03015 void KDockArea::writeDockConfig(QDomElement &base)
03016 {
03017 dockManager->writeConfig(base);
03018 }
03019
03020 void KDockArea::readDockConfig(QDomElement &base)
03021 {
03022 dockManager->readConfig(base);
03023 }
03024
03025 void KDockArea::slotDockWidgetUndocked()
03026 {
03027 QObject* pSender = (QObject*) sender();
03028 if (!pSender->inherits("KDockWidget")) return;
03029 KDockWidget* pDW = (KDockWidget*) pSender;
03030 emit dockWidgetHasUndocked( pDW);
03031 }
03032
03033 void KDockArea::resizeEvent(QResizeEvent *rsize)
03034 {
03035 QWidget::resizeEvent(rsize);
03036 if (children()){
03037 #ifndef NO_KDE2
03038
03039 #endif
03040 QObjectList *list=queryList("QWidget",0,false);
03041
03042 QObjectListIt it( *list );
03043 QObject *obj;
03044
03045 while ( (obj = it.current()) != 0 ) {
03046
03047 ((QWidget*)obj)->setGeometry(QRect(QPoint(0,0),size()));
03048 break;
03049 }
03050 delete list;
03051 #if 0
03052 KDockSplitter *split;
03053
03054 {
03055
03056
03057 QObject *obj=children()->getFirst();
03058 if (split = dynamic_cast<KDockSplitter*>(obj))
03059 {
03060 split->setGeometry( QRect(QPoint(0,0), size() ));
03061
03062 }
03063 }
03064 #endif
03065 }
03066 }
03067
03068 #ifndef NO_KDE2
03069 void KDockArea::writeDockConfig( KConfig* c, QString group )
03070 {
03071 dockManager->writeConfig( c, group );
03072 }
03073
03074 void KDockArea::readDockConfig( KConfig* c, QString group )
03075 {
03076 dockManager->readConfig( c, group );
03077 }
03078
03079 void KDockArea::setMainDockWidget( KDockWidget* mdw )
03080 {
03081 if ( mainDockWidget == mdw ) return;
03082 mainDockWidget = mdw;
03083 mdw->applyToWidget(this);
03084 }
03085 #endif
03086
03087
03088
03089
03090 KDockContainer::KDockContainer(){m_overlapMode=false; m_childrenListBegin=0; m_childrenListEnd=0;}
03091 KDockContainer::~KDockContainer(){
03092
03093 if (m_childrenListBegin!=0)
03094 {
03095 struct ListItem *tmp=m_childrenListBegin;
03096 while (tmp)
03097 {
03098 struct ListItem *tmp2=tmp->next;
03099 free(tmp->data);
03100 delete tmp;
03101 tmp=tmp2;
03102 }
03103 m_childrenListBegin=0;
03104 m_childrenListEnd=0;
03105 }
03106
03107 }
03108
03109 void KDockContainer::activateOverlapMode(int nonOverlapSize) {
03110 m_nonOverlapSize=nonOverlapSize;
03111 m_overlapMode=true;
03112 if (parentDockWidget()) {
03113 if (parentDockWidget()->parent()) {
03114 kdDebug()<<"KDockContainer::activateOverlapMode: recalculating sizes"<<endl;
03115 KDockSplitter *sp= static_cast<KDockSplitter*>(parentDockWidget()->
03116 parent()->qt_cast("KDockSplitter"));
03117 if (sp) sp->resizeEvent(0);
03118 }
03119 }
03120 }
03121
03122 void KDockContainer::deactivateOverlapMode() {
03123 if (!m_overlapMode) return;
03124 m_overlapMode=false;
03125 if (parentDockWidget()) {
03126 if (parentDockWidget()->parent()) {
03127 kdDebug()<<"KDockContainer::deactivateOverlapMode: recalculating sizes"<<endl;
03128 KDockSplitter *sp= static_cast<KDockSplitter*>(parentDockWidget()->
03129 parent()->qt_cast("KDockSplitter"));
03130 if (sp) sp->resizeEvent(0);
03131 }
03132 }
03133
03134 }
03135
03136 bool KDockContainer::isOverlapMode() {
03137 return m_overlapMode;
03138 }
03139
03140 KDockWidget *KDockContainer::parentDockWidget(){return 0;}
03141
03142 QStringList KDockContainer::containedWidgets() const {
03143 QStringList tmp;
03144 for (struct ListItem *it=m_childrenListBegin;it;it=it->next) {
03145 tmp<<QString(it->data);
03146 }
03147
03148 return tmp;
03149 }
03150
03151 void KDockContainer::showWidget(KDockWidget *) {
03152 }
03153
03154 void KDockContainer::insertWidget (KDockWidget *dw, QPixmap, const QString &, int &)
03155 {
03156 struct ListItem *it=new struct ListItem;
03157 it->data=strdup(dw->name());
03158 it->next=0;
03159
03160 if (m_childrenListEnd)
03161 {
03162 m_childrenListEnd->next=it;
03163 it->prev=m_childrenListEnd;
03164 m_childrenListEnd=it;
03165 }
03166 else
03167 {
03168 it->prev=0;
03169 m_childrenListEnd=it;
03170 m_childrenListBegin=it;
03171 }
03172 }
03173 void KDockContainer::removeWidget (KDockWidget *dw){
03174 for (struct ListItem *tmp=m_childrenListBegin;tmp;tmp=tmp->next)
03175 {
03176 if (!strcmp(tmp->data,dw->name()))
03177 {
03178 free(tmp->data);
03179 if (tmp->next) tmp->next->prev=tmp->prev;
03180 if (tmp->prev) tmp->prev->next=tmp->next;
03181 if (tmp==m_childrenListBegin) m_childrenListBegin=tmp->next;
03182 if (tmp==m_childrenListEnd) m_childrenListEnd=tmp->prev;
03183 delete tmp;
03184 break;
03185 }
03186 }
03187 }
03188
03189
03190 void KDockContainer::undockWidget (KDockWidget *){;}
03191 void KDockContainer::setToolTip(KDockWidget *, QString &){;}
03192 void KDockContainer::setPixmap(KDockWidget*,const QPixmap&){;}
03193 void KDockContainer::load (KConfig*, const QString&){;}
03194 void KDockContainer::save (KConfig*, const QString&){;}
03195 void KDockContainer::load (QDomElement&){;}
03196 void KDockContainer::save (QDomElement&){;}
03197 void KDockContainer::prepareSave(QStringList &names)
03198 {
03199
03200 for (struct ListItem *tmp=m_childrenListBegin;tmp; tmp=tmp->next)
03201 names.remove(tmp->data);
03202
03203
03204
03205
03206 }
03207
03208
03209 QWidget *KDockTabGroup::transientTo() {
03210 QWidget *tT=0;
03211 for (int i=0;i<count();i++) {
03212 KDockWidget *dw=static_cast<KDockWidget*>(page(i)->qt_cast("KDockWidget"));
03213 QWidget *tmp;
03214 if ((tmp=dw->transientTo())) {
03215 if (!tT) tT=tmp;
03216 else {
03217 if (tT!=tmp) {
03218 kdDebug()<<"KDockTabGroup::transientTo: widget mismatch"<<endl;
03219 return 0;
03220 }
03221 }
03222 }
03223 }
03224
03225 kdDebug()<<"KDockTabGroup::transientTo: "<<((tT!=0)?"YES":"NO")<<endl;
03226
03227 return tT;
03228 }
03229
03230 void KDockWidgetAbstractHeader::virtual_hook( int, void* )
03231 { }
03232
03233 void KDockWidgetAbstractHeaderDrag::virtual_hook( int, void* )
03234 { }
03235
03236 void KDockWidgetHeaderDrag::virtual_hook( int id, void* data )
03237 { KDockWidgetAbstractHeaderDrag::virtual_hook( id, data ); }
03238
03239 void KDockWidgetHeader::virtual_hook( int id, void* data )
03240 { KDockWidgetAbstractHeader::virtual_hook( id, data ); }
03241
03242 void KDockTabGroup::virtual_hook( int, void* )
03243 { }
03244
03245 void KDockWidget::virtual_hook( int, void* )
03246 { }
03247
03248 void KDockManager::virtual_hook( int, void* )
03249 { }
03250
03251 void KDockMainWindow::virtual_hook( int id, void* data )
03252 { KMainWindow::virtual_hook( id, data ); }
03253
03254 void KDockArea::virtual_hook( int, void* )
03255 { }
03256
03257
03258 #ifndef NO_INCLUDE_MOCFILES // for Qt-only projects, because tmake doesn't take this name
03259 #include "kdockwidget.moc"
03260 #endif