kmdi Library: kmdichildfrm.cpp Source File (kmdi Library)

| # kmdi Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# 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;

This file is part of the documentation for kmdi Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:32:06 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003