kdeui Library API Documentation

kdockwidget.cpp

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