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