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