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