00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #include "config.h"
00031
00032 #include <assert.h>
00033
00034 #include <qcursor.h>
00035 #include <qclipboard.h>
00036 #include <qobjectlist.h>
00037 #include <qpopupmenu.h>
00038 #include <qmenubar.h>
00039
00040 #include <kmenubar.h>
00041 #include <kapplication.h>
00042 #include <kdebug.h>
00043 #include <kdeversion.h>
00044 #include <qtabwidget.h>
00045 #include <klocale.h>
00046 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00047 #include <kipc.h>
00048 #endif
00049
00050 #include <kiconloader.h>
00051 #include <kmdidockcontainer.h>
00052
00053
00054 #include <qtoolbutton.h>
00055 #include <qlayout.h>
00056 #include <qtimer.h>
00057 #include <qtextstream.h>
00058 #include <qstring.h>
00059 #include <qmap.h>
00060 #include <qvaluelist.h>
00061
00062 #include "kmdimainfrm.h"
00063 #include "kmditaskbar.h"
00064 #include "kmdichildfrm.h"
00065 #include "kmdichildarea.h"
00066 #include "kmdichildview.h"
00067 #include "kmdidockcontainer.h"
00068 #include "kmditoolviewaccessor_p.h"
00069 #include "kmdifocuslist.h"
00070 #include "kmdidocumentviewtabwidget.h"
00071 # include "kmdiguiclient.h"
00072
00073 #include "win_undockbutton.xpm"
00074 #include "win_minbutton.xpm"
00075 #include "win_restorebutton.xpm"
00076 #include "win_closebutton.xpm"
00077 #include "kde_undockbutton.xpm"
00078 #include "kde_minbutton.xpm"
00079 #include "kde_restorebutton.xpm"
00080 #include "kde_closebutton.xpm"
00081 #include "kde2_undockbutton.xpm"
00082 #include "kde2_minbutton.xpm"
00083 #include "kde2_restorebutton.xpm"
00084 #include "kde2_closebutton.xpm"
00085 #include "kde2laptop_undockbutton.xpm"
00086 #include "kde2laptop_minbutton.xpm"
00087 #include "kde2laptop_restorebutton.xpm"
00088 #include "kde2laptop_closebutton.xpm"
00089 #include "kde2laptop_closebutton_menu.xpm"
00090
00091 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00092 #ifndef NO_KDE
00093 #include <X11/X.h>
00094 #include <X11/Xlib.h>
00095 #endif
00096
00097 #ifdef KeyRelease
00098
00099 #undef KeyRelease
00100 #endif
00101
00102 #ifdef KeyPress
00103
00104 #undef KeyPress
00105 #endif
00106 #endif // Q_WS_X11 && ! K_WS_QTONLY
00107
00108 using namespace KParts;
00109
00110 KMdi::FrameDecor KMdiMainFrm::m_frameDecoration = KMdi::KDELook;
00111
00112
00113
00114
00115 class KMdiMainFrmPrivate {
00116 public:
00117 KMdiMainFrmPrivate(): focusList(0) {
00118 for (int i=0;i<4;i++) activeDockPriority[i]=0;
00119 }
00120 ~KMdiMainFrmPrivate(){}
00121 KMdiDockContainer* activeDockPriority[4];
00122 KMdiFocusList *focusList;
00123 int m_styleIDEAlMode;
00124 };
00125
00126
00127 KMdiMainFrm::KMdiMainFrm(QWidget* parentWidget, const char* name, KMdi::MdiMode mdiMode,WFlags flags)
00128 : KParts::DockMainWindow( parentWidget, name, flags)
00129 ,m_mdiMode(KMdi::UndefinedMode)
00130 ,m_pMdi(0L)
00131 ,m_pTaskBar(0L)
00132 ,m_pDocumentViews(0L)
00133 ,m_pCurrentWindow(0L)
00134 ,m_pWindowPopup(0L)
00135 ,m_pTaskBarPopup(0L)
00136 ,m_pWindowMenu(0L)
00137 ,m_pDockMenu(0L)
00138 ,m_pMdiModeMenu(0L)
00139 ,m_pPlacingMenu(0L)
00140 ,m_pMainMenuBar(0L)
00141 ,m_pUndockButtonPixmap(0L)
00142 ,m_pMinButtonPixmap(0L)
00143 ,m_pRestoreButtonPixmap(0L)
00144 ,m_pCloseButtonPixmap(0L)
00145 ,m_pUndock(0L)
00146 ,m_pMinimize(0L)
00147 ,m_pRestore(0L)
00148 ,m_pClose(0L)
00149 ,m_bMaximizedChildFrmMode(false)
00150 ,m_oldMainFrmHeight(0)
00151 ,m_oldMainFrmMinHeight(0)
00152 ,m_oldMainFrmMaxHeight(0)
00153 ,m_bSDIApplication(false)
00154 ,m_pDockbaseAreaOfDocumentViews(0L)
00155 ,m_pTempDockSession(0L)
00156 ,m_bClearingOfWindowMenuBlocked(false)
00157 ,m_pDragEndTimer(0L)
00158 ,m_bSwitching(false)
00159 ,m_leftContainer(0)
00160 ,m_rightContainer(0)
00161 ,m_topContainer(0)
00162 ,m_bottomContainer(0)
00163 ,d(new KMdiMainFrmPrivate())
00164 ,m_mdiGUIClient(0)
00165 ,m_documentTabWidget(0)
00166 ,m_managedDockPositionMode(false)
00167 {
00168
00169 m_pDocumentViews = new QPtrList<KMdiChildView>;
00170 m_pDocumentViews->setAutoDelete(false);
00171 m_pToolViews = new QMap<QWidget*,KMdiToolViewAccessor*>;
00172
00173
00174 setFocusPolicy(ClickFocus);
00175
00176
00177 createMdiManager();
00178
00179
00180 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover");
00181 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true);
00182 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone);
00183 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner);
00184 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi);
00185
00186 setView(m_pDockbaseAreaOfDocumentViews);
00187 setMainDockWidget(m_pDockbaseAreaOfDocumentViews);
00188
00189
00190 applyOptions();
00191
00192 m_pTaskBarPopup=new QPopupMenu( this, "taskbar_popup_menu");
00193 m_pWindowPopup=new QPopupMenu( this, "window_popup_menu");
00194
00195 m_pWindowMenu = new QPopupMenu( this, "window_menu");
00196 m_pWindowMenu->setCheckable( true);
00197 QObject::connect( m_pWindowMenu, SIGNAL(aboutToShow()), this, SLOT(fillWindowMenu()) );
00198
00199 m_pDockMenu = new QPopupMenu( this, "dock_menu");
00200 m_pDockMenu->setCheckable( true);
00201
00202 m_pMdiModeMenu = new QPopupMenu( this, "mdimode_menu");
00203 m_pMdiModeMenu->setCheckable( true);
00204
00205 m_pPlacingMenu = new QPopupMenu( this, "placing_menu");
00206
00207
00208 createTaskBar();
00209
00210
00211
00212 setMenuForSDIModeSysButtons(menuBar());
00213
00214 switch (mdiMode) {
00215 case KMdi::IDEAlMode:
00216 kdDebug(760)<<"switch(mdiMode): IDEAlMode"<<endl;
00217 switchToIDEAlMode();
00218 break;
00219 case KMdi::TabPageMode:
00220 kdDebug(760)<<"switch(mdiMode): TabPageMode"<<endl;
00221 switchToTabPageMode();
00222 break;
00223 case KMdi::ToplevelMode:
00224 kdDebug(760)<<"switch(mdiMode): TopLevelMode"<<endl;
00225 switchToToplevelMode();
00226 break;
00227 default:
00228 m_mdiMode=KMdi::ChildframeMode;
00229 kdDebug(760)<<"switch(mdiMode): default"<<endl;
00230 break;
00231 }
00232
00233
00234 m_pDragEndTimer = new QTimer();
00235 connect(m_pDragEndTimer, SIGNAL(timeout()), this, SLOT(dragEndTimeOut()));
00236 }
00237
00238 void KMdiMainFrm::setStandardMDIMenuEnabled(bool showModeMenu) {
00239 m_mdiGUIClient=new KMDIPrivate::KMDIGUIClient(this,showModeMenu);
00240 connect(m_mdiGUIClient,SIGNAL(toggleTop()),this,SIGNAL(toggleTop()));
00241 connect(m_mdiGUIClient,SIGNAL(toggleLeft()),this,SIGNAL(toggleLeft()));
00242 connect(m_mdiGUIClient,SIGNAL(toggleRight()),this,SIGNAL(toggleRight()));
00243 connect(m_mdiGUIClient,SIGNAL(toggleBottom()),this,SIGNAL(toggleBottom()));
00244
00245 if (m_mdiMode==KMdi::IDEAlMode) {
00246 if (m_topContainer)
00247 connect(this,SIGNAL(toggleTop()),m_topContainer->getWidget(),SLOT(toggle()));
00248 if (m_leftContainer)
00249 connect(this,SIGNAL(toggleLeft()),m_leftContainer->getWidget(),SLOT(toggle()));
00250 if (m_rightContainer)
00251 connect(this,SIGNAL(toggleRight()),m_rightContainer->getWidget(),SLOT(toggle()));
00252 if (m_bottomContainer)
00253 connect(this,SIGNAL(toggleBottom()),m_bottomContainer->getWidget(),SLOT(toggle()));
00254 }
00255
00256 mdiModeHasBeenChangedTo(m_mdiMode);
00257 }
00258
00259
00260 KMdiMainFrm::~KMdiMainFrm()
00261 {
00262 delete d;
00263 d=0;
00264
00265 QValueList<KMdiChildView *> children;
00266 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()){
00267 children.append(w);
00268 }
00269
00270 QValueListIterator<KMdiChildView *> childIt;
00271 for (childIt = children.begin(); childIt != children.end(); ++childIt)
00272 {
00273 closeWindow(*childIt, false);
00274 }
00275 emit lastChildViewClosed();
00276 delete m_pDocumentViews;
00277 delete m_pToolViews;
00278 m_pToolViews=0;
00279 delete m_pDragEndTimer;
00280
00281 delete m_pUndockButtonPixmap;
00282 delete m_pMinButtonPixmap;
00283 delete m_pRestoreButtonPixmap;
00284 delete m_pCloseButtonPixmap;
00285
00286
00287 delete m_pDockMenu;
00288 delete m_pMdiModeMenu;
00289 delete m_pPlacingMenu;
00290 delete m_pTaskBarPopup;
00291 delete m_pWindowPopup;
00292 delete m_pWindowMenu;
00293 delete m_mdiGUIClient;
00294 m_mdiGUIClient=0;
00295 }
00296
00297
00298 #ifdef __GNUC__
00299 #warning fixme
00300 #endif
00301 void KMdiMainFrm::applyOptions()
00302 {
00303 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()){
00304 QWidget *wdgt = w;
00305 if(w->mdiParent())wdgt =w->mdiParent();
00306
00307
00308 wdgt->resize(wdgt->width()+1,wdgt->height()+1);
00309 wdgt->resize(wdgt->width()-1,wdgt->height()-1);
00310 }
00311 }
00312
00313
00314 void KMdiMainFrm::createMdiManager()
00315 {
00316 m_pMdi=new KMdiChildArea(this);
00317 setCentralWidget(m_pMdi);
00318 QObject::connect( m_pMdi, SIGNAL(nowMaximized(bool)), this, SLOT(setEnableMaximizedChildFrmMode(bool)) );
00319 QObject::connect( m_pMdi, SIGNAL(noMaximizedChildFrmLeft(KMdiChildFrm*)), this, SLOT(switchOffMaximizeModeForMenu(KMdiChildFrm*)) );
00320 QObject::connect( m_pMdi, SIGNAL(sysButtonConnectionsMustChange(KMdiChildFrm*,KMdiChildFrm*)), this, SLOT(updateSysButtonConnections(KMdiChildFrm*,KMdiChildFrm*)) );
00321 QObject::connect( m_pMdi, SIGNAL(popupWindowMenu(QPoint)), this, SLOT(popupWindowMenu(QPoint)) );
00322 QObject::connect( m_pMdi, SIGNAL(lastChildFrmClosed()), this, SIGNAL(lastChildFrmClosed()) );
00323 }
00324
00325
00326 void KMdiMainFrm::createTaskBar()
00327 {
00328 m_pTaskBar = new KMdiTaskBar(this,QMainWindow::DockBottom);
00329 m_pTaskBar->installEventFilter( this);
00330 }
00331
00332 void KMdiMainFrm::slot_toggleTaskBar()
00333 {
00334 if (!m_pTaskBar)
00335 return;
00336 m_pTaskBar->switchOn( !m_pTaskBar->isSwitchedOn());
00337 }
00338
00339 void KMdiMainFrm::resizeEvent(QResizeEvent *e)
00340 {
00341 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget())
00342 if( e->oldSize().height() != e->size().height()) {
00343 return;
00344 }
00345 KParts::DockMainWindow::resizeEvent(e);
00346 if (!m_mdiGUIClient) return;
00347 setSysButtonsAtMenuPosition();
00348 }
00349
00350
00351
00352 void KMdiMainFrm::setMinimumSize( int minw, int minh)
00353 {
00354 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget())
00355 return;
00356 DockMainWindow::setMinimumSize( minw, minh);
00357 }
00358
00359
00360
00361 KMdiChildView* KMdiMainFrm::createWrapper(QWidget *view, const QString& name, const QString& shortName)
00362 {
00363 Q_ASSERT( view );
00364
00365 KMdiChildView* pMDICover = new KMdiChildView(name,
00366 0L,
00367 name.latin1());
00368 QBoxLayout* pLayout = new QHBoxLayout( pMDICover, 0, -1, "layout");
00369 view->reparent(pMDICover, QPoint(0,0));
00370 pLayout->addWidget(view);
00371
00372 pMDICover->setTabCaption(shortName);
00373 pMDICover->setCaption(name);
00374
00375 const QPixmap* wndIcon = view->icon();
00376 if (wndIcon) {
00377 pMDICover->setIcon(*wndIcon);
00378 }
00379 pMDICover->trackIconAndCaptionChanges(view);
00380 return pMDICover;
00381 }
00382
00383
00384
00385 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, int flags)
00386 {
00387 if( windowExists( pWnd,AnyView)) {
00388
00389 return;
00390 }
00391
00392 if( flags & KMdi::ToolWindow) {
00393 addToolWindow( pWnd);
00394
00395 pWnd->move(m_pMdi->mapToGlobal(m_pMdi->getCascadePoint()));
00396
00397 return;
00398 }
00399
00400
00401 QObject::connect( pWnd, SIGNAL(clickedInWindowMenu(int)), this, SLOT(windowMenuItemActivated(int)) );
00402 QObject::connect( pWnd, SIGNAL(focusInEventOccurs(KMdiChildView*)), this, SLOT(activateView(KMdiChildView*)) );
00403 QObject::connect( pWnd, SIGNAL(childWindowCloseRequest(KMdiChildView*)), this, SLOT(childWindowCloseRequest(KMdiChildView*)) );
00404 QObject::connect( pWnd, SIGNAL(attachWindow(KMdiChildView*,bool)), this, SLOT(attachWindow(KMdiChildView*,bool)) );
00405 QObject::connect( pWnd, SIGNAL(detachWindow(KMdiChildView*,bool)), this, SLOT(detachWindow(KMdiChildView*,bool)) );
00406 QObject::connect( pWnd, SIGNAL(clickedInDockMenu(int)), this, SLOT(dockMenuItemActivated(int)) );
00407 connect(pWnd,SIGNAL(activated(KMdiChildView*)),this,SIGNAL(viewActivated(KMdiChildView*)));
00408 connect(pWnd,SIGNAL(deactivated(KMdiChildView*)),this,SIGNAL(viewDeactivated(KMdiChildView*)));
00409 m_pDocumentViews->append(pWnd);
00410 if (m_pTaskBar) {
00411 KMdiTaskBarButton* but = m_pTaskBar->addWinButton(pWnd);
00412 QObject::connect( pWnd, SIGNAL(tabCaptionChanged(const QString&)), but, SLOT(setNewText(const QString&)) );
00413 }
00414
00415
00416 if (m_mdiMode == KMdi::TabPageMode || m_mdiMode == KMdi::IDEAlMode) {
00417
00418
00419 m_documentTabWidget->addTab(pWnd, pWnd->icon() ? *(pWnd->icon()) : QPixmap(),pWnd->tabCaption());
00420
00421
00422
00423
00424 connect( pWnd, SIGNAL(iconUpdated(QWidget*, QPixmap )), m_documentTabWidget, SLOT(updateIconInView(QWidget*, QPixmap )) );
00425 connect( pWnd, SIGNAL(captionUpdated(QWidget*, const QString& )), m_documentTabWidget, SLOT(updateCaptionInView(QWidget*, const QString& )) );
00426 #if 0
00427 KDockWidget* pCover = createDockWidget( pWnd->name(),
00428 wndIcon,
00429 0L,
00430 pWnd->caption(),
00431 pWnd->tabCaption());
00432 pCover->setWidget( pWnd);
00433 pCover->setToolTipString( pWnd->caption());
00434 pCover->setDockWindowTransient(this,true);
00435 if (!(flags & KMdi::Detach)) {
00436 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockFullSite);
00437 pCover->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter);
00438 pCover->setEnableDocking(KDockWidget::DockNone);
00439 if (m_pDockbaseOfTabPage == m_pDockbaseAreaOfDocumentViews) {
00440 m_pDockbaseAreaOfDocumentViews->undock();
00441 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockNone);
00442 }
00443 else {
00444 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockCorner);
00445 }
00446 m_pDockbaseOfTabPage = (KDockWidget*) pCover;
00447 }
00448 if (!(flags & KMdi::Hide)) {
00449 pCover->show();
00450 }
00451 pWnd->setFocus();
00452 if (m_pDocumentViews->count() == 1) {
00453 m_pClose->show();
00454 }
00455 #endif
00456 }
00457 else {
00458 if( (flags & KMdi::Detach) || (m_mdiMode == KMdi::ToplevelMode)) {
00459 detachWindow( pWnd, !(flags & KMdi::Hide));
00460 emit childViewIsDetachedNow(pWnd);
00461 } else {
00462 attachWindow( pWnd, !(flags & KMdi::Hide), flags & KMdi::UseKMdiSizeHint);
00463 }
00464
00465 if ((m_bMaximizedChildFrmMode && !(m_bSDIApplication && (flags & KMdi::Detach)) && (m_mdiMode != KMdi::ToplevelMode))
00466 || (flags & KMdi::Maximize) ) {
00467 if (!pWnd->isMaximized())
00468 pWnd->maximize();
00469 }
00470 if (!m_bSDIApplication || (flags & KMdi::Detach)) {
00471 if (flags & KMdi::Minimize)
00472 {
00473 pWnd->minimize();
00474 }
00475 if (!(flags & KMdi::Hide)) {
00476 if (pWnd->isAttached()) {
00477 pWnd->mdiParent()->show();
00478 }
00479 else {
00480 pWnd->show();
00481 }
00482 }
00483 }
00484 }
00485 }
00486
00487
00488 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, QRect rectNormal, int flags)
00489 {
00490 addWindow( pWnd, flags);
00491 if (m_bMaximizedChildFrmMode && pWnd->isAttached()) {
00492 pWnd->setRestoreGeometry( rectNormal);
00493 } else {
00494 pWnd->setGeometry( rectNormal);
00495 }
00496 }
00497
00498
00499 void KMdiMainFrm::addWindow( KMdiChildView* pWnd, QPoint pos, int flags)
00500 {
00501 addWindow( pWnd, flags);
00502 if (m_bMaximizedChildFrmMode && pWnd->isAttached()) {
00503 pWnd->setRestoreGeometry( QRect(pos, pWnd->restoreGeometry().size()));
00504 } else {
00505 pWnd->move( pos);
00506 }
00507 }
00508
00509
00510
00511 KMdiToolViewAccessor *KMdiMainFrm::createToolWindow()
00512 {
00513 return new KMdiToolViewAccessor(this);
00514 }
00515
00516
00517 void KMdiMainFrm::deleteToolWindow( QWidget* pWnd) {
00518 if (m_pToolViews->contains(pWnd)) {
00519 deleteToolWindow((*m_pToolViews)[pWnd]);
00520 }
00521 }
00522
00523 void KMdiMainFrm::deleteToolWindow( KMdiToolViewAccessor *accessor) {
00524 if (!accessor) return;
00525 delete accessor;
00526 }
00527
00528
00529 KMdiToolViewAccessor *KMdiMainFrm::addToolWindow( QWidget* pWnd, KDockWidget::DockPosition pos, QWidget* pTargetWnd, int percent, const QString& tabToolTip, const QString& tabCaption)
00530 {
00531 QWidget *tvta=pWnd;
00532 KDockWidget* pDW = dockManager->getDockWidgetFromName(pWnd->name());
00533 if (pDW) {
00534
00535 pDW->setWidget(pWnd);
00536
00537 if (pWnd->icon()) {
00538 pDW->setPixmap(*pWnd->icon());
00539 }
00540 pDW->setTabPageLabel((tabCaption==0)?pWnd->caption():tabCaption);
00541 pDW->setToolTipString(tabToolTip);
00542 dockManager->removeFromAutoCreateList(pDW);
00543 pWnd=pDW;
00544 }
00545
00546 QRect r=pWnd->geometry();
00547
00548 KMdiToolViewAccessor *mtva=new KMdiToolViewAccessor(this,pWnd,tabToolTip,(tabCaption==0)?pWnd->caption():tabCaption);
00549 m_pToolViews->insert(tvta,mtva);
00550
00551 if (pos == KDockWidget::DockNone) {
00552 mtva->d->widgetContainer->setEnableDocking(KDockWidget::DockNone);
00553 mtva->d->widgetContainer->reparent(this, Qt::WType_TopLevel | Qt::WType_Dialog, r.topLeft(), true);
00554 }
00555 else {
00556 const QPixmap& wndIcon = pWnd->icon() ? *(pWnd->icon()) : QPixmap();
00557
00558 KDockWidget *pCover=mtva->d->widgetContainer;
00559
00560 mtva->place(pos, pTargetWnd,percent);
00561
00562 }
00563
00564 return mtva;
00565
00566 }
00567
00568
00569 void KMdiMainFrm::attachWindow(KMdiChildView *pWnd, bool bShow, bool bAutomaticResize)
00570 {
00571 pWnd->installEventFilter(this);
00572
00573
00574
00575 bool bCascade = false;
00576 QApplication::sendPostedEvents();
00577 QRect frameGeo = pWnd->frameGeometry();
00578 QPoint topLeftScreen = pWnd->mapToGlobal(QPoint(0,0));
00579 QPoint topLeftMdiChildArea = m_pMdi->mapFromGlobal(topLeftScreen);
00580 QRect childAreaGeo = m_pMdi->geometry();
00581 if ( (topLeftMdiChildArea.x() < 0) || (topLeftMdiChildArea.y() < 0) ||
00582 (topLeftMdiChildArea.x()+frameGeo.width() > childAreaGeo.width()) ||
00583 (topLeftMdiChildArea.y()+frameGeo.height() > childAreaGeo.height()) ) {
00584 bCascade = true;
00585 }
00586
00587
00588 KMdiChildFrm *lpC=new KMdiChildFrm(m_pMdi);
00589 pWnd->hide();
00590 if (!bCascade) {
00591 lpC->move(topLeftMdiChildArea);
00592 }
00593 lpC->setClient(pWnd, bAutomaticResize);
00594 lpC->setFocus();
00595 pWnd->youAreAttached(lpC);
00596 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget()) {
00597 setMinimumHeight( m_oldMainFrmMinHeight);
00598 setMaximumHeight( m_oldMainFrmMaxHeight);
00599 resize( width(), m_oldMainFrmHeight);
00600 m_oldMainFrmHeight = 0;
00601 switchToChildframeMode();
00602 }
00603
00604 m_pMdi->manageChild(lpC,false,bCascade);
00605 if (m_pMdi->topChild() && m_pMdi->topChild()->isMaximized()) {
00606 QRect r = lpC->geometry();
00607 lpC->setGeometry(-lpC->m_pClient->x(), -lpC->m_pClient->y(),
00608 m_pMdi->width() + KMDI_CHILDFRM_DOUBLE_BORDER,
00609 m_pMdi->height() + lpC->captionHeight() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER);
00610 lpC->setRestoreGeometry(r);
00611 }
00612
00613 if (bShow) {
00614 lpC->show();
00615 }
00616
00617 #undef FocusIn
00618 QFocusEvent fe(QEvent::FocusIn);
00619 QApplication::sendEvent( pWnd, &fe);
00620
00621 m_pCurrentWindow = pWnd;
00622 }
00623
00624
00625 void KMdiMainFrm::detachWindow(KMdiChildView *pWnd, bool bShow)
00626 {
00627 if (pWnd->isAttached()) {
00628 pWnd->removeEventFilter(this);
00629 pWnd->youAreDetached();
00630
00631 if (pWnd->parent()) {
00632 KMdiChildFrm *lpC=pWnd->mdiParent();
00633 if (lpC) {
00634 if (lpC->icon()) {
00635 QPixmap pixm(*(lpC->icon()));
00636 pWnd->setIcon(pixm);
00637 }
00638 QString capt(lpC->caption());
00639 if (!bShow)
00640 lpC->hide();
00641 lpC->unsetClient( m_undockPositioningOffset);
00642 m_pMdi->destroyChildButNotItsView(lpC,false);
00643 pWnd->setCaption(capt);
00644 }
00645 }
00646 }
00647 else {
00648 if (pWnd->size().isEmpty() || (pWnd->size() == QSize(1,1))) {
00649 if (m_pCurrentWindow) {
00650 pWnd->setGeometry( QRect( m_pMdi->getCascadePoint(m_pDocumentViews->count()-1), m_pCurrentWindow->size()));
00651 }
00652 else {
00653 pWnd->setGeometry( QRect( m_pMdi->getCascadePoint(m_pDocumentViews->count()-1), defaultChildFrmSize()));
00654 }
00655 }
00656 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00657 if (mdiMode() == KMdi::ToplevelMode) {
00658 XSetTransientForHint(qt_xdisplay(),pWnd->winId(),topLevelWidget()->winId());
00659 }
00660 #endif
00661
00662 return;
00663 }
00664
00665 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00666 if (mdiMode() == KMdi::ToplevelMode) {
00667 XSetTransientForHint(qt_xdisplay(),pWnd->winId(),topLevelWidget()->winId());
00668 }
00669 #endif
00670
00671
00672 if (bShow) {
00673 activateView(pWnd);
00674 }
00675
00676 emit childViewIsDetachedNow(pWnd);
00677 }
00678
00679
00680 void KMdiMainFrm::removeWindowFromMdi(KMdiChildView *pWnd)
00681 {
00682
00683 #ifdef __GNUC__
00684 #warning FIXME FIXME FIXME
00685 #endif
00686 #if 0
00687 if (!(m_pWinList->removeRef(pWnd)))
00688 return;
00689 if (m_pWinList->count() == 0)
00690 m_pCurrentWindow = 0L;
00691
00692 QObject::disconnect( pWnd, SIGNAL(attachWindow(KMdiChildView*,bool)), this, SLOT(attachWindow(KMdiChildView*,bool)) );
00693 QObject::disconnect( pWnd, SIGNAL(detachWindow(KMdiChildView*,bool)), this, SLOT(detachWindow(KMdiChildView*,bool)) );
00694 QObject::disconnect( pWnd, SIGNAL(focusInEventOccurs(KMdiChildView*)), this, SLOT(activateView(KMdiChildView*)) );
00695 QObject::disconnect( pWnd, SIGNAL(childWindowCloseRequest(KMdiChildView*)), this, SLOT(childWindowCloseRequest(KMdiChildView*)) );
00696 QObject::disconnect( pWnd, SIGNAL(clickedInWindowMenu(int)), this, SLOT(windowMenuItemActivated(int)) );
00697 QObject::disconnect( pWnd, SIGNAL(clickedInDockMenu(int)), this, SLOT(dockMenuItemActivated(int)) );
00698
00699 if (m_pTaskBar) {
00700 KMdiTaskBarButton* but = m_pTaskBar->getButton(pWnd);
00701 if (but != 0L) {
00702 QObject::disconnect( pWnd, SIGNAL(tabCaptionChanged(const QString&)), but, SLOT(setNewText(const QString&)) );
00703 }
00704 m_pTaskBar->removeWinButton(pWnd);
00705 }
00706
00707 if (m_mdiMode == KMdi::TabPageMode) {
00708 if (m_pWinList->count() == 0) {
00709 if (!m_pDockbaseAreaOfDocumentViews) {
00710 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover");
00711 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true);
00712
00713 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi);
00714 setMainDockWidget(m_pDockbaseAreaOfDocumentViews);
00715 }
00716 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockFullSite);
00717 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockCenter);
00718 m_pDockbaseAreaOfDocumentViews->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter);
00719 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone);
00720 m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews;
00721 m_pClose->hide();
00722 }
00723 KDockWidget* pDockW = (KDockWidget*) pWnd->parentWidget();
00724 pWnd->reparent(0L, QPoint(0,0));
00725 pDockW->setWidget(0L);
00726 if (pDockW == m_pDockbaseOfTabPage) {
00727 QTabWidget* pTab = (QTabWidget*) pDockW->parentWidget()->parentWidget();
00728 int cnt = pTab->count();
00729 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 2);
00730 if (pDockW == m_pDockbaseOfTabPage) {
00731 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 1);
00732 }
00733 }
00734 delete pDockW;
00735 if (m_pWinList->count() == 1) {
00736 m_pWinList->last()->activate();
00737 }
00738 }
00739 else if (pWnd->isAttached()) {
00740 pWnd->mdiParent()->hide();
00741 m_pMdi->destroyChildButNotItsView(pWnd->mdiParent());
00742 }
00743 else {
00744
00745 if (m_pMdi->getVisibleChildCount() > 0) {
00746 setActiveWindow();
00747 m_pCurrentWindow = 0L;
00748 KMdiChildView* pView = m_pMdi->topChild()->m_pClient;
00749 if (pView) {
00750 pView->activate();
00751 }
00752 }
00753 else if (m_pWinList->count() > 0) {
00754
00755
00756 }
00757 }
00758
00759 if (pWnd->isToolView())
00760 pWnd->m_bToolView = false;
00761
00762 if (!m_pCurrentWindow)
00763 emit lastChildViewClosed();
00764 #endif
00765 }
00766
00767
00768 void KMdiMainFrm::closeWindow(KMdiChildView *pWnd, bool layoutTaskBar)
00769 {
00770 if (!pWnd) return;
00771
00772 m_pDocumentViews->removeRef(pWnd);
00773 if (m_pDocumentViews->count() == 0)
00774 m_pCurrentWindow = 0L;
00775
00776 if (m_pTaskBar) {
00777 m_pTaskBar->removeWinButton(pWnd, layoutTaskBar);
00778 }
00779
00780 if ((m_mdiMode == KMdi::TabPageMode) || (m_mdiMode==KMdi::IDEAlMode)) {
00781 if (!m_documentTabWidget) return;
00782 if (m_pDocumentViews->count()==0) m_pClose->hide();
00783 pWnd->reparent(0L, QPoint(0,0));
00784 if (m_pDocumentViews->count() == 1) {
00785 m_pDocumentViews->last()->activate();
00786 }
00787 }
00788 if (m_mdiMode == KMdi::TabPageMode) {
00789 if (m_pDocumentViews->count() == 0) {
00790 if (!m_pDockbaseAreaOfDocumentViews) {
00791 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover");
00792 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true);
00793 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi);
00794 setMainDockWidget(m_pDockbaseAreaOfDocumentViews);
00795 }
00796 #if 0
00797 m_pDockbaseOfTabPage->setDockSite(KDockWidget::DockFullSite);
00798 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockCenter);
00799 m_pDockbaseAreaOfDocumentViews->manualDock( m_pDockbaseOfTabPage, KDockWidget::DockCenter);
00800 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone);
00801 m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews;
00802 #endif
00803 m_pClose->hide();
00804 }
00805 #if 0
00806 KDockWidget* pDockW = (KDockWidget*) pWnd->parentWidget();
00807 pWnd->reparent(0L, QPoint(0,0));
00808 pDockW->setWidget(0L);
00809 if (pDockW == m_pDockbaseOfTabPage) {
00810 QTabWidget* pTab = (QTabWidget*) pDockW->parentWidget()->parentWidget();
00811 int cnt = pTab->count();
00812 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 2);
00813 if (pDockW == m_pDockbaseOfTabPage) {
00814 m_pDockbaseOfTabPage = (KDockWidget*) pTab->page(cnt - 1);
00815 }
00816 }
00817 delete pDockW;
00818 #endif
00819 if (m_pDocumentViews->count() == 1) {
00820 m_pDocumentViews->last()->activate();
00821 }
00822 }
00823 else if (pWnd->isAttached()) {
00824 m_pMdi->destroyChild(pWnd->mdiParent());
00825 }
00826 else {
00827 delete pWnd;
00828
00829 if (m_pMdi->getVisibleChildCount() > 0) {
00830 setActiveWindow();
00831 m_pCurrentWindow = 0L;
00832 KMdiChildView* pView = m_pMdi->topChild()->m_pClient;
00833 if (pView) {
00834 pView->activate();
00835 }
00836 }
00837 else if (m_pDocumentViews->count() > 0) {
00838 m_pDocumentViews->last()->activate();
00839 m_pDocumentViews->last()->setFocus();
00840 }
00841 }
00842
00843 if (!m_pCurrentWindow)
00844 emit lastChildViewClosed();
00845 }
00846
00847
00848 KMdiChildView * KMdiMainFrm::findWindow(const QString& caption)
00849 {
00850 for(KMdiChildView *w=m_pDocumentViews->first();w;w=m_pDocumentViews->next()){
00851 if(QString(w->caption()) == QString(caption))return w;
00852 }
00853 return 0L;
00854 }
00855
00856
00857 KMdiChildView * KMdiMainFrm::activeWindow()
00858 {
00859 return m_pCurrentWindow;
00860 }
00861
00862
00863 bool KMdiMainFrm::windowExists(KMdiChildView *pWnd, ExistsAs as)
00864 {
00865 if ((as==ToolView) || (as==AnyView)) {
00866 if (m_pToolViews->contains(pWnd)) return true;
00867 if (as==ToolView) return false;
00868 }
00869
00870 for(KMdiChildView *w=m_pDocumentViews->first();w;w=m_pDocumentViews->next()){
00871 if (w == pWnd) return true;
00872 }
00873
00874 return false;
00875 }
00876
00877 QPopupMenu * KMdiMainFrm::windowPopup(KMdiChildView * pWnd,bool bIncludeTaskbarPopup)
00878 {
00879 m_pWindowPopup->clear();
00880 if(bIncludeTaskbarPopup){
00881 m_pWindowPopup->insertItem(i18n("Window"),taskBarPopup(pWnd,false));
00882 m_pWindowPopup->insertSeparator();
00883 }
00884 return m_pWindowPopup;
00885 }
00886
00887
00888 QPopupMenu * KMdiMainFrm::taskBarPopup(KMdiChildView *pWnd,bool )
00889 {
00890
00891 m_pTaskBarPopup->clear();
00892 if(pWnd->isAttached()){
00893 m_pTaskBarPopup->insertItem(i18n("Undock"),pWnd,SLOT(detach()));
00894 m_pTaskBarPopup->insertSeparator();
00895 if(pWnd->isMinimized() || pWnd->isMaximized())
00896 m_pTaskBarPopup->insertItem(i18n("Restore"),pWnd,SLOT(restore()));
00897 if(!pWnd->isMaximized())m_pTaskBarPopup->insertItem(i18n("Maximize"),pWnd,SLOT(maximize()));
00898 if(!pWnd->isMinimized())m_pTaskBarPopup->insertItem(i18n("Minimize"),pWnd,SLOT(minimize()));
00899 } else m_pTaskBarPopup->insertItem(i18n("Dock"),pWnd,SLOT(attach()));
00900 m_pTaskBarPopup->insertSeparator();
00901 m_pTaskBarPopup->insertItem(i18n("Close"),pWnd,SLOT(close()));
00902
00903 m_pTaskBarPopup->insertSeparator();
00904 m_pTaskBarPopup->insertItem(i18n("Operations"),windowPopup(pWnd,false));
00905 return m_pTaskBarPopup;
00906 }
00907
00908
00909 void KMdiMainFrm::slotDocCurrentChanged(QWidget* pWnd) {
00910 activateView((KMdiChildView*) pWnd);
00911 }
00912 void KMdiMainFrm::activateView(KMdiChildView* pWnd)
00913 {
00914 pWnd->m_bMainframesActivateViewIsPending = true;
00915
00916 bool bActivateNecessary = true;
00917 if (m_pCurrentWindow != pWnd) {
00918 m_pCurrentWindow = pWnd;
00919 }
00920 else {
00921 bActivateNecessary = false;
00922
00923
00924 pWnd->m_bInterruptActivation = true;
00925
00926 }
00927
00928 if (m_pTaskBar) {
00929 m_pTaskBar->setActiveButton(pWnd);
00930 }
00931
00932
00933 if (m_documentTabWidget && m_mdiMode == KMdi::TabPageMode || m_mdiMode==KMdi::IDEAlMode) {
00934 m_documentTabWidget->showPage(pWnd);
00935 pWnd->activate();
00936 }
00937 #if 0
00938 if (m_mdiMode == KMdi::TabPageMode) {
00939 makeWidgetDockVisible(pWnd);
00940 m_pDockbaseOfTabPage = (KDockWidget*) pWnd->parentWidget();
00941 }
00942 #endif
00943 else {
00944 if (pWnd->isAttached()) {
00945 if (bActivateNecessary && (m_pMdi->topChild() == pWnd->mdiParent())) {
00946 pWnd->activate();
00947 }
00948 pWnd->mdiParent()->raiseAndActivate();
00949 }
00950 if (!pWnd->isAttached()) {
00951 if (bActivateNecessary)
00952 pWnd->activate();
00953 m_pMdi->setTopChild(0L);
00954 if (!pWnd->isActiveWindow()) {
00955 pWnd->setActiveWindow();
00956 }
00957 pWnd->raise();
00958
00959
00960
00961 }
00962 }
00963
00964 emit collapseOverlapContainers();
00965
00966 pWnd->m_bMainframesActivateViewIsPending = false;
00967 }
00968
00969 void KMdiMainFrm::taskbarButtonRightClicked(KMdiChildView *pWnd)
00970 {
00971 activateView( pWnd);
00972 QApplication::sendPostedEvents();
00973 taskBarPopup( pWnd, true)->popup( QCursor::pos());
00974 }
00975
00976 void KMdiMainFrm::childWindowCloseRequest(KMdiChildView *pWnd)
00977 {
00978 KMdiViewCloseEvent* ce = new KMdiViewCloseEvent( pWnd);
00979 QApplication::postEvent( this, ce);
00980 }
00981
00982 bool KMdiMainFrm::event( QEvent* e)
00983 {
00984 if( e->type() == QEvent::User) {
00985 KMdiChildView* pWnd = (KMdiChildView*)((KMdiViewCloseEvent*)e)->data();
00986 if( pWnd != 0L)
00987 closeWindow( pWnd);
00988 return true;
00989 }
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004 else if( isVisible() && (e->type() == QEvent::Move)) {
01005 if (m_pDragEndTimer->isActive()) {
01006
01007 m_pDragEndTimer->stop();
01008 }
01009 else {
01010
01011 KMdiChildView* pView;
01012 for (m_pDocumentViews->first(); (pView = m_pDocumentViews->current()) != 0L; m_pDocumentViews->next()) {
01013 KMdiChildFrmDragBeginEvent dragBeginEvent(0L);
01014 QApplication::sendEvent(pView, &dragBeginEvent);
01015 }
01016 }
01017 m_pDragEndTimer->start(200, true);
01018 }
01019
01020 return DockMainWindow::event( e);
01021 }
01022
01023 bool KMdiMainFrm::eventFilter(QObject * , QEvent *e )
01024 {
01025 if( e->type() == QEvent::FocusIn) {
01026 QFocusEvent* pFE = (QFocusEvent*) e;
01027 if (pFE->reason() == QFocusEvent::ActiveWindow) {
01028 if (m_pCurrentWindow && !m_pCurrentWindow->isHidden() && !m_pCurrentWindow->isAttached() && m_pMdi->topChild()) {
01029 return true;
01030 }
01031 }
01032 if (m_pMdi) {
01033 static bool bFocusTCIsPending = false;
01034 if (!bFocusTCIsPending) {
01035 bFocusTCIsPending = true;
01036 m_pMdi->focusTopChild();
01037 bFocusTCIsPending = false;
01038 }
01039 }
01040 }
01041 else if (e->type() == QEvent::KeyRelease) {
01042 if (switching()) {
01043 KAction *a = actionCollection()->action( "view_last_window" ) ;
01044 if (a) {
01045 const KShortcut cut( a->shortcut() );
01046 const KKeySequence& seq = cut.seq( 0 );
01047 const KKey& key = seq.key(0);
01048 int modFlags = key.modFlags();
01049 int state = ((QKeyEvent *)e)->state();
01050 KKey key2( (QKeyEvent *)e );
01051
01056 if (state != ((QKeyEvent *)e)->stateAfter() &&
01057 ((modFlags & KKey::CTRL) > 0) == ((state & Qt::ControlButton) > 0 ) &&
01058 ((modFlags & KKey::ALT) > 0) == ((state & Qt::AltButton) > 0) &&
01059 ((modFlags & KKey::WIN) > 0) == ((state & Qt::MetaButton) > 0) )
01060 {
01061 activeWindow()->updateTimeStamp();
01062 setSwitching(false);
01063 }
01064 return true;
01065 }
01066 else
01067 {
01068 kdDebug(9000) << "KAction( \"view_last_window\") not found." << endl;
01069 }
01070 }
01071 }
01072 return false;
01073 }
01074
01078 void KMdiMainFrm::closeAllViews()
01079 {
01080
01081 QValueList<KMdiChildView *> children;
01082 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next()){
01083 children.append(w);
01084 }
01085 QValueListIterator<KMdiChildView *> childIt;
01086 for (childIt = children.begin(); childIt != children.end(); ++childIt)
01087 {
01088 (*childIt)->close();
01089 }
01090 }
01091
01092
01096 void KMdiMainFrm::iconifyAllViews()
01097 {
01098 for(KMdiChildView *w = m_pDocumentViews->first();w;w= m_pDocumentViews->next())
01099 w->minimize();
01100 }
01101
01105 void KMdiMainFrm::closeActiveView()
01106 {
01107 if( m_pCurrentWindow != 0L) {
01108 m_pCurrentWindow->close();
01109 }
01110 }
01111
01113 void KMdiMainFrm::findRootDockWidgets(QPtrList<KDockWidget>* pRootDockWidgetList, QValueList<QRect>* pPositionList)
01114 {
01115 if (!pRootDockWidgetList) return;
01116 if (!pPositionList) return;
01117
01118
01119 const int frameBorderWidth = 7;
01120 const int windowTitleHeight = 10;
01121
01122 QObjectList* pObjList = queryList( "KDockWidget");
01123 if (pObjList->isEmpty()) {
01124 pObjList = queryList( "KDockWidget_Compat::KDockWidget");
01125 }
01126 QObjectListIt it( *pObjList);
01127 QObject* pObj;
01128
01129 while ((pObj = it.current()) != 0L) {
01130 ++it;
01131 KDockWidget* pDockW = (KDockWidget*) pObj;
01132 KDockWidget* pRootDockW = 0L;
01133 KDockWidget* pUndockCandidate = 0L;
01134 QWidget* pW = pDockW;
01135
01136 while (!pW->isTopLevel()) {
01137 if (pW->inherits("KDockWidget") || pW->inherits("KDockWidget_Compat::KDockWidget")) {
01138 pUndockCandidate = (KDockWidget*) pW;
01139 if (pUndockCandidate->enableDocking() != KDockWidget::DockNone)
01140 pRootDockW = pUndockCandidate;
01141 }
01142 pW = pW->parentWidget();
01143 }
01144 if (pRootDockW) {
01145
01146 bool found = false;
01147 QPtrListIterator<KDockWidget> it2( *pRootDockWidgetList);
01148 if (!pRootDockWidgetList->isEmpty()) {
01149 for ( ; it2.current() && !found; ++it2 ) {
01150 KDockWidget* pDockW = it2.current();
01151 if (pDockW == pRootDockW)
01152 found = true;
01153 }
01154 if (!found) {
01155 pRootDockWidgetList->append( (KDockWidget*)pDockW);
01156 kdDebug(760)<<"pRootDockWidgetList->append("<<pDockW->name()<<");"<<endl;
01157 QPoint p = pDockW->mapToGlobal( pDockW->pos())-pDockW->pos();
01158 QRect r( p.x(),
01159 p.y()+m_undockPositioningOffset.y(),
01160 pDockW->width() - windowTitleHeight - frameBorderWidth*2,
01161 pDockW->height() - windowTitleHeight - frameBorderWidth*2);
01162 pPositionList->append( r);
01163 }
01164 }
01165 else {
01166 pRootDockWidgetList->append( (KDockWidget*)pRootDockW);
01167 kdDebug(760)<<"pRootDockWidgetList->append("<<pDockW->name()<<");"<<endl;
01168 QPoint p = pRootDockW->mapToGlobal( pRootDockW->pos())-pRootDockW->pos();
01169 QRect r( p.x(),
01170 p.y()+m_undockPositioningOffset.y(),
01171 pRootDockW->width() - windowTitleHeight - frameBorderWidth*2,
01172 pRootDockW->height() - windowTitleHeight - frameBorderWidth*2);
01173 pPositionList->append( r);
01174 }
01175 }
01176 }
01177 delete pObjList;
01178 }
01179
01183 void KMdiMainFrm::switchToToplevelMode()
01184 {
01185 if (m_mdiMode == KMdi::ToplevelMode) {
01186 mdiModeHasBeenChangedTo(KMdi::ToplevelMode);
01187 return;
01188 }
01189
01190 KMdi::MdiMode oldMdiMode = m_mdiMode;
01191
01192 const int frameBorderWidth = 7;
01193 setUndockPositioningOffset( QPoint( 0, (m_pTaskBar ? m_pTaskBar->height() : 0) + frameBorderWidth));
01194
01195
01196
01197 QPtrList<KDockWidget> rootDockWidgetList;
01198 QValueList<QRect> positionList;
01199 if (oldMdiMode!=KMdi::IDEAlMode)
01200 findRootDockWidgets(&rootDockWidgetList, &positionList);
01201
01202
01203 if (oldMdiMode == KMdi::ChildframeMode) {
01204 finishChildframeMode();
01205 }
01206 else if (oldMdiMode == KMdi::TabPageMode) {
01207 finishTabPageMode();
01208 } else if (m_mdiMode == KMdi::IDEAlMode) {
01209 finishIDEAlMode();
01210 findRootDockWidgets(&rootDockWidgetList, &positionList);
01211 }
01212
01213
01214
01215
01216 QPtrListIterator<KDockWidget> it3( rootDockWidgetList);
01217 for (; it3.current(); ++it3 ) {
01218 KDockWidget* pDockW = it3.current();
01219 pDockW->undock();
01220 }
01221
01222
01223 if ((oldMdiMode == KMdi::TabPageMode) || (oldMdiMode==KMdi::IDEAlMode)) {
01224 if (!m_pDockbaseAreaOfDocumentViews) {
01225 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover");
01226 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true);
01227 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone);
01228 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner);
01229 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi);
01230 }
01231
01232 setView(m_pDockbaseAreaOfDocumentViews);
01233 setMainDockWidget(m_pDockbaseAreaOfDocumentViews);
01234
01235 }
01236 QApplication::sendPostedEvents();
01237 if (!parentWidget()) {
01238 m_oldMainFrmMinHeight = minimumHeight();
01239 m_oldMainFrmMaxHeight = maximumHeight();
01240 m_oldMainFrmHeight = height();
01241 if( m_pDocumentViews->count())
01242 setFixedHeight( height() - m_pDockbaseAreaOfDocumentViews->height());
01243 else {
01244 QApplication::sendPostedEvents();
01245 setFixedHeight( height() - m_pDockbaseAreaOfDocumentViews->height() + 27);
01246 }
01247 }
01248
01249 #ifdef __GNUC__
01250 #warning fixme
01251 #endif
01252
01253 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews);
01254 for( it.toFirst(); it.current(); ++it) {
01255 KMdiChildView* pView = it.current();
01256 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
01257 XSetTransientForHint(qt_xdisplay(),pView->winId(),winId());
01258 #endif
01259
01260 pView->show();
01261 }
01262
01263
01264 QValueList<QRect>::Iterator it5;
01265 for (it3.toFirst(), it5 = positionList.begin() ; it3.current(), it5 != positionList.end(); ++it3, ++it5 ) {
01266 KDockWidget* pDockW = it3.current();
01267 pDockW->setGeometry( (*it5));
01268 pDockW->show();
01269 }
01270
01271 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockNone);
01272 m_mdiMode = KMdi::ToplevelMode;
01273
01274
01275 mdiModeHasBeenChangedTo(KMdi::ToplevelMode);
01276
01277 }
01278
01279 void KMdiMainFrm::finishToplevelMode()
01280 {
01281 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner);
01282
01283 }
01284
01288 void KMdiMainFrm::switchToChildframeMode()
01289 {
01290 if (m_mdiMode == KMdi::ChildframeMode) {
01291 mdiModeHasBeenChangedTo(KMdi::ChildframeMode);
01292 return;
01293 }
01294
01295 QPtrList<KDockWidget> rootDockWidgetList;
01296 if (m_mdiMode == KMdi::TabPageMode) {
01297
01298 QValueList<QRect> positionList;
01299 findRootDockWidgets(&rootDockWidgetList, &positionList);
01300
01301
01302 QPtrListIterator<KDockWidget> it3( rootDockWidgetList);
01303 for (; it3.current(); ++it3 ) {
01304 KDockWidget* pDockW = it3.current();
01305 pDockW->undock();
01306 }
01307
01308 finishTabPageMode();
01309 }
01310 else if (m_mdiMode == KMdi::ToplevelMode) {
01311 finishToplevelMode();
01312 } else if (m_mdiMode == KMdi::IDEAlMode) {
01313 finishIDEAlMode(false);
01314
01315
01316 QValueList<QRect> positionList;
01317 findRootDockWidgets(&rootDockWidgetList, &positionList);
01318
01319
01320
01321
01322
01323 QPtrListIterator<KDockWidget> it3( rootDockWidgetList);
01324 for (; it3.current(); ++it3 ) {
01325 KDockWidget* pDockW = it3.current();
01326 pDockW->undock();
01327 }
01328 m_mdiMode=KMdi::TabPageMode;
01329 finishTabPageMode();
01330 m_mdiMode=KMdi::IDEAlMode;
01331
01332 }
01333
01334
01335
01336
01337 if (!m_pDockbaseAreaOfDocumentViews) {
01338
01339 m_pDockbaseAreaOfDocumentViews = createDockWidget( "mdiAreaCover", QPixmap(), 0L, "mdi_area_cover");
01340 m_pDockbaseAreaOfDocumentViews->setDockWindowTransient(this,true);
01341 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone);
01342 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner);
01343 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi);
01344 kdDebug(760)<<"!swtichToChildframeMode: m_pDockbaseAreaOfDocumentViews"<<endl;
01345 }
01346 if (m_pDockbaseAreaOfDocumentViews->isTopLevel()) {
01347
01348 setView(m_pDockbaseAreaOfDocumentViews);
01349 setMainDockWidget(m_pDockbaseAreaOfDocumentViews);
01350 m_pDockbaseAreaOfDocumentViews->setEnableDocking(KDockWidget::DockNone);
01351 m_pDockbaseAreaOfDocumentViews->setDockSite(KDockWidget::DockCorner);
01352
01353 kdDebug(760)<<"swtichToChildframeMode: m_pDockbaaseAreaOfDocumentViews->isTopLevel()"<<endl;
01354 }
01355 m_pDockbaseAreaOfDocumentViews->setWidget(m_pMdi);
01356 m_pDockbaseAreaOfDocumentViews->show();
01357
01358 if ( (m_mdiMode == KMdi::TabPageMode) || (m_mdiMode == KMdi::IDEAlMode)) {
01359 kdDebug(760)<<"switchToChildFrameMode: trying to dock back toolviews"<<endl;
01360 QPtrListIterator<KDockWidget> it4( rootDockWidgetList);
01361 for (; it4.current(); ++it4 ) {
01362 KDockWidget* pDockW = it4.current();
01363 pDockW->dockBack();
01364 }
01365 }
01366
01367 if (m_mdiMode == KMdi::ToplevelMode && m_pTempDockSession) {
01368
01369 QDomElement oldDockState = m_pTempDockSession->namedItem("cur_dock_state").toElement();
01370 readDockConfig( oldDockState);
01371 }
01372
01373 KMdi::MdiMode oldMdiMode = m_mdiMode;
01374 m_mdiMode = KMdi::ChildframeMode;
01375
01376 #ifdef __GNUC__
01377 #warning fixme
01378 #endif
01379 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews);
01380 for( ; it.current(); ++it) {
01381 KMdiChildView* pView = it.current();
01382 if( !pView->isToolView())
01383 if( !pView->isAttached())
01384 attachWindow( pView, true);
01385 }
01386 for( it.toFirst(); it.current(); ++it) {
01387 KMdiChildView* pView = it.current();
01388 if( !pView->isToolView())
01389 pView->show();
01390 }
01391 if( (oldMdiMode == KMdi::ToplevelMode) && !parentWidget()) {
01392 setMinimumHeight( m_oldMainFrmMinHeight);
01393 setMaximumHeight( m_oldMainFrmMaxHeight);
01394 resize( width(), m_oldMainFrmHeight);
01395 m_oldMainFrmHeight = 0;
01396
01397 emit leftTopLevelMode();
01398 }
01399 mdiModeHasBeenChangedTo(KMdi::ChildframeMode);
01400 }
01401
01402 void KMdiMainFrm::finishChildframeMode()
01403 {
01404
01405 delete m_pTempDockSession;
01406 m_pTempDockSession = new QDomDocument( "docksession");
01407 QDomElement curDockState = m_pTempDockSession->createElement("cur_dock_state");
01408 m_pTempDockSession->appendChild( curDockState);
01409 writeDockConfig( curDockState);
01410
01411
01412 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews);
01413 for( ; it.current(); ++it) {
01414 KMdiChildView* pView = it.current();
01415 if( pView->isToolView())
01416 continue;
01417 if( pView->isAttached()) {
01418 if( pView->isMaximized())
01419 pView->mdiParent()->setGeometry( 0, 0, m_pMdi->width(), m_pMdi->height());
01420 detachWindow( pView, false);
01421
01422 }
01423 }
01424 }
01425
01426
01427
01428
01432 void KMdiMainFrm::switchToTabPageMode()
01433 {
01434 KMdiChildView* pRemActiveWindow = activeWindow();
01435
01436 if (m_mdiMode == KMdi::TabPageMode) {
01437 mdiModeHasBeenChangedTo(KMdi::TabPageMode);
01438 return;
01439 }
01440
01441
01442 if (m_mdiMode == KMdi::ChildframeMode) {
01443 finishChildframeMode();
01444 }
01445 else if (m_mdiMode == KMdi::ToplevelMode) {
01446 finishToplevelMode();
01447 } else if (m_mdiMode == KMdi::IDEAlMode) {
01448 finishIDEAlMode(false);
01449 mdiModeHasBeenChangedTo(KMdi::TabPageMode);
01450 m_mdiMode=KMdi::TabPageMode;
01451 return;
01452 }
01453
01454 setupTabbedDocumentViewSpace();
01455 m_mdiMode = KMdi::TabPageMode;
01456 if (pRemActiveWindow)
01457 pRemActiveWindow->setFocus();
01458
01459 m_pTaskBar->switchOn(false);
01460
01461 assert(m_pClose);
01462 QObject::connect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) );
01463 if (m_pDocumentViews->count() > 0) {
01464 m_pClose->show();
01465 }
01466
01467 mdiModeHasBeenChangedTo(KMdi::TabPageMode);
01468 }
01469
01470 void KMdiMainFrm::finishTabPageMode()
01471 {
01472
01473 if (m_mdiMode == KMdi::TabPageMode) {
01474 m_pClose->hide();
01475 QObject::disconnect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) );
01476
01477 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews);
01478 for( ; it.current(); ++it) {
01479 KMdiChildView* pView = it.current();
01480 if( pView->isToolView())
01481 continue;
01482 kdDebug(760)<<"KMdiMainFrm::finishTabPageMode: in loop"<<endl;
01483 QSize mins = pView->minimumSize();
01484 QSize maxs = pView->maximumSize();
01485 QSize sz = pView->size();
01486 QWidget* pParent = pView->parentWidget();
01487 QPoint p(pParent->mapToGlobal(pParent->pos())-pParent->pos()+m_undockPositioningOffset);
01488 m_documentTabWidget->removePage(pView);
01489 pView->reparent(0,0,p);
01490
01491 pView->resize(sz);
01492 pView->setMinimumSize(mins.width(),mins.height());
01493 pView->setMaximumSize(maxs.width(),maxs.height());
01494
01495
01496
01497
01498
01499
01500 }
01501 delete m_documentTabWidget;
01502 m_documentTabWidget=0;
01503 m_pTaskBar->switchOn(true);
01504 }
01505 }
01506
01507
01508
01509 void KMdiMainFrm::setupTabbedDocumentViewSpace() {
01510
01511 if( (m_mdiMode == KMdi::ToplevelMode) && !parentWidget()) {
01512 setMinimumHeight( m_oldMainFrmMinHeight);
01513 setMaximumHeight( m_oldMainFrmMaxHeight);
01514 resize( width(), m_oldMainFrmHeight);
01515 m_oldMainFrmHeight = 0;
01516
01517 emit leftTopLevelMode();
01518 QApplication::sendPostedEvents();
01519
01520
01521 QDomElement oldDockState = m_pTempDockSession->namedItem("cur_dock_state").toElement();
01522 readDockConfig( oldDockState);
01523 }
01524
01525 #if 0
01526 if (m_pDockbaseOfTabPage != m_pDockbaseAreaOfDocumentViews) {
01527 delete m_pDockbaseOfTabPage;
01528 m_pDockbaseOfTabPage = m_pDockbaseAreaOfDocumentViews;
01529 }
01530 #endif
01531 delete m_documentTabWidget;
01532 m_documentTabWidget=new KMdiDocumentViewTabWidget(m_pDockbaseAreaOfDocumentViews);
01533 connect(m_documentTabWidget,SIGNAL(currentChanged(QWidget*)),this,SLOT(slotDocCurrentChanged(QWidget*)));
01534 m_pDockbaseAreaOfDocumentViews->setWidget(m_documentTabWidget);
01535 m_documentTabWidget->show();
01536 QPtrListIterator<KMdiChildView> it4( *m_pDocumentViews);
01537 for( ; it4.current(); ++it4) {
01538 KMdiChildView* pView = it4.current();
01539 m_documentTabWidget->addTab(pView, pView->icon() ? *(pView->icon()) : QPixmap(),pView->tabCaption());
01540
01541
01542
01543
01544 connect( pView, SIGNAL(iconUpdated(QWidget*, QPixmap )), m_documentTabWidget, SLOT(updateIconInView(QWidget*, QPixmap )) );
01545 connect( pView, SIGNAL(captionUpdated(QWidget*, const QString& )), m_documentTabWidget, SLOT(updateCaptionInView(QWidget*, const QString& )) );
01546
01547 }
01548
01549
01550 }
01551
01552 void KMdiMainFrm::setIDEAlModeStyle(int flags)
01553 {
01554 d->m_styleIDEAlMode = flags;
01555 }
01556
01560 void KMdiMainFrm::switchToIDEAlMode()
01561 {
01562
01563 kdDebug(760)<<"SWITCHING TO IDEAL"<<endl;
01564 KMdiChildView* pRemActiveWindow = activeWindow();
01565
01566 if (m_mdiMode == KMdi::IDEAlMode) {
01567 mdiModeHasBeenChangedTo(KMdi::IDEAlMode);
01568 return;
01569 }
01570
01571
01572 if (m_mdiMode == KMdi::ChildframeMode) {
01573 finishChildframeMode();
01574 }
01575 else if (m_mdiMode == KMdi::ToplevelMode) {
01576 finishToplevelMode();
01577 } else if (m_mdiMode == KMdi::TabPageMode) {
01578 m_mdiMode=KMdi::IDEAlMode;
01579 setupToolViewsForIDEALMode();
01580 mdiModeHasBeenChangedTo(KMdi::IDEAlMode);
01581 return;
01582 }
01583
01584 setupTabbedDocumentViewSpace();
01585 m_mdiMode = KMdi::IDEAlMode;
01586
01587
01588 setupToolViewsForIDEALMode();
01589
01590 if (pRemActiveWindow)
01591 pRemActiveWindow->setFocus();
01592
01593 m_pTaskBar->switchOn(false);
01594
01595 assert(m_pClose);
01596 QObject::connect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) );
01597 if (m_pDocumentViews->count() > 0) {
01598 m_pClose->show();
01599 }
01600
01601
01602 mdiModeHasBeenChangedTo(KMdi::IDEAlMode);
01603 }
01604
01605
01606 void KMdiMainFrm::dockToolViewsIntoContainers(QPtrList<KDockWidget>& widgetsToReparent,KDockWidget *container) {
01607 for ( KDockWidget *dw = widgetsToReparent.first(); dw;
01608 dw=widgetsToReparent.next()){
01609 dw->manualDock(container,KDockWidget::DockCenter,20);
01610 dw->loseFormerBrotherDockWidget();
01611 }
01612 }
01613
01614 void KMdiMainFrm::findToolViewsDockedToMain(QPtrList<KDockWidget>* list,KDockWidget::DockPosition dprtmw) {
01615 KDockWidget *mainDock=getMainDockWidget();
01616 if (mainDock->parentDockTabGroup()) {
01617 mainDock=dynamic_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent());
01618 }
01619
01620 KDockWidget* widget=mainDock->findNearestDockWidget(dprtmw);
01621 if (widget) {
01622 if (widget->parentDockTabGroup()) {
01623 widget=static_cast<KDockWidget*>(widget->parentDockTabGroup()->
01624 parent());
01625 }
01626
01627 if (widget) {
01628 KDockTabGroup *tg=dynamic_cast<KDockTabGroup*>(widget->
01629 getWidget());
01630 if (tg) {
01631 kdDebug(760)<<"KDockTabGroup found"<<endl;
01632 for (int i=0;i<tg->count();i++)
01633 list->append((KDockWidget*)static_cast<KDockWidget*>(
01634 tg->page(i)));
01635 } else
01636 list->append((KDockWidget*)widget);
01637 }
01638 else
01639 kdDebug(760)<<"setupToolViewsForIDEALMode: no widget found"<<endl;
01640
01641
01642 } else
01643 kdDebug(760)<<"No main dock widget found"<<endl;
01644
01645
01646 }
01647
01648
01649 void KMdiMainFrm::setupToolViewsForIDEALMode()
01650 {
01651 m_leftContainer = createDockWidget("KMdiDock::leftDock",SmallIcon("misc"),0L,"Left Dock");
01652 m_rightContainer = createDockWidget("KMdiDock::rightDock",SmallIcon("misc"),0L,"Right Dock");
01653 m_topContainer = createDockWidget("KMdiDock::topDock",SmallIcon("misc"),0L,"Top Dock");
01654 m_bottomContainer = createDockWidget("KMdiDock::bottomDock",SmallIcon("misc"),0L,"Bottom Dock");
01655
01656 KDockWidget *mainDock=getMainDockWidget();
01657 KDockWidget *w=mainDock;
01658 if (mainDock->parentDockTabGroup()) {
01659 w=static_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent());
01660 }
01661
01662 QPtrList<KDockWidget> leftReparentWidgets;
01663 QPtrList<KDockWidget> rightReparentWidgets;
01664 QPtrList<KDockWidget> bottomReparentWidgets;
01665 QPtrList<KDockWidget> topReparentWidgets;
01666
01667 if (mainDock->parentDockTabGroup()) {
01668 mainDock=static_cast<KDockWidget*>(mainDock->parentDockTabGroup()->parent());
01669 }
01670
01671 findToolViewsDockedToMain(&leftReparentWidgets,KDockWidget::DockLeft);
01672 findToolViewsDockedToMain(&rightReparentWidgets,KDockWidget::DockRight);
01673 findToolViewsDockedToMain(&bottomReparentWidgets,KDockWidget::DockBottom);
01674 findToolViewsDockedToMain(&topReparentWidgets,KDockWidget::DockTop);
01675
01676 mainDock->setEnableDocking(KDockWidget::DockNone);
01677 mainDock->setDockSite(KDockWidget::DockCorner);
01678
01679
01680 KMdiDockContainer *tmpDC;
01681 m_leftContainer->setWidget(tmpDC=new KMdiDockContainer(m_leftContainer, this, KDockWidget::DockLeft, d->m_styleIDEAlMode));
01682 m_leftContainer->setEnableDocking(KDockWidget::DockLeft);
01683 m_leftContainer->manualDock(mainDock, KDockWidget::DockLeft,20);
01684 tmpDC->init();
01685 if (m_mdiGUIClient) connect (this,SIGNAL(toggleLeft()),tmpDC,SLOT(toggle()));
01686 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped()));
01687 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*)));
01688 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*)));
01689
01690 m_rightContainer->setWidget(tmpDC=new KMdiDockContainer(m_rightContainer, this, KDockWidget::DockRight, d->m_styleIDEAlMode));
01691 m_rightContainer->setEnableDocking(KDockWidget::DockRight);
01692 m_rightContainer->manualDock(mainDock, KDockWidget::DockRight,80);
01693 tmpDC->init();
01694 if (m_mdiGUIClient) connect (this,SIGNAL(toggleRight()),tmpDC,SLOT(toggle()));
01695 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped()));
01696 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*)));
01697 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*)));
01698
01699 m_topContainer->setWidget(tmpDC=new KMdiDockContainer(m_topContainer, this, KDockWidget::DockTop, d->m_styleIDEAlMode));
01700 m_topContainer->setEnableDocking(KDockWidget::DockTop);
01701 m_topContainer->manualDock(mainDock, KDockWidget::DockTop,20);
01702 tmpDC->init();
01703 if (m_mdiGUIClient) connect (this,SIGNAL(toggleTop()),tmpDC,SLOT(toggle()));
01704 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped()));
01705 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*)));
01706 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*)));
01707
01708 m_bottomContainer->setWidget(tmpDC=new KMdiDockContainer(m_bottomContainer, this, KDockWidget::DockBottom, d->m_styleIDEAlMode));
01709 m_bottomContainer->setEnableDocking(KDockWidget::DockBottom);
01710 m_bottomContainer->manualDock(mainDock, KDockWidget::DockBottom,80);
01711 tmpDC->init();
01712 if (m_mdiGUIClient) connect (this,SIGNAL(toggleBottom()),tmpDC,SLOT(toggle()));
01713 connect(this,SIGNAL(collapseOverlapContainers()),tmpDC,SLOT(collapseOverlapped()));
01714 connect(tmpDC,SIGNAL(activated(KMdiDockContainer*)),this,SLOT(setActiveToolDock(KMdiDockContainer*)));
01715 connect(tmpDC,SIGNAL(deactivated(KMdiDockContainer*)),this,SLOT(removeFromActiveDockList(KMdiDockContainer*)));
01716
01717 m_leftContainer->setDockSite( KDockWidget::DockCenter );
01718 m_rightContainer->setDockSite( KDockWidget::DockCenter );
01719 m_topContainer->setDockSite( KDockWidget::DockCenter );
01720 m_bottomContainer->setDockSite( KDockWidget::DockCenter );
01721
01722 dockToolViewsIntoContainers(leftReparentWidgets,m_leftContainer);
01723 dockToolViewsIntoContainers(rightReparentWidgets,m_rightContainer);
01724 dockToolViewsIntoContainers(bottomReparentWidgets,m_bottomContainer);
01725 dockToolViewsIntoContainers(topReparentWidgets,m_topContainer);
01726
01727
01728 dockManager->setSpecialLeftDockContainer(m_leftContainer);
01729 dockManager->setSpecialRightDockContainer(m_rightContainer);
01730 dockManager->setSpecialTopDockContainer(m_topContainer);
01731 dockManager->setSpecialBottomDockContainer(m_bottomContainer);
01732
01733
01734 ((KMdiDockContainer*) (m_leftContainer->getWidget()))->hideIfNeeded();
01735 ((KMdiDockContainer*) (m_rightContainer->getWidget()))->hideIfNeeded();
01736 ((KMdiDockContainer*) (m_topContainer->getWidget()))->hideIfNeeded();
01737 ((KMdiDockContainer*) (m_bottomContainer->getWidget()))->hideIfNeeded();
01738
01739 }
01740
01741
01742
01743 void KMdiMainFrm::finishIDEAlMode(bool full)
01744 {
01745
01746 if (m_mdiMode == KMdi::IDEAlMode) {
01747 assert(m_pClose);
01748 m_pClose->hide();
01749 QObject::disconnect( m_pClose, SIGNAL(clicked()), this, SLOT(closeViewButtonPressed()) );
01750
01751
01752 QStringList leftNames;
01753 leftNames=prepareIdealToTabs(m_leftContainer);
01754 int leftWidth=m_leftContainer->width();
01755
01756 QStringList rightNames;
01757 rightNames=prepareIdealToTabs(m_rightContainer);
01758 int rightWidth=m_rightContainer->width();
01759
01760 QStringList topNames;
01761 topNames=prepareIdealToTabs(m_topContainer);
01762 int topHeight=m_topContainer->height();
01763
01764 QStringList bottomNames;
01765 bottomNames=prepareIdealToTabs(m_bottomContainer);
01766 int bottomHeight=m_bottomContainer->height();
01767
01768
01769 kdDebug(760)<<"leftNames"<<leftNames<<endl;
01770 kdDebug(760)<<"rightNames"<<rightNames<<endl;
01771 kdDebug(760)<<"topNames"<<topNames<<endl;
01772 kdDebug(760)<<"bottomNames"<<bottomNames<<endl;
01773
01774 delete m_leftContainer;
01775 m_leftContainer=0;
01776 delete m_rightContainer;
01777 m_rightContainer=0;
01778 delete m_bottomContainer;
01779 m_bottomContainer=0;
01780 delete m_topContainer;
01781 m_topContainer=0;
01782
01783
01784 idealToolViewsToStandardTabs(bottomNames,KDockWidget::DockBottom,bottomHeight);
01785 idealToolViewsToStandardTabs(leftNames,KDockWidget::DockLeft,leftWidth);
01786 idealToolViewsToStandardTabs(rightNames,KDockWidget::DockRight,rightWidth);
01787 idealToolViewsToStandardTabs(topNames,KDockWidget::DockTop,topHeight);
01788
01789 QApplication::sendPostedEvents();
01790
01791 if (!full) return;
01792
01793 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews);
01794 for( ; it.current(); ++it) {
01795 KMdiChildView* pView = it.current();
01796 if( pView->isToolView())
01797 continue;
01798 QSize mins = pView->minimumSize();
01799 QSize maxs = pView->maximumSize();
01800 QSize sz = pView->size();
01801 QWidget* pParent = pView->parentWidget();
01802 QPoint p(pParent->mapToGlobal(pParent->pos())-pParent->pos()+m_undockPositioningOffset);
01803 pView->reparent(0,0,p);
01804 pView->reparent(0,0,p);
01805 pView->resize(sz);
01806 pView->setMinimumSize(mins.width(),mins.height());
01807 pView->setMaximumSize(maxs.width(),maxs.height());
01808 KDockWidget* pDockW = 0L;
01809
01810 do {
01811 if (pParent->inherits("KDockWidget") || pParent->inherits("KDockWidget_Compat::KDockWidget")) {
01812 pDockW = (KDockWidget*) pParent;
01813 pDockW->undock();
01814 if (pParent != m_pDockbaseAreaOfDocumentViews) {
01815 pParent->close();
01816 delete pParent;
01817 }
01818 }
01819 else {
01820 pParent = pParent->parentWidget();
01821 }
01822 }
01823 while (pParent && !pDockW);
01824 if (centralWidget() == pParent) {
01825 setCentralWidget(0L);
01826 }
01827 }
01828 m_pTaskBar->switchOn(true);
01829
01830 }
01831
01832 }
01833
01834 QStringList KMdiMainFrm::prepareIdealToTabs(KDockWidget* container) {
01835 KDockContainer* pDW = dynamic_cast<KDockContainer*>(container->getWidget());
01836 QStringList widgetNames=((KMdiDockContainer*)pDW)->containedWidgets();
01837 for (QStringList::iterator it=widgetNames.begin();it!=widgetNames.end();++it) {
01838 KDockWidget* dw = (KDockWidget*) manager()->getDockWidgetFromName(*it);
01839 dw->undock();
01840 dw->setLatestKDockContainer(0);
01841 dw->loseFormerBrotherDockWidget();
01842
01843 }
01844 return widgetNames;
01845 }
01846
01847 void KMdiMainFrm::idealToolViewsToStandardTabs(QStringList widgetNames,KDockWidget::DockPosition pos,int size) {
01848
01849 KDockWidget *mainDock=getMainDockWidget();
01850 if (mainDock->parentDockTabGroup()) {
01851 mainDock=static_cast<KDockWidget*>(mainDock->parentDockTabGroup()->
01852 parent());
01853 }
01854
01855 if(widgetNames.count()>0) {
01856 QStringList::iterator it=widgetNames.begin();
01857 KDockWidget *dwpd=manager()->getDockWidgetFromName(*it);
01858 if (!dwpd) {
01859 kdDebug(760)<<"Fatal error in finishIDEAlMode"<<endl;
01860 return;
01861 }
01862 dwpd->manualDock(mainDock,pos,20);
01863 ++it;
01864 for (;it!=widgetNames.end();++it) {
01865 KDockWidget *tmpdw=manager()->getDockWidgetFromName(*it);
01866 if (!tmpdw) {
01867 kdDebug(760)<<"Fatal error in finishIDEAlMode"<<endl;
01868 return;
01869 }
01870 tmpdw->manualDock(dwpd,KDockWidget::DockCenter,20);
01871 }
01872
01873 #if 0
01874 QWidget *wid=dwpd->parentDockTabGroup();
01875 if (!wid) wid=dwpd;
01876 wid->setGeometry(0,0,20,20);
01877
01878
01879
01880
01881 #endif
01882 }
01883
01884 }
01885
01886
01894 void KMdiMainFrm::setMenuForSDIModeSysButtons( KMenuBar* pMenuBar)
01895 {
01896 if (m_bSDIApplication)
01897 return;
01898
01899 m_pMainMenuBar = pMenuBar;
01900 if( m_pMainMenuBar == 0L)
01901 return;
01902
01903 if (!m_pUndock)
01904 m_pUndock = new QToolButton( pMenuBar);
01905 if (!m_pRestore)
01906 m_pRestore = new QToolButton( pMenuBar);
01907 if (!m_pMinimize)
01908 m_pMinimize = new QToolButton( pMenuBar);
01909 if (!m_pClose)
01910 m_pClose = new QToolButton( pMenuBar);
01911 m_pUndock->setAutoRaise(false);
01912 m_pMinimize->setAutoRaise(false);
01913 m_pRestore->setAutoRaise(false);
01914 m_pClose->setAutoRaise(false);
01915
01916 setSysButtonsAtMenuPosition();
01917
01918 delete m_pUndockButtonPixmap;
01919 delete m_pMinButtonPixmap;
01920 delete m_pRestoreButtonPixmap;
01921 delete m_pCloseButtonPixmap;
01922
01923 if (frameDecorOfAttachedViews() == KMdi::Win95Look) {
01924 m_pUndockButtonPixmap = new QPixmap( win_undockbutton);
01925 m_pMinButtonPixmap = new QPixmap( win_minbutton);
01926 m_pRestoreButtonPixmap = new QPixmap( win_restorebutton);
01927 m_pCloseButtonPixmap = new QPixmap( win_closebutton);
01928 }
01929 else if (frameDecorOfAttachedViews() == KMdi::KDE1Look) {
01930 m_pUndockButtonPixmap = new QPixmap( kde_undockbutton);
01931 m_pMinButtonPixmap = new QPixmap( kde_minbutton);
01932 m_pRestoreButtonPixmap = new QPixmap( kde_restorebutton);
01933 m_pCloseButtonPixmap = new QPixmap( kde_closebutton);
01934 m_pUndock->setAutoRaise(true);
01935 m_pMinimize->setAutoRaise(true);
01936 m_pRestore->setAutoRaise(true);
01937 m_pClose->setAutoRaise(true);
01938 }
01939 else if (frameDecorOfAttachedViews() == KMdi::KDELook) {
01940 m_pUndockButtonPixmap = new QPixmap( kde2_undockbutton);
01941 m_pMinButtonPixmap = new QPixmap( kde2_minbutton);
01942 m_pRestoreButtonPixmap = new QPixmap( kde2_restorebutton);
01943 m_pCloseButtonPixmap = new QPixmap( kde2_closebutton);
01944 }
01945 else {
01946 m_pUndockButtonPixmap = new QPixmap( kde2laptop_undockbutton);
01947 m_pMinButtonPixmap = new QPixmap( kde2laptop_minbutton);
01948 m_pRestoreButtonPixmap = new QPixmap( kde2laptop_restorebutton);
01949 m_pCloseButtonPixmap = new QPixmap( kde2laptop_closebutton);
01950 }
01951
01952 m_pUndock->hide();
01953 m_pMinimize->hide();
01954 m_pRestore->hide();
01955 m_pClose->hide();
01956
01957 m_pUndock->setPixmap( *m_pUndockButtonPixmap);
01958 m_pMinimize->setPixmap( *m_pMinButtonPixmap);
01959 m_pRestore->setPixmap( *m_pRestoreButtonPixmap);
01960 m_pClose->setPixmap( *m_pCloseButtonPixmap);
01961 }
01962
01963 void KMdiMainFrm::setSysButtonsAtMenuPosition()
01964 {
01965 if( m_pMainMenuBar == 0L)
01966 return;
01967 if( m_pMainMenuBar->parentWidget() == 0L)
01968 return;
01969
01970 int menuW = m_pMainMenuBar->parentWidget()->width();
01971 int h;
01972 int y;
01973 if (frameDecorOfAttachedViews() == KMdi::Win95Look)
01974 h = 16;
01975 else if (frameDecorOfAttachedViews() == KMdi::KDE1Look)
01976 h = 20;
01977 else if (frameDecorOfAttachedViews() == KMdi::KDELook)
01978 h = 16;
01979 else
01980 h = 14;
01981 y = m_pMainMenuBar->height()/2 - h/2;
01982
01983 if (frameDecorOfAttachedViews() == KMdi::KDELaptopLook) {
01984 int w = 27;
01985 m_pUndock->setGeometry( ( menuW - ( w * 3) - 5), y, w, h);
01986 m_pMinimize->setGeometry( ( menuW - ( w * 2) - 5), y, w, h);
01987 m_pRestore->setGeometry( ( menuW - w - 5), y, w, h);
01988 }
01989 else {
01990 m_pUndock->setGeometry( ( menuW - ( h * 4) - 5), y, h, h);
01991 m_pMinimize->setGeometry( ( menuW - ( h * 3) - 5), y, h, h);
01992 m_pRestore->setGeometry( ( menuW - ( h * 2) - 5), y, h, h);
01993 m_pClose->setGeometry( ( menuW - h - 5), y, h, h);
01994 }
01995 }
01996
01998 void KMdiMainFrm::activateNextWin()
01999 {
02000 KMdiIterator<KMdiChildView*>* it = createIterator();
02001 KMdiChildView* aWin = activeWindow();
02002 for (it->first(); !it->isDone(); it->next()) {
02003 if (it->currentItem() == aWin) {
02004 it->next();
02005 if (!it->currentItem()) {
02006 it->first();
02007 }
02008 if (it->currentItem()) {
02009 activateView(it->currentItem());
02010 }
02011 break;
02012 }
02013 }
02014 delete it;
02015 }
02016
02018 void KMdiMainFrm::activatePrevWin()
02019 {
02020 KMdiIterator<KMdiChildView*>* it = createIterator();
02021 KMdiChildView* aWin = activeWindow();
02022 for (it->first(); !it->isDone(); it->next()) {
02023 if (it->currentItem() == aWin) {
02024 it->prev();
02025 if (!it->currentItem()) {
02026 it->last();
02027 }
02028 if (it->currentItem()) {
02029 activateView(it->currentItem());
02030 }
02031 break;
02032 }
02033 }
02034 delete it;
02035 }
02036
02038 void KMdiMainFrm::activateFirstWin()
02039 {
02040 KMdiIterator<KMdiChildView*>* it = createIterator();
02041 QMap<QDateTime,KMdiChildView*> m;
02042 for (it->first(); !it->isDone(); it->next()) {
02043 m.insert(it->currentItem()->getTimeStamp(), it->currentItem());
02044 }
02045
02046 if ( !activeWindow() ) return;
02047
02048 QDateTime current = activeWindow()->getTimeStamp();
02049 QMap<QDateTime,KMdiChildView*>::iterator pos(m.find(current));
02050 QMap<QDateTime,KMdiChildView*>::iterator newPos = pos;
02051 if (pos != m.end()) {
02052 ++newPos;
02053 }
02054 if (newPos != m.end()) {
02055 ++pos;
02056 }
02057 else {
02058 pos = m.begin();
02059 }
02060 activateView(pos.data());
02061 m_bSwitching= true;
02062 delete it;
02063 }
02064
02066 void KMdiMainFrm::activateLastWin()
02067 {
02068 KMdiIterator<KMdiChildView*>* it = createIterator();
02069 QMap<QDateTime,KMdiChildView*> m;
02070 for (it->first(); !it->isDone(); it->next()) {
02071 m.insert(it->currentItem()->getTimeStamp(), it->currentItem());
02072 }
02073
02074 if ( !activeWindow() ) return;
02075
02076 QDateTime current = activeWindow()->getTimeStamp();
02077 QMap<QDateTime,KMdiChildView*>::iterator pos(m.find(current));
02078 if (pos != m.begin()) {
02079 --pos;
02080 }
02081 else {
02082 pos = m.end();
02083 --pos;
02084 }
02085 activateView(pos.data());
02086 m_bSwitching= true;
02087 delete it;
02088 }
02089
02091 void KMdiMainFrm::activateView(int index)
02092 {
02093 KMdiChildView* pView = m_pDocumentViews->first();
02094 for (int i = 0; pView && (i < index); i++) {
02095 pView = m_pDocumentViews->next();
02096 }
02097 if (pView) {
02098 pView->activate();
02099 }
02100 }
02101
02103 void KMdiMainFrm::setEnableMaximizedChildFrmMode(bool bEnable)
02104 {
02105 if (bEnable) {
02106 m_bMaximizedChildFrmMode = true;
02107
02108
02109 KMdiChildFrm* pCurrentChild = m_pMdi->topChild();
02110 if( !pCurrentChild)
02111 return;
02112
02113
02114 if( m_pMainMenuBar == 0L)
02115 return;
02116
02117 QObject::connect( m_pUndock, SIGNAL(clicked()), pCurrentChild, SLOT(undockPressed()) );
02118 m_pUndock->show();
02119 QObject::connect( m_pMinimize, SIGNAL(clicked()), pCurrentChild, SLOT(minimizePressed()) );
02120 m_pMinimize->show();
02121 QObject::connect( m_pRestore, SIGNAL(clicked()), pCurrentChild, SLOT(maximizePressed()) );
02122 m_pRestore->show();
02123
02124 if (frameDecorOfAttachedViews() == KMdi::KDELaptopLook) {
02125 m_pMainMenuBar->insertItem( QPixmap(kde2laptop_closebutton_menu), m_pMdi->topChild(), SLOT(closePressed()), 0, -1, 0);
02126 }
02127 else {
02128 m_pMainMenuBar->insertItem( *pCurrentChild->icon(), pCurrentChild->systemMenu(), -1, 0);
02129 assert(m_pClose);
02130 QObject::connect( m_pClose, SIGNAL(clicked()), pCurrentChild, SLOT(closePressed()) );
02131 m_pClose->show();
02132 }
02133 }
02134 else {
02135 if (!m_bMaximizedChildFrmMode) return;
02136
02137 m_bMaximizedChildFrmMode = false;
02138
02139
02140 KMdiChildFrm* pFrmChild = m_pMdi->topChild();
02141 if (!pFrmChild) return;
02142
02143 if (pFrmChild->m_pClient && pFrmChild->state() == KMdiChildFrm::Maximized) {
02144 pFrmChild->m_pClient->restore();
02145 switchOffMaximizeModeForMenu( pFrmChild);
02146 }
02147 }
02148 }
02149
02151 void KMdiMainFrm::switchOffMaximizeModeForMenu(KMdiChildFrm* oldChild)
02152 {
02153
02154
02155
02156 if( m_pMainMenuBar == 0L)
02157 return;
02158
02159 m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt(0));
02160
02161 if( oldChild) {
02162 assert(m_pClose);
02163 QObject::disconnect( m_pUndock, SIGNAL(clicked()), oldChild, SLOT(undockPressed()) );
02164 QObject::disconnect( m_pMinimize, SIGNAL(clicked()), oldChild, SLOT(minimizePressed()) );
02165 QObject::disconnect( m_pRestore, SIGNAL(clicked()), oldChild, SLOT(maximizePressed()) );
02166 QObject::disconnect( m_pClose, SIGNAL(clicked()), oldChild, SLOT(closePressed()) );
02167 }
02168 m_pUndock->hide();
02169 m_pMinimize->hide();
02170 m_pRestore->hide();
02171 m_pClose->hide();
02172 }
02173
02175 void KMdiMainFrm::updateSysButtonConnections( KMdiChildFrm* oldChild, KMdiChildFrm* newChild)
02176 {
02177
02178
02179 if( m_pMainMenuBar == 0L)
02180 return;
02181
02182 if (newChild) {
02183 if (frameDecorOfAttachedViews() == KMdi::KDELaptopLook) {
02184 m_pMainMenuBar->insertItem( QPixmap(kde2laptop_closebutton_menu), newChild, SLOT(closePressed()), 0, -1, 0);
02185 }
02186 else {
02187 m_pMainMenuBar->insertItem( *newChild->icon(), newChild->systemMenu(), -1, 0);
02188 }
02189 }
02190 if (oldChild) {
02191 m_pMainMenuBar->removeItem( m_pMainMenuBar->idAt(1));
02192 }
02193 if (oldChild) {
02194 assert(m_pClose);
02195 QObject::disconnect( m_pUndock, SIGNAL(clicked()), oldChild, SLOT(undockPressed()) );
02196 QObject::disconnect( m_pMinimize, SIGNAL(clicked()), oldChild, SLOT(minimizePressed()) );
02197 QObject::disconnect( m_pRestore, SIGNAL(clicked()), oldChild, SLOT(maximizePressed()) );
02198 QObject::disconnect( m_pClose, SIGNAL(clicked()), oldChild, SLOT(closePressed()) );
02199 }
02200 if (newChild) {
02201 assert(m_pClose);
02202 QObject::connect( m_pUndock, SIGNAL(clicked()), newChild, SLOT(undockPressed()) );
02203 QObject::connect( m_pMinimize, SIGNAL(clicked()), newChild, SLOT(minimizePressed()) );
02204 QObject::connect( m_pRestore, SIGNAL(clicked()), newChild, SLOT(maximizePressed()) );
02205 QObject::connect( m_pClose, SIGNAL(clicked()), newChild, SLOT(closePressed()) );
02206 }
02207 }
02208
02210 bool KMdiMainFrm::isViewTaskBarOn()
02211 {
02212 bool bOn = false;
02213 if (m_pTaskBar)
02214 bOn = m_pTaskBar->isSwitchedOn();
02215 return bOn;
02216 }
02217
02219 void KMdiMainFrm::showViewTaskBar()
02220 {
02221 if (m_pTaskBar)
02222 m_pTaskBar->switchOn(true);
02223 }
02224
02226 void KMdiMainFrm::hideViewTaskBar()
02227 {
02228 if (m_pTaskBar)
02229 m_pTaskBar->switchOn(false);
02230 }
02231
02232
02233 void KMdiMainFrm::fillWindowMenu()
02234 {
02235 bool bTabPageMode = false;
02236 if (m_mdiMode == KMdi::TabPageMode)
02237 bTabPageMode = true;
02238
02239 bool bNoViewOpened = false;
02240 if (m_pDocumentViews->isEmpty()) {
02241 bNoViewOpened = true;
02242 }
02243
02244 if (!m_bClearingOfWindowMenuBlocked) {
02245 m_pWindowMenu->clear();
02246 }
02247 int closeId = m_pWindowMenu->insertItem(i18n("&Close"), this, SLOT(closeActiveView()));
02248 int closeAllId = m_pWindowMenu->insertItem(i18n("Close &All"), this, SLOT(closeAllViews()));
02249 if (bNoViewOpened) {
02250 m_pWindowMenu->setItemEnabled(closeId, false);
02251 m_pWindowMenu->setItemEnabled(closeAllId, false);
02252 }
02253 if (!bTabPageMode) {
02254 int iconifyId = m_pWindowMenu->insertItem(i18n("&Minimize All"), this, SLOT(iconifyAllViews()));
02255 if (bNoViewOpened) {
02256 m_pWindowMenu->setItemEnabled(iconifyId, false);
02257 }
02258 }
02259 m_pWindowMenu->insertSeparator();
02260 m_pWindowMenu->insertItem(i18n("&MDI Mode..."), m_pMdiModeMenu);
02261 m_pMdiModeMenu->clear();
02262 m_pMdiModeMenu->insertItem(i18n("&Toplevel Mode"), this, SLOT(switchToToplevelMode()));
02263 m_pMdiModeMenu->insertItem(i18n("C&hildframe Mode"), this, SLOT(switchToChildframeMode()));
02264 m_pMdiModeMenu->insertItem(i18n("Ta&b Page Mode"), this, SLOT(switchToTabPageMode()));
02265 m_pMdiModeMenu->insertItem(i18n("I&DEAl Mode"), this, SLOT(switchToIDEAlMode()));
02266 switch (m_mdiMode) {
02267 case KMdi::ToplevelMode:
02268 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(0), true);
02269 break;
02270 case KMdi::ChildframeMode:
02271 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(1), true);
02272 break;
02273 case KMdi::TabPageMode:
02274 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(2), true);
02275 break;
02276 case KMdi::IDEAlMode:
02277 m_pMdiModeMenu->setItemChecked(m_pMdiModeMenu->idAt(3),true);
02278 break;
02279 default:
02280 break;
02281 }
02282 m_pWindowMenu->insertSeparator();
02283 if (!bTabPageMode) {
02284 int placMenuId = m_pWindowMenu->insertItem(i18n("&Tile..."), m_pPlacingMenu);
02285 m_pPlacingMenu->clear();
02286 m_pPlacingMenu->insertItem(i18n("Ca&scade Windows"), m_pMdi,SLOT(cascadeWindows()));
02287 m_pPlacingMenu->insertItem(i18n("Cascade &Maximized"), m_pMdi,SLOT(cascadeMaximized()));
02288 m_pPlacingMenu->insertItem(i18n("Expand &Vertically"), m_pMdi,SLOT(expandVertical()));
02289 m_pPlacingMenu->insertItem(i18n("Expand &Horizontally"), m_pMdi,SLOT(expandHorizontal()));
02290 m_pPlacingMenu->insertItem(i18n("Tile &Non-overlapped"), m_pMdi,SLOT(tileAnodine()));
02291 m_pPlacingMenu->insertItem(i18n("Tile Overla&pped"), m_pMdi,SLOT(tilePragma()));
02292 m_pPlacingMenu->insertItem(i18n("Tile V&ertically"), m_pMdi,SLOT(tileVertically()));
02293 if (m_mdiMode == KMdi::ToplevelMode) {
02294 m_pWindowMenu->setItemEnabled(placMenuId, false);
02295 }
02296 m_pWindowMenu->insertSeparator();
02297 int dockUndockId = m_pWindowMenu->insertItem(i18n("&Dock/Undock..."), m_pDockMenu);
02298 m_pDockMenu->clear();
02299 m_pWindowMenu->insertSeparator();
02300 if (bNoViewOpened) {
02301 m_pWindowMenu->setItemEnabled(placMenuId, false);
02302 m_pWindowMenu->setItemEnabled(dockUndockId, false);
02303 }
02304 }
02305 int entryCount = m_pWindowMenu->count();
02306
02307
02308 int i=100;
02309 KMdiChildView* pView = 0L;
02310 QPtrListIterator<KMdiChildView> it(*m_pDocumentViews);
02311 QValueList<QDateTime> timeStamps;
02312 for (; it.current(); ++it) {
02313 pView = it.current();
02314 QDateTime timeStamp( pView->getTimeStamp() );
02315
02316 if (pView->isToolView()) {
02317 continue;
02318 }
02319
02320 QString item;
02321
02322 if (pView->isMinimized()) {
02323 item += "(";
02324 item += pView->caption();
02325 item += ")";
02326 }
02327 else {
02328 item += " ";
02329 item += pView->caption();
02330 }
02331
02332
02333 unsigned int indx;
02334 unsigned int windowItemCount = m_pWindowMenu->count() - entryCount;
02335 bool inserted = false;
02336 QString tmpString;
02337 QValueList<QDateTime>::iterator timeStampIterator = timeStamps.begin();
02338 for (indx = 0; indx <= windowItemCount; indx++, ++timeStampIterator) {
02339 bool putHere = false;
02340 if ((*timeStampIterator) < timeStamp) {
02341 putHere = true;
02342 timeStamps.insert(timeStampIterator, timeStamp);
02343 }
02344 if (putHere) {
02345 m_pWindowMenu->insertItem( item, pView, SLOT(slot_clickedInWindowMenu()), 0, -1, indx+entryCount);
02346 if (pView == m_pCurrentWindow) {
02347 m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt( indx+entryCount), true);
02348 }
02349 pView->setWindowMenuID(i);
02350 if (!bTabPageMode) {
02351 m_pDockMenu->insertItem( item, pView, SLOT(slot_clickedInDockMenu()), 0, -1, indx);
02352 if (pView->isAttached()) {
02353 m_pDockMenu->setItemChecked( m_pDockMenu->idAt( indx), true);
02354 }
02355 }
02356 inserted = true;
02357 break;
02358 indx = windowItemCount+1;
02359 }
02360 }
02361 if (!inserted) {
02362 m_pWindowMenu->insertItem( item, pView, SLOT(slot_clickedInWindowMenu()), 0, -1, windowItemCount+entryCount);
02363 if (pView == m_pCurrentWindow) {
02364 m_pWindowMenu->setItemChecked( m_pWindowMenu->idAt(windowItemCount+entryCount), true);
02365 }
02366 pView->setWindowMenuID( i);
02367 if (!bTabPageMode) {
02368 m_pDockMenu->insertItem( item, pView, SLOT(slot_clickedInDockMenu()), 0, -1, windowItemCount);
02369 if (pView->isAttached()) {
02370 m_pDockMenu->setItemChecked( m_pDockMenu->idAt(windowItemCount), true);
02371 }
02372 }
02373 }
02374 i++;
02375 }
02376 }
02377
02378
02379
02380 void KMdiMainFrm::windowMenuItemActivated(int id)
02381 {
02382 if (id < 100) return;
02383 id -= 100;
02384 KMdiChildView *pView = m_pDocumentViews->at( id);
02385 if (!pView) return;
02386 if (pView->isMinimized()) pView->minimize();
02387 if (m_mdiMode != KMdi::TabPageMode) {
02388 KMdiChildFrm* pTopChild = m_pMdi->topChild();
02389 if (pTopChild) {
02390 if ((pView == pTopChild->m_pClient) && pView->isAttached()) {
02391 return;
02392 }
02393 }
02394 }
02395 activateView( pView);
02396 }
02397
02398
02399
02400 void KMdiMainFrm::dockMenuItemActivated(int id)
02401 {
02402 if( id < 100) return;
02403 id -= 100;
02404 KMdiChildView *pView = m_pDocumentViews->at( id);
02405 if( !pView) return;
02406 if( pView->isMinimized()) pView->minimize();
02407 if( pView->isAttached()) {
02408 detachWindow( pView, true);
02409 }
02410 else {
02411 attachWindow( pView, true);
02412 }
02413 }
02414
02415
02416
02417 void KMdiMainFrm::popupWindowMenu(QPoint p)
02418 {
02419 if (!isFakingSDIApplication()) {
02420 m_pWindowMenu->popup( p);
02421 }
02422 }
02423
02424
02425 void KMdiMainFrm::dragEndTimeOut()
02426 {
02427
02428 KMdiChildView* pView;
02429 for (m_pDocumentViews->first(); (pView = m_pDocumentViews->current()) != 0L; m_pDocumentViews->next()) {
02430 KMdiChildFrmDragEndEvent dragEndEvent(0L);
02431 QApplication::sendEvent(pView, &dragEndEvent);
02432 }
02433 }
02434
02435
02436
02437 void KMdiMainFrm::setFrameDecorOfAttachedViews( int frameDecor)
02438 {
02439 switch (frameDecor) {
02440 case 0:
02441 m_frameDecoration = KMdi::Win95Look;
02442 break;
02443 case 1:
02444 m_frameDecoration = KMdi::KDE1Look;
02445 break;
02446 case 2:
02447 m_frameDecoration = KMdi::KDELook;
02448 break;
02449 case 3:
02450 m_frameDecoration = KMdi::KDELaptopLook;
02451 break;
02452 default:
02453 qDebug("unknown MDI decoration");
02454 break;
02455 }
02456 setMenuForSDIModeSysButtons( m_pMainMenuBar);
02457 QPtrListIterator<KMdiChildView> it( *m_pDocumentViews);
02458 for( ; it.current(); ++it) {
02459 KMdiChildView* pView = it.current();
02460 if( pView->isToolView())
02461 continue;
02462 if( pView->isAttached())
02463 pView->mdiParent()->redecorateButtons();
02464 }
02465 }
02466
02467 void KMdiMainFrm::fakeSDIApplication()
02468 {
02469 m_bSDIApplication = true;
02470 if (m_pTaskBar)
02471 m_pTaskBar->close();
02472 m_pTaskBar = 0L;
02473 }
02474
02475 void KMdiMainFrm::closeViewButtonPressed()
02476 {
02477 KMdiChildView* pView = activeWindow();
02478 if (pView) {
02479 pView->close();
02480 }
02481 }
02482
02483 void KMdiMainFrm::setManagedDockPositionModeEnabled(bool enabled)
02484 {
02485 m_managedDockPositionMode=enabled;
02486 }
02487
02488 void KMdiMainFrm::setActiveToolDock(KMdiDockContainer* td) {
02489 if (td==d->activeDockPriority[0]) return;
02490 if (d->activeDockPriority[0]==0) {
02491 d->activeDockPriority[0]=td;
02492 d->focusList=new KMdiFocusList(this);
02493 if (m_pMdi) d->focusList->addWidgetTree(m_pMdi);
02494 if (m_documentTabWidget) d->focusList->addWidgetTree(m_documentTabWidget);
02495 return;
02496 }
02497 int offset=0;
02498 for (int dst=3,src=2;src>=0;dst--,src--) {
02499 if (d->activeDockPriority[src]==td) src--;
02500 if (src<0) break;
02501 d->activeDockPriority[dst]=d->activeDockPriority[src];
02502 }
02503 d->activeDockPriority[0]=td;
02504 }
02505
02506 void KMdiMainFrm::removeFromActiveDockList(KMdiDockContainer* td) {
02507 for (int i=0;i<4;i++) {
02508 if (d->activeDockPriority[i]==td) {
02509 for (int i2=i;i<3;i++)
02510 d->activeDockPriority[i]=d->activeDockPriority[i+1];
02511 d->activeDockPriority[3]=0;
02512 break;
02513 }
02514 }
02515 if (d->activeDockPriority[0]==0) {
02516 if (d->focusList) d->focusList->restore();
02517 delete d->focusList;
02518 d->focusList=0;
02519 }
02520 }
02521
02522 void KMdiMainFrm::prevToolViewInDock() {
02523 KMdiDockContainer* td=d->activeDockPriority[0];
02524 if (!td) return;
02525 td->prevToolView();
02526 }
02527
02528 void KMdiMainFrm::nextToolViewInDock() {
02529 KMdiDockContainer* td=d->activeDockPriority[0];
02530 if (!td) return;
02531 td->nextToolView();
02532 }
02533
02534 KTabWidget * KMdiMainFrm::tabWidget() const
02535 {
02536 return m_documentTabWidget;
02537 }
02538
02539 #include "kmdimainfrm.moc"
02540
02541