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 focusEvent( QFocusEvent::FocusIn );
01108                     QApplication::sendEvent( qApp->mainWidget(), &focusEvent );
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 Home | KDE Accessibility Home | Description of Access Keys