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