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