Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdewebdev@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 789 insertions, 0 deletions

diff --git a/lib/compatibility/kmdi/qextmdi/kmdichildarea.cpp b/lib/compatibility/kmdi/qextmdi/kmdichildarea.cpp
new file mode 100644
index 00000000..8074dac4
--- /dev/null
+++ b/lib/compatibility/kmdi/qextmdi/kmdichildarea.cpp
@@ -0,0 +1,789 @@
+//----------------------------------------------------------------------------
+//    filename             : kmdichildarea.cpp
+//----------------------------------------------------------------------------
+//    Project              : KDE MDI extension
+//
+//    begin                : 07/1999       by Szymon Stefanek as part of kvirc
+//                                         (an IRC application)
+//    changes              : 09/1999       by Falk Brettschneider to create an
+//                           - 06/2000     stand-alone Qt extension set of
+//                                         classes and a Qt-based library
+//                           2000-2003     maintained by the KDevelop project
+//
+//    copyright            : (C) 1999-2003 by Szymon Stefanek ([email protected])
+//                                         and
+//                                         Falk Brettschneider
+//    email                :  [email protected] (Falk Brettschneider)
+//----------------------------------------------------------------------------
+//
+//----------------------------------------------------------------------------
+//
+//    This program is free software; you can redistribute it and/or modify
+//    it under the terms of the GNU Library General Public License as
+//    published by the Free Software Foundation; either version 2 of the
+//    License, or (at your option) any later version.
+//
+//----------------------------------------------------------------------------
+
+#include "kmdichildarea.h"
+#include "kmdichildarea.moc"
+
+#include "kmdidefines.h"
+
+#include <kconfig.h>
+#include <kdebug.h>
+#include <kglobal.h>
+#include <kglobalsettings.h>
+
+#include <math.h>
+#include <qpopupmenu.h>
+
+
+///////////////////////////////////////////////////////////////////////////////
+// KMdiChildArea
+///////////////////////////////////////////////////////////////////////////////
+
+//============ KMdiChildArea ============//
+
+KMdiChildArea::KMdiChildArea( QWidget *parent )
+		: QFrame( parent, "kmdi_childarea" )
+{
+	setFrameStyle( QFrame::Panel | QFrame::Sunken );
+	m_captionFont = QFont();
+	QFontMetrics fm( m_captionFont );
+	m_captionFontLineSpacing = fm.lineSpacing();
+	m_captionActiveBackColor = KGlobalSettings::activeTitleColor();
+	m_captionActiveForeColor = KGlobalSettings::activeTextColor();
+	m_captionInactiveBackColor = KGlobalSettings::inactiveTitleColor();
+	m_captionInactiveForeColor = KGlobalSettings::inactiveTextColor();
+	m_pZ = new QPtrList<KMdiChildFrm>;
+	m_pZ->setAutoDelete( true );
+	setFocusPolicy( ClickFocus );
+	m_defaultChildFrmSize = QSize( 400, 300 );
+}
+
+
+KMdiChildArea::~KMdiChildArea()
+{
+	delete m_pZ; //This will destroy all the widgets inside.
+}
+
+
+void KMdiChildArea::manageChild( KMdiChildFrm* child, bool show, bool cascade )
+{
+	kdDebug( 760 ) << k_funcinfo << "Adding child " << child << " to be managed" << endl;
+	KMdiChildFrm* top = topChild();
+	
+	//remove old references. There can be more than one so we remove them all
+	if ( m_pZ->findRef( child ) != -1 )
+	{
+		//QPtrList::find* moves current() to the found item
+		m_pZ->take(); 
+		while ( m_pZ->findNextRef( child ) != -1 )
+			m_pZ->take();
+	}
+
+	if ( show )
+		m_pZ->append( child ); //visible -> first in the Z order
+	else
+		m_pZ->insert( 0, child ); //hidden -> last in the Z order
+
+	if ( cascade )
+		child->move( getCascadePoint( m_pZ->count() - 1 ) );
+	
+	if ( show )
+	{
+		if ( top && top->state() == KMdiChildFrm::Maximized )
+		{
+			kdDebug( 760 ) << k_funcinfo << "Maximizing the new child" << endl;
+			emit sysButtonConnectionsMustChange( top, child );
+			top->setState( KMdiChildFrm::Normal, false /*animate*/ );
+			child->setState( KMdiChildFrm::Maximized, false /*animate*/ );
+		}
+		child->show();
+		focusTopChild();
+	}
+}
+
+
+void KMdiChildArea::destroyChild( KMdiChildFrm *child, bool focusTop )
+{
+	kdDebug( 760 ) << k_funcinfo << "Removing child " << child->caption() << endl;
+	bool wasMaximized = ( child->state() == KMdiChildFrm::Maximized );
+
+	// destroy the old one
+	QObject::disconnect( child );
+	child->blockSignals( true );
+	m_pZ->setAutoDelete( false );
+	m_pZ->removeRef( child );
+
+	// focus the next new childframe
+	KMdiChildFrm* newTopChild = topChild();
+	if ( wasMaximized )
+	{
+		if ( newTopChild )
+		{
+			newTopChild->setState( KMdiChildFrm::Maximized, false );
+			emit sysButtonConnectionsMustChange( child, newTopChild );
+		}
+		else
+			emit noMaximizedChildFrmLeft( child ); // last childframe removed
+	}
+	
+	delete child;
+	m_pZ->setAutoDelete( true );
+
+	if ( focusTop )
+		focusTopChild();
+}
+
+
+void KMdiChildArea::destroyChildButNotItsView( KMdiChildFrm* child, bool focusTop )
+{
+	kdDebug( 760 ) << k_funcinfo << "Removing child " << child->caption() << endl;
+	bool wasMaximized = ( child->state() == KMdiChildFrm::Maximized );
+
+	// destroy the old one
+	QObject::disconnect( child );
+	child->unsetClient();
+	m_pZ->setAutoDelete( false );
+	m_pZ->removeRef( child );
+
+	// focus the next new childframe
+	KMdiChildFrm* newTopChild = topChild();
+	if ( wasMaximized )
+	{
+		if ( newTopChild )
+		{
+			newTopChild->setState( KMdiChildFrm::Maximized, false );
+			emit sysButtonConnectionsMustChange( child, newTopChild );
+		}
+		else
+			emit noMaximizedChildFrmLeft( child ); // last childframe removed
+	}
+	delete child;
+	m_pZ->setAutoDelete( true );
+
+	if ( focusTop )
+		focusTopChild();
+}
+
+void KMdiChildArea::setTopChild( KMdiChildFrm* child, bool /* bSetFocus */ )
+{
+	if ( !child )
+		return;
+	
+	if ( topChild() != child )
+	{
+		kdDebug( 760 ) << k_funcinfo << "Setting " << child->caption() << " as the new top child" << endl;
+		m_pZ->setAutoDelete( false );
+		if ( child )
+			m_pZ->removeRef( child );
+		m_pZ->setAutoDelete( true );
+		
+		//disable the labels of all the other children
+		QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+		for ( ; ( *it ); ++it )
+			( *it )->m_pCaption->setActive( false );
+		
+		KMdiChildFrm* maximizedChild = topChild();
+		bool topChildMaximized = false;
+		if ( maximizedChild && maximizedChild->state() == KMdiChildFrm::Maximized )
+			topChildMaximized = true;
+		
+		m_pZ->append( child );
+		
+		int nChildAreaMinW = 0, nChildAreaMinH = 0;
+		int nChildAreaMaxW = QWIDGETSIZE_MAX, nChildAreaMaxH = QWIDGETSIZE_MAX;
+		if ( topChildMaximized && child->m_pClient )
+		{
+			//the former top child is maximized, so maximize the new one
+			nChildAreaMinW = child->m_pClient->minimumWidth();
+			nChildAreaMinH = child->m_pClient->minimumHeight();
+			/// @todo: setting the maximum size doesn't work properly - fix this later
+			// nChildAreaMaxW = child->m_pClient->maximumWidth();
+			// nChildAreaMaxH = child->m_pClient->maximumHeight();
+		}
+		
+		//set the min and max sizes of this child area to the new top child
+		setMinimumSize( nChildAreaMinW, nChildAreaMinH );
+		setMaximumSize( nChildAreaMaxW, nChildAreaMaxH );
+		
+		if ( topChildMaximized )
+		{   //maximize the new view and restore the old
+			child->setState( KMdiChildFrm::Maximized, false /*animate*/);
+			maximizedChild->setState( KMdiChildFrm::Normal, false /*animate*/ );
+			emit sysButtonConnectionsMustChange( maximizedChild, child );
+		}
+		else
+			child->raise();
+		
+		QFocusEvent::setReason( QFocusEvent::Other );
+		child->m_pClient->setFocus();
+	}
+}
+
+
+void KMdiChildArea::resizeEvent( QResizeEvent* e )
+{
+	//If we have a maximized children at the top , adjust its size
+	KMdiChildFrm* child = topChild();
+	if ( child && child->state() == KMdiChildFrm::Maximized  )
+	{
+		int clientw = 0, clienth = 0;
+		if ( child->m_pClient != 0L )
+		{
+			clientw = child->m_pClient->width();
+			clienth = child->m_pClient->height();
+		}
+		child->resize( width() + KMDI_CHILDFRM_DOUBLE_BORDER,
+		               height() + child->m_pCaption->heightHint() + KMDI_CHILDFRM_SEPARATOR + KMDI_CHILDFRM_DOUBLE_BORDER );
+
+	}
+	layoutMinimizedChildren();
+	QWidget::resizeEvent( e );
+}
+
+//=============== mousePressEvent =============//
+
+void KMdiChildArea::mousePressEvent( QMouseEvent *e )
+{
+	//Popup the window menu
+	if ( e->button() & RightButton )
+		emit popupWindowMenu( mapToGlobal( e->pos() ) );
+}
+
+//=============== getCascadePoint ============//
+
+QPoint KMdiChildArea::getCascadePoint( int indexOfWindow )
+{
+	if ( indexOfWindow < 0 )
+	{
+		indexOfWindow = m_pZ->count(); //use the window count
+		kdDebug( 760 ) << k_funcinfo << "indexOfWindow was less than zero, using "
+			<< indexOfWindow << " as new index" << endl;
+	}
+
+	QPoint pnt( 0, 0 );
+	if ( indexOfWindow == 0 )
+	{
+		kdDebug( 760 ) << k_funcinfo << "No windows. Returning QPoint( 0, 0 ) as the cascade point" << endl;
+		return pnt;
+	}
+
+	bool topLevelMode = false;
+	if ( height() == 1 ) 	// hacky?!
+		topLevelMode = true;
+
+	kdDebug( 760 ) << k_funcinfo << "Getting the cascade point for window index " << indexOfWindow << endl;
+	kdDebug( 760 ) << k_funcinfo << "Do we think we're in top level mode? " << topLevelMode << endl;
+	
+	KMdiChildFrm* child = m_pZ->first();
+	
+	//default values
+	int step = 20;
+	int h = ( topLevelMode ? QApplication::desktop()->height() : height() );
+	int w = ( topLevelMode ? QApplication::desktop()->width() : width() );
+	
+	int availableHeight = h - m_defaultChildFrmSize.height();
+	int availableWidth = w - m_defaultChildFrmSize.width();
+	int ax = 0;
+	int ay = 0;
+	
+	if ( child )
+	{
+		kdDebug( 760 ) << k_funcinfo << "child frame exists. resetting height and width values" << endl;
+		step = child->m_pCaption->heightHint() + KMDI_CHILDFRM_BORDER;
+		availableHeight = h - child->minimumHeight();
+		availableWidth = w - child->minimumWidth();
+	}
+	
+	for ( int i = 0; i < indexOfWindow; i++ )
+	{
+		ax += step;
+		ay += step;
+		
+		//do some bounds checking, because to not do it would be bad.
+		if ( ax > availableWidth )
+			ax = 0;
+
+		if ( ay > availableHeight )
+			ay = 0;
+	}
+	pnt.setX( ax );
+	pnt.setY( ay );
+	return pnt;
+}
+
+
+void KMdiChildArea::childMinimized( KMdiChildFrm *minimizedChild, bool wasMaximized )
+{
+	//can't find the child in our list, so we don't care.
+	if ( m_pZ->findRef( minimizedChild ) == -1 )
+	{
+		kdDebug( 760 ) << k_funcinfo << "child was minimized but wasn't in our list!" << endl;
+		return;
+	}
+	
+	kdDebug( 760 ) << k_funcinfo << endl;
+	if ( m_pZ->count() > 1 )
+	{
+		//move the minimized child to the bottom
+		m_pZ->setAutoDelete( false );
+		m_pZ->removeRef( minimizedChild );
+		m_pZ->setAutoDelete( true );
+		m_pZ->insert( 0, minimizedChild );
+		
+		if ( wasMaximized )
+		{ // Need to maximize the new top child
+			kdDebug( 760 ) << k_funcinfo << "child just minimized from maximized state. maximize new top child" << endl;
+			minimizedChild = topChild();
+			if ( !minimizedChild )
+				return; //??
+			
+			if ( minimizedChild->state() == KMdiChildFrm::Maximized )
+				return; //it's already maximized
+			
+			minimizedChild->setState( KMdiChildFrm::Maximized, false ); //do not animate the change
+		}
+		focusTopChild();
+	}
+	else
+		setFocus(); //Remove focus from the child. We only have one window
+}
+
+void KMdiChildArea::focusTopChild()
+{
+	KMdiChildFrm* lastChild = topChild();
+	if ( !lastChild )
+	{
+		kdDebug( 760 ) << k_funcinfo << "No more child windows left" << endl;
+		emit lastChildFrmClosed();
+		return;
+	}
+
+	if ( !lastChild->m_pClient->hasFocus() )
+	{
+		//disable the labels of all the other children
+		QPtrListIterator<KMdiChildFrm> it ( *m_pZ );
+		for ( ; ( *it ); ++it )
+		{
+			if ( ( *it ) != lastChild )
+				( *it )->m_pCaption->setActive( false );
+		}
+
+		kdDebug( 760 ) << k_funcinfo << "Giving focus to " << lastChild->caption() << endl;
+		lastChild->raise();
+		lastChild->m_pClient->activate();
+	}
+
+}
+
+void KMdiChildArea::cascadeWindows()
+{
+	kdDebug( 760 ) << k_funcinfo << "cascading windows but not changing their size" << endl;
+	int idx = 0;
+	QPtrList<KMdiChildFrm> list( *m_pZ );
+	list.setAutoDelete( false );
+	while ( !list.isEmpty() )
+	{
+		KMdiChildFrm* childFrm = list.first();
+		if ( childFrm->state() != KMdiChildFrm::Minimized )
+		{
+			if ( childFrm->state() == KMdiChildFrm::Maximized )
+				childFrm->restorePressed();
+			
+			childFrm->move( getCascadePoint( idx ) );
+			idx++;
+		}
+		list.removeFirst();
+	}
+	focusTopChild();
+}
+
+void KMdiChildArea::cascadeMaximized()
+{
+	kdDebug( 760 ) << k_funcinfo << "cascading windows. will make sure they are minimum sized" << endl;
+	int idx = 0;
+	QPtrList<KMdiChildFrm> list( *m_pZ );
+
+	list.setAutoDelete( false );
+	while ( !list.isEmpty() )
+	{
+		KMdiChildFrm* childFrm = list.first();
+		if (childFrm->state() != KMdiChildFrm::Minimized )
+		{
+			if (childFrm->state() == KMdiChildFrm::Maximized )
+				childFrm->restorePressed();
+			
+			QPoint pnt( getCascadePoint( idx ) );
+			childFrm->move( pnt );
+			QSize curSize( width() - pnt.x(), height() - pnt.y() );
+			
+			if ( ( childFrm->minimumSize().width() > curSize.width() ) ||
+			     ( childFrm->minimumSize().height() > curSize.height() ) )
+			{
+				childFrm->resize( childFrm->minimumSize() );
+			}
+			else
+				childFrm->resize( curSize );
+			
+			idx++;
+		}
+		list.removeFirst();
+	}
+	focusTopChild();
+}
+
+void KMdiChildArea::expandVertical()
+{
+	kdDebug( 760 ) << k_funcinfo << "expanding all child frames vertically" << endl;
+	int idx = 0;
+	QPtrList<KMdiChildFrm> list( *m_pZ );
+	list.setAutoDelete( false );
+	while ( !list.isEmpty() )
+	{
+		KMdiChildFrm* childFrm = list.first();
+		if ( childFrm->state() != KMdiChildFrm::Minimized )
+		{
+			if ( childFrm->state() == KMdiChildFrm::Maximized )
+				childFrm->restorePressed();
+			
+			childFrm->setGeometry( childFrm->x(), 0, childFrm->width(), height() );
+			idx++;
+		}
+		list.removeFirst();
+	}
+	focusTopChild();
+}
+
+void KMdiChildArea::expandHorizontal()
+{
+	kdDebug( 760 ) << k_funcinfo << "expanding all child frames horizontally" << endl;
+	int idx = 0;
+	QPtrList<KMdiChildFrm> list( *m_pZ );
+	list.setAutoDelete( false );
+	while ( !list.isEmpty() )
+	{
+		KMdiChildFrm* childFrm = list.first();
+		if ( childFrm->state() != KMdiChildFrm::Minimized )
+		{
+			if ( childFrm->state() == KMdiChildFrm::Maximized )
+				childFrm->restorePressed();
+			
+			childFrm->setGeometry( 0, childFrm->y(), width(), childFrm->height() );
+			idx++;
+		}
+		list.removeFirst();
+	}
+	focusTopChild();
+}
+
+int KMdiChildArea::getVisibleChildCount() const
+{
+	int visibleChildCount = 0;
+	QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+	for ( ; ( *it ); ++it )
+	{
+		if ( ( *it )->state() != KMdiChildFrm::Minimized && ( *it )->isVisible() )
+			visibleChildCount++;
+	}
+	return visibleChildCount;
+}
+
+void KMdiChildArea::tilePragma()
+{
+	kdDebug( 760 ) << k_funcinfo << endl;
+	tileAllInternal( 9 );
+}
+
+void KMdiChildArea::tileAllInternal( int maxWnds )
+{
+	kdDebug( 760 ) << k_funcinfo << endl;
+	//NUM WINDOWS =           1,2,3,4,5,6,7,8,9
+	static int colstable[ 9 ] = { 1, 1, 1, 2, 2, 2, 3, 3, 3 }; //num columns
+	static int rowstable[ 9 ] = { 1, 2, 3, 2, 3, 3, 3, 3, 3 }; //num rows
+	static int lastwindw[ 9 ] = { 1, 1, 1, 1, 2, 1, 3, 2, 1 }; //last window multiplier
+	static int colrecall[ 9 ] = { 0, 0, 0, 3, 3, 3, 6, 6, 6 }; //adjust self
+	static int rowrecall[ 9 ] = { 0, 0, 0, 0, 4, 4, 4, 4, 4 }; //adjust self
+
+	int numVisible = getVisibleChildCount();
+	if ( numVisible < 1 )
+	{
+		kdDebug( 760 ) << k_funcinfo << "No visible child windows to tile" << endl;
+		return;
+	}
+
+	KMdiChildFrm *tcw = topChild();
+	int numToHandle = ( ( numVisible > maxWnds ) ? maxWnds : numVisible );
+	
+	int xQuantum = width() / colstable[ numToHandle - 1 ];
+	int widthToCompare;
+	
+	if ( tcw->minimumWidth() > m_defaultChildFrmSize.width() )
+		widthToCompare = tcw->minimumWidth();
+	else
+		widthToCompare = m_defaultChildFrmSize.width();
+	
+	if ( xQuantum < widthToCompare )
+	{
+		if ( colrecall[ numToHandle - 1 ] != 0 )
+		{
+			tileAllInternal( colrecall[ numToHandle - 1 ] );
+			return ;
+		}
+	}
+	
+	int yQuantum = height() / rowstable[ numToHandle - 1 ];
+	int heightToCompare;
+	if ( tcw->minimumHeight() > m_defaultChildFrmSize.height() )
+		heightToCompare = tcw->minimumHeight();
+	else
+		heightToCompare = m_defaultChildFrmSize.height();
+		
+	if ( yQuantum < heightToCompare )
+	{
+		if ( rowrecall[ numToHandle - 1 ] != 0 )
+		{
+			tileAllInternal( rowrecall[ numToHandle - 1 ] );
+			return ;
+		}
+	}
+	int curX = 0;
+	int curY = 0;
+	int curRow = 1;
+	int curCol = 1;
+	int curWin = 1;
+	
+	QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+	for ( ; ( *it ); ++it )
+	{
+		KMdiChildFrm* child = ( *it );
+		if ( child->state() != KMdiChildFrm::Minimized )
+		{
+			//restore the window
+			if ( child->state() == KMdiChildFrm::Maximized )
+				child->restorePressed();
+			
+			if ( ( curWin % numToHandle ) == 0 )
+				child->setGeometry( curX, curY, xQuantum * lastwindw[ numToHandle - 1 ], yQuantum );
+			else
+				child->setGeometry( curX, curY, xQuantum, yQuantum );
+			
+			//example : 12 windows : 3 cols 3 rows
+			if ( curCol < colstable[ numToHandle - 1 ] )
+			{ //curCol<3
+				curX += xQuantum; //add a column in the same row
+				curCol++;         //increase current column
+			}
+			else
+			{
+				curX = 0;         //new row
+				curCol = 1;       //column 1
+				if ( curRow < rowstable[ numToHandle - 1 ] )
+				{ //curRow<3
+					curY += yQuantum; //add a row
+					curRow++;         //increase current row
+				}
+				else
+				{
+					curY = 0;         //restart from beginning
+					curRow = 1;       //reset current row
+				}
+			}
+			curWin++;
+		}
+	}
+	
+	if ( tcw )
+		tcw->m_pClient->activate();
+}
+
+void KMdiChildArea::tileAnodine()
+{
+	KMdiChildFrm * topChildWindow = topChild();
+	int numVisible = getVisibleChildCount(); // count visible windows
+	if ( numVisible < 1 )
+		return ;
+	
+	int numCols = int( sqrt( ( double ) numVisible ) ); // set columns to square root of visible count
+	// create an array to form grid layout
+	int *numRows = new int[ numCols ];
+	int numCurCol = 0;
+	
+	while ( numCurCol < numCols )
+	{
+		numRows[numCurCol] = numCols; // create primary grid values
+		numCurCol++;
+	}
+	
+	int numDiff = numVisible - ( numCols * numCols ); // count extra rows
+	int numCurDiffCol = numCols; // set column limiting for grid updates
+	
+	while ( numDiff > 0 )
+	{
+		numCurDiffCol--;
+		numRows[numCurDiffCol]++; // add extra rows to column grid
+		
+		if ( numCurDiffCol < 1 )
+			numCurDiffCol = numCols; // rotate through the grid
+		
+		numDiff--;
+	}
+	
+	numCurCol = 0;
+	int numCurRow = 0;
+	int curX = 0;
+	int curY = 0;
+	
+	// the following code will size everything based on my grid above
+	// there is no limit to the number of windows it will handle
+	// it's great when a kick-ass theory works!!!                      // Pragma :)
+	int xQuantum = width() / numCols;
+	int yQuantum = height() / numRows[numCurCol];
+	QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+	for ( ; ( *it ); ++it )
+	{
+		KMdiChildFrm* child = ( *it );
+		if ( child->state() != KMdiChildFrm::Minimized )
+		{
+			if ( child->state() == KMdiChildFrm::Maximized )
+				child->restorePressed();
+			
+			child->setGeometry( curX, curY, xQuantum, yQuantum );
+			numCurRow++;
+			curY += yQuantum;
+			
+			if ( numCurRow == numRows[numCurCol] )
+			{
+				numCurRow = 0;
+				numCurCol++;
+				curY = 0;
+				curX += xQuantum;
+				if ( numCurCol != numCols )
+					yQuantum = height() / numRows[ numCurCol ];
+			}
+		}
+	}
+	
+	delete[] numRows;
+	
+	if ( topChildWindow )
+		topChildWindow->m_pClient->activate();
+}
+
+
+void KMdiChildArea::tileVertically()
+{
+	KMdiChildFrm * topChildWindow = topChild();
+	int numVisible = getVisibleChildCount(); // count visible windows
+	if ( numVisible < 1 )
+		return ;
+
+	int w = width() / numVisible;
+	int lastWidth = 0;
+	
+	if ( numVisible > 1 )
+		lastWidth = width() - ( w * ( numVisible - 1 ) );
+	else
+		lastWidth = w;
+	
+	int h = height();
+	int posX = 0;
+	int countVisible = 0;
+
+	QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+	for ( ; ( *it ); ++it )
+	{
+		KMdiChildFrm* child = ( *it );
+		if ( child->state() != KMdiChildFrm::Minimized )
+		{
+			if ( child->state() == KMdiChildFrm::Maximized )
+				child->restorePressed();
+			
+			countVisible++;
+			
+			if ( countVisible < numVisible )
+			{
+				child->setGeometry( posX, 0, w, h );
+				posX += w;
+			}
+			else
+			{ // last visible childframe
+				child->setGeometry( posX, 0, lastWidth, h );
+			}
+		}
+	}
+	
+	if ( topChildWindow )
+		topChildWindow->m_pClient->activate();
+}
+
+
+void KMdiChildArea::layoutMinimizedChildren()
+{
+	int posX = 0;
+	int posY = height();
+	QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+	for ( ; ( *it ); ++it )
+	{
+		KMdiChildFrm* child = *( it );
+		if ( child->state() == KMdiChildFrm::Minimized )
+		{
+			
+			if ( ( posX > 0 ) && ( posX + child->width() > width() ) )
+			{
+				posX = 0;
+				posY -= child->height();
+			}
+			
+			child->move( posX, posY - child->height() );
+			posX = child->geometry().right();
+		}
+	}
+}
+
+
+void KMdiChildArea::setMdiCaptionFont( const QFont& fnt )
+{
+	m_captionFont = fnt;
+	QFontMetrics fm( m_captionFont );
+	m_captionFontLineSpacing = fm.lineSpacing();
+
+	QPtrListIterator<KMdiChildFrm> it( *m_pZ );
+	for ( ; ( *it ); ++it )
+		( *it )->doResize();
+
+}
+
+void KMdiChildArea::setMdiCaptionActiveForeColor( const QColor& clr )
+{
+	m_captionActiveForeColor = clr;
+}
+
+void KMdiChildArea::setMdiCaptionActiveBackColor( const QColor& clr )
+{
+	m_captionActiveBackColor = clr;
+}
+
+void KMdiChildArea::setMdiCaptionInactiveForeColor( const QColor& clr )
+{
+	m_captionInactiveForeColor = clr;
+}
+
+void KMdiChildArea::setMdiCaptionInactiveBackColor( const QColor& clr )
+{
+	m_captionInactiveBackColor = clr;
+}
+
+//KDE4: remove
+void KMdiChildArea::getCaptionColors( const QPalette& /*pal*/, QColor& activeBG,
+                                      QColor& activeFG, QColor& inactiveBG, QColor& inactiveFG )
+{
+	activeBG = KGlobalSettings::activeTitleColor();
+	activeFG = KGlobalSettings::activeTextColor();
+	inactiveBG = KGlobalSettings::inactiveTitleColor();
+	inactiveFG = KGlobalSettings::inactiveTextColor();
+}
+
+// kate: space-indent off; replace-tabs off; tab-width 4; indent-mode csands;