00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 #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 
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 
00093 
00094 
00095 void KMdiWin32IconButton::mousePressEvent( QMouseEvent*)
00096 {
00097    
00098 }
00099 
00100 
00101 
00102 KMdiChildFrm::KMdiChildFrm(KMdiChildArea *parent)
00103  : QFrame(parent, "kmdi_childfrm")
00104    ,m_pClient(0L)
00105    ,m_pManager(0L)
00106    ,m_pCaption(0L)
00107    ,m_pWinIcon(0L)
00108    ,m_pUnixIcon(0L)
00109    ,m_pMinimize(0L)
00110    ,m_pMaximize(0L)
00111    ,m_pClose(0L)
00112    ,m_pUndock(0L)
00113    ,m_state(Normal)
00114    ,m_restoredRect()
00115    ,m_iResizeCorner(KMDI_NORESIZE)
00116    ,m_iLastCursorCorner(KMDI_NORESIZE)
00117    ,m_bResizing(false)
00118    ,m_bDragging(false)
00119    ,m_pIconButtonPixmap(0L)
00120    ,m_pMinButtonPixmap(0L)
00121    ,m_pMaxButtonPixmap(0L)
00122    ,m_pRestoreButtonPixmap(0L)
00123    ,m_pCloseButtonPixmap(0L)
00124    ,m_pUndockButtonPixmap(0L)
00125    ,m_windowMenuID(0)
00126    ,m_pSystemMenu(0L)
00127    ,m_oldClientMinSize()
00128    ,m_oldClientMaxSize()
00129    ,m_oldLayoutResizeMode(QLayout::Minimum)
00130 {
00131    m_pCaption  = new KMdiChildFrmCaption(this);
00132 
00133    m_pManager  = parent;
00134 
00135    m_pWinIcon  = new KMdiWin32IconButton(m_pCaption, "kmdi_iconbutton_icon");
00136    m_pUnixIcon = new QToolButton(m_pCaption, "kmdi_toolbutton_icon");
00137    m_pMinimize = new QToolButton(m_pCaption, "kmdi_toolbutton_min");
00138    m_pMaximize = new QToolButton(m_pCaption, "kmdi_toolbutton_max");
00139    m_pClose    = new QToolButton(m_pCaption, "kmdi_toolbutton_close");
00140    m_pUndock   = new QToolButton(m_pCaption, "kmdi_toolbutton_undock");
00141 
00142    QObject::connect(m_pMinimize,SIGNAL(clicked()),this,SLOT(minimizePressed()));
00143    QObject::connect(m_pMaximize,SIGNAL(clicked()),this,SLOT(maximizePressed()));
00144    QObject::connect(m_pClose,SIGNAL(clicked()),this,SLOT(closePressed()));
00145    QObject::connect(m_pUndock,SIGNAL(clicked()),this,SLOT(undockPressed()));
00146 
00147    m_pIconButtonPixmap = new QPixmap( SmallIcon("filenew") );
00148    if (m_pIconButtonPixmap->isNull())
00149       *m_pIconButtonPixmap = QPixmap(filenew);
00150    
00151    redecorateButtons();
00152 
00153    m_pWinIcon->setFocusPolicy(NoFocus);
00154    m_pUnixIcon->setFocusPolicy(NoFocus);
00155    m_pClose->setFocusPolicy(NoFocus);
00156    m_pMinimize->setFocusPolicy(NoFocus);
00157    m_pMaximize->setFocusPolicy(NoFocus);
00158    m_pUndock->setFocusPolicy(NoFocus);
00159 
00160    setFrameStyle(QFrame::WinPanel|QFrame::Raised);
00161    setFocusPolicy(NoFocus);
00162 
00163    setMouseTracking(true);
00164 
00165    setMinimumSize(KMDI_CHILDFRM_MIN_WIDTH, m_pCaption->heightHint());
00166 
00167    m_pSystemMenu = new QPopupMenu();
00168 }
00169 
00170 
00171 
00172 KMdiChildFrm::~KMdiChildFrm()
00173 {
00174    delete m_pMinButtonPixmap;
00175    delete m_pMaxButtonPixmap;
00176    delete m_pRestoreButtonPixmap;
00177    delete m_pCloseButtonPixmap;
00178    delete m_pUndockButtonPixmap;
00179    delete m_pSystemMenu;
00180    delete m_pIconButtonPixmap;
00181 }
00182 
00183 
00184 void KMdiChildFrm::mousePressEvent(QMouseEvent *e)
00185 {
00186    if( m_bResizing) {
00187       if(QApplication::overrideCursor()) { QApplication::restoreOverrideCursor(); }
00188       m_bResizing = false;
00189       releaseMouse();
00190    }
00191 
00192    m_pCaption->setActive(true);
00193    m_pManager->setTopChild(this,false);
00194 
00195    m_iResizeCorner=getResizeCorner(e->pos().x(),e->pos().y());
00196    if(m_iResizeCorner != KMDI_NORESIZE) {
00197       m_bResizing = true;
00198       
00199       KMdiChildFrmResizeBeginEvent ue(e);
00200       if( m_pClient != 0L) {
00201          QApplication::sendEvent( m_pClient, &ue);
00202       }
00203    }
00204 }
00205 
00206 
00207 
00208 void KMdiChildFrm::mouseReleaseEvent(QMouseEvent *e)
00209 {
00210    if(m_bResizing) {
00211       if(QApplication::overrideCursor()) { QApplication::restoreOverrideCursor(); }
00212 
00213       m_bResizing = false;
00214       
00215       KMdiChildFrmResizeEndEvent ue(e);
00216       if( m_pClient != 0L) {
00217          QApplication::sendEvent( m_pClient, &ue);
00218       }
00219    }
00220 }
00221 
00222 
00223 
00224 void KMdiChildFrm::setResizeCursor(int resizeCorner)
00225 {
00226    if(resizeCorner == m_iLastCursorCorner)return; 
00227    m_iLastCursorCorner = resizeCorner;
00228    switch (resizeCorner) {
00229       case KMDI_NORESIZE:
00230          if(QApplication::overrideCursor())QApplication::restoreOverrideCursor();
00231          break;
00232       case KMDI_RESIZE_LEFT:
00233       case KMDI_RESIZE_RIGHT:
00234          QApplication::setOverrideCursor(Qt::sizeHorCursor,true);
00235          break;
00236       case KMDI_RESIZE_TOP:
00237       case KMDI_RESIZE_BOTTOM:
00238          QApplication::setOverrideCursor(Qt::sizeVerCursor,true);
00239          break;
00240       case KMDI_RESIZE_TOPLEFT:
00241       case KMDI_RESIZE_BOTTOMRIGHT:
00242          QApplication::setOverrideCursor(Qt::sizeFDiagCursor,true);
00243          break;
00244       case KMDI_RESIZE_BOTTOMLEFT:
00245       case KMDI_RESIZE_TOPRIGHT:
00246          QApplication::setOverrideCursor(Qt::sizeBDiagCursor,true);
00247          break;
00248    }
00249 }
00250 
00251 
00252 
00253 void KMdiChildFrm::unsetResizeCursor()
00254 {
00255    if ( !m_bResizing && (m_iResizeCorner != KMDI_NORESIZE) ) {
00256       m_iResizeCorner=KMDI_NORESIZE;
00257       m_iLastCursorCorner=KMDI_NORESIZE;
00258       if(QApplication::overrideCursor())QApplication::restoreOverrideCursor();
00259    }
00260 }
00261 
00262 
00263 
00264 void KMdiChildFrm::mouseMoveEvent(QMouseEvent *e)
00265 {
00266    if(m_state != Normal) return;
00267    if(!m_pClient) return;
00268    if(m_pClient->minimumSize() == m_pClient->maximumSize()) return;
00269 
00270    if(m_bResizing) {
00271       if( !(e->state() & RightButton) && !(e->state() & MidButton)) {
00272          
00273          QPoint p = parentWidget()->mapFromGlobal( e->globalPos() );
00274          resizeWindow(m_iResizeCorner, p.x(), p.y());
00275       }
00276       else
00277          m_bResizing = false;
00278    }
00279    else {
00280       m_iResizeCorner = getResizeCorner(e->pos().x(), e->pos().y());
00281       setResizeCursor( m_iResizeCorner);
00282    }
00283 }
00284 
00285 
00286 
00287 void KMdiChildFrm::moveEvent(QMoveEvent* me)
00288 {
00289    
00290    KMdiChildFrmMoveEvent cfme( me);
00291    if( m_pClient != 0L) {
00292       QApplication::sendEvent( m_pClient, &cfme);
00293    }
00294 }
00295 
00296 
00297 
00298 void KMdiChildFrm::leaveEvent(QEvent *)
00299 {
00300    unsetResizeCursor();
00301 }
00302 
00303 void KMdiChildFrm::resizeWindow(int resizeCorner, int xPos, int yPos)
00304 {
00305    QRect resizeRect(x(),y(),width(),height());
00306 
00307    
00308    int minWidth=0;
00309    int minHeight=0;
00310    int maxWidth=QWIDGETSIZE_MAX;
00311    int maxHeight=QWIDGETSIZE_MAX;
00312    
00313    if(m_pClient){
00314       minWidth  = m_pClient->minimumSize().width() + KMDI_CHILDFRM_DOUBLE_BORDER;
00315       minHeight = m_pClient->minimumSize().height()+ KMDI_CHILDFRM_DOUBLE_BORDER +
00316                     m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR;
00317       maxWidth  = m_pClient->maximumSize().width() + KMDI_CHILDFRM_DOUBLE_BORDER;
00318       maxHeight = m_pClient->maximumSize().height()+ KMDI_CHILDFRM_DOUBLE_BORDER +
00319                     m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR;
00320    }
00321    if(minWidth<minimumWidth())minWidth=minimumWidth();
00322    if(minHeight<minimumHeight())minHeight=minimumHeight();
00323    if(maxWidth>maximumWidth())maxWidth=maximumWidth();
00324    if(maxHeight>maximumHeight())maxHeight=maximumHeight();
00325 
00326    QPoint mousePos( xPos, yPos);
00327 
00328    
00329    switch (resizeCorner){
00330    case KMDI_RESIZE_TOPLEFT:     
00331    case KMDI_RESIZE_LEFT:        
00332    case KMDI_RESIZE_BOTTOMLEFT:
00333       resizeRect.setLeft(mousePos.x());
00334       if(resizeRect.width() < minWidth)resizeRect.setLeft(resizeRect.right() - minWidth + 1);
00335       if(resizeRect.width() > maxWidth)resizeRect.setLeft(resizeRect.right() - maxWidth + 1);
00336       break;
00337    case KMDI_RESIZE_TOPRIGHT:    
00338    case KMDI_RESIZE_RIGHT:       
00339    case KMDI_RESIZE_BOTTOMRIGHT:
00340       resizeRect.setRight(mousePos.x());
00341       if(resizeRect.width() < minWidth)resizeRect.setRight(resizeRect.left() + minWidth - 1);
00342       if(resizeRect.width() > maxWidth)resizeRect.setRight(resizeRect.left() + maxWidth - 1);
00343       break;
00344    default:
00345       
00346       break;
00347    }
00348    
00349    switch (resizeCorner){
00350    case KMDI_RESIZE_TOPLEFT:  
00351    case KMDI_RESIZE_TOP:      
00352    case KMDI_RESIZE_TOPRIGHT:
00353       resizeRect.setTop(mousePos.y());
00354       if(resizeRect.height() < minHeight)resizeRect.setTop(resizeRect.bottom() - minHeight + 1);
00355       if(resizeRect.height() > maxHeight)resizeRect.setTop(resizeRect.bottom() - maxHeight + 1);
00356       break;
00357    case KMDI_RESIZE_BOTTOMLEFT:  
00358    case KMDI_RESIZE_BOTTOM:      
00359    case KMDI_RESIZE_BOTTOMRIGHT:
00360       resizeRect.setBottom(mousePos.y());
00361       if(resizeRect.height() < minHeight)resizeRect.setBottom(resizeRect.top() + minHeight - 1);
00362       if(resizeRect.height() > maxHeight)resizeRect.setBottom(resizeRect.top() + maxHeight - 1);
00363       break;
00364    default:
00365       
00366       break;
00367    }
00368    
00369    setGeometry( resizeRect);
00370 
00371    if(m_state==Maximized){
00372       m_state=Normal;
00373       m_pMaximize->setPixmap( *m_pMaxButtonPixmap);
00374    }
00375 }
00376 
00377 
00378 
00379 int KMdiChildFrm::getResizeCorner(int ax,int ay)
00380 {
00381    int ret = KMDI_NORESIZE;
00382    if(m_pClient->minimumWidth() != m_pClient->maximumWidth()) {
00383    if((ax>0)&&(ax<(KMDI_CHILDFRM_BORDER+2))) ret |= KMDI_RESIZE_LEFT;
00384      if((ax<width())&&(ax>(width()-(KMDI_CHILDFRM_BORDER+2)))) ret |= KMDI_RESIZE_RIGHT;
00385    }
00386   if(m_pClient->minimumHeight() != m_pClient->maximumHeight()) {
00387    if((ay>0)&&(ay<(KMDI_CHILDFRM_BORDER+2))) ret |= KMDI_RESIZE_TOP;
00388      if((ay<(height()))&&(ay>(height()-(KMDI_CHILDFRM_BORDER+2)))) ret |= KMDI_RESIZE_BOTTOM;
00389    }
00390    return ret;
00391 }
00392 
00393 
00394 
00395 void KMdiChildFrm::maximizePressed()
00396 {
00397    switch(m_state){
00398       case Maximized:
00399          emit m_pManager->nowMaximized(false);
00400          setState(Normal);
00401          break;
00402       case Normal:
00403       case Minimized:
00404          setState(Maximized);
00405          emit m_pManager->nowMaximized(true);
00406          break;
00407    }
00408 }
00409 
00410 void KMdiChildFrm::restorePressed()
00411 {
00412    if( m_state == Normal)
00413       return;
00414    if( m_state == Maximized)
00415       emit m_pManager->nowMaximized(false);
00416    setState(Normal);
00417 }
00418 
00419 
00420 
00421 void KMdiChildFrm::minimizePressed()
00422 {
00423    switch(m_state){
00424       case Minimized: setState(Normal);    break;
00425       case Normal:    setState(Minimized); break;
00426       case Maximized:
00427          emit m_pManager->nowMaximized(false);
00428          setState(Normal);
00429          setState(Minimized);
00430          break;
00431    }
00432 }
00433 
00434 
00435 
00436 void KMdiChildFrm::closePressed()
00437 {
00438    if(m_pClient)
00439       m_pClient->close();
00440 }
00441 
00442 
00443 
00444 void KMdiChildFrm::undockPressed()
00445 {
00446    if(m_pClient) {
00447       if( m_state == Minimized)
00448          setState( Normal);
00449       m_pClient->detach();
00450    }
00451 }
00452 
00453 
00454 
00455 void KMdiChildFrm::setState(MdiWindowState state, bool )
00456 {
00457    if(m_state==Normal){ 
00458       m_restoredRect=QRect(x(),y(),width(),height());
00459    }
00460    switch(state){
00461    case Normal:
00462       switch(m_state){
00463       case Maximized:
00464          m_pClient->m_stateChanged = true;
00465          m_state=state;
00466          
00467          
00468          
00469          m_pClient->setMaximumSize(m_pClient->maximumSize().width(), m_pClient->maximumSize().height());
00470          m_pMaximize->setPixmap( *m_pMaxButtonPixmap);
00471          setGeometry(m_restoredRect);
00472          break;
00473       case Minimized:
00474          m_pClient->m_stateChanged = true;
00475          m_state=state;
00476          
00477          m_pClient->setMinimumSize(m_oldClientMinSize.width(),m_oldClientMinSize.height());
00478          m_pClient->setMaximumSize(m_oldClientMaxSize.width(),m_oldClientMaxSize.height());
00479          if (m_pClient->layout() != 0L) {
00480             m_pClient->layout()->setResizeMode(m_oldLayoutResizeMode);
00481          }
00482          m_pMinimize->setPixmap( *m_pMinButtonPixmap);
00483          m_pMaximize->setPixmap( *m_pMaxButtonPixmap);
00484          QObject::disconnect(m_pMinimize,SIGNAL(clicked()),this,SLOT(restorePressed()));
00485          QObject::connect(m_pMinimize,SIGNAL(clicked()),this,SLOT(minimizePressed()));
00486          setGeometry(m_restoredRect);
00487          break;
00488       case Normal:
00489           break;
00490       }
00491       break;
00492    case Maximized:
00493       switch(m_state){
00494       case Minimized: {
00495             m_pClient->m_stateChanged = true;
00496             m_state=state;
00497             
00498             m_pClient->setMinimumSize(m_oldClientMinSize.width(),m_oldClientMinSize.height());
00499             m_pClient->setMaximumSize(m_oldClientMaxSize.width(),m_oldClientMaxSize.height());
00500             if (m_pClient->layout() != 0L) {
00501                m_pClient->layout()->setResizeMode(m_oldLayoutResizeMode);
00502             }
00503             setMaximumSize(QWIDGETSIZE_MAX,QWIDGETSIZE_MAX);
00504             
00505             m_pMaximize->setPixmap( *m_pRestoreButtonPixmap);
00506             m_pMinimize->setPixmap( *m_pMinButtonPixmap);
00507             QObject::disconnect(m_pMinimize,SIGNAL(clicked()),this,SLOT(restorePressed()));
00508             QObject::connect(m_pMinimize,SIGNAL(clicked()),this,SLOT(minimizePressed()));
00509             int nFrameWidth = KMDI_CHILDFRM_DOUBLE_BORDER;
00510             int nFrameHeight = KMDI_CHILDFRM_DOUBLE_BORDER + KMDI_CHILDFRM_SEPARATOR +
00511                                m_pCaption->heightHint();
00512             setGeometry(-m_pClient->x(), -m_pClient->y(),
00513                         m_pManager->width() + nFrameWidth,
00514                         m_pManager->height() + nFrameHeight);
00515             raise();
00516          }
00517          break;
00518       case Normal: {
00519             m_pClient->m_stateChanged = true;
00520             m_state=state;
00521             
00522             setMaximumSize(QWIDGETSIZE_MAX,QWIDGETSIZE_MAX);
00523             m_pMaximize->setPixmap( *m_pRestoreButtonPixmap);
00524             int nFrameWidth = KMDI_CHILDFRM_DOUBLE_BORDER;
00525             int nFrameHeight = KMDI_CHILDFRM_DOUBLE_BORDER + KMDI_CHILDFRM_SEPARATOR +
00526                                m_pCaption->heightHint();
00527             QRect maximizedFrmRect(-m_pClient->x(), -m_pClient->y(),
00528                                    m_pManager->width() + nFrameWidth,
00529                                    m_pManager->height() + nFrameHeight);
00530             if (geometry() != maximizedFrmRect) {
00531                setGeometry(maximizedFrmRect);
00532             }
00533             raise();
00534          }
00535          break;
00536       case Maximized:
00537          break;
00538       }
00539    break;
00540    case Minimized:
00541       switch(m_state){
00542       case Maximized:
00543          m_pClient->m_stateChanged = true;
00544          m_state=state;
00545          
00546          m_oldClientMinSize = m_pClient->minimumSize();
00547          m_oldClientMaxSize = m_pClient->maximumSize();
00548          if (m_pClient->layout() != 0L) {
00549             m_oldLayoutResizeMode = m_pClient->layout()->resizeMode();
00550          }
00551          m_pClient->setMinimumSize(0, 0);
00552          m_pClient->setMaximumSize(0, 0);
00553          if (m_pClient->layout() != 0L) {
00554             m_pClient->layout()->setResizeMode(QLayout::FreeResize);
00555          }
00556          switchToMinimizeLayout();
00557          m_pManager->childMinimized(this,true);
00558          break;
00559       case Normal:
00560          m_pClient->m_stateChanged = true;
00561          m_state=state;
00562          
00563          m_oldClientMinSize = m_pClient->minimumSize();
00564          m_oldClientMaxSize = m_pClient->maximumSize();
00565          if (m_pClient->layout() != 0L) {
00566             m_oldLayoutResizeMode = m_pClient->layout()->resizeMode();
00567          }
00568          m_restoredRect = geometry();
00569          m_pClient->setMinimumSize(0, 0);
00570          m_pClient->setMaximumSize(0, 0);
00571          if (m_pClient->layout() != 0L) {
00572             m_pClient->layout()->setResizeMode(QLayout::FreeResize);
00573          }
00574          switchToMinimizeLayout();
00575          m_pManager->childMinimized(this,false);
00576          break;
00577       case Minimized:
00578          break;
00579       }
00580    break;
00581    }
00582 
00583    KMdiChildFrm*     pTopFrame = m_pManager->topChild();
00584    KMdiChildView*    pTopChild = 0L;
00585    if (pTopFrame != 0L) {
00586       pTopChild = pTopFrame->m_pClient;
00587    }
00588    if ( (pTopChild != 0L) && pTopChild->isMaximized() ) {
00589       m_pManager->setMinimumSize(pTopChild->minimumWidth(), pTopChild->minimumHeight());
00592    }
00593    else {
00594       m_pManager->setMinimumSize(0, 0);
00595       m_pManager->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
00596    }
00597 }
00598 
00599 
00600 
00601 QRect KMdiChildFrm::restoreGeometry() const
00602 {
00603    return m_restoredRect;
00604 }
00605 
00606 
00607 
00608 void KMdiChildFrm::setRestoreGeometry(const QRect& newRestGeo)
00609 {
00610    m_restoredRect = newRestGeo;
00611 }
00612 
00613 
00614 
00615 void KMdiChildFrm::setCaption(const QString& text)
00616 {
00617    m_pCaption->setCaption(text);
00618 }
00619 
00620 
00621 
00622 void KMdiChildFrm::enableClose(bool bEnable)
00623 {
00624    m_pClose->setEnabled(bEnable);
00625    m_pClose->repaint(false);
00626 }
00627 
00628 
00629 
00630 void KMdiChildFrm::setIcon(const QPixmap& pxm)
00631 {
00632    QPixmap p = pxm;
00633    if (p.width()!=18 || p.height()!=18) {
00634       QImage img = p.convertToImage();
00635       p = img.smoothScale(18,18,QImage::ScaleMin);
00636    }
00637    const bool do_resize = m_pIconButtonPixmap->size()!=p.size();
00638    *m_pIconButtonPixmap = p;
00639    m_pWinIcon->setPixmap( p );
00640    m_pUnixIcon->setPixmap( p );
00641    if (do_resize)
00642       doResize(true);
00643 }
00644 
00645 
00646 
00647 QPixmap* KMdiChildFrm::icon() const
00648 {
00649    return m_pIconButtonPixmap;
00650 }
00651 
00652 
00653 void KMdiChildFrm::setClient(KMdiChildView *w, bool bAutomaticResize)
00654 {
00655    m_pClient=w;
00656 
00657    if (w->icon())
00658       setIcon( *(w->icon()));
00659 
00660    
00661    int clientYPos=m_pCaption->heightHint()+KMDI_CHILDFRM_SEPARATOR+KMDI_CHILDFRM_BORDER;
00662    if (bAutomaticResize || w->size().isEmpty() || (w->size() == QSize(1,1))) {
00663       if (m_pManager->topChild()) {
00664          resize(m_pManager->topChild()->size());
00665       }
00666       else {
00667          resize(m_pManager->m_defaultChildFrmSize.width()+KMDI_CHILDFRM_DOUBLE_BORDER,m_pManager->m_defaultChildFrmSize.height()+KMDI_CHILDFRM_BORDER+clientYPos);
00668       }
00669    }
00670    else {
00671       resize(w->width()+KMDI_CHILDFRM_DOUBLE_BORDER,w->height()+KMDI_CHILDFRM_BORDER+clientYPos);
00672    }
00673 
00674    
00675    QDict<FocusPolicy>* pFocPolDict = new QDict<FocusPolicy>;
00676    pFocPolDict->setAutoDelete(true);
00677    QObjectList *list = m_pClient->queryList( "QWidget" );
00678    QObjectListIt it( *list );          
00679    QObject * obj;
00680    int i = 1;
00681    while ( (obj=it.current()) != 0 ) { 
00682       ++it;
00683       QWidget* widg = (QWidget*)obj;
00684       if( widg->name(0) == 0) {
00685          QString tmpStr;
00686          tmpStr.setNum( i);
00687          tmpStr = "unnamed" + tmpStr;
00688          widg->setName( tmpStr.latin1() );
00689          i++;
00690       }
00691       FocusPolicy* pFocPol = new FocusPolicy;
00692       *pFocPol = widg->focusPolicy();
00693       pFocPolDict->insert( widg->name(), pFocPol);
00694    }
00695    delete list;                        
00696 
00697    
00698    if(w->parent()!=this){
00699       
00700       QPoint pnt2(KMDI_CHILDFRM_BORDER,clientYPos);
00701       QSize mincs = w->minimumSize();
00702       QSize maxcs = w->maximumSize();
00703       w->setMinimumSize(0,0);
00704       w->setMaximumSize(QWIDGETSIZE_MAX,QWIDGETSIZE_MAX);
00705 
00706       
00707       w->reparent(this,0,pnt2,w->isVisible());
00708 
00709       w->setMinimumSize(mincs.width(),mincs.height());
00710       w->setMaximumSize(maxcs.width(),maxcs.height());
00711    } else w->move(KMDI_CHILDFRM_BORDER,clientYPos);
00712 
00713    linkChildren( pFocPolDict);
00714 
00715    QObject::connect( m_pClient, SIGNAL(mdiParentNowMaximized(bool)), m_pManager, SIGNAL(nowMaximized(bool)) );
00716 
00717    if( m_pClient->minimumSize().width() > m_pManager->m_defaultChildFrmSize.width()) {
00718       setMinimumWidth(m_pClient->minimumSize().width() + KMDI_CHILDFRM_DOUBLE_BORDER);
00719    }
00720    if( m_pClient->minimumSize().height() > m_pManager->m_defaultChildFrmSize.height()) {
00721       setMinimumHeight( m_pClient->minimumSize().height()+ KMDI_CHILDFRM_DOUBLE_BORDER +
00722                         m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR);
00723    }
00724 }
00725 
00726 
00727 
00728 void KMdiChildFrm::unsetClient( QPoint positionOffset)
00729 {
00730    if(!m_pClient)return;
00731 
00732    QObject::disconnect( m_pClient, SIGNAL(mdiParentNowMaximized(bool)), m_pManager, SIGNAL(nowMaximized(bool)) );
00733 
00734    
00735    QDict<FocusPolicy>* pFocPolDict;
00736    pFocPolDict = unlinkChildren();
00737 
00738    
00739    QWidget* focusedChildWidget = m_pClient->focusedChildWidget();
00740    const char* nameOfFocusedWidget = "";
00741    if( focusedChildWidget != 0)
00742       nameOfFocusedWidget = focusedChildWidget->name();
00743 
00744    QSize mins = m_pClient->minimumSize();
00745    QSize maxs = m_pClient->maximumSize();
00746    m_pClient->reparent(0,0,mapToGlobal(pos())-pos()+positionOffset,isVisible());
00747    m_pClient->setMinimumSize(mins.width(),mins.height());
00748    m_pClient->setMaximumSize(maxs.width(),maxs.height());
00749 
00750    
00751    QObjectList *list = m_pClient->queryList( "QWidget" );
00752    QObjectListIt it( *list );          
00753    QObject * obj;
00754    QWidget* firstFocusableChildWidget = 0;
00755    QWidget* lastFocusableChildWidget = 0;
00756    while ( (obj=it.current()) != 0 ) { 
00757       QWidget* widg = (QWidget*)obj;
00758       ++it;
00759       FocusPolicy* pFocPol = pFocPolDict->find( widg->name()); 
00760       if( pFocPol)
00761          widg->setFocusPolicy( *pFocPol);
00762       
00763       if( widg->name() == nameOfFocusedWidget) {
00764          widg->setFocus();
00765       }
00766       
00767       if( (widg->focusPolicy() == QWidget::StrongFocus) || (widg->focusPolicy() == QWidget::TabFocus)) {
00768          if( firstFocusableChildWidget == 0)
00769             firstFocusableChildWidget = widg;  
00770          lastFocusableChildWidget = widg; 
00771          
00772       }
00773       else {
00774          if( widg->focusPolicy() == QWidget::WheelFocus) {
00775             if( firstFocusableChildWidget == 0)
00776                firstFocusableChildWidget = widg;  
00777             lastFocusableChildWidget = widg; 
00778             
00779          }
00780       }
00781    }
00782    delete list;                        
00783    delete pFocPolDict;
00784 
00785    
00786    m_pClient->setFirstFocusableChildWidget( firstFocusableChildWidget);
00787    m_pClient->setLastFocusableChildWidget( lastFocusableChildWidget);
00788 
00789    
00790    m_pClient->setFocusPolicy(QWidget::ClickFocus);
00791 
00792    
00793    m_pClient=0;
00794 }
00795 
00796 
00797 void KMdiChildFrm::linkChildren( QDict<FocusPolicy>* pFocPolDict)
00798 {
00799    
00800    QObjectList *list = m_pClient->queryList( "QWidget" );
00801    QObjectListIt it( *list );          
00802    QObject * obj;
00803    while ( (obj=it.current()) != 0 ) { 
00804       QWidget* widg = (QWidget*)obj;
00805       ++it;
00806       FocusPolicy* pFocPol = pFocPolDict->find(widg->name()); 
00807       if( pFocPol != 0)
00808          widg->setFocusPolicy( *pFocPol);
00809       if (!(widg->inherits("QPopupMenu"))) {
00810          widg->installEventFilter(this);
00811       }
00812    }
00813    delete list;                        
00814    delete pFocPolDict;
00815 
00816    
00817    m_pWinIcon->setFocusPolicy(QWidget::NoFocus);
00818    m_pUnixIcon->setFocusPolicy(QWidget::NoFocus);
00819    m_pClient->setFocusPolicy(QWidget::ClickFocus);
00820    m_pCaption->setFocusPolicy(QWidget::NoFocus);
00821    m_pUndock->setFocusPolicy(QWidget::NoFocus);
00822    m_pMinimize->setFocusPolicy(QWidget::NoFocus);
00823    m_pMaximize->setFocusPolicy(QWidget::NoFocus);
00824    m_pClose->setFocusPolicy(QWidget::NoFocus);
00825 
00826    
00827    m_pWinIcon->installEventFilter(this);
00828    m_pUnixIcon->installEventFilter(this);
00829    m_pCaption->installEventFilter(this);
00830    m_pUndock->installEventFilter(this);
00831    m_pMinimize->installEventFilter(this);
00832    m_pMaximize->installEventFilter(this);
00833    m_pClose->installEventFilter(this);
00834    m_pClient->installEventFilter(this);
00835 
00836 }
00837 
00838 
00839 
00840 QDict<QWidget::FocusPolicy>* KMdiChildFrm::unlinkChildren()
00841 {
00842    
00843    QDict<FocusPolicy>* pFocPolDict = new QDict<FocusPolicy>;
00844    pFocPolDict->setAutoDelete(true);
00845 
00846    QObjectList *list = m_pClient->queryList( "QWidget" );
00847    QObjectListIt it( *list );          
00848    QObject * obj;
00849    int i = 1;
00850    while ( (obj=it.current()) != 0 ) { 
00851       ++it;
00852       QWidget* widg = (QWidget*)obj;
00853       
00854       if( widg->name(0) == 0) {
00855          QString tmpStr;
00856          tmpStr.setNum( i);
00857          tmpStr = "unnamed" + tmpStr;
00858          widg->setName( tmpStr.latin1() );
00859          i++;
00860       }
00861       FocusPolicy* pFocPol = new FocusPolicy;
00862       *pFocPol = widg->focusPolicy();
00863       
00864       pFocPolDict->insert( widg->name(), pFocPol);
00865       
00866       ((QWidget*)obj)->removeEventFilter(this);
00867    }
00868    delete list;                        
00869 
00870    
00871    m_pWinIcon->removeEventFilter(this);
00872    m_pUnixIcon->removeEventFilter(this);
00873    m_pCaption->removeEventFilter(this);
00874    m_pUndock->removeEventFilter(this);
00875    m_pMinimize->removeEventFilter(this);
00876    m_pMaximize->removeEventFilter(this);
00877    m_pClose->removeEventFilter(this);
00878    m_pClient->removeEventFilter(this);
00879 
00880 
00881 
00882    return pFocPolDict;
00883 }
00884 
00885 
00886 
00887 void KMdiChildFrm::resizeEvent(QResizeEvent *)
00888 {
00889    doResize(); 
00890 }
00891 
00892 void KMdiChildFrm::doResize()
00893 {
00894     doResize(false);
00895 }
00896 
00897 void KMdiChildFrm::doResize(bool captionOnly)
00898 {
00899    
00900    int captionHeight = m_pCaption->heightHint();
00901    int captionWidth = width() - KMDI_CHILDFRM_DOUBLE_BORDER;
00902    int buttonHeight = m_pClose->pixmap()->height();
00903    int buttonWidth  = m_pClose->pixmap()->width();
00904    int heightOffset = captionHeight/2 - buttonHeight/2;
00905    int rightOffset1 = 1;
00906    int rightOffset2 = 1;
00907    int frmIconHeight = m_pWinIcon->pixmap()->height();
00908    int frmIconWidth  = m_pWinIcon->pixmap()->width();
00909    int frmIconOffset = 1;
00910    QWidget* pIconWidget = m_pWinIcon;
00911    m_pCaption->setGeometry( KMDI_CHILDFRM_BORDER, KMDI_CHILDFRM_BORDER, captionWidth, captionHeight);
00912    
00913    if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::Win95Look) {
00914       rightOffset2 += 2;
00915       m_pUnixIcon->hide();
00916    }
00917    else if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDE1Look) {
00918       buttonWidth  += 4;
00919       buttonHeight += 4;
00920       heightOffset -= 2;
00921       rightOffset1 = 0;
00922       rightOffset2 = 0;
00923       m_pWinIcon->hide();
00924       frmIconHeight = buttonHeight;
00925       frmIconWidth  = buttonWidth;
00926       frmIconOffset = 0;
00927       pIconWidget = m_pUnixIcon;
00928    }
00929    else if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDELook) {
00930       buttonWidth  += 3;
00931       buttonHeight += 3;
00932       heightOffset -= 1;
00933       m_pUnixIcon->hide();
00934    }
00935    if (KMdiMainFrm::frameDecorOfAttachedViews() != KMdi::KDELaptopLook) {
00936       pIconWidget->setGeometry(frmIconOffset,captionHeight/2-frmIconHeight/2,frmIconWidth,frmIconHeight);
00937       m_pClose->setGeometry((captionWidth-buttonWidth)-rightOffset1,heightOffset,buttonWidth,buttonHeight);
00938       m_pMaximize->setGeometry((captionWidth-(buttonWidth*2))-rightOffset2,heightOffset,buttonWidth,buttonHeight);
00939       m_pMinimize->setGeometry((captionWidth-(buttonWidth*3))-rightOffset2,heightOffset,buttonWidth,buttonHeight);
00940       m_pUndock->setGeometry((captionWidth-(buttonWidth*4))-rightOffset2,heightOffset,buttonWidth,buttonHeight);
00941    }
00942    else {   
00943       m_pWinIcon->hide();
00944       m_pUnixIcon->hide();
00945       buttonHeight += 5;
00946       heightOffset -= 2;
00947       m_pClose->setGeometry   ( 0,                 heightOffset, 27, buttonHeight);
00948       m_pMaximize->setGeometry( captionWidth-27,   heightOffset, 27, buttonHeight);
00949       m_pMinimize->setGeometry( captionWidth-27*2, heightOffset, 27, buttonHeight);
00950       m_pUndock->setGeometry  ( captionWidth-27*3, heightOffset, 27, buttonHeight);
00951    }
00952    
00953    if (!captionOnly && m_pClient) {
00954       QSize newClientSize(captionWidth,
00955       height()-(KMDI_CHILDFRM_DOUBLE_BORDER+captionHeight+KMDI_CHILDFRM_SEPARATOR));
00956       if (newClientSize != m_pClient->size()) {
00957          m_pClient->setGeometry(KMDI_CHILDFRM_BORDER,
00958                                 m_pCaption->heightHint()+KMDI_CHILDFRM_SEPARATOR+KMDI_CHILDFRM_BORDER,
00959                                 newClientSize.width(), newClientSize.height());
00960       }
00961    }
00962 }
00963 
00964 
00965 
00966 bool KMdiChildFrm::eventFilter( QObject *obj, QEvent *e )
00967 {
00968    switch (e->type()) {
00969    case QEvent::Enter:
00970       {
00971          
00972          bool bIsChild = false;
00973          QObject*    pObj = obj;
00974          while ( (pObj != 0L) && !bIsChild) {
00975             bIsChild = (pObj == this);
00976             pObj = pObj->parent();
00977          }
00978          
00979          if (bIsChild) {
00980             unsetResizeCursor();
00981          }
00982       }
00983       break;
00984    case QEvent::MouseButtonPress:
00985       {
00986          if ( (QWidget*)obj != m_pClient ) {
00987             bool bIsSecondClick = false;
00988             if (m_timeMeasure.elapsed() <= QApplication::doubleClickInterval()) {
00989                bIsSecondClick = true;  
00990             }
00991             if ( !(((obj == m_pWinIcon) || (obj == m_pUnixIcon)) && bIsSecondClick) ) {
00992                
00993                QFocusEvent* pFE = new QFocusEvent(QFocusEvent::FocusIn);
00994                QApplication::sendEvent(qApp->mainWidget(), pFE);
00995                if (m_pClient) {
00996                   m_pClient->updateTimeStamp();
00997                   m_pClient->activate();
00998                }
00999                QWidget* w = (QWidget*) obj;
01000                if( (w->parent() != m_pCaption) && (w != m_pCaption)) {
01001                   if ((w->focusPolicy() == QWidget::ClickFocus) || (w->focusPolicy() == QWidget::StrongFocus)) {
01002                      w->setFocus();
01003                   }
01004                }
01005             }
01006             if ((obj == m_pWinIcon) || (obj == m_pUnixIcon)) {
01007                
01008                if (m_timeMeasure.elapsed() > QApplication::doubleClickInterval()) {
01009                   showSystemMenu();
01010                   m_timeMeasure.start();
01011                }
01012                else {
01013                   closePressed();   
01014                }
01015                return true;
01016             }
01017          }
01018       }
01019       break;
01020    case QEvent::Resize:
01021       {
01022          if ( ( (QWidget*)obj == m_pClient ) && (m_state == Normal) ) {
01023             QResizeEvent* re = (QResizeEvent*)e;
01024             int captionHeight = m_pCaption->heightHint();
01025             QSize newChildFrmSize( re->size().width() + KMDI_CHILDFRM_DOUBLE_BORDER,
01026                re->size().height() + captionHeight + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER );
01027             if( newChildFrmSize != size())
01028                resize( newChildFrmSize );
01029          }
01030       }
01031       break;
01032    case QEvent::ChildRemoved:
01033       {
01034          
01035          
01036          QObject* pLostChild = ((QChildEvent*)e)->child();
01037          if ((pLostChild != 0L)  ) {
01038             QObjectList *list = pLostChild->queryList();
01039             list->insert(0, pLostChild);        
01040             QObjectListIt it( *list );          
01041             QObject * obj;
01042             while ( (obj=it.current()) != 0 ) { 
01043                QWidget* widg = (QWidget*)obj;
01044                ++it;
01045                widg->removeEventFilter(this);
01046             }
01047             delete list;                        
01048          }
01049       }
01050       break;
01051    case QEvent::ChildInserted:
01052       {
01053          
01054          
01055          
01056          QObject* pNewChild = ((QChildEvent*)e)->child();
01057          if ( (pNewChild != 0L) && (pNewChild->inherits("QWidget")) ) {
01058             QWidget* pNewWidget = (QWidget*)pNewChild;
01059             QObjectList *list = pNewWidget->queryList( "QWidget" );
01060             list->insert(0, pNewChild);         
01061             QObjectListIt it( *list );          
01062             QObject * obj;
01063             while ( (obj=it.current()) != 0 ) { 
01064                QWidget* widg = (QWidget*)obj;
01065                ++it;
01066                if (!(widg->inherits("QPopupMenu"))) {
01067                   widg->installEventFilter(this);
01068                }
01069             }
01070             delete list;                        
01071          }
01072       }
01073       break;
01074    default:
01075       break;
01076    }
01077    
01078    return false;                  
01079 }
01080 
01081 
01082 
01083 void KMdiChildFrm::raiseAndActivate()
01084 {
01085    
01086    m_pCaption->setActive(true);
01087    m_pManager->setTopChild(this,false); 
01088 }
01089 
01090 
01091 
01092 void KMdiChildFrm::setMinimumSize ( int minw, int minh )
01093 {
01094    QWidget::setMinimumSize(minw, minh);
01095    if (m_state == Maximized) {
01096       m_pManager->setMinimumSize(minw, minh);
01097    }
01098 }
01099 
01100 
01101 
01102 QPopupMenu* KMdiChildFrm::systemMenu() const
01103 {
01104    if( m_pSystemMenu == 0)
01105       return 0;
01106 
01107    m_pSystemMenu->clear();
01108 
01109    if (KMdiMainFrm::frameDecorOfAttachedViews() != KMdi::Win95Look) {
01110       m_pSystemMenu->insertItem(i18n("&Restore"),this,SLOT(restorePressed()));
01111       m_pSystemMenu->insertItem(i18n("&Move"),m_pCaption, SLOT(slot_moveViaSystemMenu()));
01112       m_pSystemMenu->insertItem(i18n("R&esize"),this, SLOT(slot_resizeViaSystemMenu()));
01113       m_pSystemMenu->insertItem(i18n("M&inimize"),this, SLOT(minimizePressed()));
01114       m_pSystemMenu->insertItem(i18n("M&aximize"),this, SLOT(maximizePressed()));
01115       if( state() == Normal)
01116          m_pSystemMenu->setItemEnabled(m_pSystemMenu->idAt(0),false);
01117       else if( state() == Maximized) {
01118          m_pSystemMenu->setItemEnabled(m_pSystemMenu->idAt(1),false);
01119          m_pSystemMenu->setItemEnabled(m_pSystemMenu->idAt(2),false);
01120          m_pSystemMenu->setItemEnabled(m_pSystemMenu->idAt(4),false);
01121       }
01122       else if( state() == Minimized) {
01123          m_pSystemMenu->setItemEnabled(m_pSystemMenu->idAt(2),false);
01124          m_pSystemMenu->setItemEnabled(m_pSystemMenu->idAt(3),false);
01125       }
01126    }
01127    else  {
01128       if( state() != Normal)
01129          m_pSystemMenu->insertItem(i18n("&Restore"),this,SLOT(restorePressed()));
01130       if( state() != Maximized)
01131          m_pSystemMenu->insertItem(i18n("&Maximize"),this, SLOT(maximizePressed()));
01132       if( state() != Minimized)
01133          m_pSystemMenu->insertItem(i18n("&Minimize"),this, SLOT(minimizePressed()));
01134       if( state() != Maximized)
01135          m_pSystemMenu->insertItem(i18n("M&ove"),m_pCaption, SLOT(slot_moveViaSystemMenu()));
01136       if( state() == Normal)
01137          m_pSystemMenu->insertItem(i18n("&Resize"),this, SLOT(slot_resizeViaSystemMenu()));
01138    }
01139 
01140    m_pSystemMenu->insertItem(i18n("&Undock"),this, SLOT(undockPressed()));
01141    m_pSystemMenu->insertSeparator();
01142    m_pSystemMenu->insertItem(i18n("&Close"),this, SLOT(closePressed()));
01143 
01144    return m_pSystemMenu;
01145 }
01146 
01148 void KMdiChildFrm::showSystemMenu()
01149 {
01150    if (KMdiMainFrm::frameDecorOfAttachedViews() != KMdi::Win95Look) {
01151       m_pUnixIcon->setDown( false);
01152    }
01153    QPoint popupmenuPosition;
01154    
01155    QRect iconGeom;
01156    if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::Win95Look)
01157       iconGeom = m_pWinIcon->geometry();
01158    else
01159       iconGeom = m_pUnixIcon->geometry();
01160    popupmenuPosition = QPoint( iconGeom.x(),
01161                                iconGeom.y() + captionHeight() + KMDI_CHILDFRM_BORDER );
01162    systemMenu()->popup( mapToGlobal( popupmenuPosition));
01163 }
01164 
01165 void KMdiChildFrm::switchToMinimizeLayout()
01166 {
01167    setMinimumWidth(KMDI_CHILDFRM_MIN_WIDTH);
01168    setFixedHeight(m_pCaption->height()+KMDI_CHILDFRM_DOUBLE_BORDER);
01169 
01170    m_pMaximize->setPixmap( *m_pMaxButtonPixmap);
01171 
01172    
01173    m_pMinimize->setPixmap( *m_pRestoreButtonPixmap);
01174    QObject::disconnect(m_pMinimize,SIGNAL(clicked()),this,SLOT(minimizePressed()));
01175    QObject::connect(m_pMinimize,SIGNAL(clicked()),this,SLOT(restorePressed()));
01176 
01177    
01178    resize( 300, minimumHeight());
01179 
01180    
01181    m_pManager->layoutMinimizedChildren();
01182 }
01183 
01184 void KMdiChildFrm::slot_resizeViaSystemMenu()
01185 {
01186    grabMouse();
01187    m_bResizing = true;
01188    m_iResizeCorner = KMDI_RESIZE_BOTTOMLEFT;
01189    setResizeCursor( m_iResizeCorner);
01190 }
01191 
01192 void KMdiChildFrm::redecorateButtons()
01193 {
01194    if (m_pMinButtonPixmap)
01195       delete m_pMinButtonPixmap;
01196    if (m_pMaxButtonPixmap)
01197       delete m_pMaxButtonPixmap;
01198    if (m_pRestoreButtonPixmap)
01199       delete m_pRestoreButtonPixmap;
01200    if (m_pCloseButtonPixmap)
01201       delete m_pCloseButtonPixmap;
01202    if (m_pUndockButtonPixmap)
01203       delete m_pUndockButtonPixmap;
01204 
01205    if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::Win95Look) {
01206       m_pMinButtonPixmap = new QPixmap( win_minbutton);
01207       m_pMaxButtonPixmap = new QPixmap( win_maxbutton);
01208       m_pRestoreButtonPixmap = new QPixmap( win_restorebutton);
01209       m_pCloseButtonPixmap = new QPixmap( win_closebutton);
01210       m_pUndockButtonPixmap = new QPixmap( win_undockbutton);
01211    }
01212    else if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDE1Look) {
01213       m_pMinButtonPixmap = new QPixmap( kde_minbutton);
01214       m_pMaxButtonPixmap = new QPixmap( kde_maxbutton);
01215       m_pRestoreButtonPixmap = new QPixmap( kde_restorebutton);
01216       m_pCloseButtonPixmap = new QPixmap( kde_closebutton);
01217       m_pUndockButtonPixmap = new QPixmap( kde_undockbutton);
01218    }
01219    else if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDELook) {
01220       m_pMinButtonPixmap = new QPixmap( kde2_minbutton);
01221       m_pMaxButtonPixmap = new QPixmap( kde2_maxbutton);
01222       m_pRestoreButtonPixmap = new QPixmap( kde2_restorebutton);
01223       m_pCloseButtonPixmap = new QPixmap( kde2_closebutton);
01224       m_pUndockButtonPixmap = new QPixmap( kde2_undockbutton);
01225    }
01226    else {   
01227       m_pMinButtonPixmap = new QPixmap( kde2laptop_minbutton);
01228       m_pMaxButtonPixmap = new QPixmap( kde2laptop_maxbutton);
01229       m_pRestoreButtonPixmap = new QPixmap( kde2laptop_restorebutton);
01230       m_pCloseButtonPixmap = new QPixmap( kde2laptop_closebutton);
01231       m_pUndockButtonPixmap = new QPixmap( kde2laptop_undockbutton);
01232    }
01233 
01234    m_pUnixIcon->setAutoRaise(true);
01235    if (KMdiMainFrm::frameDecorOfAttachedViews() == KMdi::KDE1Look) {
01236       m_pMinimize->setAutoRaise(true);
01237       m_pMaximize->setAutoRaise(true);
01238       m_pClose->setAutoRaise(true);
01239       m_pUndock->setAutoRaise(true);
01240    }
01241    else {
01242       m_pMinimize->setAutoRaise(false);
01243       m_pMaximize->setAutoRaise(false);
01244       m_pClose->setAutoRaise(false);
01245       m_pUndock->setAutoRaise(false);
01246    }
01247 
01248    if (m_pClient && m_pClient->icon()) {
01249       m_pWinIcon->setPixmap( *(m_pClient)->icon());
01250       m_pUnixIcon->setPixmap( *(m_pClient)->icon());
01251    }
01252    else {
01253       m_pWinIcon->setPixmap( *m_pIconButtonPixmap);
01254       m_pUnixIcon->setPixmap( *m_pIconButtonPixmap);
01255    }
01256    m_pClose->setPixmap( *m_pCloseButtonPixmap);
01257    m_pMinimize->setPixmap( *m_pMinButtonPixmap);
01258    m_pMaximize->setPixmap( *m_pMaxButtonPixmap);
01259    m_pUndock->setPixmap( *m_pUndockButtonPixmap);
01260 }
01261 
01262 QRect KMdiChildFrm::mdiAreaContentsRect() const
01263 {
01264    QFrame* p = (QFrame*)parentWidget();
01265    if (p) {
01266       return p->contentsRect();
01267    }
01268    else {
01269       QRect empty;
01270       return empty;
01271    }
01272 }
01273 
01274