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

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

# kmdichildarea.cpp

    00001 //----------------------------------------------------------------------------
    00002 //    filename             : kmdichildarea.cpp
    00003 //----------------------------------------------------------------------------
    00004 //    Project              : KDE MDI extension
    00005 //
    00006 //    begin                : 07/1999       by Szymon Stefanek as part of kvirc
    00007 //                                         (an IRC application)
    00008 //    changes              : 09/1999       by Falk Brettschneider to create an
    00009 //                           - 06/2000     stand-alone Qt extension set of
    00010 //                                         classes and a Qt-based library
    00011 //                           2000-2003     maintained by the KDevelop project
    00012 //
    00013 //    copyright            : (C) 1999-2003 by Szymon Stefanek (stefanek@tin.it)
    00014 //                                         and
    00015 //                                         Falk Brettschneider
    00016 //    email                :  falkbr@kdevelop.org (Falk Brettschneider)
    00017 //----------------------------------------------------------------------------
    00018 //
    00019 //----------------------------------------------------------------------------
    00020 //
    00021 //    This program is free software; you can redistribute it and/or modify
    00022 //    it under the terms of the GNU Library General Public License as
    00023 //    published by the Free Software Foundation; either version 2 of the
    00024 //    License, or (at your option) any later version.
    00025 //
    00026 //----------------------------------------------------------------------------
    00027
    00028 #include "kmdichildarea.h"
    00029 #include "kmdichildarea.moc"
    00030
    00031 #include "kmdidefines.h"
    00032
    00033 #include <kconfig.h>
    00034 #include <kdebug.h>
    00035 #include <kglobal.h>
    00036 #include <kglobalsettings.h>
    00037
    00038 #include <math.h>
    00039 #include <qpopupmenu.h>
    00040
    00041
    00043 // KMdiChildArea
    00045
    00046 //============ KMdiChildArea ============//
    00047
    00048 KMdiChildArea::KMdiChildArea( QWidget *parent )
    00049         : QFrame( parent, "kmdi_childarea" )
    00050 {
    00051     setFrameStyle( QFrame::Panel | QFrame::Sunken );
    00052     m_captionFont = QFont();
    00053     QFontMetrics fm( m_captionFont );
    00054     m_captionFontLineSpacing = fm.lineSpacing();
    00055     m_captionActiveBackColor = KGlobalSettings::activeTitleColor();
    00056     m_captionActiveForeColor = KGlobalSettings::activeTextColor();
    00057     m_captionInactiveBackColor = KGlobalSettings::inactiveTitleColor();
    00058     m_captionInactiveForeColor = KGlobalSettings::inactiveTextColor();
    00059     m_pZ = new QPtrList<KMdiChildFrm>;
    00060     m_pZ->setAutoDelete( true );
    00061     setFocusPolicy( ClickFocus );
    00062     m_defaultChildFrmSize = QSize( 400, 300 );
    00063 }
    00064
    00065
    00066 KMdiChildArea::~KMdiChildArea()
    00067 {
    00068     delete m_pZ; //This will destroy all the widgets inside.
    00069 }
    00070
    00071
    00072 void KMdiChildArea::manageChild( KMdiChildFrm* child, bool show, bool cascade )
    00073 {
    00074     kdDebug( 760 ) << k_funcinfo << "Adding child " << child << " to be managed" << endl;
    00075     KMdiChildFrm* top = topChild();
    00076
    00077     //remove old references. There can be more than one so we remove them all
    00078     if ( m_pZ->findRef( child ) != -1 )
    00079     {
    00080         //QPtrList::find* moves current() to the found item
    00081         m_pZ->take();
    00082         while ( m_pZ->findNextRef( child ) != -1 )
    00083             m_pZ->take();
    00084     }
    00085
    00086     if ( show )
    00087         m_pZ->append( child ); //visible -> first in the Z order
    00088     else
    00089         m_pZ->insert( 0, child ); //hidden -> last in the Z order
    00090
    00091     if ( cascade )
    00092         child->move( getCascadePoint( m_pZ->count() - 1 ) );
    00093
    00094     if ( show )
    00095     {
    00096         if ( top && top->state() == KMdiChildFrm::Maximized )
    00097         {
    00098             kdDebug( 760 ) << k_funcinfo << "Maximizing the new child" << endl;
    00099             emit sysButtonConnectionsMustChange( top, child );
    00100             top->setState( KMdiChildFrm::Normal, false /*animate*/ );
    00101             child->setState( KMdiChildFrm::Maximized, false /*animate*/ );
    00102         }
    00103         child->show();
    00104         focusTopChild();
    00105     }
    00106 }
    00107
    00108
    00109 void KMdiChildArea::destroyChild( KMdiChildFrm *child, bool focusTop )
    00110 {
    00111     kdDebug( 760 ) << k_funcinfo << "Removing child " << child->caption() << endl;
    00112     bool wasMaximized = ( child->state() == KMdiChildFrm::Maximized );
    00113
    00114     // destroy the old one
    00115     QObject::disconnect( child );
    00116     child->blockSignals( true );
    00117     m_pZ->setAutoDelete( false );
    00118     m_pZ->removeRef( child );
    00119
    00120     // focus the next new childframe
    00121     KMdiChildFrm* newTopChild = topChild();
    00122     if ( wasMaximized )
    00123     {
    00124         if ( newTopChild )
    00125         {
    00126             newTopChild->setState( KMdiChildFrm::Maximized, false );
    00127             emit sysButtonConnectionsMustChange( child, newTopChild );
    00128         }
    00129         else
    00130             emit noMaximizedChildFrmLeft( child ); // last childframe removed
    00131     }
    00132
    00133     delete child;
    00134     m_pZ->setAutoDelete( true );
    00135
    00136     if ( focusTop )
    00137         focusTopChild();
    00138 }
    00139
    00140
    00141 void KMdiChildArea::destroyChildButNotItsView( KMdiChildFrm* child, bool focusTop )
    00142 {
    00143     kdDebug( 760 ) << k_funcinfo << "Removing child " << child->caption() << endl;
    00144     bool wasMaximized = ( child->state() == KMdiChildFrm::Maximized );
    00145
    00146     // destroy the old one
    00147     QObject::disconnect( child );
    00148     child->unsetClient();
    00149     m_pZ->setAutoDelete( false );
    00150     m_pZ->removeRef( child );
    00151
    00152     // focus the next new childframe
    00153     KMdiChildFrm* newTopChild = topChild();
    00154     if ( wasMaximized )
    00155     {
    00156         if ( newTopChild )
    00157         {
    00158             newTopChild->setState( KMdiChildFrm::Maximized, false );
    00159             emit sysButtonConnectionsMustChange( child, newTopChild );
    00160         }
    00161         else
    00162             emit noMaximizedChildFrmLeft( child ); // last childframe removed
    00163     }
    00164     delete child;
    00165     m_pZ->setAutoDelete( true );
    00166
    00167     if ( focusTop )
    00168         focusTopChild();
    00169 }
    00170
    00171 void KMdiChildArea::setTopChild( KMdiChildFrm* child, bool /* bSetFocus */ )
    00172 {
    00173     if ( !child )
    00174         return;
    00175
    00176     if ( topChild() != child )
    00177     {
    00178         kdDebug( 760 ) << k_funcinfo << "Setting " << child->caption() << " as the new top child" << endl;
    00179         m_pZ->setAutoDelete( false );
    00180         if ( child )
    00181             m_pZ->removeRef( child );
    00182         m_pZ->setAutoDelete( true );
    00183
    00184         //disable the labels of all the other children
    00185         QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00186         for ( ; ( *it ); ++it )
    00187             ( *it )->m_pCaption->setActive( false );
    00188
    00189         KMdiChildFrm* maximizedChild = topChild();
    00190         bool topChildMaximized = false;
    00191         if ( maximizedChild && maximizedChild->state() == KMdiChildFrm::Maximized )
    00192             topChildMaximized = true;
    00193
    00194         m_pZ->append( child );
    00195
    00196         int nChildAreaMinW = 0, nChildAreaMinH = 0;
    00197         int nChildAreaMaxW = QWIDGETSIZE_MAX, nChildAreaMaxH = QWIDGETSIZE_MAX;
    00198         if ( topChildMaximized && child->m_pClient )
    00199         {
    00200             //the former top child is maximized, so maximize the new one
    00201             nChildAreaMinW = child->m_pClient->minimumWidth();
    00202             nChildAreaMinH = child->m_pClient->minimumHeight();
    00204             // nChildAreaMaxW = child->m_pClient->maximumWidth();
    00205             // nChildAreaMaxH = child->m_pClient->maximumHeight();
    00206         }
    00207
    00208         //set the min and max sizes of this child area to the new top child
    00209         setMinimumSize( nChildAreaMinW, nChildAreaMinH );
    00210         setMaximumSize( nChildAreaMaxW, nChildAreaMaxH );
    00211
    00212         if ( topChildMaximized )
    00213         {   //maximize the new view and restore the old
    00214             child->setState( KMdiChildFrm::Maximized, false /*animate*/);
    00215             maximizedChild->setState( KMdiChildFrm::Normal, false /*animate*/ );
    00216             emit sysButtonConnectionsMustChange( maximizedChild, child );
    00217         }
    00218         else
    00219             child->raise();
    00220
    00221         QFocusEvent::setReason( QFocusEvent::Other );
    00222         child->m_pClient->setFocus();
    00223     }
    00224 }
    00225
    00226
    00227 void KMdiChildArea::resizeEvent( QResizeEvent* e )
    00228 {
    00229     //If we have a maximized children at the top , adjust its size
    00230     KMdiChildFrm* child = topChild();
    00231     if ( child && child->state() == KMdiChildFrm::Maximized  )
    00232     {
    00233         int clientw = 0, clienth = 0;
    00234         if ( child->m_pClient != 0L )
    00235         {
    00236             clientw = child->m_pClient->width();
    00237             clienth = child->m_pClient->height();
    00238         }
    00239         child->resize( width() + KMDI_CHILDFRM_DOUBLE_BORDER,
    00240                        height() + child->m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER );
    00241
    00242     }
    00243     layoutMinimizedChildren();
    00244     QWidget::resizeEvent( e );
    00245 }
    00246
    00247 //=============== mousePressEvent =============//
    00248
    00249 void KMdiChildArea::mousePressEvent( QMouseEvent *e )
    00250 {
    00251     //Popup the window menu
    00252     if ( e->button() & RightButton )
    00253         emit popupWindowMenu( mapToGlobal( e->pos() ) );
    00254 }
    00255
    00256 //=============== getCascadePoint ============//
    00257
    00258 QPoint KMdiChildArea::getCascadePoint( int indexOfWindow )
    00259 {
    00260     if ( indexOfWindow < 0 )
    00261     {
    00262         indexOfWindow = m_pZ->count(); //use the window count
    00263         kdDebug( 760 ) << k_funcinfo << "indexOfWindow was less than zero, using "
    00264             << indexOfWindow << " as new index" << endl;
    00265     }
    00266
    00267     QPoint pnt( 0, 0 );
    00268     if ( indexOfWindow == 0 )
    00269     {
    00270         kdDebug( 760 ) << k_funcinfo << "No windows. Returning QPoint( 0, 0 ) as the cascade point" << endl;
    00271         return pnt;
    00272     }
    00273
    00274     bool topLevelMode = false;
    00275     if ( height() == 1 )    // hacky?!
    00276         topLevelMode = true;
    00277
    00278     kdDebug( 760 ) << k_funcinfo << "Getting the cascade point for window index " << indexOfWindow << endl;
    00279     kdDebug( 760 ) << k_funcinfo << "Do we think we're in top level mode? " << topLevelMode << endl;
    00280
    00281     KMdiChildFrm* child = m_pZ->first();
    00282
    00283     //default values
    00284     int step = 20;
    00285     int h = ( topLevelMode ? QApplication::desktop()->height() : height() );
    00286     int w = ( topLevelMode ? QApplication::desktop()->width() : width() );
    00287
    00288     int availableHeight = h - m_defaultChildFrmSize.height();
    00289     int availableWidth = w - m_defaultChildFrmSize.width();
    00290     int ax = 0;
    00291     int ay = 0;
    00292
    00293     if ( child )
    00294     {
    00295         kdDebug( 760 ) << k_funcinfo << "child frame exists. resetting height and width values" << endl;
    00296         step = child->m_pCaption->heightHint() + KMDI_CHILDFRM_BORDER;
    00297         availableHeight = h - child->minimumHeight();
    00298         availableWidth = w - child->minimumWidth();
    00299     }
    00300
    00301     for ( int i = 0; i < indexOfWindow; i++ )
    00302     {
    00303         ax += step;
    00304         ay += step;
    00305
    00306         //do some bounds checking, because to not do it would be bad.
    00307         if ( ax > availableWidth )
    00308             ax = 0;
    00309
    00310         if ( ay > availableHeight )
    00311             ay = 0;
    00312     }
    00313     pnt.setX( ax );
    00314     pnt.setY( ay );
    00315     return pnt;
    00316 }
    00317
    00318
    00319 void KMdiChildArea::childMinimized( KMdiChildFrm *minimizedChild, bool wasMaximized )
    00320 {
    00321     //can't find the child in our list, so we don't care.
    00322     if ( m_pZ->findRef( minimizedChild ) == -1 )
    00323     {
    00324         kdDebug( 760 ) << k_funcinfo << "child was minimized but wasn't in our list!" << endl;
    00325         return;
    00326     }
    00327
    00328     kdDebug( 760 ) << k_funcinfo << endl;
    00329     if ( m_pZ->count() > 1 )
    00330     {
    00331         //move the minimized child to the bottom
    00332         m_pZ->setAutoDelete( false );
    00333         m_pZ->removeRef( minimizedChild );
    00334         m_pZ->setAutoDelete( true );
    00335         m_pZ->insert( 0, minimizedChild );
    00336
    00337         if ( wasMaximized )
    00338         { // Need to maximize the new top child
    00339             kdDebug( 760 ) << k_funcinfo << "child just minimized from maximized state. maximize new top child" << endl;
    00340             minimizedChild = topChild();
    00341             if ( !minimizedChild )
    00342                 return; //??
    00343
    00344             if ( minimizedChild->state() == KMdiChildFrm::Maximized )
    00345                 return; //it's already maximized
    00346
    00347             minimizedChild->setState( KMdiChildFrm::Maximized, false ); //do not animate the change
    00348         }
    00349         focusTopChild();
    00350     }
    00351     else
    00352         setFocus(); //Remove focus from the child. We only have one window
    00353 }
    00354
    00355 void KMdiChildArea::focusTopChild()
    00356 {
    00357     KMdiChildFrm* lastChild = topChild();
    00358     if ( !lastChild )
    00359     {
    00360         kdDebug( 760 ) << k_funcinfo << "No more child windows left" << endl;
    00361         emit lastChildFrmClosed();
    00362         return;
    00363     }
    00364
    00365     if ( !lastChild->m_pClient->hasFocus() )
    00366     {
    00367         //disable the labels of all the other children
    00368         QPtrListIterator<KMdiChildFrm> it ( *m_pZ );
    00369         for ( ; ( *it ); ++it )
    00370         {
    00371             if ( ( *it ) != lastChild )
    00372                 ( *it )->m_pCaption->setActive( false );
    00373         }
    00374
    00375         kdDebug( 760 ) << k_funcinfo << "Giving focus to " << lastChild->caption() << endl;
    00376         lastChild->raise();
    00377         lastChild->m_pClient->activate();
    00378     }
    00379
    00380 }
    00381
    00382 void KMdiChildArea::cascadeWindows()
    00383 {
    00384     kdDebug( 760 ) << k_funcinfo << "cascading windows but not changing their size" << endl;
    00385     int idx = 0;
    00386     QPtrList<KMdiChildFrm> list( *m_pZ );
    00387     list.setAutoDelete( false );
    00388     while ( !list.isEmpty() )
    00389     {
    00390         KMdiChildFrm* childFrm = list.first();
    00391         if ( childFrm->state() != KMdiChildFrm::Minimized )
    00392         {
    00393             if ( childFrm->state() == KMdiChildFrm::Maximized )
    00394                 childFrm->restorePressed();
    00395
    00396             childFrm->move( getCascadePoint( idx ) );
    00397             idx++;
    00398         }
    00399         list.removeFirst();
    00400     }
    00401     focusTopChild();
    00402 }
    00403
    00404 void KMdiChildArea::cascadeMaximized()
    00405 {
    00406     kdDebug( 760 ) << k_funcinfo << "cascading windows. will make sure they are minimum sized" << endl;
    00407     int idx = 0;
    00408     QPtrList<KMdiChildFrm> list( *m_pZ );
    00409
    00410     list.setAutoDelete( false );
    00411     while ( !list.isEmpty() )
    00412     {
    00413         KMdiChildFrm* childFrm = list.first();
    00414         if (childFrm->state() != KMdiChildFrm::Minimized )
    00415         {
    00416             if (childFrm->state() == KMdiChildFrm::Maximized )
    00417                 childFrm->restorePressed();
    00418
    00419             QPoint pnt( getCascadePoint( idx ) );
    00420             childFrm->move( pnt );
    00421             QSize curSize( width() - pnt.x(), height() - pnt.y() );
    00422
    00423             if ( ( childFrm->minimumSize().width() > curSize.width() ) ||
    00424                  ( childFrm->minimumSize().height() > curSize.height() ) )
    00425             {
    00426                 childFrm->resize( childFrm->minimumSize() );
    00427             }
    00428             else
    00429                 childFrm->resize( curSize );
    00430
    00431             idx++;
    00432         }
    00433         list.removeFirst();
    00434     }
    00435     focusTopChild();
    00436 }
    00437
    00438 void KMdiChildArea::expandVertical()
    00439 {
    00440     kdDebug( 760 ) << k_funcinfo << "expanding all child frames vertically" << endl;
    00441     int idx = 0;
    00442     QPtrList<KMdiChildFrm> list( *m_pZ );
    00443     list.setAutoDelete( false );
    00444     while ( !list.isEmpty() )
    00445     {
    00446         KMdiChildFrm* childFrm = list.first();
    00447         if ( childFrm->state() != KMdiChildFrm::Minimized )
    00448         {
    00449             if ( childFrm->state() == KMdiChildFrm::Maximized )
    00450                 childFrm->restorePressed();
    00451
    00452             childFrm->setGeometry( childFrm->x(), 0, childFrm->width(), height() );
    00453             idx++;
    00454         }
    00455         list.removeFirst();
    00456     }
    00457     focusTopChild();
    00458 }
    00459
    00460 void KMdiChildArea::expandHorizontal()
    00461 {
    00462     kdDebug( 760 ) << k_funcinfo << "expanding all child frames horizontally" << endl;
    00463     int idx = 0;
    00464     QPtrList<KMdiChildFrm> list( *m_pZ );
    00465     list.setAutoDelete( false );
    00466     while ( !list.isEmpty() )
    00467     {
    00468         KMdiChildFrm* childFrm = list.first();
    00469         if ( childFrm->state() != KMdiChildFrm::Minimized )
    00470         {
    00471             if ( childFrm->state() == KMdiChildFrm::Maximized )
    00472                 childFrm->restorePressed();
    00473
    00474             childFrm->setGeometry( 0, childFrm->y(), width(), childFrm->height() );
    00475             idx++;
    00476         }
    00477         list.removeFirst();
    00478     }
    00479     focusTopChild();
    00480 }
    00481
    00482 int KMdiChildArea::getVisibleChildCount() const
    00483 {
    00484     int visibleChildCount = 0;
    00485     QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00486     for ( ; ( *it ); ++it )
    00487     {
    00488         if ( ( *it )->state() != KMdiChildFrm::Minimized && ( *it )->isVisible() )
    00489             visibleChildCount++;
    00490     }
    00491     return visibleChildCount;
    00492 }
    00493
    00494 void KMdiChildArea::tilePragma()
    00495 {
    00496     kdDebug( 760 ) << k_funcinfo << endl;
    00497     tileAllInternal( 9 );
    00498 }
    00499
    00500 void KMdiChildArea::tileAllInternal( int maxWnds )
    00501 {
    00502     kdDebug( 760 ) << k_funcinfo << endl;
    00503     //NUM WINDOWS =           1,2,3,4,5,6,7,8,9
    00504     static int colstable[ 9 ] = { 1, 1, 1, 2, 2, 2, 3, 3, 3 }; //num columns
    00505     static int rowstable[ 9 ] = { 1, 2, 3, 2, 3, 3, 3, 3, 3 }; //num rows
    00506     static int lastwindw[ 9 ] = { 1, 1, 1, 1, 2, 1, 3, 2, 1 }; //last window multiplier
    00507     static int colrecall[ 9 ] = { 0, 0, 0, 3, 3, 3, 6, 6, 6 }; //adjust self
    00508     static int rowrecall[ 9 ] = { 0, 0, 0, 0, 4, 4, 4, 4, 4 }; //adjust self
    00509
    00510     int numVisible = getVisibleChildCount();
    00511     if ( numVisible < 1 )
    00512     {
    00513         kdDebug( 760 ) << k_funcinfo << "No visible child windows to tile" << endl;
    00514         return;
    00515     }
    00516
    00517     KMdiChildFrm *tcw = topChild();
    00518     int numToHandle = ( ( numVisible > maxWnds ) ? maxWnds : numVisible );
    00519
    00520     int xQuantum = width() / colstable[ numToHandle - 1 ];
    00521     int widthToCompare;
    00522
    00523     if ( tcw->minimumWidth() > m_defaultChildFrmSize.width() )
    00524         widthToCompare = tcw->minimumWidth();
    00525     else
    00526         widthToCompare = m_defaultChildFrmSize.width();
    00527
    00528     if ( xQuantum < widthToCompare )
    00529     {
    00530         if ( colrecall[ numToHandle - 1 ] != 0 )
    00531         {
    00532             tileAllInternal( colrecall[ numToHandle - 1 ] );
    00533             return ;
    00534         }
    00535     }
    00536
    00537     int yQuantum = height() / rowstable[ numToHandle - 1 ];
    00538     int heightToCompare;
    00539     if ( tcw->minimumHeight() > m_defaultChildFrmSize.height() )
    00540         heightToCompare = tcw->minimumHeight();
    00541     else
    00542         heightToCompare = m_defaultChildFrmSize.height();
    00543
    00544     if ( yQuantum < heightToCompare )
    00545     {
    00546         if ( rowrecall[ numToHandle - 1 ] != 0 )
    00547         {
    00548             tileAllInternal( rowrecall[ numToHandle - 1 ] );
    00549             return ;
    00550         }
    00551     }
    00552     int curX = 0;
    00553     int curY = 0;
    00554     int curRow = 1;
    00555     int curCol = 1;
    00556     int curWin = 1;
    00557
    00558     QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00559     for ( ; ( *it ); ++it )
    00560     {
    00561         KMdiChildFrm* child = ( *it );
    00562         if ( child->state() != KMdiChildFrm::Minimized )
    00563         {
    00564             //restore the window
    00565             if ( child->state() == KMdiChildFrm::Maximized )
    00566                 child->restorePressed();
    00567
    00568             if ( ( curWin % numToHandle ) == 0 )
    00569                 child->setGeometry( curX, curY, xQuantum * lastwindw[ numToHandle - 1 ], yQuantum );
    00570             else
    00571                 child->setGeometry( curX, curY, xQuantum, yQuantum );
    00572
    00573             //example : 12 windows : 3 cols 3 rows
    00574             if ( curCol < colstable[ numToHandle - 1 ] )
    00575             { //curCol<3
    00576                 curX += xQuantum; //add a column in the same row
    00577                 curCol++;         //increase current column
    00578             }
    00579             else
    00580             {
    00581                 curX = 0;         //new row
    00582                 curCol = 1;       //column 1
    00583                 if ( curRow < rowstable[ numToHandle - 1 ] )
    00584                 { //curRow<3
    00585                     curY += yQuantum; //add a row
    00586                     curRow++;         //increase current row
    00587                 }
    00588                 else
    00589                 {
    00590                     curY = 0;         //restart from beginning
    00591                     curRow = 1;       //reset current row
    00592                 }
    00593             }
    00594             curWin++;
    00595         }
    00596     }
    00597
    00598     if ( tcw )
    00599         tcw->m_pClient->activate();
    00600 }
    00601
    00602 void KMdiChildArea::tileAnodine()
    00603 {
    00604     KMdiChildFrm * topChildWindow = topChild();
    00605     int numVisible = getVisibleChildCount(); // count visible windows
    00606     if ( numVisible < 1 )
    00607         return ;
    00608
    00609     int numCols = int( sqrt( ( double ) numVisible ) ); // set columns to square root of visible count
    00610     // create an array to form grid layout
    00611     int *numRows = new int[ numCols ];
    00612     int numCurCol = 0;
    00613
    00614     while ( numCurCol < numCols )
    00615     {
    00616         numRows[numCurCol] = numCols; // create primary grid values
    00617         numCurCol++;
    00618     }
    00619
    00620     int numDiff = numVisible - ( numCols * numCols ); // count extra rows
    00621     int numCurDiffCol = numCols; // set column limiting for grid updates
    00622
    00623     while ( numDiff > 0 )
    00624     {
    00625         numCurDiffCol--;
    00626         numRows[numCurDiffCol]++; // add extra rows to column grid
    00627
    00628         if ( numCurDiffCol < 1 )
    00629             numCurDiffCol = numCols; // rotate through the grid
    00630
    00631         numDiff--;
    00632     }
    00633
    00634     numCurCol = 0;
    00635     int numCurRow = 0;
    00636     int curX = 0;
    00637     int curY = 0;
    00638
    00639     // the following code will size everything based on my grid above
    00640     // there is no limit to the number of windows it will handle
    00641     // it's great when a kick-ass theory works!!!                      // Pragma :)
    00642     int xQuantum = width() / numCols;
    00643     int yQuantum = height() / numRows[numCurCol];
    00644     QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00645     for ( ; ( *it ); ++it )
    00646     {
    00647         KMdiChildFrm* child = ( *it );
    00648         if ( child->state() != KMdiChildFrm::Minimized )
    00649         {
    00650             if ( child->state() == KMdiChildFrm::Maximized )
    00651                 child->restorePressed();
    00652
    00653             child->setGeometry( curX, curY, xQuantum, yQuantum );
    00654             numCurRow++;
    00655             curY += yQuantum;
    00656
    00657             if ( numCurRow == numRows[numCurCol] )
    00658             {
    00659                 numCurRow = 0;
    00660                 numCurCol++;
    00661                 curY = 0;
    00662                 curX += xQuantum;
    00663                 if ( numCurCol != numCols )
    00664                     yQuantum = height() / numRows[ numCurCol ];
    00665             }
    00666         }
    00667     }
    00668
    00669     delete[] numRows;
    00670
    00671     if ( topChildWindow )
    00672         topChildWindow->m_pClient->activate();
    00673 }
    00674
    00675
    00676 void KMdiChildArea::tileVertically()
    00677 {
    00678     KMdiChildFrm * topChildWindow = topChild();
    00679     int numVisible = getVisibleChildCount(); // count visible windows
    00680     if ( numVisible < 1 )
    00681         return ;
    00682
    00683     int w = width() / numVisible;
    00684     int lastWidth = 0;
    00685
    00686     if ( numVisible > 1 )
    00687         lastWidth = width() - ( w * ( numVisible - 1 ) );
    00688     else
    00689         lastWidth = w;
    00690
    00691     int h = height();
    00692     int posX = 0;
    00693     int countVisible = 0;
    00694
    00695     QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00696     for ( ; ( *it ); ++it )
    00697     {
    00698         KMdiChildFrm* child = ( *it );
    00699         if ( child->state() != KMdiChildFrm::Minimized )
    00700         {
    00701             if ( child->state() == KMdiChildFrm::Maximized )
    00702                 child->restorePressed();
    00703
    00704             countVisible++;
    00705
    00706             if ( countVisible < numVisible )
    00707             {
    00708                 child->setGeometry( posX, 0, w, h );
    00709                 posX += w;
    00710             }
    00711             else
    00712             { // last visible childframe
    00713                 child->setGeometry( posX, 0, lastWidth, h );
    00714             }
    00715         }
    00716     }
    00717
    00718     if ( topChildWindow )
    00719         topChildWindow->m_pClient->activate();
    00720 }
    00721
    00722
    00723 void KMdiChildArea::layoutMinimizedChildren()
    00724 {
    00725     int posX = 0;
    00726     int posY = height();
    00727     QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00728     for ( ; ( *it ); ++it )
    00729     {
    00730         KMdiChildFrm* child = *( it );
    00731         if ( child->state() == KMdiChildFrm::Minimized )
    00732         {
    00733
    00734             if ( ( posX > 0 ) && ( posX + child->width() > width() ) )
    00735             {
    00736                 posX = 0;
    00737                 posY -= child->height();
    00738             }
    00739
    00740             child->move( posX, posY - child->height() );
    00741             posX = child->geometry().right();
    00742         }
    00743     }
    00744 }
    00745
    00746
    00747 void KMdiChildArea::setMdiCaptionFont( const QFont& fnt )
    00748 {
    00749     m_captionFont = fnt;
    00750     QFontMetrics fm( m_captionFont );
    00751     m_captionFontLineSpacing = fm.lineSpacing();
    00752
    00753     QPtrListIterator<KMdiChildFrm> it( *m_pZ );
    00754     for ( ; ( *it ); ++it )
    00755         ( *it )->doResize();
    00756
    00757 }
    00758
    00759 void KMdiChildArea::setMdiCaptionActiveForeColor( const QColor& clr )
    00760 {
    00761     m_captionActiveForeColor = clr;
    00762 }
    00763
    00764 void KMdiChildArea::setMdiCaptionActiveBackColor( const QColor& clr )
    00765 {
    00766     m_captionActiveBackColor = clr;
    00767 }
    00768
    00769 void KMdiChildArea::setMdiCaptionInactiveForeColor( const QColor& clr )
    00770 {
    00771     m_captionInactiveForeColor = clr;
    00772 }
    00773
    00774 void KMdiChildArea::setMdiCaptionInactiveBackColor( const QColor& clr )
    00775 {
    00776     m_captionInactiveBackColor = clr;
    00777 }
    00778
    00779 //KDE4: remove
    00780 void KMdiChildArea::getCaptionColors( const QPalette& /*pal*/, QColor& activeBG,
    00781                                       QColor& activeFG, QColor& inactiveBG, QColor& inactiveFG )
    00782 {
    00783     activeBG = KGlobalSettings::activeTitleColor();
    00784     activeFG = KGlobalSettings::activeTextColor();
    00785     inactiveBG = KGlobalSettings::inactiveTitleColor();
    00786     inactiveFG = KGlobalSettings::inactiveTextColor();
    00787 }
    00788
    00789 // kate: space-indent off; replace-tabs off; tab-width 4; indent-mode csands;

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