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