kmdi Library API Documentation

kmdichildfrm.cpp

00001 //---------------------------------------------------------------------------- 00002 // filename : kmdichildfrm.cpp 00003 //---------------------------------------------------------------------------- 00004 // Project : KDE MDI extension 00005 // 00006 // begin : 07/1999 by Szymon Stefanek as part of kvirc 00007 // (an IRC application) 00008 // changes : 09/1999 by Falk Brettschneider to create an 00009 // - 06/2000 stand-alone Qt extension set of 00010 // classes and a Qt-based library 00011 // : 01/2003 by Jens Zurheide to allow switching 00012 // between views based on timestamps 00013 // 2000-2003 maintained by the KDevelop project 00014 // 00015 // copyright : (C) 1999-2003 by Szymon Stefanek (stefanek@tin.it) 00016 // and 00017 // Falk Brettschneider 00018 // email : falkbr@kdevelop.org (Falk Brettschneider) 00019 //---------------------------------------------------------------------------- 00020 // 00021 //---------------------------------------------------------------------------- 00022 // 00023 // This program is free software; you can redistribute it and/or modify 00024 // it under the terms of the GNU Library General Public License as 00025 // published by the Free Software Foundation; either version 2 of the 00026 // License, or (at your option) any later version. 00027 // 00028 //---------------------------------------------------------------------------- 00029 00030 #include "kmdichildfrm.h" 00031 #include "kmdichildfrm.moc" 00032 00033 #include "kmdidefines.h" 00034 #include "kmdichildfrmcaption.h" 00035 #include "kmdichildarea.h" 00036 #include "kmdimainfrm.h" 00037 00038 #include <qpainter.h> 00039 #include <qapplication.h> 00040 #include <qcursor.h> 00041 #include <qobjectlist.h> 00042 #include <qframe.h> 00043 #include <qpopupmenu.h> 00044 #include <qtoolbutton.h> 00045 #include <qnamespace.h> 00046 #include <qimage.h> 00047 00048 #include <klocale.h> 00049 #include <kiconloader.h> 00050 00052 // KMdiChildFrm 00054 00055 #define KMDI_NORESIZE 0 00056 #define KMDI_RESIZE_TOP 1 00057 #define KMDI_RESIZE_LEFT 2 00058 #define KMDI_RESIZE_RIGHT 4 00059 #define KMDI_RESIZE_BOTTOM 8 00060 #define KMDI_RESIZE_TOPLEFT (1|2) 00061 #define KMDI_RESIZE_TOPRIGHT (1|4) 00062 #define KMDI_RESIZE_BOTTOMLEFT (8|2) 00063 #define KMDI_RESIZE_BOTTOMRIGHT (8|4) 00064 00065 #include "filenew.xpm" 00066 #include "win_closebutton.xpm" 00067 #include "win_minbutton.xpm" 00068 #include "win_maxbutton.xpm" 00069 #include "win_restorebutton.xpm" 00070 #include "win_undockbutton.xpm" 00071 #include "kde_closebutton.xpm" 00072 #include "kde_minbutton.xpm" 00073 #include "kde_maxbutton.xpm" 00074 #include "kde_restorebutton.xpm" 00075 #include "kde_undockbutton.xpm" 00076 #include "kde2_closebutton.xpm" 00077 #include "kde2_minbutton.xpm" 00078 #include "kde2_maxbutton.xpm" 00079 #include "kde2_restorebutton.xpm" 00080 #include "kde2_undockbutton.xpm" 00081 #include "kde2laptop_closebutton.xpm" 00082 #include "kde2laptop_minbutton.xpm" 00083 #include "kde2laptop_maxbutton.xpm" 00084 #include "kde2laptop_restorebutton.xpm" 00085 #include "kde2laptop_undockbutton.xpm" 00086 00087 00088 KMdiWin32IconButton::KMdiWin32IconButton( QWidget* parent, const char* name ) 00089 : QLabel( parent, name ) 00090 {} 00091 00092 //============ mousePressEvent ============// 00093 00094 void KMdiWin32IconButton::mousePressEvent( QMouseEvent* ) 00095 { 00096 //emit pressed(); 00097 } 00098 00099 //============ KMdiChildFrm ============// 00100 00101 KMdiChildFrm::KMdiChildFrm( KMdiChildArea *parent ) 00102 : QFrame( parent, "kmdi_childfrm" ) 00103 , m_pClient( 0L ) 00104 , m_pManager( 0L ) 00105 , m_pCaption( 0L ) 00106 , m_pWinIcon( 0L ) 00107 , m_pUnixIcon( 0L ) 00108 , m_pMinimize( 0L ) 00109 , m_pMaximize( 0L ) 00110 , m_pClose( 0L ) 00111 , m_pUndock( 0L ) 00112 , m_state( Normal ) 00113 , m_restoredRect() 00114 , m_iResizeCorner( KMDI_NORESIZE ) 00115 , m_iLastCursorCorner( KMDI_NORESIZE ) 00116 , m_bResizing( false ) 00117 , m_bDragging( false ) 00118 , m_pIconButtonPixmap( 0L ) 00119 , m_pMinButtonPixmap( 0L ) 00120 , m_pMaxButtonPixmap( 0L ) 00121 , m_pRestoreButtonPixmap( 0L ) 00122 , m_pCloseButtonPixmap( 0L ) 00123 , m_pUndockButtonPixmap( 0L ) 00124 , m_windowMenuID( 0 ) 00125 , m_pSystemMenu( 0L ) 00126 , m_oldClientMinSize() 00127 , m_oldClientMaxSize() 00128 , m_oldLayoutResizeMode( QLayout::Minimum ) 00129 { 00130 m_pCaption = new KMdiChildFrmCaption( this ); 00131 00132 m_pManager = parent; 00133 00134 m_pWinIcon = new KMdiWin32IconButton( m_pCaption, "kmdi_iconbutton_icon" ); 00135 m_pUnixIcon = new QToolButton( m_pCaption, "kmdi_toolbutton_icon" ); 00136 m_pMinimize = new QToolButton( m_pCaption, "kmdi_toolbutton_min" ); 00137 m_pMaximize = new QToolButton( m_pCaption, "kmdi_toolbutton_max" ); 00138 m_pClose = new QToolButton( m_pCaption, "kmdi_toolbutton_close" ); 00139 m_pUndock = new QToolButton( m_pCaption, "kmdi_toolbutton_undock" ); 00140 00141 QObject::connect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( minimizePressed() ) ); 00142 QObject::connect( m_pMaximize, SIGNAL( clicked() ), this, SLOT( maximizePressed() ) ); 00143 QObject::connect( m_pClose, SIGNAL( clicked() ), this, SLOT( closePressed() ) ); 00144 QObject::connect( m_pUndock, SIGNAL( clicked() ), this, SLOT( undockPressed() ) ); 00145 00146 m_pIconButtonPixmap = new QPixmap( SmallIcon( "filenew" ) ); 00147 if ( m_pIconButtonPixmap->isNull() ) 00148 * m_pIconButtonPixmap = QPixmap( filenew ); 00149 00150 redecorateButtons(); 00151 00152 m_pWinIcon->setFocusPolicy( NoFocus ); 00153 m_pUnixIcon->setFocusPolicy( NoFocus ); 00154 m_pClose->setFocusPolicy( NoFocus ); 00155 m_pMinimize->setFocusPolicy( NoFocus ); 00156 m_pMaximize->setFocusPolicy( NoFocus ); 00157 m_pUndock->setFocusPolicy( NoFocus ); 00158 00159 setFrameStyle( QFrame::WinPanel | QFrame::Raised ); 00160 setFocusPolicy( NoFocus ); 00161 00162 setMouseTracking( true ); 00163 00164 setMinimumSize( KMDI_CHILDFRM_MIN_WIDTH, m_pCaption->heightHint() ); 00165 00166 m_pSystemMenu = new QPopupMenu(); 00167 } 00168 00169 //============ ~KMdiChildFrm ============// 00170 00171 KMdiChildFrm::~KMdiChildFrm() 00172 { 00173 delete m_pMinButtonPixmap; 00174 delete m_pMaxButtonPixmap; 00175 delete m_pRestoreButtonPixmap; 00176 delete m_pCloseButtonPixmap; 00177 delete m_pUndockButtonPixmap; 00178 delete m_pSystemMenu; 00179 delete m_pIconButtonPixmap; 00180 } 00181 00182 //============ mousePressEvent =============// 00183 void KMdiChildFrm::mousePressEvent( QMouseEvent *e ) 00184 { 00185 if ( m_bResizing ) 00186 { 00187 if ( QApplication::overrideCursor() ) 00188 QApplication::restoreOverrideCursor(); 00189 00190 m_bResizing = false; 00191 releaseMouse(); 00192 } 00193 00194 m_pCaption->setActive( true ); 00195 m_pManager->setTopChild( this, false ); 00196 00197 m_iResizeCorner = getResizeCorner( e->pos().x(), e->pos().y() ); 00198 if ( m_iResizeCorner != KMDI_NORESIZE ) 00199 { 00200 m_bResizing = true; 00201 //notify child view 00202 KMdiChildFrmResizeBeginEvent ue( e ); 00203 if ( m_pClient != 0L ) 00204 QApplication::sendEvent( m_pClient, &ue ); 00205 } 00206 } 00207 00208 //============ mouseReleaseEvent ==============// 00209 00210 void KMdiChildFrm::mouseReleaseEvent( QMouseEvent *e ) 00211 { 00212 if ( m_bResizing ) 00213 { 00214 if ( QApplication::overrideCursor() ) 00215 QApplication::restoreOverrideCursor(); 00216 00217 m_bResizing = false; 00218 //notify child view 00219 KMdiChildFrmResizeEndEvent ue( e ); 00220 if ( m_pClient != 0L ) 00221 QApplication::sendEvent( m_pClient, &ue ); 00222 } 00223 } 00224 00225 //============= setResizeCursor ===============// 00226 00227 void KMdiChildFrm::setResizeCursor( int resizeCorner ) 00228 { 00229 if ( resizeCorner == m_iLastCursorCorner ) 00230 return ; //Don't do it twice 00231 00232 m_iLastCursorCorner = resizeCorner; 00233 switch ( resizeCorner ) 00234 { 00235 case KMDI_NORESIZE: 00236 if ( QApplication::overrideCursor() ) 00237 QApplication::restoreOverrideCursor(); 00238 break; 00239 case KMDI_RESIZE_LEFT: 00240 case KMDI_RESIZE_RIGHT: 00241 QApplication::setOverrideCursor( Qt::sizeHorCursor, true ); 00242 break; 00243 case KMDI_RESIZE_TOP: 00244 case KMDI_RESIZE_BOTTOM: 00245 QApplication::setOverrideCursor( Qt::sizeVerCursor, true ); 00246 break; 00247 case KMDI_RESIZE_TOPLEFT: 00248 case KMDI_RESIZE_BOTTOMRIGHT: 00249 QApplication::setOverrideCursor( Qt::sizeFDiagCursor, true ); 00250 break; 00251 case KMDI_RESIZE_BOTTOMLEFT: 00252 case KMDI_RESIZE_TOPRIGHT: 00253 QApplication::setOverrideCursor( Qt::sizeBDiagCursor, true ); 00254 break; 00255 } 00256 } 00257 00258 //============= unsetResizeCursor ===============// 00259 00260 void KMdiChildFrm::unsetResizeCursor() 00261 { 00262 if ( !m_bResizing && m_iResizeCorner != KMDI_NORESIZE ) 00263 { 00264 m_iResizeCorner = KMDI_NORESIZE; 00265 m_iLastCursorCorner = KMDI_NORESIZE; 00266 if ( QApplication::overrideCursor() ) 00267 QApplication::restoreOverrideCursor(); 00268 } 00269 } 00270 00271 //============= mouseMoveEvent ===============// 00272 00273 void KMdiChildFrm::mouseMoveEvent( QMouseEvent *e ) 00274 { 00275 if ( m_state != Normal ) 00276 return; 00277 00278 if ( !m_pClient ) 00279 return; 00280 00281 if ( m_pClient->minimumSize() == m_pClient->maximumSize() ) 00282 return; 00283 00284 if ( m_bResizing ) 00285 { 00286 if ( !( e->state() & RightButton ) && !( e->state() & MidButton ) ) 00287 { 00288 // same as: if no button or left button pressed 00289 QPoint p = parentWidget()->mapFromGlobal( e->globalPos() ); 00290 resizeWindow( m_iResizeCorner, p.x(), p.y() ); 00291 } 00292 else 00293 m_bResizing = false; 00294 } 00295 else 00296 { 00297 m_iResizeCorner = getResizeCorner( e->pos().x(), e->pos().y() ); 00298 setResizeCursor( m_iResizeCorner ); 00299 } 00300 } 00301 00302 //============= moveEvent ===============// 00303 00304 void KMdiChildFrm::moveEvent( QMoveEvent* me ) 00305 { 00306 // give its child view the chance to notify a childframe move 00307 KMdiChildFrmMoveEvent cfme( me ); 00308 if ( m_pClient != 0L ) 00309 QApplication::sendEvent( m_pClient, &cfme ); 00310 } 00311 00312 //=============== leaveEvent ===============// 00313 00314 void KMdiChildFrm::leaveEvent( QEvent * ) 00315 { 00316 unsetResizeCursor(); 00317 } 00318 00319 void KMdiChildFrm::resizeWindow( int resizeCorner, int xPos, int yPos ) 00320 { 00321 QRect resizeRect( x(), y(), width(), height() ); 00322 00323 // Calculate the minimum width & height 00324 int minWidth = 0; 00325 int minHeight = 0; 00326 int maxWidth = QWIDGETSIZE_MAX; 00327 int maxHeight = QWIDGETSIZE_MAX; 00328 00329 // it could be the client forces the childframe to enlarge its minimum size 00330 if ( m_pClient ) 00331 { 00332 minWidth = m_pClient->minimumSize().width() + KMDI_CHILDFRM_DOUBLE_BORDER; 00333 minHeight = m_pClient->minimumSize().height() + KMDI_CHILDFRM_DOUBLE_BORDER + 00334 m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR; 00335 maxWidth = m_pClient->maximumSize().width() + KMDI_CHILDFRM_DOUBLE_BORDER; 00336 maxHeight = m_pClient->maximumSize().height() + KMDI_CHILDFRM_DOUBLE_BORDER + 00337 m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR; 00338 } 00339 00340 if ( minWidth < minimumWidth() ) 00341 minWidth = minimumWidth(); 00342 00343 if ( minHeight < minimumHeight() ) 00344 minHeight = minimumHeight(); 00345 00346 if ( maxWidth > maximumWidth() ) 00347 maxWidth = maximumWidth(); 00348 00349 if ( maxHeight > maximumHeight() ) 00350 maxHeight = maximumHeight(); 00351 00352 QPoint mousePos( xPos, yPos ); 00353 00354 // manipulate width 00355 switch ( resizeCorner ) 00356 { 00357 //left sides 00358 case KMDI_RESIZE_TOPLEFT: 00359 case KMDI_RESIZE_LEFT: 00360 case KMDI_RESIZE_BOTTOMLEFT: 00361 resizeRect.setLeft( mousePos.x() ); 00362 if ( resizeRect.width() < minWidth ) 00363 resizeRect.setLeft( resizeRect.right() - minWidth + 1 ); 00364 if ( resizeRect.width() > maxWidth ) 00365 resizeRect.setLeft( resizeRect.right() - maxWidth + 1 ); 00366 break; 00367 //right sides 00368 case KMDI_RESIZE_TOPRIGHT: 00369 case KMDI_RESIZE_RIGHT: 00370 case KMDI_RESIZE_BOTTOMRIGHT: 00371 resizeRect.setRight( mousePos.x() ); 00372 if ( resizeRect.width() < minWidth ) 00373 resizeRect.setRight( resizeRect.left() + minWidth - 1 ); 00374 if ( resizeRect.width() > maxWidth ) 00375 resizeRect.setRight( resizeRect.left() + maxWidth - 1 ); 00376 break; 00377 default: 00378 break; 00379 } 00380 00381 // manipulate height 00382 switch ( resizeCorner ) 00383 { 00384 case KMDI_RESIZE_TOPLEFT: 00385 case KMDI_RESIZE_TOP: 00386 case KMDI_RESIZE_TOPRIGHT: 00387 resizeRect.setTop( mousePos.y() ); 00388 if ( resizeRect.height() < minHeight ) 00389 resizeRect.setTop( resizeRect.bottom() - minHeight + 1 ); 00390 if ( resizeRect.height() > maxHeight ) 00391 resizeRect.setTop( resizeRect.bottom() - maxHeight + 1 ); 00392 break; 00393 case KMDI_RESIZE_BOTTOMLEFT: 00394 case KMDI_RESIZE_BOTTOM: 00395 case KMDI_RESIZE_BOTTOMRIGHT: 00396 resizeRect.setBottom( mousePos.y() ); 00397 if ( resizeRect.height() < minHeight ) 00398 resizeRect.setBottom( resizeRect.top() + minHeight - 1 ); 00399 if ( resizeRect.height() > maxHeight ) 00400 resizeRect.setBottom( resizeRect.top() + maxHeight - 1 ); 00401 break; 00402 default: 00403 // nothing to do 00404 break; 00405 } 00406 // actually resize 00407 setGeometry( resizeRect ); 00408 00409 if ( m_state == Maximized ) 00410 { 00411 m_state = Normal; 00412 m_pMaximize->setPixmap( *m_pMaxButtonPixmap ); 00413 } 00414 } 00415 00416 //================= getResizeCorner =============// 00417 00418 int KMdiChildFrm::getResizeCorner( int ax, int ay ) 00419 { 00420 int ret = KMDI_NORESIZE; 00421 if ( m_pClient->minimumWidth() != m_pClient->maximumWidth() ) 00422 { 00423 if ( ( ax > 0 ) && ( ax < ( KMDI_CHILDFRM_BORDER + 2 ) ) ) 00424 ret |= KMDI_RESIZE_LEFT; 00425 00426 if ( ( ax < width() ) && ( ax > ( width() - ( KMDI_CHILDFRM_BORDER + 2 ) ) ) ) 00427 ret |= KMDI_RESIZE_RIGHT; 00428 } 00429 if ( m_pClient->minimumHeight() != m_pClient->maximumHeight() ) 00430 { 00431 if ( ( ay > 0 ) && ( ay < ( KMDI_CHILDFRM_BORDER + 2 ) ) ) 00432 ret |= KMDI_RESIZE_TOP; 00433 00434 if ( ( ay < ( height() ) ) && ( ay > ( height() - ( KMDI_CHILDFRM_BORDER + 2 ) ) ) ) 00435 ret |= KMDI_RESIZE_BOTTOM; 00436 } 00437 return ret; 00438 } 00439 00440 //============= maximizePressed ============// 00441 00442 void KMdiChildFrm::maximizePressed() 00443 { 00444 switch ( m_state ) 00445 { 00446 case Maximized: 00447 emit m_pManager->nowMaximized( false ); 00448 setState( Normal ); 00449 break; 00450 case Normal: 00451 case Minimized: 00452 setState( Maximized ); 00453 emit m_pManager->nowMaximized( true ); 00454 break; 00455 } 00456 } 00457 00458 void KMdiChildFrm::restorePressed() 00459 { 00460 if ( m_state == Normal ) 00461 return ; 00462 00463 if ( m_state == Maximized ) 00464 emit m_pManager->nowMaximized( false ); 00465 00466 setState( Normal ); 00467 } 00468 00469 //============= minimizePressed ============// 00470 00471 void KMdiChildFrm::minimizePressed() 00472 { 00473 switch ( m_state ) 00474 { 00475 case Minimized: 00476 setState( Normal ); 00477 break; 00478 case Normal: 00479 setState( Minimized ); 00480 break; 00481 case Maximized: 00482 emit m_pManager->nowMaximized( false ); 00483 setState( Normal ); 00484 setState( Minimized ); 00485 break; 00486 } 00487 } 00488 00489 //============= closePressed ============// 00490 00491 void KMdiChildFrm::closePressed() 00492 { 00493 if ( m_pClient ) 00494 m_pClient->close(); 00495 } 00496 00497 //============= undockPressed ============// 00498 00499 void KMdiChildFrm::undockPressed() 00500 { 00501 if ( m_pClient ) 00502 { 00503 if ( m_state == Minimized ) 00504 setState( Normal ); 00505 m_pClient->detach(); 00506 } 00507 } 00508 00509 //============ setState =================// 00510 00511 void KMdiChildFrm::setState( MdiWindowState state, bool /*bAnimate*/ ) 00512 { 00513 if ( m_state == Normal ) //save the current rect 00514 m_restoredRect = QRect( x(), y(), width(), height() ); 00515 00516 switch ( state ) 00517 { 00518 case Normal: 00519 switch ( m_state ) 00520 { 00521 case Maximized: 00522 m_pClient->m_stateChanged = true; 00523 m_state = state; 00524 // client min / max size / layout behavior don't change 00525 // set frame max size indirectly by setting the clients max size to 00526 // it's current value (calls setMaxSize() of frame) 00527 m_pClient->setMaximumSize( m_pClient->maximumSize().width(), m_pClient->maximumSize().height() ); 00528 m_pMaximize->setPixmap( *m_pMaxButtonPixmap ); 00529 setGeometry( m_restoredRect ); 00530 break; 00531 case Minimized: 00532 m_pClient->m_stateChanged = true; 00533 m_state = state; 00534 // restore client min / max size / layout behavior 00535 m_pClient->setMinimumSize( m_oldClientMinSize.width(), m_oldClientMinSize.height() ); 00536 m_pClient->setMaximumSize( m_oldClientMaxSize.width(), m_oldClientMaxSize.height() ); 00537 if ( m_pClient->layout() != 0L ) 00538 { 00539 m_pClient->layout() ->setResizeMode( m_oldLayoutResizeMode ); 00540 } 00541 m_pMinimize->setPixmap( *m_pMinButtonPixmap ); 00542 m_pMaximize->setPixmap( *m_pMaxButtonPixmap ); 00543 QObject::disconnect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( restorePressed() ) ); 00544 QObject::connect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( minimizePressed() ) ); 00545 setGeometry( m_restoredRect ); 00546 break; 00547 case Normal: 00548 break; 00549 } 00550 break; 00551 case Maximized: 00552 switch ( m_state ) 00553 { 00554 case Minimized: 00555 { 00556 m_pClient->m_stateChanged = true; 00557 m_state = state; 00558 // restore client min / max size / layout behavior 00559 m_pClient->setMinimumSize( m_oldClientMinSize.width(), m_oldClientMinSize.height() ); 00560 m_pClient->setMaximumSize( m_oldClientMaxSize.width(), m_oldClientMaxSize.height() ); 00561 if ( m_pClient->layout() != 0L ) 00562 { 00563 m_pClient->layout() ->setResizeMode( m_oldLayoutResizeMode ); 00564 } 00565 setMaximumSize( QWIDGETSIZE_MAX, QWIDGETSIZE_MAX ); 00566 // reset to maximize-captionbar 00567 m_pMaximize->setPixmap( *m_pRestoreButtonPixmap ); 00568 m_pMinimize->setPixmap( *m_pMinButtonPixmap ); 00569 QObject::disconnect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( restorePressed() ) ); 00570 QObject::connect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( minimizePressed() ) ); 00571 int nFrameWidth = KMDI_CHILDFRM_DOUBLE_BORDER; 00572 int nFrameHeight = KMDI_CHILDFRM_DOUBLE_BORDER + KMDI_CHILDFRM_SEPARATOR + 00573 m_pCaption->heightHint(); 00574 setGeometry( -m_pClient->x(), -m_pClient->y(), 00575 m_pManager->width() + nFrameWidth, 00576 m_pManager->height() + nFrameHeight ); 00577 raise(); 00578 } 00579 break; 00580 case Normal: 00581 { 00582 m_pClient->m_stateChanged = true; 00583 m_state = state; 00584 // client min / max size / layout behavior don't change 00585 setMaximumSize( QWIDGETSIZE_MAX, QWIDGETSIZE_MAX ); 00586 m_pMaximize->setPixmap( *m_pRestoreButtonPixmap ); 00587 int nFrameWidth = KMDI_CHILDFRM_DOUBLE_BORDER; 00588 int nFrameHeight = KMDI_CHILDFRM_DOUBLE_BORDER + KMDI_CHILDFRM_SEPARATOR + 00589 m_pCaption->heightHint(); 00590 QRect maximizedFrmRect( -m_pClient->x(), -m_pClient->y(), 00591 m_pManager->width() + nFrameWidth, 00592 m_pManager->height() + nFrameHeight ); 00593 if ( geometry() != maximizedFrmRect ) 00594 { 00595 setGeometry( maximizedFrmRect ); 00596 } 00597 raise(); 00598 } 00599 break; 00600 case Maximized: 00601 break; 00602 } 00603 break; 00604 case Minimized: 00605 switch ( m_state ) 00606 { 00607 case Maximized: 00608 m_pClient->m_stateChanged = true; 00609 m_state = state; 00610 // save client min / max size / layout behavior 00611 m_oldClientMinSize = m_pClient->minimumSize(); 00612 m_oldClientMaxSize = m_pClient->maximumSize(); 00613 if ( m_pClient->layout() != 0L ) 00614 { 00615 m_oldLayoutResizeMode = m_pClient->layout() ->resizeMode(); 00616 } 00617 m_pClient->setMinimumSize( 0, 0 ); 00618 m_pClient->setMaximumSize( 0, 0 ); 00619 if ( m_pClient->layout() != 0L ) 00620 { 00621 m_pClient->layout() ->setResizeMode( QLayout::FreeResize ); 00622 } 00623 switchToMinimizeLayout(); 00624 m_pManager->childMinimized( this, true ); 00625 break; 00626 case Normal: 00627 m_pClient->m_stateChanged = true; 00628 m_state = state; 00629 // save client min / max size / layout behavior 00630 m_oldClientMinSize = m_pClient->minimumSize(); 00631 m_oldClientMaxSize = m_pClient->maximumSize(); 00632 if ( m_pClient->layout() != 0L ) 00633 { 00634 m_oldLayoutResizeMode = m_pClient->layout() ->resizeMode(); 00635 } 00636 m_restoredRect = geometry(); 00637 m_pClient->setMinimumSize( 0, 0 ); 00638 m_pClient->setMaximumSize( 0, 0 ); 00639 if ( m_pClient->layout() != 0L ) 00640 { 00641 m_pClient->layout() ->setResizeMode( QLayout::FreeResize ); 00642 } 00643 switchToMinimizeLayout(); 00644 m_pManager->childMinimized( this, false ); 00645 break; 00646 case Minimized: 00647 break; 00648 } 00649 break; 00650 } 00651 00652 KMdiChildFrm* pTopFrame = m_pManager->topChild(); 00653 KMdiChildView* pTopChild = 0L; 00654 if ( pTopFrame != 0L ) 00655 { 00656 pTopChild = pTopFrame->m_pClient; 00657 } 00658 if ( ( pTopChild != 0L ) && pTopChild->isMaximized() ) 00659 { 00660 m_pManager->setMinimumSize( pTopChild->minimumWidth(), pTopChild->minimumHeight() ); 00663 } 00664 else 00665 { 00666 m_pManager->setMinimumSize( 0, 0 ); 00667 m_pManager->setMaximumSize( QWIDGETSIZE_MAX, QWIDGETSIZE_MAX ); 00668 } 00669 } 00670 00671 //============== restoreGeometry ================// 00672 00673 QRect KMdiChildFrm::restoreGeometry() const 00674 { 00675 return m_restoredRect; 00676 } 00677 00678 //============== setRestoreGeometry ================// 00679 00680 void KMdiChildFrm::setRestoreGeometry( const QRect& newRestGeo ) 00681 { 00682 m_restoredRect = newRestGeo; 00683 } 00684 00685 //============ setCaption ===============// 00686 00687 void KMdiChildFrm::setCaption( const QString& text ) 00688 { 00689 m_pCaption->setCaption( text ); 00690 } 00691 00692 //============ enableClose ==============// 00693 00694 void KMdiChildFrm::enableClose( bool bEnable ) 00695 { 00696 m_pClose->setEnabled( bEnable ); 00697 m_pClose->repaint( false ); 00698 } 00699 00700 //============ setIcon ==================// 00701 00702 void KMdiChildFrm::setIcon( const QPixmap& pxm ) 00703 { 00704 QPixmap p = pxm; 00705 if ( p.width() != 18 || p.height() != 18 ) 00706 { 00707 QImage img = p.convertToImage(); 00708 p = img.smoothScale( 18, 18, QImage::ScaleMin ); 00709 } 00710 const bool do_resize = m_pIconButtonPixmap->size() != p.size(); 00711 *m_pIconButtonPixmap = p; 00712 m_pWinIcon->setPixmap( p ); 00713 m_pUnixIcon->setPixmap( p ); 00714 if ( do_resize ) 00715 doResize( true ); 00716 } 00717 00718 //============ icon =================// 00719 00720 QPixmap* KMdiChildFrm::icon() const 00721 { 00722 return m_pIconButtonPixmap; 00723 } 00724 00725 //============ setClient ============// 00726 void KMdiChildFrm::setClient( KMdiChildView *w, bool bAutomaticResize ) 00727 { 00728 m_pClient = w; 00729 00730 if ( w->icon() ) 00731 setIcon( *( w->icon() ) ); 00732 00733 //resize to match the client 00734 int clientYPos = m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_BORDER; 00735 if ( bAutomaticResize || w->size().isEmpty() || ( w->size() == QSize( 1, 1 ) ) ) 00736 { 00737 if ( m_pManager->topChild() ) 00738 { 00739 resize( m_pManager->topChild() ->size() ); 00740 } 00741 else 00742 { 00743 resize( m_pManager->m_defaultChildFrmSize.width() + KMDI_CHILDFRM_DOUBLE_BORDER, 00744 m_pManager->m_defaultChildFrmSize.height() + KMDI_CHILDFRM_BORDER + clientYPos ); 00745 } 00746 } 00747 else 00748 { 00749 resize( w->width() + KMDI_CHILDFRM_DOUBLE_BORDER, w->height() + KMDI_CHILDFRM_BORDER + clientYPos ); 00750 } 00751 00752 // memorize the focuses in a dictionary because they will get lost during reparenting 00753 QDict<FocusPolicy>* pFocPolDict = new QDict<FocusPolicy>; 00754 pFocPolDict->setAutoDelete( true ); 00755 QObjectList *list = m_pClient->queryList( "QWidget" ); 00756 QObjectListIt it( *list ); // iterate over the buttons 00757 QObject * obj; 00758 int i = 1; 00759 while ( ( obj = it.current() ) != 0 ) 00760 { // for each found object... 00761 ++it; 00762 QWidget* widg = ( QWidget* ) obj; 00763 if ( widg->name( 0 ) == 0 ) 00764 { 00765 QString tmpStr; 00766 tmpStr.setNum( i ); 00767 tmpStr = "unnamed" + tmpStr; 00768 widg->setName( tmpStr.latin1() ); 00769 i++; 00770 } 00771 FocusPolicy* pFocPol = new FocusPolicy; 00772 *pFocPol = widg->focusPolicy(); 00773 pFocPolDict->insert( widg->name(), pFocPol ); 00774 } 00775 delete list; // delete the list, not the objects 00776 00777 //Reparent if needed 00778 if ( w->parent() != this ) 00779 { 00780 //reparent to this widget , no flags , point , show it 00781 QPoint pnt2( KMDI_CHILDFRM_BORDER, clientYPos ); 00782 QSize mincs = w->minimumSize(); 00783 QSize maxcs = w->maximumSize(); 00784 w->setMinimumSize( 0, 0 ); 00785 w->setMaximumSize( QWIDGETSIZE_MAX, QWIDGETSIZE_MAX ); 00786 00787 // min/max sizes, flags, DND get lost. :-( 00788 w->reparent( this, 0, pnt2, w->isVisible() ); 00789 00790 w->setMinimumSize( mincs.width(), mincs.height() ); 00791 w->setMaximumSize( maxcs.width(), maxcs.height() ); 00792 } 00793 else 00794 w->move( KMDI_CHILDFRM_BORDER, clientYPos ); 00795 00796 linkChildren( pFocPolDict ); 00797 00798 QObject::connect( m_pClient, SIGNAL( mdiParentNowMaximized( bool ) ), m_pManager, SIGNAL( nowMaximized( bool ) ) ); 00799 00800 if ( m_pClient->minimumWidth() > m_pManager->m_defaultChildFrmSize.width() ) 00801 setMinimumWidth( m_pClient->minimumSize().width() + KMDI_CHILDFRM_DOUBLE_BORDER ); 00802 00803 if ( m_pClient->minimumHeight() > m_pManager->m_defaultChildFrmSize.height() ) 00804 { 00805 setMinimumHeight( m_pClient->minimumSize().height() + KMDI_CHILDFRM_DOUBLE_BORDER + 00806 m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR ); 00807 } 00808 } 00809 00810 //============ unsetClient ============// 00811 00812 void KMdiChildFrm::unsetClient( QPoint positionOffset ) 00813 { 00814 if ( !m_pClient ) 00815 return ; 00816 00817 QObject::disconnect( m_pClient, SIGNAL( mdiParentNowMaximized( bool ) ), m_pManager, SIGNAL( nowMaximized( bool ) ) ); 00818 00819 //reparent to desktop widget , no flags , point , show it 00820 QDict<FocusPolicy>* pFocPolDict; 00821 pFocPolDict = unlinkChildren(); 00822 00823 // get name of focused child widget 00824 QWidget* focusedChildWidget = m_pClient->focusedChildWidget(); 00825 const char* nameOfFocusedWidget = ""; 00826 if ( focusedChildWidget != 0 ) 00827 nameOfFocusedWidget = focusedChildWidget->name(); 00828 00829 QSize mins = m_pClient->minimumSize(); 00830 QSize maxs = m_pClient->maximumSize(); 00831 m_pClient->reparent( 0, 0, mapToGlobal( pos() ) - pos() + positionOffset, isVisible() ); 00832 m_pClient->setMinimumSize( mins.width(), mins.height() ); 00833 m_pClient->setMaximumSize( maxs.width(), maxs.height() ); 00834 00835 // remember the focus policies using the dictionary and reset them 00836 QObjectList *list = m_pClient->queryList( "QWidget" ); 00837 QObjectListIt it( *list ); // iterate over all child widgets of child frame 00838 QObject * obj; 00839 QWidget* firstFocusableChildWidget = 0; 00840 QWidget* lastFocusableChildWidget = 0; 00841 while ( ( obj = it.current() ) != 0 ) 00842 { // for each found object... 00843 QWidget * widg = ( QWidget* ) obj; 00844 ++it; 00845 FocusPolicy* pFocPol = pFocPolDict->find( widg->name() ); // remember the focus policy from before the reparent 00846 if ( pFocPol ) 00847 widg->setFocusPolicy( *pFocPol ); 00848 00849 // reset focus to old position (doesn't work :-( for its own unexplicable reasons) 00850 if ( widg->name() == nameOfFocusedWidget ) 00851 widg->setFocus(); 00852 00853 // get first and last focusable widget 00854 if ( ( widg->focusPolicy() == QWidget::StrongFocus ) || ( widg->focusPolicy() == QWidget::TabFocus ) ) 00855 { 00856 if ( firstFocusableChildWidget == 0 ) 00857 firstFocusableChildWidget = widg; // first widget 00858 lastFocusableChildWidget = widg; // last widget 00859 00860 } 00861 else 00862 { 00863 if ( widg->focusPolicy() == QWidget::WheelFocus ) 00864 { 00865 if ( firstFocusableChildWidget == 0 ) 00866 firstFocusableChildWidget = widg; // first widget 00867 lastFocusableChildWidget = widg; // last widget 00868 //qDebug("*** %s (%s)",widg->name(),widg->className()); 00869 } 00870 } 00871 } 00872 delete list; // delete the list, not the objects 00873 delete pFocPolDict; 00874 00875 // reset first and last focusable widget 00876 m_pClient->setFirstFocusableChildWidget( firstFocusableChildWidget ); 00877 m_pClient->setLastFocusableChildWidget( lastFocusableChildWidget ); 00878 00879 // reset the focus policy of the view 00880 m_pClient->setFocusPolicy( QWidget::ClickFocus ); 00881 00882 // lose information about the view (because it's undocked now) 00883 m_pClient = 0; 00884 } 00885 00886 //============== linkChildren =============// 00887 void KMdiChildFrm::linkChildren( QDict<FocusPolicy>* pFocPolDict ) 00888 { 00889 // reset the focus policies for all widgets in the view (take them from the dictionary) 00890 QObjectList* list = m_pClient->queryList( "QWidget" ); 00891 QObjectListIt it( *list ); // iterate over all child widgets of child frame 00892 QObject* obj; 00893 while ( ( obj = it.current() ) != 0 ) 00894 { // for each found object... 00895 QWidget* widg = ( QWidget* ) obj; 00896 ++it; 00897 FocusPolicy* pFocPol = pFocPolDict->find( widg->name() ); // remember the focus policy from before the reparent 00898 00899 if ( pFocPol != 0 ) 00900 widg->setFocusPolicy( *pFocPol ); 00901 00902 if ( !( widg->inherits( "QPopupMenu" ) ) ) 00903 widg->installEventFilter( this ); 00904 00905 } 00906 delete list; // delete the list, not the objects 00907 delete pFocPolDict; 00908 00909 // reset the focus policies for the rest 00910 m_pWinIcon->setFocusPolicy( QWidget::NoFocus ); 00911 m_pUnixIcon->setFocusPolicy( QWidget::NoFocus ); 00912 m_pClient->setFocusPolicy( QWidget::ClickFocus ); 00913 m_pCaption->setFocusPolicy( QWidget::NoFocus ); 00914 m_pUndock->setFocusPolicy( QWidget::NoFocus ); 00915 m_pMinimize->setFocusPolicy( QWidget::NoFocus ); 00916 m_pMaximize->setFocusPolicy( QWidget::NoFocus ); 00917 m_pClose->setFocusPolicy( QWidget::NoFocus ); 00918 00919 // install the event filter (catch mouse clicks) for the rest 00920 m_pWinIcon->installEventFilter( this ); 00921 m_pUnixIcon->installEventFilter( this ); 00922 m_pCaption->installEventFilter( this ); 00923 m_pUndock->installEventFilter( this ); 00924 m_pMinimize->installEventFilter( this ); 00925 m_pMaximize->installEventFilter( this ); 00926 m_pClose->installEventFilter( this ); 00927 m_pClient->installEventFilter( this ); 00928 // m_pClient->installEventFilterForAllChildren(); 00929 } 00930 00931 //============== unlinkChildren =============// 00932 00933 QDict<QWidget::FocusPolicy>* KMdiChildFrm::unlinkChildren() 00934 { 00935 // memorize the focuses in a dictionary because they will get lost during reparenting 00936 QDict<FocusPolicy>* pFocPolDict = new QDict<FocusPolicy>; 00937 pFocPolDict->setAutoDelete( true ); 00938 00939 QObjectList *list = m_pClient->queryList( "QWidget" ); 00940 QObjectListIt it( *list ); // iterate over all child widgets of child frame 00941 QObject * obj; 00942 int i = 1; 00943 while ( ( obj = it.current() ) != 0 ) 00944 { // for each found object... 00945 ++it; 00946 QWidget* w = ( QWidget* ) obj; 00947 // get current widget object name 00948 if ( w->name( 0 ) == 0 ) 00949 { 00950 QString tmpStr; 00951 tmpStr.setNum( i ); 00952 tmpStr = "unnamed" + tmpStr; 00953 w->setName( tmpStr.latin1() ); 00954 i++; 00955 } 00956 FocusPolicy* pFocPol = new FocusPolicy; 00957 *pFocPol = w->focusPolicy(); 00958 // memorize focus policy 00959 pFocPolDict->insert( w->name(), pFocPol ); 00960 // remove event filter 00961 ( ( QWidget* ) obj ) ->removeEventFilter( this ); 00962 } 00963 delete list; // delete the list, not the objects 00964 00965 // remove the event filter (catch mouse clicks) for the rest 00966 m_pWinIcon->removeEventFilter( this ); 00967 m_pUnixIcon->removeEventFilter( this ); 00968 m_pCaption->removeEventFilter( this ); 00969 m_pUndock->removeEventFilter( this ); 00970 m_pMinimize->removeEventFilter( this ); 00971 m_pMaximize->removeEventFilter( this ); 00972 m_pClose->removeEventFilter( this ); 00973 m_pClient->removeEventFilter( this ); 00974 00975 //SCHEDULED_FOR_REMOVE m_pClient->removeEventFilterForAllChildren(); 00976 00977 return pFocPolDict; 00978 } 00979 00980 //============== resizeEvent ===============// 00981 00982 void KMdiChildFrm::resizeEvent( QResizeEvent * ) 00983 { 00984 doResize(); // an extra method because it can also called directly 00985 } 00986 00987 void KMdiChildFrm::doResize() 00988 { 00989 doResize( false ); 00990 } 00991 00992 void KMdiChildFrm::doResize( bool captionOnly ) 00993 { 00994 //Resize the caption 00995 int captionHeight = m_pCaption->heightHint(); 00996 int captionWidth = width() - KMDI_CHILDFRM_DOUBLE_BORDER; 00997 int buttonHeight = m_pClose->pixmap() ->height(); 00998 int buttonWidth = m_pClose->pixmap() ->width(); 00999 int heightOffset = captionHeight / 2 - buttonHeight / 2; 01000 int rightOffset1 = 1; 01001 int rightOffset2 = 1; 01002 int frmIconHeight = m_pWinIcon->pixmap() ->height(); 01003 int frmIconWidth = m_pWinIcon->pixmap() ->width(); 01004 int frmIconOffset = 1; 01005 QWidget* pIconWidget = m_pWinIcon; 01006 m_pCaption->setGeometry( KMDI_CHILDFRM_BORDER, KMDI_CHILDFRM_BORDER, captionWidth, captionHeight ); 01007 01008 //The buttons are caption children 01009 if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::Win95Look ) 01010 { 01011 rightOffset2 += 2; 01012 m_pUnixIcon->hide(); 01013 } 01014 else if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDE1Look ) 01015 { 01016 buttonWidth += 4; 01017 buttonHeight += 4; 01018 heightOffset -= 2; 01019 rightOffset1 = 0; 01020 rightOffset2 = 0; 01021 m_pWinIcon->hide(); 01022 frmIconHeight = buttonHeight; 01023 frmIconWidth = buttonWidth; 01024 frmIconOffset = 0; 01025 pIconWidget = m_pUnixIcon; 01026 } 01027 else if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDELook ) 01028 { 01029 buttonWidth += 3; 01030 buttonHeight += 3; 01031 heightOffset -= 1; 01032 m_pUnixIcon->hide(); 01033 } 01034 if ( KMdiMainFrm::frameDecorOfAttachedViews() != KMdi::KDELaptopLook ) 01035 { 01036 pIconWidget->setGeometry( frmIconOffset, captionHeight / 2 - frmIconHeight / 2, frmIconWidth, frmIconHeight ); 01037 m_pClose->setGeometry( ( captionWidth - buttonWidth ) - rightOffset1, heightOffset, buttonWidth, buttonHeight ); 01038 m_pMaximize->setGeometry( ( captionWidth - ( buttonWidth * 2 ) ) - rightOffset2, heightOffset, buttonWidth, buttonHeight ); 01039 m_pMinimize->setGeometry( ( captionWidth - ( buttonWidth * 3 ) ) - rightOffset2, heightOffset, buttonWidth, buttonHeight ); 01040 m_pUndock->setGeometry( ( captionWidth - ( buttonWidth * 4 ) ) - rightOffset2, heightOffset, buttonWidth, buttonHeight ); 01041 } 01042 else 01043 { // KDELaptopLook 01044 m_pWinIcon->hide(); 01045 m_pUnixIcon->hide(); 01046 buttonHeight += 5; 01047 heightOffset -= 2; 01048 m_pClose->setGeometry ( 0, heightOffset, 27, buttonHeight ); 01049 m_pMaximize->setGeometry( captionWidth - 27, heightOffset, 27, buttonHeight ); 01050 m_pMinimize->setGeometry( captionWidth - 27 * 2, heightOffset, 27, buttonHeight ); 01051 m_pUndock->setGeometry ( captionWidth - 27 * 3, heightOffset, 27, buttonHeight ); 01052 } 01053 01054 //Resize the client 01055 if ( !captionOnly && m_pClient ) 01056 { 01057 QSize newClientSize( captionWidth, 01058 height() - ( KMDI_CHILDFRM_DOUBLE_BORDER + captionHeight + KMDI_CHILDFRM_SEPARATOR ) ); 01059 if ( newClientSize != m_pClient->size() ) 01060 { 01061 m_pClient->setGeometry( KMDI_CHILDFRM_BORDER, 01062 m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_BORDER, 01063 newClientSize.width(), newClientSize.height() ); 01064 } 01065 } 01066 } 01067 01068 static bool hasParent( QObject* par, QObject* o ) 01069 { 01070 while ( o && o != par ) 01071 o = o->parent(); 01072 return o == par; 01073 } 01074 01075 //============= eventFilter ===============// 01076 01077 bool KMdiChildFrm::eventFilter( QObject *obj, QEvent *e ) 01078 { 01079 switch ( e->type() ) 01080 { 01081 case QEvent::Enter: 01082 { 01083 // check if the receiver is really a child of this frame 01084 bool bIsChild = false; 01085 QObject* pObj = obj; 01086 while ( ( pObj != 0L ) && !bIsChild ) 01087 { 01088 bIsChild = ( pObj == this ); 01089 pObj = pObj->parent(); 01090 } 01091 // unset the resize cursor if the cursor moved from the frame into a inner widget 01092 if ( bIsChild ) 01093 unsetResizeCursor(); 01094 } 01095 break; 01096 case QEvent::MouseButtonPress: 01097 { 01098 if ( !hasParent( m_pClient, obj ) ) 01099 { 01100 bool bIsSecondClick = false; 01101 if ( m_timeMeasure.elapsed() <= QApplication::doubleClickInterval() ) 01102 bIsSecondClick = true; // of a possible double click 01103 01104 if ( !( ( ( obj == m_pWinIcon ) || ( obj == m_pUnixIcon ) ) && bIsSecondClick ) ) 01105 { 01106 // in case we didn't click on the icon button 01107 QFocusEvent* pFE = new QFocusEvent( QFocusEvent::FocusIn ); 01108 QApplication::sendEvent( qApp->mainWidget(), pFE ); 01109 if ( m_pClient ) 01110 { 01111 m_pClient->updateTimeStamp(); 01112 m_pClient->activate(); 01113 } 01114 01115 if ( ( obj->parent() != m_pCaption ) && ( obj != m_pCaption ) ) 01116 { 01117 QWidget* w = ( QWidget* ) obj; 01118 if ( ( w->focusPolicy() == QWidget::ClickFocus ) || ( w->focusPolicy() == QWidget::StrongFocus ) ) 01119 { 01120 w->setFocus(); 01121 } 01122 } 01123 } 01124 if ( ( obj == m_pWinIcon ) || ( obj == m_pUnixIcon ) ) 01125 { 01126 // in case we clicked on the icon button 01127 if ( m_timeMeasure.elapsed() > QApplication::doubleClickInterval() ) 01128 { 01129 showSystemMenu(); 01130 m_timeMeasure.start(); 01131 } 01132 else 01133 closePressed(); // double click on icon button closes the view 01134 01135 return true; 01136 } 01137 } 01138 } 01139 break; 01140 case QEvent::Resize: 01141 { 01142 if ( ( ( QWidget* ) obj == m_pClient ) && ( m_state == Normal ) ) 01143 { 01144 QResizeEvent* re = ( QResizeEvent* ) e; 01145 int captionHeight = m_pCaption->heightHint(); 01146 QSize newChildFrmSize( re->size().width() + KMDI_CHILDFRM_DOUBLE_BORDER, 01147 re->size().height() + captionHeight + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER ); 01148 if ( newChildFrmSize != size() ) 01149 resize( newChildFrmSize ); 01150 } 01151 } 01152 break; 01153 case QEvent::ChildRemoved: 01154 { 01155 // if we lost a child we uninstall ourself as event filter for the lost 01156 // child and its children 01157 QObject* pLostChild = ( ( QChildEvent* ) e )->child(); 01158 if ( ( pLostChild != 0L ) /*&& (pLostChild->inherits("QWidget"))*/ ) 01159 { 01160 QObjectList* list = pLostChild->queryList(); 01161 list->insert( 0, pLostChild ); // add the lost child to the list too, just to save code 01162 QObjectListIt it( *list ); // iterate over all lost child widgets 01163 QObject* obj; 01164 while ( ( obj = it.current() ) != 0 ) 01165 { // for each found object... 01166 QWidget* widg = ( QWidget* ) obj; 01167 ++it; 01168 widg->removeEventFilter( this ); 01169 } 01170 delete list; // delete the list, not the objects 01171 } 01172 } 01173 break; 01174 case QEvent::ChildInserted: 01175 { 01176 // if we got a new child we install ourself as event filter for the new 01177 // child and its children (as we did when we got our client). 01178 // XXX see linkChildren() and focus policy stuff 01179 QObject* pNewChild = ( ( QChildEvent* ) e ) ->child(); 01180 if ( ( pNewChild != 0L ) && ::qt_cast<QWidget*>( pNewChild ) ) 01181 { 01182 QWidget * pNewWidget = static_cast<QWidget*>( pNewChild ); 01183 QObjectList *list = pNewWidget->queryList( "QWidget" ); 01184 list->insert( 0, pNewChild ); // add the new child to the list too, just to save code 01185 QObjectListIt it( *list ); // iterate over all new child widgets 01186 QObject * obj; 01187 while ( ( obj = it.current() ) != 0 ) 01188 { // for each found object... 01189 QWidget * widg = ( QWidget* ) obj; 01190 ++it; 01191 if ( !::qt_cast<QPopupMenu*>( widg ) ) 01192 { 01193 widg->installEventFilter( this ); 01194 } 01195 } 01196 delete list; // delete the list, not the objects 01197 } 01198 } 01199 break; 01200 default: 01201 break; 01202 } 01203 01204 return false; // standard event processing (see Qt documentation) 01205 } 01206 01207 //============= raiseAndActivate ===============// 01208 01209 void KMdiChildFrm::raiseAndActivate() 01210 { 01211 m_pCaption->setActive( true ); 01212 m_pManager->setTopChild( this, false ); //Do not focus by now... 01213 } 01214 01215 //============= setMinimumSize ===============// 01216 01217 void KMdiChildFrm::setMinimumSize ( int minw, int minh ) 01218 { 01219 QWidget::setMinimumSize( minw, minh ); 01220 if ( m_state == Maximized ) 01221 { 01222 m_pManager->setMinimumSize( minw, minh ); 01223 } 01224 } 01225 01226 //============= systemMenu ===============// 01227 01228 QPopupMenu* KMdiChildFrm::systemMenu() const 01229 { 01230 if ( m_pSystemMenu == 0 ) 01231 return 0; 01232 01233 m_pSystemMenu->clear(); 01234 01235 if ( KMdiMainFrm::frameDecorOfAttachedViews() != KMdi::Win95Look ) 01236 { 01237 m_pSystemMenu->insertItem( i18n( "&Restore" ), this, SLOT( restorePressed() ) ); 01238 m_pSystemMenu->insertItem( i18n( "&Move" ), m_pCaption, SLOT( slot_moveViaSystemMenu() ) ); 01239 m_pSystemMenu->insertItem( i18n( "R&esize" ), this, SLOT( slot_resizeViaSystemMenu() ) ); 01240 m_pSystemMenu->insertItem( i18n( "M&inimize" ), this, SLOT( minimizePressed() ) ); 01241 m_pSystemMenu->insertItem( i18n( "M&aximize" ), this, SLOT( maximizePressed() ) ); 01242 if ( state() == Normal ) 01243 m_pSystemMenu->setItemEnabled( m_pSystemMenu->idAt( 0 ), false ); 01244 else if ( state() == Maximized ) 01245 { 01246 m_pSystemMenu->setItemEnabled( m_pSystemMenu->idAt( 1 ), false ); 01247 m_pSystemMenu->setItemEnabled( m_pSystemMenu->idAt( 2 ), false ); 01248 m_pSystemMenu->setItemEnabled( m_pSystemMenu->idAt( 4 ), false ); 01249 } 01250 else if ( state() == Minimized ) 01251 { 01252 m_pSystemMenu->setItemEnabled( m_pSystemMenu->idAt( 2 ), false ); 01253 m_pSystemMenu->setItemEnabled( m_pSystemMenu->idAt( 3 ), false ); 01254 } 01255 } 01256 else 01257 { 01258 if ( state() != Normal ) 01259 m_pSystemMenu->insertItem( i18n( "&Restore" ), this, SLOT( restorePressed() ) ); 01260 if ( state() != Maximized ) 01261 m_pSystemMenu->insertItem( i18n( "&Maximize" ), this, SLOT( maximizePressed() ) ); 01262 if ( state() != Minimized ) 01263 m_pSystemMenu->insertItem( i18n( "&Minimize" ), this, SLOT( minimizePressed() ) ); 01264 if ( state() != Maximized ) 01265 m_pSystemMenu->insertItem( i18n( "M&ove" ), m_pCaption, SLOT( slot_moveViaSystemMenu() ) ); 01266 if ( state() == Normal ) 01267 m_pSystemMenu->insertItem( i18n( "&Resize" ), this, SLOT( slot_resizeViaSystemMenu() ) ); 01268 } 01269 01270 m_pSystemMenu->insertItem( i18n( "&Undock" ), this, SLOT( undockPressed() ) ); 01271 m_pSystemMenu->insertSeparator(); 01272 m_pSystemMenu->insertItem( i18n( "&Close" ), this, SLOT( closePressed() ) ); 01273 01274 return m_pSystemMenu; 01275 } 01276 01278 void KMdiChildFrm::showSystemMenu() 01279 { 01280 if ( KMdiMainFrm::frameDecorOfAttachedViews() != KMdi::Win95Look ) 01281 m_pUnixIcon->setDown( false ); 01282 01283 QPoint popupmenuPosition; 01284 01285 QRect iconGeom; 01286 if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::Win95Look ) 01287 iconGeom = m_pWinIcon->geometry(); 01288 else 01289 iconGeom = m_pUnixIcon->geometry(); 01290 01291 popupmenuPosition = QPoint( iconGeom.x(), iconGeom.y() + captionHeight() + KMDI_CHILDFRM_BORDER ); 01292 systemMenu() ->popup( mapToGlobal( popupmenuPosition ) ); 01293 } 01294 01295 void KMdiChildFrm::switchToMinimizeLayout() 01296 { 01297 setMinimumWidth( KMDI_CHILDFRM_MIN_WIDTH ); 01298 setFixedHeight( m_pCaption->height() + KMDI_CHILDFRM_DOUBLE_BORDER ); 01299 01300 m_pMaximize->setPixmap( *m_pMaxButtonPixmap ); 01301 01302 // temporary use of minimize button for restore function 01303 m_pMinimize->setPixmap( *m_pRestoreButtonPixmap ); 01304 QObject::disconnect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( minimizePressed() ) ); 01305 QObject::connect( m_pMinimize, SIGNAL( clicked() ), this, SLOT( restorePressed() ) ); 01306 01307 // resizing 01308 resize( 300, minimumHeight() ); 01309 01310 // positioning 01311 m_pManager->layoutMinimizedChildren(); 01312 } 01313 01314 void KMdiChildFrm::slot_resizeViaSystemMenu() 01315 { 01316 grabMouse(); 01317 m_bResizing = true; 01318 m_iResizeCorner = KMDI_RESIZE_BOTTOMLEFT; 01319 setResizeCursor( m_iResizeCorner ); 01320 } 01321 01322 void KMdiChildFrm::redecorateButtons() 01323 { 01324 delete m_pMinButtonPixmap; 01325 delete m_pMaxButtonPixmap; 01326 delete m_pRestoreButtonPixmap; 01327 delete m_pCloseButtonPixmap; 01328 delete m_pUndockButtonPixmap; 01329 01330 if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::Win95Look ) 01331 { 01332 m_pMinButtonPixmap = new QPixmap( win_minbutton ); 01333 m_pMaxButtonPixmap = new QPixmap( win_maxbutton ); 01334 m_pRestoreButtonPixmap = new QPixmap( win_restorebutton ); 01335 m_pCloseButtonPixmap = new QPixmap( win_closebutton ); 01336 m_pUndockButtonPixmap = new QPixmap( win_undockbutton ); 01337 } 01338 else if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDE1Look ) 01339 { 01340 m_pMinButtonPixmap = new QPixmap( kde_minbutton ); 01341 m_pMaxButtonPixmap = new QPixmap( kde_maxbutton ); 01342 m_pRestoreButtonPixmap = new QPixmap( kde_restorebutton ); 01343 m_pCloseButtonPixmap = new QPixmap( kde_closebutton ); 01344 m_pUndockButtonPixmap = new QPixmap( kde_undockbutton ); 01345 } 01346 else if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDELook ) 01347 { 01348 m_pMinButtonPixmap = new QPixmap( kde2_minbutton ); 01349 m_pMaxButtonPixmap = new QPixmap( kde2_maxbutton ); 01350 m_pRestoreButtonPixmap = new QPixmap( kde2_restorebutton ); 01351 m_pCloseButtonPixmap = new QPixmap( kde2_closebutton ); 01352 m_pUndockButtonPixmap = new QPixmap( kde2_undockbutton ); 01353 } 01354 else 01355 { // kde2laptop look 01356 m_pMinButtonPixmap = new QPixmap( kde2laptop_minbutton ); 01357 m_pMaxButtonPixmap = new QPixmap( kde2laptop_maxbutton ); 01358 m_pRestoreButtonPixmap = new QPixmap( kde2laptop_restorebutton ); 01359 m_pCloseButtonPixmap = new QPixmap( kde2laptop_closebutton ); 01360 m_pUndockButtonPixmap = new QPixmap( kde2laptop_undockbutton ); 01361 } 01362 01363 m_pUnixIcon->setAutoRaise( true ); 01364 if ( KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDE1Look ) 01365 { 01366 m_pMinimize->setAutoRaise( true ); 01367 m_pMaximize->setAutoRaise( true ); 01368 m_pClose->setAutoRaise( true ); 01369 m_pUndock->setAutoRaise( true ); 01370 } 01371 else 01372 { 01373 m_pMinimize->setAutoRaise( false ); 01374 m_pMaximize->setAutoRaise( false ); 01375 m_pClose->setAutoRaise( false ); 01376 m_pUndock->setAutoRaise( false ); 01377 } 01378 01379 if ( m_pClient && m_pClient->icon() ) 01380 { 01381 m_pWinIcon->setPixmap( *( m_pClient )->icon() ); 01382 m_pUnixIcon->setPixmap( *( m_pClient )->icon() ); 01383 } 01384 else 01385 { 01386 m_pWinIcon->setPixmap( *m_pIconButtonPixmap ); 01387 m_pUnixIcon->setPixmap( *m_pIconButtonPixmap ); 01388 } 01389 m_pClose->setPixmap( *m_pCloseButtonPixmap ); 01390 m_pMinimize->setPixmap( *m_pMinButtonPixmap ); 01391 m_pMaximize->setPixmap( *m_pMaxButtonPixmap ); 01392 m_pUndock->setPixmap( *m_pUndockButtonPixmap ); 01393 } 01394 01395 QRect KMdiChildFrm::mdiAreaContentsRect() const 01396 { 01397 QFrame * p = ( QFrame* ) parentWidget(); 01398 if ( p ) 01399 { 01400 return p->contentsRect(); 01401 } 01402 else 01403 { 01404 QRect empty; 01405 return empty; 01406 } 01407 } 01408 01409 // kate: indent-mode csands; tab-width 4; space-indent off; replace-tabs off;
KDE Logo
This file is part of the documentation for kmdi Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Apr 14 00:37:12 2005 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003