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