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