Add Qt3 development HEAD version

24 files changed, 18866 insertions, 0 deletions

diff --git a/main/dependencies/qt3/src/dialogs/qcolordialog.cpp b/main/dependencies/qt3/src/dialogs/qcolordialog.cpp
new file mode 100644
index 000000000..44bf70e35
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qcolordialog.cpp
@@ -0,0 +1,1659 @@
+/****************************************************************************
+**
+** Implementation of QColorDialog class
+**
+** Created : 990222
+**
+** Copyright (C) 1999-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qcolordialog.h"
+
+#ifndef QT_NO_COLORDIALOG
+
+#include "qpainter.h"
+#include "qlayout.h"
+#include "qlabel.h"
+#include "qpushbutton.h"
+#include "qlineedit.h"
+#include "qimage.h"
+#include "qpixmap.h"
+#include "qdrawutil.h"
+#include "qvalidator.h"
+#include "qdragobject.h"
+#include "qgridview.h"
+#include "qapplication.h"
+#include "qstyle.h"
+#include "qsettings.h"
+#include "qpopupmenu.h"
+
+#ifdef Q_WS_MAC
+QRgb macGetRgba( QRgb initial, bool *ok, QWidget *parent, const char* name );
+QColor macGetColor( const QColor& initial, QWidget *parent, const char *name );
+#endif
+
+//////////// QWellArray BEGIN
+
+struct QWellArrayData;
+
+class QWellArray : public QGridView
+{
+    Q_OBJECT
+    Q_PROPERTY( int selectedColumn READ selectedColumn )
+    Q_PROPERTY( int selectedRow READ selectedRow )
+
+public:
+    QWellArray( QWidget* parent=0, const char* name=0, bool popup = FALSE );
+
+    ~QWellArray() {}
+    QString cellContent( int row, int col ) const;
+    // ### Paul !!! virtual void setCellContent( int row, int col, const QString &);
+
+    int selectedColumn() const { return selCol; }
+    int selectedRow() const { return selRow; }
+
+    virtual void setCurrent( int row, int col );
+    virtual void setSelected( int row, int col );
+
+    QSize sizeHint() const;
+
+    virtual void setCellBrush( int row, int col, const QBrush & );
+    QBrush cellBrush( int row, int col );
+
+signals:
+    void selected( int row, int col );
+
+protected:
+    void dimensionChange( int oldRows, int oldCols );
+
+    virtual void paintCell( QPainter *, int row, int col );
+    virtual void paintCellContents( QPainter *, int row, int col, const QRect& );
+
+    void mousePressEvent( QMouseEvent* );
+    void mouseReleaseEvent( QMouseEvent* );
+    void mouseMoveEvent( QMouseEvent* );
+    void keyPressEvent( QKeyEvent* );
+    void focusInEvent( QFocusEvent* );
+    void focusOutEvent( QFocusEvent* );
+
+private:
+    int curRow;
+    int curCol;
+    int selRow;
+    int selCol;
+    bool smallStyle;
+    QWellArrayData *d;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QWellArray( const QWellArray & );
+    QWellArray& operator=( const QWellArray & );
+#endif
+};
+
+
+
+// non-interface ...
+
+
+
+struct QWellArrayData {
+    QBrush *brush;
+};
+
+/*!
+    \internal
+    \class QWellArray qwellarray_p.h
+    \brief The QWellArray class provides a well array.
+
+
+    \ingroup advanced
+*/
+
+QWellArray::QWellArray( QWidget *parent, const char * name, bool popup )
+    : QGridView( parent, name,
+		 (popup ? (WStyle_Customize|WStyle_Tool|WStyle_NoBorder) : 0 ) )
+{
+    d = 0;
+    setFocusPolicy( StrongFocus );
+    setVScrollBarMode(AlwaysOff);
+    setHScrollBarMode(AlwaysOff);
+    viewport()->setBackgroundMode( PaletteBackground );
+    setNumCols( 7 );
+    setNumRows( 7 );
+    setCellWidth( 24 );
+    setCellHeight( 21 );
+    smallStyle = popup;
+
+    if ( popup ) {
+	setCellWidth( 18 );
+	setCellHeight( 18 );
+	setFrameStyle(QFrame::StyledPanel | QFrame::Raised);
+	setMargin( 1 );
+	setLineWidth( 2 );
+    } else {
+	setFrameStyle( QFrame::NoFrame );
+    }
+    curCol = 0;
+    curRow = 0;
+    selCol = -1;
+    selRow = -1;
+
+    if ( smallStyle )
+	setMouseTracking( TRUE );
+}
+
+
+QSize QWellArray::sizeHint() const
+{
+    constPolish();
+    QSize s = gridSize().boundedTo( QSize(640, 480 ) );
+    return QSize( s.width() + 2*frameWidth(), s.height() + 2*frameWidth() );
+}
+
+
+void QWellArray::paintCell( QPainter* p, int row, int col )
+{
+    int w = cellWidth();			// width of cell in pixels
+    int h = cellHeight();			// height of cell in pixels
+    int b = 1;
+
+    if ( !smallStyle )
+	b = 3;
+
+    const QColorGroup & g = colorGroup();
+    p->setPen( QPen( black, 0, SolidLine ) );
+    if ( !smallStyle && row ==selRow && col == selCol &&
+	 style().styleHint(QStyle::SH_GUIStyle) != MotifStyle) {
+	int n = 2;
+	p->drawRect( n, n, w-2*n, h-2*n );
+    }
+
+    style().drawPrimitive(QStyle::PE_Panel, p, QRect(b, b, w-2*b, h-2*b), g,
+			  QStyle::Style_Enabled | QStyle::Style_Sunken);
+
+    int t = 0;
+    if (style().styleHint(QStyle::SH_GUIStyle) == MotifStyle)
+	t = ( row == selRow && col == selCol ) ? 2 : 0;
+    b += 2 + t;
+
+    if ( (row == curRow) && (col == curCol) ) {
+	if ( smallStyle ) {
+	    p->setPen ( white );
+	    p->drawRect( 1, 1, w-2, h-2 );
+	    p->setPen ( black );
+	    p->drawRect( 0, 0, w, h );
+	    p->drawRect( 2, 2, w-4, h-4 );
+	    b = 3;
+	} else if ( hasFocus() ) {
+	    style().drawPrimitive(QStyle::PE_FocusRect, p, QRect(0, 0, w, h), g);
+	}
+    }
+    paintCellContents( p, row, col, QRect(b, b, w - 2*b, h - 2*b) );
+}
+
+/*!
+  Reimplement this function to change the contents of the well array.
+ */
+void QWellArray::paintCellContents( QPainter *p, int row, int col, const QRect &r )
+{
+
+    if ( d ) {
+	p->fillRect( r, d->brush[row*numCols()+col] );
+    } else {
+	p->fillRect( r, white );
+	p->setPen( black );
+	p->drawLine( r.topLeft(), r.bottomRight() );
+	p->drawLine( r.topRight(), r.bottomLeft() );
+    }
+}
+
+
+/*\reimp
+*/
+void QWellArray::mousePressEvent( QMouseEvent* e )
+{
+    // The current cell marker is set to the cell the mouse is pressed
+    // in.
+    QPoint pos = e->pos();
+    setCurrent( rowAt( pos.y() ), columnAt( pos.x() ) );
+}
+
+/*\reimp
+*/
+void QWellArray::mouseReleaseEvent( QMouseEvent* )
+{
+    // The current cell marker is set to the cell the mouse is clicked
+    // in.
+    setSelected( curRow, curCol );
+}
+
+
+/*\reimp
+*/
+void QWellArray::mouseMoveEvent( QMouseEvent* e )
+{
+    //   The current cell marker is set to the cell the mouse is
+    //   clicked in.
+    if ( smallStyle ) {
+	QPoint pos = e->pos();
+	setCurrent( rowAt( pos.y() ), columnAt( pos.x() ) );
+    }
+}
+
+/*
+  Sets the cell currently having the focus. This is not necessarily
+  the same as the currently selected cell.
+*/
+
+void QWellArray::setCurrent( int row, int col )
+{
+
+    if ( (curRow == row) && (curCol == col) )
+	return;
+
+    if ( row < 0 || col < 0 )
+	row = col = -1;
+
+    int oldRow = curRow;
+    int oldCol = curCol;
+
+    curRow = row;
+    curCol = col;
+
+    updateCell( oldRow, oldCol );
+    updateCell( curRow, curCol );
+}
+
+
+/*!
+  Sets the currently selected cell to \a row, \a col.  If \a row or \a
+  col are less than zero, the current cell is unselected.
+
+  Does not set the position of the focus indicator.
+*/
+
+void QWellArray::setSelected( int row, int col )
+{
+    if ( (selRow == row) && (selCol == col) )
+	return;
+
+    int oldRow = selRow;
+    int oldCol = selCol;
+
+    if ( row < 0 || col < 0 )
+	row = col = -1;
+
+    selCol = col;
+    selRow = row;
+
+    updateCell( oldRow, oldCol );
+    updateCell( selRow, selCol );
+    if ( row >= 0 )
+	emit selected( row, col );
+
+    if ( isVisible() && ::qt_cast<QPopupMenu*>(parentWidget()) )
+	parentWidget()->close();
+}
+
+
+
+/*!\reimp
+*/
+void QWellArray::focusInEvent( QFocusEvent* )
+{
+    updateCell( curRow, curCol );
+}
+
+
+/*!
+  Sets the size of the well array to be \a rows cells by \a cols.
+  Resets any brush information set by setCellBrush().
+ */
+void QWellArray::dimensionChange( int, int )
+{
+    if ( d ) {
+	if ( d->brush )
+	    delete[] d->brush;
+	delete d;
+	d = 0;
+    }
+}
+
+void QWellArray::setCellBrush( int row, int col, const QBrush &b )
+{
+    if ( !d ) {
+	d = new QWellArrayData;
+	int i = numRows()*numCols();
+	d->brush = new QBrush[i];
+    }
+    if ( row >= 0 && row < numRows() && col >= 0 && col < numCols() )
+	d->brush[row*numCols()+col] = b;
+#ifdef QT_CHECK_RANGE
+    else
+	qWarning( "QWellArray::setCellBrush( %d, %d ) out of range", row, col );
+#endif
+}
+
+
+
+/*!
+  Returns the brush set for the cell at \a row, \a col. If no brush is set,
+  \c NoBrush is returned.
+*/
+
+QBrush QWellArray::cellBrush( int row, int col )
+{
+    if ( d && row >= 0 && row < numRows() && col >= 0 && col < numCols() )
+	return d->brush[row*numCols()+col];
+    return NoBrush;
+}
+
+
+
+/*!\reimp
+*/
+
+void QWellArray::focusOutEvent( QFocusEvent* )
+{
+    updateCell( curRow, curCol );
+}
+
+/*\reimp
+*/
+void QWellArray::keyPressEvent( QKeyEvent* e )
+{
+    switch( e->key() ) {			// Look at the key code
+    case Key_Left:				// If 'left arrow'-key,
+	if( curCol > 0 )			// and cr't not in leftmost col
+	    setCurrent( curRow, curCol - 1);	// set cr't to next left column
+	break;
+    case Key_Right:				// Correspondingly...
+	if( curCol < numCols()-1 )
+	    setCurrent( curRow, curCol + 1);
+	break;
+    case Key_Up:
+	if( curRow > 0 )
+	    setCurrent( curRow - 1, curCol);
+	else if ( smallStyle )
+	    focusNextPrevChild( FALSE );
+	break;
+    case Key_Down:
+	if( curRow < numRows()-1 )
+	    setCurrent( curRow + 1, curCol);
+	else if ( smallStyle )
+	    focusNextPrevChild( TRUE );
+	break;
+    case Key_Space:
+    case Key_Return:
+    case Key_Enter:
+	setSelected( curRow, curCol );
+	break;
+    default:				// If not an interesting key,
+	e->ignore();			// we don't accept the event
+	return;
+    }
+
+}
+
+//////////// QWellArray END
+
+static bool initrgb = FALSE;
+static QRgb stdrgb[6*8];
+static QRgb cusrgb[2*8];
+static bool customSet = FALSE;
+
+
+static void initRGB()
+{
+    if ( initrgb )
+	return;
+    initrgb = TRUE;
+    int i = 0;
+    for ( int g = 0; g < 4; g++ )
+	for ( int r = 0;  r < 4; r++ )
+	    for ( int b = 0; b < 3; b++ )
+		stdrgb[i++] = qRgb( r*255/3, g*255/3, b*255/2 );
+
+    for ( i = 0; i < 2*8; i++ )
+	cusrgb[i] = qRgb(0xff,0xff,0xff);
+}
+
+/*!
+    Returns the number of custom colors supported by QColorDialog. All
+    color dialogs share the same custom colors.
+*/
+int QColorDialog::customCount()
+{
+    return 2*8;
+}
+
+/*!
+    Returns custom color number \a i as a QRgb.
+*/
+QRgb QColorDialog::customColor( int i )
+{
+    initRGB();
+    if ( i < 0 || i >= customCount() ) {
+#ifdef QT_CHECK_RANGE
+	qWarning( "QColorDialog::customColor() index %d out of range", i );
+#endif
+	i = 0;
+    }
+    return cusrgb[i];
+}
+
+/*!
+    Sets custom color number \a i to the QRgb value \a c.
+*/
+void QColorDialog::setCustomColor( int i, QRgb c )
+{
+    initRGB();
+    if ( i < 0 || i >= customCount() ) {
+#ifdef QT_CHECK_RANGE
+	qWarning( "QColorDialog::setCustomColor() index %d out of range", i );
+#endif
+	return;
+    }
+    customSet = TRUE;
+    cusrgb[i] = c;
+}
+
+/*!
+    Sets standard color number \a i to the QRgb value \a c.
+*/
+
+void QColorDialog::setStandardColor( int i, QRgb c )
+{
+    initRGB();
+    if ( i < 0 || i >= 6*8 ) {
+#ifdef QT_CHECK_RANGE
+	qWarning( "QColorDialog::setStandardColor() index %d out of range", i );
+#endif
+	return;
+    }
+    stdrgb[i] = c;
+}
+
+static inline void rgb2hsv( QRgb rgb, int&h, int&s, int&v )
+{
+    QColor c;
+    c.setRgb( rgb );
+    c.getHsv(h,s,v);
+}
+
+class QColorWell : public QWellArray
+{
+public:
+    QColorWell( QWidget *parent, int r, int c, QRgb *vals )
+	:QWellArray( parent, "" ), values( vals ), mousePressed( FALSE ), oldCurrent( -1, -1 )
+    { setNumRows(r), setNumCols(c); setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum) ); }
+
+protected:
+    void paintCellContents( QPainter *, int row, int col, const QRect& );
+    void mousePressEvent( QMouseEvent *e );
+    void mouseMoveEvent( QMouseEvent *e );
+    void mouseReleaseEvent( QMouseEvent *e );
+#ifndef QT_NO_DRAGANDDROP
+    void dragEnterEvent( QDragEnterEvent *e );
+    void dragLeaveEvent( QDragLeaveEvent *e );
+    void dragMoveEvent( QDragMoveEvent *e );
+    void dropEvent( QDropEvent *e );
+#endif
+
+private:
+    QRgb *values;
+    bool mousePressed;
+    QPoint pressPos;
+    QPoint oldCurrent;
+
+};
+
+void QColorWell::paintCellContents( QPainter *p, int row, int col, const QRect &r )
+{
+    int i = row + col*numRows();
+    p->fillRect( r, QColor( values[i] ) );
+}
+
+void QColorWell::mousePressEvent( QMouseEvent *e )
+{
+    oldCurrent = QPoint( selectedRow(), selectedColumn() );
+    QWellArray::mousePressEvent( e );
+    mousePressed = TRUE;
+    pressPos = e->pos();
+}
+
+void QColorWell::mouseMoveEvent( QMouseEvent *e )
+{
+    QWellArray::mouseMoveEvent( e );
+#ifndef QT_NO_DRAGANDDROP
+    if ( !mousePressed )
+	return;
+    if ( ( pressPos - e->pos() ).manhattanLength() > QApplication::startDragDistance() ) {
+	setCurrent( oldCurrent.x(), oldCurrent.y() );
+	int i = rowAt(pressPos.y()) + columnAt(pressPos.x()) * numRows();
+	QColor col( values[ i ] );
+	QColorDrag *drg = new QColorDrag( col, this );
+	QPixmap pix( cellWidth(), cellHeight() );
+	pix.fill( col );
+	QPainter p( &pix );
+	p.drawRect( 0, 0, pix.width(), pix.height() );
+	p.end();
+	drg->setPixmap( pix );
+	mousePressed = FALSE;
+	drg->dragCopy();
+    }
+#endif
+}
+
+#ifndef QT_NO_DRAGANDDROP
+void QColorWell::dragEnterEvent( QDragEnterEvent *e )
+{
+    setFocus();
+    if ( QColorDrag::canDecode( e ) )
+	e->accept();
+    else
+	e->ignore();
+}
+
+void QColorWell::dragLeaveEvent( QDragLeaveEvent * )
+{
+    if ( hasFocus() )
+	parentWidget()->setFocus();
+}
+
+void QColorWell::dragMoveEvent( QDragMoveEvent *e )
+{
+    if ( QColorDrag::canDecode( e ) ) {
+	setCurrent( rowAt( e->pos().y() ), columnAt( e->pos().x() ) );
+	e->accept();
+    } else
+	e->ignore();
+}
+
+void QColorWell::dropEvent( QDropEvent *e )
+{
+    if ( QColorDrag::canDecode( e ) ) {
+	int i = rowAt( e->pos().y() ) + columnAt( e->pos().x() ) * numRows();
+	QColor col;
+	QColorDrag::decode( e, col );
+	values[ i ] = col.rgb();
+	repaintContents( FALSE );
+	e->accept();
+    } else {
+	e->ignore();
+    }
+}
+
+#endif // QT_NO_DRAGANDDROP
+
+void QColorWell::mouseReleaseEvent( QMouseEvent *e )
+{
+    if ( !mousePressed )
+	return;
+    QWellArray::mouseReleaseEvent( e );
+    mousePressed = FALSE;
+}
+
+class QColorPicker : public QFrame
+{
+    Q_OBJECT
+public:
+    QColorPicker(QWidget* parent=0, const char* name=0);
+    ~QColorPicker();
+
+public slots:
+    void setCol( int h, int s );
+
+signals:
+    void newCol( int h, int s );
+
+protected:
+    QSize sizeHint() const;
+    void drawContents(QPainter* p);
+    void mouseMoveEvent( QMouseEvent * );
+    void mousePressEvent( QMouseEvent * );
+
+private:
+    int hue;
+    int sat;
+
+    QPoint colPt();
+    int huePt( const QPoint &pt );
+    int satPt( const QPoint &pt );
+    void setCol( const QPoint &pt );
+
+    QPixmap *pix;
+};
+
+static int pWidth = 200;
+static int pHeight = 200;
+
+class QColorLuminancePicker : public QWidget
+{
+    Q_OBJECT
+public:
+    QColorLuminancePicker(QWidget* parent=0, const char* name=0);
+    ~QColorLuminancePicker();
+
+public slots:
+    void setCol( int h, int s, int v );
+    void setCol( int h, int s );
+
+signals:
+    void newHsv( int h, int s, int v );
+
+protected:
+    void paintEvent( QPaintEvent*);
+    void mouseMoveEvent( QMouseEvent * );
+    void mousePressEvent( QMouseEvent * );
+
+private:
+    enum { foff = 3, coff = 4 }; //frame and contents offset
+    int val;
+    int hue;
+    int sat;
+
+    int y2val( int y );
+    int val2y( int val );
+    void setVal( int v );
+
+    QPixmap *pix;
+};
+
+
+int QColorLuminancePicker::y2val( int y )
+{
+    int d = height() - 2*coff - 1;
+    return 255 - (y - coff)*255/d;
+}
+
+int QColorLuminancePicker::val2y( int v )
+{
+    int d = height() - 2*coff - 1;
+    return coff + (255-v)*d/255;
+}
+
+QColorLuminancePicker::QColorLuminancePicker(QWidget* parent,
+						  const char* name)
+    :QWidget( parent, name )
+{
+    hue = 100; val = 100; sat = 100;
+    pix = 0;
+    //    setBackgroundMode( NoBackground );
+}
+
+QColorLuminancePicker::~QColorLuminancePicker()
+{
+    delete pix;
+}
+
+void QColorLuminancePicker::mouseMoveEvent( QMouseEvent *m )
+{
+    setVal( y2val(m->y()) );
+}
+void QColorLuminancePicker::mousePressEvent( QMouseEvent *m )
+{
+    setVal( y2val(m->y()) );
+}
+
+void QColorLuminancePicker::setVal( int v )
+{
+    if ( val == v )
+	return;
+    val = QMAX( 0, QMIN(v,255));
+    delete pix; pix=0;
+    repaint( FALSE ); //###
+    emit newHsv( hue, sat, val );
+}
+
+//receives from a hue,sat chooser and relays.
+void QColorLuminancePicker::setCol( int h, int s )
+{
+    setCol( h, s, val );
+    emit newHsv( h, s, val );
+}
+
+void QColorLuminancePicker::paintEvent( QPaintEvent * )
+{
+    int w = width() - 5;
+
+    QRect r( 0, foff, w, height() - 2*foff );
+    int wi = r.width() - 2;
+    int hi = r.height() - 2;
+    if ( !pix || pix->height() != hi || pix->width() != wi ) {
+	delete pix;
+	QImage img( wi, hi, 32 );
+	int y;
+	for ( y = 0; y < hi; y++ ) {
+	    QColor c( hue, sat, y2val(y+coff), QColor::Hsv );
+	    QRgb r = c.rgb();
+	    int x;
+	    for ( x = 0; x < wi; x++ )
+		img.setPixel( x, y, r );
+	}
+	pix = new QPixmap;
+	pix->convertFromImage(img);
+    }
+    QPainter p(this);
+    p.drawPixmap( 1, coff, *pix );
+    const QColorGroup &g = colorGroup();
+    qDrawShadePanel( &p, r, g, TRUE );
+    p.setPen( g.foreground() );
+    p.setBrush( g.foreground() );
+    QPointArray a;
+    int y = val2y(val);
+    a.setPoints( 3, w, y, w+5, y+5, w+5, y-5 );
+    erase( w, 0, 5, height() );
+    p.drawPolygon( a );
+}
+
+void QColorLuminancePicker::setCol( int h, int s , int v )
+{
+    val = v;
+    hue = h;
+    sat = s;
+    delete pix; pix=0;
+    repaint( FALSE );//####
+}
+
+QPoint QColorPicker::colPt()
+{ return QPoint( (360-hue)*(pWidth-1)/360, (255-sat)*(pHeight-1)/255 ); }
+int QColorPicker::huePt( const QPoint &pt )
+{ return 360 - pt.x()*360/(pWidth-1); }
+int QColorPicker::satPt( const QPoint &pt )
+{ return 255 - pt.y()*255/(pHeight-1) ; }
+void QColorPicker::setCol( const QPoint &pt )
+{ setCol( huePt(pt), satPt(pt) ); }
+
+QColorPicker::QColorPicker(QWidget* parent, const char* name )
+    : QFrame( parent, name )
+{
+    hue = 0; sat = 0;
+    setCol( 150, 255 );
+
+    QImage img( pWidth, pHeight, 32 );
+    int x,y;
+    for ( y = 0; y < pHeight; y++ )
+	for ( x = 0; x < pWidth; x++ ) {
+	    QPoint p( x, y );
+	    img.setPixel( x, y, QColor(huePt(p), satPt(p),
+				       200, QColor::Hsv).rgb() );
+	}
+    pix = new QPixmap;
+    pix->convertFromImage(img);
+    setBackgroundMode( NoBackground );
+    setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed )  );
+}
+
+QColorPicker::~QColorPicker()
+{
+    delete pix;
+}
+
+QSize QColorPicker::sizeHint() const
+{
+    return QSize( pWidth + 2*frameWidth(), pHeight + 2*frameWidth() );
+}
+
+void QColorPicker::setCol( int h, int s )
+{
+    int nhue = QMIN( QMAX(0,h), 360 );
+    int nsat = QMIN( QMAX(0,s), 255);
+    if ( nhue == hue && nsat == sat )
+	return;
+    QRect r( colPt(), QSize(20,20) );
+    hue = nhue; sat = nsat;
+    r = r.unite( QRect( colPt(), QSize(20,20) ) );
+    r.moveBy( contentsRect().x()-9, contentsRect().y()-9 );
+    //    update( r );
+    repaint( r, FALSE );
+}
+
+void QColorPicker::mouseMoveEvent( QMouseEvent *m )
+{
+    QPoint p = m->pos() - contentsRect().topLeft();
+    setCol( p );
+    emit newCol( hue, sat );
+}
+
+void QColorPicker::mousePressEvent( QMouseEvent *m )
+{
+    QPoint p = m->pos() - contentsRect().topLeft();
+    setCol( p );
+    emit newCol( hue, sat );
+}
+
+void QColorPicker::drawContents(QPainter* p)
+{
+    QRect r = contentsRect();
+
+    p->drawPixmap( r.topLeft(), *pix );
+    QPoint pt = colPt() + r.topLeft();
+    p->setPen( QPen(black) );
+
+    p->fillRect( pt.x()-9, pt.y(), 20, 2, black );
+    p->fillRect( pt.x(), pt.y()-9, 2, 20, black );
+
+}
+
+class QColorShowLabel;
+
+
+
+class QColIntValidator: public QIntValidator
+{
+public:
+    QColIntValidator( int bottom, int top,
+		   QWidget * parent, const char *name = 0 )
+	:QIntValidator( bottom, top, parent, name ) {}
+
+    QValidator::State validate( QString &, int & ) const;
+};
+
+QValidator::State QColIntValidator::validate( QString &s, int &pos ) const
+{
+    State state = QIntValidator::validate(s,pos);
+    if ( state == Valid ) {
+	long int val = s.toLong();
+	// This is not a general solution, assumes that top() > 0 and
+	// bottom >= 0
+	if ( val < 0 ) {
+	    s = "0";
+	    pos = 1;
+	} else if ( val > top() ) {
+	    s.setNum( top() );
+	    pos = s.length();
+	}
+    }
+    return state;
+}
+
+
+
+class QColNumLineEdit : public QLineEdit
+{
+public:
+    QColNumLineEdit( QWidget *parent, const char* name=0 )
+	: QLineEdit( parent, name ) { setMaxLength( 3 );}
+    QSize sizeHint() const {
+	return QSize( fontMetrics().width( "999" ) + 2 * ( margin() + frameWidth() ),
+		      QLineEdit::sizeHint().height() ); }
+    void setNum( int i ) {
+	QString s;
+	s.setNum(i);
+	bool block = signalsBlocked();
+	blockSignals(TRUE);
+	setText( s );
+	blockSignals(block);
+    }
+    int val() const { return text().toInt(); }
+};
+
+
+class QColorShower : public QWidget
+{
+    Q_OBJECT
+public:
+    QColorShower( QWidget *parent, const char *name=0 );
+
+    //things that don't emit signals
+    void setHsv( int h, int s, int v );
+
+    int currentAlpha() const { return alphaEd->val(); }
+    void setCurrentAlpha( int a ) { alphaEd->setNum( a ); }
+    void showAlpha( bool b );
+
+
+    QRgb currentColor() const { return curCol; }
+
+public slots:
+    void setRgb( QRgb rgb );
+
+signals:
+    void newCol( QRgb rgb );
+private slots:
+    void rgbEd();
+    void hsvEd();
+private:
+    void showCurrentColor();
+    int hue, sat, val;
+    QRgb curCol;
+    QColNumLineEdit *hEd;
+    QColNumLineEdit *sEd;
+    QColNumLineEdit *vEd;
+    QColNumLineEdit *rEd;
+    QColNumLineEdit *gEd;
+    QColNumLineEdit *bEd;
+    QColNumLineEdit *alphaEd;
+    QLabel *alphaLab;
+    QColorShowLabel *lab;
+    bool rgbOriginal;
+};
+
+class QColorShowLabel : public QFrame
+{
+    Q_OBJECT
+
+public:
+    QColorShowLabel( QWidget *parent ) : QFrame( parent, "qt_colorshow_lbl" ) {
+	setFrameStyle( QFrame::Panel|QFrame::Sunken );
+	setBackgroundMode( PaletteBackground );
+	setAcceptDrops( TRUE );
+	mousePressed = FALSE;
+    }
+    void setColor( QColor c ) { col = c; }
+
+signals:
+    void colorDropped( QRgb );
+
+protected:
+    void drawContents( QPainter *p );
+    void mousePressEvent( QMouseEvent *e );
+    void mouseMoveEvent( QMouseEvent *e );
+    void mouseReleaseEvent( QMouseEvent *e );
+#ifndef QT_NO_DRAGANDDROP
+    void dragEnterEvent( QDragEnterEvent *e );
+    void dragLeaveEvent( QDragLeaveEvent *e );
+    void dropEvent( QDropEvent *e );
+#endif
+
+private:
+    QColor col;
+    bool mousePressed;
+    QPoint pressPos;
+
+};
+
+void QColorShowLabel::drawContents( QPainter *p )
+{
+    p->fillRect( contentsRect(), col );
+}
+
+void QColorShower::showAlpha( bool b )
+{
+    if ( b ) {
+	alphaLab->show();
+	alphaEd->show();
+    } else {
+	alphaLab->hide();
+	alphaEd->hide();
+    }
+}
+
+void QColorShowLabel::mousePressEvent( QMouseEvent *e )
+{
+    mousePressed = TRUE;
+    pressPos = e->pos();
+}
+
+void QColorShowLabel::mouseMoveEvent( QMouseEvent *e )
+{
+#ifndef QT_NO_DRAGANDDROP
+    if ( !mousePressed )
+	return;
+    if ( ( pressPos - e->pos() ).manhattanLength() > QApplication::startDragDistance() ) {
+	QColorDrag *drg = new QColorDrag( col, this );
+	QPixmap pix( 30, 20 );
+	pix.fill( col );
+	QPainter p( &pix );
+	p.drawRect( 0, 0, pix.width(), pix.height() );
+	p.end();
+	drg->setPixmap( pix );
+	mousePressed = FALSE;
+	drg->dragCopy();
+    }
+#endif
+}
+
+#ifndef QT_NO_DRAGANDDROP
+void QColorShowLabel::dragEnterEvent( QDragEnterEvent *e )
+{
+    if ( QColorDrag::canDecode( e ) )
+	e->accept();
+    else
+	e->ignore();
+}
+
+void QColorShowLabel::dragLeaveEvent( QDragLeaveEvent * )
+{
+}
+
+void QColorShowLabel::dropEvent( QDropEvent *e )
+{
+    if ( QColorDrag::canDecode( e ) ) {
+	QColorDrag::decode( e, col );
+	repaint( FALSE );
+	emit colorDropped( col.rgb() );
+	e->accept();
+    } else {
+	e->ignore();
+    }
+}
+#endif // QT_NO_DRAGANDDROP
+
+void QColorShowLabel::mouseReleaseEvent( QMouseEvent * )
+{
+    if ( !mousePressed )
+	return;
+    mousePressed = FALSE;
+}
+
+QColorShower::QColorShower( QWidget *parent, const char *name )
+    :QWidget( parent, name)
+{
+    curCol = qRgb( -1, -1, -1 );
+    QColIntValidator *val256 = new QColIntValidator( 0, 255, this );
+    QColIntValidator *val360 = new QColIntValidator( 0, 360, this );
+
+    QGridLayout *gl = new QGridLayout( this, 1, 1, 6 );
+    lab = new QColorShowLabel( this );
+    lab->setMinimumWidth( 60 ); //###
+    gl->addMultiCellWidget(lab, 0,-1,0,0);
+    connect( lab, SIGNAL( colorDropped(QRgb) ),
+	     this, SIGNAL( newCol(QRgb) ) );
+    connect( lab, SIGNAL( colorDropped(QRgb) ),
+	     this, SLOT( setRgb(QRgb) ) );
+
+    hEd = new QColNumLineEdit( this, "qt_hue_edit" );
+    hEd->setValidator( val360 );
+    QLabel *l = new QLabel( hEd, QColorDialog::tr("Hu&e:"), this, "qt_hue_lbl" );
+    l->setAlignment( AlignRight|AlignVCenter );
+    gl->addWidget( l, 0, 1 );
+    gl->addWidget( hEd, 0, 2 );
+
+    sEd = new QColNumLineEdit( this, "qt_sat_edit" );
+    sEd->setValidator( val256 );
+    l = new QLabel( sEd, QColorDialog::tr("&Sat:"), this, "qt_sat_lbl" );
+    l->setAlignment( AlignRight|AlignVCenter );
+    gl->addWidget( l, 1, 1 );
+    gl->addWidget( sEd, 1, 2 );
+
+    vEd = new QColNumLineEdit( this, "qt_val_edit" );
+    vEd->setValidator( val256 );
+    l = new QLabel( vEd, QColorDialog::tr("&Val:"), this, "qt_val_lbl" );
+    l->setAlignment( AlignRight|AlignVCenter );
+    gl->addWidget( l, 2, 1 );
+    gl->addWidget( vEd, 2, 2 );
+
+    rEd = new QColNumLineEdit( this, "qt_red_edit" );
+    rEd->setValidator( val256 );
+    l = new QLabel( rEd, QColorDialog::tr("&Red:"), this, "qt_red_lbl" );
+    l->setAlignment( AlignRight|AlignVCenter );
+    gl->addWidget( l, 0, 3 );
+    gl->addWidget( rEd, 0, 4 );
+
+    gEd = new QColNumLineEdit( this, "qt_grn_edit" );
+    gEd->setValidator( val256 );
+    l = new QLabel( gEd, QColorDialog::tr("&Green:"), this, "qt_grn_lbl" );
+    l->setAlignment( AlignRight|AlignVCenter );
+    gl->addWidget( l, 1, 3 );
+    gl->addWidget( gEd, 1, 4 );
+
+    bEd = new QColNumLineEdit( this, "qt_blue_edit" );
+    bEd->setValidator( val256 );
+    l = new QLabel( bEd, QColorDialog::tr("Bl&ue:"), this, "qt_blue_lbl" );
+    l->setAlignment( AlignRight|AlignVCenter );
+    gl->addWidget( l, 2, 3 );
+    gl->addWidget( bEd, 2, 4 );
+
+    alphaEd = new QColNumLineEdit( this, "qt_aplha_edit" );
+    alphaEd->setValidator( val256 );
+    alphaLab = new QLabel( alphaEd, QColorDialog::tr("A&lpha channel:"), this, "qt_alpha_lbl" );
+    alphaLab->setAlignment( AlignRight|AlignVCenter );
+    gl->addMultiCellWidget( alphaLab, 3, 3, 1, 3 );
+    gl->addWidget( alphaEd, 3, 4 );
+    alphaEd->hide();
+    alphaLab->hide();
+
+    connect( hEd, SIGNAL(textChanged(const QString&)), this, SLOT(hsvEd()) );
+    connect( sEd, SIGNAL(textChanged(const QString&)), this, SLOT(hsvEd()) );
+    connect( vEd, SIGNAL(textChanged(const QString&)), this, SLOT(hsvEd()) );
+
+    connect( rEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
+    connect( gEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
+    connect( bEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
+    connect( alphaEd, SIGNAL(textChanged(const QString&)), this, SLOT(rgbEd()) );
+}
+
+void QColorShower::showCurrentColor()
+{
+    lab->setColor( currentColor() );
+    lab->repaint(FALSE); //###
+}
+
+void QColorShower::rgbEd()
+{
+    rgbOriginal = TRUE;
+    if ( alphaEd->isVisible() )
+	curCol = qRgba( rEd->val(), gEd->val(), bEd->val(), currentAlpha() );
+    else
+	curCol = qRgb( rEd->val(), gEd->val(), bEd->val() );
+
+    rgb2hsv(currentColor(), hue, sat, val );
+
+    hEd->setNum( hue );
+    sEd->setNum( sat );
+    vEd->setNum( val );
+
+    showCurrentColor();
+    emit newCol( currentColor() );
+}
+
+void QColorShower::hsvEd()
+{
+    rgbOriginal = FALSE;
+    hue = hEd->val();
+    sat = sEd->val();
+    val = vEd->val();
+
+    curCol = QColor( hue, sat, val, QColor::Hsv ).rgb();
+
+    rEd->setNum( qRed(currentColor()) );
+    gEd->setNum( qGreen(currentColor()) );
+    bEd->setNum( qBlue(currentColor()) );
+
+    showCurrentColor();
+    emit newCol( currentColor() );
+}
+
+void QColorShower::setRgb( QRgb rgb )
+{
+    rgbOriginal = TRUE;
+    curCol = rgb;
+
+    rgb2hsv( currentColor(), hue, sat, val );
+
+    hEd->setNum( hue );
+    sEd->setNum( sat );
+    vEd->setNum( val );
+
+    rEd->setNum( qRed(currentColor()) );
+    gEd->setNum( qGreen(currentColor()) );
+    bEd->setNum( qBlue(currentColor()) );
+
+    showCurrentColor();
+}
+
+void QColorShower::setHsv( int h, int s, int v )
+{
+    rgbOriginal = FALSE;
+    hue = h; val = v; sat = s; //Range check###
+    curCol = QColor( hue, sat, val, QColor::Hsv ).rgb();
+
+    hEd->setNum( hue );
+    sEd->setNum( sat );
+    vEd->setNum( val );
+
+    rEd->setNum( qRed(currentColor()) );
+    gEd->setNum( qGreen(currentColor()) );
+    bEd->setNum( qBlue(currentColor()) );
+
+    showCurrentColor();
+}
+
+class QColorDialogPrivate : public QObject
+{
+Q_OBJECT
+public:
+    QColorDialogPrivate( QColorDialog *p );
+    QRgb currentColor() const { return cs->currentColor(); }
+    void setCurrentColor( QRgb rgb );
+
+    int currentAlpha() const { return cs->currentAlpha(); }
+    void setCurrentAlpha( int a ) { cs->setCurrentAlpha( a ); }
+    void showAlpha( bool b ) { cs->showAlpha( b ); }
+
+public slots:
+    void addCustom();
+
+    void newHsv( int h, int s, int v );
+    void newColorTypedIn( QRgb rgb );
+    void newCustom( int, int );
+    void newStandard( int, int );
+public:
+    QWellArray *custom;
+    QWellArray *standard;
+
+    QColorPicker *cp;
+    QColorLuminancePicker *lp;
+    QColorShower *cs;
+    int nextCust;
+    bool compact;
+};
+
+//sets all widgets to display h,s,v
+void QColorDialogPrivate::newHsv( int h, int s, int v )
+{
+    cs->setHsv( h, s, v );
+    cp->setCol( h, s );
+    lp->setCol( h, s, v );
+}
+
+//sets all widgets to display rgb
+void QColorDialogPrivate::setCurrentColor( QRgb rgb )
+{
+    cs->setRgb( rgb );
+    newColorTypedIn( rgb );
+}
+
+//sets all widgets exept cs to display rgb
+void QColorDialogPrivate::newColorTypedIn( QRgb rgb )
+{
+    int h, s, v;
+    rgb2hsv(rgb, h, s, v );
+    cp->setCol( h, s );
+    lp->setCol( h, s, v);
+}
+
+void QColorDialogPrivate::newCustom( int r, int c )
+{
+    int i = r+2*c;
+    setCurrentColor( cusrgb[i] );
+    nextCust = i;
+    if (standard)
+        standard->setSelected(-1,-1);
+}
+
+void QColorDialogPrivate::newStandard( int r, int c )
+{
+    setCurrentColor( stdrgb[r+c*6] );
+    if (custom)
+        custom->setSelected(-1,-1);
+}
+
+QColorDialogPrivate::QColorDialogPrivate( QColorDialog *dialog ) :
+    QObject(dialog)
+{
+    compact = FALSE;
+    // small displays (e.g. PDAs cannot fit the full color dialog,
+    // so just use the color picker.
+    if ( qApp->desktop()->width() < 480 || qApp->desktop()->height() < 350 )
+	compact = TRUE;
+
+    nextCust = 0;
+    const int lumSpace = 3;
+    int border = 12;
+    if ( compact )
+	border = 6;
+    QHBoxLayout *topLay = new QHBoxLayout( dialog, border, 6 );
+    QVBoxLayout *leftLay = 0;
+
+    if ( !compact )
+	leftLay = new QVBoxLayout( topLay );
+
+    initRGB();
+
+    if ( !compact ) {
+	standard = new QColorWell( dialog, 6, 8, stdrgb );
+	standard->setCellWidth( 28 );
+	standard->setCellHeight( 24 );
+	QLabel * lab = new QLabel( standard,
+				QColorDialog::tr( "&Basic colors"), dialog, "qt_basiccolors_lbl" );
+	connect( standard, SIGNAL(selected(int,int)), SLOT(newStandard(int,int)));
+	leftLay->addWidget( lab );
+	leftLay->addWidget( standard );
+
+
+	leftLay->addStretch();
+
+	custom = new QColorWell( dialog, 2, 8, cusrgb );
+	custom->setCellWidth( 28 );
+	custom->setCellHeight( 24 );
+	custom->setAcceptDrops( TRUE );
+
+	connect( custom, SIGNAL(selected(int,int)), SLOT(newCustom(int,int)));
+	lab = new QLabel( custom, QColorDialog::tr( "&Custom colors") , dialog, "qt_custcolors_lbl" );
+	leftLay->addWidget( lab );
+	leftLay->addWidget( custom );
+
+	QPushButton *custbut =
+	    new QPushButton( QColorDialog::tr("&Define Custom Colors >>"),
+						dialog, "qt_def_custcolors_lbl" );
+	custbut->setEnabled( FALSE );
+	leftLay->addWidget( custbut );
+    } else {
+	// better color picker size for small displays
+	pWidth = 150;
+	pHeight = 100;
+
+        custom = 0;
+        standard = 0;
+    }
+
+    QVBoxLayout *rightLay = new QVBoxLayout( topLay );
+
+    QHBoxLayout *pickLay = new QHBoxLayout( rightLay );
+
+
+    QVBoxLayout *cLay = new QVBoxLayout( pickLay );
+    cp = new QColorPicker( dialog, "qt_colorpicker" );
+    cp->setFrameStyle( QFrame::Panel + QFrame::Sunken );
+    cLay->addSpacing( lumSpace );
+    cLay->addWidget( cp );
+    cLay->addSpacing( lumSpace );
+
+    lp = new QColorLuminancePicker( dialog, "qt_luminance_picker" );
+    lp->setFixedWidth( 20 ); //###
+    pickLay->addWidget( lp );
+
+    connect( cp, SIGNAL(newCol(int,int)), lp, SLOT(setCol(int,int)) );
+    connect( lp, SIGNAL(newHsv(int,int,int)), this, SLOT(newHsv(int,int,int)) );
+
+    rightLay->addStretch();
+
+    cs = new QColorShower( dialog, "qt_colorshower" );
+    connect( cs, SIGNAL(newCol(QRgb)), this, SLOT(newColorTypedIn(QRgb)));
+    rightLay->addWidget( cs );
+
+    QHBoxLayout *buttons;
+    if ( compact )
+	buttons = new QHBoxLayout( rightLay );
+    else
+	buttons = new QHBoxLayout( leftLay );
+
+    QPushButton *ok, *cancel;
+    ok = new QPushButton( QColorDialog::tr("OK"), dialog, "qt_ok_btn" );
+    connect( ok, SIGNAL(clicked()), dialog, SLOT(accept()) );
+    ok->setDefault(TRUE);
+    cancel = new QPushButton( QColorDialog::tr("Cancel"), dialog, "qt_cancel_btn" );
+    connect( cancel, SIGNAL(clicked()), dialog, SLOT(reject()) );
+    buttons->addWidget( ok );
+    buttons->addWidget( cancel );
+    buttons->addStretch();
+
+    if ( !compact ) {
+	QPushButton *addCusBt = new QPushButton(
+					QColorDialog::tr("&Add to Custom Colors"),
+						 dialog, "qt_add_btn" );
+	rightLay->addWidget( addCusBt );
+	connect( addCusBt, SIGNAL(clicked()), this, SLOT(addCustom()) );
+    }
+}
+
+void QColorDialogPrivate::addCustom()
+{
+    cusrgb[nextCust] = cs->currentColor();
+    if (custom)
+        custom->repaintContents( FALSE );
+    nextCust = (nextCust+1) % 16;
+}
+
+
+/*!
+    \class QColorDialog qcolordialog.h
+    \brief The QColorDialog class provides a dialog widget for specifying colors.
+    \mainclass
+    \ingroup dialogs
+    \ingroup graphics
+
+    The color dialog's function is to allow users to choose colors.
+    For example, you might use this in a drawing program to allow the
+    user to set the brush color.
+
+    The static functions provide modal color dialogs.
+    \omit
+    If you require a modeless dialog, use the QColorDialog constructor.
+    \endomit
+
+    The static getColor() function shows the dialog and allows the
+    user to specify a color. The getRgba() function does the same but
+    also allows the user to specify a color with an alpha channel
+    (transparency) value.
+
+    The user can store customCount() different custom colors. The
+    custom colors are shared by all color dialogs, and remembered
+    during the execution of the program. Use setCustomColor() to set
+    the custom colors, and use customColor() to get them.
+
+    \img qcolordlg-w.png
+*/
+
+/*!
+    Constructs a default color dialog with parent \a parent and called
+    \a name. If \a modal is TRUE the dialog will be modal. Use
+    setColor() to set an initial value.
+
+    \sa getColor()
+*/
+
+QColorDialog::QColorDialog(QWidget* parent, const char* name, bool modal) :
+    QDialog(parent, name, modal, (  WType_Dialog | WStyle_Customize | WStyle_Title |
+                                    WStyle_DialogBorder | WStyle_SysMenu ) )
+{
+    setSizeGripEnabled( FALSE );
+    d = new QColorDialogPrivate( this );
+
+#ifndef QT_NO_SETTINGS
+    if ( !customSet ) {
+	QSettings settings;
+	settings.insertSearchPath( QSettings::Windows, "/Trolltech" );
+	for ( int i = 0; i < 2*8; ++i ) {
+	    bool ok = FALSE;
+	    QRgb rgb = (QRgb)settings.readNumEntry( "/Qt/customColors/" + QString::number( i ), 0, &ok );
+	    if ( ok )
+		cusrgb[i] = rgb;
+	}
+    }
+#endif
+}
+
+/*!
+    Pops up a modal color dialog, lets the user choose a color, and
+    returns that color. The color is initially set to \a initial. The
+    dialog is a child of \a parent and is called \a name. It returns
+    an invalid (see QColor::isValid()) color if the user cancels the
+    dialog. All colors allocated by the dialog will be deallocated
+    before this function returns.
+*/
+
+QColor QColorDialog::getColor( const QColor& initial, QWidget *parent,
+			       const char *name )
+{
+#if defined(Q_WS_MAC)
+    return macGetColor(initial, parent, name);
+#endif
+
+    int allocContext = QColor::enterAllocContext();
+    QColorDialog *dlg = new QColorDialog( parent, name, TRUE );  //modal
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg->setCaption( QColorDialog::tr( "Select color" ) );
+#endif
+    dlg->setColor( initial );
+    dlg->selectColor( initial );
+    int resultCode = dlg->exec();
+    QColor::leaveAllocContext();
+    QColor result;
+    if ( resultCode == QDialog::Accepted )
+	result = dlg->color();
+    QColor::destroyAllocContext(allocContext);
+    delete dlg;
+    return result;
+}
+
+
+/*!
+    Pops up a modal color dialog to allow the user to choose a color
+    and an alpha channel (transparency) value. The color+alpha is
+    initially set to \a initial. The dialog is a child of \a parent
+    and called \a name.
+
+    If \a ok is non-null, \e *\a ok is set to TRUE if the user clicked
+    OK, and to FALSE if the user clicked Cancel.
+
+    If the user clicks Cancel, the \a initial value is returned.
+*/
+
+QRgb QColorDialog::getRgba( QRgb initial, bool *ok,
+			    QWidget *parent, const char* name )
+{
+#if defined(Q_WS_MAC)
+    return macGetRgba(initial, ok, parent, name);
+#endif
+
+    int allocContext = QColor::enterAllocContext();
+    QColorDialog *dlg = new QColorDialog( parent, name, TRUE );  //modal
+
+    Q_CHECK_PTR( dlg );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg->setCaption( QColorDialog::tr( "Select color" ) );
+#endif
+    dlg->setColor( initial );
+    dlg->selectColor( initial );
+    dlg->setSelectedAlpha( qAlpha(initial) );
+    int resultCode = dlg->exec();
+    QColor::leaveAllocContext();
+    QRgb result = initial;
+    if ( resultCode == QDialog::Accepted ) {
+	QRgb c = dlg->color().rgb();
+	int alpha = dlg->selectedAlpha();
+	result = qRgba( qRed(c), qGreen(c), qBlue(c), alpha );
+    }
+    if ( ok )
+	*ok = resultCode == QDialog::Accepted;
+
+    QColor::destroyAllocContext(allocContext);
+    delete dlg;
+    return result;
+}
+
+
+
+
+
+/*!
+    Returns the color currently selected in the dialog.
+
+    \sa setColor()
+*/
+
+QColor QColorDialog::color() const
+{
+    return QColor(d->currentColor());
+}
+
+
+/*!
+    Destroys the dialog and frees any memory it allocated.
+*/
+
+QColorDialog::~QColorDialog()
+{
+#ifndef QT_NO_SETTINGS
+    if ( !customSet ) {
+	QSettings settings;
+	settings.insertSearchPath( QSettings::Windows, "/Trolltech" );
+	for ( int i = 0; i < 2*8; ++i )
+	    settings.writeEntry( "/Qt/customColors/" + QString::number( i ), (int)cusrgb[i] );
+    }
+#endif
+}
+
+
+/*!
+    Sets the color shown in the dialog to \a c.
+
+    \sa color()
+*/
+
+void QColorDialog::setColor( const QColor& c )
+{
+    d->setCurrentColor( c.rgb() );
+}
+
+
+
+
+/*!
+    Sets the initial alpha channel value to \a a, and shows the alpha
+    channel entry box.
+*/
+
+void QColorDialog::setSelectedAlpha( int a )
+{
+    d->showAlpha( TRUE );
+    d->setCurrentAlpha( a );
+}
+
+
+/*!
+    Returns the value selected for the alpha channel.
+*/
+
+int QColorDialog::selectedAlpha() const
+{
+    return d->currentAlpha();
+}
+
+/*!
+    Sets focus to the corresponding button, if any.
+*/
+bool QColorDialog::selectColor( const QColor& col )
+{
+    QRgb color = col.rgb();
+    int i = 0, j = 0;
+    // Check standard colors
+    if (d->standard) {
+        for ( i = 0; i < 6; i++ ) {
+            for ( j = 0; j < 8; j++ ) {
+                if ( color == stdrgb[i + j*6] ) {
+                    d->newStandard( i, j );
+                    d->standard->setCurrent( i, j );
+                    d->standard->setSelected( i, j );
+                    d->standard->setFocus();
+                    return TRUE;
+                }
+            }
+        }
+    }
+    // Check custom colors
+    if (d->custom) {
+        for ( i = 0; i < 2; i++ ) {
+            for ( j = 0; j < 8; j++ ) {
+                if ( color == cusrgb[i + j*2] ) {
+                    d->newCustom( i, j );
+                    d->custom->setCurrent( i, j );
+                    d->custom->setSelected( i, j );
+                    d->custom->setFocus();
+                    return TRUE;
+                }
+            }
+        }
+    }
+    return FALSE;
+}
+
+#include "qcolordialog.moc"
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qcolordialog.h b/main/dependencies/qt3/src/dialogs/qcolordialog.h
new file mode 100644
index 000000000..9860dc895
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qcolordialog.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Definition of QColorDialog class
+**
+** Created : 990222
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QCOLORDIALOG_H
+#define QCOLORDIALOG_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#endif // QT_H
+
+#ifndef QT_NO_COLORDIALOG
+
+class QColorDialogPrivate;
+
+class Q_EXPORT QColorDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    static QColor getColor( const QColor& init = white, QWidget* parent=0, const char* name=0 );
+    static QRgb getRgba( QRgb, bool* ok = 0,
+			 QWidget* parent=0, const char* name=0 );
+
+    static int customCount();
+    static QRgb customColor( int );
+    static void setCustomColor( int, QRgb );
+    static void setStandardColor( int, QRgb );
+
+private:
+    ~QColorDialog();
+    QColorDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE );
+
+    void setColor( const QColor& );
+    QColor color() const;
+
+    bool selectColor( const QColor& );
+
+    void setSelectedAlpha( int );
+    int selectedAlpha() const;
+
+    void showCustom( bool=TRUE );
+
+private:	// Disabled copy constructor and operator=
+    QColorDialogPrivate *d;
+    friend class QColorDialogPrivate;
+    friend class QColorShower;
+
+#if defined(Q_DISABLE_COPY)
+    QColorDialog( const QColorDialog & );
+    QColorDialog& operator=( const QColorDialog & );
+#endif
+};
+
+#endif
+
+#endif //QCOLORDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qdialog.cpp b/main/dependencies/qt3/src/dialogs/qdialog.cpp
new file mode 100644
index 000000000..a80f509b7
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qdialog.cpp
@@ -0,0 +1,1178 @@
+/****************************************************************************
+**
+** Implementation of QDialog class
+**
+** Created : 950502
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qdialog.h"
+
+#ifndef QT_NO_DIALOG
+
+#include "qpushbutton.h"
+#include "qfocusdata.h"
+#include "qapplication.h"
+#include "qobjectlist.h"
+#include "qwidgetlist.h"
+#include "qlayout.h"
+#include "qsizegrip.h"
+#include "qwhatsthis.h"
+#include "qpopupmenu.h"
+#include "qcursor.h"
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+#include "qaccessible.h"
+#endif
+#if defined( Q_OS_TEMP )
+#include "qt_windows.h"
+#endif
+
+/*!
+    \class QDialog
+    \brief The QDialog class is the base class of dialog windows.
+
+    \ingroup dialogs
+    \ingroup abstractwidgets
+    \mainclass
+
+    A dialog window is a top-level window mostly used for short-term
+    tasks and brief communications with the user. QDialogs may be
+    modal or modeless. QDialogs support \link #extensibility
+    extensibility\endlink and can provide a \link #return return
+    value\endlink. They can have \link #default default
+    buttons\endlink. QDialogs can also have a QSizeGrip in their
+    lower-right corner, using setSizeGripEnabled().
+
+    Note that QDialog uses the parent widget slightly differently from
+    other classes in Qt. A dialog is always a top-level widget, but if
+    it has a parent, its default location is centered on top of the
+    parent's top-level widget (if it is not top-level itself). It will
+    also share the parent's taskbar entry.
+
+    \target modal
+    \section1 Modal Dialogs
+
+    A <b>modal</b> dialog is a dialog that blocks input to other
+    visible windows in the same application. Users must finish
+    interacting with the dialog and close it before they can access
+    any other window in the application. Dialogs that are used to
+    request a file name from the user or that are used to set
+    application preferences are usually modal.
+
+    The most common way to display a modal dialog is to call its
+    exec() function. When the user closes the dialog, exec() will
+    provide a useful \link #return return value\endlink. Typically we
+    connect a default button, e.g. "OK", to the accept() slot and a
+    "Cancel" button to the reject() slot, to get the dialog to close
+    and return the appropriate value. Alternatively you can connect to
+    the done() slot, passing it \c Accepted or \c Rejected.
+
+    An alternative is to call setModal(TRUE), then show(). Unlike
+    exec(), show() returns control to the caller immediately. Calling
+    setModal(TRUE) is especially useful for progress dialogs, where
+    the user must have the ability to interact with the dialog, e.g.
+    to cancel a long running operation. If you use show() and
+    setModal(TRUE) together you must call
+    QApplication::processEvents() periodically during processing to
+    enable the user to interact with the dialog. (See \l
+    QProgressDialog.)
+
+    \target modeless
+    \section1 Modeless Dialogs
+
+    A <b>modeless</b> dialog is a dialog that operates
+    independently of other windows in the same application. Find and
+    replace dialogs in word-processors are often modeless to allow the
+    user to interact with both the application's main window and with
+    the dialog.
+
+    Modeless dialogs are displayed using show(), which returns control
+    to the caller immediately.
+
+    \target default
+    \section1 Default button
+
+    A dialog's \e default button is the button that's pressed when the
+    user presses Enter (Return). This button is used to signify that
+    the user accepts the dialog's settings and wants to close the
+    dialog. Use QPushButton::setDefault(), QPushButton::isDefault()
+    and QPushButton::autoDefault() to set and control the dialog's
+    default button.
+
+    \target escapekey
+    \section1 Escape Key
+
+    If the user presses the Esc key in a dialog, QDialog::reject()
+    will be called. This will cause the window to close: the \link
+    QCloseEvent closeEvent \endlink cannot be \link
+    QCloseEvent::ignore() ignored \endlink.
+
+    \target extensibility
+    \section1 Extensibility
+
+    Extensibility is the ability to show the dialog in two ways: a
+    partial dialog that shows the most commonly used options, and a
+    full dialog that shows all the options. Typically an extensible
+    dialog will initially appear as a partial dialog, but with a
+    "More" toggle button. If the user presses the "More" button down,
+    the full dialog will appear. The extension widget will be resized
+    to its sizeHint(). If orientation is \c Horizontal the extension
+    widget's height() will be expanded to the height() of the dialog.
+    If the orientation is \c Vertical the extension widget's width()
+    will be expanded to the width() of the dialog. Extensibility is
+    controlled with setExtension(), setOrientation() and
+    showExtension().
+
+    \target return
+    \section1 Return value (modal dialogs)
+
+    Modal dialogs are often used in situations where a return value is
+    required, e.g. to indicate whether the user pressed "OK" or
+    "Cancel". A dialog can be closed by calling the accept() or the
+    reject() slots, and exec() will return \c Accepted or \c Rejected
+    as appropriate. The exec() call returns the result of the dialog.
+    The result is also available from result() if the dialog has not
+    been destroyed. If the \c WDestructiveClose flag is set, the
+    dialog is deleted after exec() returns.
+
+    \target examples
+    \section1 Examples
+
+    A modal dialog.
+
+    \quotefile network/networkprotocol/view.cpp
+    \skipto QFileDialog *dlg
+    \printuntil return
+
+    A modeless dialog. After the show() call, control returns to the main
+    event loop.
+    \quotefile life/main.cpp
+    \skipto argv
+    \printuntil QApplication
+    \skipto scale
+    \printline
+    \skipto LifeDialog
+    \printuntil show
+    \skipto exec
+    \printuntil }
+
+    \sa QTabDialog QWidget QProgressDialog
+    \link guibooks.html#fowler GUI Design Handbook: Dialogs, Standard\endlink
+*/
+
+/*! \enum QDialog::DialogCode
+
+    The value returned by a modal dialog.
+
+    \value Accepted
+    \value Rejected
+
+*/
+
+/*!
+  \property QDialog::sizeGripEnabled
+  \brief whether the size grip is enabled
+
+  A QSizeGrip is placed in the bottom right corner of the dialog when this
+  property is enabled. By default, the size grip is disabled.
+*/
+
+class QDialogPrivate : public Qt
+{
+public:
+
+    QDialogPrivate()
+	: mainDef(0), orientation(Horizontal),extension(0), doShowExtension(FALSE)
+#ifndef QT_NO_SIZEGRIP
+	,resizer(0)
+#endif
+	{
+    }
+
+    QPushButton* mainDef;
+    Orientation orientation;
+    QWidget* extension;
+    bool doShowExtension;
+    QSize size, min, max;
+#ifndef QT_NO_SIZEGRIP
+    QSizeGrip* resizer;
+#endif
+    QPoint lastRMBPress;
+    QPoint relPos; // relative position to the main window
+};
+
+/*!
+  Constructs a dialog called \a name, with parent \a parent.
+
+  A dialog is always a top-level widget, but if it has a parent, its
+  default location is centered on top of the parent. It will also
+  share the parent's taskbar entry.
+
+  The widget flags \a f are passed on to the QWidget constructor.
+  If, for example, you don't want a What's This button in the titlebar
+  of the dialog, pass WStyle_Customize | WStyle_NormalBorder |
+  WStyle_Title | WStyle_SysMenu in \a f.
+
+  \warning In Qt 3.2, the \a modal flag is obsolete. There is now a
+  setModal() function that can be used for obtaining a modal behavior
+  when calling show(). This is rarely needed, because modal dialogs
+  are usually invoked using exec(), which ignores the \a modal flag.
+
+  \sa QWidget::setWFlags() Qt::WidgetFlags
+*/
+
+QDialog::QDialog( QWidget *parent, const char *name, bool modal, WFlags f )
+    : QWidget( parent, name,
+	       (modal ? (f|WShowModal) : f) | WType_Dialog ),
+      rescode(0), did_move(0), has_relpos(0), did_resize(0), in_loop(0)
+{
+    d = new QDialogPrivate;
+}
+
+/*!
+  Destroys the QDialog, deleting all its children.
+*/
+
+QDialog::~QDialog()
+{
+    // Need to hide() here, as our (to-be) overridden hide()
+    // will not be called in ~QWidget.
+    hide();
+    delete d;
+}
+
+/*!
+  \internal
+  This function is called by the push button \a pushButton when it
+  becomes the default button. If \a pushButton is 0, the dialogs
+  default default button becomes the default button. This is what a
+  push button calls when it loses focus.
+*/
+
+void QDialog::setDefault( QPushButton *pushButton )
+{
+#ifndef QT_NO_PUSHBUTTON
+    QObjectList *list = queryList( "QPushButton" );
+    Q_ASSERT(list);
+    QObjectListIt it( *list );
+    QPushButton *pb;
+    bool hasMain = FALSE;
+    while ( (pb = (QPushButton*)it.current()) ) {
+	++it;
+	if ( pb->topLevelWidget() != this )
+	    continue;
+	if ( pb == d->mainDef )
+	    hasMain = TRUE;
+	if ( pb != pushButton )
+	    pb->setDefault( FALSE );
+    }
+    if (!pushButton && hasMain)
+	d->mainDef->setDefault( TRUE );
+    if (!hasMain)
+	d->mainDef = pushButton;
+    delete list;
+#endif
+}
+
+/*!
+  \internal
+  This function sets the default default pushbutton to \a pushButton.
+  This function is called by QPushButton::setDefault().
+*/
+void QDialog::setMainDefault( QPushButton *pushButton )
+{
+#ifndef QT_NO_PUSHBUTTON
+    d->mainDef = 0;
+    setDefault(pushButton);
+#endif
+}
+
+/*!
+  \internal
+  Hides the default button indicator. Called when non auto-default
+  push button get focus.
+ */
+void QDialog::hideDefault()
+{
+#ifndef QT_NO_PUSHBUTTON
+    QObjectList *list = queryList( "QPushButton" );
+    QObjectListIt it( *list );
+    QPushButton *pb;
+    while ( (pb = (QPushButton*)it.current()) ) {
+	++it;
+	pb->setDefault( FALSE );
+    }
+    delete list;
+#endif
+}
+
+#ifdef Q_OS_TEMP
+/*!
+  \internal
+  Hides special buttons which are rather shown in the titlebar
+  on WinCE, to conserve screen space.
+*/
+# include "qmessagebox.h"
+extern const char * mb_texts[]; // Defined in qmessagebox.cpp
+void QDialog::hideSpecial()
+{
+    // "OK"     buttons are hidden, and (Ok) shown on titlebar
+    // "Cancel" buttons are hidden, and (X)  shown on titlebar
+    // "Help"   buttons are hidden, and (?)  shown on titlebar
+    bool showOK = FALSE,
+	 showX  = FALSE,
+	 showQ  = FALSE;
+    QObjectList *list = queryList( "QPushButton" );
+    QObjectListIt it( *list );
+    QPushButton *pb;
+    while ( (pb = (QPushButton*)it.current()) ) {
+	if ( !showOK &&
+	     pb->text() == qApp->translate( "QMessageBox", mb_texts[QMessageBox::Ok] ) ) {
+	    pb->hide();
+	    showOK = TRUE;
+	} else if ( !showX &&
+		    pb->text() == qApp->translate( "QMessageBox", mb_texts[QMessageBox::Cancel] ) ) {
+	    pb->hide();
+	    showX = TRUE;
+	} else if ( !showQ &&
+		    pb->text() == qApp->tr("Help") ) {
+	    pb->hide();
+	    showQ = TRUE;
+	}
+        ++it;
+    }
+    delete list;
+    if ( showOK || showQ ) {
+	DWORD ext = GetWindowLong( winId(), GWL_EXSTYLE );
+	ext |= showOK ? WS_EX_CAPTIONOKBTN : 0;
+	ext |= showQ  ? WS_EX_CONTEXTHELP: 0;
+	SetWindowLong( winId(), GWL_EXSTYLE, ext );
+    }
+    if ( !showX ) {
+	DWORD ext = GetWindowLong( winId(), GWL_STYLE );
+	ext &= ~WS_SYSMENU;
+	SetWindowLong( winId(), GWL_STYLE, ext );
+    }
+}
+#endif
+
+/*!
+  \fn int QDialog::result() const
+
+  Returns the modal dialog's result code, \c Accepted or \c Rejected.
+
+  Do not call this function if the dialog was constructed with the \c
+  WDestructiveClose flag.
+*/
+
+/*!
+  \fn void QDialog::setResult( int i )
+
+  Sets the modal dialog's result code to \a i.
+*/
+
+
+/*!
+    Shows the dialog as a \link #modal modal \endlink dialog,
+    blocking until the user closes it. The function returns a \l
+    DialogCode result.
+
+    Users cannot interact with any other window in the same
+    application until they close the dialog.
+
+  \sa show(), result()
+*/
+
+int QDialog::exec()
+{
+    if ( in_loop ) {
+	qWarning( "QDialog::exec: Recursive call detected" );
+	return -1;
+    }
+
+    bool destructiveClose = testWFlags( WDestructiveClose );
+    clearWFlags( WDestructiveClose );
+
+    bool wasShowModal = testWFlags( WShowModal );
+    setWFlags( WShowModal );
+    setResult( 0 );
+
+    show();
+
+    in_loop = TRUE;
+    qApp->enter_loop();
+
+    if ( !wasShowModal )
+	clearWFlags( WShowModal );
+
+    int res = result();
+
+    if ( destructiveClose )
+	delete this;
+
+    return res;
+}
+
+
+/*! Closes the dialog and sets its result code to \a r. If this dialog
+  is shown with exec(), done() causes the local event loop to finish,
+  and exec() to return \a r.
+
+  As with QWidget::close(), done() deletes the dialog if the \c
+  WDestructiveClose flag is set. If the dialog is the application's
+  main widget, the application terminates. If the dialog is the
+  last window closed, the QApplication::lastWindowClosed() signal is
+  emitted.
+
+  \sa accept(), reject(), QApplication::mainWidget(), QApplication::quit()
+*/
+
+void QDialog::done( int r )
+{
+    hide();
+    setResult( r );
+
+    // emulate QWidget::close()
+    bool isMain = qApp->mainWidget() == this;
+    bool checkLastWindowClosed = isTopLevel() && !isPopup();
+    if ( checkLastWindowClosed
+	 && qApp->receivers(SIGNAL(lastWindowClosed())) ) {
+	/* if there is no non-withdrawn top level window left (except
+	   the desktop, popups, or dialogs with parents), we emit the
+	   lastWindowClosed signal */
+	QWidgetList *list   = qApp->topLevelWidgets();
+	QWidget     *widget = list->first();
+	while ( widget ) {
+	    if ( !widget->isHidden()
+		 && !widget->isDesktop()
+		 && !widget->isPopup()
+		 && (!widget->isDialog() || !widget->parentWidget()))
+		break;
+	    widget = list->next();
+	}
+	delete list;
+	if ( widget == 0 )
+	    emit qApp->lastWindowClosed();
+    }
+    if ( isMain )
+	qApp->quit();
+    else if ( testWFlags(WDestructiveClose) ) {
+	clearWFlags(WDestructiveClose);
+	deleteLater();
+    }
+}
+
+/*!
+  Hides the modal dialog and sets the result code to \c Accepted.
+
+  \sa reject() done()
+*/
+
+void QDialog::accept()
+{
+    done( Accepted );
+}
+
+/*!
+  Hides the modal dialog and sets the result code to \c Rejected.
+
+  \sa accept() done()
+*/
+
+void QDialog::reject()
+{
+    done( Rejected );
+}
+
+/*! \reimp */
+bool QDialog::eventFilter( QObject *o, QEvent *e )
+{
+    return QWidget::eventFilter( o, e );
+}
+
+/*****************************************************************************
+  Event handlers
+ *****************************************************************************/
+
+/*! \reimp */
+void QDialog::contextMenuEvent( QContextMenuEvent *e )
+{
+#if !defined(QT_NO_WHATSTHIS) && !defined(QT_NO_POPUPMENU)
+    QWidget* w = childAt( e->pos(), TRUE );
+    if ( !w )
+	return;
+    QString s;
+    while ( s.isEmpty() && w ) {
+	s = QWhatsThis::textFor( w, e->pos(), FALSE );
+	if ( s.isEmpty() )
+	    w = w->parentWidget(TRUE);
+    }
+    if ( !s.isEmpty() ) {
+	QPopupMenu p(0,"qt_whats_this_menu");
+	p.insertItem( tr("What's This?"), 42 );
+	if ( p.exec( e->globalPos() ) >= 42 )
+	    QWhatsThis::display( s, w->mapToGlobal( w->rect().center() ), w );
+    }
+#endif
+}
+
+/*! \reimp */
+void QDialog::keyPressEvent( QKeyEvent *e )
+{
+    //   Calls reject() if Escape is pressed. Simulates a button
+    //   click for the default button if Enter is pressed. Move focus
+    //   for the arrow keys. Ignore the rest.
+#ifdef Q_OS_MAC
+    if(e->state() == ControlButton && e->key() == Key_Period) {
+	reject();
+    } else
+#endif
+    if ( e->state() == 0 || ( e->state() & Keypad && e->key() == Key_Enter ) ) {
+	switch ( e->key() ) {
+	case Key_Enter:
+	case Key_Return: {
+#ifndef QT_NO_PUSHBUTTON
+	    QObjectList *list = queryList( "QPushButton" );
+	    QObjectListIt it( *list );
+	    QPushButton *pb;
+	    while ( (pb = (QPushButton*)it.current()) ) {
+		if ( pb->isDefault() && pb->isVisible() ) {
+		    delete list;
+		    if ( pb->isEnabled() ) {
+			emit pb->clicked();
+		    }
+		    return;
+		}
+		++it;
+	    }
+	    delete list;
+#endif
+	}
+	break;
+	case Key_Escape:
+	    reject();
+	    break;
+	case Key_Up:
+	case Key_Left:
+	    if ( focusWidget() &&
+		 ( focusWidget()->focusPolicy() == QWidget::StrongFocus ||
+		   focusWidget()->focusPolicy() == QWidget::WheelFocus ) ) {
+		e->ignore();
+		break;
+	    }
+	    // call ours, since c++ blocks us from calling the one
+	    // belonging to focusWidget().
+	    QFocusEvent::setReason(QFocusEvent::Backtab);
+	    focusNextPrevChild( FALSE );
+	    QFocusEvent::resetReason();
+	    break;
+	case Key_Down:
+	case Key_Right:
+	    if ( focusWidget() &&
+		 ( focusWidget()->focusPolicy() == QWidget::StrongFocus ||
+		   focusWidget()->focusPolicy() == QWidget::WheelFocus ) ) {
+		e->ignore();
+		break;
+	    }
+	    QFocusEvent::setReason(QFocusEvent::Tab);
+	    focusNextPrevChild( TRUE );
+	    QFocusEvent::resetReason();
+	    break;
+	default:
+	    e->ignore();
+	    return;
+	}
+    } else {
+	e->ignore();
+    }
+}
+
+/*! \reimp */
+void QDialog::closeEvent( QCloseEvent *e )
+{
+#ifndef QT_NO_WHATSTHIS
+    if ( isModal() && QWhatsThis::inWhatsThisMode() )
+	QWhatsThis::leaveWhatsThisMode();
+#endif
+    if ( isShown() )
+	reject();
+    if ( isHidden() )
+	e->accept();
+}
+
+#ifdef Q_OS_TEMP
+/*! \internal
+    \reimp
+*/
+bool QDialog::event( QEvent *e )
+{
+    switch ( e->type() ) {
+    case QEvent::OkRequest:
+    case QEvent::HelpRequest:
+	{
+	    QString bName =
+		(e->type() == QEvent::OkRequest)
+		? qApp->translate( "QMessageBox", mb_texts[QMessageBox::Ok] )
+		: qApp->tr( "Help" );
+
+	    QObjectList *list = queryList( "QPushButton" );
+	    QObjectListIt it( *list );
+	    QPushButton *pb;
+	    while ( (pb = (QPushButton*)it.current()) ) {
+		if ( pb->text() == bName ) {
+		    delete list;
+		    if ( pb->isEnabled() )
+			emit pb->clicked();
+		    return pb->isEnabled();
+		}
+		++it;
+	    }
+	    delete list;
+	}
+    }
+    return QWidget::event( e );
+}
+#endif
+
+
+/*****************************************************************************
+  Geometry management.
+ *****************************************************************************/
+
+#if defined(Q_WS_X11)
+extern "C" { int XSetTransientForHint( Display *, unsigned long, unsigned long ); }
+#include <private/qt_x11_p.h>
+#undef FocusIn
+// defined in qapplication_x11.cpp
+extern Atom qt_net_wm_full_placement;
+extern bool qt_net_supports(Atom atom);
+#endif // Q_WS_X11
+
+/*!
+    Shows the dialog as a \link #modeless modeless \endlink dialog.
+    Control returns immediately to the calling code.
+
+    The dialog will be modal or modeless according to the value
+    of the \l modal property.
+
+    \sa exec(), modal
+*/
+
+void QDialog::show()
+{
+    if ( testWState(WState_Visible) )
+	return;
+
+    uint state = windowState();
+
+    if ( !did_resize )
+	adjustSize();
+    if( !qt_net_supports( qt_net_wm_full_placement )) {
+	if ( has_relpos && !did_move ) {
+	    adjustPositionInternal( parentWidget(), TRUE );
+	} else if ( !did_move ) {
+	    adjustPositionInternal( parentWidget() );
+	}
+    }
+
+    if (windowState() != state)
+	setWindowState(state);
+
+#if defined(Q_WS_X11)
+    if (!parentWidget() && testWFlags(WShowModal)
+	&& qApp->mainWidget() && qApp->mainWidget()->isVisible()
+	&& !qApp->mainWidget()->isMinimized()) {
+	// make sure the transient for hint is set properly for modal dialogs
+        x11SetWindowTransient( qApp->mainWidget());
+    }
+#endif // Q_WS_X11
+
+#ifdef Q_OS_TEMP
+    hideSpecial();
+#endif
+
+    QWidget::show();
+    showExtension( d->doShowExtension );
+#ifndef QT_NO_PUSHBUTTON
+    QWidget *fw = focusWidget();
+    QFocusData *fd = focusData();
+
+    /*
+      The following block is to handle a special case, and does not
+      really follow propper logic in concern of autoDefault and TAB
+      order. However, it's here to ease usage for the users. If a
+      dialog has a default QPushButton, and first widget in the TAB
+      order also is a QPushButton, then we give focus to the main
+      default QPushButton. This simplifies code for the developers,
+      and actually catches most cases... If not, then they simply
+      have to use [widget*]->setFocus() themselves...
+    */
+    if ( !fw || fw->focusPolicy() == NoFocus ) {
+	fd->home(); // Skip main form
+	QWidget *first = fd->next(); // Get first main widget
+	if ( d->mainDef &&
+	     first != d->mainDef &&
+	     ::qt_cast<QPushButton*>(first) )
+	    d->mainDef->setFocus();
+    }
+
+    if ( !d->mainDef && isTopLevel() ) {
+	if ( !fw || fw->focusPolicy() == NoFocus ) {
+	    focusNextPrevChild( TRUE );
+	    fw = focusWidget();
+	}
+	if ( fw ) {
+	    fd = focusData();
+	    QWidget *home = fd->home();
+	    QWidget *candidate = home;
+	    Q_ASSERT( candidate == fw );
+	    do {
+		QPushButton *pb = ::qt_cast<QPushButton*>(candidate);
+		if ( pb && pb->autoDefault() ) {
+		    pb->setDefault( TRUE );
+		    break;
+		}
+		candidate = fd->next();
+	    } while ( candidate != home );
+	}
+    }
+    if ( fw ) {
+	QFocusEvent e( QEvent::FocusIn );
+	QFocusEvent::setReason( QFocusEvent::Tab );
+	QApplication::sendEvent( fw, &e );
+	QFocusEvent::resetReason();
+    }
+
+#endif
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+    QAccessible::updateAccessibility( this, 0, QAccessible::DialogStart );
+#endif
+}
+
+/*! \internal */
+void QDialog::adjustPosition( QWidget* w)
+{
+    adjustPositionInternal( w );
+}
+
+
+void QDialog::adjustPositionInternal( QWidget*w, bool useRelPos)
+{
+    /* need to make sure these events are already sent to be sure
+       our information below is correct --sam */
+    QApplication::sendPostedEvents( this, QEvent::LayoutHint );
+    QApplication::sendPostedEvents( this, QEvent::Resize );
+
+    // processing the events might call polish(), which is a nice place
+    // to restore geometries, so return if the dialog has been positioned
+    if ( did_move || has_relpos )
+	return;
+
+    QPoint p( 0, 0 );
+    int extraw = 0, extrah = 0, scrn = 0;
+    if ( w )
+	w = w->topLevelWidget();
+    QRect desk;
+    if ( w ) {
+	// Use mapToGlobal rather than geometry() in case w might
+	// be embedded in another application
+	scrn = QApplication::desktop()->screenNumber( w->mapToGlobal( QPoint(0,0) ) );
+    } else if ( QApplication::desktop()->isVirtualDesktop() ) {
+	scrn = QApplication::desktop()->screenNumber( QCursor::pos() );
+    } else {
+	scrn = QApplication::desktop()->screenNumber( this );
+    }
+    desk = QApplication::desktop()->availableGeometry( scrn );
+
+    QWidgetList  *list = QApplication::topLevelWidgets();
+    QWidgetListIt it( *list );
+    while ( (extraw == 0 || extrah == 0) &&
+	    it.current() != 0 ) {
+	int framew, frameh;
+	QWidget * current = it.current();
+	++it;
+	if ( ! current->isVisible() )
+	    continue;
+
+	framew = current->geometry().x() - current->x();
+	frameh = current->geometry().y() - current->y();
+
+	extraw = QMAX( extraw, framew );
+	extrah = QMAX( extrah, frameh );
+    }
+    delete list;
+
+    // sanity check for decoration frames. With embedding, we
+    // might get extraordinary values
+    if ( extraw == 0 || extrah == 0 || extraw >= 10 || extrah >= 40 ) {
+	extrah = 40;
+	extraw = 10;
+    }
+
+    if ( useRelPos && w ) {
+	p = w->pos() + d->relPos;
+    } else {
+#ifndef Q_OS_TEMP
+	if ( w ) {
+	    // Use mapToGlobal rather than geometry() in case w might
+	    // be embedded in another application
+	    QPoint pp = w->mapToGlobal( QPoint(0,0) );
+	    p = QPoint( pp.x() + w->width()/2,
+			pp.y() + w->height()/ 2 );
+	} else {
+	    // p = middle of the desktop
+	    p = QPoint( desk.x() + desk.width()/2, desk.y() + desk.height()/2 );
+	}
+#else
+	p = QPoint( desk.x() + desk.width()/2, desk.y() + desk.height()/2 );
+#endif
+
+	// p = origin of this
+	p = QPoint( p.x()-width()/2 - extraw,
+		    p.y()-height()/2 - extrah );
+    }
+
+
+    if ( p.x() + extraw + width() > desk.x() + desk.width() )
+	p.setX( desk.x() + desk.width() - width() - extraw );
+    if ( p.x() < desk.x() )
+	p.setX( desk.x() );
+
+    if ( p.y() + extrah + height() > desk.y() + desk.height() )
+	p.setY( desk.y() + desk.height() - height() - extrah );
+    if ( p.y() < desk.y() )
+	p.setY( desk.y() );
+
+    move( p );
+    did_move = !useRelPos;
+}
+
+
+/*! \reimp */
+void QDialog::hide()
+{
+    if ( isHidden() )
+	return;
+
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+    if ( isVisible() )
+	QAccessible::updateAccessibility( this, 0, QAccessible::DialogEnd );
+#endif
+
+    if ( parentWidget() && !did_move ) {
+	d->relPos = pos() - parentWidget()->topLevelWidget()->pos();
+	has_relpos = 1;
+    }
+
+    // Reimplemented to exit a modal when the dialog is hidden.
+    QWidget::hide();
+    if ( in_loop ) {
+	in_loop = FALSE;
+	qApp->exit_loop();
+    }
+}
+
+
+/*****************************************************************************
+  Detects any widget geometry changes done by the user.
+ *****************************************************************************/
+
+/*! \reimp */
+
+void QDialog::move( int x, int y )
+{
+    did_move = TRUE;
+    QWidget::move( x, y );
+}
+
+/*! \reimp */
+
+void QDialog::move( const QPoint &p )
+{
+    did_move = TRUE;
+    QWidget::move( p );
+}
+
+/*! \reimp */
+
+void QDialog::resize( int w, int h )
+{
+    did_resize = TRUE;
+    QWidget::resize( w, h );
+}
+
+/*! \reimp */
+
+void QDialog::resize( const QSize &s )
+{
+    did_resize = TRUE;
+    QWidget::resize( s );
+}
+
+/*! \reimp */
+
+void QDialog::setGeometry( int x, int y, int w, int h )
+{
+    did_move   = TRUE;
+    did_resize = TRUE;
+    QWidget::setGeometry( x, y, w, h );
+}
+
+/*! \reimp */
+
+void QDialog::setGeometry( const QRect &r )
+{
+    did_move   = TRUE;
+    did_resize = TRUE;
+    QWidget::setGeometry( r );
+}
+
+
+/*!
+    If \a orientation is \c Horizontal, the extension will be displayed
+    to the right of the dialog's main area. If \a orientation is \c
+    Vertical, the extension will be displayed below the dialog's main
+    area.
+
+  \sa orientation(), setExtension()
+*/
+void QDialog::setOrientation( Orientation orientation )
+{
+    d->orientation = orientation;
+}
+
+/*!
+  Returns the dialog's extension orientation.
+
+  \sa setOrientation()
+*/
+Qt::Orientation QDialog::orientation() const
+{
+    return d->orientation;
+}
+
+/*!
+    Sets the widget, \a extension, to be the dialog's extension,
+    deleting any previous extension. The dialog takes ownership of the
+    extension. Note that if 0 is passed any existing extension will be
+    deleted.
+
+  This function must only be called while the dialog is hidden.
+
+  \sa showExtension(), setOrientation(), extension()
+ */
+void QDialog::setExtension( QWidget* extension )
+{
+    delete d->extension;
+    d->extension = extension;
+
+    if ( !extension )
+	return;
+
+    if ( extension->parentWidget() != this )
+	extension->reparent( this, QPoint(0,0) );
+    extension->hide();
+}
+
+/*!
+  Returns the dialog's extension or 0 if no extension has been
+  defined.
+
+  \sa setExtension()
+ */
+QWidget* QDialog::extension() const
+{
+    return d->extension;
+}
+
+
+/*!
+  If \a showIt is TRUE, the dialog's extension is shown; otherwise the
+  extension is hidden.
+
+  This slot is usually connected to the \l QButton::toggled() signal
+  of a QPushButton.
+
+  A dialog with a visible extension is not resizeable.
+
+  \sa show(), setExtension(), setOrientation()
+ */
+void QDialog::showExtension( bool showIt )
+{
+    d->doShowExtension = showIt;
+    if ( !d->extension )
+	return;
+    if ( !testWState(WState_Visible) )
+	return;
+    if ( d->extension->isVisible() == showIt )
+	return;
+
+    if ( showIt ) {
+	d->size = size();
+	d->min = minimumSize();
+	d->max = maximumSize();
+#ifndef QT_NO_LAYOUT
+	if ( layout() )
+	    layout()->setEnabled( FALSE );
+#endif
+	QSize s( d->extension->sizeHint()
+		 .expandedTo( d->extension->minimumSize() )
+		 .boundedTo( d->extension->maximumSize() ) );
+	if ( d->orientation == Horizontal ) {
+	    int h = QMAX( height(), s.height() );
+	    d->extension->setGeometry( width(), 0, s.width(), h );
+	    setFixedSize( width() + s.width(), h );
+	} else {
+	    int w = QMAX( width(), s.width() );
+	    d->extension->setGeometry( 0, height(), w, s.height() );
+	    setFixedSize( w, height() + s.height() );
+	}
+	d->extension->show();
+    } else {
+	d->extension->hide();
+	// workaround for CDE window manager that won't shrink with (-1,-1)
+	setMinimumSize( d->min.expandedTo( QSize( 1, 1 ) ) );
+	setMaximumSize( d->max );
+	resize( d->size );
+#ifndef QT_NO_LAYOUT
+	if ( layout() )
+	    layout()->setEnabled( TRUE );
+#endif
+    }
+}
+
+
+/*! \reimp */
+QSize QDialog::sizeHint() const
+{
+    if ( d->extension )
+	if ( d->orientation == Horizontal )
+	    return QSize( QWidget::sizeHint().width(),
+			QMAX( QWidget::sizeHint().height(),d->extension->sizeHint().height() ) );
+	else
+	    return QSize( QMAX( QWidget::sizeHint().width(), d->extension->sizeHint().width() ),
+			QWidget::sizeHint().height() );
+
+    return QWidget::sizeHint();
+}
+
+
+/*! \reimp */
+QSize QDialog::minimumSizeHint() const
+{
+    if ( d->extension )
+	if (d->orientation == Horizontal )
+	    return QSize( QWidget::minimumSizeHint().width(),
+			QMAX( QWidget::minimumSizeHint().height(), d->extension->minimumSizeHint().height() ) );
+	else
+	    return QSize( QMAX( QWidget::minimumSizeHint().width(), d->extension->minimumSizeHint().width() ),
+			QWidget::minimumSizeHint().height() );
+
+    return QWidget::minimumSizeHint();
+}
+
+/*! \property QDialog::modal
+    \brief whether show() should pop up the dialog as modal or modeless
+
+    By default, this property is false and show() pops up the dialog as
+    modeless.
+
+    exec() ignores the value of this property and always pops up the
+    dialog as modal.
+
+    \sa show(), exec()
+*/
+
+void QDialog::setModal( bool modal )
+{
+    if ( modal )
+	setWFlags( WShowModal );
+    else
+	clearWFlags( WShowModal );
+}
+
+bool QDialog::isModal() const
+{
+    return testWFlags( WShowModal ) != 0;
+}
+
+bool QDialog::isSizeGripEnabled() const
+{
+#ifndef QT_NO_SIZEGRIP
+    return !!d->resizer;
+#else
+    return FALSE;
+#endif
+}
+
+
+void QDialog::setSizeGripEnabled(bool enabled)
+{
+#ifndef QT_NO_SIZEGRIP
+    if ( !enabled != !d->resizer ) {
+	if ( enabled ) {
+	    d->resizer = new QSizeGrip( this, "QDialog::resizer" );
+	    // adjustSize() processes all events, which is suboptimal
+	    d->resizer->resize( d->resizer->sizeHint() );
+	    if ( QApplication::reverseLayout() )
+		d->resizer->move( rect().bottomLeft() -d->resizer->rect().bottomLeft() );
+	    else
+		d->resizer->move( rect().bottomRight() -d->resizer->rect().bottomRight() );
+	    d->resizer->raise();
+	    d->resizer->show();
+	} else {
+	    delete d->resizer;
+	    d->resizer = 0;
+	}
+    }
+#endif //QT_NO_SIZEGRIP
+}
+
+
+
+/*! \reimp */
+void QDialog::resizeEvent( QResizeEvent * )
+{
+#ifndef QT_NO_SIZEGRIP
+    if ( d->resizer ) {
+	if ( QApplication::reverseLayout() )
+	    d->resizer->move( rect().bottomLeft() -d->resizer->rect().bottomLeft() );
+	else
+	    d->resizer->move( rect().bottomRight() -d->resizer->rect().bottomRight() );
+    }
+#endif
+}
+
+#endif // QT_NO_DIALOG
diff --git a/main/dependencies/qt3/src/dialogs/qdialog.h b/main/dependencies/qt3/src/dialogs/qdialog.h
new file mode 100644
index 000000000..612b351b6
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qdialog.h
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Definition of QDialog class
+**
+** Created : 950502
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QDIALOG_H
+#define QDIALOG_H
+
+#ifndef QT_H
+#include "qwidget.h"
+#endif // QT_H
+#ifndef QT_NO_DIALOG
+#if 0
+Q_OBJECT
+#endif
+
+class QPushButton;
+class QDialogPrivate;
+
+class Q_EXPORT QDialog : public QWidget
+{
+friend class QPushButton;
+    Q_OBJECT
+    Q_PROPERTY( bool sizeGripEnabled READ isSizeGripEnabled WRITE setSizeGripEnabled )
+    Q_PROPERTY( bool modal READ isModal WRITE setModal )
+
+public:
+    Q_EXPLICIT QDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE,
+	     WFlags f=0 );
+    ~QDialog();
+
+    enum DialogCode { Rejected, Accepted };
+
+    int		result() const { return rescode; }
+
+    void	show();
+    void	hide();
+    void	move( int x, int y );
+    void	move( const QPoint &p );
+    void	resize( int w, int h );
+    void	resize( const QSize & );
+    void	setGeometry( int x, int y, int w, int h );
+    void	setGeometry( const QRect & );
+
+    void	setOrientation( Orientation orientation );
+    Orientation	orientation() const;
+
+    void	setExtension( QWidget* extension );
+    QWidget*	extension() const;
+
+    QSize	sizeHint() const;
+    QSize	minimumSizeHint() const;
+
+    void setSizeGripEnabled( bool );
+    bool isSizeGripEnabled() const;
+
+    void setModal( bool modal );
+    bool isModal() const;
+#ifdef Q_OS_TEMP
+    bool	event( QEvent * );
+#endif
+
+public slots:
+    int exec();
+
+protected slots:
+    virtual void done( int );
+    virtual void accept();
+    virtual void reject();
+
+    void	showExtension( bool );
+
+protected:
+    void	setResult( int r )	{ rescode = r; }
+    void	keyPressEvent( QKeyEvent * );
+    void	closeEvent( QCloseEvent * );
+    void	resizeEvent( QResizeEvent * );
+    void	contextMenuEvent( QContextMenuEvent * );
+    bool	eventFilter( QObject *, QEvent * );
+    void	adjustPosition( QWidget*);
+
+private:
+    void	setDefault( QPushButton * );
+    void	setMainDefault( QPushButton * );
+    void	hideDefault();
+#ifdef Q_OS_TEMP
+    void	hideSpecial();
+#endif
+
+    int		rescode;
+    uint	did_move   : 1;
+    uint	has_relpos : 1;
+    uint	did_resize : 1;
+    uint	in_loop: 1;
+    void adjustPositionInternal( QWidget*, bool useRelPos = FALSE );
+    QDialogPrivate* d;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QDialog( const QDialog & );
+    QDialog &operator=( const QDialog & );
+#endif
+};
+
+#endif // QT_NO_DIALOG
+#endif // QDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qerrormessage.cpp b/main/dependencies/qt3/src/dialogs/qerrormessage.cpp
new file mode 100644
index 000000000..4e4dc5a8f
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qerrormessage.cpp
@@ -0,0 +1,270 @@
+/****************************************************************************
+**
+** Implementation of a nice qInstallMsgHandler() handler
+**
+** Created : 000527, after Kalle Dalheimer's birthday
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qerrormessage.h"
+
+#ifndef QT_NO_ERRORMESSAGE
+
+#include "qapplication.h"
+#include "qcheckbox.h"
+#include "qdict.h"
+#include "qlabel.h"
+#include "qlayout.h"
+#include "qmessagebox.h"
+#include "qpushbutton.h"
+#include "qstringlist.h"
+#include "qstylesheet.h"
+#include "qtextview.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+class QErrorMessageTextView : public QTextView
+{
+public:
+    QErrorMessageTextView( QWidget *parent, const char *name )
+	: QTextView( parent, name ) { }
+
+    virtual QSize minimumSizeHint() const;
+    virtual QSize sizeHint() const;
+};
+
+QSize QErrorMessageTextView::minimumSizeHint() const
+{
+    return QSize( 50, 50 );
+}
+
+QSize QErrorMessageTextView::sizeHint() const
+{
+    return QSize( 250, 75 );
+}
+
+/*! \class QErrorMessage
+
+  \brief The QErrorMessage class provides an error message display dialog.
+
+  \ingroup dialogs
+  \ingroup misc
+
+This is basically a QLabel and a "show this message again" checkbox which
+remembers what not to show.
+
+There are two ways to use this class:
+\list 1
+\i For production applications. In this context the class can be used to
+display messages which you don't need the user to see more than once. To use
+QErrorMessage like this, you create the dialog in the usual way and call the
+message() slot, or connect signals to it.
+
+\i For developers. In this context the static qtHandler() installs
+a message handler using qInstallMsgHandler() and creates a QErrorMessage
+that displays qDebug(), qWarning() and qFatal() messages.
+\endlist
+
+In both cases QErrorMessage will queue pending messages, and display
+them (or not) in order, as soon as the user presses Enter or clicks OK
+after seeing each message.
+
+\img qerrormessage.png
+
+\sa QMessageBox QStatusBar::message()
+*/
+
+static QErrorMessage * qtMessageHandler = 0;
+
+static void deleteStaticcQErrorMessage() // post-routine
+{
+    if ( qtMessageHandler ) {
+	delete qtMessageHandler;
+	qtMessageHandler = 0;
+    }
+}
+
+static bool metFatal = FALSE;
+
+void jump( QtMsgType t, const char * m )
+{
+    if ( !qtMessageHandler )
+	return;
+
+    QString rich;
+
+    switch ( t ) {
+    case QtDebugMsg:
+    default:
+	rich = QErrorMessage::tr( "Debug Message:" );
+	break;
+    case QtWarningMsg:
+	rich = QErrorMessage::tr( "Warning:" );
+	break;
+    case QtFatalMsg:
+	rich = QErrorMessage::tr( "Fatal Error:" );
+    }
+    rich = QString( "<p><b>%1</b></p>" ).arg( rich );
+    rich += QStyleSheet::convertFromPlainText( m,
+		QStyleSheetItem::WhiteSpaceNormal );
+
+    // ### work around text engine quirk
+    if ( rich.endsWith("</p>") )
+	rich.truncate( rich.length() - 4 );
+
+    if ( !metFatal ) {
+	qtMessageHandler->message( rich );
+	metFatal = ( t == QtFatalMsg );
+    }
+}
+
+
+/*!  Constructs and installs an error handler window.
+    The parent \a parent and name \a name are passed on to the QDialog
+    constructor.
+*/
+
+QErrorMessage::QErrorMessage( QWidget * parent, const char * name )
+    : QDialog( parent, name )
+{
+    QGridLayout * grid = new QGridLayout( this, 3, 2, 11, 6 );
+    icon = new QLabel( this, "qt_icon_lbl" );
+#ifndef QT_NO_MESSAGEBOX
+    icon->setPixmap( QMessageBox::standardIcon(QMessageBox::Information) );
+#endif
+    grid->addWidget( icon, 0, 0, AlignTop );
+    errors = new QErrorMessageTextView( this, "errors" );
+    grid->addWidget( errors, 0, 1 );
+    again = new QCheckBox( tr( "&Show this message again" ), this, "again" );
+    again->setChecked( TRUE );
+    grid->addWidget( again, 1, 1, AlignTop + AlignAuto );
+    ok = new QPushButton( tr( "&OK" ), this, "ok" );
+    connect( ok, SIGNAL(clicked()), this, SLOT(accept()) );
+    ok->setFocus();
+    grid->addMultiCellWidget( ok, 2, 2, 0, 1, AlignCenter );
+    grid->setColStretch( 1, 42 );
+    grid->setRowStretch( 0, 42 );
+    pending = new QStringList;
+    doNotShow = new QDict<int>;
+}
+
+
+/*! Destroys the object and frees any allocated resources.  Notably,
+the list of "do not show again" messages is deleted. */
+
+QErrorMessage::~QErrorMessage()
+{
+    if ( this == qtMessageHandler ) {
+	qtMessageHandler = 0;
+	QtMsgHandler tmp = qInstallMsgHandler( 0 );
+	// in case someone else has later stuck in another...
+	if ( tmp != jump )
+	    qInstallMsgHandler( tmp );
+    }
+
+    delete pending;
+    delete doNotShow;
+}
+
+
+/*! \reimp */
+
+void QErrorMessage::done( int a )
+{
+    int dummy = 0;
+    if ( !again->isChecked() )
+	doNotShow->insert( errors->text(), &dummy );
+    if ( !nextPending() ) {
+	QDialog::done( a );
+	if ( this == qtMessageHandler && metFatal )
+	    exit( 1 );
+    }
+}
+
+
+/*!  Returns a pointer to a QErrorMessage object that outputs the
+default Qt messages.  This function creates such an object, if there
+isn't one already.
+*/
+
+QErrorMessage * QErrorMessage::qtHandler()
+{
+    if ( !qtMessageHandler ) {
+	qtMessageHandler = new QErrorMessage( 0, "automatic message handler" );
+	qAddPostRoutine( deleteStaticcQErrorMessage ); // clean up
+#ifndef QT_NO_WIDGET_TOPEXTRA
+	if ( qApp->mainWidget() )
+	    qtMessageHandler->setCaption( qApp->mainWidget()->caption() );
+#endif
+	qInstallMsgHandler( jump );
+    }
+    return qtMessageHandler;
+}
+
+
+/*! \internal */
+
+bool QErrorMessage::nextPending()
+{
+    while ( !pending->isEmpty() ) {
+	QString p = *pending->begin();
+	pending->remove( pending->begin() );
+	if ( !p.isEmpty() && !doNotShow->find( p ) ) {
+	    errors->setText( p );
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+
+/*! Shows message \a m and returns immediately.  If the user has requested
+  that \a m not be shown, this function does nothing.
+
+  Normally, \a m is shown at once, but if there are pending messages,
+  \a m is queued for later display.
+*/
+
+void QErrorMessage::message( const QString & m )
+{
+    if ( doNotShow->find( m ) )
+	return;
+    pending->append( m );
+    if ( !isVisible() && nextPending() )
+	show();
+}
+
+#endif // QT_NO_ERRORMESSAGE
diff --git a/main/dependencies/qt3/src/dialogs/qerrormessage.h b/main/dependencies/qt3/src/dialogs/qerrormessage.h
new file mode 100644
index 000000000..c1a71498a
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qerrormessage.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Definition of a nice qInstallErrorMessage() handler
+**
+** Created : 000527, after Kalle Dalheimer's birthday
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QERRORMESSAGE_H
+#define QERRORMESSAGE_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#endif // QT_H
+
+#ifndef QT_NO_ERRORMESSAGE
+class QPushButton;
+class QCheckBox;
+class QLabel;
+class QTextView;
+class QStringList;
+template<class type> class QDict;
+
+
+class Q_EXPORT QErrorMessage: public QDialog {
+    Q_OBJECT
+public:
+    QErrorMessage( QWidget* parent, const char* name=0 );
+    ~QErrorMessage();
+
+    static QErrorMessage * qtHandler();
+
+public slots:
+    void message( const QString & );
+
+protected:
+    void done( int );
+
+private:
+    QPushButton * ok;
+    QCheckBox * again;
+    QTextView * errors;
+    QLabel * icon;
+    QStringList * pending;
+    QDict<int> * doNotShow;
+
+    bool nextPending();
+
+#if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator=
+    QErrorMessage( const QErrorMessage & );
+    QErrorMessage &operator=( const QErrorMessage & );
+#endif
+};
+
+#endif //QT_NO_ERRORMESSAGE
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qfiledialog.cpp b/main/dependencies/qt3/src/dialogs/qfiledialog.cpp
new file mode 100644
index 000000000..d69620496
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qfiledialog.cpp
@@ -0,0 +1,6461 @@
+/****************************************************************************
+**
+** Implementation of QFileDialog class
+**
+** Created : 950429
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qplatformdefs.h"
+
+// Solaris redefines connect -> __xnet_connect with _XOPEN_SOURCE_EXTENDED.
+#if defined(connect)
+# undef connect
+#endif
+
+// POSIX Large File Support redefines truncate -> truncate64
+#if defined(truncate)
+# undef truncate
+#endif
+
+#include "qfiledialog.h"
+
+#ifndef QT_NO_FILEDIALOG
+
+#include "private/qapplication_p.h"
+#include "qapplication.h"
+#include "qbitmap.h"
+#include "qbuttongroup.h"
+#include "qcheckbox.h"
+#include "qcleanuphandler.h"
+#include "qcombobox.h"
+#include "qcstring.h"
+#include "qcursor.h"
+#include "qdragobject.h"
+#include "qfile.h"
+#include "qguardedptr.h"
+#include "qhbox.h"
+#include "qheader.h"
+#include "qlabel.h"
+#include "qlayout.h"
+#include "qlibrary.h"
+#include "qlineedit.h"
+#include "qlistbox.h"
+#include "qlistview.h"
+#include "qmap.h"
+#include "qmessagebox.h"
+#include "qmime.h"
+#include "qnetworkprotocol.h"
+#include "qobjectlist.h"
+#include "qpainter.h"
+#include "qpopupmenu.h"
+#include "qprogressbar.h"
+#include "qptrvector.h"
+#include "qpushbutton.h"
+#include "qregexp.h"
+#include "qsemimodal.h"
+#include "qsplitter.h"
+#include "qstrlist.h"
+#include "qstyle.h"
+#include "qtimer.h"
+#include "qtoolbutton.h"
+#include "qtooltip.h"
+#include "qvbox.h"
+#include "qwidgetstack.h"
+
+#ifdef Q_WS_WIN
+#ifdef QT_THREAD_SUPPORT
+#  include <private/qmutexpool_p.h>
+#endif // QT_THREAD_SUPPORT
+#endif // Q_WS_WIN
+
+#if !defined(Q_OS_TEMP)
+#include <time.h>
+#else
+#include <shellapi.h>
+#endif
+#include <stdlib.h>
+#include <limits.h>
+#include <ctype.h>
+
+#ifdef Q_WS_MAC
+#include "qt_mac.h"
+extern QString qt_mac_precomposeFileName(const QString &); // qglobal.cpp
+#undef check
+#endif
+
+/* XPM */
+static const char * const start_xpm[]={
+    "16 15 8 1",
+    "a c #cec6bd",
+    "# c #000000",
+    "e c #ffff00",
+    "b c #999999",
+    "f c #cccccc",
+    "d c #dcdcdc",
+    "c c #ffffff",
+    ". c None",
+    ".....######aaaaa",
+    "...bb#cccc##aaaa",
+    "..bcc#cccc#d#aaa",
+    ".bcef#cccc#dd#aa",
+    ".bcfe#cccc#####a",
+    ".bcef#ccccccccc#",
+    "bbbbbbbbbbbbccc#",
+    "bccccccccccbbcc#",
+    "bcefefefefee#bc#",
+    ".bcefefefefef#c#",
+    ".bcfefefefefe#c#",
+    "..bcfefefefeeb##",
+    "..bbbbbbbbbbbbb#",
+    "...#############",
+    "................"};
+
+/* XPM */
+static const char * const end_xpm[]={
+    "16 15 9 1",
+    "d c #a0a0a0",
+    "c c #c3c3c3",
+    "# c #cec6bd",
+    ". c #000000",
+    "f c #ffff00",
+    "e c #999999",
+    "g c #cccccc",
+    "b c #ffffff",
+    "a c None",
+    "......####aaaaaa",
+    ".bbbb..###aaaaaa",
+    ".bbbb.c.##aaaaaa",
+    ".bbbb....ddeeeea",
+    ".bbbbbbb.bbbbbe.",
+    ".bbbbbbb.bcfgfe.",
+    "eeeeeeeeeeeeefe.",
+    "ebbbbbbbbbbeege.",
+    "ebfgfgfgfgff.ee.",
+    "aebfgfgfgfgfg.e.",
+    "aebgfgfgfgfgf.e.",
+    "aaebgfgfgfgffe..",
+    "aaeeeeeeeeeeeee.",
+    "aaa.............",
+    "aaaaaaaaaaaaaaaa"};
+
+/* XPM */
+static const char* const open_xpm[]={
+    "16 16 6 1",
+    ". c None",
+    "b c #ffff00",
+    "d c #000000",
+    "* c #999999",
+    "c c #cccccc",
+    "a c #ffffff",
+    "................",
+    "................",
+    "...*****........",
+    "..*aaaaa*.......",
+    ".*abcbcba******.",
+    ".*acbcbcaaaaaa*d",
+    ".*abcbcbcbcbcb*d",
+    "*************b*d",
+    "*aaaaaaaaaa**c*d",
+    "*abcbcbcbcbbd**d",
+    ".*abcbcbcbcbcd*d",
+    ".*acbcbcbcbcbd*d",
+    "..*acbcbcbcbb*dd",
+    "..*************d",
+    "...ddddddddddddd",
+    "................"};
+
+/* XPM */
+static const char * const link_dir_xpm[]={
+    "16 16 10 1",
+    "h c #808080",
+    "g c #a0a0a0",
+    "d c #000000",
+    "b c #ffff00",
+    "f c #303030",
+    "# c #999999",
+    "a c #cccccc",
+    "e c #585858",
+    "c c #ffffff",
+    ". c None",
+    "................",
+    "................",
+    "..#####.........",
+    ".#ababa#........",
+    "#abababa######..",
+    "#cccccccccccc#d.",
+    "#cbababababab#d.",
+    "#cabababababa#d.",
+    "#cbababdddddddd.",
+    "#cababadccccccd.",
+    "#cbababdcececcd.",
+    "#cababadcefdfcd.",
+    "#cbababdccgdhcd.",
+    "#######dccchccd.",
+    ".dddddddddddddd.",
+    "................"};
+
+/* XPM */
+static const char * const link_file_xpm[]={
+    "16 16 10 1",
+    "h c #808080",
+    "g c #a0a0a0",
+    "d c #c3c3c3",
+    ". c #7f7f7f",
+    "c c #000000",
+    "b c #bfbfbf",
+    "f c #303030",
+    "e c #585858",
+    "a c #ffffff",
+    "# c None",
+    "################",
+    "..........######",
+    ".aaaaaaaab.#####",
+    ".aaaaaaaaba.####",
+    ".aaaaaaaacccc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaadc###",
+    ".aaaaaaaaaadc###",
+    ".aaaacccccccc###",
+    ".aaaacaaaaaac###",
+    ".aaaacaeaeaac###",
+    ".aaaacaefcfac###",
+    ".aaaacaagchac###",
+    ".ddddcaaahaac###",
+    "ccccccccccccc###"};
+
+/* XPM */
+static const char* const file_xpm[]={
+    "16 16 5 1",
+    ". c #7f7f7f",
+    "# c None",
+    "c c #000000",
+    "b c #bfbfbf",
+    "a c #ffffff",
+    "################",
+    "..........######",
+    ".aaaaaaaab.#####",
+    ".aaaaaaaaba.####",
+    ".aaaaaaaacccc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".aaaaaaaaaabc###",
+    ".bbbbbbbbbbbc###",
+    "ccccccccccccc###"};
+
+/* XPM */
+static const char * const closed_xpm[]={
+    "16 16 6 1",
+    ". c None",
+    "b c #ffff00",
+    "d c #000000",
+    "* c #999999",
+    "a c #cccccc",
+    "c c #ffffff",
+    "................",
+    "................",
+    "..*****.........",
+    ".*ababa*........",
+    "*abababa******..",
+    "*cccccccccccc*d.",
+    "*cbababababab*d.",
+    "*cabababababa*d.",
+    "*cbababababab*d.",
+    "*cabababababa*d.",
+    "*cbababababab*d.",
+    "*cabababababa*d.",
+    "*cbababababab*d.",
+    "**************d.",
+    ".dddddddddddddd.",
+    "................"};
+
+
+/* XPM */
+static const char* const cdtoparent_xpm[]={
+    "15 13 3 1",
+    ". c None",
+    "* c #000000",
+    "a c #ffff99",
+    "..*****........",
+    ".*aaaaa*.......",
+    "***************",
+    "*aaaaaaaaaaaaa*",
+    "*aaaa*aaaaaaaa*",
+    "*aaa***aaaaaaa*",
+    "*aa*****aaaaaa*",
+    "*aaaa*aaaaaaaa*",
+    "*aaaa*aaaaaaaa*",
+    "*aaaa******aaa*",
+    "*aaaaaaaaaaaaa*",
+    "*aaaaaaaaaaaaa*",
+    "***************"};
+
+
+/* XPM */
+static const char* const newfolder_xpm[] = {
+    "15 14 4 1",
+    "	c None",
+    ".	c #000000",
+    "+	c #FFFF00",
+    "@	c #FFFFFF",
+    "          .    ",
+    "               ",
+    "          .    ",
+    "       .     . ",
+    "  ....  . . .  ",
+    " .+@+@.  . .   ",
+    "..........  . .",
+    ".@+@+@+@+@..   ",
+    ".+@+@+@+@+. .  ",
+    ".@+@+@+@+@.  . ",
+    ".+@+@+@+@+.    ",
+    ".@+@+@+@+@.    ",
+    ".+@+@+@+@+.    ",
+    "...........    "};
+
+/* XPM */
+static const char* const detailedview_xpm[]={
+    "14 11 3 1",
+    ". c None",
+    "* c #000000",
+    "a c #000099",
+    ".****.***.***.",
+    "..............",
+    "aaaaaaaaaaaaaa",
+    "..............",
+    ".****.***.***.",
+    "..............",
+    ".****.***.***.",
+    "..............",
+    ".****.***.***.",
+    "..............",
+    ".****.***.***."};
+
+/* XPM */
+static const char* const previewinfoview_xpm[]={
+    "13 13 4 1",
+    ". c #00007f",
+    "a c black",
+    "# c #cec6bd",
+    "b c #000000",
+    "..#####aaaaaa",
+    ".#.#bb#a#####",
+    "...####a#bbb#",
+    "#######a#####",
+    "#######a#bb##",
+    "..#####a#####",
+    ".#.#bb#a#bbb#",
+    "...####a#####",
+    "#######a#bb##",
+    "#######a#####",
+    "..#####a#bbb#",
+    ".#.#bb#a#####",
+    "...####aaaaaa"};
+
+/* XPM */
+static const char* const previewcontentsview_xpm[]={
+    "14 13 5 1",
+    ". c #00007f",
+    "a c black",
+    "c c #7f007f",
+    "# c #cec6bd",
+    "b c #000000",
+    "..#####aaaaaaa",
+    ".#.#bb#a#####a",
+    "...####a#ccc#a",
+    "#######a#ccc#a",
+    "#######a#####a",
+    "..#####a#bbb#a",
+    ".#.#bb#a#####a",
+    "...####a#bbb#a",
+    "#######a#####a",
+    "#######a#bbb#a",
+    "..#####a#####a",
+    ".#.#bb#a#####a",
+    "...####aaaaaaa"};
+
+/* XPM */
+static const char* const mclistview_xpm[]={
+    "15 11 4 1",
+    "* c None",
+    "b c #000000",
+    ". c #000099",
+    "a c #ffffff",
+    "...*****...****",
+    ".a.*bbb*.a.*bbb",
+    "...*****...****",
+    "***************",
+    "...*****...****",
+    ".a.*bbb*.a.*bbb",
+    "...*****...****",
+    "***************",
+    "...*****...****",
+    ".a.*bbb*.a.*bbb",
+    "...*****...****"};
+
+/* XPM */
+static const char * const back_xpm [] = {
+    "13 11 3 1",
+    "a c #00ffff",
+    "# c #000000",
+    ". c None",
+    ".....#.......",
+    "....##.......",
+    "...#a#.......",
+    "..#aa########",
+    ".#aaaaaaaaaa#",
+    "#aaaaaaaaaaa#",
+    ".#aaaaaaaaaa#",
+    "..#aa########",
+    "...#a#.......",
+    "....##.......",
+    ".....#......."};
+
+static QPixmap * openFolderIcon = 0;
+static QPixmap * closedFolderIcon = 0;
+static QPixmap * detailViewIcon = 0;
+static QPixmap * multiColumnListViewIcon = 0;
+static QPixmap * cdToParentIcon = 0;
+static QPixmap * newFolderIcon = 0;
+static QPixmap * fifteenTransparentPixels = 0;
+static QPixmap * symLinkDirIcon = 0;
+static QPixmap * symLinkFileIcon = 0;
+static QPixmap * fileIcon = 0;
+static QPixmap * startCopyIcon = 0;
+static QPixmap * endCopyIcon = 0;
+static QPixmap * previewContentsViewIcon = 0;
+static QPixmap * previewInfoViewIcon = 0;
+static QPixmap *goBackIcon = 0;
+static QFileIconProvider * fileIconProvider = 0;
+static int lastWidth = 0;
+static int lastHeight = 0;
+static QString * workingDirectory = 0;
+
+static bool bShowHiddenFiles = FALSE;
+static int sortFilesBy = (int)QDir::Name;
+static bool sortAscending = TRUE;
+static bool detailViewMode = FALSE;
+
+static QCleanupHandler<QPixmap> qfd_cleanup_pixmap;
+static QCleanupHandler<QString> qfd_cleanup_string;
+
+static QString toRootIfNotExists( const QString &path )
+{
+    if ( !path.isEmpty() )
+        return path;
+
+    const QFileInfoList *drives = QDir::drives();
+    Q_ASSERT( drives && !drives->isEmpty() );
+    return drives->getFirst()->filePath();
+}
+
+static bool isDirectoryMode( int m )
+{
+    return m == QFileDialog::Directory || m == QFileDialog::DirectoryOnly;
+}
+
+static void updateLastSize( QFileDialog *that )
+{
+    int extWidth = 0;
+    int extHeight = 0;
+    if ( that->extension() && that->extension()->isVisible() ) {
+	if ( that->orientation() == Qt::Vertical )
+	    extHeight = that->extension()->height();
+	else
+	    extWidth = that->extension()->width();
+    }
+    lastWidth = that->width() - extWidth;
+    lastHeight = that->height() - extHeight;
+}
+
+// Don't remove the lines below!
+//
+// resolving the W methods manually is needed, because Windows 95 doesn't include
+// these methods in Shell32.lib (not even stubs!), so you'd get an unresolved symbol
+// when Qt calls getEsistingDirectory(), etc.
+#if defined(Q_WS_WIN)
+
+typedef UINT (WINAPI *PtrExtractIconEx)(LPCTSTR,int,HICON*,HICON*,UINT);
+static PtrExtractIconEx ptrExtractIconEx = 0;
+
+static void resolveLibs()
+{
+#ifndef Q_OS_TEMP
+    static bool triedResolve = FALSE;
+
+    if ( !triedResolve ) {
+#ifdef QT_THREAD_SUPPORT
+	// protect initialization
+	QMutexLocker locker( qt_global_mutexpool ?
+			     qt_global_mutexpool->get( &triedResolve ) : 0 );
+	// check triedResolve again, since another thread may have already
+	// done the initialization
+	if ( triedResolve ) {
+	    // another thread did initialize the security function pointers,
+	    // so we shouldn't do it again.
+	    return;
+	}
+#endif
+	triedResolve = TRUE;
+	if ( qt_winunicode ) {
+	    QLibrary lib("shell32");
+	    lib.setAutoUnload( FALSE );
+	    ptrExtractIconEx = (PtrExtractIconEx) lib.resolve( "ExtractIconExW" );
+	}
+    }
+#endif
+}
+#ifdef Q_OS_TEMP
+#define PtrExtractIconEx ExtractIconEx
+#endif
+
+class QWindowsIconProvider : public QFileIconProvider
+{
+public:
+    QWindowsIconProvider( QObject *parent=0, const char *name=0 );
+    ~QWindowsIconProvider();
+
+    const QPixmap * pixmap( const QFileInfo &fi );
+
+private:
+    QPixmap defaultFolder;
+    QPixmap defaultFile;
+    QPixmap defaultExe;
+    QPixmap pix;
+    int pixw, pixh;
+    QMap< QString, QPixmap > cache;
+
+};
+#endif
+
+static void makeVariables() {
+    if ( !openFolderIcon ) {
+	workingDirectory = new QString( ::toRootIfNotExists(QDir::currentDirPath()) );
+        qfd_cleanup_string.add( &workingDirectory );
+
+	openFolderIcon = new QPixmap( (const char **)open_xpm);
+	qfd_cleanup_pixmap.add( &openFolderIcon );
+	symLinkDirIcon = new QPixmap( (const char **)link_dir_xpm);
+	qfd_cleanup_pixmap.add( &symLinkDirIcon );
+	symLinkFileIcon = new QPixmap( (const char **)link_file_xpm);
+	qfd_cleanup_pixmap.add( &symLinkFileIcon );
+	fileIcon = new QPixmap( (const char **)file_xpm);
+	qfd_cleanup_pixmap.add( &fileIcon );
+	closedFolderIcon = new QPixmap( (const char **)closed_xpm);
+	qfd_cleanup_pixmap.add( &closedFolderIcon );
+	detailViewIcon = new QPixmap( (const char **)detailedview_xpm);
+	qfd_cleanup_pixmap.add( &detailViewIcon );
+	multiColumnListViewIcon = new QPixmap( (const char **)mclistview_xpm);
+	qfd_cleanup_pixmap.add( &multiColumnListViewIcon );
+	cdToParentIcon = new QPixmap( (const char **)cdtoparent_xpm);
+	qfd_cleanup_pixmap.add( &cdToParentIcon );
+	newFolderIcon = new QPixmap( (const char **)newfolder_xpm);
+	qfd_cleanup_pixmap.add( &newFolderIcon );
+	previewInfoViewIcon
+	    = new QPixmap( (const char **)previewinfoview_xpm );
+	qfd_cleanup_pixmap.add( &previewInfoViewIcon );
+	previewContentsViewIcon
+	    = new QPixmap( (const char **)previewcontentsview_xpm );
+	qfd_cleanup_pixmap.add( &previewContentsViewIcon );
+	startCopyIcon = new QPixmap( (const char **)start_xpm );
+	qfd_cleanup_pixmap.add( &startCopyIcon );
+	endCopyIcon = new QPixmap( (const char **)end_xpm );
+	qfd_cleanup_pixmap.add( &endCopyIcon );
+	goBackIcon = new QPixmap( (const char **)back_xpm );
+	qfd_cleanup_pixmap.add( &goBackIcon );
+	fifteenTransparentPixels = new QPixmap( closedFolderIcon->width(), 1 );
+	qfd_cleanup_pixmap.add( &fifteenTransparentPixels );
+	QBitmap m( fifteenTransparentPixels->width(), 1 );
+	m.fill( Qt::color0 );
+	fifteenTransparentPixels->setMask( m );
+	bShowHiddenFiles = FALSE;
+	sortFilesBy = (int)QDir::Name;
+	detailViewMode = FALSE;
+#if defined(Q_WS_WIN)
+	if ( !fileIconProvider )
+	    fileIconProvider = new QWindowsIconProvider( qApp );
+#endif
+    }
+}
+
+/******************************************************************
+ *
+ * Definitions of view classes
+ *
+ ******************************************************************/
+
+class QRenameEdit : public QLineEdit
+{
+    Q_OBJECT
+
+public:
+    QRenameEdit( QWidget *parent )
+	: QLineEdit( parent, "qt_rename_edit" ), doRenameAlreadyEmitted(FALSE)
+    {
+	connect( this, SIGNAL(returnPressed()), SLOT(slotReturnPressed()) );
+    }
+
+protected:
+    void keyPressEvent( QKeyEvent *e );
+    void focusOutEvent( QFocusEvent *e );
+
+signals:
+    void cancelRename();
+    void doRename();
+
+private slots:
+    void slotReturnPressed();
+
+private:
+    bool doRenameAlreadyEmitted;
+};
+
+class QFileListBox : public QListBox
+{
+    friend class QFileDialog;
+
+    Q_OBJECT
+
+private:
+    QFileListBox( QWidget *parent, QFileDialog *d );
+
+    void clear();
+    void show();
+    void startRename( bool check = TRUE );
+    void viewportMousePressEvent( QMouseEvent *e );
+    void viewportMouseReleaseEvent( QMouseEvent *e );
+    void viewportMouseDoubleClickEvent( QMouseEvent *e );
+    void viewportMouseMoveEvent( QMouseEvent *e );
+#ifndef QT_NO_DRAGANDDROP
+    void viewportDragEnterEvent( QDragEnterEvent *e );
+    void viewportDragMoveEvent( QDragMoveEvent *e );
+    void viewportDragLeaveEvent( QDragLeaveEvent *e );
+    void viewportDropEvent( QDropEvent *e );
+    bool acceptDrop( const QPoint &pnt, QWidget *source );
+    void setCurrentDropItem( const QPoint &pnt );
+#endif
+    void keyPressEvent( QKeyEvent *e );
+
+private slots:
+    void rename();
+    void cancelRename();
+    void doubleClickTimeout();
+    void changeDirDuringDrag();
+    void dragObjDestroyed();
+    void contentsMoved( int, int );
+
+private:
+    QRenameEdit *lined;
+    QFileDialog *filedialog;
+    bool renaming;
+    QTimer* renameTimer;
+    QListBoxItem *renameItem, *dragItem;
+    QPoint pressPos, oldDragPos;
+    bool mousePressed;
+    int urls;
+    QString startDragDir;
+    QListBoxItem *currDropItem;
+    QTimer *changeDirTimer;
+    bool firstMousePressEvent;
+    QUrlOperator startDragUrl;
+
+};
+
+
+class QFileDialogQFileListView : public QListView
+{
+    Q_OBJECT
+
+public:
+    QFileDialogQFileListView( QWidget *parent, QFileDialog *d );
+
+    void clear();
+    void startRename( bool check = TRUE );
+    void setSorting( int column, bool increasing = TRUE );
+
+    QRenameEdit *lined;
+    bool renaming;
+    QListViewItem *renameItem;
+
+private:
+    void viewportMousePressEvent( QMouseEvent *e );
+    void viewportMouseDoubleClickEvent( QMouseEvent *e );
+    void keyPressEvent( QKeyEvent *e );
+    void viewportMouseReleaseEvent( QMouseEvent *e );
+    void viewportMouseMoveEvent( QMouseEvent *e );
+#ifndef QT_NO_DRAGANDDROP
+    void viewportDragEnterEvent( QDragEnterEvent *e );
+    void viewportDragMoveEvent( QDragMoveEvent *e );
+    void viewportDragLeaveEvent( QDragLeaveEvent *e );
+    void viewportDropEvent( QDropEvent *e );
+    bool acceptDrop( const QPoint &pnt, QWidget *source );
+    void setCurrentDropItem( const QPoint &pnt );
+#endif
+
+private slots:
+    void rename();
+    void cancelRename();
+    void changeSortColumn2( int column );
+    void doubleClickTimeout();
+    void changeDirDuringDrag();
+    void dragObjDestroyed();
+    void contentsMoved( int, int );
+
+private:
+    QFileDialog *filedialog;
+    QTimer* renameTimer;
+    QPoint pressPos, oldDragPos;
+    bool mousePressed;
+    int urls;
+    QString startDragDir;
+    QListViewItem *currDropItem, *dragItem;
+    QTimer *changeDirTimer;
+    bool firstMousePressEvent;
+    bool ascending;
+    int sortcolumn;
+    QUrlOperator startDragUrl;
+
+};
+
+/****************************************************************************
+ *
+ * Classes for copy progress dialog
+ *
+ ****************************************************************************/
+
+class QFDProgressAnimation : public QWidget
+{
+    Q_OBJECT
+
+public:
+    QFDProgressAnimation( QWidget *parent );
+    void start();
+
+private slots:
+    void next();
+
+protected:
+    void paintEvent( QPaintEvent *e );
+
+private:
+    int step;
+    QTimer *timer;
+
+};
+
+QFDProgressAnimation::QFDProgressAnimation( QWidget *parent )
+    : QWidget( parent, "qt_progressanimation" )
+{
+    setFixedSize( 300, 50 );
+    step = -1;
+    next();
+    timer = new QTimer( this );
+    connect( timer, SIGNAL( timeout() ),
+	     this, SLOT( next() ) );
+}
+
+void QFDProgressAnimation::start()
+{
+    timer->start( 150, FALSE );
+}
+
+void QFDProgressAnimation::next()
+{
+    ++step;
+    if ( step > 10 )
+	step = 0;
+    repaint();
+}
+
+void QFDProgressAnimation::paintEvent( QPaintEvent * )
+{
+    erase();
+
+    QPainter p;
+    p.begin( this );
+    if ( step == 0 ) {
+	p.drawPixmap( 5, ( height() - startCopyIcon->height() ) / 2,
+		      *startCopyIcon );
+	p.drawPixmap( width() - 5 - openFolderIcon->width(),
+		      ( height() - openFolderIcon->height() ) / 2 , *openFolderIcon );
+    } else if ( step == 10 ) {
+	p.drawPixmap( 5, ( height() - openFolderIcon->height() ) / 2,
+		      *openFolderIcon );
+	p.drawPixmap( width() - 5 - endCopyIcon->width(),
+		      ( height() - endCopyIcon->height() ) / 2 , *endCopyIcon );
+    } else {
+	p.drawPixmap( 5, ( height() - openFolderIcon->height() ) / 2,
+		      *openFolderIcon );
+	p.drawPixmap( width() - 5 - openFolderIcon->width(),
+		      ( height() - openFolderIcon->height() ) / 2 , *openFolderIcon );
+	int x = 10 + openFolderIcon->width();
+	int w = width() - 2 * x;
+	int s = w / 9;
+	p.drawPixmap( x + s * step, ( height() - fileIcon->height() ) / 2 - fileIcon->height(),
+		      *fileIcon );
+    }
+}
+
+
+class QFDProgressDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    QFDProgressDialog( QWidget *parent, const QString &fn, int steps );
+
+    void setReadProgress( int p );
+    void setWriteProgress( int p );
+    void setWriteLabel( const QString &s );
+
+signals:
+    void cancelled();
+
+private:
+    QProgressBar *readBar;
+    QProgressBar *writeBar;
+    QLabel *writeLabel;
+    QFDProgressAnimation *animation;
+
+};
+
+QFDProgressDialog::QFDProgressDialog( QWidget *parent, const QString &fn, int steps )
+    : QDialog( parent, "", TRUE )
+{
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    setCaption( QFileDialog::tr( "Copy or Move a File" ) );
+#endif
+    QVBoxLayout *layout = new QVBoxLayout( this );
+    layout->setSpacing( 5 );
+    layout->setMargin( 5 );
+
+    animation = new QFDProgressAnimation( this );
+    layout->addWidget( animation );
+
+    layout->addWidget( new QLabel( QFileDialog::tr( "Read: %1" ).arg( fn ),
+		       this, "qt_read_lbl" ) );
+    readBar = new QProgressBar( steps, this, "qt_readbar" );
+    readBar->reset();
+    readBar->setProgress( 0 );
+    layout->addWidget( readBar );
+    writeLabel = new QLabel( QFileDialog::tr( "Write: %1" ).arg( QString::null ),
+			     this, "qt_write_lbl" );
+    layout->addWidget( writeLabel );
+    writeBar = new QProgressBar( steps, this, "qt_writebar" );
+    writeBar->reset();
+    writeBar->setProgress( 0 );
+    layout->addWidget( writeBar );
+
+    QPushButton *b = new QPushButton( QFileDialog::tr( "Cancel" ), this,
+				      "qt_cancel_btn" );
+    b->setFixedSize( b->sizeHint() );
+    layout->addWidget( b );
+    connect( b, SIGNAL( clicked() ),
+	     this, SIGNAL( cancelled() ) );
+
+    animation->start();
+}
+
+void QFDProgressDialog::setReadProgress( int p )
+{
+    readBar->setProgress( p );
+}
+
+void QFDProgressDialog::setWriteProgress( int p )
+{
+    writeBar->setProgress( p );
+}
+
+void QFDProgressDialog::setWriteLabel( const QString &s )
+{
+    writeLabel->setText( QFileDialog::tr( "Write: %1" ).arg( s ) );
+}
+
+/************************************************************************
+ *
+ * Private QFileDialog members
+ *
+ ************************************************************************/
+
+class QFileDialogPrivate {
+public:
+    ~QFileDialogPrivate();
+
+    QStringList history;
+
+    bool geometryDirty;
+    QComboBox * paths;
+    QComboBox * types;
+    QLabel * pathL;
+    QLabel * fileL;
+    QLabel * typeL;
+
+    QVBoxLayout * topLevelLayout;
+    QHBoxLayout *buttonLayout, *leftLayout, *rightLayout;
+    QPtrList<QHBoxLayout> extraWidgetsLayouts;
+    QPtrList<QLabel> extraLabels;
+    QPtrList<QWidget> extraWidgets;
+    QPtrList<QWidget> extraButtons;
+    QPtrList<QButton> toolButtons;
+
+    QWidgetStack * stack;
+
+    QToolButton * cdToParent, *newFolder, * detailView, * mcView,
+	*previewInfo, *previewContents, *goBack;
+    QButtonGroup * modeButtons;
+
+    QString currentFileName;
+    QListViewItem *last;
+
+    QListBoxItem *lastEFSelected;
+
+    struct File: public QListViewItem {
+	File( QFileDialogPrivate * dlgp,
+	      const QUrlInfo * fi, QListViewItem * parent )
+	    : QListViewItem( parent, dlgp->last ), info( *fi ), d(dlgp), i( 0 ), hasMimePixmap( FALSE )
+	{ setup(); dlgp->last = this; }
+	File( QFileDialogPrivate * dlgp,
+	      const QUrlInfo * fi, QListView * parent )
+	    : QListViewItem( parent, dlgp->last ), info( *fi ), d(dlgp), i( 0 ), hasMimePixmap( FALSE )
+	{ setup(); dlgp->last = this; }
+	File( QFileDialogPrivate * dlgp,
+	      const QUrlInfo * fi, QListView * parent, QListViewItem * after )
+	    : QListViewItem( parent, after ), info( *fi ), d(dlgp), i( 0 ), hasMimePixmap( FALSE )
+	{ setup(); if ( !nextSibling() ) dlgp->last = this; }
+	~File();
+
+	QString text( int column ) const;
+	const QPixmap * pixmap( int ) const;
+
+	QUrlInfo info;
+	QFileDialogPrivate * d;
+	QListBoxItem *i;
+	bool hasMimePixmap;
+    };
+
+    class MCItem: public QListBoxItem {
+    public:
+	MCItem( QListBox *, QListViewItem * item );
+	MCItem( QListBox *, QListViewItem * item, QListBoxItem *after );
+	QString text() const;
+	const QPixmap *pixmap() const;
+	int height( const QListBox * ) const;
+	int width( const QListBox * ) const;
+	void paint( QPainter * );
+	QListViewItem * i;
+    };
+
+    class UrlInfoList : public QPtrList<QUrlInfo> {
+    public:
+	UrlInfoList() { setAutoDelete( TRUE ); }
+	int compareItems( QPtrCollection::Item n1, QPtrCollection::Item n2 ) {
+	    if ( !n1 || !n2 )
+		return 0;
+
+	    QUrlInfo *i1 = ( QUrlInfo *)n1;
+	    QUrlInfo *i2 = ( QUrlInfo *)n2;
+
+	    if ( i1->isDir() && !i2->isDir() )
+		return -1;
+	    if ( !i1->isDir() && i2->isDir() )
+		return 1;
+
+	    if ( i1->name() == ".." )
+		return -1;
+	    if ( i2->name() == ".." )
+		return 1;
+
+	    if ( sortFilesBy == QDir::Name ) {
+#if defined(Q_OS_WIN32)
+		QString name1 = i1->name().lower();
+		QString name2 = i2->name().lower();
+		return name1.localeAwareCompare( name2 );
+#else
+		QString name1 = i1->name();
+		QString name2 = i2->name();
+		return name1.localeAwareCompare( name2 );
+#endif
+	    }
+	    if ( QUrlInfo::equal( *i1, *i2, sortFilesBy ) )
+		return 0;
+	    else if ( QUrlInfo::greaterThan( *i1, *i2, sortFilesBy ) )
+		return 1;
+	    else if ( QUrlInfo::lessThan( *i1, *i2, sortFilesBy ) )
+		return -1;
+	    // can't happen...
+	    return 0;
+	}
+	QUrlInfo *operator[]( int i ) {
+	    return at( i );
+	}
+    };
+
+    UrlInfoList sortedList;
+    QPtrList<File> pendingItems;
+
+    QFileListBox * moreFiles;
+
+    QFileDialog::Mode mode;
+
+    QString rw;
+    QString ro;
+    QString wo;
+    QString inaccessible;
+
+    QString symLinkToFile;
+    QString file;
+    QString symLinkToDir;
+    QString dir;
+    QString symLinkToSpecial;
+    QString special;
+    QWidgetStack *preview;
+    bool infoPreview, contentsPreview;
+    QSplitter *splitter;
+    QUrlOperator url, oldUrl;
+    QWidget *infoPreviewWidget, *contentsPreviewWidget;
+    QFilePreview *infoPreviewer, *contentsPreviewer;
+    bool hadDotDot;
+
+    bool ignoreNextKeyPress;
+    // ignores the next refresh operation in case the user forced a selection
+    bool ignoreNextRefresh;
+    QFDProgressDialog *progressDia;
+    bool checkForFilter;
+    bool ignoreStop;
+
+    QTimer *mimeTypeTimer;
+    const QNetworkOperation *currListChildren;
+
+    // this is similar to QUrl::encode but does encode "*" and
+    // doesn't encode whitespaces
+    static QString encodeFileName( const QString& fName ) {
+
+	QString newStr;
+	QCString cName = fName.utf8();
+	const QCString sChars(
+#ifdef Q_WS_WIN
+	    "#%"
+#else
+	    "<>#@\"&%$:,;?={}|^~[]\'`\\*"
+#endif
+	    );
+
+	int len = cName.length();
+	if ( !len )
+	    return QString::null;
+	for ( int i = 0; i < len ;++i ) {
+	    uchar inCh = (uchar)cName[ i ];
+	    if ( inCh >= 128 || sChars.contains(inCh) )
+	    {
+		newStr += QChar( '%' );
+		ushort c = inCh / 16;
+		c += c > 9 ? 'A' - 10 : '0';
+		newStr += (char)c;
+		c = inCh % 16;
+		c += c > 9 ? 'A' - 10 : '0';
+		newStr += (char)c;
+	    } else {
+		newStr += (char)inCh;
+	    }
+	}
+	return newStr;
+    }
+
+    static bool fileExists( const QUrlOperator &url, const QString& name )
+    {
+	QUrl u( url, QFileDialogPrivate::encodeFileName(name) );
+	if ( u.isLocalFile() ) {
+	    QFileInfo f( u.path() );
+	    return f.exists();
+	} else {
+	    QNetworkProtocol *p = QNetworkProtocol::getNetworkProtocol( url.protocol() );
+	    if ( p && (p->supportedOperations()&QNetworkProtocol::OpListChildren) ) {
+		QUrlInfo ui( url, name );
+		return ui.isValid();
+	    }
+	}
+	return TRUE;
+    }
+
+#ifndef Q_NO_CURSOR
+    bool cursorOverride; // Remember if the cursor was overridden or not.
+#endif
+#ifdef Q_WS_WIN
+    int oldPermissionLookup;
+#endif
+};
+
+QFileDialogPrivate::~QFileDialogPrivate()
+{
+    delete modeButtons;
+}
+
+
+
+/************************************************************************
+ *
+ * Internal class QRenameEdit
+ *
+ ************************************************************************/
+
+void QRenameEdit::keyPressEvent( QKeyEvent *e )
+{
+    if ( e->key() == Key_Escape )
+	emit cancelRename();
+    else
+	QLineEdit::keyPressEvent( e );
+    e->accept();
+}
+
+void QRenameEdit::focusOutEvent( QFocusEvent * )
+{
+    if ( !doRenameAlreadyEmitted )
+	emit doRename();
+    else
+	doRenameAlreadyEmitted = FALSE;
+}
+
+void QRenameEdit::slotReturnPressed()
+{
+    doRenameAlreadyEmitted = TRUE;
+    emit doRename();
+}
+
+/************************************************************************
+ *
+ * Internal class QFileListBox
+ *
+ ************************************************************************/
+
+QFileListBox::QFileListBox( QWidget *parent, QFileDialog *dlg )
+    : QListBox( parent, "filelistbox" ), filedialog( dlg ),
+      renaming( FALSE ), renameItem( 0 ), mousePressed( FALSE ),
+      firstMousePressEvent( TRUE )
+{
+    changeDirTimer = new QTimer( this );
+    QVBox *box = new QVBox( viewport(), "qt_vbox" );
+    box->setFrameStyle( QFrame::Box | QFrame::Plain );
+    lined = new QRenameEdit( box );
+    lined->setFixedHeight( lined->sizeHint().height() );
+    box->hide();
+    box->setBackgroundMode( PaletteBase );
+    renameTimer = new QTimer( this );
+    connect( lined, SIGNAL( doRename() ),
+	     this, SLOT (rename() ) );
+    connect( lined, SIGNAL( cancelRename() ),
+	     this, SLOT( cancelRename() ) );
+    connect( renameTimer, SIGNAL( timeout() ),
+	     this, SLOT( doubleClickTimeout() ) );
+    connect( changeDirTimer, SIGNAL( timeout() ),
+	     this, SLOT( changeDirDuringDrag() ) );
+    connect( this, SIGNAL( contentsMoving(int,int) ),
+	     this, SLOT( contentsMoved(int,int) ) );
+    viewport()->setAcceptDrops( TRUE );
+    dragItem = 0;
+}
+
+void QFileListBox::show()
+{
+    setBackgroundMode( PaletteBase );
+    viewport()->setBackgroundMode( PaletteBase );
+    QListBox::show();
+}
+
+void QFileListBox::keyPressEvent( QKeyEvent *e )
+{
+    if ( ( e->key() == Key_Enter ||
+	   e->key() == Key_Return ) &&
+	 renaming )
+	return;
+
+    QString keyPressed = ((QKeyEvent *)e)->text().lower();
+    QChar keyChar = keyPressed[0];
+    bool handled = false;
+    if ( keyChar.isLetterOrNumber() ) {
+	QListBoxItem * i = 0;
+	if ( currentItem() )
+	    i = item( currentItem() );
+	else
+	    i = firstItem();
+	if ( i->next() )
+	    i = i->next();
+	else
+	    i = firstItem();
+	while ( i != item( currentItem() ) ) {
+	    QString it = text( index( i ) );
+	    if ( it[0].lower() == keyChar ) {
+	        clearSelection();
+	        setCurrentItem( i );
+	        handled = true;
+	        e->accept();
+            } else {
+	        if ( i->next() )
+	            i = i->next();
+	        else
+	            i = firstItem();
+	    }
+	}
+    }
+    cancelRename();
+    if (!handled){
+        QListBox::keyPressEvent( e );
+    }
+}
+
+void QFileListBox::viewportMousePressEvent( QMouseEvent *e )
+{
+    pressPos = e->pos();
+    mousePressed = FALSE;
+
+    bool didRename = renaming;
+
+    cancelRename();
+    if ( !hasFocus() && !viewport()->hasFocus() )
+	setFocus();
+
+    if ( e->button() != LeftButton ) {
+	QListBox::viewportMousePressEvent( e );
+	firstMousePressEvent = FALSE;
+	return;
+    }
+
+    int i = currentItem();
+    bool wasSelected = FALSE;
+    if ( i != -1 )
+	wasSelected = item( i )->isSelected();
+    QListBox::mousePressEvent( e );
+
+    QFileDialogPrivate::MCItem *i1 = (QFileDialogPrivate::MCItem*)item( currentItem() );
+    if ( i1 )
+	mousePressed =  ( !( (QFileDialogPrivate::File*)i1->i )->info.isDir() )
+			|| ( filedialog->mode() == QFileDialog::Directory ) || ( filedialog->mode() == QFileDialog::DirectoryOnly );
+
+    if ( itemAt( e->pos() ) != item( i ) ) {
+	firstMousePressEvent = FALSE;
+	return;
+    }
+
+     if ( !firstMousePressEvent && !didRename && i == currentItem() && currentItem() != -1 &&
+	  wasSelected && QUrlInfo( filedialog->d->url, "." ).isWritable() && item( currentItem() )->text() != ".." ) {
+	renameTimer->start( QApplication::doubleClickInterval(), TRUE );
+	renameItem = item( i );
+    }
+
+    firstMousePressEvent = FALSE;
+}
+
+void QFileListBox::viewportMouseReleaseEvent( QMouseEvent *e )
+{
+    dragItem = 0;
+    QListBox::viewportMouseReleaseEvent( e );
+    mousePressed = FALSE;
+}
+
+void QFileListBox::viewportMouseDoubleClickEvent( QMouseEvent *e )
+{
+    renameTimer->stop();
+    QListBox::viewportMouseDoubleClickEvent( e );
+}
+
+void QFileListBox::viewportMouseMoveEvent( QMouseEvent *e )
+{
+    if ( !dragItem )
+	dragItem = itemAt( e->pos() );
+    renameTimer->stop();
+#ifndef QT_NO_DRAGANDDROP
+    if (  ( pressPos - e->pos() ).manhattanLength() > QApplication::startDragDistance() && mousePressed ) {
+	QListBoxItem *item = dragItem;
+	dragItem = 0;
+	if ( item ) {
+	    if ( !itemRect( item ).contains( e->pos() ) )
+		return;
+	    QUriDrag* drag = new QUriDrag( viewport() );
+	    QStringList files;
+	    if ( filedialog->mode() == QFileDialog::ExistingFiles )
+		files = filedialog->selectedFiles();
+	    else
+		files = filedialog->selectedFile();
+	    drag->setFileNames( files );
+
+	    if ( lined->parentWidget()->isVisible() )
+		cancelRename();
+
+	    connect( drag, SIGNAL( destroyed() ),
+		     this, SLOT( dragObjDestroyed() ) );
+	    drag->drag();
+
+	    mousePressed = FALSE;
+	}
+    } else
+#endif
+    {
+	QListBox::viewportMouseMoveEvent( e );
+    }
+
+}
+
+void QFileListBox::dragObjDestroyed()
+{
+#ifndef QT_NO_DRAGANDDROP
+    //#######
+    //filedialog->rereadDir();
+#endif
+}
+
+#ifndef QT_NO_DRAGANDDROP
+void QFileListBox::viewportDragEnterEvent( QDragEnterEvent *e )
+{
+    startDragUrl = filedialog->d->url;
+    startDragDir = filedialog->dirPath();
+    currDropItem = 0;
+
+    if ( !QUriDrag::canDecode( e ) ) {
+	e->ignore();
+	return;
+    }
+
+    QStringList l;
+    QUriDrag::decodeLocalFiles( e, l );
+    urls = (int)l.count();
+
+    if ( acceptDrop( e->pos(), e->source() ) ) {
+	e->accept();
+	setCurrentDropItem( e->pos() );
+    } else {
+	e->ignore();
+	setCurrentDropItem( QPoint( -1, -1 ) );
+    }
+
+    oldDragPos = e->pos();
+}
+
+void QFileListBox::viewportDragMoveEvent( QDragMoveEvent *e )
+{
+    if ( acceptDrop( e->pos(), e->source() ) ) {
+	switch ( e->action() ) {
+	case QDropEvent::Copy:
+	    e->acceptAction();
+	    break;
+	case QDropEvent::Move:
+	    e->acceptAction();
+	    break;
+	case QDropEvent::Link:
+	    break;
+	default:
+	    break;
+	}
+	if ( oldDragPos != e->pos() )
+	    setCurrentDropItem( e->pos() );
+    } else {
+	changeDirTimer->stop();
+	e->ignore();
+	setCurrentDropItem( QPoint( -1, -1 ) );
+    }
+
+    oldDragPos = e->pos();
+}
+
+void QFileListBox::viewportDragLeaveEvent( QDragLeaveEvent * )
+{
+    changeDirTimer->stop();
+    setCurrentDropItem( QPoint( -1, -1 ) );
+//########
+//     if ( startDragDir != filedialog->d->url )
+//	filedialog->setUrl( startDragUrl );
+}
+
+void QFileListBox::viewportDropEvent( QDropEvent *e )
+{
+    changeDirTimer->stop();
+
+    if ( !QUriDrag::canDecode( e ) ) {
+	e->ignore();
+	return;
+    }
+
+    uint i;
+    QStrList l;
+    QUriDrag::decode( e, l );
+
+    bool move = e->action() == QDropEvent::Move;
+//     bool supportAction = move || e->action() == QDropEvent::Copy;
+
+    QUrlOperator dest;
+    if ( currDropItem )
+	dest = QUrlOperator( filedialog->d->url, QFileDialogPrivate::encodeFileName( currDropItem->text() ) );
+    else
+	dest = filedialog->d->url;
+    QStringList lst;
+    for ( i = 0; i < l.count(); ++i ) {
+	lst << l.at( i );
+    }
+
+    // make sure that we can write to the destination before performing the action
+    bool exists = false;
+    QString name = (currDropItem ? QFileDialogPrivate::encodeFileName(currDropItem->text()) : QString("."));
+    QUrlInfo info(filedialog->d->url, name);
+    for ( i = 0; i < lst.count(); ++i ) {
+        int slash = lst[i].findRev('/');
+        QString filename = lst[i].right(lst[i].length() - slash - 1);
+        exists = exists || QFileDialogPrivate::fileExists( dest, filename);
+    }
+    if (info.isWritable() && !exists)
+        filedialog->d->url.copy( lst, dest, move );
+
+    // ##### what is supportAction for?
+    e->acceptAction();
+    currDropItem = 0;
+}
+
+bool QFileListBox::acceptDrop( const QPoint &pnt, QWidget *source )
+{
+    QListBoxItem *item = itemAt( pnt );
+    if ( !item || item && !itemRect( item ).contains( pnt ) ) {
+	if ( source == viewport() && startDragDir == filedialog->dirPath() )
+	    return FALSE;
+	return TRUE;
+    }
+
+    QUrlInfo fi( filedialog->d->url, item->text() );
+
+    if ( fi.isDir() && itemRect( item ).contains( pnt ) )
+	return TRUE;
+    return FALSE;
+}
+
+void QFileListBox::setCurrentDropItem( const QPoint &pnt )
+{
+    changeDirTimer->stop();
+
+    QListBoxItem *item = 0;
+    if ( pnt != QPoint( -1, -1 ) )
+	item = itemAt( pnt );
+    if ( item && !QUrlInfo( filedialog->d->url, item->text() ).isDir() )
+	item = 0;
+    if ( item && !itemRect( item ).contains( pnt ) )
+	item = 0;
+
+    currDropItem = item;
+    if ( currDropItem )
+	setCurrentItem( currDropItem );
+    changeDirTimer->start( 750 );
+}
+#endif // QT_NO_DRAGANDDROP
+
+void QFileListBox::changeDirDuringDrag()
+{
+#ifndef QT_NO_DRAGANDDROP
+    if ( !currDropItem )
+	return;
+    changeDirTimer->stop();
+    QUrl u( filedialog->d->url, QFileDialogPrivate::encodeFileName(currDropItem->text()) );
+    filedialog->setDir( u );
+    currDropItem = 0;
+#endif
+}
+
+void QFileListBox::doubleClickTimeout()
+{
+    startRename();
+    renameTimer->stop();
+}
+
+void QFileListBox::startRename( bool check )
+{
+    if ( check && ( !renameItem || renameItem != item( currentItem() ) ) )
+	return;
+
+    int i = currentItem();
+    setSelected( i, TRUE );
+    QRect r = itemRect( item( i ) );
+    int bdr = item( i )->pixmap() ?
+	      item( i )->pixmap()->width() : 16;
+    int x = r.x() + bdr;
+    int y = r.y();
+    int w = item( i )->width( this ) - bdr;
+    int h = QMAX( lined->height() + 2, r.height() );
+    y = y + r.height() / 2 - h / 2;
+
+    lined->parentWidget()->setGeometry( x, y, w + 6, h );
+    lined->setFocus();
+    lined->setText( item( i )->text() );
+    lined->selectAll();
+    lined->setFrame( FALSE );
+    lined->parentWidget()->show();
+    viewport()->setFocusProxy( lined );
+    renaming = TRUE;
+}
+
+void QFileListBox::clear()
+{
+    cancelRename();
+    QListBox::clear();
+}
+
+void QFileListBox::rename()
+{
+    if ( !lined->text().isEmpty() ) {
+	QString file = currentText();
+
+	if ( lined->text() != file )
+	    filedialog->d->url.rename( file, lined->text() );
+    }
+    cancelRename();
+}
+
+void QFileListBox::cancelRename()
+{
+    renameItem = 0;
+    lined->parentWidget()->hide();
+    viewport()->setFocusProxy( this );
+    renaming = FALSE;
+    updateItem( currentItem() );
+    if ( lined->hasFocus() )
+	viewport()->setFocus();
+}
+
+void QFileListBox::contentsMoved( int, int )
+{
+    changeDirTimer->stop();
+#ifndef QT_NO_DRAGANDDROP
+    setCurrentDropItem( QPoint( -1, -1 ) );
+#endif
+}
+
+/************************************************************************
+ *
+ * Internal class QFileListView
+ *
+ ************************************************************************/
+
+QFileDialogQFileListView::QFileDialogQFileListView( QWidget *parent, QFileDialog *dlg )
+    : QListView( parent, "qt_filedlg_listview" ), renaming( FALSE ), renameItem( 0 ),
+    filedialog( dlg ), mousePressed( FALSE ),
+    firstMousePressEvent( TRUE )
+{
+    changeDirTimer = new QTimer( this );
+    QVBox *box = new QVBox( viewport(), "qt_vbox" );
+    box->setFrameStyle( QFrame::Box | QFrame::Plain );
+    lined = new QRenameEdit( box );
+    lined->setFixedHeight( lined->sizeHint().height() );
+    box->hide();
+    box->setBackgroundMode( PaletteBase );
+    renameTimer = new QTimer( this );
+    connect( lined, SIGNAL( doRename() ),
+	     this, SLOT (rename() ) );
+    connect( lined, SIGNAL( cancelRename() ),
+	     this, SLOT( cancelRename() ) );
+    header()->setMovingEnabled( FALSE );
+    connect( renameTimer, SIGNAL( timeout() ),
+	     this, SLOT( doubleClickTimeout() ) );
+    connect( changeDirTimer, SIGNAL( timeout() ),
+	     this, SLOT( changeDirDuringDrag() ) );
+    disconnect( header(), SIGNAL( sectionClicked(int) ),
+		this, SLOT( changeSortColumn(int) ) );
+    connect( header(), SIGNAL( sectionClicked(int) ),
+	     this, SLOT( changeSortColumn2(int) ) );
+    connect( this, SIGNAL( contentsMoving(int,int) ),
+	     this, SLOT( contentsMoved(int,int) ) );
+
+    viewport()->setAcceptDrops( TRUE );
+    sortcolumn = 0;
+    ascending = TRUE;
+    dragItem = 0;
+}
+
+void QFileDialogQFileListView::setSorting( int column, bool increasing )
+{
+    if ( column == -1 ) {
+	QListView::setSorting( column, increasing );
+	return;
+    }
+
+    sortAscending = ascending = increasing;
+    sortcolumn = column;
+    switch ( column ) {
+    case 0:
+	sortFilesBy = QDir::Name;
+	break;
+    case 1:
+	sortFilesBy = QDir::Size;
+	break;
+    case 3:
+	sortFilesBy = QDir::Time;
+	break;
+    default:
+	sortFilesBy = QDir::Name; // #### ???
+	break;
+    }
+
+    filedialog->resortDir();
+}
+
+void QFileDialogQFileListView::changeSortColumn2( int column )
+{
+    int lcol = header()->mapToLogical( column );
+    setSorting( lcol, sortcolumn == lcol ? !ascending : TRUE );
+}
+
+void QFileDialogQFileListView::keyPressEvent( QKeyEvent *e )
+{
+    if ( ( e->key() == Key_Enter ||
+	   e->key() == Key_Return ) &&
+	 renaming )
+	return;
+
+    QString keyPressed = e->text().lower();
+    QChar keyChar = keyPressed[0];
+    if ( keyChar.isLetterOrNumber() ) {
+	QListViewItem * i = 0;
+	if ( currentItem() )
+	i = currentItem();
+	else
+	i = firstChild();
+	if ( i->nextSibling() )
+	i = i->nextSibling();
+	else
+	i = firstChild();
+	while ( i != currentItem() ) {
+	    QString it = i->text(0);
+	    if ( it[0].lower() == keyChar ) {
+	    clearSelection();
+	    ensureItemVisible( i );
+	    setCurrentItem( i );
+	    } else {
+	    if ( i->nextSibling() )
+	    i = i->nextSibling();
+	    else
+	    i = firstChild();
+	    }
+	}
+	return;
+    }
+
+    cancelRename();
+    QListView::keyPressEvent( e );
+}
+
+void QFileDialogQFileListView::viewportMousePressEvent( QMouseEvent *e )
+{
+    pressPos = e->pos();
+    mousePressed = FALSE;
+
+    bool didRename = renaming;
+    cancelRename();
+    if ( !hasFocus() && !viewport()->hasFocus() )
+	setFocus();
+
+    if ( e->button() != LeftButton ) {
+	QListView::viewportMousePressEvent( e );
+	firstMousePressEvent = FALSE;
+	return;
+    }
+
+    QListViewItem *i = currentItem();
+    QListView::viewportMousePressEvent( e );
+
+    QFileDialogPrivate::File *i1 = (QFileDialogPrivate::File*)currentItem();
+    if ( i1 )
+	mousePressed = !i1->info.isDir() || ( filedialog->mode() == QFileDialog::Directory ) || ( filedialog->mode() == QFileDialog::DirectoryOnly );
+
+
+    if ( itemAt( e->pos() ) != i ||
+	 e->x() + contentsX() > columnWidth( 0 ) ) {
+	firstMousePressEvent = FALSE;
+	return;
+    }
+
+    if ( !firstMousePressEvent && !didRename && i == currentItem() && currentItem() &&
+	 QUrlInfo( filedialog->d->url, "." ).isWritable() && currentItem()->text( 0 ) != ".." ) {
+	renameTimer->start( QApplication::doubleClickInterval(), TRUE );
+	renameItem = currentItem();
+    }
+
+    firstMousePressEvent = FALSE;
+}
+
+void QFileDialogQFileListView::viewportMouseDoubleClickEvent( QMouseEvent *e )
+{
+    renameTimer->stop();
+    QListView::viewportMouseDoubleClickEvent( e );
+}
+
+void QFileDialogQFileListView::viewportMouseReleaseEvent( QMouseEvent *e )
+{
+    QListView::viewportMouseReleaseEvent( e );
+    mousePressed = FALSE;
+    dragItem = 0;
+}
+
+void QFileDialogQFileListView::viewportMouseMoveEvent( QMouseEvent *e )
+{
+    renameTimer->stop();
+    if ( !dragItem )
+	dragItem = itemAt( e->pos() );
+#ifndef QT_NO_DRAGANDDROP
+    if (  ( pressPos - e->pos() ).manhattanLength() > QApplication::startDragDistance() && mousePressed ) {
+	QListViewItem *item = dragItem;
+	dragItem = 0;
+	if ( item ) {
+	    QUriDrag* drag = new QUriDrag( viewport() );
+	    QStringList files;
+	    if ( filedialog->mode() == QFileDialog::ExistingFiles )
+		files = filedialog->selectedFiles();
+	    else
+		files = filedialog->selectedFile();
+	    drag->setFileNames( files );
+
+	    if ( lined->isVisible() )
+		cancelRename();
+
+	    connect( drag, SIGNAL( destroyed() ),
+		     this, SLOT( dragObjDestroyed() ) );
+	    drag->drag();
+
+	    mousePressed = FALSE;
+	}
+    }
+#endif
+}
+
+void QFileDialogQFileListView::dragObjDestroyed()
+{
+#ifndef QT_NO_DRAGANDDROP
+    //######
+    //filedialog->rereadDir();
+#endif
+}
+
+#ifndef QT_NO_DRAGANDDROP
+void QFileDialogQFileListView::viewportDragEnterEvent( QDragEnterEvent *e )
+{
+    startDragUrl = filedialog->d->url;
+    startDragDir = filedialog->dirPath();
+    currDropItem = 0;
+
+    if ( !QUriDrag::canDecode( e ) ) {
+	e->ignore();
+	return;
+    }
+
+    QStringList l;
+    QUriDrag::decodeLocalFiles( e, l );
+    urls = (int)l.count();
+
+    if ( acceptDrop( e->pos(), e->source() ) ) {
+	e->accept();
+	setCurrentDropItem( e->pos() );
+    } else {
+	e->ignore();
+	setCurrentDropItem( QPoint( -1, -1 ) );
+    }
+
+    oldDragPos = e->pos();
+}
+
+void QFileDialogQFileListView::viewportDragMoveEvent( QDragMoveEvent *e )
+{
+    if ( acceptDrop( e->pos(), e->source() ) ) {
+	if ( oldDragPos != e->pos() )
+	    setCurrentDropItem( e->pos() );
+	switch ( e->action() ) {
+	case QDropEvent::Copy:
+	    e->acceptAction();
+	    break;
+	case QDropEvent::Move:
+	    e->acceptAction();
+	    break;
+	case QDropEvent::Link:
+	    break;
+	default:
+	    break;
+	}
+    } else {
+	changeDirTimer->stop();
+	e->ignore();
+	setCurrentDropItem( QPoint( -1, -1 ) );
+    }
+
+    oldDragPos = e->pos();
+}
+
+void QFileDialogQFileListView::viewportDragLeaveEvent( QDragLeaveEvent * )
+{
+    changeDirTimer->stop();
+    setCurrentDropItem( QPoint( -1, -1 ) );
+//########
+//     if ( startDragDir != filedialog->d->url )
+//	filedialog->setUrl( startDragUrl );
+}
+
+void QFileDialogQFileListView::viewportDropEvent( QDropEvent *e )
+{
+    changeDirTimer->stop();
+
+    if ( !QUriDrag::canDecode( e ) ) {
+	e->ignore();
+	return;
+    }
+
+    QStringList l;
+    QUriDrag::decodeToUnicodeUris( e, l );
+
+    bool move = e->action() == QDropEvent::Move;
+//     bool supportAction = move || e->action() == QDropEvent::Copy;
+
+    QUrlOperator dest;
+    if ( currDropItem )
+	dest = QUrlOperator( filedialog->d->url, QFileDialogPrivate::encodeFileName( currDropItem->text( 0 ) ) );
+    else
+	dest = filedialog->d->url;
+    
+    // make sure that we can write to the destination before performing the action
+    bool exists = false;
+    QString name = (currDropItem ? QFileDialogPrivate::encodeFileName(currDropItem->text(0)) : QString("."));
+    QUrlInfo info(filedialog->d->url, name);
+    for (uint i = 0; i < l.count(); ++i) {
+        int slash = l[i].findRev('/');
+        QString filename = l[i].right(l[i].length() - slash - 1);
+        exists = exists || QFileDialogPrivate::fileExists(dest, filename);
+    }
+    if (info.isWritable() && !exists)
+        filedialog->d->url.copy( l, dest, move );
+
+    // ##### what is supportAction for?
+    e->acceptAction();
+    currDropItem = 0;
+}
+
+bool QFileDialogQFileListView::acceptDrop( const QPoint &pnt, QWidget *source )
+{
+    QListViewItem *item = itemAt( pnt );
+    if ( !item || item && !itemRect( item ).contains( pnt ) ) {
+	if ( source == viewport() && startDragDir == filedialog->dirPath() )
+	    return FALSE;
+	return TRUE;
+    }
+
+    QUrlInfo fi( filedialog->d->url, item->text( 0 ) );
+
+    if ( fi.isDir() && itemRect( item ).contains( pnt ) )
+	return TRUE;
+    return FALSE;
+}
+
+void QFileDialogQFileListView::setCurrentDropItem( const QPoint &pnt )
+{
+    changeDirTimer->stop();
+
+    QListViewItem *item = itemAt( pnt );
+    if ( pnt == QPoint( -1, -1 ) )
+	item = 0;
+    if ( item && !QUrlInfo( filedialog->d->url, item->text( 0 ) ).isDir() )
+	item = 0;
+
+    if ( item && !itemRect( item ).contains( pnt ) )
+	item = 0;
+
+    currDropItem = item;
+
+    if ( currDropItem )
+	setCurrentItem( currDropItem );
+
+    changeDirTimer->start( 750 );
+}
+#endif // QT_NO_DRAGANDDROP
+
+void QFileDialogQFileListView::changeDirDuringDrag()
+{
+#ifndef QT_NO_DRAGANDDROP
+    if ( !currDropItem )
+	return;
+    changeDirTimer->stop();
+    QUrl u( filedialog->d->url, QFileDialogPrivate::encodeFileName(currDropItem->text( 0 ) ) );
+    filedialog->setDir( u );
+    currDropItem = 0;
+#endif // QT_NO_DRAGANDDROP
+}
+
+
+void QFileDialogQFileListView::doubleClickTimeout()
+{
+    startRename();
+    renameTimer->stop();
+}
+
+void QFileDialogQFileListView::startRename( bool check )
+{
+    if ( check && ( !renameItem || renameItem != currentItem() ) )
+	return;
+
+    QListViewItem *i = currentItem();
+    setSelected( i, TRUE );
+
+    QRect r = itemRect( i );
+    int bdr = i->pixmap( 0 ) ?
+	      i->pixmap( 0 )->width() : 16;
+    int x = r.x() + bdr;
+    int y = r.y();
+    int w = columnWidth( 0 ) - bdr;
+    int h = QMAX( lined->height() + 2, r.height() );
+    y = y + r.height() / 2 - h / 2;
+
+    lined->parentWidget()->setGeometry( x, y, w + 6, h );
+    lined->setFocus();
+    lined->setText( i->text( 0 ) );
+    lined->selectAll();
+    lined->setFrame( FALSE );
+    lined->parentWidget()->show();
+    viewport()->setFocusProxy( lined );
+    renaming = TRUE;
+}
+
+void QFileDialogQFileListView::clear()
+{
+    cancelRename();
+    QListView::clear();
+}
+
+void QFileDialogQFileListView::rename()
+{
+    if ( !lined->text().isEmpty() ) {
+	QString file = currentItem()->text( 0 );
+
+	if ( lined->text() != file )
+	    filedialog->d->url.rename( file, lined->text() );
+    }
+    cancelRename();
+}
+
+void QFileDialogQFileListView::cancelRename()
+{
+    renameItem = 0;
+    lined->parentWidget()->hide();
+    viewport()->setFocusProxy( this );
+    renaming = FALSE;
+    if ( currentItem() )
+	currentItem()->repaint();
+    if ( lined->hasFocus() )
+	viewport()->setFocus();
+}
+
+void QFileDialogQFileListView::contentsMoved( int, int )
+{
+    changeDirTimer->stop();
+#ifndef QT_NO_DRAGANDDROP
+    setCurrentDropItem( QPoint( -1, -1 ) );
+#endif
+}
+
+
+QFileDialogPrivate::File::~File()
+{
+    if ( d->pendingItems.findRef( this ) )
+	d->pendingItems.removeRef( this );
+}
+
+QString QFileDialogPrivate::File::text( int column ) const
+{
+    makeVariables();
+
+    switch( column ) {
+    case 0:
+        return info.name();
+    case 1:
+	if ( info.isFile() ) {
+#if (QT_VERSION-0 >= 0x040000)
+#error "clean up Large File Support"
+#elif defined(QT_ABI_QT4)
+	    QIODevice::Offset size = info.size();
+#else
+	    uint size = info.size();
+#endif
+#if defined(QT_LARGEFILE_SUPPORT) && defined(Q_OS_UNIX)
+	    // ### the following code should not be needed as soon
+	    // ### as QUrlInfo::size() can return 64-bit
+	    if ( size > INT_MAX ) {
+		struct stat buffer;
+		if ( ::stat( QFile::encodeName(info.name()), &buffer ) == 0 ) {
+		    Q_ULLONG size64 = (Q_ULLONG)buffer.st_size;
+		    return QString::number(size64);
+		}
+	    }
+#endif
+	    return QString::number(size);
+	} else {
+	    return QString::fromLatin1("");
+	}
+    case 2:
+	if ( info.isFile() && info.isSymLink() ) {
+	    return d->symLinkToFile;
+	} else if ( info.isFile() ) {
+	    return d->file;
+	} else if ( info.isDir() && info.isSymLink() ) {
+	    return d->symLinkToDir;
+	} else if ( info.isDir() ) {
+	    return d->dir;
+	} else if ( info.isSymLink() ) {
+	    return d->symLinkToSpecial;
+	} else {
+	    return d->special;
+	}
+    case 3: {
+	return info.lastModified().toString( Qt::LocalDate );
+    }
+    case 4:
+	if ( info.isReadable() )
+	    return info.isWritable() ? d->rw : d->ro;
+	else
+	    return info.isWritable() ? d->wo : d->inaccessible;
+    }
+
+    return QString::fromLatin1("<--->");
+}
+
+const QPixmap * QFileDialogPrivate::File::pixmap( int column ) const
+{
+    if ( column ) {
+	return 0;
+    } else if ( QListViewItem::pixmap( column ) ) {
+	return QListViewItem::pixmap( column );
+    } else if ( info.isSymLink() ) {
+	if ( info.isFile() )
+	    return symLinkFileIcon;
+	else
+	    return symLinkDirIcon;
+    } else if ( info.isDir() ) {
+	return closedFolderIcon;
+    } else if ( info.isFile() ) {
+	return fileIcon;
+    } else {
+	return fifteenTransparentPixels;
+    }
+}
+
+QFileDialogPrivate::MCItem::MCItem( QListBox * lb, QListViewItem * item )
+    : QListBoxItem()
+{
+    i = item;
+    if ( lb )
+	lb->insertItem( this );
+}
+
+QFileDialogPrivate::MCItem::MCItem( QListBox * lb, QListViewItem * item, QListBoxItem *after )
+    : QListBoxItem()
+{
+    i = item;
+    if ( lb )
+	lb->insertItem( this, after );
+}
+
+QString QFileDialogPrivate::MCItem::text() const
+{
+    return i->text( 0 );
+}
+
+
+const QPixmap *QFileDialogPrivate::MCItem::pixmap() const
+{
+    return i->pixmap( 0 );
+}
+
+
+int QFileDialogPrivate::MCItem::height( const QListBox * lb ) const
+{
+    int hf = lb->fontMetrics().height();
+    int hp = pixmap() ? pixmap()->height() : 0;
+    return QMAX(hf, hp) + 2;
+}
+
+
+int QFileDialogPrivate::MCItem::width( const QListBox * lb ) const
+{
+    QFontMetrics fm = lb->fontMetrics();
+    int w = 2;
+    if ( pixmap() )
+	w += pixmap()->width() + 4;
+    else
+	w += 18;
+    w += fm.width( text() );
+    w += -fm.minLeftBearing();
+    w += -fm.minRightBearing();
+    w += 6;
+    return w;
+}
+
+
+void QFileDialogPrivate::MCItem::paint( QPainter * ptr )
+{
+    QFontMetrics fm = ptr->fontMetrics();
+
+    int h;
+
+    if ( pixmap() )
+	h = QMAX( fm.height(), pixmap()->height()) + 2;
+    else
+	h = fm.height() + 2;
+
+    const QPixmap * pm = pixmap();
+    if ( pm )
+	ptr->drawPixmap( 2, 1, *pm );
+
+    ptr->drawText( pm ? pm->width() + 4 : 22, h - fm.descent() - 2,
+		   text() );
+}
+
+static QStringList makeFiltersList( const QString &filter )
+{
+    if ( filter.isEmpty() )
+	return QStringList();
+
+    int i = filter.find( ";;", 0 );
+    QString sep( ";;" );
+    if ( i == -1 ) {
+	if ( filter.find( "\n", 0 ) != -1 ) {
+	    sep = "\n";
+	    i = filter.find( sep, 0 );
+	}
+    }
+
+    return QStringList::split( sep, filter );
+}
+
+/*!
+  \class QFileDialog qfiledialog.h
+  \brief The QFileDialog class provides dialogs that allow users to select files or directories.
+  \ingroup dialogs
+  \mainclass
+
+  The QFileDialog class enables a user to traverse their file system in
+  order to select one or many files or a directory.
+
+  The easiest way to create a QFileDialog is to use the static
+  functions. On Windows, these static functions will call the native
+  Windows file dialog and on Mac OS X, these static function will call
+  the native Mac OS X file dialog.
+
+  \code
+    QString s = QFileDialog::getOpenFileName(
+		    "/home",
+		    "Images (*.png *.xpm *.jpg)",
+		    this,
+		    "open file dialog",
+		    "Choose a file" );
+  \endcode
+
+  In the above example, a modal QFileDialog is created using a static
+  function. The startup directory is set to "/home". The file filter
+  is set to "Images (*.png *.xpm *.jpg)". The parent of the file dialog
+  is set to \e this and it is given the identification name - "open file
+  dialog". The caption at the top of file dialog is set to "Choose a
+  file". If you want to use multiple filters, separate each one with
+  \e two semi-colons, e.g.
+  \code
+  "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
+  \endcode
+
+  You can create your own QFileDialog without using the static
+  functions. By calling setMode(), you can set what can be returned by
+  the QFileDialog.
+
+  \code
+    QFileDialog* fd = new QFileDialog( this, "file dialog", TRUE );
+    fd->setMode( QFileDialog::AnyFile );
+  \endcode
+
+  In the above example, the mode of the file dialog is set to \c
+  AnyFile, meaning that the user can select any file, or even specify a
+  file that doesn't exist. This mode is useful for creating a "File Save
+  As" file dialog. Use \c ExistingFile if the user must select an
+  existing file or \c Directory if only a directory may be selected.
+  (See the \l QFileDialog::Mode enum for the complete list of modes.)
+
+  You can retrieve the dialog's mode with mode(). Use setFilter() to set
+  the dialog's file filter, e.g.
+
+  \code
+    fd->setFilter( "Images (*.png *.xpm *.jpg)" );
+  \endcode
+
+  In the above example, the filter is set to "Images (*.png *.xpm
+  *.jpg)", this means that only files with the extension \c png, \c xpm
+  or \c jpg will be shown in the QFileDialog. You can apply
+  several filters by using setFilters() and add additional filters with
+  addFilter(). Use setSelectedFilter() to select one of the filters
+  you've given as the file dialog's default filter. Whenever the user
+  changes the filter the filterSelected() signal is emitted.
+
+  The file dialog has two view modes, QFileDialog::List which simply
+  lists file and directory names and QFileDialog::Detail which
+  displays additional information alongside each name, e.g. file size,
+  modification date, etc. Set the mode with setViewMode().
+
+  \code
+    fd->setViewMode( QFileDialog::Detail );
+  \endcode
+
+  The last important function you will need to use when creating your
+  own file dialog is selectedFile().
+
+  \code
+    QString fileName;
+    if ( fd->exec() == QDialog::Accepted )
+	fileName = fd->selectedFile();
+  \endcode
+
+  In the above example, a modal file dialog is created and shown. If
+  the user clicked OK, then the file they selected is put in \c
+  fileName.
+
+  If you are using the \c ExistingFiles mode then you will need to use
+  selectedFiles() which will return the selected files in a QStringList.
+
+  The dialog's working directory can be set with setDir(). The display
+  of hidden files is controlled with setShowHiddenFiles(). The dialog
+  can be forced to re-read the directory with rereadDir() and re-sort
+  the directory with resortDir(). All the files in the current directory
+  can be selected with selectAll().
+
+  \section1 Creating and using preview widgets
+
+  There are two kinds of preview widgets that can be used with
+  QFileDialogs: \e content preview widgets and \e information preview
+  widgets. They are created and used in the same way except that the
+  function names differ, e.g. setContentsPreview() and setInfoPreview().
+
+  A preview widget is a widget that is placed inside a QFileDialog so
+  that the user can see either the contents of the file, or information
+  about the file.
+
+  \code
+    class Preview : public QLabel, public QFilePreview
+    {
+    public:
+	Preview( QWidget *parent=0 ) : QLabel( parent ) {}
+
+	void previewUrl( const QUrl &u )
+	{
+	    QString path = u.path();
+	    QPixmap pix( path );
+	    if ( pix.isNull() )
+		setText( "This is not a pixmap" );
+	    else
+		setPixmap( pix );
+	}
+    };
+  \endcode
+
+  In the above snippet, we create a preview widget which inherits from
+  QLabel and QFilePreview. File preview widgets \e must inherit from
+  QFilePreview.
+
+  Inside the class we reimplement QFilePreview::previewUrl(), this is
+  where we determine what happens when a file is selected. In the
+  above example we only show a preview of the file if it is a valid
+  pixmap. Here's how to make a file dialog use a preview widget:
+
+  \code
+    Preview* p = new Preview;
+
+    QFileDialog* fd = new QFileDialog( this );
+    fd->setContentsPreviewEnabled( TRUE );
+    fd->setContentsPreview( p, p );
+    fd->setPreviewMode( QFileDialog::Contents );
+    fd->show();
+  \endcode
+
+  The first line creates an instance of our preview widget. We then
+  create our file dialog and call setContentsPreviewEnabled( TRUE ),
+  this tell the file dialog to preview the contents of the currently
+  selected file. We then call setContentsPreview() -- note that we pass
+  the same preview widget twice. Finally, before showing the file
+  dialog, we call setPreviewMode() setting the mode to \e Contents which
+  will show the contents preview of the file that the user has selected.
+
+  If you create another preview widget that is used for displaying
+  information about a file, create it in the same way as the contents
+  preview widget and call setInfoPreviewEnabled(), and
+  setInfoPreview(). Then the user will be able to switch between the
+  two preview modes.
+
+  For more information about creating a QFilePreview widget see
+  \l{QFilePreview}.
+
+  <img src=qfiledlg-m.png> <img src=qfiledlg-w.png>
+
+*/
+
+
+/*! \enum QFileDialog::Mode
+
+  This enum is used to indicate what the user may select in the file
+  dialog, i.e. what the dialog will return if the user clicks OK.
+
+  \value AnyFile  The name of a file, whether it exists or not.
+  \value ExistingFile  The name of a single existing file.
+  \value Directory  The name of a directory. Both files and directories
+  are displayed.
+  \value DirectoryOnly  The name of a directory. The file dialog will only display directories.
+  \value ExistingFiles  The names of zero or more existing files.
+
+  See setMode().
+*/
+
+/*!
+  \enum QFileDialog::ViewMode
+
+  This enum describes the view mode of the file dialog, i.e. what
+  information about each file will be displayed.
+
+  \value List  Display file and directory names with icons.
+  \value Detail  Display file and directory names with icons plus
+  additional information, such as file size and modification date.
+
+  See setViewMode().
+*/
+
+/*!
+  \enum QFileDialog::PreviewMode
+
+  This enum describes the preview mode of the file dialog.
+
+  \value NoPreview  No preview is shown at all.
+  \value Contents  Show a preview of the contents of the current file
+  using the contents preview widget.
+  \value Info  Show information about the current file using the
+  info preview widget.
+
+  See setPreviewMode(), setContentsPreview() and setInfoPreview().
+*/
+
+/*!
+  \fn void QFileDialog::detailViewSelectionChanged()
+  \internal
+*/
+
+/*!
+  \fn void QFileDialog::listBoxSelectionChanged()
+  \internal
+*/
+
+extern const char qt_file_dialog_filter_reg_exp[] =
+	"([a-zA-Z0-9 ]*)\\(([a-zA-Z0-9_.*? +;#\\[\\]]*)\\)$";
+
+/*!
+  Constructs a file dialog called \a name, with the parent, \a parent.
+  If \a modal is TRUE then the file dialog is modal; otherwise it is
+  modeless.
+*/
+
+QFileDialog::QFileDialog( QWidget *parent, const char *name, bool modal )
+    : QDialog( parent, name, modal,
+	       (modal ?
+		(WStyle_Customize | WStyle_DialogBorder | WStyle_Title | WStyle_SysMenu) : 0) )
+{
+    init();
+    d->mode = ExistingFile;
+    d->types->insertItem( tr( "All Files (*)" ) );
+    d->cursorOverride = FALSE;
+    emit dirEntered( d->url.dirPath() );
+    rereadDir();
+}
+
+
+/*!
+  Constructs a file dialog called \a name with the parent, \a parent.
+  If \a modal is TRUE then the file dialog is modal; otherwise it is
+  modeless.
+
+  If \a dirName is specified then it will be used as the dialog's
+  working directory, i.e. it will be the directory that is shown when
+  the dialog appears. If \a filter is specified it will be used as the
+  dialog's file filter.
+
+*/
+
+QFileDialog::QFileDialog( const QString& dirName, const QString & filter,
+			  QWidget *parent, const char *name, bool modal )
+    : QDialog( parent, name, modal,
+	       (modal ?
+		(WStyle_Customize | WStyle_DialogBorder | WStyle_Title | WStyle_SysMenu) : 0) )
+{
+    init();
+    d->mode = ExistingFile;
+    rereadDir();
+    QUrlOperator u( dirName );
+    if ( !dirName.isEmpty() && ( !u.isLocalFile() || QDir( dirName ).exists() ) )
+	setSelection( dirName );
+    else if ( workingDirectory && !workingDirectory->isEmpty() )
+	setDir( *workingDirectory );
+
+    if ( !filter.isEmpty() ) {
+	setFilters( filter );
+	if ( !dirName.isEmpty() ) {
+	    int dotpos = dirName.find( QChar('.'), 0, FALSE );
+	    if ( dotpos != -1 ) {
+		for ( int b=0 ; b<d->types->count() ; b++ ) {
+		    if ( d->types->text(b).contains( dirName.right( dirName.length() - dotpos ) ) ) {
+			d->types->setCurrentItem( b );
+			setFilter( d->types->text( b ) );
+			return;
+		    }
+		}
+	    }
+	}
+    } else {
+	d->types->insertItem( tr( "All Files (*)" ) );
+    }
+}
+
+
+#if defined(Q_WS_WIN)
+extern int qt_ntfs_permission_lookup;
+#endif
+
+/*!
+  \internal
+  Initializes the file dialog.
+*/
+
+void QFileDialog::init()
+{
+    setSizeGripEnabled( TRUE );
+    d = new QFileDialogPrivate();
+    d->mode = AnyFile;
+    d->last = 0;
+    d->lastEFSelected = 0;
+    d->moreFiles = 0;
+    d->infoPreview = FALSE;
+    d->contentsPreview = FALSE;
+    d->hadDotDot = FALSE;
+    d->ignoreNextKeyPress = FALSE;
+    d->progressDia = 0;
+    d->checkForFilter = FALSE;
+    d->ignoreNextRefresh = FALSE;
+    d->ignoreStop = FALSE;
+    d->pendingItems.setAutoDelete( FALSE );
+    d->mimeTypeTimer = new QTimer( this );
+    d->cursorOverride = FALSE;
+#if defined(Q_WS_WIN)
+    d->oldPermissionLookup = qt_ntfs_permission_lookup;
+#endif
+    connect( d->mimeTypeTimer, SIGNAL( timeout() ),
+	     this, SLOT( doMimeTypeLookup() ) );
+
+    d->url = QUrlOperator( ::toRootIfNotExists( QDir::currentDirPath() ) );
+    d->oldUrl = d->url;
+    d->currListChildren = 0;
+
+    connect( &d->url, SIGNAL( start(QNetworkOperation*) ),
+	     this, SLOT( urlStart(QNetworkOperation*) ) );
+    connect( &d->url, SIGNAL( finished(QNetworkOperation*) ),
+	     this, SLOT( urlFinished(QNetworkOperation*) ) );
+    connect( &d->url, SIGNAL( newChildren(const QValueList<QUrlInfo>&,QNetworkOperation*) ),
+	     this, SLOT( insertEntry(const QValueList<QUrlInfo>&,QNetworkOperation*) ) );
+    connect( &d->url, SIGNAL( removed(QNetworkOperation*) ),
+	     this, SLOT( removeEntry(QNetworkOperation*) ) );
+    connect( &d->url, SIGNAL( createdDirectory(const QUrlInfo&,QNetworkOperation*) ),
+	     this, SLOT( createdDirectory(const QUrlInfo&,QNetworkOperation*) ) );
+    connect( &d->url, SIGNAL( itemChanged(QNetworkOperation*) ),
+	     this, SLOT( itemChanged(QNetworkOperation*) ) );
+    connect( &d->url, SIGNAL( dataTransferProgress(int,int,QNetworkOperation*) ),
+	     this, SLOT( dataTransferProgress(int,int,QNetworkOperation*) ) );
+
+    nameEdit = new QLineEdit( this, "name/filter editor" );
+    nameEdit->setMaxLength( 255 ); //_POSIX_MAX_PATH
+    connect( nameEdit, SIGNAL(textChanged(const QString&)),
+	     this,  SLOT(fileNameEditDone()) );
+    nameEdit->installEventFilter( this );
+
+    d->splitter = new QSplitter( this, "qt_splitter" );
+
+    d->stack = new QWidgetStack( d->splitter, "files and more files" );
+
+    d->splitter->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
+
+    files = new QFileDialogQFileListView( d->stack, this );
+    QFontMetrics fm = fontMetrics();
+    files->addColumn( tr("Name") );
+    files->addColumn( tr("Size") );
+    files->setColumnAlignment( 1, AlignRight );
+    files->addColumn( tr("Type") );
+    files->addColumn( tr("Date") );
+    files->addColumn( tr("Attributes") );
+    files->header()->setStretchEnabled( TRUE, 0 );
+
+    files->setMinimumSize( 50, 25 + 2*fm.lineSpacing() );
+
+    connect( files, SIGNAL( selectionChanged() ),
+	     this, SLOT( detailViewSelectionChanged() ) );
+    connect( files, SIGNAL(currentChanged(QListViewItem*)),
+	     this, SLOT(updateFileNameEdit(QListViewItem*)) );
+    connect( files, SIGNAL(doubleClicked(QListViewItem*)),
+	     this, SLOT(selectDirectoryOrFile(QListViewItem*)) );
+    connect( files, SIGNAL(returnPressed(QListViewItem*)),
+	     this, SLOT(selectDirectoryOrFile(QListViewItem*)) );
+    connect( files, SIGNAL(rightButtonPressed(QListViewItem*,const QPoint&,int)),
+	     this, SLOT(popupContextMenu(QListViewItem*,const QPoint&,int)) );
+
+    files->installEventFilter( this );
+    files->viewport()->installEventFilter( this );
+
+    d->moreFiles = new QFileListBox( d->stack, this );
+    d->moreFiles->setRowMode( QListBox::FitToHeight );
+    d->moreFiles->setVariableWidth( TRUE );
+
+    connect( d->moreFiles, SIGNAL(selected(QListBoxItem*)),
+	     this, SLOT(selectDirectoryOrFile(QListBoxItem*)) );
+    connect( d->moreFiles, SIGNAL( selectionChanged() ),
+	     this, SLOT( listBoxSelectionChanged() ) );
+    connect( d->moreFiles, SIGNAL(highlighted(QListBoxItem*)),
+      this, SLOT(updateFileNameEdit(QListBoxItem*)) );
+    connect( d->moreFiles, SIGNAL( rightButtonPressed(QListBoxItem*,const QPoint&) ),
+	     this, SLOT( popupContextMenu(QListBoxItem*,const QPoint&) ) );
+
+    d->moreFiles->installEventFilter( this );
+    d->moreFiles->viewport()->installEventFilter( this );
+
+    okB = new QPushButton( tr("&OK"), this, "OK" ); //### Or "Save (see other "OK")
+    okB->setDefault( TRUE );
+    okB->setEnabled( FALSE );
+    connect( okB, SIGNAL(clicked()), this, SLOT(okClicked()) );
+    cancelB = new QPushButton( tr("Cancel") , this, "Cancel" );
+    connect( cancelB, SIGNAL(clicked()), this, SLOT(cancelClicked()) );
+
+    d->paths = new QComboBox( TRUE, this, "directory history/editor" );
+    d->paths->setDuplicatesEnabled( FALSE );
+    d->paths->setInsertionPolicy( QComboBox::NoInsertion );
+    const QFileInfoList * rootDrives = QDir::drives();
+    QFileInfoListIterator it( *rootDrives );
+    QFileInfo *fi;
+    makeVariables();
+
+    while ( (fi = it.current()) != 0 ) {
+	++it;
+	d->paths->insertItem( *openFolderIcon, fi->absFilePath() );
+    }
+
+    if ( !!QDir::homeDirPath() ) {
+	if ( !d->paths->listBox()->findItem( QDir::homeDirPath() ) )
+	    d->paths->insertItem( *openFolderIcon, QDir::homeDirPath() );
+    }
+
+    connect( d->paths, SIGNAL(activated(const QString&)),
+	     this, SLOT(setDir(const QString&)) );
+
+    d->paths->installEventFilter( this );
+    QObjectList *ol = d->paths->queryList( "QLineEdit" );
+    if ( ol && ol->first() )
+	( (QLineEdit*)ol->first() )->installEventFilter( this );
+    delete ol;
+
+    d->geometryDirty = TRUE;
+    d->types = new QComboBox( TRUE, this, "file types" );
+    d->types->setDuplicatesEnabled( FALSE );
+    d->types->setEditable( FALSE );
+    connect( d->types, SIGNAL(activated(const QString&)),
+	     this, SLOT(setFilter(const QString&)) );
+    connect( d->types, SIGNAL(activated(const QString&)),
+	     this, SIGNAL(filterSelected(const QString&)) );
+
+    d->pathL = new QLabel( d->paths, tr("Look &in:"), this, "qt_looin_lbl" );
+    d->fileL = new QLabel( nameEdit, tr("File &name:"), this, "qt_filename_lbl" );
+    d->typeL = new QLabel( d->types, tr("File &type:"), this, "qt_filetype_lbl" );
+
+    d->goBack = new QToolButton( this, "go back" );
+    d->goBack->setEnabled( FALSE );
+    d->goBack->setFocusPolicy( TabFocus );
+    connect( d->goBack, SIGNAL( clicked() ), this, SLOT( goBack() ) );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->goBack, tr( "Back" ) );
+#endif
+    d->goBack->setIconSet( *goBackIcon );
+
+    d->cdToParent = new QToolButton( this, "cd to parent" );
+    d->cdToParent->setFocusPolicy( TabFocus );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->cdToParent, tr( "One directory up" ) );
+#endif
+    d->cdToParent->setIconSet( *cdToParentIcon );
+    connect( d->cdToParent, SIGNAL(clicked()),
+	     this, SLOT(cdUpClicked()) );
+
+    d->newFolder = new QToolButton( this, "new folder" );
+    d->newFolder->setFocusPolicy( TabFocus );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->newFolder, tr( "Create New Folder" ) );
+#endif
+    d->newFolder->setIconSet( *newFolderIcon );
+    connect( d->newFolder, SIGNAL(clicked()),
+	     this, SLOT(newFolderClicked()) );
+
+    d->modeButtons = new QButtonGroup( 0, "invisible group" );
+    connect( d->modeButtons, SIGNAL(destroyed()),
+	     this, SLOT(modeButtonsDestroyed()) );
+    d->modeButtons->setExclusive( TRUE );
+    connect( d->modeButtons, SIGNAL(clicked(int)),
+	     d->stack, SLOT(raiseWidget(int)) );
+    connect( d->modeButtons, SIGNAL(clicked(int)),
+	     this, SLOT(changeMode(int)) );
+
+    d->mcView = new QToolButton( this, "mclistbox view" );
+    d->mcView->setFocusPolicy( TabFocus );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->mcView, tr( "List View" ) );
+#endif
+    d->mcView->setIconSet( *multiColumnListViewIcon );
+    d->mcView->setToggleButton( TRUE );
+    d->stack->addWidget( d->moreFiles, d->modeButtons->insert( d->mcView ) );
+    d->detailView = new QToolButton( this, "list view" );
+    d->detailView->setFocusPolicy( TabFocus );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->detailView, tr( "Detail View" ) );
+#endif
+    d->detailView->setIconSet( *detailViewIcon );
+    d->detailView->setToggleButton( TRUE );
+    d->stack->addWidget( files, d->modeButtons->insert( d->detailView ) );
+
+    d->previewInfo = new QToolButton( this, "preview info view" );
+    d->previewInfo->setFocusPolicy( TabFocus );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->previewInfo, tr( "Preview File Info" ) );
+#endif
+    d->previewInfo->setIconSet( *previewInfoViewIcon );
+    d->previewInfo->setToggleButton( TRUE );
+    d->modeButtons->insert( d->previewInfo );
+
+    d->previewContents = new QToolButton( this, "preview info view" );
+#if defined(Q_WS_WIN) && !defined(Q_OS_TEMP)
+    if ( (qt_winver & WV_NT_based) > Qt::WV_NT )
+#else
+    if ( !qstrcmp(style().className(), "QWindowsStyle") )
+#endif
+    {
+	d->goBack->setAutoRaise( TRUE );
+	d->cdToParent->setAutoRaise( TRUE );
+	d->newFolder->setAutoRaise( TRUE );
+	d->mcView->setAutoRaise( TRUE );
+	d->detailView->setAutoRaise( TRUE );
+	d->previewInfo->setAutoRaise( TRUE );
+	d->previewContents->setAutoRaise( TRUE );
+    }
+    d->previewContents->setFocusPolicy( TabFocus );
+#ifndef QT_NO_TOOLTIP
+    QToolTip::add( d->previewContents, tr( "Preview File Contents" ) );
+#endif
+    d->previewContents->setIconSet( *previewContentsViewIcon );
+    d->previewContents->setToggleButton( TRUE );
+    d->modeButtons->insert( d->previewContents );
+
+    connect( d->detailView, SIGNAL( clicked() ),
+	     d->moreFiles, SLOT( cancelRename() ) );
+    connect( d->detailView, SIGNAL( clicked() ),
+	     files, SLOT( cancelRename() ) );
+    connect( d->mcView, SIGNAL( clicked() ),
+	     d->moreFiles, SLOT( cancelRename() ) );
+    connect( d->mcView, SIGNAL( clicked() ),
+	     files, SLOT( cancelRename() ) );
+
+    d->stack->raiseWidget( d->moreFiles );
+    d->mcView->setOn( TRUE );
+
+    QHBoxLayout *lay = new QHBoxLayout( this );
+    lay->setMargin( 6 );
+    d->leftLayout = new QHBoxLayout( lay, 5 );
+    d->topLevelLayout = new QVBoxLayout( (QWidget*)0, 5 );
+    lay->addLayout( d->topLevelLayout, 1 );
+    d->extraWidgetsLayouts.setAutoDelete( FALSE );
+    d->extraLabels.setAutoDelete( FALSE );
+    d->extraWidgets.setAutoDelete( FALSE );
+    d->extraButtons.setAutoDelete( FALSE );
+    d->toolButtons.setAutoDelete( FALSE );
+
+    QHBoxLayout * h;
+
+    d->preview = new QWidgetStack( d->splitter, "qt_preview" );
+
+    d->infoPreviewWidget = new QWidget( d->preview, "qt_preview_info" );
+    d->contentsPreviewWidget = new QWidget( d->preview, "qt_preview_contents" );
+    d->infoPreviewer = d->contentsPreviewer = 0;
+
+    h = new QHBoxLayout( 0 );
+    d->buttonLayout = h;
+    d->topLevelLayout->addLayout( h );
+    h->addWidget( d->pathL );
+    h->addSpacing( 8 );
+    h->addWidget( d->paths );
+    h->addSpacing( 8 );
+    if ( d->goBack )
+	h->addWidget( d->goBack );
+    h->addWidget( d->cdToParent );
+    h->addSpacing( 2 );
+    h->addWidget( d->newFolder );
+    h->addSpacing( 4 );
+    h->addWidget( d->mcView );
+    h->addWidget( d->detailView );
+    h->addWidget( d->previewInfo );
+    h->addWidget( d->previewContents );
+
+    d->topLevelLayout->addWidget( d->splitter );
+
+    h = new QHBoxLayout();
+    d->topLevelLayout->addLayout( h );
+    h->addWidget( d->fileL );
+    h->addWidget( nameEdit );
+    h->addSpacing( 15 );
+    h->addWidget( okB );
+
+    h = new QHBoxLayout();
+    d->topLevelLayout->addLayout( h );
+    h->addWidget( d->typeL );
+    h->addWidget( d->types );
+    h->addSpacing( 15 );
+    h->addWidget( cancelB );
+
+    d->rightLayout = new QHBoxLayout( lay, 5 );
+    d->topLevelLayout->setStretchFactor( d->mcView, 1 );
+    d->topLevelLayout->setStretchFactor( files, 1 );
+
+    updateGeometries();
+
+    if ( d->goBack ) {
+	setTabOrder( d->paths, d->goBack );
+	setTabOrder( d->goBack, d->cdToParent );
+    } else {
+	setTabOrder( d->paths, d->cdToParent );
+    }
+    setTabOrder( d->cdToParent, d->newFolder );
+    setTabOrder( d->newFolder, d->mcView );
+    setTabOrder( d->mcView, d->detailView );
+    setTabOrder( d->detailView, d->moreFiles );
+    setTabOrder( d->moreFiles, files );
+    setTabOrder( files, nameEdit );
+    setTabOrder( nameEdit, d->types );
+    setTabOrder( d->types, okB );
+    setTabOrder( okB, cancelB );
+
+    d->rw = tr( "Read-write" );
+    d->ro = tr( "Read-only" );
+    d->wo = tr( "Write-only" );
+    d->inaccessible = tr( "Inaccessible" );
+
+    d->symLinkToFile = tr( "Symlink to File" );
+    d->symLinkToDir = tr( "Symlink to Directory" );
+    d->symLinkToSpecial = tr( "Symlink to Special" );
+    d->file = tr( "File" );
+    d->dir = tr( "Dir" );
+    d->special = tr( "Special" );
+
+    if ( lastWidth == 0 ) {
+	QRect screen = QApplication::desktop()->screenGeometry( pos() );
+	if ( screen.width() < 1024 || screen.height() < 768 ) {
+	    resize( QMIN(screen.width(), 420), QMIN(screen.height(), 236) );
+	} else {
+	    QSize s = files->sizeHint();
+	    s = QSize( s.width() + 300, s.height() + 82 );
+
+	    if ( s.width() * 3 > screen.width() * 2 )
+		s.setWidth( screen.width() * 2 / 3 );
+
+	    if ( s.height() * 3 > screen.height() * 2 )
+		s.setHeight( screen.height() * 2 / 3 );
+	    else if ( s.height() * 3 < screen.height() )
+		s.setHeight( screen.height() / 3 );
+
+	    resize( s );
+	}
+	updateLastSize(this);
+    } else {
+	resize( lastWidth, lastHeight );
+    }
+
+    if ( detailViewMode ) {
+	d->stack->raiseWidget( files );
+	d->mcView->setOn( FALSE );
+	d->detailView->setOn( TRUE );
+    }
+
+    d->preview->hide();
+    nameEdit->setFocus();
+
+    connect( nameEdit, SIGNAL( returnPressed() ),
+	     this, SLOT( fileNameEditReturnPressed() ) );
+}
+
+/*!
+  \internal
+*/
+
+void QFileDialog::fileNameEditReturnPressed()
+{
+    d->oldUrl = d->url;
+    if ( !isDirectoryMode( d->mode ) ) {
+	okClicked();
+    } else {
+	d->currentFileName = QString::null;
+	if ( nameEdit->text().isEmpty() ) {
+	    emit fileSelected( selectedFile() );
+	    accept();
+	} else {
+	    QUrlInfo f;
+	    QFileDialogPrivate::File * c
+		= (QFileDialogPrivate::File *)files->currentItem();
+	    if ( c && files->isSelected(c) )
+		f = c->info;
+	    else
+		f = QUrlInfo( d->url, nameEdit->text() );
+	    if ( f.isDir() ) {
+		setUrl( QUrlOperator( d->url,
+				      QFileDialogPrivate::encodeFileName(nameEdit->text() + "/" ) ) );
+		d->checkForFilter = TRUE;
+		trySetSelection( TRUE, d->url, TRUE );
+		d->checkForFilter = FALSE;
+	    }
+	}
+	nameEdit->setText( QString::null );
+    }
+}
+
+/*!
+  \internal
+  Update the info and content preview widgets to display \a u.
+*/
+
+void QFileDialog::updatePreviews( const QUrl &u )
+{
+    if ( d->infoPreviewer )
+	d->infoPreviewer->previewUrl( u );
+    if ( d->contentsPreviewer )
+	d->contentsPreviewer->previewUrl( u );
+}
+
+/*!
+  \internal
+  Changes the preview mode to the mode specified at \a id.
+*/
+
+void QFileDialog::changeMode( int id )
+{
+    if ( !d->infoPreview && !d->contentsPreview )
+	return;
+
+    QButton *btn = (QButton*)d->modeButtons->find( id );
+    if ( !btn )
+	return;
+
+    if ( btn == d->previewContents && !d->contentsPreview )
+	return;
+    if ( btn == d->previewInfo && !d->infoPreview )
+	return;
+
+    if ( btn != d->previewContents && btn != d->previewInfo ) {
+	d->preview->hide();
+    } else {
+	if ( files->currentItem() )
+	    updatePreviews( QUrl( d->url, files->currentItem()->text( 0 ) ) );
+	if ( btn == d->previewInfo )
+	    d->preview->raiseWidget( d->infoPreviewWidget );
+	else
+	    d->preview->raiseWidget( d->contentsPreviewWidget );
+	d->preview->show();
+    }
+}
+
+/*!
+  Destroys the file dialog.
+*/
+
+QFileDialog::~QFileDialog()
+{
+    // since clear might call setContentsPos which would emit
+    // a signal and thus cause a recompute of sizes...
+    files->blockSignals( TRUE );
+    d->moreFiles->blockSignals( TRUE );
+    files->clear();
+    d->moreFiles->clear();
+    d->moreFiles->blockSignals( FALSE );
+    files->blockSignals( FALSE );
+
+#ifndef QT_NO_CURSOR
+    if ( d->cursorOverride )
+	QApplication::restoreOverrideCursor();
+#endif
+
+    delete d;
+    d = 0;
+}
+
+
+/*!
+  \property QFileDialog::selectedFile
+
+  \brief the name of the selected file
+
+  If a file was selected selectedFile contains the file's name including
+  its absolute path; otherwise selectedFile is empty.
+
+  \sa QString::isEmpty(), selectedFiles, selectedFilter
+*/
+
+QString QFileDialog::selectedFile() const
+{
+    QString s = d->currentFileName;
+    // remove the protocol because we do not want to encode it...
+    QString prot = QUrl( s ).protocol();
+    if ( !prot.isEmpty() ) {
+        prot += ":";
+	s.remove( 0, prot.length() );
+    }
+    QUrl u( prot + QFileDialogPrivate::encodeFileName( s ) );
+    if ( u.isLocalFile() ) {
+	QString s = u.toString();
+	if ( s.left( 5 ) == "file:" )
+	    s.remove( (uint)0, 5 );
+	return s;
+    }
+    return d->currentFileName;
+}
+
+/*!
+  \property QFileDialog::selectedFilter
+
+  \brief the filter which the user has selected in the file dialog
+
+  \sa filterSelected(), selectedFiles, selectedFile
+*/
+
+QString QFileDialog::selectedFilter() const
+{
+    return d->types->currentText();
+}
+
+/*! \overload
+
+  Sets the current filter selected in the file dialog to the
+  \a{n}-th filter in the filter list.
+
+  \sa filterSelected(), selectedFilter(), selectedFiles(), selectedFile()
+*/
+
+void QFileDialog::setSelectedFilter( int n )
+{
+    d->types->setCurrentItem( n );
+    QString f = d->types->currentText();
+    QRegExp r( QString::fromLatin1(qt_file_dialog_filter_reg_exp) );
+    int index = r.search( f );
+    if ( index >= 0 )
+	f = r.cap( 2 );
+    d->url.setNameFilter( f );
+    rereadDir();
+}
+
+/*!
+  Sets the current filter selected in the file dialog to the first
+  one that contains the text \a mask.
+*/
+
+void QFileDialog::setSelectedFilter( const QString& mask )
+{
+    int n;
+
+    for ( n = 0; n < d->types->count(); n++ ) {
+	if ( d->types->text( n ).contains( mask, FALSE ) ) {
+	    d->types->setCurrentItem( n );
+	    QString f = mask;
+	    QRegExp r( QString::fromLatin1(qt_file_dialog_filter_reg_exp) );
+	    int index = r.search( f );
+	    if ( index >= 0 )
+		f = r.cap( 2 );
+	    d->url.setNameFilter( f );
+	    rereadDir();
+	    return;
+	}
+    }
+}
+
+/*!
+  \property QFileDialog::selectedFiles
+
+  \brief the list of selected files
+
+  If one or more files are selected, selectedFiles contains their
+  names including their absolute paths. If no files are selected or
+  the mode isn't ExistingFiles selectedFiles is an empty list.
+
+  It is more convenient to use selectedFile() if the mode is
+  \c ExistingFile, \c Directory or \c DirectoryOnly.
+
+  Note that if you want to iterate over the list, you should
+  iterate over a copy, e.g.
+    \code
+    QStringList list = myFileDialog.selectedFiles();
+    QStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+  \sa selectedFile, selectedFilter, QValueList::empty()
+*/
+
+QStringList QFileDialog::selectedFiles() const
+{
+    QStringList lst;
+
+    if ( mode() == ExistingFiles ) {
+	QStringList selectedLst;
+	QString selectedFiles = nameEdit->text();
+        if (selectedFiles.findRev('\"') == -1) {
+            //probably because Enter was pressed on the nameEdit, so we have one file
+            //not in "" but raw
+            selectedLst.append(selectedFiles);
+        } else {
+            selectedFiles.truncate( selectedFiles.findRev( '\"' ) );
+            selectedLst = selectedLst.split( QString("\" "), selectedFiles );
+        }
+	for ( QStringList::Iterator it = selectedLst.begin(); it != selectedLst.end(); ++it ) {
+	    QUrl u;
+	    if ( (*it)[0] == '\"' ) {
+		u = QUrl( d->url, QFileDialogPrivate::encodeFileName( (*it).mid(1) ) );
+	    } else {
+		u = QUrl( d->url, QFileDialogPrivate::encodeFileName( (*it) ) );
+	    }
+	    if ( u.isLocalFile() ) {
+		QString s = u.toString();
+		if ( s.left( 5 ) == "file:" )
+		    s.remove( (uint)0, 5 );
+		lst << s;
+	    } else {
+		lst << u.toString();
+	    }
+	}
+    }
+
+    return lst;
+}
+
+/*!
+  Sets the default selection to \a filename. If \a filename is
+  absolute, setDir() is also called to set the file dialog's working
+  directory to the filename's directory.
+
+  \omit
+  Only for external use. Not useful inside QFileDialog.
+  \endomit
+*/
+
+void QFileDialog::setSelection( const QString & filename )
+{
+    d->oldUrl = d->url;
+    QString nf = d->url.nameFilter();
+    if ( QUrl::isRelativeUrl( filename ) )
+	d->url = QUrlOperator( d->url, QFileDialogPrivate::encodeFileName( filename ) );
+    else
+	d->url = QUrlOperator( filename );
+    d->url.setNameFilter( nf );
+    d->checkForFilter = TRUE;
+    bool isDirOk;
+    bool isDir = d->url.isDir( &isDirOk );
+    if ( !isDirOk )
+	isDir = d->url.path().right( 1 ) == "/";
+    if ( !isDir ) {
+	QUrlOperator u( d->url );
+	d->url.setPath( d->url.dirPath() );
+	trySetSelection( FALSE, u, TRUE );
+	d->ignoreNextRefresh = TRUE;
+	nameEdit->selectAll();
+	rereadDir();
+	emit dirEntered( d->url.dirPath() );
+    } else {
+	if ( !d->url.path().isEmpty() &&
+	     d->url.path().right( 1 ) != "/" ) {
+	    QString p = d->url.path();
+	    p += "/";
+	    d->url.setPath( p );
+	}
+	trySetSelection( TRUE, d->url, FALSE );
+	rereadDir();
+	emit dirEntered( d->url.dirPath() );
+	nameEdit->setText( QString::fromLatin1("") );
+    }
+    d->checkForFilter = FALSE;
+}
+
+/*!
+  \property QFileDialog::dirPath
+
+  \brief the file dialog's working directory
+
+  \sa dir(), setDir()
+*/
+
+QString QFileDialog::dirPath() const
+{
+    return d->url.dirPath();
+}
+
+
+/*!
+
+  Sets the filter used in the file dialog to \a newFilter.
+
+  If \a newFilter contains a pair of parentheses containing one or more
+  of <em><b>anything*something</b></em> separated by spaces or by
+  semi-colons then only the text contained in the parentheses is used as
+  the filter. This means that these calls are all equivalent:
+
+  \code
+     fd->setFilter( "All C++ files (*.cpp *.cc *.C *.cxx *.c++)" );
+     fd->setFilter( "*.cpp *.cc *.C *.cxx *.c++" );
+     fd->setFilter( "All C++ files (*.cpp;*.cc;*.C;*.cxx;*.c++)" );
+     fd->setFilter( "*.cpp;*.cc;*.C;*.cxx;*.c++" );
+  \endcode
+
+  \sa setFilters()
+*/
+
+void QFileDialog::setFilter( const QString & newFilter )
+{
+    if ( newFilter.isEmpty() )
+	return;
+    QString f = newFilter;
+    QRegExp r( QString::fromLatin1(qt_file_dialog_filter_reg_exp) );
+    int index = r.search( f );
+    if ( index >= 0 )
+	f = r.cap( 2 );
+    d->url.setNameFilter( f );
+    if ( d->types->count() == 1 )  {
+	d->types->clear();
+	d->types->insertItem( newFilter );
+    } else {
+	for ( int i = 0; i < d->types->count(); ++i ) {
+	    if ( d->types->text( i ).left( newFilter.length() ) == newFilter ||
+		 d->types->text( i ).left( f.length() ) == f ) {
+		d->types->setCurrentItem( i );
+		break;
+	    }
+	}
+    }
+    rereadDir();
+}
+
+
+/*! \overload
+  Sets the file dialog's working directory to \a pathstr.
+
+  \sa dir()
+*/
+
+void QFileDialog::setDir( const QString & pathstr )
+{
+    QString dr = pathstr;
+    if ( dr.isEmpty() )
+	return;
+
+#if defined(Q_OS_UNIX)
+    if ( dr.length() && dr[0] == '~' ) {
+	int i = 0;
+	while( i < (int)dr.length() && dr[i] != '/' )
+	    i++;
+	QCString user;
+	if ( i == 1 ) {
+#if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+
+#  ifndef _POSIX_LOGIN_NAME_MAX
+#    define _POSIX_LOGIN_NAME_MAX 9
+#  endif
+
+	    char name[_POSIX_LOGIN_NAME_MAX];
+	    if ( ::getlogin_r( name, _POSIX_LOGIN_NAME_MAX ) == 0 )
+		user = name;
+	    else
+#else
+	    user = ::getlogin();
+	    if ( !user )
+#endif
+		user = getenv( "LOGNAME" );
+	} else
+	    user = dr.mid( 1, i-1 ).local8Bit();
+	dr = dr.mid( i, dr.length() );
+	struct passwd *pw;
+#if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_FREEBSD) && !defined(Q_OS_OPENBSD)
+	struct passwd mt_pw;
+	char buffer[2048];
+	if ( ::getpwnam_r( user, &mt_pw, buffer, 2048, &pw ) == 0 && pw == &mt_pw )
+#else
+	pw = ::getpwnam( user );
+	if ( pw )
+#endif
+	    dr.prepend( QString::fromLocal8Bit(pw->pw_dir) );
+    }
+#endif
+
+    setUrl( dr );
+}
+
+/*!
+  Returns the current directory shown in the file dialog.
+
+  The ownership of the QDir pointer is transferred to the caller, so
+  it must be deleted by the caller when no longer required.
+
+  \sa setDir()
+*/
+
+const QDir *QFileDialog::dir() const
+{
+    if ( d->url.isLocalFile() )
+	return  new QDir( d->url.path() );
+    else
+	return 0;
+}
+
+/*!
+  Sets the file dialog's working directory to \a dir.
+  \sa dir()
+*/
+
+void QFileDialog::setDir( const QDir &dir )
+{
+    d->oldUrl = d->url;
+    QString nf( d->url.nameFilter() );
+    d->url = dir.canonicalPath();
+    d->url.setNameFilter( nf );
+    QUrlInfo i( d->url, nameEdit->text() );
+    d->checkForFilter = TRUE;
+    trySetSelection( i.isDir(), QUrlOperator( d->url, QFileDialogPrivate::encodeFileName(nameEdit->text() ) ), FALSE );
+    d->checkForFilter = FALSE;
+    rereadDir();
+    emit dirEntered( d->url.path() );
+}
+
+/*!
+  Sets the file dialog's working directory to the directory specified at \a url.
+
+  \sa url()
+*/
+
+void QFileDialog::setUrl( const QUrlOperator &url )
+{
+    d->oldUrl = d->url;
+    QString nf = d->url.nameFilter();
+
+    QString operatorPath = url.toString( FALSE, FALSE );
+    if ( QUrl::isRelativeUrl( operatorPath ) ) {
+	d->url = QUrl( d->url, operatorPath );
+    } else {
+	d->url = url;
+    }
+    d->url.setNameFilter( nf );
+
+    d->checkForFilter = TRUE;
+    if ( !d->url.isDir() ) {
+	QUrlOperator u = d->url;
+	d->url.setPath( d->url.dirPath() );
+	trySetSelection( FALSE, u, FALSE );
+	rereadDir();
+	emit dirEntered( d->url.dirPath() );
+	QString fn = u.fileName();
+	nameEdit->setText( fn );
+    } else {
+	trySetSelection( TRUE, d->url, FALSE );
+	rereadDir();
+	emit dirEntered( d->url.dirPath() );
+    }
+    d->checkForFilter = FALSE;
+}
+
+/*!
+  \property QFileDialog::showHiddenFiles
+
+  \brief whether hidden files are shown in the file dialog
+
+  The default is FALSE, i.e. don't show hidden files.
+*/
+
+void QFileDialog::setShowHiddenFiles( bool s )
+{
+    if ( s == bShowHiddenFiles )
+	return;
+
+    bShowHiddenFiles = s;
+    rereadDir();
+}
+
+bool QFileDialog::showHiddenFiles() const
+{
+    return bShowHiddenFiles;
+}
+
+/*!
+  Rereads the current directory shown in the file dialog.
+
+  The only time you will need to call this function is if the contents of
+  the directory change and you wish to refresh the file dialog to reflect
+  the change.
+
+  \sa resortDir()
+*/
+
+void QFileDialog::rereadDir()
+{
+#ifndef QT_NO_CURSOR
+    if ( !d->cursorOverride ) {
+	QApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
+	d->cursorOverride = TRUE;
+    }
+#endif
+    d->pendingItems.clear();
+    if ( d->mimeTypeTimer->isActive() )
+	d->mimeTypeTimer->stop();
+    d->currListChildren = d->url.listChildren();
+#ifndef QT_NO_CURSOR
+    if ( d->cursorOverride ) {
+	QApplication::restoreOverrideCursor();
+	d->cursorOverride = FALSE;
+    }
+#endif
+}
+
+
+/*!
+  \fn void QFileDialog::fileHighlighted( const QString& )
+
+  This signal is emitted when the user highlights a file, i.e. makes
+  it the current file.
+
+  \sa fileSelected(), filesSelected()
+*/
+
+/*!
+  \fn void QFileDialog::fileSelected( const QString& )
+
+  This signal is emitted when the user selects a file.
+
+  \sa filesSelected(), fileHighlighted(), selectedFile()
+*/
+
+/*!
+  \fn void QFileDialog::filesSelected( const QStringList& )
+
+  This signal is emitted when the user selects one or more files in \e
+  ExistingFiles mode.
+
+  \sa fileSelected(), fileHighlighted(), selectedFiles()
+*/
+
+/*!
+  \fn void QFileDialog::dirEntered( const QString& )
+
+  This signal is emitted when the user enters a directory.
+
+  \sa dir()
+*/
+
+/*!
+  \fn void QFileDialog::filterSelected( const QString& )
+
+  This signal is emitted when the user selects a filter.
+
+  \sa selectedFilter()
+*/
+
+extern bool qt_resolve_symlinks; // defined in qapplication.cpp
+bool Q_EXPORT qt_use_native_dialogs = TRUE;
+
+/*!
+  This is a convenience static function that returns an existing file
+  selected by the user. If the user pressed Cancel, it returns a null
+  string.
+
+  \code
+    QString s = QFileDialog::getOpenFileName(
+                    "/home",
+		    "Images (*.png *.xpm *.jpg)",
+		    this,
+		    "open file dialog",
+		    "Choose a file to open" );
+  \endcode
+
+  The function creates a modal file dialog called \a name, with
+  parent, \a parent. If a parent is not 0, the dialog will be shown
+  centered over the parent.
+
+  The file dialog's working directory will be set to \a startWith. If \a
+  startWith includes a file name, the file will be selected. The filter
+  is set to \a filter so that only those files which match the filter
+  are shown. The filter selected is set to \a selectedFilter. The parameters
+  \a startWith, \a selectedFilter and \a filter may be QString::null.
+
+  The dialog's caption is set to \a caption. If \a caption is not
+  specified then a default caption will be used.
+
+  Under Windows and Mac OS X, this static function will use the native
+  file dialog and not a QFileDialog, unless the style of the application
+  is set to something other than the native style (Note that on Windows the
+  dialog will spin a blocking modal event loop that will not dispatch any
+  QTimers and if parent is not 0 then it will position the dialog just under
+  the parent's titlebar).
+
+  Under Unix/X11, the normal behavior of the file dialog is to resolve
+  and follow symlinks. For example, if /usr/tmp is a symlink to /var/tmp,
+  the file dialog will change to /var/tmp after entering /usr/tmp.
+  If \a resolveSymlinks is FALSE, the file dialog will treat
+  symlinks as regular directories.
+
+  \sa getOpenFileNames(), getSaveFileName(), getExistingDirectory()
+*/
+
+QString QFileDialog::getOpenFileName( const QString & startWith,
+				      const QString& filter,
+				      QWidget *parent, const char* name,
+				      const QString& caption,
+				      QString *selectedFilter,
+				      bool resolveSymlinks )
+{
+    bool save_qt_resolve_symlinks = qt_resolve_symlinks;
+    qt_resolve_symlinks = resolveSymlinks;
+
+    QStringList filters;
+    if ( !filter.isEmpty() )
+	filters = makeFiltersList( filter );
+
+    makeVariables();
+    QString initialSelection;
+    //### Problem with the logic here: If a startWith is given and a file
+    // with that name exists in D->URL, the box will be opened at D->URL instead of
+    // the last directory used ('workingDirectory').
+    //
+    // hm... isn't that problem exactly the documented behaviour? the
+    // documented behaviour sounds meaningful.
+    if ( !startWith.isEmpty() ) {
+	QUrlOperator u( QFileDialogPrivate::encodeFileName( startWith ) );
+	if ( u.isLocalFile() && QFileInfo( u.path() ).isDir() ) {
+	    *workingDirectory = startWith;
+	} else {
+	    if ( u.isLocalFile() ) {
+		QFileInfo fi( u.dirPath() );
+		if ( fi.exists() ) {
+		    *workingDirectory = u.dirPath();
+		    initialSelection = u.fileName();
+		}
+	    } else {
+		*workingDirectory = u.toString();
+		initialSelection = QString::null;//u.fileName();
+	    }
+	}
+    }
+
+    if ( workingDirectory->isNull() )
+	*workingDirectory = ::toRootIfNotExists( QDir::currentDirPath() );
+
+#if defined(Q_WS_WIN)
+    if ( qt_use_native_dialogs && qApp->style().styleHint( QStyle::SH_GUIStyle ) == WindowsStyle )
+	return winGetOpenFileName( initialSelection, filter, workingDirectory,
+				   parent, name, caption, selectedFilter );
+#elif defined(Q_WS_MAC)
+    if (qt_use_native_dialogs && (qApp->style().inherits(QMAC_DEFAULT_STYLE)
+                                  || qApp->style().inherits("QMacStyle")))
+        return qt_mac_precomposeFileName(macGetOpenFileNames(filter,
+                                         startWith.isEmpty() ? 0 : workingDirectory,
+                                         parent, name, caption, selectedFilter, FALSE).first());
+#endif
+
+    QFileDialog *dlg = new QFileDialog( *workingDirectory, QString::null, parent, name ? name : "qt_filedlg_gofn", TRUE );
+
+    Q_CHECK_PTR( dlg );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    if ( !caption.isNull() )
+	dlg->setCaption( caption );
+    else
+	dlg->setCaption( QFileDialog::tr( "Open" ) );
+#endif
+
+    dlg->setFilters( filters );
+    if ( selectedFilter )
+	dlg->setFilter( *selectedFilter );
+    dlg->setMode( QFileDialog::ExistingFile );
+    QString result;
+    if ( !initialSelection.isEmpty() )
+	dlg->setSelection( initialSelection );
+    if ( dlg->exec() == QDialog::Accepted ) {
+	result = dlg->selectedFile();
+	*workingDirectory = dlg->d->url;
+	if ( selectedFilter )
+	    *selectedFilter = dlg->selectedFilter();
+    }
+    delete dlg;
+
+    qt_resolve_symlinks = save_qt_resolve_symlinks;
+
+    return result;
+}
+
+/*!
+  This is a convenience static function that will return a file name
+  selected by the user. The file does not have to exist.
+
+  It creates a modal file dialog called \a name, with parent, \a parent.
+  If a parent is not 0, the dialog will be shown centered over the
+  parent.
+
+  \code
+    QString s = QFileDialog::getSaveFileName(
+                    "/home",
+		    "Images (*.png *.xpm *.jpg)",
+		    this,
+		    "save file dialog",
+		    "Choose a filename to save under" );
+  \endcode
+
+  The file dialog's working directory will be set to \a startWith. If \a
+  startWith includes a file name, the file will be selected. The filter
+  is set to \a filter so that only those files which match the filter
+  are shown. The filter selected is set to \a selectedFilter. The parameters
+  \a startWith, \a selectedFilter and \a filter may be QString::null.
+
+  The dialog's caption is set to \a caption. If \a caption is not
+  specified then a default caption will be used.
+
+  Under Windows and Mac OS X, this static function will use the native
+  file dialog and not a QFileDialog, unless the style of the application
+  is set to something other than the native style. (Note that on Windows the
+  dialog will spin a blocking modal event loop that will not dispatch any
+  QTimers and if parent is not 0 then it will position the dialog just under
+  the parent's titlebar.
+
+  Under Unix/X11, the normal behavior of the file dialog is to resolve
+  and follow symlinks. For example, if /usr/tmp is a symlink to /var/tmp,
+  the file dialog will change to /var/tmp after entering /usr/tmp.
+  If \a resolveSymlinks is FALSE, the file dialog will treat
+  symlinks as regular directories.
+
+  \sa getOpenFileName(), getOpenFileNames(), getExistingDirectory()
+*/
+
+QString QFileDialog::getSaveFileName( const QString & startWith,
+				      const QString& filter,
+				      QWidget *parent, const char* name,
+				      const QString& caption,
+				      QString *selectedFilter,
+				      bool resolveSymlinks)
+{
+    bool save_qt_resolve_symlinks = qt_resolve_symlinks;
+    qt_resolve_symlinks = resolveSymlinks;
+
+    QStringList filters;
+    if ( !filter.isEmpty() )
+	filters = makeFiltersList( filter );
+
+    makeVariables();
+    QString initialSelection;
+    if ( !startWith.isEmpty() ) {
+	QUrlOperator u( QFileDialogPrivate::encodeFileName( startWith ) );
+	if ( u.isLocalFile() && QFileInfo( u.path() ).isDir() ) {
+	    *workingDirectory = startWith;
+	} else {
+	    if ( u.isLocalFile() ) {
+		QFileInfo fi( u.dirPath() );
+		if ( fi.exists() ) {
+		    *workingDirectory = u.dirPath();
+		    initialSelection = u.fileName();
+		}
+	    } else {
+		*workingDirectory = u.toString();
+		initialSelection = QString::null;//u.fileName();
+	    }
+	}
+    }
+
+    if ( workingDirectory->isNull() )
+	*workingDirectory = ::toRootIfNotExists( QDir::currentDirPath() );
+
+#if defined(Q_WS_WIN)
+    if ( qt_use_native_dialogs && qApp->style().styleHint( QStyle::SH_GUIStyle ) == WindowsStyle )
+	return winGetSaveFileName( initialSelection, filter, workingDirectory,
+				   parent, name, caption, selectedFilter );
+#elif defined(Q_WS_MAC)
+    if (qt_use_native_dialogs && (qApp->style().inherits(QMAC_DEFAULT_STYLE)
+                                  || qApp->style().inherits("QMacStyle")))
+        return qt_mac_precomposeFileName(macGetSaveFileName(initialSelection, filter,
+                                         startWith.isEmpty() ? 0 : workingDirectory, parent, name,
+                                         caption, selectedFilter));
+#endif
+
+    QFileDialog *dlg = new QFileDialog( *workingDirectory, QString::null, parent, name ? name : "qt_filedlg_gsfn", TRUE );
+
+    Q_CHECK_PTR( dlg );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    if ( !caption.isNull() )
+	dlg->setCaption( caption );
+    else
+	dlg->setCaption( QFileDialog::tr( "Save As" ) );
+#endif
+
+    QString result;
+    dlg->setFilters( filters );
+    if ( selectedFilter )
+	dlg->setFilter( *selectedFilter );
+    dlg->setMode( QFileDialog::AnyFile );
+    if ( !initialSelection.isEmpty() )
+	dlg->setSelection( initialSelection );
+    if ( dlg->exec() == QDialog::Accepted ) {
+	result = dlg->selectedFile();
+	*workingDirectory = dlg->d->url;
+	if ( selectedFilter )
+	    *selectedFilter = dlg->selectedFilter();
+    }
+    delete dlg;
+
+    qt_resolve_symlinks = save_qt_resolve_symlinks;
+
+    return result;
+}
+
+/*!
+  \internal
+  Activated when the "OK" button is clicked.
+*/
+
+void QFileDialog::okClicked()
+{
+    QString fn( nameEdit->text() );
+
+#if defined(Q_WS_WIN)
+    QFileInfo fi( d->url.path() + fn );
+    if ( fi.isSymLink() ) {
+	nameEdit->setText( fi.readLink() );
+    }
+#endif
+
+    if ( fn.contains("*") ) {
+	addFilter( fn );
+	nameEdit->blockSignals( TRUE );
+	nameEdit->setText( QString::fromLatin1("") );
+	nameEdit->blockSignals( FALSE );
+	return;
+    }
+
+    *workingDirectory = d->url;
+    detailViewMode = files->isVisible();
+    updateLastSize(this);
+
+    if ( isDirectoryMode( d->mode ) ) {
+	QUrlInfo f( d->url, nameEdit->text() );
+	if ( f.isDir() ) {
+	    d->currentFileName = d->url;
+	    if ( d->currentFileName.right(1) != "/" )
+		d->currentFileName += '/';
+	    if ( f.name() != "." )
+		d->currentFileName += f.name();
+	    accept();
+	    return;
+	}
+	// Since it's not a directory and we clicked ok, we
+	// don't really want to do anything else
+	return;
+    }
+
+    // if we're in multi-selection mode and something is selected,
+    // accept it and be done.
+    if ( mode() == ExistingFiles ) {
+	if ( ! nameEdit->text().isEmpty() ) {
+	    QStringList sf = selectedFiles();
+	    bool isdir = FALSE;
+	    if ( sf.count() == 1 ) {
+		QUrlOperator u( d->url, sf[0] );
+		bool ok;
+		isdir = u.isDir(&ok) && ok;
+	    }
+	    if ( !isdir ) {
+		emit filesSelected( sf );
+		accept();
+		return;
+	    }
+	}
+    }
+
+    if ( mode() == AnyFile ) {
+	QUrlOperator u( d->url, QFileDialogPrivate::encodeFileName(nameEdit->text()) );
+	if ( !u.isDir() ) {
+	    d->currentFileName = u;
+	    emit fileSelected( selectedFile() );
+	    accept();
+	    return;
+	}
+    }
+
+    if ( mode() == ExistingFile ) {
+	if ( !QFileDialogPrivate::fileExists( d->url, nameEdit->text() ) )
+	    return;
+    }
+
+    // If selection is valid, return it, else try
+    // using selection as a directory to change to.
+    if ( !d->currentFileName.isNull() && !d->currentFileName.contains( "*" ) ) {
+	emit fileSelected( selectedFile() );
+	accept();
+    } else {
+	QUrlInfo f;
+	QFileDialogPrivate::File * c
+	    = (QFileDialogPrivate::File *)files->currentItem();
+	QFileDialogPrivate::MCItem * m
+	    = (QFileDialogPrivate::MCItem *)d->moreFiles->item( d->moreFiles->currentItem() );
+	if ( c && files->isVisible() && files->hasFocus() ||
+	     m && d->moreFiles->isVisible() && d->moreFiles->hasFocus() ) {
+	    if ( c && files->isVisible() )
+		f = c->info;
+	    else
+		f = ( (QFileDialogPrivate::File*)m->i )->info;
+	} else {
+	    f = QUrlInfo( d->url, nameEdit->text() );
+	}
+	if ( f.isDir() ) {
+	    setUrl( QUrlOperator( d->url, QFileDialogPrivate::encodeFileName(f.name() + "/" ) ) );
+	    d->checkForFilter = TRUE;
+	    trySetSelection( TRUE, d->url, TRUE );
+	    d->checkForFilter = FALSE;
+	} else {
+	    if ( !nameEdit->text().contains( "/" ) &&
+		 !nameEdit->text().contains( "\\" )
+#if defined(Q_OS_WIN32)
+		 && nameEdit->text()[ 1 ] != ':'
+#endif
+		 )
+		addFilter( nameEdit->text() );
+	    else if ( nameEdit->text()[ 0 ] == '/' ||
+		      nameEdit->text()[ 0 ] == '\\'
+#if defined(Q_OS_WIN32)
+		      || nameEdit->text()[ 1 ] == ':'
+#endif
+		      )
+		setDir( nameEdit->text() );
+	    else if ( nameEdit->text().left( 3 ) == "../" || nameEdit->text().left( 3 ) == "..\\" )
+		setDir( QUrl( d->url.toString(), QFileDialogPrivate::encodeFileName(nameEdit->text() ) ).toString() );
+	}
+	nameEdit->setText( "" );
+    }
+}
+
+/*!
+  \internal
+  Activated when the "Filter" button is clicked.
+*/
+
+void QFileDialog::filterClicked()
+{
+    // unused
+}
+
+/*!
+  \internal
+  Activated when the "Cancel" button is clicked.
+*/
+
+void QFileDialog::cancelClicked()
+{
+    *workingDirectory = d->url;
+    detailViewMode = files->isVisible();
+    updateLastSize(this);
+    reject();
+}
+
+
+/*!\reimp
+*/
+
+void QFileDialog::resizeEvent( QResizeEvent * e )
+{
+    QDialog::resizeEvent( e );
+    updateGeometries();
+}
+
+/*
+  \internal
+  The only correct way to try to set currentFileName
+*/
+bool QFileDialog::trySetSelection( bool isDir, const QUrlOperator &u, bool updatelined )
+{
+    if ( !isDir && !u.path().isEmpty() && u.path().right( 1 ) == "/" )
+	isDir = TRUE;
+    if ( u.fileName().contains( "*") && d->checkForFilter ) {
+	QString fn( u.fileName() );
+	if ( fn.contains( "*" ) ) {
+	    addFilter( fn );
+	    d->currentFileName = QString::null;
+	    d->url.setFileName( QString::null );
+	    nameEdit->setText( QString::fromLatin1("") );
+	    return FALSE;
+	}
+    }
+
+    if ( d->preview && d->preview->isVisible() )
+	updatePreviews( u );
+
+    QString old = d->currentFileName;
+
+    if ( isDirectoryMode( mode() ) ) {
+	if ( isDir )
+	    d->currentFileName = u;
+	else
+	    d->currentFileName = QString::null;
+    } else if ( !isDir && mode() == ExistingFiles ) {
+	d->currentFileName = u;
+    } else if ( !isDir || ( mode() == AnyFile && !isDir ) ) {
+	d->currentFileName = u;
+    } else {
+	d->currentFileName = QString::null;
+    }
+    if ( updatelined && !d->currentFileName.isEmpty() ) {
+	// If the selection is valid, or if its a directory, allow OK.
+	if ( !d->currentFileName.isNull() || isDir ) {
+	    if ( u.fileName() != ".." ) {
+		QString fn = u.fileName();
+		nameEdit->setText( fn );
+	    } else {
+		nameEdit->setText("");
+	    }
+	} else
+	    nameEdit->setText( QString::fromLatin1("") );
+    }
+
+    if ( !d->currentFileName.isNull() || isDir ) {
+	okB->setEnabled( TRUE );
+    } else if ( !isDirectoryMode( d->mode ) ) {
+	okB->setEnabled( FALSE );
+    }
+
+    if ( d->currentFileName.length() && old != d->currentFileName )
+	emit fileHighlighted( selectedFile() );
+
+    return !d->currentFileName.isNull();
+}
+
+
+/*!  Make sure the minimum and maximum sizes of everything are sane.
+*/
+
+void QFileDialog::updateGeometries()
+{
+    if ( !d || !d->geometryDirty )
+	return;
+
+    d->geometryDirty = FALSE;
+
+    QSize r, t;
+
+    // we really should have a QSize::unite()
+#define RM r.setWidth( QMAX(r.width(),t.width()) ); \
+r.setHeight( QMAX(r.height(),t.height()) )
+
+    // labels first
+    r = d->pathL->sizeHint();
+    t = d->fileL->sizeHint();
+    RM;
+    t = d->typeL->sizeHint();
+    RM;
+    d->pathL->setFixedSize( d->pathL->sizeHint() );
+    d->fileL->setFixedSize( r );
+    d->typeL->setFixedSize( r );
+
+    // single-line input areas
+    r = d->paths->sizeHint();
+    t = nameEdit->sizeHint();
+    RM;
+    t = d->types->sizeHint();
+    RM;
+    r.setWidth( t.width() * 2 / 3 );
+    t.setWidth( QWIDGETSIZE_MAX );
+    t.setHeight( r.height() );
+    d->paths->setMinimumSize( r );
+    d->paths->setMaximumSize( t );
+    nameEdit->setMinimumSize( r );
+    nameEdit->setMaximumSize( t );
+    d->types->setMinimumSize( r );
+    d->types->setMaximumSize( t );
+
+    // buttons on top row
+    r = QSize( 0, d->paths->minimumSize().height() );
+    t = QSize( 21, 20 );
+    RM;
+    if ( r.height()+1 > r.width() )
+	r.setWidth( r.height()+1 );
+    if ( d->goBack )
+	d->goBack->setFixedSize( r );
+    d->cdToParent->setFixedSize( r );
+    d->newFolder->setFixedSize( r );
+    d->mcView->setFixedSize( r );
+    d->detailView->setFixedSize( r );
+
+    QButton *b = 0;
+    if ( !d->toolButtons.isEmpty() ) {
+	for ( b = d->toolButtons.first(); b; b = d->toolButtons.next() )
+	    b->setFixedSize( b->sizeHint().width(), r.height() );
+    }
+
+    if ( d->infoPreview ) {
+	d->previewInfo->show();
+	d->previewInfo->setFixedSize( r );
+    } else {
+	d->previewInfo->hide();
+	d->previewInfo->setFixedSize( QSize( 0, 0 ) );
+    }
+
+    if ( d->contentsPreview ) {
+	d->previewContents->show();
+	d->previewContents->setFixedSize( r );
+    } else {
+	d->previewContents->hide();
+	d->previewContents->setFixedSize( QSize( 0, 0 ) );
+    }
+
+    // open/save, cancel
+    r = QSize( 75, 20 );
+    t = okB->sizeHint();
+    RM;
+    t = cancelB->sizeHint();
+    RM;
+
+    okB->setFixedSize( r );
+    cancelB->setFixedSize( r );
+
+    d->topLevelLayout->activate();
+
+#undef RM
+}
+
+
+/*! Updates the file name edit box to \a newItem in the file dialog
+ when the cursor moves in the listview.
+*/
+
+void QFileDialog::updateFileNameEdit( QListViewItem * newItem )
+{
+    if ( !newItem )
+	return;
+
+    if ( mode() == ExistingFiles ) {
+	detailViewSelectionChanged();
+        QUrl u( d->url, QFileDialogPrivate::encodeFileName( ((QFileDialogPrivate::File*)files->currentItem())->info.name() ) );
+	QFileInfo fi( u.toString( FALSE, FALSE ) );
+	if ( !fi.isDir() )
+	    emit fileHighlighted( u.toString( FALSE, FALSE ) );
+    } else if ( files->isSelected( newItem ) ) {
+	QFileDialogPrivate::File * i = (QFileDialogPrivate::File *)newItem;
+	if ( i && i->i && !i->i->isSelected() ) {
+	    d->moreFiles->blockSignals( TRUE );
+	    d->moreFiles->setSelected( i->i, TRUE );
+	    d->moreFiles->blockSignals( FALSE );
+	}
+	// Encode the filename in case it had any special characters in it
+	QString encFile = QFileDialogPrivate::encodeFileName( newItem->text( 0 ) );
+	trySetSelection( i->info.isDir(), QUrlOperator( d->url, encFile ), TRUE );
+    }
+}
+
+void QFileDialog::detailViewSelectionChanged()
+{
+    if ( d->mode != ExistingFiles )
+	return;
+
+    nameEdit->clear();
+    QString str;
+    QListViewItem * i = files->firstChild();
+    d->moreFiles->blockSignals( TRUE );
+    while( i ) {
+	if ( d->moreFiles && isVisible() ) {
+	    QFileDialogPrivate::File *f = (QFileDialogPrivate::File *)i;
+	    if ( f->i && f->i->isSelected() != i->isSelected() )
+		d->moreFiles->setSelected( f->i, i->isSelected() );
+	}
+	if ( i->isSelected() && !( (QFileDialogPrivate::File *)i )->info.isDir() )
+	    str += QString( "\"%1\" " ).arg( i->text( 0 ) );
+	i = i->nextSibling();
+    }
+    d->moreFiles->blockSignals( FALSE );
+    nameEdit->setText( str );
+    nameEdit->setCursorPosition( str.length() );
+    okB->setEnabled( TRUE );
+    if ( d->preview && d->preview->isVisible() && files->currentItem() ) {
+	QUrl u = QUrl( d->url, QFileDialogPrivate::encodeFileName( ((QFileDialogPrivate::File*)files->currentItem())->info.name() ) );
+	updatePreviews( u );
+    }
+}
+
+void QFileDialog::listBoxSelectionChanged()
+{
+    if ( d->mode != ExistingFiles )
+	return;
+
+    if ( d->ignoreNextRefresh ) {
+	d->ignoreNextRefresh = FALSE;
+	return;
+    }
+
+    nameEdit->clear();
+    QString str;
+    QListBoxItem * i = d->moreFiles->item( 0 );
+    QListBoxItem * j = 0;
+    int index = 0;
+    files->blockSignals( TRUE );
+    while( i ) {
+	QFileDialogPrivate::MCItem *mcitem = (QFileDialogPrivate::MCItem *)i;
+	if ( files && isVisible() ) {
+	    if ( mcitem->i->isSelected() != mcitem->isSelected() ) {
+		files->setSelected( mcitem->i, mcitem->isSelected() );
+
+		// What happens here is that we want to emit signal highlighted for
+		// newly added items.  But QListBox apparently emits selectionChanged even
+		// when a user clicks on the same item twice.  So, basically emulate the behaivor
+		// we have in the "Details" view which only emits highlighted the first time we
+		// click on the item.  Perhaps at some point we should have a call to
+		// updateFileNameEdit(QListViewItem) which also emits fileHighlighted() for
+		// ExistingFiles.  For better or for worse, this clones the behaivor of the
+		// "Details" view quite well.
+		if ( mcitem->isSelected() && i != d->lastEFSelected ) {
+		    QUrl u( d->url, QFileDialogPrivate::encodeFileName( ((QFileDialogPrivate::File*)(mcitem)->i)->info.name()) );
+		    d->lastEFSelected = i;
+		    emit fileHighlighted( u.toString(FALSE, FALSE) );
+		}
+	    }
+	}
+	if ( d->moreFiles->isSelected( i )
+	     && !( (QFileDialogPrivate::File*)(mcitem)->i )->info.isDir() ) {
+	    str += QString( "\"%1\" " ).arg( i->text() );
+	    if ( j == 0 )
+		j = i;
+	}
+	i = d->moreFiles->item( ++index );
+    }
+
+    files->blockSignals( FALSE );
+    nameEdit->setText( str );
+    nameEdit->setCursorPosition( str.length() );
+    okB->setEnabled( TRUE );
+    if ( d->preview && d->preview->isVisible() && j ) {
+	QUrl u = QUrl( d->url,
+		       QFileDialogPrivate::encodeFileName( ( (QFileDialogPrivate::File*)( (QFileDialogPrivate::MCItem*)j )->i )->info.name() ) );
+	updatePreviews( u );
+    }
+}
+
+/*! \overload */
+
+void QFileDialog::updateFileNameEdit( QListBoxItem * newItem )
+{
+    if ( !newItem )
+	return;
+    QFileDialogPrivate::MCItem * i = (QFileDialogPrivate::MCItem *)newItem;
+    if ( i->i ) {
+	i->i->listView()->setSelected( i->i, i->isSelected() );
+	updateFileNameEdit( i->i );
+    }
+}
+
+
+/*!  Updates the dialog when the file name edit changes. */
+
+void QFileDialog::fileNameEditDone()
+{
+    QUrlInfo f( d->url, nameEdit->text() );
+    if ( mode() != QFileDialog::ExistingFiles ) {
+	QUrlOperator u( d->url, QFileDialogPrivate::encodeFileName( nameEdit->text() ) );
+	trySetSelection( f.isDir(), u, FALSE );
+	if ( d->preview && d->preview->isVisible() )
+	    updatePreviews( u );
+    }
+}
+
+
+
+/*! This private slot reacts to double-clicks in the list view. The item that
+was double-clicked is specified in \a newItem */
+
+void QFileDialog::selectDirectoryOrFile( QListViewItem * newItem )
+{
+
+    *workingDirectory = d->url;
+    detailViewMode = files->isVisible();
+    updateLastSize(this);
+
+    if ( !newItem )
+	return;
+
+    if ( d->url.isLocalFile() ) {
+	QFileInfo fi( d->url.path() + newItem->text(0) );
+#if defined(Q_WS_WIN)
+	if ( fi.isSymLink() ) {
+	    nameEdit->setText( fi.readLink() );
+	    okClicked();
+	    return;
+	}
+#endif
+    }
+
+    QFileDialogPrivate::File * i = (QFileDialogPrivate::File *)newItem;
+
+    QString oldName = nameEdit->text();
+    if ( i->info.isDir() ) {
+	setUrl( QUrlOperator( d->url, QFileDialogPrivate::encodeFileName( i->info.name() ) + "/" ) );
+	if ( isDirectoryMode( mode() ) ) {
+	    QUrlInfo f ( d->url, QString::fromLatin1( "." ) );
+	    trySetSelection( f.isDir(), d->url, TRUE );
+	}
+    } else if ( newItem->isSelectable() &&
+		trySetSelection( i->info.isDir(), QUrlOperator( d->url, QFileDialogPrivate::encodeFileName( i->info.name() ) ), TRUE ) ) {
+        if ( !isDirectoryMode( mode() ) ) {
+	    if ( mode() == ExistingFile ) {
+		if ( QFileDialogPrivate::fileExists( d->url, nameEdit->text() ) ) {
+		    emit fileSelected( selectedFile() );
+		    accept();
+		}
+	    } else {
+		emit fileSelected( selectedFile() );
+		accept();
+	    }
+	}
+    } else if ( isDirectoryMode( d->mode ) ) {
+	d->currentFileName = d->url;
+	accept();
+    }
+    if ( !oldName.isEmpty() && !isDirectoryMode( mode() ) )
+	nameEdit->setText( oldName );
+}
+
+
+void QFileDialog::selectDirectoryOrFile( QListBoxItem * newItem )
+{
+    if ( !newItem )
+	return;
+
+    QFileDialogPrivate::MCItem * i = (QFileDialogPrivate::MCItem *)newItem;
+    if ( i->i ) {
+	i->i->listView()->setSelected( i->i, i->isSelected() );
+	selectDirectoryOrFile( i->i );
+    }
+}
+
+
+void QFileDialog::popupContextMenu( QListViewItem *item, const QPoint &p,
+				    int )
+{
+    if ( item ) {
+	files->setCurrentItem( item );
+	files->setSelected( item, TRUE );
+    }
+
+    PopupAction action;
+    popupContextMenu( item ? item->text( 0 ) : QString::null, TRUE, action, p );
+
+    if ( action == PA_Open )
+	selectDirectoryOrFile( item );
+    else if ( action == PA_Rename )
+	files->startRename( FALSE );
+    else if ( action == PA_Delete )
+	deleteFile( item ? item->text( 0 ) : QString::null );
+    else if ( action == PA_Reload )
+	rereadDir();
+    else if ( action == PA_Hidden ) {
+	bShowHiddenFiles = !bShowHiddenFiles;
+	rereadDir();
+    } else if ( action == PA_SortName ) {
+	sortFilesBy = (int)QDir::Name;
+	sortAscending = TRUE;
+	resortDir();
+    } else if ( action == PA_SortSize ) {
+	sortFilesBy = (int)QDir::Size;
+	sortAscending = TRUE;
+	resortDir();
+    } else if ( action == PA_SortDate ) {
+	sortFilesBy = (int)QDir::Time;
+	sortAscending = TRUE;
+	resortDir();
+    } else if ( action == PA_SortUnsorted ) {
+	sortFilesBy = (int)QDir::Unsorted;
+	sortAscending = TRUE;
+	resortDir();
+    }
+
+}
+
+void QFileDialog::popupContextMenu( QListBoxItem *item, const QPoint & p )
+{
+    PopupAction action;
+    popupContextMenu( item ? item->text() : QString::null, FALSE, action, p );
+
+    if ( action == PA_Open )
+	selectDirectoryOrFile( item );
+    else if ( action == PA_Rename )
+	d->moreFiles->startRename( FALSE );
+    else if ( action == PA_Delete )
+	deleteFile( item->text() );
+    else if ( action == PA_Reload )
+	rereadDir();
+    else if ( action == PA_Hidden ) {
+	bShowHiddenFiles = !bShowHiddenFiles;
+	rereadDir();
+    } else if ( action == PA_SortName ) {
+	sortFilesBy = (int)QDir::Name;
+	sortAscending = TRUE;
+	resortDir();
+    } else if ( action == PA_SortSize ) {
+	sortFilesBy = (int)QDir::Size;
+	sortAscending = TRUE;
+	resortDir();
+    } else if ( action == PA_SortDate ) {
+	sortFilesBy = (int)QDir::Time;
+	sortAscending = TRUE;
+	resortDir();
+    } else if ( action == PA_SortUnsorted ) {
+	sortFilesBy = (int)QDir::Unsorted;
+	sortAscending = TRUE;
+	resortDir();
+    }
+}
+
+void QFileDialog::popupContextMenu( const QString &filename, bool,
+				    PopupAction &action, const QPoint &p )
+{
+    action = PA_Cancel;
+
+    bool glob = filename.isEmpty();
+
+    QPopupMenu m( 0, "file dialog context menu" );
+    m.setCheckable( TRUE );
+
+    if ( !glob ) {
+	QString okt;
+	if ( QUrlInfo( d->url, filename ).isDir() ) {
+	    okt = tr( "&Open" );
+	} else {
+	    if ( mode() == AnyFile )
+		okt = tr( "&Save" );
+	    else
+		okt = tr( "&Open" );
+	}
+	int ok = m.insertItem( okt );
+
+	m.insertSeparator();
+	int rename = m.insertItem( tr( "&Rename" ) );
+	int del = m.insertItem( tr( "&Delete" ) );
+
+	if ( filename.isEmpty() || !QUrlInfo( d->url, filename ).isWritable() ||
+	     filename == ".." ) {
+	    if ( filename.isEmpty() || !QUrlInfo( d->url, filename ).isReadable() )
+		m.setItemEnabled( ok, FALSE );
+	    m.setItemEnabled( rename, FALSE );
+	    m.setItemEnabled( del, FALSE );
+	}
+
+	m.move( p );
+	int res = m.exec();
+
+	if ( res == ok )
+	    action = PA_Open;
+	else if ( res == rename )
+	    action = PA_Rename;
+	else if ( res == del )
+	    action = PA_Delete;
+    } else {
+	int reload = m.insertItem( tr( "R&eload" ) );
+
+	QPopupMenu m2( 0, "sort menu" );
+
+	int sname = m2.insertItem( tr( "Sort by &Name" ) );
+	//int stype = m2.insertItem( tr( "Sort by &Type" ) );
+	int ssize = m2.insertItem( tr( "Sort by &Size" ) );
+	int sdate = m2.insertItem( tr( "Sort by &Date" ) );
+	m2.insertSeparator();
+	int sunsorted = m2.insertItem( tr( "&Unsorted" ) );
+
+	//m2.setItemEnabled( stype, FALSE );
+
+	if ( sortFilesBy == (int)QDir::Name )
+	    m2.setItemChecked( sname, TRUE );
+	else if ( sortFilesBy == (int)QDir::Size )
+	    m2.setItemChecked( ssize, TRUE );
+//	else if ( sortFilesBy == 0x16 )
+//	    m2.setItemChecked( stype, TRUE );
+	else if ( sortFilesBy == (int)QDir::Time )
+	    m2.setItemChecked( sdate, TRUE );
+	else if ( sortFilesBy == (int)QDir::Unsorted )
+	    m2.setItemChecked( sunsorted, TRUE );
+
+	m.insertItem( tr( "Sort" ), &m2 );
+
+	m.insertSeparator();
+
+	int hidden = m.insertItem( tr( "Show &hidden files" ) );
+	m.setItemChecked( hidden, bShowHiddenFiles );
+
+	m.move( p );
+	int res = m.exec();
+
+	if ( res == reload )
+	    action = PA_Reload;
+	else if ( res == hidden )
+	    action = PA_Hidden;
+	else if ( res == sname )
+	    action = PA_SortName;
+//	else if ( res == stype )
+//	    action = PA_SortType;
+	else if ( res == sdate )
+	    action = PA_SortDate;
+	else if ( res == ssize )
+	    action = PA_SortSize;
+	else if ( res == sunsorted )
+	    action = PA_SortUnsorted;
+    }
+
+}
+
+void QFileDialog::deleteFile( const QString &filename )
+{
+    if ( filename.isEmpty() )
+	return;
+
+    QUrlInfo fi( d->url, QFileDialogPrivate::encodeFileName( filename ) );
+    QString t = tr( "the file" );
+    if ( fi.isDir() )
+	t = tr( "the directory" );
+    if ( fi.isSymLink() )
+	t = tr( "the symlink" );
+
+    if ( QMessageBox::warning( this,
+			       tr( "Delete %1" ).arg( t ),
+			       tr( "<qt>Are you sure you wish to delete %1 \"%2\"?</qt>" )
+			       .arg( t ).arg(filename),
+			       tr( "&Yes" ), tr( "&No" ), QString::null, 1 ) == 0 )
+	d->url.remove( QFileDialogPrivate::encodeFileName( filename ) );
+
+}
+
+void QFileDialog::fileSelected( int  )
+{
+    // unused
+}
+
+void QFileDialog::fileHighlighted( int )
+{
+    // unused
+}
+
+void QFileDialog::dirSelected( int )
+{
+    // unused
+}
+
+void QFileDialog::pathSelected( int )
+{
+    // unused
+}
+
+
+void QFileDialog::cdUpClicked()
+{
+    QString oldName = nameEdit->text();
+    setUrl( QUrlOperator( d->url, ".." ) );
+    if ( !oldName.isEmpty() )
+	nameEdit->setText( oldName );
+}
+
+void QFileDialog::newFolderClicked()
+{
+    QString foldername( tr( "New Folder 1" ) );
+    int i = 0;
+    QStringList lst;
+    QListViewItemIterator it( files );
+    for ( ; it.current(); ++it )
+	if ( it.current()->text( 0 ).contains( tr( "New Folder" ) ) )
+	    lst.append( it.current()->text( 0 ) );
+
+    if ( !lst.count() == 0 )
+	while ( lst.contains( foldername ) )
+	    foldername = tr( "New Folder %1" ).arg( ++i );
+
+    d->url.mkdir( foldername );
+}
+
+void QFileDialog::createdDirectory( const QUrlInfo &info, QNetworkOperation * )
+{
+    resortDir();
+    if ( d->moreFiles->isVisible() ) {
+	for ( uint i = 0; i < d->moreFiles->count(); ++i ) {
+	    if ( d->moreFiles->text( i ) == info.name() ) {
+		d->moreFiles->setCurrentItem( i );
+		d->moreFiles->startRename( FALSE );
+		break;
+	    }
+	}
+    } else {
+	QListViewItem *item = files->firstChild();
+	while ( item ) {
+	    if ( item->text( 0 ) == info.name() ) {
+		files->setSelected( item, TRUE );
+		files->setCurrentItem( item );
+		files->startRename( FALSE );
+		break;
+	    }
+	    item = item->nextSibling();
+	}
+    }
+}
+
+
+/*!
+  This is a convenience static function that will return an existing directory
+  selected by the user.
+
+  \code
+    QString s = QFileDialog::getExistingDirectory(
+                    "/home",
+		    this,
+		    "get existing directory",
+		    "Choose a directory",
+		    TRUE );
+  \endcode
+
+  This function creates a modal file dialog called \a name, with
+  parent, \a parent. If parent is not 0, the dialog will be shown
+  centered over the parent.
+
+  The dialog's working directory is set to \a dir, and the caption is
+  set to \a caption. Either of these may be QString::null in which case
+  the current directory and a default caption will be used respectively.
+
+  Note on Windows that if \a dir is QString::null then the dialog's working
+  directory will be set to the user's My Documents directory.
+
+  If \a dirOnly is TRUE, then only directories will be shown in
+  the file dialog; otherwise both directories and files will be shown.
+
+  Under Unix/X11, the normal behavior of the file dialog is to resolve
+  and follow symlinks. For example, if /usr/tmp is a symlink to /var/tmp,
+  the file dialog will change to /var/tmp after entering /usr/tmp.
+  If \a resolveSymlinks is FALSE, the file dialog will treat
+  symlinks as regular directories.
+
+  Under Windows and Mac OS X, this static function will use the native
+  file dialog and not a QFileDialog, unless the style of the application
+  is set to something other than the native style. (Note that on Windows the
+  dialog will spin a blocking modal event loop that will not dispatch any
+  QTimers and if parent is not 0 then it will position the dialog just under
+  the parent's titlebar).
+
+  \sa getOpenFileName(), getOpenFileNames(), getSaveFileName()
+*/
+
+QString QFileDialog::getExistingDirectory( const QString & dir,
+					   QWidget *parent,
+					   const char* name,
+					   const QString& caption,
+					   bool dirOnly,
+					   bool resolveSymlinks)
+{
+    bool save_qt_resolve_symlinks = qt_resolve_symlinks;
+    qt_resolve_symlinks = resolveSymlinks;
+
+    makeVariables();
+    QString wd;
+    if ( workingDirectory )
+	wd = *workingDirectory;
+
+#if defined(Q_WS_WIN)
+    QString initialDir;
+    if ( !dir.isEmpty() ) {
+	QUrlOperator u( dir );
+	if ( QFileInfo( u.path() ).isDir() )
+	    initialDir = dir;
+    } else
+	initialDir = QString::null;
+    if ( qt_use_native_dialogs && qApp->style().styleHint( QStyle::SH_GUIStyle ) == WindowsStyle && dirOnly )
+        return winGetExistingDirectory( initialDir, parent, name, caption );
+#endif
+#if defined(Q_WS_MAC)
+    QString *initialDir = 0;
+    if (!dir.isEmpty()) {
+        QUrlOperator u(dir);
+        if (QFileInfo(u.path()).isDir())
+            initialDir = (QString *)&dir;
+    }
+    if( qt_use_native_dialogs && (qApp->style().inherits(QMAC_DEFAULT_STYLE)
+                                  || qApp->style().inherits("QMacStyle")))
+	return qt_mac_precomposeFileName(macGetOpenFileNames("", initialDir, parent, name,
+                                                      caption, 0, FALSE, TRUE).first());
+#endif
+
+    QFileDialog *dlg = new QFileDialog( parent, name ? name : "qt_filedlg_ged", TRUE );
+
+    Q_CHECK_PTR( dlg );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    if ( !caption.isNull() )
+	dlg->setCaption( caption );
+    else
+	dlg->setCaption( QFileDialog::tr("Find Directory") );
+#endif
+
+    dlg->setMode( dirOnly ? DirectoryOnly : Directory );
+
+    dlg->d->types->clear();
+    dlg->d->types->insertItem( QFileDialog::tr("Directories") );
+    dlg->d->types->setEnabled( FALSE );
+
+    QString dir_( dir );
+    dir_ = dir_.simplifyWhiteSpace();
+    if ( dir_.isEmpty() && !wd.isEmpty() )
+	dir_ = wd;
+    QUrlOperator u( dir_ );
+    if ( u.isLocalFile() ) {
+	if ( !dir_.isEmpty() ) {
+	    QFileInfo f( u.path() );
+	if ( f.exists() )
+	if ( f.isDir() ) {
+		dlg->setDir( dir_ );
+		wd = dir_;
+	    }
+	} else if ( !wd.isEmpty() ) {
+	    QUrl tempUrl( wd );
+	    QFileInfo f( tempUrl.path() );
+	    if ( f.isDir() ) {
+		dlg->setDir( wd );
+	    }
+	} else {
+	    QString theDir = dir_;
+	    if ( theDir.isEmpty() ) {
+		theDir = ::toRootIfNotExists( QDir::currentDirPath() );
+	    } if ( !theDir.isEmpty() ) {
+		QUrl tempUrl( theDir );
+		QFileInfo f( tempUrl.path() );
+		if ( f.isDir() ) {
+		    wd = theDir;
+		    dlg->setDir( theDir );
+		}
+	    }
+	}
+    } else {
+	dlg->setUrl( dir_ );
+    }
+
+    QString result;
+    dlg->setSelection( dlg->d->url.toString() );
+
+    if ( dlg->exec() == QDialog::Accepted ) {
+	result = dlg->selectedFile();
+	wd = result;
+    }
+    delete dlg;
+
+    if ( !result.isEmpty() && result.right( 1 ) != "/" )
+	result += "/";
+
+    qt_resolve_symlinks = save_qt_resolve_symlinks;
+
+    return result;
+}
+
+
+/*!
+  \property QFileDialog::mode
+  \brief the file dialog's mode
+
+  The default mode is \c ExistingFile.
+*/
+
+void QFileDialog::setMode( Mode newMode )
+{
+    if ( d->mode != newMode ) {
+	d->mode = newMode;
+	QString sel = d->currentFileName;
+	int maxnamelen = 255; // _POSIX_MAX_PATH
+	if ( isDirectoryMode( newMode ) ) {
+	    files->setSelectionMode( QListView::Single );
+	    d->moreFiles->setSelectionMode( QListBox::Single );
+	    if ( sel.isNull() )
+		sel = QString::fromLatin1(".");
+	    d->types->setEnabled( FALSE );
+	} else if ( newMode == ExistingFiles ) {
+	    maxnamelen = INT_MAX;
+	    files->setSelectionMode( QListView::Extended );
+	    d->moreFiles->setSelectionMode( QListBox::Extended );
+	    d->types->setEnabled( TRUE );
+	} else {
+	    files->setSelectionMode( QListView::Single );
+	    d->moreFiles->setSelectionMode( QListBox::Single );
+	    d->types->setEnabled( TRUE );
+	}
+	nameEdit->setMaxLength(maxnamelen);
+	rereadDir();
+	QUrlInfo f( d->url, "." );
+	trySetSelection( f.isDir(), d->url, FALSE );
+    }
+
+    QString okt;
+    bool changeFilters = FALSE;
+    if ( mode() == AnyFile ) {
+	okt = tr("&Save");
+	d->fileL->setText( tr("File &name:") );
+	if ( d->types->count() == 1 ) {
+	    d->types->setCurrentItem( 0 );
+	    if ( d->types->currentText() == "Directories" ) {
+		changeFilters = TRUE;
+	    }
+	}
+    }
+    else if ( mode() == Directory || mode() == DirectoryOnly ) {
+	okt = tr("&OK");
+	d->fileL->setText( tr("Directory:") );
+	d->types->clear();
+	d->types->insertItem( tr("Directories") );
+    }
+    else {
+	okt = tr("&Open");
+	d->fileL->setText( tr("File &name:") );
+	if ( d->types->count() == 1 ) {
+	    d->types->setCurrentItem( 0 );
+	    if ( d->types->currentText() == "Directories" ) {
+		changeFilters = TRUE;
+	    }
+	}
+    }
+
+    if ( changeFilters ) {
+	d->types->clear();
+	d->types->insertItem( tr("All Files (*)") );
+    }
+
+    okB->setText( okt );
+}
+
+QFileDialog::Mode QFileDialog::mode() const
+{
+    return d->mode;
+}
+
+/*! \reimp
+*/
+
+void QFileDialog::done( int i )
+{
+    if ( i == QDialog::Accepted && (d->mode == ExistingFile || d->mode == ExistingFiles) ) {
+	QStringList selection = selectedFiles();
+	for ( uint f = 0; f < selection.count(); f++ ) {
+	    QString file = selection[f];
+	    if ( file.isNull() )
+		continue;
+	    if ( d->url.isLocalFile() && !QFile::exists( file ) ) {
+		QMessageBox::information( this, tr("Error"),
+					  tr("%1\nFile not found.\nCheck path and filename.").arg( file ) );
+		return;
+	    }
+	}
+    }
+    QDialog::done( i );
+}
+
+/*!
+  \property QFileDialog::viewMode
+
+  \brief the file dialog's view mode
+
+  If you set the view mode to be \e Detail (the default), then you
+  will see the file's details, such as the size of the file and the
+  date the file was last modified in addition to the file's name.
+
+  If you set the view mode to be \e List, then you will just
+  see a list of the files and folders.
+
+  See \l QFileDialog::ViewMode
+*/
+
+
+QFileDialog::ViewMode QFileDialog::viewMode() const
+{
+    if ( detailViewMode )
+	return Detail;
+    else
+	return List;
+}
+
+void QFileDialog::setViewMode( ViewMode m )
+{
+    if ( m == Detail ) {
+	detailViewMode = TRUE;
+	d->stack->raiseWidget( files );
+	d->detailView->setOn( TRUE );
+	d->mcView->setOn( FALSE );
+    } else if ( m == List ) {
+	detailViewMode = FALSE;
+	d->stack->raiseWidget( d->moreFiles );
+	d->detailView->setOn( FALSE );
+	d->mcView->setOn( TRUE );
+    }
+}
+
+
+/*!
+  \property QFileDialog::previewMode
+
+  \brief the preview mode for the file dialog
+
+  If you set the mode to be a mode other than \e NoPreview, you must
+  use setInfoPreview() or setContentsPreview() to set the dialog's
+  preview widget to your preview widget and enable the preview
+  widget(s) with setInfoPreviewEnabled() or
+  setContentsPreviewEnabled().
+
+  \sa infoPreview, contentsPreview, viewMode
+*/
+
+void QFileDialog::setPreviewMode( PreviewMode m )
+{
+    if ( m == NoPreview ) {
+	d->previewInfo->setOn( FALSE );
+	d->previewContents->setOn( FALSE );
+    } else if ( m == Info && d->infoPreview ) {
+	d->previewInfo->setOn( TRUE );
+	d->previewContents->setOn( FALSE );
+	changeMode( d->modeButtons->id( d->previewInfo ) );
+    } else if ( m == Contents && d->contentsPreview ) {
+	d->previewInfo->setOn( FALSE );
+	d->previewContents->setOn( TRUE );
+	changeMode( d->modeButtons->id( d->previewContents ) );
+    }
+}
+QFileDialog::PreviewMode QFileDialog::previewMode() const
+{
+    if ( d->infoPreview && d->infoPreviewWidget->isVisible() )
+	return Info;
+    else if ( d->contentsPreview && d->contentsPreviewWidget->isVisible() )
+	return Contents;
+
+    return NoPreview;
+}
+
+
+/*!
+  Adds the specified widgets to the bottom of the file dialog. The
+  label \a l is placed underneath the "file name" and the "file types"
+  labels. The widget \a w is placed underneath the file types combobox.
+  The button \a b is placed underneath the Cancel pushbutton.
+
+  \code
+    MyFileDialog::MyFileDialog( QWidget* parent, const char* name ) :
+	QFileDialog( parent, name )
+    {
+	QLabel* label = new QLabel( "Added widgets", this );
+	QLineEdit* lineedit = new QLineEdit( this );
+	QPushButton* pushbutton = new QPushButton( this );
+
+	addWidgets( label, lineedit, pushbutton );
+    }
+  \endcode
+
+  If you don't want to have one of the widgets added, pass 0 in that
+  widget's position.
+
+  Every time you call this function, a new row of widgets will be added
+  to the bottom of the file dialog.
+
+  \sa addToolButton(), addLeftWidget(), addRightWidget()
+*/
+
+void QFileDialog::addWidgets( QLabel * l, QWidget * w, QPushButton * b )
+{
+    if ( !l && !w && !b )
+	return;
+
+    d->geometryDirty = TRUE;
+
+    QHBoxLayout *lay = new QHBoxLayout();
+    d->extraWidgetsLayouts.append( lay );
+    d->topLevelLayout->addLayout( lay );
+
+    if ( !l )
+	l = new QLabel( this, "qt_intern_lbl" );
+    d->extraLabels.append( l );
+    lay->addWidget( l );
+
+    if ( !w )
+	w = new QWidget( this, "qt_intern_widget" );
+    d->extraWidgets.append( w );
+    lay->addWidget( w );
+    lay->addSpacing( 15 );
+
+    if ( b ) {
+	d->extraButtons.append( b );
+	lay->addWidget( b );
+    } else {
+	QWidget *wid = new QWidget( this, "qt_extrabuttons_widget" );
+	d->extraButtons.append( wid );
+	lay->addWidget( wid );
+    }
+
+    updateGeometries();
+}
+
+/*!
+  Adds the tool button \a b to the row of tool buttons at the top of the
+  file dialog. The button is appended to the right of
+  this row. If \a separator is TRUE, a small space is inserted between the
+  last button of the row and the new button \a b.
+
+  \sa addWidgets(), addLeftWidget(), addRightWidget()
+*/
+
+void QFileDialog::addToolButton( QButton *b, bool separator )
+{
+    if ( !b || !d->buttonLayout )
+	return;
+
+    d->geometryDirty = TRUE;
+
+    d->toolButtons.append( b );
+    if ( separator )
+	d->buttonLayout->addSpacing( 8 );
+    d->buttonLayout->addWidget( b );
+
+    updateGeometries();
+}
+
+/*!
+  Adds the widget \a w to the left-hand side of the file dialog.
+
+  \sa addRightWidget(), addWidgets(), addToolButton()
+*/
+
+void QFileDialog::addLeftWidget( QWidget *w )
+{
+    if ( !w )
+	return;
+    d->geometryDirty = TRUE;
+
+    d->leftLayout->addWidget( w );
+    d->leftLayout->addSpacing( 5 );
+
+    updateGeometries();
+}
+
+/*!
+  Adds the widget \a w to the right-hand side of the file dialog.
+
+  \sa addLeftWidget(), addWidgets(), addToolButton()
+*/
+
+void QFileDialog::addRightWidget( QWidget *w )
+{
+    if ( !w )
+	return;
+    d->geometryDirty = TRUE;
+
+    d->rightLayout->addSpacing( 5 );
+    d->rightLayout->addWidget( w );
+
+    updateGeometries();
+}
+
+/*! \reimp */
+
+void QFileDialog::keyPressEvent( QKeyEvent * ke )
+{
+    if ( !d->ignoreNextKeyPress &&
+	 ke && ( ke->key() == Key_Enter ||
+		 ke->key() == Key_Return ) ) {
+	ke->ignore();
+	if ( d->paths->hasFocus() ) {
+	    ke->accept();
+	    if ( d->url == QUrl(d->paths->currentText()) )
+		nameEdit->setFocus();
+	} else if ( d->types->hasFocus() ) {
+	    ke->accept();
+	    // ### is there a suitable condition for this?  only valid
+	    // wildcards?
+	    nameEdit->setFocus();
+	} else if ( nameEdit->hasFocus() ) {
+	    if ( d->currentFileName.isNull() ) {
+		// maybe change directory
+		QUrlInfo i( d->url, nameEdit->text() );
+		if ( i.isDir() ) {
+		    nameEdit->setText( QString::fromLatin1("") );
+		    setDir( QUrlOperator( d->url, QFileDialogPrivate::encodeFileName(i.name()) ) );
+		}
+		ke->accept();
+	    } else if ( mode() == ExistingFiles ) {
+		QUrlInfo i( d->url, nameEdit->text() );
+		if ( i.isFile() ) {
+		    QListViewItem * i = files->firstChild();
+		    while ( i && nameEdit->text() != i->text( 0 ) )
+			i = i->nextSibling();
+		    if ( i )
+			files->setSelected( i, TRUE );
+		    else
+			ke->accept(); // strangely, means to ignore that event
+		}
+	    }
+	} else if ( files->hasFocus() || d->moreFiles->hasFocus() ) {
+	    ke->accept();
+	}
+    } else if ( ke->key() == Key_Escape ) {
+	ke->ignore();
+    }
+
+    d->ignoreNextKeyPress = FALSE;
+
+    if ( !ke->isAccepted() ) {
+	QDialog::keyPressEvent( ke );
+    }
+}
+
+
+/*! \class QFileIconProvider qfiledialog.h
+
+  \brief The QFileIconProvider class provides icons for QFileDialog to
+  use.
+
+  \ingroup misc
+
+  By default QFileIconProvider is not used, but any application or
+  library can subclass it, reimplement pixmap() to return a suitable
+  icon, and make all QFileDialog objects use it by calling the static
+  function QFileDialog::setIconProvider().
+
+  It is advisable to make all the icons that QFileIconProvider returns be
+  the same size or at least the same width. This makes the list view
+  look much better.
+
+  \sa QFileDialog
+*/
+
+
+/*! Constructs an empty file icon provider called \a name, with the
+  parent \a parent.
+*/
+
+QFileIconProvider::QFileIconProvider( QObject * parent, const char* name )
+    : QObject( parent, name )
+{
+    // nothing necessary
+}
+
+
+/*!
+  Returns a pointer to a pixmap that should be used to
+  signify the file with the information \a info.
+
+  If pixmap() returns 0, QFileDialog draws the default pixmap.
+
+  The default implementation returns particular icons for files, directories,
+  link-files and link-directories. It returns a blank "icon" for other types.
+
+  If you return a pixmap here, it should measure 16x16 pixels.
+*/
+
+const QPixmap * QFileIconProvider::pixmap( const QFileInfo & info )
+{
+    if ( info.isSymLink() ) {
+	if ( info.isFile() )
+	    return symLinkFileIcon;
+	else
+	    return symLinkDirIcon;
+    } else if ( info.isDir() ) {
+	return closedFolderIcon;
+    } else if ( info.isFile() ) {
+	return fileIcon;
+    } else {
+	return fifteenTransparentPixels;
+    }
+}
+
+/*!
+  Sets the QFileIconProvider used by the file dialog to \a provider.
+
+  The default is that there is no QFileIconProvider and QFileDialog
+  just draws a folder icon next to each directory and nothing next
+  to files.
+
+  \sa QFileIconProvider, iconProvider()
+*/
+
+void QFileDialog::setIconProvider( QFileIconProvider * provider )
+{
+    fileIconProvider = provider;
+}
+
+
+/*!
+  Returns a pointer to the icon provider currently set on the file dialog.
+  By default there is no icon provider, and this function returns 0.
+
+  \sa setIconProvider(), QFileIconProvider
+*/
+
+QFileIconProvider * QFileDialog::iconProvider()
+{
+    return fileIconProvider;
+}
+
+
+#if defined(Q_WS_WIN)
+
+// ### FIXME: this code is duplicated in qdns.cpp
+static QString getWindowsRegString( HKEY key, const QString &subKey )
+{
+    QString s;
+    QT_WA( {
+	char buf[1024];
+	DWORD bsz = sizeof(buf);
+	int r = RegQueryValueEx( key, (TCHAR*)subKey.ucs2(), 0, 0, (LPBYTE)buf, &bsz );
+	if ( r == ERROR_SUCCESS ) {
+	    s = QString::fromUcs2( (unsigned short *)buf );
+	} else if ( r == ERROR_MORE_DATA ) {
+	    char *ptr = new char[bsz+1];
+	    r = RegQueryValueEx( key, (TCHAR*)subKey.ucs2(), 0, 0, (LPBYTE)ptr, &bsz );
+	    if ( r == ERROR_SUCCESS )
+		s = ptr;
+	    delete [] ptr;
+	}
+    } , {
+	char buf[512];
+	DWORD bsz = sizeof(buf);
+	int r = RegQueryValueExA( key, subKey.local8Bit(), 0, 0, (LPBYTE)buf, &bsz );
+	if ( r == ERROR_SUCCESS ) {
+	    s = buf;
+	} else if ( r == ERROR_MORE_DATA ) {
+	    char *ptr = new char[bsz+1];
+	    r = RegQueryValueExA( key, subKey.local8Bit(), 0, 0, (LPBYTE)ptr, &bsz );
+	    if ( r == ERROR_SUCCESS )
+		s = ptr;
+	    delete [] ptr;
+	}
+    } );
+    return s;
+}
+
+static void initPixmap( QPixmap &pm )
+{
+    pm.fill( Qt::white );
+}
+
+
+QWindowsIconProvider::QWindowsIconProvider( QObject *parent, const char *name )
+    : QFileIconProvider( parent, name )
+{
+    pixw = GetSystemMetrics( SM_CXSMICON );
+    pixh = GetSystemMetrics( SM_CYSMICON );
+
+    HKEY k;
+    HICON si;
+    int r;
+    QString s;
+    UINT res = 0;
+
+    // ---------- get default folder pixmap
+    const wchar_t iconFolder[] = L"folder\\DefaultIcon"; // workaround for Borland
+    QT_WA( {
+	r = RegOpenKeyEx( HKEY_CLASSES_ROOT,
+			   iconFolder,
+			   0, KEY_READ, &k );
+    } , {
+	r = RegOpenKeyExA( HKEY_CLASSES_ROOT,
+			   "folder\\DefaultIcon",
+			   0, KEY_READ, &k );
+    } );
+    resolveLibs();
+    if ( r == ERROR_SUCCESS ) {
+	s = getWindowsRegString( k, QString::null );
+	RegCloseKey( k );
+
+	QStringList lst = QStringList::split( ",", s );
+        
+    if (lst.count() >= 2) { // don't just assume that lst has two entries
+#ifndef Q_OS_TEMP
+            QT_WA( {
+                    res = ptrExtractIconEx( (TCHAR*)lst[ 0 ].simplifyWhiteSpace().ucs2(),
+                        lst[ 1 ].simplifyWhiteSpace().toInt(),
+                        0, &si, 1 );
+                    } , {
+                    res = ExtractIconExA( lst[ 0 ].simplifyWhiteSpace().local8Bit(),
+                        lst[ 1 ].simplifyWhiteSpace().toInt(),
+                        0, &si, 1 );
+                    } );
+#else
+            res = (UINT)ExtractIconEx( (TCHAR*)lst[ 0 ].simplifyWhiteSpace().ucs2(),
+                    lst[ 1 ].simplifyWhiteSpace().toInt(),
+                    0, &si, 1 );
+#endif
+    }
+	if ( res ) {
+	    defaultFolder.resize( pixw, pixh );
+	    initPixmap( defaultFolder );
+	    QPainter p( &defaultFolder );
+	    DrawIconEx( p.handle(), 0, 0, si, pixw, pixh, 0, 0,  DI_NORMAL );
+	    p.end();
+	    defaultFolder.setMask( defaultFolder.createHeuristicMask() );
+	    *closedFolderIcon = defaultFolder;
+	    DestroyIcon( si );
+	} else {
+	    defaultFolder = *closedFolderIcon;
+	}
+    } else {
+	RegCloseKey( k );
+    }
+
+    //------------------------------- get default file pixmap
+#ifndef Q_OS_TEMP
+    QT_WA( {
+	res = ptrExtractIconEx( L"shell32.dll",
+				 0, 0, &si, 1 );
+    } , {
+	res = ExtractIconExA( "shell32.dll",
+				 0, 0, &si, 1 );
+    } );
+#else
+	res = (UINT)ExtractIconEx( L"shell32.dll",
+				    0, 0, &si, 1 );
+#endif
+
+    if ( res ) {
+	defaultFile.resize( pixw, pixh );
+	initPixmap( defaultFile );
+	QPainter p( &defaultFile );
+	DrawIconEx( p.handle(), 0, 0, si, pixw, pixh, 0, 0,  DI_NORMAL );
+	p.end();
+	defaultFile.setMask( defaultFile.createHeuristicMask() );
+	*fileIcon = defaultFile;
+	DestroyIcon( si );
+    } else {
+	defaultFile = *fileIcon;
+    }
+
+    //------------------------------- get default exe pixmap
+#ifndef Q_OS_TEMP
+    QT_WA( {
+	res = ptrExtractIconEx( L"shell32.dll",
+			      2, 0, &si, 1 );
+    } , {
+	res = ExtractIconExA( "shell32.dll",
+			  2, 0, &si, 1 );
+    } );
+#else
+	res = (UINT)ExtractIconEx( L"ceshell.dll",
+				    10, 0, &si, 1 );
+#endif
+
+    if ( res ) {
+	defaultExe.resize( pixw, pixh );
+	initPixmap( defaultExe );
+	QPainter p( &defaultExe );
+	DrawIconEx( p.handle(), 0, 0, si, pixw, pixh, 0, 0,  DI_NORMAL );
+	p.end();
+	defaultExe.setMask( defaultExe.createHeuristicMask() );
+	DestroyIcon( si );
+    } else {
+	defaultExe = *fileIcon;
+    }
+}
+
+QWindowsIconProvider::~QWindowsIconProvider()
+{
+    if ( this == fileIconProvider )
+	fileIconProvider = 0;
+}
+
+const QPixmap * QWindowsIconProvider::pixmap( const QFileInfo &fi )
+{
+    if (fi.isSymLink()) {
+        QString real = fi.readLink();
+        if (!real.isEmpty())
+            return pixmap(QFileInfo(real));
+    }
+
+    QString ext = fi.extension( FALSE ).upper();
+    QString key = ext;
+    ext.prepend( "." );
+    QMap< QString, QPixmap >::Iterator it;
+
+    if ( fi.isDir() ) {
+	return &defaultFolder;
+    } else if ( ext != ".EXE" ) {
+	it = cache.find( key );
+	if ( it != cache.end() )
+	    return &( *it );
+
+	HKEY k, k2;
+	int r;
+	QT_WA( {
+	    r = RegOpenKeyEx( HKEY_CLASSES_ROOT, (TCHAR*)ext.ucs2(),
+			      0, KEY_READ, &k );
+	} , {
+	    r = RegOpenKeyExA( HKEY_CLASSES_ROOT, ext.local8Bit(),
+			       0, KEY_READ, &k );
+	} );
+	QString s;
+	if ( r == ERROR_SUCCESS ) {
+	    s = getWindowsRegString( k, QString::null );
+	} else {
+	    cache[ key ] = defaultFile;
+	    RegCloseKey( k );
+	    return &defaultFile;
+	}
+	RegCloseKey( k );
+
+	QT_WA( {
+	    r = RegOpenKeyEx( HKEY_CLASSES_ROOT, (TCHAR*)QString( s + "\\DefaultIcon" ).ucs2(),
+			       0, KEY_READ, &k2 );
+	} , {
+	    r = RegOpenKeyExA( HKEY_CLASSES_ROOT, QString( s + "\\DefaultIcon" ).local8Bit() ,
+	    		       0, KEY_READ, &k2 );
+	} );
+	if ( r == ERROR_SUCCESS ) {
+	    s = getWindowsRegString( k2, QString::null );
+	} else {
+	    cache[ key ] = defaultFile;
+	    RegCloseKey( k2 );
+	    return &defaultFile;
+	}
+	RegCloseKey( k2 );
+
+	QStringList lst = QStringList::split( ",", s );
+
+        HICON si;
+        UINT res = 0;
+        if (lst.count() >= 2) { // don't just assume that lst has two entries
+            QString filepath = lst[ 0 ].stripWhiteSpace();
+            if ( !filepath.isEmpty() ) {
+                if ( filepath.find("%1") != -1 ) {
+                    filepath = filepath.arg( fi.filePath() );
+                    if ( ext == ".DLL" ) {
+                        pix = defaultFile;
+                        return &pix;
+                    }
+                }
+                if ( filepath[0] == '"' && filepath[(int)filepath.length()-1] == '"' )
+                    filepath = filepath.mid( 1, filepath.length()-2 );
+
+                resolveLibs();
+#ifndef Q_OS_TEMP
+                QT_WA( {
+                        res = ptrExtractIconEx( (TCHAR*)filepath.ucs2(), lst[ 1 ].stripWhiteSpace().toInt(),
+                            0, &si, 1 );
+                        } , {
+                        res = ExtractIconExA( filepath.local8Bit(), lst[ 1 ].stripWhiteSpace().toInt(),
+                            0, &si, 1 );
+                        } );
+#else
+                res = (UINT)ExtractIconEx( (TCHAR*)filepath.ucs2(), lst[ 1 ].stripWhiteSpace().toInt(),
+                        0, &si, 1 );
+#endif
+            }
+        }
+
+	if ( res ) {
+	    pix.resize( pixw, pixh );
+	    initPixmap( pix );
+	    QPainter p( &pix );
+	    DrawIconEx( p.handle(), 0, 0, si, pixw, pixh, 0, 0,  DI_NORMAL );
+	    p.end();
+	    pix.setMask( pix.createHeuristicMask() );
+	    DestroyIcon( si );
+	} else {
+	    pix = defaultFile;
+	}
+
+	cache[ key ] = pix;
+	return &pix;
+    } else {
+	HICON si;
+	UINT res = 0;
+	if ( !fi.absFilePath().isEmpty() ) {
+#ifndef Q_OS_TEMP
+	    QT_WA( {
+		res = ptrExtractIconEx( (TCHAR*)fi.absFilePath().ucs2(), -1,
+				      0, 0, 1 );
+	    } , {
+		res = ExtractIconExA( fi.absFilePath().local8Bit(), -1,
+				      0, 0, 1 );
+	    } );
+
+	    if ( res ) {
+		QT_WA( {
+		    res = ptrExtractIconEx( (TCHAR*)fi.absFilePath().ucs2(), res - 1,
+					  0, &si, 1 );
+		} , {
+		    res = ExtractIconExA( fi.absFilePath().local8Bit(), res - 1,
+					  0, &si, 1 );
+		} );
+	    }
+#else
+		res = (UINT)ExtractIconEx( (TCHAR*)fi.absFilePath().ucs2(), -1,
+					    0, 0, 1 );
+		if ( res )
+		    res = (UINT)ExtractIconEx( (TCHAR*)fi.absFilePath().ucs2(), res - 1,
+						0, &si, 1 );
+#endif
+
+	}
+
+	if ( res ) {
+	    pix.resize( pixw, pixh );
+	    initPixmap( pix );
+	    QPainter p( &pix );
+	    DrawIconEx( p.handle(), 0, 0, si, pixw, pixh, 0, 0,  DI_NORMAL );
+	    p.end();
+	    pix.setMask( pix.createHeuristicMask() );
+	    DestroyIcon( si );
+	} else {
+	    pix = defaultExe;
+	}
+
+	return &pix;
+    }
+
+    // can't happen!
+    return 0;
+}
+#endif
+
+
+
+/*!
+  \reimp
+*/
+bool QFileDialog::eventFilter( QObject * o, QEvent * e )
+{
+    if ( e->type() == QEvent::KeyPress && ( (QKeyEvent*)e )->key() == Key_F5 ) {
+	rereadDir();
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress && ( (QKeyEvent*)e )->key() == Key_F2 &&
+		( o == files || o == files->viewport() ) ) {
+	if ( files->isVisible() && files->currentItem() ) {
+	    if ( QUrlInfo( d->url, "." ).isWritable() && files->currentItem()->text( 0 ) != ".." ) {
+		files->renameItem = files->currentItem();
+		files->startRename( TRUE );
+	    }
+	}
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress && ( (QKeyEvent*)e )->key() == Key_F2 &&
+		( o == d->moreFiles || o == d->moreFiles->viewport() ) ) {
+	if ( d->moreFiles->isVisible() && d->moreFiles->currentItem() != -1 ) {
+	    if ( QUrlInfo( d->url, "." ).isWritable() &&
+		 d->moreFiles->item( d->moreFiles->currentItem() )->text() != ".." ) {
+		d->moreFiles->renameItem = d->moreFiles->item( d->moreFiles->currentItem() );
+		d->moreFiles->startRename( TRUE );
+	    }
+	}
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress && d->moreFiles->renaming ) {
+	d->moreFiles->lined->setFocus();
+	QApplication::sendEvent( d->moreFiles->lined, e );
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress && files->renaming ) {
+	files->lined->setFocus();
+	QApplication::sendEvent( files->lined, e );
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress &&
+		((QKeyEvent *)e)->key() == Key_Backspace &&
+		( o == files ||
+		  o == d->moreFiles ||
+		  o == files->viewport() ||
+		  o == d->moreFiles->viewport() ) ) {
+	cdUpClicked();
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress &&
+		((QKeyEvent *)e)->key() == Key_Delete &&
+		( o == files ||
+		  o == files->viewport() ) ) {
+	if ( files->currentItem() )
+	    deleteFile( files->currentItem()->text( 0 ) );
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( e->type() == QEvent::KeyPress &&
+		((QKeyEvent *)e)->key() == Key_Delete &&
+		( o == d->moreFiles ||
+		  o == d->moreFiles->viewport() ) ) {
+	int c = d->moreFiles->currentItem();
+	if ( c >= 0 )
+	    deleteFile( d->moreFiles->item( c )->text() );
+	((QKeyEvent *)e)->accept();
+	return TRUE;
+    } else if ( o == files && e->type() == QEvent::FocusOut && files->currentItem() ) {
+    } else if ( o == files && e->type() == QEvent::KeyPress ) {
+	QTimer::singleShot( 0, this, SLOT(fixupNameEdit()) );
+    } else if ( o == nameEdit && e->type() == QEvent::KeyPress && d->mode != AnyFile ) {
+	if ( ( nameEdit->cursorPosition() == (int)nameEdit->text().length() || nameEdit->hasSelectedText() ) &&
+	     isprint(((QKeyEvent *)e)->ascii()) ) {
+#if defined(Q_WS_WIN)
+	    QString nt( nameEdit->text().lower() );
+#else
+	    QString nt( nameEdit->text() );
+#endif
+	    nt.truncate( nameEdit->cursorPosition() );
+	    nt += (char)(((QKeyEvent *)e)->ascii());
+	    QListViewItem * i = files->firstChild();
+#if defined(Q_WS_WIN)
+	    while( i && i->text( 0 ).left(nt.length()).lower() != nt )
+#else
+	    while( i && i->text( 0 ).left(nt.length()) != nt )
+#endif
+		i = i->nextSibling();
+	    if ( i ) {
+		nt = i->text( 0 );
+		int cp = nameEdit->cursorPosition()+1;
+		nameEdit->validateAndSet( nt, cp, cp, nt.length() );
+		return TRUE;
+	    }
+	}
+    } else if ( o == nameEdit && e->type() == QEvent::FocusIn ) {
+	fileNameEditDone();
+    } else if ( d->moreFiles->renaming && o != d->moreFiles->lined && e->type() == QEvent::FocusIn ) {
+	d->moreFiles->lined->setFocus();
+	return TRUE;
+    } else if ( files->renaming && o != files->lined && e->type() == QEvent::FocusIn ) {
+	files->lined->setFocus();
+	return TRUE;
+    } else if ( ( o == d->moreFiles || o == d->moreFiles->viewport() ) &&
+		e->type() == QEvent::FocusIn ) {
+	if ( o == d->moreFiles->viewport() && !d->moreFiles->viewport()->hasFocus() ||
+	     o == d->moreFiles && !d->moreFiles->hasFocus() )
+	    ((QWidget*)o)->setFocus();
+	return FALSE;
+    }
+
+    return QDialog::eventFilter( o, e );
+}
+
+/*!
+  Sets the filters used in the file dialog to \a filters. Each group
+  of filters must be separated by \c{;;} (\e two semi-colons).
+
+  \code
+    QString types("Image files (*.png *.xpm *.jpg);;"
+                  "Text files (*.txt);;"
+		  "Any files (*)");
+    QFileDialog fd = new QFileDialog( this );
+    fd->setFilters( types );
+    fd->show();
+  \endcode
+
+*/
+
+void QFileDialog::setFilters( const QString &filters )
+{
+    QStringList lst = makeFiltersList( filters );
+    setFilters( lst );
+}
+
+/*!
+  \overload
+
+  \a types must be a null-terminated list of strings.
+
+*/
+
+void QFileDialog::setFilters( const char ** types )
+{
+    if ( !types || !*types )
+	return;
+
+    d->types->clear();
+    while( types && *types ) {
+	d->types->insertItem( QString::fromLatin1(*types) );
+	types++;
+    }
+    d->types->setCurrentItem( 0 );
+    setFilter( d->types->text( 0 ) );
+}
+
+
+/*! \overload void QFileDialog::setFilters( const QStringList & )
+*/
+
+void QFileDialog::setFilters( const QStringList & types )
+{
+    if ( types.count() < 1 )
+	return;
+
+    d->types->clear();
+    for ( QStringList::ConstIterator it = types.begin(); it != types.end(); ++it )
+	d->types->insertItem( *it );
+    d->types->setCurrentItem( 0 );
+    setFilter( d->types->text( 0 ) );
+}
+
+/*!
+  Adds the filter \a filter to the list of filters and makes it the
+  current filter.
+
+  \code
+    QFileDialog* fd = new QFileDialog( this );
+    fd->addFilter( "Images (*.png *.jpg *.xpm)" );
+    fd->show();
+  \endcode
+
+  In the above example, a file dialog is created, and the file filter "Images
+  (*.png *.jpg *.xpm)" is added and is set as the current filter. The original
+  filter, "All Files (*)", is still available.
+
+  \sa setFilter(), setFilters()
+*/
+
+void QFileDialog::addFilter( const QString &filter )
+{
+    if ( filter.isEmpty() )
+	return;
+    QString f = filter;
+    QRegExp r( QString::fromLatin1(qt_file_dialog_filter_reg_exp) );
+    int index = r.search( f );
+    if ( index >= 0 )
+	f = r.cap( 2 );
+    for ( int i = 0; i < d->types->count(); ++i ) {
+	QString f2( d->types->text( i ) );
+	int index = r.search( f2 );
+	if ( index >= 0 )
+	    f2 = r.cap( 1 );
+	if ( f2 == f ) {
+	    d->types->setCurrentItem( i );
+	    setFilter( f2 );
+	    return;
+	}
+    }
+
+    d->types->insertItem( filter );
+    d->types->setCurrentItem( d->types->count() - 1 );
+    setFilter( d->types->text( d->types->count() - 1 ) );
+}
+
+/*!
+  Since modeButtons is a top-level widget, it may be destroyed by the
+  kernel at application exit. Notice if this happens to
+  avoid double deletion.
+*/
+
+void QFileDialog::modeButtonsDestroyed()
+{
+    if ( d )
+	d->modeButtons = 0;
+}
+
+
+/*!
+  This is a convenience static function that will return one or more
+  existing files selected by the user.
+
+  \code
+    QStringList files = QFileDialog::getOpenFileNames(
+			    "Images (*.png *.xpm *.jpg)",
+			    "/home",
+			    this,
+			    "open files dialog",
+			    "Select one or more files to open" );
+  \endcode
+
+  This function creates a modal file dialog called \a name, with
+  parent \a parent. If \a parent is not 0, the dialog will be shown
+  centered over the parent.
+
+  The file dialog's working directory will be set to \a dir. If \a
+  dir includes a file name, the file will be selected. The filter
+  is set to \a filter so that only those files which match the filter
+  are shown. The filter selected is set to \a selectedFilter. The parameters
+  \a dir, \a selectedFilter and \a filter may be QString::null.
+
+  The dialog's caption is set to \a caption. If \a caption is not
+  specified then a default caption will be used.
+
+  Under Windows and Mac OS X, this static function will use the native
+  file dialog and not a QFileDialog, unless the style of the application
+  is set to something other than the native style. (Note that on Windows the
+  dialog will spin a blocking modal event loop that will not dispatch any
+  QTimers and if parent is not 0 then it will position the dialog just under
+  the parent's titlebar).
+
+  Under Unix/X11, the normal behavior of the file dialog is to resolve
+  and follow symlinks. For example, if /usr/tmp is a symlink to /var/tmp,
+  the file dialog will change to /var/tmp after entering /usr/tmp.
+  If \a resolveSymlinks is FALSE, the file dialog will treat
+  symlinks as regular directories.
+
+  Note that if you want to iterate over the list of files, you should
+  iterate over a copy, e.g.
+    \code
+    QStringList list = files;
+    QStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+  \sa getOpenFileName(), getSaveFileName(), getExistingDirectory()
+*/
+
+QStringList QFileDialog::getOpenFileNames( const QString & filter,
+					   const QString& dir,
+					   QWidget *parent,
+					   const char* name,
+					   const QString& caption,
+					   QString *selectedFilter,
+					   bool resolveSymlinks )
+{
+    bool save_qt_resolve_symlinks = qt_resolve_symlinks;
+    qt_resolve_symlinks = resolveSymlinks;
+
+    QStringList filters;
+    if ( !filter.isEmpty() )
+	filters = makeFiltersList( filter );
+
+    makeVariables();
+
+    if ( workingDirectory->isNull() )
+	*workingDirectory = ::toRootIfNotExists( QDir::currentDirPath() );
+
+    if ( !dir.isEmpty() ) {
+	// #### works only correct for local files
+	QUrlOperator u( QFileDialogPrivate::encodeFileName(dir) );
+	if ( u.isLocalFile() && QFileInfo( u.path() ).isDir() ) {
+	    *workingDirectory = dir;
+	} else {
+	    *workingDirectory = u.toString();
+	}
+    }
+
+#if defined(Q_WS_WIN)
+    if ( qt_use_native_dialogs && qApp->style().styleHint( QStyle::SH_GUIStyle ) == WindowsStyle )
+	return winGetOpenFileNames( filter, workingDirectory, parent, name, caption, selectedFilter );
+#elif defined(Q_WS_MAC)
+    if (qt_use_native_dialogs && (qApp->style().inherits(QMAC_DEFAULT_STYLE)
+                                  || qApp->style().inherits("QMacStyle"))) {
+        QStringList sl = macGetOpenFileNames(filter, dir.isEmpty() ? 0 : workingDirectory, parent,
+                                             name, caption, selectedFilter);
+        QStringList::iterator it = sl.begin();
+        while (it != sl.end()) {
+            *it = qt_mac_precomposeFileName(*it);
+            ++it;
+        }
+	return sl;
+    }
+#endif
+
+    QFileDialog *dlg = new QFileDialog( *workingDirectory, QString::null, parent, name ? name : "qt_filedlg_gofns", TRUE );
+
+    Q_CHECK_PTR( dlg );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    if ( !caption.isNull() )
+	dlg->setCaption( caption );
+    else
+	dlg->setCaption( QFileDialog::tr("Open") );
+#endif
+
+    dlg->setFilters( filters );
+    if ( selectedFilter )
+	dlg->setFilter( *selectedFilter );
+    dlg->setMode( QFileDialog::ExistingFiles );
+    QString result;
+    QStringList lst;
+    if ( dlg->exec() == QDialog::Accepted ) {
+	lst = dlg->selectedFiles();
+	*workingDirectory = dlg->d->url;
+	if ( selectedFilter )
+	    *selectedFilter = dlg->selectedFilter();
+    }
+    delete dlg;
+
+    qt_resolve_symlinks = save_qt_resolve_symlinks;
+    return lst;
+}
+
+/*!  Updates the line edit to match the speed-key usage in QListView. */
+
+void QFileDialog::fixupNameEdit()
+{
+    if ( files->currentItem() ) {
+	if ( ( (QFileDialogPrivate::File*)files->currentItem() )->info.isFile() )
+	    nameEdit->setText( files->currentItem()->text( 0 ) );
+    }
+}
+
+/*!
+  Returns the URL of the current working directory in the file dialog.
+
+  \sa setUrl()
+*/
+
+QUrl QFileDialog::url() const
+{
+    return d->url;
+}
+
+static bool isRoot( const QUrl &u )
+{
+#if defined(Q_OS_MAC9)
+     QString p = QDir::convertSeparators(u.path());
+     if(p.contains(':') == 1)
+	return TRUE;
+#elif defined(Q_OS_UNIX)
+    if ( u.path() == "/" )
+	return TRUE;
+#elif defined(Q_OS_WIN32)
+    QString p = u.path();
+    if ( p.length() == 3 &&
+	 p.right( 2 ) == ":/" )
+	return TRUE;
+    if ( p[ 0 ] == '/' && p[ 1 ] == '/' ) {
+	int slashes = p.contains( '/' );
+	if ( slashes <= 3 )
+	    return TRUE;
+	if ( slashes == 4 && p[ (int)p.length() - 1 ] == '/' )
+	    return TRUE;
+    }
+#else
+#if defined(Q_CC_GNU)
+#warning "case not covered.."
+#endif
+#endif
+
+    if ( !u.isLocalFile() && u.path() == "/" )
+	return TRUE;
+
+    return FALSE;
+}
+
+void QFileDialog::urlStart( QNetworkOperation *op )
+{
+    if ( !op )
+	return;
+
+#if defined(Q_WS_WIN)
+    qt_ntfs_permission_lookup--;
+#endif
+    if ( op->operation() == QNetworkProtocol::OpListChildren ) {
+#ifndef QT_NO_CURSOR
+	if ( !d->cursorOverride ) {
+	    QApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
+	    d->cursorOverride = TRUE;
+	}
+#endif
+	if ( isRoot( d->url ) )
+	    d->cdToParent->setEnabled( FALSE );
+	else
+	    d->cdToParent->setEnabled( TRUE );
+	d->mimeTypeTimer->stop();
+	d->sortedList.clear();
+	d->pendingItems.clear();
+	d->moreFiles->clearSelection();
+	files->clearSelection();
+	d->moreFiles->clear();
+	files->clear();
+	files->setSorting( -1 );
+
+	QString s = d->url.toString( FALSE, FALSE );
+	bool found = FALSE;
+	for ( int i = 0; i < d->paths->count(); ++i ) {
+#if defined(Q_WS_WIN)
+	    if ( d->paths->text( i ).lower() == s.lower() ) {
+#else
+	    if ( d->paths->text( i ) == s ) {
+#endif
+		found = TRUE;
+		d->paths->setCurrentItem( i );
+		break;
+	    }
+	}
+	if ( !found ) {
+	    d->paths->insertItem( *openFolderIcon, s, -1 );
+	    d->paths->setCurrentItem( d->paths->count() - 1 );
+	}
+	d->last = 0;
+	d->hadDotDot = FALSE;
+
+	if ( d->goBack && d->history.last() != d->url.toString() ) {
+	    d->history.append( d->url.toString() );
+	    if ( d->history.count() > 1 )
+		d->goBack->setEnabled( TRUE );
+	}
+    }
+}
+
+void QFileDialog::urlFinished( QNetworkOperation *op )
+{
+    if ( !op )
+	return;
+
+#ifndef QT_NO_CURSOR
+    if ( op->operation() == QNetworkProtocol::OpListChildren &&
+	 d->cursorOverride ) {
+	QApplication::restoreOverrideCursor();
+	d->cursorOverride = FALSE;
+    }
+#endif
+
+    if ( op->state() == QNetworkProtocol::StFailed ) {
+	if ( d->paths->hasFocus() )
+	    d->ignoreNextKeyPress = TRUE;
+
+	if ( d->progressDia ) {
+	    d->ignoreStop = TRUE;
+	    d->progressDia->close();
+	    delete d->progressDia;
+	    d->progressDia = 0;
+	}
+
+	int ecode = op->errorCode();
+	QMessageBox::critical( this, tr( "Error" ), op->protocolDetail() );
+
+	if ( ecode == QNetworkProtocol::ErrListChildren || ecode == QNetworkProtocol::ErrParse ||
+	     ecode == QNetworkProtocol::ErrUnknownProtocol || ecode == QNetworkProtocol::ErrLoginIncorrect ||
+	     ecode == QNetworkProtocol::ErrValid || ecode == QNetworkProtocol::ErrHostNotFound ||
+	     ecode == QNetworkProtocol::ErrFileNotExisting ) {
+	    if (d->url != d->oldUrl) {
+		d->url = d->oldUrl;
+		rereadDir();
+	    }
+	} else {
+	    // another error happened, no need to go back to last dir
+	}
+    } else if ( op->operation() == QNetworkProtocol::OpListChildren &&
+		op == d->currListChildren ) {
+	if ( !d->hadDotDot && !isRoot( d->url ) ) {
+	    bool ok = TRUE;
+#if defined(Q_WS_WIN)
+	    if ( d->url.path().left( 2 ) == "//" )
+		ok = FALSE;
+#endif
+	    if ( ok ) {
+		QUrlInfo ui( d->url, ".." );
+		ui.setName( ".." );
+		ui.setDir( TRUE );
+		ui.setFile( FALSE );
+		ui.setSymLink( FALSE );
+		ui.setSize( 0 );
+		QValueList<QUrlInfo> lst;
+		lst << ui;
+		insertEntry( lst, 0 );
+	    }
+	}
+	resortDir();
+    } else if ( op->operation() == QNetworkProtocol::OpGet ) {
+    } else if ( op->operation() == QNetworkProtocol::OpPut ) {
+	rereadDir();
+	if ( d->progressDia ) {
+	    d->ignoreStop = TRUE;
+	    d->progressDia->close();
+	}
+	delete d->progressDia;
+	d->progressDia = 0;
+    }
+
+#if defined(Q_WS_WIN)
+    if (d->oldPermissionLookup != qt_ntfs_permission_lookup)
+        qt_ntfs_permission_lookup++;
+#endif
+}
+
+void QFileDialog::dataTransferProgress( int bytesDone, int bytesTotal, QNetworkOperation *op )
+{
+    if ( !op )
+	return;
+
+    QString label;
+    QUrl u( op->arg( 0 ) );
+    if ( u.isLocalFile() ) {
+	label = u.path();
+    } else {
+	label = QString( "%1 (on %2)" );
+	label = label.arg( u.path() ).arg( u.host() );
+    }
+
+    if ( !d->progressDia ) {
+	if ( bytesDone < bytesTotal) {
+	    d->ignoreStop = FALSE;
+	    d->progressDia = new QFDProgressDialog( this, label, bytesTotal );
+	    connect( d->progressDia, SIGNAL( cancelled() ),
+		     this, SLOT( stopCopy() ) );
+	    d->progressDia->show();
+	} else
+	    return;
+    }
+
+    if ( d->progressDia ) {
+	if ( op->operation() == QNetworkProtocol::OpGet ) {
+	    if ( d->progressDia ) {
+		d->progressDia->setReadProgress( bytesDone );
+	    }
+	} else if ( op->operation() == QNetworkProtocol::OpPut ) {
+	    if ( d->progressDia ) {
+		d->progressDia->setWriteLabel( label );
+		d->progressDia->setWriteProgress( bytesDone );
+	    }
+	} else {
+	    return;
+	}
+    }
+}
+
+void QFileDialog::insertEntry( const QValueList<QUrlInfo> &lst, QNetworkOperation *op )
+{
+    if ( op && op->operation() == QNetworkProtocol::OpListChildren &&
+	 op != d->currListChildren )
+	return;
+    QValueList<QUrlInfo>::ConstIterator it = lst.begin();
+    for ( ; it != lst.end(); ++it ) {
+	const QUrlInfo &inf = *it;
+	if ( d->mode == DirectoryOnly && !inf.isDir() )
+	    continue;
+	if ( inf.name() == ".." ) {
+	    d->hadDotDot = TRUE;
+	    if ( isRoot( d->url ) )
+		continue;
+#if defined(Q_WS_WIN)
+	    if ( d->url.path().left( 2 ) == "//" )
+		continue;
+#endif
+	} else if ( inf.name() == "." )
+	    continue;
+
+#if defined(Q_WS_WIN)
+	// Workaround a Windows bug, '..' is apparantly hidden in directories
+	// that are one level away from root
+	if ( !bShowHiddenFiles && inf.name() != ".." ) {
+	    if ( d->url.isLocalFile() ) {
+		QString file = d->url.path();
+		if ( !file.endsWith( "/" ) )
+		    file.append( "/" );
+	        file += inf.name();
+		QT_WA( {
+		    if ( GetFileAttributesW( (TCHAR*)file.ucs2() ) & FILE_ATTRIBUTE_HIDDEN )
+			continue;
+		} , {
+		    if ( GetFileAttributesA( file.local8Bit() ) & FILE_ATTRIBUTE_HIDDEN )
+			continue;
+		} );
+	    } else {
+		if ( inf.name() != ".." && inf.name()[0] == QChar('.') )
+		    continue;
+	    }
+	}
+#else
+ 	if ( !bShowHiddenFiles && inf.name() != ".." ) {
+ 	    if ( inf.name()[ 0 ] == QChar( '.' ) )
+ 		continue;
+ 	}
+#endif
+	if ( !d->url.isLocalFile() ) {
+	    QFileDialogPrivate::File * i = 0;
+	    QFileDialogPrivate::MCItem *i2 = 0;
+	    i = new QFileDialogPrivate::File( d, &inf, files );
+	    i2 = new QFileDialogPrivate::MCItem( d->moreFiles, i );
+
+	    if ( d->mode == ExistingFiles && inf.isDir() ||
+		( isDirectoryMode( d->mode ) && inf.isFile() ) ) {
+		i->setSelectable( FALSE );
+		i2->setSelectable( FALSE );
+	    }
+
+	    i->i = i2;
+	}
+
+	d->sortedList.append( new QUrlInfo( inf ) );
+    }
+}
+
+void QFileDialog::removeEntry( QNetworkOperation *op )
+{
+    if ( !op )
+	return;
+
+    QUrlInfo *i = 0;
+    QListViewItemIterator it( files );
+    bool ok1 = FALSE, ok2 = FALSE;
+    for ( i = d->sortedList.first(); it.current(); ++it, i = d->sortedList.next() ) {
+        QString encName = QFileDialogPrivate::encodeFileName(
+            ( (QFileDialogPrivate::File*)it.current() )->info.name() );
+	if ( encName == op->arg( 0 ) ) {
+	    d->pendingItems.removeRef( (QFileDialogPrivate::File*)it.current() );
+	    delete ( (QFileDialogPrivate::File*)it.current() )->i;
+	    delete it.current();
+	    ok1 = TRUE;
+	}
+	if ( i && i->name() == op->arg( 0 ) ) {
+	    d->sortedList.removeRef( i );
+	    i = d->sortedList.prev();
+	    ok2 = TRUE;
+	}
+	if ( ok1 && ok2 )
+	    break;
+    }
+}
+
+void QFileDialog::itemChanged( QNetworkOperation *op )
+{
+    if ( !op )
+	return;
+
+    QUrlInfo *i = 0;
+    QListViewItemIterator it1( files );
+    bool ok1 = FALSE, ok2 = FALSE;
+    // first check whether the new file replaces an existing file.
+    for ( i = d->sortedList.first(); it1.current(); ++it1, i = d->sortedList.next() ) {
+	if ( ( (QFileDialogPrivate::File*)it1.current() )->info.name() == op->arg( 1 ) ) {
+	    delete ( (QFileDialogPrivate::File*)it1.current() )->i;
+	    delete it1.current();
+	    ok1 = TRUE;
+	}
+	if ( i && i->name() == op->arg( 1 ) ) {
+	    d->sortedList.removeRef( i );
+	    i = d->sortedList.prev();
+	    ok2 = TRUE;
+	}
+	if ( ok1 && ok2 )
+	    break;
+    }
+
+    i = 0;
+    QListViewItemIterator it( files );
+    ok1 = FALSE;
+    ok2 = FALSE;
+    for ( i = d->sortedList.first(); it.current(); ++it, i = d->sortedList.next() ) {
+	if ( ( (QFileDialogPrivate::File*)it.current() )->info.name() == op->arg( 0 ) ) {
+	    ( (QFileDialogPrivate::File*)it.current() )->info.setName( op->arg( 1 ) );
+	    ok1 = TRUE;
+	}
+	if ( i && i->name() == op->arg( 0 ) ) {
+	    i->setName( op->arg( 1 ) );
+	    ok2 = TRUE;
+	}
+	if ( ok1 && ok2 )
+	    break;
+    }
+
+    resortDir();
+}
+
+/*!
+  \property QFileDialog::infoPreview
+
+  \brief whether the file dialog can provide preview information about
+  the currently selected file
+
+  The default is FALSE.
+*/
+bool QFileDialog::isInfoPreviewEnabled() const
+{
+    return d->infoPreview;
+}
+
+void QFileDialog::setInfoPreviewEnabled( bool info )
+{
+    if ( info == d->infoPreview )
+	return;
+    d->geometryDirty = TRUE;
+    d->infoPreview = info;
+    updateGeometries();
+}
+
+
+/*!
+  \property QFileDialog::contentsPreview
+
+  \brief whether the file dialog can provide a contents preview of the
+  currently selected file
+
+  The default is FALSE.
+
+  \sa setContentsPreview() setInfoPreviewEnabled()
+*/
+// ### improve the above documentation: how is the preview done, how can I add
+// support for customized preview, etc.
+
+bool QFileDialog::isContentsPreviewEnabled() const
+{
+    return d->contentsPreview;
+}
+
+void QFileDialog::setContentsPreviewEnabled( bool contents )
+{
+    if ( contents == d->contentsPreview )
+	return;
+    d->geometryDirty = TRUE;
+    d->contentsPreview = contents;
+    updateGeometries();
+}
+
+
+/*!
+  Sets the widget to be used for displaying information about the file
+  to the widget \a w and a preview of that information to the
+  QFilePreview \a preview.
+
+  Normally you would create a preview widget that derives from both QWidget and
+  QFilePreview, so you should pass the same widget twice. If you
+  don't, you must remember to delete the preview object in order to
+  avoid memory leaks.
+
+  \code
+    class Preview : public QLabel, public QFilePreview
+    {
+    public:
+	Preview( QWidget *parent=0 ) : QLabel( parent ) {}
+
+	void previewUrl( const QUrl &u )
+	{
+	    QString path = u.path();
+	    QPixmap pix( path );
+	    if ( pix.isNull() )
+		setText( "This is not a pixmap" );
+	    else
+		setText( "This is a pixmap" );
+	}
+    };
+
+  //...
+
+  int main( int argc, char** argv )
+  {
+    Preview* p = new Preview;
+
+    QFileDialog* fd = new QFileDialog( this );
+    fd->setInfoPreviewEnabled( TRUE );
+    fd->setInfoPreview( p, p );
+    fd->setPreviewMode( QFileDialog::Info );
+    fd->show();
+  }
+
+  \endcode
+
+  \sa setContentsPreview(), setInfoPreviewEnabled(), setPreviewMode()
+
+*/
+
+void QFileDialog::setInfoPreview( QWidget *w, QFilePreview *preview )
+{
+    if ( !w || !preview )
+	return;
+
+    if ( d->infoPreviewWidget ) {
+	d->preview->removeWidget( d->infoPreviewWidget );
+	delete d->infoPreviewWidget;
+    }
+    d->infoPreviewWidget = w;
+    d->infoPreviewer = preview;
+    w->reparent( d->preview, 0, QPoint( 0, 0 ) );
+}
+
+/*!
+  Sets the widget to be used for displaying the contents of the file
+  to the widget \a w and a preview of those contents to the
+  QFilePreview \a preview.
+
+  Normally you would create a preview widget that derives from both QWidget and
+  QFilePreview, so you should pass the same widget twice. If you
+  don't, you must remember to delete the preview object in order to
+  avoid memory leaks.
+
+  \code
+    class Preview : public QLabel, public QFilePreview
+    {
+    public:
+	Preview( QWidget *parent=0 ) : QLabel( parent ) {}
+
+	void previewUrl( const QUrl &u )
+	{
+	    QString path = u.path();
+	    QPixmap pix( path );
+	    if ( pix.isNull() )
+		setText( "This is not a pixmap" );
+	    else
+		setPixmap( pix );
+	}
+    };
+
+  //...
+
+  int main( int argc, char** argv )
+  {
+    Preview* p = new Preview;
+
+    QFileDialog* fd = new QFileDialog( this );
+    fd->setContentsPreviewEnabled( TRUE );
+    fd->setContentsPreview( p, p );
+    fd->setPreviewMode( QFileDialog::Contents );
+    fd->show();
+  }
+  \endcode
+
+  \sa setContentsPreviewEnabled(), setInfoPreview(), setPreviewMode()
+*/
+
+void QFileDialog::setContentsPreview( QWidget *w, QFilePreview *preview )
+{
+    if ( !w || !preview )
+	return;
+
+    if ( d->contentsPreviewWidget ) {
+	d->preview->removeWidget( d->contentsPreviewWidget );
+	delete d->contentsPreviewWidget;
+    }
+    d->contentsPreviewWidget = w;
+    d->contentsPreviewer = preview;
+    w->reparent( d->preview, 0, QPoint( 0, 0 ) );
+}
+
+/*!
+  Re-sorts the displayed directory.
+
+  \sa rereadDir()
+*/
+
+void QFileDialog::resortDir()
+{
+    d->mimeTypeTimer->stop();
+    d->pendingItems.clear();
+
+    QFileDialogPrivate::File *item = 0;
+    QFileDialogPrivate::MCItem *item2 = 0;
+
+    d->sortedList.sort();
+
+    if ( files->childCount() > 0 || d->moreFiles->count() > 0 ) {
+	d->moreFiles->clear();
+	files->clear();
+	d->last = 0;
+	files->setSorting( -1 );
+    }
+
+    QUrlInfo *i = sortAscending ? d->sortedList.first() : d->sortedList.last();
+    for ( ; i; i = sortAscending ? d->sortedList.next() : d->sortedList.prev() ) {
+	item = new QFileDialogPrivate::File( d, i, files );
+	item2 = new QFileDialogPrivate::MCItem( d->moreFiles, item, item2 );
+	item->i = item2;
+	d->pendingItems.append( item );
+	if ( d->mode == ExistingFiles && item->info.isDir() ||
+	    ( isDirectoryMode( d->mode ) && item->info.isFile() ) ) {
+	    item->setSelectable( FALSE );
+	    item2->setSelectable( FALSE );
+	}
+    }
+
+    // ##### As the QFileIconProvider only support QFileInfo and no
+    // QUrlInfo it can be only used for local files at the moment. In
+    // 3.0 we have to change the API of QFileIconProvider to work on
+    // QUrlInfo so that also remote filesystems can be show mime-type
+    // specific icons.
+    if ( d->url.isLocalFile() )
+	d->mimeTypeTimer->start( 0 );
+}
+
+/*!
+  Stops the current copy operation.
+*/
+
+void QFileDialog::stopCopy()
+{
+    if ( d->ignoreStop )
+	return;
+
+    d->url.blockSignals( TRUE );
+    d->url.stop();
+    if ( d->progressDia ) {
+	d->ignoreStop = TRUE;
+	QTimer::singleShot( 100, this, SLOT( removeProgressDia() ) );
+    }
+    d->url.blockSignals( FALSE );
+}
+
+/*!
+  \internal
+*/
+
+void QFileDialog::removeProgressDia()
+{
+    if ( d->progressDia )
+	delete d->progressDia;
+    d->progressDia = 0;
+}
+
+/*!
+  \internal
+*/
+
+void QFileDialog::doMimeTypeLookup()
+{
+    if ( !iconProvider() ) {
+	d->pendingItems.clear();
+	d->mimeTypeTimer->stop();
+	return;
+    }
+
+    d->mimeTypeTimer->stop();
+    if ( d->pendingItems.count() == 0 ) {
+	return;
+    }
+
+    QRect r;
+    QFileDialogPrivate::File *item = d->pendingItems.first();
+    if ( item ) {
+	QFileInfo fi;
+	if ( d->url.isLocalFile() ) {
+	    fi.setFile( QUrl( d->url.path(), QFileDialogPrivate::encodeFileName( item->info.name() ) ).path( FALSE ) );
+	} else
+	    fi.setFile( item->info.name() ); // #####
+	const QPixmap *p = iconProvider()->pixmap( fi );
+	if ( p && p != item->pixmap( 0 ) &&
+	     ( !item->pixmap( 0 ) || p->serialNumber() != item->pixmap( 0 )->serialNumber() ) &&
+	     p != fifteenTransparentPixels ) {
+	    item->hasMimePixmap = TRUE;
+
+	    // evil hack to avoid much too much repaints!
+	    QGuardedPtr<QFileDialog> that( this ); // this may be deleted by an event handler
+	    qApp->processEvents();
+	    if ( that.isNull() )
+		return;
+	    files->setUpdatesEnabled( FALSE );
+	    files->viewport()->setUpdatesEnabled( FALSE );
+	    if ( item != d->pendingItems.first() )
+		return;
+	    item->setPixmap( 0, *p );
+	    qApp->processEvents();
+	    if ( that.isNull() )
+		return;
+	    files->setUpdatesEnabled( TRUE );
+	    files->viewport()->setUpdatesEnabled( TRUE );
+
+	    if ( files->isVisible() ) {
+		QRect ir( files->itemRect( item ) );
+		if ( ir != QRect( 0, 0, -1, -1 ) ) {
+		    r = r.unite( ir );
+		}
+	    } else {
+		QRect ir( d->moreFiles->itemRect( item->i ) );
+		if ( ir != QRect( 0, 0, -1, -1 ) ) {
+		    r = r.unite( ir );
+		}
+	    }
+	}
+	if ( d->pendingItems.count() )
+	    d->pendingItems.removeFirst();
+    }
+
+    if ( d->moreFiles->isVisible() ) {
+	d->moreFiles->viewport()->repaint( r, FALSE );
+    } else {
+	files->viewport()->repaint( r, FALSE );
+    }
+
+    if ( d->pendingItems.count() )
+	d->mimeTypeTimer->start( 0 );
+    else if ( d->moreFiles->isVisible() )
+	d->moreFiles->triggerUpdate( TRUE );
+}
+
+/*!
+  If \a b is TRUE then all the files in the current directory are selected;
+  otherwise, they are deselected.
+*/
+
+void QFileDialog::selectAll( bool b )
+{
+    if ( d->mode != ExistingFiles )
+	return;
+    d->moreFiles->selectAll( b );
+    files->selectAll( b );
+}
+
+void QFileDialog::goBack()
+{
+    if ( !d->goBack || !d->goBack->isEnabled() )
+	return;
+    d->history.remove( d->history.last() );
+    if ( d->history.count() < 2 )
+	d->goBack->setEnabled( FALSE );
+    setUrl( d->history.last() );
+}
+
+// a class with wonderfully inflexible flexibility. why doesn't it
+// just subclass QWidget in the first place? 'you have to derive your
+// preview widget from QWidget and from this class' indeed.
+
+/*!
+  \class QFilePreview qfiledialog.h
+  \ingroup misc
+  \brief The QFilePreview class provides file previewing in QFileDialog.
+
+  This class is an abstract base class which is used to implement
+  widgets that can display a preview of a file in a QFileDialog.
+
+  You must derive the preview widget from both QWidget and from this
+  class. Then you must reimplement this class's previewUrl() function,
+  which is called by the file dialog if the preview of a file
+  (specified as a URL) should be shown.
+
+  See also QFileDialog::setPreviewMode(), QFileDialog::setContentsPreview(),
+  QFileDialog::setInfoPreview(), QFileDialog::setInfoPreviewEnabled(),
+  QFileDialog::setContentsPreviewEnabled().
+
+  For an example of a preview widget see qt/examples/qdir/qdir.cpp.
+*/
+
+/*!
+  Constructs the QFilePreview.
+*/
+
+QFilePreview::QFilePreview()
+{
+}
+
+/*!
+  \fn void QFilePreview::previewUrl( const QUrl &url )
+
+  This function is called by QFileDialog if a preview
+  for the \a url should be shown. Reimplement this
+  function to provide file previewing.
+*/
+
+
+#include "qfiledialog.moc"
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qfiledialog.h b/main/dependencies/qt3/src/dialogs/qfiledialog.h
new file mode 100644
index 000000000..82d1f9a47
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qfiledialog.h
@@ -0,0 +1,347 @@
+/****************************************************************************
+**
+** Definition of QFileDialog class
+**
+** Created : 950428
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QFILEDIALOG_H
+#define QFILEDIALOG_H
+
+class QPushButton;
+class QButton;
+class QLabel;
+class QWidget;
+class QFileDialog;
+class QTimer;
+class QNetworkOperation;
+class QLineEdit;
+class QListViewItem;
+class QListBoxItem;
+class QFileDialogPrivate;
+class QFileDialogQFileListView;
+
+#ifndef QT_H
+#include "qdir.h"
+#include "qdialog.h"
+#include "qurloperator.h"
+#include "qurlinfo.h"
+#endif // QT_H
+
+#if __GNUC__ - 0 > 3
+#pragma GCC system_header
+#endif
+
+#ifndef QT_NO_FILEDIALOG
+
+class Q_EXPORT QFileIconProvider : public QObject
+{
+    Q_OBJECT
+public:
+    QFileIconProvider( QObject * parent = 0, const char* name = 0 );
+    virtual const QPixmap * pixmap( const QFileInfo & );
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QFileIconProvider( const QFileIconProvider & );
+    QFileIconProvider& operator=( const QFileIconProvider & );
+#endif
+};
+
+class Q_EXPORT QFilePreview
+{
+public:
+    QFilePreview();
+    virtual void previewUrl( const QUrl &url ) = 0;
+
+};
+
+class Q_EXPORT QFileDialog : public QDialog
+{
+    Q_OBJECT
+    Q_ENUMS( Mode ViewMode PreviewMode )
+    // ##### Why are this read-only properties ?
+    Q_PROPERTY( QString selectedFile READ selectedFile )
+    Q_PROPERTY( QString selectedFilter READ selectedFilter )
+    Q_PROPERTY( QStringList selectedFiles READ selectedFiles )
+    // #### Should not we be able to set the path ?
+    Q_PROPERTY( QString dirPath READ dirPath )
+    Q_PROPERTY( bool showHiddenFiles READ showHiddenFiles WRITE setShowHiddenFiles )
+    Q_PROPERTY( Mode mode READ mode WRITE setMode )
+    Q_PROPERTY( ViewMode viewMode READ viewMode WRITE setViewMode )
+    Q_PROPERTY( PreviewMode previewMode READ previewMode WRITE setPreviewMode )
+    Q_PROPERTY( bool infoPreview READ isInfoPreviewEnabled WRITE setInfoPreviewEnabled )
+    Q_PROPERTY( bool contentsPreview READ isContentsPreviewEnabled WRITE setContentsPreviewEnabled )
+
+public:
+    QFileDialog( const QString& dirName, const QString& filter = QString::null,
+		 QWidget* parent=0, const char* name=0, bool modal = FALSE );
+    QFileDialog( QWidget* parent=0, const char* name=0, bool modal = FALSE );
+    ~QFileDialog();
+
+    // recommended static functions
+
+    static QString getOpenFileName( const QString &initially = QString::null,
+				    const QString &filter = QString::null,
+				    QWidget *parent = 0, const char* name = 0,
+				    const QString &caption = QString::null,
+				    QString *selectedFilter = 0,
+				    bool resolveSymlinks = TRUE);
+    static QString getSaveFileName( const QString &initially = QString::null,
+				    const QString &filter = QString::null,
+				    QWidget *parent = 0, const char* name = 0,
+				    const QString &caption = QString::null,
+				    QString *selectedFilter = 0,
+				    bool resolveSymlinks = TRUE);
+    static QString getExistingDirectory( const QString &dir = QString::null,
+					 QWidget *parent = 0,
+					 const char* name = 0,
+					 const QString &caption = QString::null,
+					 bool dirOnly = TRUE,
+					 bool resolveSymlinks = TRUE);
+    static QStringList getOpenFileNames( const QString &filter= QString::null,
+					 const QString &dir = QString::null,
+					 QWidget *parent = 0,
+					 const char* name = 0,
+					 const QString &caption = QString::null,
+					 QString *selectedFilter = 0,
+					 bool resolveSymlinks = TRUE);
+
+    // other static functions
+
+    static void setIconProvider( QFileIconProvider * );
+    static QFileIconProvider * iconProvider();
+
+    // non-static function for special needs
+
+    QString selectedFile() const;
+    QString selectedFilter() const;
+    virtual void setSelectedFilter( const QString& );
+    virtual void setSelectedFilter( int );
+
+    void setSelection( const QString &);
+
+    void selectAll( bool b );
+
+    QStringList selectedFiles() const;
+
+    QString dirPath() const;
+
+    void setDir( const QDir & );
+    const QDir *dir() const;
+
+    void setShowHiddenFiles( bool s );
+    bool showHiddenFiles() const;
+
+    void rereadDir();
+    void resortDir();
+
+    enum Mode { AnyFile, ExistingFile, Directory, ExistingFiles, DirectoryOnly };
+    void setMode( Mode );
+    Mode mode() const;
+
+    enum ViewMode { Detail, List };
+    enum PreviewMode { NoPreview, Contents, Info };
+    void setViewMode( ViewMode m );
+    ViewMode viewMode() const;
+    void setPreviewMode( PreviewMode m );
+    PreviewMode previewMode() const;
+
+    bool eventFilter( QObject *, QEvent * );
+
+    bool isInfoPreviewEnabled() const;
+    bool isContentsPreviewEnabled() const;
+    void setInfoPreviewEnabled( bool );
+    void setContentsPreviewEnabled( bool );
+
+    void setInfoPreview( QWidget *w, QFilePreview *preview );
+    void setContentsPreview( QWidget *w, QFilePreview *preview );
+
+    QUrl url() const;
+
+    void addFilter( const QString &filter );
+
+public slots:
+    void done( int );
+    void setDir( const QString& );
+    void setUrl( const QUrlOperator &url );
+    void setFilter( const QString& );
+    void setFilters( const QString& );
+    void setFilters( const char ** );
+    void setFilters( const QStringList& );
+
+protected:
+    void resizeEvent( QResizeEvent * );
+    void keyPressEvent( QKeyEvent * );
+
+    void addWidgets( QLabel *, QWidget *, QPushButton * );
+    void addToolButton( QButton *b, bool separator = FALSE );
+    void addLeftWidget( QWidget *w );
+    void addRightWidget( QWidget *w );
+
+signals:
+    void fileHighlighted( const QString& );
+    void fileSelected( const QString& );
+    void filesSelected( const QStringList& );
+    void dirEntered( const QString& );
+    void filterSelected( const QString& );
+
+private slots:
+    void detailViewSelectionChanged();
+    void listBoxSelectionChanged();
+    void changeMode( int );
+    void fileNameEditReturnPressed();
+    void stopCopy();
+    void removeProgressDia();
+
+    void fileSelected( int );
+    void fileHighlighted( int );
+    void dirSelected( int );
+    void pathSelected( int );
+
+    void updateFileNameEdit( QListViewItem *);
+    void selectDirectoryOrFile( QListViewItem * );
+    void popupContextMenu( QListViewItem *, const QPoint &, int );
+    void popupContextMenu( QListBoxItem *, const QPoint & );
+    void updateFileNameEdit( QListBoxItem *);
+    void selectDirectoryOrFile( QListBoxItem * );
+    void fileNameEditDone();
+
+    void okClicked();
+    void filterClicked(); // not used
+    void cancelClicked();
+
+    void cdUpClicked();
+    void newFolderClicked();
+
+    void fixupNameEdit();
+
+    void doMimeTypeLookup();
+
+    void updateGeometries();
+    void modeButtonsDestroyed();
+    void urlStart( QNetworkOperation *op );
+    void urlFinished( QNetworkOperation *op );
+    void dataTransferProgress( int bytesDone, int bytesTotal, QNetworkOperation * );
+    void insertEntry( const QValueList<QUrlInfo> &fi, QNetworkOperation *op );
+    void removeEntry( QNetworkOperation * );
+    void createdDirectory( const QUrlInfo &info, QNetworkOperation * );
+    void itemChanged( QNetworkOperation * );
+    void goBack();
+
+private:
+    enum PopupAction {
+	PA_Open = 0,
+	PA_Delete,
+	PA_Rename,
+	PA_SortName,
+	PA_SortSize,
+	PA_SortType,
+	PA_SortDate,
+	PA_SortUnsorted,
+	PA_Cancel,
+	PA_Reload,
+	PA_Hidden
+    };
+
+    void init();
+    bool trySetSelection( bool isDir, const QUrlOperator &, bool );
+    void deleteFile( const QString &filename );
+    void popupContextMenu( const QString &filename, bool withSort,
+			   PopupAction &action, const QPoint &p );
+    void updatePreviews( const QUrl &u );
+
+    QDir reserved; // was cwd
+    QString fileName;
+
+    friend class QFileDialogQFileListView;
+    friend class QFileListBox;
+
+    QFileDialogPrivate *d;
+    QFileDialogQFileListView  *files;
+
+    QLineEdit  *nameEdit; // also filter
+    QPushButton *okB;
+    QPushButton *cancelB;
+
+#if defined(Q_WS_WIN)
+    static QString winGetOpenFileName( const QString &initialSelection,
+				       const QString &filter,
+				       QString* workingDirectory,
+				       QWidget *parent = 0,
+				       const char* name = 0,
+				       const QString& caption = QString::null,
+				       QString* selectedFilter = 0 );
+    static QString winGetSaveFileName( const QString &initialSelection,
+				       const QString &filter,
+				       QString* workingDirectory,
+				       QWidget *parent = 0,
+				       const char* name = 0,
+				       const QString& caption = QString::null,
+    				       QString* selectedFilter = 0 );
+    static QStringList winGetOpenFileNames( const QString &filter,
+					    QString* workingDirectory,
+					    QWidget *parent = 0,
+					    const char* name = 0,
+					    const QString& caption = QString::null,
+					    QString* selectedFilter = 0 );
+    static QString winGetExistingDirectory( const QString &initialDirectory,
+					    QWidget* parent = 0,
+					    const char* name = 0,
+					    const QString& caption = QString::null);
+    static QString resolveLinkFile( const QString& linkfile );
+#endif
+#if defined(Q_WS_MACX) || defined(Q_WS_MAC9)
+    static QString macGetSaveFileName( const QString &, const QString &,
+				       QString *, QWidget *, const char*,
+				       const QString&, QString *);
+    static QStringList macGetOpenFileNames( const QString &, QString*,
+					    QWidget *, const char *,
+					    const QString&, QString *,
+					    bool = TRUE, bool = FALSE );
+#endif
+
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QFileDialog( const QFileDialog & );
+    QFileDialog &operator=( const QFileDialog & );
+#endif
+};
+
+#endif
+
+#endif // QFILEDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qfontdialog.cpp b/main/dependencies/qt3/src/dialogs/qfontdialog.cpp
new file mode 100644
index 000000000..1deec00e6
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qfontdialog.cpp
@@ -0,0 +1,831 @@
+/****************************************************************************
+**
+** Implementation of QFontDialog
+**
+** Created : 970605
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qwindowdefs.h"
+
+#ifndef QT_NO_FONTDIALOG
+
+#include "qfontdialog.h"
+
+#include "qlineedit.h"
+#include "qlistbox.h"
+#include "qpushbutton.h"
+#include "qcheckbox.h"
+#include "qcombobox.h"
+#include "qlayout.h"
+#include "qvgroupbox.h"
+#include "qhgroupbox.h"
+#include "qlabel.h"
+#include "qapplication.h"
+#include "qfontdatabase.h"
+#include "qstyle.h"
+#include <private/qfontdata_p.h>
+#include <qvalidator.h>
+
+/*!
+  \class QFontDialog qfontdialog.h
+  \ingroup dialogs
+  \mainclass
+  \brief The QFontDialog class provides a dialog widget for selecting a font.
+
+  The usual way to use this class is to call one of the static convenience
+  functions, e.g. getFont().
+
+  Examples:
+
+  \code
+    bool ok;
+    QFont font = QFontDialog::getFont(
+		    &ok, QFont( "Helvetica [Cronyx]", 10 ), this );
+    if ( ok ) {
+	// font is set to the font the user selected
+    } else {
+	// the user canceled the dialog; font is set to the initial
+	// value, in this case Helvetica [Cronyx], 10
+    }
+  \endcode
+
+    The dialog can also be used to set a widget's font directly:
+  \code
+    myWidget.setFont( QFontDialog::getFont( 0, myWidget.font() ) );
+  \endcode
+  If the user clicks OK the font they chose will be used for myWidget,
+  and if they click Cancel the original font is used.
+
+  \sa QFont QFontInfo QFontMetrics
+
+  <img src=qfontdlg-w.png>
+*/
+
+class QFontDialogPrivate
+{
+public:
+    QFontDialogPrivate() : script( QFontPrivate::defaultScript ) {};
+    QLabel * familyAccel;
+    QLineEdit * familyEdit;
+    QListBox * familyList;
+
+    QLabel * styleAccel;
+    QLineEdit * styleEdit;
+    QListBox * styleList;
+
+    QLabel * sizeAccel;
+    QLineEdit * sizeEdit;
+    QListBox * sizeList;
+
+    QVGroupBox * effects;
+    QCheckBox * strikeout;
+    QCheckBox * underline;
+    QComboBox * color;
+
+    QHGroupBox * sample;
+    QLineEdit * sampleEdit;
+
+    QLabel * scriptAccel;
+    QComboBox * scriptCombo;
+
+    QPushButton * ok;
+    QPushButton * cancel;
+
+    QBoxLayout * buttonLayout;
+    QBoxLayout * effectsLayout;
+    QBoxLayout * sampleLayout;
+    QBoxLayout * sampleEditLayout;
+
+    QFontDatabase fdb;
+
+    QString       family;
+    QFont::Script script;
+    QString       style;
+    int           size;
+
+    bool smoothScalable;
+};
+
+
+/*!
+  \internal
+  Constructs a standard font dialog.
+
+  Use setFont() to set the initial font attributes.
+
+  The \a parent, \a name, \a modal and \a f parameters are passed to
+  the QDialog constructor.
+
+  \sa getFont()
+*/
+
+QFontDialog::QFontDialog( QWidget *parent, const char *name,
+			  bool modal, WFlags f )
+    : QDialog( parent, name, modal, f )
+{
+    setSizeGripEnabled( TRUE );
+    d = new QFontDialogPrivate;
+    // grid
+    d->familyEdit = new QLineEdit( this, "font family I" );
+    d->familyEdit->setReadOnly( TRUE );
+    d->familyList = new QListBox( this, "font family II" );
+    d->familyEdit->setFocusProxy( d->familyList );
+
+    d->familyAccel
+	= new QLabel( d->familyList, tr("&Font"), this, "family accelerator" );
+    d->familyAccel->setIndent( 2 );
+
+    d->styleEdit = new QLineEdit( this, "font style I" );
+    d->styleEdit->setReadOnly( TRUE );
+    d->styleList = new QListBox( this, "font style II" );
+    d->styleEdit->setFocusProxy( d->styleList );
+
+    d->styleAccel
+	= new QLabel( d->styleList, tr("Font st&yle"), this, "style accelerator" );
+    d->styleAccel->setIndent( 2 );
+
+    d->sizeEdit = new QLineEdit( this, "font size I" );
+    d->sizeEdit->setFocusPolicy( ClickFocus );
+    QIntValidator *validator = new QIntValidator( 1, 512, this );
+    d->sizeEdit->setValidator( validator );
+    d->sizeList = new QListBox( this, "font size II" );
+
+    d->sizeAccel
+	= new QLabel ( d->sizeEdit, tr("&Size"), this, "size accelerator" );
+    d->sizeAccel->setIndent( 2 );
+
+    // effects box
+    d->effects = new QVGroupBox( tr("Effects"), this, "font effects" );
+    d->strikeout = new QCheckBox( d->effects, "strikeout on/off" );
+    d->strikeout->setText( tr("Stri&keout") );
+    d->underline = new QCheckBox( d->effects, "underline on/off" );
+    d->underline->setText( tr("&Underline") );
+
+    d->sample = new QHGroupBox( tr("Sample"), this, "sample text" );
+    d->sampleEdit = new QLineEdit( d->sample, "r/w sample text" );
+    d->sampleEdit->setSizePolicy( QSizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored) );
+    d->sampleEdit->setAlignment( AlignCenter );
+    // Note that the sample text is *not* translated with tr(), as the
+    // characters used depend on the charset encoding.
+    d->sampleEdit->setText( "AaBbYyZz" );
+
+    d->scriptCombo = new QComboBox( FALSE, this, "font encoding" );
+
+    d->scriptAccel
+	= new QLabel( d->scriptCombo, tr("Scr&ipt"), this,"encoding label");
+    d->scriptAccel->setIndent( 2 );
+
+    d->size = 0;
+    d->smoothScalable = FALSE;
+
+    connect( d->scriptCombo, SIGNAL(activated(int)),
+	     SLOT(scriptHighlighted(int)) );
+    connect( d->familyList, SIGNAL(highlighted(int)),
+	     SLOT(familyHighlighted(int)) );
+    connect( d->styleList, SIGNAL(highlighted(int)),
+	     SLOT(styleHighlighted(int)) );
+    connect( d->sizeList, SIGNAL(highlighted(const QString&)),
+	     SLOT(sizeHighlighted(const QString&)) );
+    connect( d->sizeEdit, SIGNAL(textChanged(const QString&)),
+	     SLOT(sizeChanged(const QString&)) );
+
+    connect( d->strikeout, SIGNAL(clicked()),
+	     SLOT(updateSample()) );
+    connect( d->underline, SIGNAL(clicked()),
+	     SLOT(updateSample()) );
+
+    (void)d->familyList->sizeHint();
+    (void)d->styleList->sizeHint();
+    (void)d->sizeList->sizeHint();
+
+    for (int i = 0; i < QFont::NScripts; i++) {
+	QString scriptname = QFontDatabase::scriptName((QFont::Script) i);
+	if ( !scriptname.isEmpty() )
+	    d->scriptCombo->insertItem( scriptname );
+    }
+
+    updateFamilies();
+    if ( d->familyList->count() != 0 )
+	d->familyList->setCurrentItem( 0 );
+
+    // grid layout
+    QGridLayout * mainGrid = new QGridLayout( this, 9, 6, 12, 0 );
+
+    mainGrid->addWidget( d->familyAccel, 0, 0 );
+    mainGrid->addWidget( d->familyEdit, 1, 0 );
+    mainGrid->addWidget( d->familyList, 2, 0 );
+
+    mainGrid->addWidget( d->styleAccel, 0, 2 );
+    mainGrid->addWidget( d->styleEdit, 1, 2 );
+    mainGrid->addWidget( d->styleList, 2, 2 );
+
+    mainGrid->addWidget( d->sizeAccel, 0, 4 );
+    mainGrid->addWidget( d->sizeEdit, 1, 4 );
+    mainGrid->addWidget( d->sizeList, 2, 4 );
+
+    mainGrid->setColStretch( 0, 38 );
+    mainGrid->setColStretch( 2, 24 );
+    mainGrid->setColStretch( 4, 10 );
+
+    mainGrid->addColSpacing( 1, 6 );
+    mainGrid->addColSpacing( 3, 6 );
+    mainGrid->addColSpacing( 5, 6 );
+
+    mainGrid->addRowSpacing( 3, 12 );
+
+    mainGrid->addWidget( d->effects, 4, 0 );
+
+    mainGrid->addMultiCellWidget( d->sample, 4, 7, 2, 4 );
+
+    mainGrid->addWidget( d->scriptAccel, 5, 0 );
+    mainGrid->addRowSpacing( 6, 2 );
+    mainGrid->addWidget( d->scriptCombo, 7, 0 );
+
+    mainGrid->addRowSpacing( 8, 12 );
+
+    QHBoxLayout *buttonBox = new QHBoxLayout;
+    mainGrid->addMultiCell( buttonBox, 9, 9, 0, 4 );
+
+    buttonBox->addStretch( 1 );
+    QString okt = modal ? tr("OK") : tr("Apply");
+    d->ok = new QPushButton( okt, this, "accept font selection" );
+    buttonBox->addWidget( d->ok );
+    if ( modal )
+	connect( d->ok, SIGNAL(clicked()), SLOT(accept()) );
+    d->ok->setDefault( TRUE );
+
+    buttonBox->addSpacing( 12 );
+
+    QString cancelt = modal ? tr("Cancel") : tr("Close");
+    d->cancel = new QPushButton( cancelt, this, "cancel/close" );
+    buttonBox->addWidget( d->cancel );
+    connect( d->cancel, SIGNAL(clicked()), SLOT(reject()) );
+
+    resize( 500, 360 );
+
+    d->sizeEdit->installEventFilter( this );
+    d->familyList->installEventFilter( this );
+    d->styleList->installEventFilter( this );
+    d->sizeList->installEventFilter( this );
+
+    d->familyList->setFocus();
+}
+
+/*!
+  \internal
+ Destroys the font dialog and frees up its storage.
+*/
+
+QFontDialog::~QFontDialog()
+{
+    delete d;
+    d = 0;
+}
+
+/*!
+  Executes a modal font dialog and returns a font.
+
+  If the user clicks OK, the selected font is returned. If the user
+  clicks Cancel, the \a initial font is returned.
+
+  The dialog is called \a name, with the parent \a parent.
+  \a initial is the initially selected font.
+  If the \a ok parameter is not-null, \e *\a ok is set to TRUE if the
+  user clicked OK, and set to FALSE if the user clicked Cancel.
+
+  This static function is less flexible than the full QFontDialog
+  object, but is convenient and easy to use.
+
+  Examples:
+  \code
+    bool ok;
+    QFont font = QFontDialog::getFont( &ok, QFont( "Times", 12 ), this );
+    if ( ok ) {
+	// font is set to the font the user selected
+    } else {
+	// the user canceled the dialog; font is set to the initial
+	// value, in this case Times, 12.
+    }
+  \endcode
+
+    The dialog can also be used to set a widget's font directly:
+  \code
+    myWidget.setFont( QFontDialog::getFont( 0, myWidget.font() ) );
+  \endcode
+  In this example, if the user clicks OK the font they chose will be
+  used, and if they click Cancel the original font is used.
+*/
+QFont QFontDialog::getFont( bool *ok, const QFont &initial,
+			    QWidget *parent, const char* name)
+{
+    return getFont( ok, &initial, parent, name );
+}
+
+/*!
+    \overload
+
+  Executes a modal font dialog and returns a font.
+
+  If the user clicks OK, the selected font is returned. If the user
+  clicks Cancel, the Qt default font is returned.
+
+  The dialog is called \a name, with parent \a parent.
+  If the \a ok parameter is not-null, \e *\a ok is set to TRUE if the
+  user clicked OK, and FALSE if the user clicked Cancel.
+
+  This static function is less functional than the full QFontDialog
+  object, but is convenient and easy to use.
+
+  Example:
+  \code
+    bool ok;
+    QFont font = QFontDialog::getFont( &ok, this );
+    if ( ok ) {
+	// font is set to the font the user selected
+    } else {
+	// the user canceled the dialog; font is set to the default
+	// application font, QApplication::font()
+    }
+  \endcode
+
+*/
+QFont QFontDialog::getFont( bool *ok, QWidget *parent,const char* name)
+{
+    return getFont( ok, 0, parent, name );
+}
+
+QFont QFontDialog::getFont( bool *ok, const QFont *def,
+			    QWidget *parent, const char* name)
+{
+    QFont result;
+    if ( def )
+	result = *def;
+
+    QFontDialog *dlg = new QFontDialog( parent, name, TRUE );
+
+    dlg->setFont( ( def ? *def : QFont() ) );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg->setCaption( tr("Select Font") );
+#endif
+
+    bool res = (dlg->exec() == QDialog::Accepted);
+    if ( res )
+	result = dlg->font();
+    if ( ok )
+	*ok = res;
+    delete dlg;
+    return result;
+}
+
+
+/*!
+    \internal
+    An event filter to make the Up, Down, PageUp and PageDown keys work
+    correctly in the line edits. The source of the event is the object
+    \a o and the event is \a e.
+*/
+
+bool QFontDialog::eventFilter( QObject * o , QEvent * e )
+{
+    if ( e->type() == QEvent::KeyPress) {
+	QKeyEvent * k = (QKeyEvent *)e;
+	if ( o == d->sizeEdit &&
+        (k->key() == Key_Up ||
+	     k->key() == Key_Down ||
+         k->key() == Key_Prior ||
+         k->key() == Key_Next) ) {
+
+	    int ci = d->sizeList->currentItem();
+	    (void)QApplication::sendEvent( d->sizeList, k );
+
+	    if ( ci != d->sizeList->currentItem() &&
+		style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this))
+		d->sizeEdit->selectAll();
+	    return TRUE;
+	} else if ( ( o == d->familyList || o == d->styleList ) &&
+	            ( k->key() == Key_Return || k->key() == Key_Enter) ) {
+	    k->accept();
+        accept();
+	    return TRUE;
+	}
+    } else if ( e->type() == QEvent::FocusIn &&
+		style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) ) {
+	if ( o == d->familyList )
+	    d->familyEdit->selectAll();
+	else if ( o == d->styleList )
+	    d->styleEdit->selectAll();
+	else if ( o == d->sizeList )
+	    d->sizeEdit->selectAll();
+    } else if ( e->type() == QEvent::MouseButtonPress && o == d->sizeList ) {
+	    d->sizeEdit->setFocus();
+    }
+    return QDialog::eventFilter( o, e );
+}
+
+#ifdef Q_WS_MAC
+// #define SHOW_FONTS_IN_FAMILIES
+#endif
+
+#ifdef SHOW_FONTS_IN_FAMILIES
+#include "qpainter.h"
+#include <sizeedit.h>
+
+class QListBoxFontText : public QListBoxText
+{
+    QFont cfont;
+public:
+    QListBoxFontText( const QString & text );
+    ~QListBoxFontText() { }
+
+    int	 height( const QListBox * ) const;
+    int	 width( const QListBox * )  const;
+
+protected:
+    void  paint( QPainter * );
+};
+
+QListBoxFontText::QListBoxFontText( const QString & text )
+    : QListBoxText(text), cfont(text)
+{
+}
+
+int QListBoxFontText::height( const QListBox * ) const
+{
+    QFontMetrics fm(cfont);
+    return QMAX( fm.lineSpacing() + 2, QApplication::globalStrut().height() );
+}
+
+int QListBoxFontText::width( const QListBox * )  const
+{
+    QFontMetrics fm(cfont);
+    return QMAX( fm.width( text() ) + 6, QApplication::globalStrut().width() );
+}
+
+void QListBoxFontText::paint( QPainter *painter )
+{
+    painter->save();
+    painter->setFont(cfont);
+    QListBoxText::paint(painter);
+    painter->restore();
+}
+
+#endif
+
+/*!
+  \internal
+    Updates the contents of the "font family" list box. This
+  function can be reimplemented if you have special requirements.
+*/
+
+void QFontDialog::updateFamilies()
+{
+    d->familyList->blockSignals( TRUE );
+
+    enum match_t { MATCH_NONE=0, MATCH_LAST_RESORT=1, MATCH_APP=2, MATCH_FALLBACK, MATCH_FAMILY=3 };
+
+    QStringList familyNames = d->fdb.families(d->script);
+    {
+	// merge the unicode/unknown family list with the above list.
+	QStringList l = d->fdb.families(QFont::Unicode) +
+			d->fdb.families(QFont::UnknownScript);
+	QStringList::ConstIterator it = l.begin(), end = l.end();
+	for (; it != end; ++it) {
+	    if (! familyNames.contains(*it))
+		familyNames << *it;
+	}
+    }
+
+    familyNames.sort();
+
+    d->familyList->clear();
+#ifdef SHOW_FONTS_IN_FAMILIES
+    QStringList::Iterator it = familyNames.begin();
+    int idx = 0;
+    for( ; it != familyNames.end() ; ++it )
+	d->familyList->insertItem(new QListBoxFontText(*it), idx++);
+#else
+    d->familyList->insertStringList( familyNames );
+#endif
+
+    QString foundryName1, familyName1, foundryName2, familyName2;
+    int bestFamilyMatch = -1;
+    match_t bestFamilyType = MATCH_NONE;
+
+    QFont f;
+
+    // ##### do the right thing for a list of family names in the font.
+    QFontDatabase::parseFontName(d->family, foundryName1, familyName1);
+
+    QStringList::Iterator it = familyNames.begin();
+    int i = 0;
+    for( ; it != familyNames.end(); ++it, ++i ) {
+
+	QFontDatabase::parseFontName(*it, foundryName2, familyName2);
+
+	//try to match..
+	if ( familyName1 == familyName2 ) {
+	    bestFamilyType = MATCH_FAMILY;
+	    if ( foundryName1 == foundryName2 ) {
+		bestFamilyMatch = i;
+		break;
+	    }
+	    if ( bestFamilyMatch < MATCH_FAMILY )
+		bestFamilyMatch = i;
+	}
+
+	//and try some fall backs
+	match_t type = MATCH_NONE;
+	if ( bestFamilyType <= MATCH_NONE && familyName2 == f.lastResortFamily() )
+		type = MATCH_LAST_RESORT;
+	if ( bestFamilyType <= MATCH_LAST_RESORT && familyName2 == f.family() )
+		type = MATCH_APP;
+	// ### add fallback for script
+	if ( type != MATCH_NONE ) {
+	    bestFamilyType = type;
+	    bestFamilyMatch = i;
+	}
+    }
+
+    if (i != -1 && bestFamilyType != MATCH_NONE)
+	d->familyList->setCurrentItem(bestFamilyMatch);
+    else
+	d->familyList->setCurrentItem( 0 );
+    d->familyEdit->setText( d->familyList->currentText() );
+    if ( style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) &&
+	 d->familyList->hasFocus() )
+	d->familyEdit->selectAll();
+
+    d->familyList->blockSignals( FALSE );
+    updateStyles();
+}
+
+/*!
+    \internal
+    Updates the contents of the "font style" list box. This
+  function can be reimplemented if you have special requirements.
+*/
+
+void QFontDialog::updateStyles()
+{
+    d->styleList->blockSignals( TRUE );
+
+    d->styleList->clear();
+
+    QStringList styles = d->fdb.styles( d->familyList->currentText() );
+
+    if ( styles.isEmpty() ) {
+	d->styleEdit->clear();
+	d->smoothScalable = FALSE;
+    } else {
+	d->styleList->insertStringList( styles );
+
+	if ( !d->style.isEmpty() ) {
+	    bool found = FALSE;
+	    bool first = TRUE;
+	    QString cstyle = d->style;
+	redo:
+	    for ( int i = 0 ; i < (int)d->styleList->count() ; i++ ) {
+		if ( cstyle == d->styleList->text(i) ) {
+		    d->styleList->setCurrentItem( i );
+		    found = TRUE;
+		    break;
+		}
+	    }
+	    if (!found && first) {
+		if (cstyle.contains("Italic")) {
+		    cstyle.replace("Italic", "Oblique");
+		    first = FALSE;
+		    goto redo;
+		} else if (cstyle.contains("Oblique")) {
+		    cstyle.replace("Oblique", "Italic");
+		    first = FALSE;
+		    goto redo;
+		}
+	    }
+	    if ( !found )
+		d->styleList->setCurrentItem( 0 );
+	}
+
+	d->styleEdit->setText( d->styleList->currentText() );
+	if ( style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) &&
+	     d->styleList->hasFocus() )
+	    d->styleEdit->selectAll();
+
+	d->smoothScalable = d->fdb.isSmoothlyScalable( d->familyList->currentText(), d->styleList->currentText() );
+    }
+
+    d->styleList->blockSignals( FALSE );
+
+    updateSizes();
+}
+
+/*!
+    \internal
+    Updates the contents of the "font size" list box. This
+  function can be reimplemented if you have special requirements.
+*/
+
+void QFontDialog::updateSizes()
+{
+    d->sizeList->blockSignals( TRUE );
+
+    d->sizeList->clear();
+
+    if ( !d->familyList->currentText().isEmpty() ) {
+	QValueList<int> sizes = d->fdb.pointSizes( d->familyList->currentText(), d->styleList->currentText() );
+
+	int i = 0;
+	bool found = FALSE;
+	for( QValueList<int>::iterator it = sizes.begin() ; it != sizes.end(); ++it ) {
+	    d->sizeList->insertItem( QString::number( *it ) );
+	    if ( !found && *it >= d->size ) {
+		d->sizeList->setCurrentItem( i );
+		found = TRUE;
+	    }
+	    ++i;
+	}
+	if ( !found ) {
+	    // we request a size bigger than the ones in the list, select the biggest one
+	    d->sizeList->setCurrentItem( d->sizeList->count() - 1 );
+	}
+
+	d->sizeEdit->blockSignals( TRUE );
+	d->sizeEdit->setText( ( d->smoothScalable ? QString::number( d->size ) : d->sizeList->currentText() ) );
+	if ( style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) &&
+	     d->sizeList->hasFocus() )
+	    d->sizeEdit->selectAll();
+	d->sizeEdit->blockSignals( FALSE );
+    } else {
+	d->sizeEdit->clear();
+    }
+
+    d->sizeList->blockSignals( FALSE );
+    updateSample();
+}
+
+void QFontDialog::updateSample()
+{
+    if ( d->familyList->currentText().isEmpty() )
+	d->sampleEdit->clear();
+    else
+	d->sampleEdit->setFont( font() );
+}
+
+/*!
+    \internal
+*/
+void QFontDialog::scriptHighlighted( int index )
+{
+    d->script = (QFont::Script)index;
+    d->sampleEdit->setText( d->fdb.scriptSample( d->script ) );
+    updateFamilies();
+}
+
+/*!
+    \internal
+*/
+void QFontDialog::familyHighlighted( int i )
+{
+    d->family = d->familyList->text( i );
+    d->familyEdit->setText( d->family );
+    if ( style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) &&
+	 d->familyList->hasFocus() )
+	d->familyEdit->selectAll();
+
+    updateStyles();
+}
+
+
+/*!
+    \internal
+*/
+
+void QFontDialog::styleHighlighted( int index )
+{
+    QString s = d->styleList->text( index );
+    d->styleEdit->setText( s );
+    if ( style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) &&
+	 d->styleList->hasFocus() )
+	d->styleEdit->selectAll();
+
+    d->style = s;
+
+    updateSizes();
+}
+
+
+/*!
+    \internal
+*/
+
+void QFontDialog::sizeHighlighted( const QString &s )
+{
+    d->sizeEdit->setText( s );
+    if ( style().styleHint(QStyle::SH_FontDialog_SelectAssociatedText, this) &&
+	 d->sizeEdit->hasFocus() )
+	d->sizeEdit->selectAll();
+
+    d->size = s.toInt();
+    updateSample();
+}
+
+/*!
+    \internal
+    This slot is called if the user changes the font size.
+    The size is passed in the \a s argument as a \e string.
+*/
+
+void QFontDialog::sizeChanged( const QString &s )
+{
+    // no need to check if the conversion is valid, since we have an QIntValidator in the size edit
+    int size = s.toInt();
+    if ( d->size == size )
+	return;
+
+    d->size = size;
+    if ( d->sizeList->count() != 0 ) {
+	int i;
+	for ( i = 0 ; i < (int)d->sizeList->count() - 1 ; i++ ) {
+	    if ( d->sizeList->text(i).toInt() >= d->size )
+		break;
+	}
+	d->sizeList->blockSignals( TRUE );
+	d->sizeList->setCurrentItem( i );
+	d->sizeList->blockSignals( FALSE );
+    }
+    updateSample();
+}
+
+/*!
+  \internal
+  Sets the font highlighted in the QFontDialog to font \a f.
+
+  \sa font()
+*/
+
+void QFontDialog::setFont( const QFont &f )
+{
+    d->family = f.family();
+    d->style = d->fdb.styleString( f );
+    d->size = f.pointSize();
+    if ( d->size == -1 ) {
+	    QFontInfo fi( f );
+	    d->size = fi.pointSize();
+    }
+    d->strikeout->setChecked( f.strikeOut() );
+    d->underline->setChecked( f.underline() );
+
+    updateFamilies();
+}
+
+/*!
+  \internal
+  Returns the font which the user has chosen.
+
+  \sa setFont()
+*/
+
+QFont QFontDialog::font() const
+{
+    int pSize = d->sizeEdit->text().toInt();
+
+    QFont f = d->fdb.font( d->familyList->currentText(), d->style, pSize );
+    f.setStrikeOut( d->strikeout->isChecked() );
+    f.setUnderline( d->underline->isChecked() );
+    return f;
+}
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qfontdialog.h b/main/dependencies/qt3/src/dialogs/qfontdialog.h
new file mode 100644
index 000000000..0f02f8c78
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qfontdialog.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Definition of QFontDialog
+**
+** Created : 970605
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QFONTDIALOG_H
+#define QFONTDIALOG_H
+
+#include "qwindowdefs.h"
+
+#ifndef QT_NO_FONTDIALOG
+
+//
+//  W A R N I N G
+//  -------------
+//
+//  This class is under development and has private constructors.
+//
+//  You may use the public static getFont() functions which are guaranteed
+//  to be available in the future.
+//
+
+#ifndef QT_H
+#include "qdialog.h"
+#include "qfont.h"
+#endif // QT_H
+
+class QFontDialogPrivate;
+
+class Q_EXPORT QFontDialog: public QDialog
+{
+    Q_OBJECT
+
+public:
+    static QFont getFont( bool *ok, const QFont &def,
+			  QWidget* parent=0, const char* name=0);
+    static QFont getFont( bool *ok, QWidget* parent=0, const char* name=0);
+
+private:
+    static QFont getFont( bool *ok, const QFont *def,
+			  QWidget* parent=0, const char* name=0);
+
+    QFontDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE,
+		 WFlags f=0 );
+    ~QFontDialog();
+
+    QFont font() const;
+    void setFont( const QFont &font );
+
+    bool eventFilter( QObject *, QEvent * );
+
+    void updateFamilies();
+    void updateStyles();
+    void updateSizes();
+
+private slots:
+    void sizeChanged( const QString &);
+    void familyHighlighted( int );
+    void scriptHighlighted( int );
+    void styleHighlighted( int );
+    void sizeHighlighted( const QString & );
+    void updateSample();
+
+private:
+    friend class QFontDialogPrivate;
+    QFontDialogPrivate * d;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QFontDialog( const QFontDialog & );
+    QFontDialog& operator=( const QFontDialog & );
+#endif
+};
+
+#endif
+
+#endif // QFONTDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qinputdialog.cpp b/main/dependencies/qt3/src/dialogs/qinputdialog.cpp
new file mode 100644
index 000000000..fd73e0a92
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qinputdialog.cpp
@@ -0,0 +1,532 @@
+/****************************************************************************
+**
+** Implementation of QInputDialog class
+**
+** Created : 991212
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qinputdialog.h"
+
+#ifndef QT_NO_INPUTDIALOG
+
+#include "qlayout.h"
+#include "qlabel.h"
+#include "qlineedit.h"
+#include "qpushbutton.h"
+#include "qspinbox.h"
+#include "qcombobox.h"
+#include "qwidgetstack.h"
+#include "qvalidator.h"
+#include "qapplication.h"
+
+class QInputDialogPrivate
+{
+public:
+    friend class QInputDialog;
+    QLabel *label;
+    QLineEdit *lineEdit;
+    QSpinBox *spinBox;
+    QComboBox *comboBox, *editComboBox;
+    QPushButton *ok;
+    QWidgetStack *stack;
+    QInputDialog::Type type;
+};
+
+/*!
+    \class QInputDialog
+    \brief The QInputDialog class provides a simple convenience dialog to get a single value from the user.
+    \ingroup dialogs
+    \mainclass
+
+    The input value can be a string, a number or an item from a list. A
+    label must be set to tell the user what they should enter.
+
+    Four static convenience functions are provided:
+    getText(), getInteger(), getDouble() and getItem(). All the
+    functions can be used in a similar way, for example:
+    \code
+    bool ok;
+    QString text = QInputDialog::getText(
+	    "MyApp 3000", "Enter your name:", QLineEdit::Normal,
+	    QString::null, &ok, this );
+    if ( ok && !text.isEmpty() ) {
+	// user entered something and pressed OK
+    } else {
+	// user entered nothing or pressed Cancel
+    }
+    \endcode
+
+    \img inputdialogs.png Input Dialogs
+*/
+
+/*!
+  \enum QInputDialog::Type
+
+  This enum specifies the type of the dialog, i.e. what kind of data you
+  want the user to input:
+
+  \value LineEdit  A QLineEdit is used for obtaining string or numeric
+  input. The QLineEdit can be accessed using lineEdit().
+
+  \value SpinBox  A QSpinBox is used for obtaining integer input.
+  Use spinBox() to access the QSpinBox.
+
+  \value ComboBox  A read-only QComboBox is used to provide a fixed
+  list of choices from which the user can choose.
+  Use comboBox() to access the QComboBox.
+
+  \value EditableComboBox  An editable QComboBox is used to provide a fixed
+  list of choices from which the user can choose, but which also
+  allows the user to enter their own value instead.
+  Use editableComboBox() to access the QComboBox.
+*/
+
+/*!
+  Constructs the dialog. The \a label is the text which is shown to the user
+  (it should tell the user what they are expected to enter). The \a parent
+  is the dialog's parent widget. The widget is called \a name. If \a
+  modal is TRUE (the default) the dialog will be modal. The \a type
+  parameter is used to specify which type of dialog to construct.
+
+  \sa getText(), getInteger(), getDouble(), getItem()
+*/
+
+QInputDialog::QInputDialog( const QString &label, QWidget* parent,
+			    const char* name, bool modal, Type type )
+    : QDialog( parent, name, modal )
+{
+    d = new QInputDialogPrivate;
+    d->lineEdit = 0;
+    d->spinBox = 0;
+    d->comboBox = 0;
+
+    QVBoxLayout *vbox = new QVBoxLayout( this, 6, 6 );
+
+    d->label = new QLabel( label, this, "qt_inputdlg_lbl" );
+    vbox->addWidget( d->label );
+
+    d->stack = new QWidgetStack( this, "qt_inputdlg_ws" );
+    vbox->addWidget( d->stack );
+    d->lineEdit = new QLineEdit( d->stack, "qt_inputdlg_le" );
+    d->spinBox = new QSpinBox( d->stack, "qt_inputdlg_sb" );
+    d->comboBox = new QComboBox( FALSE, d->stack, "qt_inputdlg_cb" );
+    d->editComboBox = new QComboBox( TRUE, d->stack, "qt_inputdlg_editcb" );
+
+    QHBoxLayout *hbox = new QHBoxLayout( 6 );
+    vbox->addLayout( hbox, AlignRight );
+
+    d->ok = new QPushButton( tr( "OK" ), this, "qt_ok_btn" );
+    d->ok->setDefault( TRUE );
+    QPushButton *cancel = new QPushButton( tr( "Cancel" ), this, "qt_cancel_btn" );
+
+    QSize bs = d->ok->sizeHint().expandedTo( cancel->sizeHint() );
+    d->ok->setFixedSize( bs );
+    cancel->setFixedSize( bs );
+
+    hbox->addStretch();
+    hbox->addWidget( d->ok );
+    hbox->addWidget( cancel );
+
+    connect( d->lineEdit, SIGNAL( returnPressed() ),
+	     this, SLOT( tryAccept() ) );
+    connect( d->lineEdit, SIGNAL( textChanged(const QString&) ),
+	     this, SLOT( textChanged(const QString&) ) );
+
+    connect( d->ok, SIGNAL( clicked() ), this, SLOT( accept() ) );
+    connect( cancel, SIGNAL( clicked() ), this, SLOT( reject() ) );
+
+    QSize sh = sizeHint().expandedTo( QSize(400, 10) );
+    setType( type );
+    resize( sh.width(), vbox->heightForWidth(sh.width()) );
+}
+
+/*!
+  Returns the line edit which is used in LineEdit mode.
+*/
+
+QLineEdit *QInputDialog::lineEdit() const
+{
+    return d->lineEdit;
+}
+
+/*!
+  Returns the spinbox which is used in SpinBox mode.
+*/
+
+QSpinBox *QInputDialog::spinBox() const
+{
+    return d->spinBox;
+}
+
+/*!
+  Returns the combobox which is used in ComboBox mode.
+*/
+
+QComboBox *QInputDialog::comboBox() const
+{
+    return d->comboBox;
+}
+
+/*!
+  Returns the combobox which is used in EditableComboBox mode.
+*/
+
+QComboBox *QInputDialog::editableComboBox() const
+{
+    return d->editComboBox;
+}
+
+/*!
+  Sets the input type of the dialog to \a t.
+*/
+
+void QInputDialog::setType( Type t )
+{
+    QWidget *input = 0;
+    switch ( t ) {
+    case LineEdit:
+	input = d->lineEdit;
+	break;
+    case SpinBox:
+	input = d->spinBox;
+	break;
+    case ComboBox:
+	input = d->comboBox;
+	break;
+    case EditableComboBox:
+	input = d->editComboBox;
+	break;
+    default:
+#if defined(QT_CHECK_STATE)
+	qWarning( "QInputDialog::setType: Invalid type" );
+#endif
+	break;
+    }
+    if ( input ) {
+	d->stack->raiseWidget( input );
+	d->stack->setFixedHeight( input->sizeHint().height() );
+	input->setFocus();
+#ifndef QT_NO_ACCEL
+	d->label->setBuddy( input );
+#endif
+    }
+
+    d->type = t;
+}
+
+/*!
+  Returns the input type of the dialog.
+
+  \sa setType()
+*/
+
+QInputDialog::Type QInputDialog::type() const
+{
+    return d->type;
+}
+
+/*!
+  Destructor.
+*/
+
+QInputDialog::~QInputDialog()
+{
+    delete d;
+}
+
+/*!
+    Static convenience function to get a string from the user. \a
+    caption is the text which is displayed in the title bar of the
+    dialog. \a label is the text which is shown to the user (it should
+    say what should be entered). \a text is the default text which is
+    placed in the line edit. The \a mode is the echo mode the line edit
+    will use. If \a ok is not-null \e *\a ok will be set to TRUE if the
+    user pressed OK and to FALSE if the user pressed Cancel. The
+    dialog's parent is \a parent; the dialog is called \a name. The
+    dialog will be modal.
+
+    This function returns the text which has been entered in the line
+    edit. It will not return an empty string.
+
+    Use this static function like this:
+
+    \code
+    bool ok;
+    QString text = QInputDialog::getText(
+	    "MyApp 3000", "Enter your name:", QLineEdit::Normal,
+	    QString::null, &ok, this );
+    if ( ok && !text.isEmpty() ) {
+	// user entered something and pressed OK
+    } else {
+	// user entered nothing or pressed Cancel
+    }
+    \endcode
+*/
+
+QString QInputDialog::getText( const QString &caption, const QString &label,
+			       QLineEdit::EchoMode mode, const QString &text,
+			       bool *ok, QWidget *parent, const char *name )
+{
+    QInputDialog *dlg = new QInputDialog( label, parent,
+					  name ? name : "qt_inputdlg_gettext",
+					  TRUE, LineEdit );
+
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg->setCaption( caption );
+#endif
+    dlg->lineEdit()->setText( text );
+    dlg->lineEdit()->setEchoMode( mode );
+
+    bool ok_ = FALSE;
+    QString result;
+    ok_ = dlg->exec() == QDialog::Accepted;
+    if ( ok )
+	*ok = ok_;
+    if ( ok_ )
+	result = dlg->lineEdit()->text();
+
+    delete dlg;
+    return result;
+}
+
+/*!
+    Static convenience function to get an integer input from the
+    user. \a caption is the text which is displayed in the title bar
+    of the dialog.  \a label is the text which is shown to the user
+    (it should say what should be entered). \a value is the default
+    integer which the spinbox will be set to.  \a minValue and \a
+    maxValue are the minimum and maximum values the user may choose,
+    and \a step is the amount by which the values change as the user
+    presses the arrow buttons to increment or decrement the value.
+
+    If \a ok is not-null *\a ok will be set to TRUE if the user
+    pressed OK and to FALSE if the user pressed Cancel. The dialog's
+    parent is \a parent; the dialog is called \a name. The dialog will
+    be modal.
+
+    This function returns the integer which has been entered by the user.
+
+    Use this static function like this:
+
+    \code
+    bool ok;
+    int res = QInputDialog::getInteger(
+	    "MyApp 3000", "Enter a number:", 22, 0, 1000, 2,
+	    &ok, this );
+    if ( ok ) {
+	// user entered something and pressed OK
+    } else {
+	// user pressed Cancel
+    }
+    \endcode
+*/
+
+int QInputDialog::getInteger( const QString &caption, const QString &label,
+			      int value, int minValue, int maxValue, int step, bool *ok,
+			      QWidget *parent, const char *name )
+{
+    QInputDialog *dlg = new QInputDialog( label, parent,
+					  name ? name : "qt_inputdlg_getint",
+					  TRUE, SpinBox );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg->setCaption( caption );
+#endif
+    dlg->spinBox()->setRange( minValue, maxValue );
+    dlg->spinBox()->setSteps( step, 0 );
+    dlg->spinBox()->setValue( value );
+
+    bool ok_ = FALSE;
+    int result;
+    ok_ = dlg->exec() == QDialog::Accepted;
+    if ( ok )
+	*ok = ok_;
+    result = dlg->spinBox()->value();
+
+    delete dlg;
+    return result;
+}
+
+/*!
+    Static convenience function to get a floating point number from
+    the user. \a caption is the text which is displayed in the title
+    bar of the dialog. \a label is the text which is shown to the user
+    (it should say what should be entered). \a value is the default
+    floating point number that the line edit will be set to. \a
+    minValue and \a maxValue are the minimum and maximum values the
+    user may choose, and \a decimals is the maximum number of decimal
+    places the number may have.
+
+    If \a ok is not-null \e *\a ok will be set to TRUE if the user
+    pressed OK and to FALSE if the user pressed Cancel. The dialog's
+    parent is \a parent; the dialog is called \a name. The dialog will
+    be modal.
+
+    This function returns the floating point number which has been
+    entered by the user.
+
+    Use this static function like this:
+
+    \code
+    bool ok;
+    double res = QInputDialog::getDouble(
+	    "MyApp 3000", "Enter a decimal number:", 33.7, 0,
+	    1000, 2, &ok, this );
+    if ( ok ) {
+	// user entered something and pressed OK
+    } else {
+	// user pressed Cancel
+    }
+    \endcode
+*/
+
+double QInputDialog::getDouble( const QString &caption, const QString &label,
+				double value, double minValue, double maxValue,
+				int decimals, bool *ok, QWidget *parent,
+				const char *name )
+{
+    QInputDialog dlg( label, parent,
+		      name ? name : "qt_inputdlg_getdbl", TRUE, LineEdit );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg.setCaption( caption );
+#endif
+    dlg.lineEdit()->setValidator( new QDoubleValidator( minValue, maxValue, decimals, dlg.lineEdit() ) );
+    dlg.lineEdit()->setText( QString::number( value, 'f', decimals ) );
+    dlg.lineEdit()->selectAll();
+
+    bool accepted = ( dlg.exec() == QDialog::Accepted );
+    if ( ok )
+	*ok = accepted;
+    return dlg.lineEdit()->text().toDouble();
+}
+
+/*!
+    Static convenience function to let the user select an item from a
+    string list. \a caption is the text which is displayed in the title
+    bar of the dialog. \a label is the text which is shown to the user (it
+    should say what should be entered). \a list is the
+    string list which is inserted into the combobox, and \a current is the number
+    of the item which should be the current item. If \a editable is TRUE
+    the user can enter their own text; if \a editable is FALSE the user
+    may only select one of the existing items.
+
+    If \a ok is not-null \e *\a ok will be set to TRUE if the user
+    pressed OK and to FALSE if the user pressed Cancel. The dialog's
+    parent is \a parent; the dialog is called \a name. The dialog will
+    be modal.
+
+    This function returns the text of the current item, or if \a
+    editable is TRUE, the current text of the combobox.
+
+    Use this static function like this:
+
+    \code
+    QStringList lst;
+    lst << "First" << "Second" << "Third" << "Fourth" << "Fifth";
+    bool ok;
+    QString res = QInputDialog::getItem(
+	    "MyApp 3000", "Select an item:", lst, 1, TRUE, &ok,
+	    this );
+    if ( ok ) {
+	// user selected an item and pressed OK
+    } else {
+	// user pressed Cancel
+    }
+    \endcode
+*/
+
+QString QInputDialog::getItem( const QString &caption, const QString &label, const QStringList &list,
+			       int current, bool editable,
+			       bool *ok, QWidget *parent, const char *name )
+{
+    QInputDialog *dlg = new QInputDialog( label, parent, name ? name : "qt_inputdlg_getitem", TRUE, editable ? EditableComboBox : ComboBox );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    dlg->setCaption( caption );
+#endif
+    if ( editable ) {
+	dlg->editableComboBox()->insertStringList( list );
+	dlg->editableComboBox()->setCurrentItem( current );
+    } else {
+	dlg->comboBox()->insertStringList( list );
+	dlg->comboBox()->setCurrentItem( current );
+    }
+
+    bool ok_ = FALSE;
+    QString result;
+    ok_ = dlg->exec() == QDialog::Accepted;
+    if ( ok )
+	*ok = ok_;
+    if ( editable )
+	result = dlg->editableComboBox()->currentText();
+    else
+	result = dlg->comboBox()->currentText();
+
+    delete dlg;
+    return result;
+}
+
+/*!
+  \internal
+
+  This slot is invoked when the text is changed; the new text is passed
+  in \a s.
+*/
+
+void QInputDialog::textChanged( const QString &s )
+{
+    bool on = TRUE;
+
+    if ( d->lineEdit->validator() ) {
+	QString str = d->lineEdit->text();
+	int index = d->lineEdit->cursorPosition();
+	on = ( d->lineEdit->validator()->validate(str, index) ==
+	       QValidator::Acceptable );
+    } else if ( type() != LineEdit ) {
+	on = !s.isEmpty();
+    }
+    d->ok->setEnabled( on );
+}
+
+/*!
+  \internal
+*/
+
+void QInputDialog::tryAccept()
+{
+    if ( !d->lineEdit->text().isEmpty() )
+	accept();
+}
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qinputdialog.h b/main/dependencies/qt3/src/dialogs/qinputdialog.h
new file mode 100644
index 000000000..8014a867e
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qinputdialog.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Definition of QInputDialog class
+**
+** Created : 991212
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QINPUTDIALOG_H
+#define QINPUTDIALOG_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#include "qstring.h"
+#include "qlineedit.h"
+#endif // QT_H
+
+#ifndef QT_NO_INPUTDIALOG
+
+class QSpinBox;
+class QComboBox;
+class QInputDialogPrivate;
+
+class Q_EXPORT QInputDialog : public QDialog
+{
+    Q_OBJECT
+
+private:
+    enum Type { LineEdit, SpinBox, ComboBox, EditableComboBox };
+
+    QInputDialog( const QString &label, QWidget* parent=0, const char* name=0,
+		 bool modal = TRUE, Type type = LineEdit ); //### 4.0: widget flag!
+    ~QInputDialog();
+
+    QLineEdit *lineEdit() const;
+    QSpinBox *spinBox() const;
+    QComboBox *comboBox() const;
+    QComboBox *editableComboBox() const;
+
+    void setType( Type t );
+    Type type() const;
+
+public:
+    //### 4.0: widget flag!
+    static QString getText( const QString &caption, const QString &label, QLineEdit::EchoMode echo = QLineEdit::Normal,
+			    const QString &text = QString::null, bool *ok = 0, QWidget *parent = 0, const char *name = 0 );
+    static int getInteger( const QString &caption, const QString &label, int value = 0, int minValue = -2147483647,
+			   int maxValue = 2147483647,
+			   int step = 1, bool *ok = 0, QWidget *parent = 0, const char *name = 0 );
+    static double getDouble( const QString &caption, const QString &label, double value = 0,
+			     double minValue = -2147483647, double maxValue = 2147483647,
+			     int decimals = 1, bool *ok = 0, QWidget *parent = 0, const char *name = 0 );
+    static QString getItem( const QString &caption, const QString &label, const QStringList &list,
+			    int current = 0, bool editable = TRUE,
+			    bool *ok = 0, QWidget *parent = 0, const char *name = 0 );
+
+private slots:
+    void textChanged( const QString &s );
+    void tryAccept();
+
+private:
+    QInputDialogPrivate *d;
+    friend class QInputDialogPrivate; /* to avoid 'has no friends' warnings... */
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QInputDialog( const QInputDialog & );
+    QInputDialog &operator=( const QInputDialog & );
+#endif
+};
+
+#endif // QT_NO_INPUTDIALOG
+
+#endif // QINPUTDIALOG_H
+
diff --git a/main/dependencies/qt3/src/dialogs/qmessagebox.cpp b/main/dependencies/qt3/src/dialogs/qmessagebox.cpp
new file mode 100644
index 000000000..848c008a9
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qmessagebox.cpp
@@ -0,0 +1,1632 @@
+/****************************************************************************
+**
+** Implementation of QMessageBox class
+**
+** Created : 950503
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qmessagebox.h"
+
+#ifndef QT_NO_MESSAGEBOX
+
+#include "qaccel.h"
+#include "qlabel.h"
+#include "qpushbutton.h"
+#include "qimage.h"
+#include "qapplication.h"
+#include "qstyle.h"
+#include "qobjectlist.h"
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+#include "qaccessible.h"
+#endif
+#if defined QT_NON_COMMERCIAL
+#include "qnc_win.h"
+#endif
+
+
+// Internal class - don't touch
+
+class QMessageBoxLabel : public QLabel
+{
+    Q_OBJECT
+public:
+    QMessageBoxLabel( QWidget* parent ) : QLabel( parent, "messageBoxText")
+    {
+	setAlignment( AlignAuto|ExpandTabs );
+    }
+};
+#include "qmessagebox.moc"
+
+
+
+// the Qt logo, for aboutQt
+/* XPM */
+static const char * const qtlogo_xpm[] = {
+/* width height ncolors chars_per_pixel */
+"50 50 17 1",
+/* colors */
+"  c #000000",
+". c #495808",
+"X c #2A3304",
+"o c #242B04",
+"O c #030401",
+"+ c #9EC011",
+"@ c #93B310",
+"# c #748E0C",
+"$ c #A2C511",
+"% c #8BA90E",
+"& c #99BA10",
+"* c #060701",
+"= c #181D02",
+"- c #212804",
+"; c #61770A",
+": c #0B0D01",
+"/ c None",
+/* pixels */
+"/$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$/",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$+++$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$@;.o=::=o.;@$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$+#X*         **X#+$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$#oO*         O  **o#+$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$&.* OO              O*.&$$$$$$$$$$$$$",
+"$$$$$$$$$$$$@XOO            * OO    X&$$$$$$$$$$$$",
+"$$$$$$$$$$$@XO OO  O  **:::OOO OOO   X@$$$$$$$$$$$",
+"$$$$$$$$$$&XO      O-;#@++@%.oOO      X&$$$$$$$$$$",
+"$$$$$$$$$$.O  :  *-#+$$$$$$$$+#- : O O*.$$$$$$$$$$",
+"$$$$$$$$$#*OO  O*.&$$$$$$$$$$$$+.OOOO **#$$$$$$$$$",
+"$$$$$$$$+-OO O *;$$$$$$$$$$$&$$$$;*     o+$$$$$$$$",
+"$$$$$$$$#O*  O .+$$$$$$$$$$@X;$$$+.O    *#$$$$$$$$",
+"$$$$$$$$X*    -&$$$$$$$$$$@- :;$$$&-    OX$$$$$$$$",
+"$$$$$$$@*O  *O#$$$$$$$$$$@oOO**;$$$#    O*%$$$$$$$",
+"$$$$$$$;     -+$$$$$$$$$@o O OO ;+$$-O   *;$$$$$$$",
+"$$$$$$$.     ;$$$$$$$$$@-OO OO  X&$$;O    .$$$$$$$",
+"$$$$$$$o    *#$$$$$$$$@o  O O O-@$$$#O   *o$$$$$$$",
+"$$$$$$+=    *@$$$$$$$@o* OO   -@$$$$&:    =$$$$$$$",
+"$$$$$$+:    :+$$$$$$@-      *-@$$$$$$:    :+$$$$$$",
+"$$$$$$+:    :+$$$$$@o* O    *-@$$$$$$:    :+$$$$$$",
+"$$$$$$$=    :@$$$$@o*OOO      -@$$$$@:    =+$$$$$$",
+"$$$$$$$-    O%$$$@o* O O    O O-@$$$#*   OX$$$$$$$",
+"$$$$$$$. O *O;$$&o O*O* *O      -@$$;    O.$$$$$$$",
+"$$$$$$$;*   Oo+$$;O*O:OO--      Oo@+=    *;$$$$$$$",
+"$$$$$$$@*  O O#$$$;*OOOo@@-O     Oo;O*  **@$$$$$$$",
+"$$$$$$$$X* OOO-+$$$;O o@$$@-    O O     OX$$$$$$$$",
+"$$$$$$$$#*  * O.$$$$;X@$$$$@-O O        O#$$$$$$$$",
+"$$$$$$$$+oO O OO.+$$+&$$$$$$@-O         o+$$$$$$$$",
+"$$$$$$$$$#*    **.&$$$$$$$$$$@o      OO:#$$$$$$$$$",
+"$$$$$$$$$+.   O* O-#+$$$$$$$$+;O    OOO:@$$$$$$$$$",
+"$$$$$$$$$$&X  *O    -;#@++@#;=O    O    -@$$$$$$$$",
+"$$$$$$$$$$$&X O     O*O::::O      OO    Oo@$$$$$$$",
+"$$$$$$$$$$$$@XOO                  OO    O*X+$$$$$$",
+"$$$$$$$$$$$$$&.*       **  O      ::    *:#$$$$$$$",
+"$$$$$$$$$$$$$$$#o*OO       O    Oo#@-OOO=#$$$$$$$$",
+"$$$$$$$$$$$$$$$$+#X:* *     O**X#+$$@-*:#$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$%;.o=::=o.#@$$$$$$@X#$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$+++$$$$$$$$$$$+$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
+"/$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$/",
+};
+
+
+/*!
+    \class QMessageBox
+    \brief The QMessageBox class provides a modal dialog with a short message, an icon, and some buttons.
+    \ingroup dialogs
+    \mainclass
+
+    Message boxes are used to provide informative messages and to ask
+    simple questions.
+
+    QMessageBox provides a range of different messages, arranged
+    roughly along two axes: severity and complexity.
+
+    Severity is
+    \table
+    \row
+    \i \img qmessagebox-quest.png
+    \i Question
+    \i For message boxes that ask a question as part of normal
+    operation. Some style guides recommend using Information for this
+    purpose.
+    \row
+    \i \img qmessagebox-info.png
+    \i Information
+    \i For message boxes that are part of normal operation.
+    \row
+    \i \img qmessagebox-warn.png
+    \i Warning
+    \i For message boxes that tell the user about unusual errors.
+    \row
+    \i \img qmessagebox-crit.png
+    \i Critical
+    \i For message boxes that tell the user about critical errors.
+    \endtable
+
+    The message box has a different icon for each of the severity levels.
+
+    Complexity is one button (OK) for simple messages, or two or even
+    three buttons for questions.
+
+    There are static functions for the most common cases.
+
+    Examples:
+
+    If a program is unable to find a supporting file, but can do perfectly
+    well without it:
+
+    \code
+    QMessageBox::information( this, "Application name",
+    "Unable to find the user preferences file.\n"
+    "The factory default will be used instead." );
+    \endcode
+
+    question() is useful for simple yes/no questions:
+
+    \code
+    if ( QFile::exists( filename ) &&
+	QMessageBox::question(
+	    this,
+	    tr("Overwrite File? -- Application Name"),
+	    tr("A file called %1 already exists."
+		"Do you want to overwrite it?")
+		.arg( filename ),
+	    tr("&Yes"), tr("&No"),
+	    QString::null, 0, 1 ) )
+	return false;
+    \endcode
+
+    warning() can be used to tell the user about unusual errors, or
+    errors which can't be easily fixed:
+
+    \code
+    switch( QMessageBox::warning( this, "Application name",
+        "Could not connect to the <mumble> server.\n"
+        "This program can't function correctly "
+        "without the server.\n\n",
+        "Retry",
+        "Quit", 0, 0, 1 ) ) {
+    case 0: // The user clicked the Retry again button or pressed Enter
+	// try again
+	break;
+    case 1: // The user clicked the Quit or pressed Escape
+	// exit
+	break;
+    }
+    \endcode
+
+    The text part of all message box messages can be either rich text
+    or plain text. If you specify a rich text formatted string, it
+    will be rendered using the default stylesheet. See
+    QStyleSheet::defaultSheet() for details. With certain strings that
+    contain XML meta characters, the auto-rich text detection may
+    fail, interpreting plain text incorrectly as rich text. In these
+    rare cases, use QStyleSheet::convertFromPlainText() to convert
+    your plain text string to a visually equivalent rich text string
+    or set the text format explicitly with setTextFormat().
+
+    Note that the Microsoft Windows User Interface Guidelines
+    recommend using the application name as the window's caption.
+
+    Below are more examples of how to use the static member functions.
+    After these examples you will find an overview of the non-static
+    member functions.
+
+    Exiting a program is part of its normal operation. If there is
+    unsaved data the user probably should be asked if they want to
+    save the data. For example:
+
+    \code
+    switch( QMessageBox::information( this, "Application name here",
+	"The document contains unsaved changes\n"
+	"Do you want to save the changes before exiting?",
+	"&Save", "&Discard", "Cancel",
+	0,      // Enter == button 0
+	2 ) ) { // Escape == button 2
+    case 0: // Save clicked or Alt+S pressed or Enter pressed.
+	// save
+	break;
+    case 1: // Discard clicked or Alt+D pressed
+	// don't save but exit
+	break;
+    case 2: // Cancel clicked or Escape pressed
+	// don't exit
+	break;
+    }
+    \endcode
+
+    The Escape button cancels the entire exit operation, and pressing
+    Enter causes the changes to be saved before the exit occurs.
+
+    Disk full errors are unusual and they certainly can be hard to
+    correct. This example uses predefined buttons instead of
+    hard-coded button texts:
+
+    \code
+    switch( QMessageBox::warning( this, "Application name here",
+	"Could not save the user preferences,\n"
+	"because the disk is full. You can delete\n"
+	"some files and press Retry, or you can\n"
+	"abort the Save Preferences operation.",
+	QMessageBox::Retry | QMessageBox::Default,
+	QMessageBox::Abort | QMessageBox::Escape )) {
+    case QMessageBox::Retry: // Retry clicked or Enter pressed
+	// try again
+	break;
+    case QMessageBox::Abort: // Abort clicked or Escape pressed
+	// abort
+	break;
+    }
+    \endcode
+
+    The critical() function should be reserved for critical errors. In
+    this example errorDetails is a QString or const char*, and QString
+    is used to concatenate several strings:
+
+    \code
+    QMessageBox::critical( 0, "Application name here",
+	QString("An internal error occurred. Please ") +
+	"call technical support at 1234-56789 and report\n"+
+	"these numbers:\n\n" + errorDetails +
+	"\n\nApplication will now exit." );
+    \endcode
+
+    In this example an OK button is displayed.
+
+    QMessageBox provides a very simple About box which displays an
+    appropriate icon and the string you provide:
+
+    \code
+    QMessageBox::about( this, "About <Application>",
+	"<Application> is a <one-paragraph blurb>\n\n"
+	"Copyright 1991-2003 Such-and-such. "
+	"<License words here.>\n\n"
+	"For technical support, call 1234-56789 or see\n"
+	"http://www.such-and-such.com/Application/\n" );
+    \endcode
+
+    See about() for more information.
+
+    If you want your users to know that the application is built using
+    Qt (so they know that you use high quality tools) you might like
+    to add an "About Qt" menu option under the Help menu to invoke
+    aboutQt().
+
+    If none of the standard message boxes is suitable, you can create a
+    QMessageBox from scratch and use custom button texts:
+
+    \code
+    QMessageBox mb( "Application name here",
+	"Saving the file will overwrite the original file on the disk.\n"
+	"Do you really want to save?",
+	QMessageBox::Information,
+	QMessageBox::Yes | QMessageBox::Default,
+	QMessageBox::No,
+	QMessageBox::Cancel | QMessageBox::Escape );
+    mb.setButtonText( QMessageBox::Yes, "Save" );
+    mb.setButtonText( QMessageBox::No, "Discard" );
+    switch( mb.exec() ) {
+    case QMessageBox::Yes:
+	// save and exit
+	break;
+    case QMessageBox::No:
+	// exit without saving
+	break;
+    case QMessageBox::Cancel:
+	// don't save and don't exit
+	break;
+    }
+    \endcode
+
+    QMessageBox defines two enum types: Icon and an unnamed button type.
+    Icon defines the \c Question, \c Information, \c Warning, and \c
+    Critical icons for each GUI style. It is used by the constructor
+    and by the static member functions question(), information(),
+    warning() and critical(). A function called standardIcon() gives
+    you access to the various icons.
+
+    The button types are:
+    \list
+    \i Ok - the default for single-button message boxes
+    \i Cancel - note that this is \e not automatically Escape
+    \i Yes
+    \i No
+    \i Abort
+    \i Retry
+    \i Ignore
+    \i YesAll
+    \i NoAll
+    \endlist
+
+    Button types can be combined with two modifiers by using OR, '|':
+    \list
+    \i Default - makes pressing Enter equivalent to
+    clicking this button. Normally used with Ok, Yes or similar.
+    \i Escape - makes pressing Escape equivalent to clicking this button.
+    Normally used with Abort, Cancel or similar.
+    \endlist
+
+    The text(), icon() and iconPixmap() functions provide access to the
+    current text and pixmap of the message box. The setText(), setIcon()
+    and setIconPixmap() let you change it. The difference between
+    setIcon() and setIconPixmap() is that the former accepts a
+    QMessageBox::Icon and can be used to set standard icons, whereas the
+    latter accepts a QPixmap and can be used to set custom icons.
+
+    setButtonText() and buttonText() provide access to the buttons.
+
+    QMessageBox has no signals or slots.
+
+    <img src=qmsgbox-m.png> <img src=qmsgbox-w.png>
+
+    \sa QDialog,
+	\link http://www.iarchitect.com/errormsg.htm
+	    Isys on error messages \endlink,
+	\link guibooks.html#fowler GUI Design Handbook: Message Box \endlink
+*/
+
+
+/*!
+    \enum QMessageBox::Icon
+
+    This enum has the following values:
+
+    \value NoIcon the message box does not have any icon.
+
+    \value Question an icon indicating that
+    the message is asking a question.
+
+    \value Information an icon indicating that
+    the message is nothing out of the ordinary.
+
+    \value Warning an icon indicating that the
+    message is a warning, but can be dealt with.
+
+    \value Critical an icon indicating that
+    the message represents a critical problem.
+
+*/
+
+
+struct QMessageBoxData {
+    QMessageBoxData(QMessageBox* parent) :
+        iconLabel( parent, "icon" )
+    {
+    }
+
+    int                 numButtons;             // number of buttons
+    QMessageBox::Icon   icon;                   // message box icon
+    QLabel              iconLabel;              // label holding any icon
+    int                 button[3];              // button types
+    int                 defButton;              // default button (index)
+    int                 escButton;              // escape button (index)
+    QSize               buttonSize;             // button size
+    QPushButton        *pb[3];                  // buttons
+};
+
+static const int LastButton = QMessageBox::NoAll;
+
+/*
+  NOTE: The table of button texts correspond to the button enum.
+*/
+
+#ifndef Q_OS_TEMP
+static const char * const mb_texts[] = {
+#else
+const char * mb_texts[] = {
+#endif
+    0,
+    QT_TRANSLATE_NOOP("QMessageBox","OK"),
+    QT_TRANSLATE_NOOP("QMessageBox","Cancel"),
+    QT_TRANSLATE_NOOP("QMessageBox","&Yes"),
+    QT_TRANSLATE_NOOP("QMessageBox","&No"),
+    QT_TRANSLATE_NOOP("QMessageBox","&Abort"),
+    QT_TRANSLATE_NOOP("QMessageBox","&Retry"),
+    QT_TRANSLATE_NOOP("QMessageBox","&Ignore"),
+    QT_TRANSLATE_NOOP("QMessageBox","Yes to &All"),
+    QT_TRANSLATE_NOOP("QMessageBox","N&o to All"),
+    0
+};
+
+/*!
+    Constructs a message box with no text and a button with the label
+    "OK".
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    The \a parent and \a name arguments are passed to the QDialog
+    constructor.
+*/
+
+QMessageBox::QMessageBox( QWidget *parent, const char *name )
+    : QDialog( parent, name, TRUE, WStyle_Customize | WStyle_DialogBorder | WStyle_Title | WStyle_SysMenu )
+{
+    init( Ok, 0, 0 );
+}
+
+
+/*!
+    Constructs a message box with a \a caption, a \a text, an \a icon,
+    and up to three buttons.
+
+    The \a icon must be one of the following:
+    \list
+    \i QMessageBox::NoIcon
+    \i QMessageBox::Question
+    \i QMessageBox::Information
+    \i QMessageBox::Warning
+    \i QMessageBox::Critical
+    \endlist
+
+    Each button, \a button0, \a button1 and \a button2, can have one
+    of the following values:
+    \list
+    \i QMessageBox::NoButton
+    \i QMessageBox::Ok
+    \i QMessageBox::Cancel
+    \i QMessageBox::Yes
+    \i QMessageBox::No
+    \i QMessageBox::Abort
+    \i QMessageBox::Retry
+    \i QMessageBox::Ignore
+    \i QMessageBox::YesAll
+    \i QMessageBox::NoAll
+    \endlist
+
+    Use QMessageBox::NoButton for the later parameters to have fewer
+    than three buttons in your message box. If you don't specify any
+    buttons at all, QMessageBox will provide an Ok button.
+
+    One of the buttons can be OR-ed with the \c QMessageBox::Default
+    flag to make it the default button (clicked when Enter is
+    pressed).
+
+    One of the buttons can be OR-ed with the \c QMessageBox::Escape
+    flag to make it the cancel or close button (clicked when Escape is
+    pressed).
+
+    Example:
+    \code
+    QMessageBox mb( "Application Name",
+        "Hardware failure.\n\nDisk error detected\nDo you want to stop?",
+        QMessageBox::Question,
+        QMessageBox::Yes | QMessageBox::Default,
+        QMessageBox::No  | QMessageBox::Escape,
+        QMessageBox::NoButton );
+    if ( mb.exec() == QMessageBox::No )
+        // try again
+    \endcode
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    If \a modal is TRUE the message box is modal; otherwise it
+    is modeless.
+
+    The \a parent, \a name, \a modal, and \a f arguments are passed to
+    the QDialog constructor.
+
+    \sa setCaption(), setText(), setIcon()
+*/
+
+QMessageBox::QMessageBox( const QString& caption,
+			  const QString &text, Icon icon,
+			  int button0, int button1, int button2,
+			  QWidget *parent, const char *name,
+			  bool modal, WFlags f )
+    : QDialog( parent, name, modal, f | WStyle_Customize | WStyle_DialogBorder | WStyle_Title | WStyle_SysMenu )
+{
+    init( button0, button1, button2 );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    setCaption( caption );
+#endif
+    setText( text );
+    setIcon( icon );
+}
+
+
+/*!
+    Destroys the message box.
+*/
+
+QMessageBox::~QMessageBox()
+{
+    delete mbd;
+}
+
+static QString * translatedTextAboutQt = 0;
+
+void QMessageBox::init( int button0, int button1, int button2 )
+{
+    if ( !translatedTextAboutQt ) {
+	translatedTextAboutQt = new QString;
+
+#if defined(QT_NON_COMMERCIAL)
+    QT_NC_MSGBOX
+#else
+        *translatedTextAboutQt = tr(
+	    "<h3>About Qt</h3>"
+	    "<p>This program uses Qt version %1.</p>"
+	    "<p>Qt is a C++ toolkit for multiplatform GUI &amp; "
+	    "application development.</p>"
+	    "<p>Qt provides single-source "
+	    "portability across MS&nbsp;Windows, Mac&nbsp;OS&nbsp;X, "
+	    "Linux, and all major commercial Unix variants."
+	    "<br>Qt is also available for embedded devices.</p>"
+	    "<p>Qt is a Trolltech product. "
+	    "See <tt>http://www.trolltech.com/qt/</tt> "
+	    "for more information.</p>"
+	    ).arg( QT_VERSION_STR );
+#endif
+
+    }
+    label = new QMessageBoxLabel( this );
+    Q_CHECK_PTR( label );
+
+    if ( (button2 && !button1) || (button1 && !button0) ) {
+#if defined(QT_CHECK_RANGE)
+        qWarning( "QMessageBox: Inconsistent button parameters" );
+#endif
+        button0 = button1 = button2 = 0;
+    }
+    mbd = new QMessageBoxData(this);
+    Q_CHECK_PTR( mbd );
+    mbd->icon = NoIcon;
+    mbd->iconLabel.setPixmap( QPixmap() );
+    mbd->numButtons = 0;
+    mbd->button[0] = button0;
+    mbd->button[1] = button1;
+    mbd->button[2] = button2;
+    mbd->defButton = -1;
+    mbd->escButton = -1;
+    int i;
+    for ( i=0; i<3; i++ ) {
+        int b = mbd->button[i];
+        if ( (b & Default) ) {
+            if ( mbd->defButton >= 0 ) {
+#if defined(QT_CHECK_RANGE)
+                qWarning( "QMessageBox: There can be at most one "
+                           "default button" );
+#endif
+            } else {
+                mbd->defButton = i;
+            }
+        }
+        if ( (b & Escape) ) {
+            if ( mbd->escButton >= 0 ) {
+#if defined(QT_CHECK_RANGE)
+                qWarning( "QMessageBox: There can be at most one "
+                           "escape button" );
+#endif
+            } else {
+                mbd->escButton = i;
+            }
+        }
+        b &= ButtonMask;
+        if ( b == 0 ) {
+            if ( i == 0 )                       // no buttons, add an Ok button
+                b = Ok;
+        } else if ( b < 0 || b > LastButton ) {
+#if defined(QT_CHECK_RANGE)
+            qWarning( "QMessageBox: Invalid button specifier" );
+#endif
+            b = Ok;
+        } else {
+            if ( i > 0 && mbd->button[i-1] == 0 ) {
+#if defined(QT_CHECK_RANGE)
+                qWarning( "QMessageBox: Inconsistent button parameters; "
+                           "button %d defined but not button %d",
+                           i+1, i );
+#endif
+                b = 0;
+            }
+        }
+        mbd->button[i] = b;
+        if ( b )
+            mbd->numButtons++;
+    }
+    for ( i=0; i<3; i++ ) {
+        if ( i >= mbd->numButtons ) {
+            mbd->pb[i] = 0;
+        } else {
+            QCString buttonName;
+            buttonName.sprintf( "button%d", i+1 );
+            mbd->pb[i] = new QPushButton(
+                tr(mb_texts[mbd->button[i]]),
+                this, buttonName );
+	    if ( mbd->defButton == i ) {
+                mbd->pb[i]->setDefault( TRUE );
+                mbd->pb[i]->setFocus();
+            }
+            mbd->pb[i]->setAutoDefault( TRUE );
+            mbd->pb[i]->setFocusPolicy( QWidget::StrongFocus );
+            connect( mbd->pb[i], SIGNAL(clicked()), SLOT(buttonClicked()) );
+        }
+    }
+    resizeButtons();
+    reserved1 = reserved2 = 0;
+}
+
+
+int QMessageBox::indexOf( int button ) const
+{
+    int index = -1;
+    for ( int i=0; i<mbd->numButtons; i++ ) {
+        if ( mbd->button[i] == button ) {
+            index = i;
+            break;
+        }
+    }
+    return index;
+}
+
+
+void QMessageBox::resizeButtons()
+{
+    int i;
+    QSize maxSize;
+    for ( i=0; i<mbd->numButtons; i++ ) {
+        QSize s = mbd->pb[i]->sizeHint();
+        maxSize.setWidth(  QMAX(maxSize.width(), s.width()) );
+        maxSize.setHeight( QMAX(maxSize.height(),s.height()) );
+    }
+    mbd->buttonSize = maxSize;
+    for ( i=0; i<mbd->numButtons; i++ )
+        mbd->pb[i]->resize( maxSize );
+}
+
+
+/*!
+    \property QMessageBox::text
+    \brief the message box text to be displayed.
+
+    The text will be interpreted either as a plain text or as rich
+    text, depending on the text format setting (\l
+    QMessageBox::textFormat). The default setting is \c AutoText, i.e.
+    the message box will try to auto-detect the format of the text.
+
+    The default value of this property is QString::null.
+
+    \sa textFormat
+*/
+QString QMessageBox::text() const
+{
+    return label->text();
+}
+
+
+void QMessageBox::setText( const QString &text )
+{
+    label->setText( text );
+}
+
+
+/*!
+    \property QMessageBox::icon
+    \brief the message box's icon
+
+    The icon of the message box can be one of the following predefined
+    icons:
+    \list
+    \i QMessageBox::NoIcon
+    \i QMessageBox::Question
+    \i QMessageBox::Information
+    \i QMessageBox::Warning
+    \i QMessageBox::Critical
+    \endlist
+
+    The actual pixmap used for displaying the icon depends on the
+    current \link QWidget::style() GUI style\endlink. You can also set
+    a custom pixmap icon using the \l QMessageBox::iconPixmap
+    property. The default icon is QMessageBox::NoIcon.
+
+    \sa iconPixmap
+*/
+
+QMessageBox::Icon QMessageBox::icon() const
+{
+    return mbd->icon;
+}
+
+void QMessageBox::setIcon( Icon icon )
+{
+    setIconPixmap( standardIcon(icon) );
+    mbd->icon = icon;
+}
+
+/*!
+  \obsolete
+
+  Returns the pixmap used for a standard icon. This
+  allows the pixmaps to be used in more complex message boxes.
+  \a icon specifies the required icon, e.g. QMessageBox::Information,
+  QMessageBox::Warning or QMessageBox::Critical.
+
+  \a style is unused.
+*/
+
+QPixmap QMessageBox::standardIcon( Icon icon, GUIStyle style)
+{
+    Q_UNUSED(style);
+    return QMessageBox::standardIcon(icon);
+}
+
+
+/*!
+    Returns the pixmap used for a standard icon. This allows the
+    pixmaps to be used in more complex message boxes. \a icon
+    specifies the required icon, e.g. QMessageBox::Question,
+    QMessageBox::Information, QMessageBox::Warning or
+    QMessageBox::Critical.
+*/
+
+QPixmap QMessageBox::standardIcon( Icon icon )
+{
+    QPixmap pm;
+    switch ( icon ) {
+    case Information:
+	pm = QApplication::style().stylePixmap( QStyle::SP_MessageBoxInformation );
+        break;
+    case Warning:
+	pm = QApplication::style().stylePixmap( QStyle::SP_MessageBoxWarning );
+        break;
+    case Critical:
+	pm = QApplication::style().stylePixmap( QStyle::SP_MessageBoxCritical );
+        break;
+    case Question:
+	pm = QApplication::style().stylePixmap( QStyle::SP_MessageBoxQuestion );
+    default:
+	break;
+    }
+    return pm;
+}
+
+
+/*!
+    \property QMessageBox::iconPixmap
+    \brief the current icon
+
+    The icon currently used by the message box. Note that it's often
+    hard to draw one pixmap that looks appropriate in both Motif and
+    Windows GUI styles; you may want to draw two pixmaps.
+
+    \sa icon
+*/
+
+const QPixmap *QMessageBox::iconPixmap() const
+{
+    return mbd->iconLabel.pixmap();
+}
+
+
+void QMessageBox::setIconPixmap( const QPixmap &pixmap )
+{
+    mbd->iconLabel.setPixmap(pixmap);
+    mbd->icon = NoIcon;
+}
+
+
+/*!
+    Returns the text of the message box button \a button, or
+    QString::null if the message box does not contain the button.
+
+    \sa setButtonText()
+*/
+
+QString QMessageBox::buttonText( int button ) const
+{
+    int index = indexOf(button);
+    return index >= 0 && mbd->pb[index]
+            ? mbd->pb[index]->text()
+            : QString::null;
+}
+
+
+/*!
+    Sets the text of the message box button \a button to \a text.
+    Setting the text of a button that is not in the message box is
+    silently ignored.
+
+    \sa buttonText()
+*/
+
+void QMessageBox::setButtonText( int button, const QString &text )
+{
+    int index = indexOf(button);
+    if ( index >= 0 && mbd->pb[index] ) {
+        mbd->pb[index]->setText( text );
+        resizeButtons();
+    }
+}
+
+
+/*!
+    \internal
+    Internal slot to handle button clicks.
+*/
+
+void QMessageBox::buttonClicked()
+{
+    int reply = 0;
+    const QObject *s = sender();
+    for ( int i=0; i<mbd->numButtons; i++ ) {
+        if ( mbd->pb[i] == s )
+            reply = mbd->button[i];
+    }
+    done( reply );
+}
+
+
+/*!
+    Adjusts the size of the message box to fit the contents just before
+    QDialog::exec() or QDialog::show() is called.
+
+    This function will not be called if the message box has been explicitly
+    resized before showing it.
+*/
+void QMessageBox::adjustSize()
+{
+    if ( !testWState(WState_Polished) )
+        polish();
+    resizeButtons();
+    label->adjustSize();
+    QSize labelSize( label->size() );
+    int n  = mbd->numButtons;
+    int bw = mbd->buttonSize.width();
+    int bh = mbd->buttonSize.height();
+    int border = bh / 2 - style().pixelMetric(QStyle::PM_ButtonDefaultIndicator);
+    if ( border <= 0 )
+        border = 10;
+    int btn_spacing = 7;
+    if ( style().styleHint(QStyle::SH_GUIStyle) == MotifStyle )
+        btn_spacing = border;
+#ifndef Q_OS_TEMP
+    int buttons = mbd->numButtons * bw + (n-1) * btn_spacing;
+    int h = bh;
+#else
+    int visibleButtons = 0;
+    for ( int i = 0; i < mbd->numButtons; ++i )
+	visibleButtons += mbd->pb[i]->isVisible() ? 1 : 0;
+    int buttons = visibleButtons == 0 ? 0 : visibleButtons * bw + (visibleButtons-1) * btn_spacing;
+    int h = visibleButtons == 0 ? 0 : bh;
+    n = visibleButtons;
+#endif
+    if ( labelSize.height() )
+        h += labelSize.height() + 3*border;
+    else
+        h += 2*border;
+    int lmargin = 0;
+    if ( mbd->iconLabel.pixmap() && mbd->iconLabel.pixmap()->width() )  {
+        mbd->iconLabel.adjustSize();
+        lmargin += mbd->iconLabel.width() + border;
+        if ( h < mbd->iconLabel.height() + 3*border + bh && n )
+            h = mbd->iconLabel.height() + 3*border + bh;
+    }
+    int w = QMAX( buttons, labelSize.width() + lmargin ) + 2*border;
+    QRect screen = QApplication::desktop()->screenGeometry( pos() );
+    if ( w > screen.width() )
+        w = screen.width();
+    resize( w, h );
+    setMinimumSize( size() );
+#ifdef Q_WS_MAC
+    setMaximumSize(size());
+#endif
+}
+
+
+/*!\reimp
+*/
+void QMessageBox::resizeEvent( QResizeEvent * )
+{
+    int i;
+    int n  = mbd->numButtons;
+    int bw = mbd->buttonSize.width();
+    int bh = mbd->buttonSize.height();
+#ifdef Q_OS_TEMP
+    int visibleButtons = 0;
+    for ( i = 0; i < n; ++i )
+	visibleButtons += mbd->pb[i]->isVisible() ? 1 : 0;
+    n  = visibleButtons;
+    bw = visibleButtons == 0 ? 0 : bw;
+    bh = visibleButtons == 0 ? 0 : bh;
+#endif
+    int border = bh / 2 - style().pixelMetric(QStyle::PM_ButtonDefaultIndicator);
+    if ( border <= 0 )
+        border = 10;
+    int btn_spacing = 7;
+    if ( style().styleHint(QStyle::SH_GUIStyle) == MotifStyle )
+        btn_spacing = border;
+    int lmargin = 0;
+    mbd->iconLabel.adjustSize();
+    bool rtl = QApplication::reverseLayout();
+    if (rtl)
+        mbd->iconLabel.move(width() - border - mbd->iconLabel.width(), border);
+    else
+        mbd->iconLabel.move(border, border);
+    if ( mbd->iconLabel.pixmap() && mbd->iconLabel.pixmap()->width() )
+        lmargin += mbd->iconLabel.width() + border;
+    label->setGeometry((rtl ? 0 : lmargin) + border,
+                       border,
+                       width() - lmargin -2*border,
+                       height() - 3*border - bh);
+    int extra_space = (width() - bw*n - 2*border - (n-1)*btn_spacing);
+    if ( style().styleHint(QStyle::SH_GUIStyle) == MotifStyle )
+        for ( i=0; i<n; i++ )
+            mbd->pb[rtl ? n - i - 1 : i]->move(border + i*bw + i*btn_spacing + extra_space*(i+1)/(n+1),
+                                               height() - border - bh );
+    else
+        for ( i=0; i<n; i++ )
+            mbd->pb[rtl ? n - i - 1 : i]->move(border + i*bw + extra_space/2 + i*btn_spacing,
+                                               height() - border - bh );
+}
+
+
+/*!\reimp
+*/
+void QMessageBox::keyPressEvent( QKeyEvent *e )
+{
+    if ( e->key() == Key_Escape ) {
+        if ( mbd->escButton >= 0 ) {
+            QPushButton *pb = mbd->pb[mbd->escButton];
+            pb->animateClick();
+            e->accept();
+            return;
+        }
+    }
+#ifndef QT_NO_ACCEL
+    if ( !( e->state() & AltButton ) ) {
+	QObjectList *list = queryList( "QPushButton" );
+	QObjectListIt it( *list );
+	QPushButton *pb;
+	while ( (pb = (QPushButton*)it.current()) ) {
+	    int key = e->key() & ~(MODIFIER_MASK|UNICODE_ACCEL);
+	    int acc = pb->accel() & ~(MODIFIER_MASK|UNICODE_ACCEL);
+	    if ( key && acc && acc == key ) {
+		delete list;
+		emit pb->animateClick();
+		return;
+	    }
+	    ++it;
+	}
+	delete list;
+    }
+#endif
+    QDialog::keyPressEvent( e );
+}
+
+/*!\reimp
+*/
+void QMessageBox::showEvent( QShowEvent *e )
+{
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+    QAccessible::updateAccessibility( this, 0, QAccessible::Alert );
+#endif
+    QDialog::showEvent( e );
+}
+
+/*!\reimp
+*/
+void QMessageBox::closeEvent( QCloseEvent *e )
+{
+    QDialog::closeEvent( e );
+    if ( mbd->escButton != -1 )
+	setResult( mbd->button[mbd->escButton] );
+}
+
+/*****************************************************************************
+  Static QMessageBox functions
+ *****************************************************************************/
+
+/*!\fn int QMessageBox::message( const QString &,const QString&,const QString&,QWidget*,const char * )
+  \obsolete
+  Opens a modal message box directly using the specified parameters.
+
+  Please use information(), warning(), question(), or critical() instead.
+*/
+
+/*! \fn bool QMessageBox::query( const QString &,const QString&,const QString&,const QString&,QWidget *, const char * )
+  \obsolete
+  Queries the user using a modal message box with two buttons.
+  Note that \a caption is not always shown, it depends on the window manager.
+
+  Please use information(), question(), warning(), or critical() instead.
+*/
+
+/*!
+    Opens an information message box with the caption \a caption and
+    the text \a text. The dialog may have up to three buttons. Each of
+    the buttons, \a button0, \a button1 and \a button2 may be set to
+    one of the following values:
+
+    \list
+    \i QMessageBox::NoButton
+    \i QMessageBox::Ok
+    \i QMessageBox::Cancel
+    \i QMessageBox::Yes
+    \i QMessageBox::No
+    \i QMessageBox::Abort
+    \i QMessageBox::Retry
+    \i QMessageBox::Ignore
+    \i QMessageBox::YesAll
+    \i QMessageBox::NoAll
+    \endlist
+
+    If you don't want all three buttons, set the last button, or last
+    two buttons to QMessageBox::NoButton.
+
+    One button can be OR-ed with \c QMessageBox::Default, and one
+    button can be OR-ed with \c QMessageBox::Escape.
+
+    Returns the identity (QMessageBox::Ok, or QMessageBox::No, etc.)
+    of the button that was clicked.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    \sa question(), warning(), critical()
+*/
+
+int QMessageBox::information( QWidget *parent,
+                              const QString& caption, const QString& text,
+                              int button0, int button1, int button2 )
+{
+    QMessageBox *mb = new QMessageBox( caption, text, Information,
+                                       button0, button1, button2,
+                                       parent, "qt_msgbox_information", TRUE,
+				       WDestructiveClose);
+    Q_CHECK_PTR( mb );
+    return mb->exec();
+}
+
+/*!
+    Opens a question message box with the caption \a caption and the
+    text \a text. The dialog may have up to three buttons. Each of the
+    buttons, \a button0, \a button1 and \a button2 may be set to one
+    of the following values:
+
+    \list
+    \i QMessageBox::NoButton
+    \i QMessageBox::Ok
+    \i QMessageBox::Cancel
+    \i QMessageBox::Yes
+    \i QMessageBox::No
+    \i QMessageBox::Abort
+    \i QMessageBox::Retry
+    \i QMessageBox::Ignore
+    \i QMessageBox::YesAll
+    \i QMessageBox::NoAll
+    \endlist
+
+    If you don't want all three buttons, set the last button, or last
+    two buttons to QMessageBox::NoButton.
+
+    One button can be OR-ed with \c QMessageBox::Default, and one
+    button can be OR-ed with \c QMessageBox::Escape.
+
+    Returns the identity (QMessageBox::Yes, or QMessageBox::No, etc.)
+    of the button that was clicked.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    \sa information(), warning(), critical()
+*/
+
+int QMessageBox::question( QWidget *parent,
+                           const QString& caption, const QString& text,
+                           int button0, int button1, int button2 )
+{
+    QMessageBox *mb = new QMessageBox( caption, text, Question,
+                                       button0, button1, button2,
+                                       parent, "qt_msgbox_information", TRUE,
+				       WDestructiveClose);
+    Q_CHECK_PTR( mb );
+    return mb->exec();
+}
+
+
+/*!
+    Opens a warning message box with the caption \a caption and the
+    text \a text. The dialog may have up to three buttons. Each of the
+    button parameters, \a button0, \a button1 and \a button2 may be
+    set to one of the following values:
+
+    \list
+    \i QMessageBox::NoButton
+    \i QMessageBox::Ok
+    \i QMessageBox::Cancel
+    \i QMessageBox::Yes
+    \i QMessageBox::No
+    \i QMessageBox::Abort
+    \i QMessageBox::Retry
+    \i QMessageBox::Ignore
+    \i QMessageBox::YesAll
+    \i QMessageBox::NoAll
+    \endlist
+
+    If you don't want all three buttons, set the last button, or last
+    two buttons to QMessageBox::NoButton.
+
+    One button can be OR-ed with \c QMessageBox::Default, and one
+    button can be OR-ed with \c QMessageBox::Escape.
+
+    Returns the identity (QMessageBox::Ok, or QMessageBox::No, etc.)
+    of the button that was clicked.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    \sa information(), question(), critical()
+*/
+
+int QMessageBox::warning( QWidget *parent,
+                          const QString& caption, const QString& text,
+                          int button0, int button1, int button2 )
+{
+    QMessageBox *mb = new QMessageBox( caption, text, Warning,
+                                       button0, button1, button2,
+                                       parent, "qt_msgbox_warning", TRUE,
+				       WDestructiveClose);
+    Q_CHECK_PTR( mb );
+    return mb->exec();
+}
+
+
+/*!
+    Opens a critical message box with the caption \a caption and the
+    text \a text. The dialog may have up to three buttons. Each of the
+    button parameters, \a button0, \a button1 and \a button2 may be
+    set to one of the following values:
+
+    \list
+    \i QMessageBox::NoButton
+    \i QMessageBox::Ok
+    \i QMessageBox::Cancel
+    \i QMessageBox::Yes
+    \i QMessageBox::No
+    \i QMessageBox::Abort
+    \i QMessageBox::Retry
+    \i QMessageBox::Ignore
+    \i QMessageBox::YesAll
+    \i QMessageBox::NoAll
+    \endlist
+
+    If you don't want all three buttons, set the last button, or last
+    two buttons to QMessageBox::NoButton.
+
+    One button can be OR-ed with \c QMessageBox::Default, and one
+    button can be OR-ed with \c QMessageBox::Escape.
+
+    Returns the identity (QMessageBox::Ok, or QMessageBox::No, etc.)
+    of the button that was clicked.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    \sa information(), question(), warning()
+*/
+
+int QMessageBox::critical( QWidget *parent,
+                           const QString& caption, const QString& text,
+                           int button0, int button1, int button2 )
+{
+    QMessageBox *mb = new QMessageBox( caption, text, Critical,
+                                       button0, button1, button2,
+                                       parent, "qt_msgbox_critical", TRUE,
+				       WDestructiveClose);
+    Q_CHECK_PTR( mb );
+    return mb->exec();
+}
+
+
+/*!
+    Displays a simple about box with caption \a caption and text \a
+    text. The about box's parent is \a parent.
+
+    about() looks for a suitable icon in four locations:
+    \list 1
+    \i It prefers \link QWidget::icon() parent->icon() \endlink if that exists.
+    \i If not, it tries the top-level widget containing \a parent.
+    \i If that fails, it tries the \link
+    QApplication::mainWidget() main widget. \endlink
+    \i As a last resort it uses the Information icon.
+    \endlist
+
+    The about box has a single button labelled "OK".
+
+    \sa QWidget::icon() QApplication::mainWidget()
+*/
+
+void QMessageBox::about( QWidget *parent, const QString &caption,
+                         const QString& text )
+{
+    QMessageBox *mb = new QMessageBox( caption, text,
+                                       Information,
+                                       Ok + Default, 0, 0,
+                                       parent, "qt_msgbox_simple_about_box", TRUE,
+				       WDestructiveClose);
+    Q_CHECK_PTR( mb );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    const QPixmap *pm = parent ? parent->icon() : 0;
+    if ( pm && !pm->isNull() )
+	mb->setIconPixmap( *pm );
+    else {
+	pm = parent ? parent->topLevelWidget()->icon() : 0;
+	if ( pm && !pm->isNull() )
+	    mb->setIconPixmap( *pm );
+	else {
+	    pm = qApp && qApp->mainWidget() ? qApp->mainWidget()->icon() : 0;
+	    if ( pm && !pm->isNull() )
+		mb->setIconPixmap( *pm );
+	}
+    }
+#endif
+    mb->exec();
+}
+
+
+/*! \reimp
+*/
+
+void QMessageBox::styleChanged( QStyle& )
+{
+    if ( mbd->icon != NoIcon ) {
+        // Reload icon for new style
+        setIcon( mbd->icon );
+    }
+}
+
+
+static int textBox( QWidget *parent, QMessageBox::Icon severity,
+                    const QString& caption, const QString& text,
+                    const QString& button0Text,
+                    const QString& button1Text,
+                    const QString& button2Text,
+                    int defaultButtonNumber,
+                    int escapeButtonNumber )
+{
+    int b[3];
+    b[0] = 1;
+    b[1] = button1Text.isEmpty() ? 0 : 2;
+    b[2] = button2Text.isEmpty() ? 0 : 3;
+
+    int i;
+    for( i=0; i<3; i++ ) {
+        if ( b[i] && defaultButtonNumber == i )
+            b[i] += QMessageBox::Default;
+        if ( b[i] && escapeButtonNumber == i )
+            b[i] += QMessageBox::Escape;
+    }
+
+    QMessageBox *mb = new QMessageBox( caption, text, severity,
+                                       b[0], b[1], b[2],
+                                       parent, "qt_msgbox_information", TRUE,
+				       Qt::WDestructiveClose);
+    Q_CHECK_PTR( mb );
+    if ( button0Text.isEmpty() )
+        mb->setButtonText( 1, QMessageBox::tr(mb_texts[QMessageBox::Ok]) );
+    else
+        mb->setButtonText( 1, button0Text );
+    if ( b[1] )
+        mb->setButtonText( 2, button1Text );
+    if ( b[2] )
+        mb->setButtonText( 3, button2Text );
+
+#ifndef QT_NO_CURSOR
+    mb->setCursor( Qt::arrowCursor );
+#endif
+    return mb->exec() - 1;
+}
+
+
+/*!
+    \overload
+
+    Displays an information message box with caption \a caption, text
+    \a text and one, two or three buttons. Returns the index of the
+    button that was clicked (0, 1 or 2).
+
+    \a button0Text is the text of the first button, and is optional.
+    If \a button0Text is not supplied, "OK" (translated) will be used.
+    \a button1Text is the text of the second button, and is optional.
+    \a button2Text is the text of the third button, and is optional.
+    \a defaultButtonNumber (0, 1 or 2) is the index of the default
+    button; pressing Return or Enter is the same as clicking the
+    default button. It defaults to 0 (the first button). \a
+    escapeButtonNumber is the index of the Escape button; pressing
+    Escape is the same as clicking this button. It defaults to -1;
+    supply 0, 1 or 2 to make pressing Escape equivalent to clicking
+    the relevant button.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    Note: If you do not specify an Escape button then if the Escape
+    button is pressed then -1 will be returned.  It is suggested that
+    you specify an Escape button to prevent this from happening.
+
+    \sa question(), warning(), critical()
+*/
+
+int QMessageBox::information( QWidget *parent, const QString &caption,
+                              const QString& text,
+                              const QString& button0Text,
+                              const QString& button1Text,
+                              const QString& button2Text,
+                              int defaultButtonNumber,
+                              int escapeButtonNumber )
+{
+    return textBox( parent, Information, caption, text,
+                    button0Text, button1Text, button2Text,
+                    defaultButtonNumber, escapeButtonNumber );
+}
+
+/*!
+    \overload
+
+    Displays a question message box with caption \a caption, text \a
+    text and one, two or three buttons. Returns the index of the
+    button that was clicked (0, 1 or 2).
+
+    \a button0Text is the text of the first button, and is optional.
+    If \a button0Text is not supplied, "OK" (translated) will be used.
+    \a button1Text is the text of the second button, and is optional.
+    \a button2Text is the text of the third button, and is optional.
+    \a defaultButtonNumber (0, 1 or 2) is the index of the default
+    button; pressing Return or Enter is the same as clicking the
+    default button. It defaults to 0 (the first button). \a
+    escapeButtonNumber is the index of the Escape button; pressing
+    Escape is the same as clicking this button. It defaults to -1;
+    supply 0, 1 or 2 to make pressing Escape equivalent to clicking
+    the relevant button.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    Note: If you do not specify an Escape button then if the Escape
+    button is pressed then -1 will be returned.  It is suggested that
+    you specify an Escape button to prevent this from happening.
+
+    \sa information(), warning(), critical()
+*/
+int QMessageBox::question( QWidget *parent, const QString &caption,
+                           const QString& text,
+                           const QString& button0Text,
+                           const QString& button1Text,
+                           const QString& button2Text,
+                           int defaultButtonNumber,
+                           int escapeButtonNumber )
+{
+    return textBox( parent, Question, caption, text,
+                    button0Text, button1Text, button2Text,
+                    defaultButtonNumber, escapeButtonNumber );
+}
+
+
+/*!
+    \overload
+
+    Displays a warning message box with a caption, a text, and 1, 2 or
+    3 buttons. Returns the number of the button that was clicked (0,
+    1, or 2).
+
+    \a button0Text is the text of the first button, and is optional.
+    If \a button0Text is not supplied, "OK" (translated) will be used.
+    \a button1Text is the text of the second button, and is optional,
+    and \a button2Text is the text of the third button, and is
+    optional. \a defaultButtonNumber (0, 1 or 2) is the index of the
+    default button; pressing Return or Enter is the same as clicking
+    the default button. It defaults to 0 (the first button). \a
+    escapeButtonNumber is the index of the Escape button; pressing
+    Escape is the same as clicking this button. It defaults to -1;
+    supply 0, 1, or 2 to make pressing Escape equivalent to clicking
+    the relevant button.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    Note: If you do not specify an Escape button then if the Escape
+    button is pressed then -1 will be returned.  It is suggested that
+    you specify an Escape button to prevent this from happening.
+
+    \sa information(), question(), critical()
+*/
+
+int QMessageBox::warning( QWidget *parent, const QString &caption,
+                                 const QString& text,
+                                 const QString& button0Text,
+                                 const QString& button1Text,
+                                 const QString& button2Text,
+                                 int defaultButtonNumber,
+                                 int escapeButtonNumber )
+{
+    return textBox( parent, Warning, caption, text,
+                    button0Text, button1Text, button2Text,
+                    defaultButtonNumber, escapeButtonNumber );
+}
+
+
+/*!
+    \overload
+
+    Displays a critical error message box with a caption, a text, and
+    1, 2 or 3 buttons. Returns the number of the button that was
+    clicked (0, 1 or 2).
+
+    \a button0Text is the text of the first button, and is optional.
+    If \a button0Text is not supplied, "OK" (translated) will be used.
+    \a button1Text is the text of the second button, and is optional,
+    and \a button2Text is the text of the third button, and is
+    optional. \a defaultButtonNumber (0, 1 or 2) is the index of the
+    default button; pressing Return or Enter is the same as clicking
+    the default button. It defaults to 0 (the first button). \a
+    escapeButtonNumber is the index of the Escape button; pressing
+    Escape is the same as clicking this button. It defaults to -1;
+    supply 0, 1, or 2 to make pressing Escape equivalent to clicking
+    the relevant button.
+
+    If \a parent is 0, the message box becomes an application-global
+    modal dialog box. If \a parent is a widget, the message box
+    becomes modal relative to \a parent.
+
+    \sa information(), question(), warning()
+*/
+
+int QMessageBox::critical( QWidget *parent, const QString &caption,
+                                  const QString& text,
+                                  const QString& button0Text,
+                                  const QString& button1Text,
+                                  const QString& button2Text,
+                                  int defaultButtonNumber,
+                                  int escapeButtonNumber )
+{
+    return textBox( parent, Critical, caption, text,
+                    button0Text, button1Text, button2Text,
+                    defaultButtonNumber, escapeButtonNumber );
+}
+
+
+/*!
+    Displays a simple message box about Qt, with caption \a caption
+    and centered over \a parent (if \a parent is not 0). The message
+    includes the version number of Qt being used by the application.
+
+    This is useful for inclusion in the Help menu of an application.
+    See the examples/menu/menu.cpp example.
+
+    QApplication provides this functionality as a slot.
+
+    \sa QApplication::aboutQt()
+*/
+
+void QMessageBox::aboutQt( QWidget *parent, const QString &caption )
+{
+    QMessageBox *mb = new QMessageBox( parent, "qt_msgbox_about_qt" );
+    Q_CHECK_PTR( mb );
+    mb->setWFlags( WDestructiveClose );
+
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    QString c = caption;
+    if ( c.isNull() )
+        c = tr( "About Qt" );
+    mb->setCaption( c );
+#endif
+    mb->setText( *translatedTextAboutQt );
+#ifndef QT_NO_IMAGEIO
+    QPixmap pm;
+    QImage logo( (const char **)qtlogo_xpm);
+    if ( qGray(mb->palette().active().text().rgb()) >
+         qGray(mb->palette().active().base().rgb()) )
+    {
+        // light on dark, adjust some colors (where's 10?)
+        logo.setColor( 0, 0xffffffff );
+        logo.setColor( 1, 0xff666666 );
+        logo.setColor( 2, 0xffcccc66 );
+        logo.setColor( 4, 0xffcccccc );
+        logo.setColor( 6, 0xffffff66 );
+        logo.setColor( 7, 0xff999999 );
+        logo.setColor( 8, 0xff3333ff );
+        logo.setColor( 9, 0xffffff33 );
+        logo.setColor( 11, 0xffcccc99 );
+    }
+    if ( pm.convertFromImage( logo ) )
+        mb->setIconPixmap( pm );
+#endif
+    mb->setButtonText( 0, tr("OK") );
+    if ( mb->mbd && mb->mbd->pb[0] ) {
+        mb->mbd->pb[0]->setAutoDefault( TRUE );
+        mb->mbd->pb[0]->setFocusPolicy( QWidget::StrongFocus );
+        mb->mbd->pb[0]->setDefault( TRUE );
+        mb->mbd->pb[0]->setFocus();
+    }
+    mb->exec();
+}
+
+/*!
+  \reimp
+*/
+
+void QMessageBox::setIcon( const QPixmap &pix )
+{
+    //reimplemented to avoid compiler warning.
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    QDialog::setIcon( pix );
+#endif
+}
+
+
+/*!
+    \property QMessageBox::textFormat
+    \brief the format of the text displayed by the message box
+
+    The current text format used by the message box. See the \l
+    Qt::TextFormat enum for an explanation of the possible options.
+
+    The default format is \c AutoText.
+
+    \sa setText()
+*/
+
+Qt::TextFormat QMessageBox::textFormat() const
+{
+    return label->textFormat();
+}
+
+
+void QMessageBox::setTextFormat( Qt::TextFormat format )
+{
+    label->setTextFormat( format );
+}
+
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qmessagebox.h b/main/dependencies/qt3/src/dialogs/qmessagebox.h
new file mode 100644
index 000000000..338525b35
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qmessagebox.h
@@ -0,0 +1,223 @@
+/****************************************************************************
+**
+** Definition of QMessageBox class
+**
+** Created : 950503
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QMESSAGEBOX_H
+#define QMESSAGEBOX_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#endif // QT_H
+
+#ifndef QT_NO_MESSAGEBOX
+
+class  QLabel;
+class  QPushButton;
+struct QMessageBoxData;
+
+class Q_EXPORT QMessageBox : public QDialog
+{
+    Q_OBJECT
+    Q_ENUMS( Icon )
+    Q_PROPERTY( QString text READ text WRITE setText )
+    Q_PROPERTY( Icon icon READ icon WRITE setIcon )
+    Q_PROPERTY( QPixmap iconPixmap READ iconPixmap WRITE setIconPixmap )
+    Q_PROPERTY( TextFormat textFormat READ textFormat WRITE setTextFormat )
+
+public:
+    enum Icon { NoIcon = 0, Information = 1, Warning = 2, Critical = 3,
+		Question = 4 };
+
+    QMessageBox( QWidget* parent=0, const char* name=0 );
+    QMessageBox( const QString& caption, const QString &text, Icon icon,
+		 int button0, int button1, int button2,
+		 QWidget* parent=0, const char* name=0, bool modal=TRUE,
+		 WFlags f=WStyle_DialogBorder  );
+    ~QMessageBox();
+
+    enum { NoButton = 0, Ok = 1, Cancel = 2, Yes = 3, No = 4, Abort = 5,
+	   Retry = 6, Ignore = 7, YesAll = 8, NoAll = 9, ButtonMask = 0xff,
+	   Default = 0x100, Escape = 0x200, FlagMask = 0x300 };
+
+    static int information( QWidget *parent, const QString &caption,
+			    const QString& text,
+			    int button0, int button1=0, int button2=0 );
+    static int information( QWidget *parent, const QString &caption,
+			    const QString& text,
+			    const QString& button0Text = QString::null,
+			    const QString& button1Text = QString::null,
+			    const QString& button2Text = QString::null,
+			    int defaultButtonNumber = 0,
+			    int escapeButtonNumber = -1 );
+
+    static int question( QWidget *parent, const QString &caption,
+			 const QString& text,
+			 int button0, int button1=0, int button2=0 );
+    static int question( QWidget *parent, const QString &caption,
+			 const QString& text,
+			 const QString& button0Text = QString::null,
+			 const QString& button1Text = QString::null,
+			 const QString& button2Text = QString::null,
+			 int defaultButtonNumber = 0,
+			 int escapeButtonNumber = -1 );
+
+    static int warning( QWidget *parent, const QString &caption,
+			const QString& text,
+			int button0, int button1, int button2=0 );
+    static int warning( QWidget *parent, const QString &caption,
+			const QString& text,
+			const QString& button0Text = QString::null,
+			const QString& button1Text = QString::null,
+			const QString& button2Text = QString::null,
+			int defaultButtonNumber = 0,
+			int escapeButtonNumber = -1 );
+
+    static int critical( QWidget *parent, const QString &caption,
+			 const QString& text,
+			 int button0, int button1, int button2=0 );
+    static int critical( QWidget *parent, const QString &caption,
+			 const QString& text,
+			 const QString& button0Text = QString::null,
+			 const QString& button1Text = QString::null,
+			 const QString& button2Text = QString::null,
+			 int defaultButtonNumber = 0,
+			 int escapeButtonNumber = -1 );
+
+    static void about( QWidget *parent, const QString &caption,
+		       const QString& text );
+
+    static void aboutQt( QWidget *parent,
+			 const QString& caption=QString::null );
+
+/* OBSOLETE */
+    static int message( const QString &caption,
+			const QString& text,
+			const QString& buttonText=QString::null,
+			QWidget *parent=0, const char * =0 ) {
+	return QMessageBox::information( parent, caption, text,
+				     buttonText.isEmpty()
+				     ? tr("OK") : buttonText ) == 0;
+    }
+
+/* OBSOLETE */
+    static bool query( const QString &caption,
+		       const QString& text,
+		       const QString& yesButtonText=QString::null,
+		       const QString& noButtonText=QString::null,
+		       QWidget *parent=0, const char * = 0 ) {
+	return QMessageBox::information( parent, caption, text,
+				     yesButtonText.isEmpty()
+				     ? tr("OK") : yesButtonText,
+				     noButtonText ) == 0;
+    }
+
+    QString	text() const;
+    void	setText( const QString &);
+
+    Icon	icon() const;
+
+    void	setIcon( Icon );
+    void	setIcon( const QPixmap & );
+
+    const QPixmap *iconPixmap() const;
+    void	setIconPixmap( const QPixmap & );
+
+    QString	buttonText( int button ) const;
+    void	setButtonText( int button, const QString &);
+
+    void	adjustSize();
+
+/* OBSOLETE */
+    static QPixmap standardIcon( Icon icon, GUIStyle );
+
+    static QPixmap standardIcon( Icon icon );
+
+    TextFormat textFormat() const;
+    void	 setTextFormat( TextFormat );
+
+protected:
+    void	resizeEvent( QResizeEvent * );
+    void	showEvent( QShowEvent * );
+    void	closeEvent( QCloseEvent * );
+    void	keyPressEvent( QKeyEvent * );
+    void	styleChanged( QStyle& );
+
+private slots:
+    void	buttonClicked();
+
+private:
+    void	init( int, int, int );
+    int		indexOf( int ) const;
+    void	resizeButtons();
+    QLabel     *label;
+    QMessageBoxData *mbd;
+    void       *reserved1;
+    void       *reserved2;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QMessageBox( const QMessageBox & );
+    QMessageBox &operator=( const QMessageBox & );
+#endif
+};
+
+/*
+*  Macro to be used at the beginning of main(), e.g.
+*
+*   #include <qapplication.h>
+*   #include <qmessagebox.h>
+*   int main( int argc, char**argv )
+*   {
+*     QT_REQUIRE_VERSION( argc, argv, "3.0.5" )
+*     ...
+*   }
+*/
+#define QT_REQUIRE_VERSION( argc, argv, str ) { QString s=QString::fromLatin1(str);\
+QString sq=QString::fromLatin1(qVersion()); if ( (sq.section('.',0,0).toInt()<<16)+\
+(sq.section('.',1,1).toInt()<<8)+sq.section('.',2,2).toInt()<(s.section('.',0,0).toInt()<<16)+\
+(s.section('.',1,1).toInt()<<8)+s.section('.',2,2).toInt() ){if ( !qApp){ int c=0; new \
+QApplication(argc,argv);} QString s = QApplication::tr("Executable '%1' requires Qt "\
+ "%2, found Qt %3.").arg(QString::fromLatin1(qAppName())).arg(QString::fromLatin1(\
+str)).arg(QString::fromLatin1(qVersion()) ); QMessageBox::critical( 0, QApplication::tr(\
+"Incompatible Qt Library Error" ), s, QMessageBox::Abort,0 ); qFatal(s.ascii()); }}
+
+
+#endif // QT_NO_MESSAGEBOX
+
+#endif // QMESSAGEBOX_H
diff --git a/main/dependencies/qt3/src/dialogs/qprintdialog.cpp b/main/dependencies/qt3/src/dialogs/qprintdialog.cpp
new file mode 100644
index 000000000..3f3e2a144
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qprintdialog.cpp
@@ -0,0 +1,1672 @@
+/****************************************************************************
+**
+** Implementation of internal print dialog (X11) used by QPrinter::select().
+**
+** Created : 950829
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qprintdialog.h"
+
+#ifndef QT_NO_PRINTDIALOG
+
+#include "qfiledialog.h"
+#include "qfile.h"
+#include "qtextstream.h"
+#include "qcombobox.h"
+#include "qframe.h"
+#include "qlabel.h"
+#include "qlineedit.h"
+#include "qpushbutton.h"
+#include "qprinter.h"
+#include "qlistview.h"
+#include "qlayout.h"
+#include "qbuttongroup.h"
+#include "qradiobutton.h"
+#include "qspinbox.h"
+#include "qapplication.h"
+#include "qheader.h"
+#include "qstyle.h"
+#include "qstring.h"
+#include "qregexp.h"
+#if !defined(QT_NO_CUPS) || !defined(QT_NO_NIS)
+#include "qlibrary.h"
+#endif
+
+#ifndef QT_NO_NIS
+
+#ifndef BOOL_DEFINED
+#define BOOL_DEFINED
+#endif
+
+#include <rpcsvc/ypclnt.h>
+#include <rpcsvc/yp_prot.h>
+
+// Solaris redefines connect -> __xnet_connect with _XOPEN_SOURCE_EXTENDED.
+#if defined(connect)
+# undef connect
+#endif
+
+#endif // QT_NO_NIS
+
+// UNIX Large File Support redefines open -> open64
+#if defined(open)
+# undef open
+#endif
+
+#include <ctype.h>
+#include <stdlib.h>
+
+
+class QPrintDialogSpinBox : public QSpinBox
+{
+public:
+    QPrintDialogSpinBox(int min, int max, int steps, QWidget *parent, const char *name)
+	: QSpinBox(min, max, steps, parent, name)
+    {}
+
+    void interpretText()
+    {
+	QSpinBox::interpretText();
+    }
+};
+
+
+
+
+enum { Success = 's', Unavail = 'u', NotFound = 'n', TryAgain = 't' };
+enum { Continue = 'c', Return = 'r' };
+
+class QPrintDialogPrivate
+{
+public:
+    QPrinter * printer;
+
+    QButtonGroup * printerOrFile;
+
+    bool outputToFile;
+    QListView * printers;
+    QLineEdit * fileName;
+    QPushButton * browse, *ok;
+
+    QButtonGroup * printRange;
+    QLabel * firstPageLabel;
+    QPrintDialogSpinBox * firstPage;
+    QLabel * lastPageLabel;
+    QPrintDialogSpinBox * lastPage;
+    QRadioButton * printAllButton;
+    QRadioButton * printRangeButton;
+    QRadioButton * printSelectionButton;
+    QRadioButton * printToFileButton;
+    QComboBox *orientationCombo, *sizeCombo;
+
+    QPrinter::PageSize pageSize;
+    QPrinter::Orientation orientation;
+
+    QButtonGroup * pageOrder;
+    QPrinter::PageOrder pageOrder2;
+
+    QButtonGroup * colorMode;
+    QPrinter::ColorMode colorMode2;
+
+    QPrintDialogSpinBox * copies;
+    int numCopies;
+
+    QBoxLayout *customLayout;
+
+    QPrinter::PageSize indexToPageSize[QPrinter::NPageSize];
+};
+
+
+typedef void (*Q_PrintDialogHook)(QListView *);
+static Q_PrintDialogHook addPrinterHook = 0;
+
+void qt_set_printdialog_hook( Q_PrintDialogHook hook )
+{
+    addPrinterHook = hook;
+}
+
+static void isc( QPrintDialogPrivate * d, const QString & text,
+		 QPrinter::PageSize ps );
+
+class QPrinterListViewItem : public QListViewItem
+{
+public:
+    QPrinterListViewItem( QListView * printers, const QString& name,
+			  const QString& host, const QString& comment,
+			  const QStringList& aliases )
+	: QListViewItem( printers, name, host, comment ), ali( aliases ) { }
+
+    bool samePrinter( const QString& name ) {
+	return text( 0 ) == name || ali.find( name ) != ali.end();
+    }
+
+    QStringList ali;
+};
+
+static void perhapsAddPrinter( QListView * printers, const QString &name,
+			       QString host, QString comment,
+			       QStringList aliases = QStringList() )
+{
+    const QListViewItem * i = printers->firstChild();
+    while ( i && !((QPrinterListViewItem *) i)->samePrinter(name) )
+	i = i->nextSibling();
+    if ( i )
+	return;
+    if ( host.isEmpty() )
+	host = QPrintDialog::tr( "locally connected" );
+    (void)new QPrinterListViewItem( printers,
+				    name.simplifyWhiteSpace(),
+				    host.simplifyWhiteSpace(),
+				    comment.simplifyWhiteSpace(), aliases );
+}
+
+static void parsePrinterDesc( QString printerDesc, QListView * printers )
+{
+    if ( printerDesc.length() < 1 )
+	return;
+
+    printerDesc = printerDesc.simplifyWhiteSpace();
+    int i = printerDesc.find( ':' );
+    QString printerName, printerComment, printerHost;
+    QStringList aliases;
+
+    if ( i >= 0 ) {
+	// have ':' want '|'
+	int j = printerDesc.find( '|' );
+	if ( j > 0 && j < i ) {
+	    printerName = printerDesc.left( j );
+	    aliases = QStringList::split( '|',
+		    printerDesc.mid(j + 1, i - j - 1) );
+	    // try extracting a comment from the aliases
+	    printerComment = QPrintDialog::tr( "Aliases: %1" )
+			     .arg( aliases.join(", ") );
+	} else {
+	    printerName = printerDesc.left( i );
+	}
+	// look for lprng pseudo all printers entry
+	i = printerDesc.find( QRegExp(QString::fromLatin1(": *all *=")) );
+	if ( i >= 0 )
+	    printerName = "";
+	// look for signs of this being a remote printer
+	i = printerDesc.find( QRegExp(QString::fromLatin1(": *rm *=")) );
+	if ( i >= 0 ) {
+	    // point k at the end of remote host name
+	    while ( printerDesc[i] != '=' )
+		i++;
+	    while ( printerDesc[i] == '=' || printerDesc[i].isSpace() )
+		i++;
+	    j = i;
+	    while ( j < (int)printerDesc.length() && printerDesc[j] != ':' )
+		j++;
+
+	    // and stuff that into the string
+	    printerHost = printerDesc.mid( i, j - i );
+	}
+    }
+    if ( printerName.length() )
+	perhapsAddPrinter( printers, printerName, printerHost, printerComment,
+			   aliases );
+}
+
+static int parsePrintcap( QListView * printers, const QString& fileName )
+{
+    QFile printcap( fileName );
+    if ( !printcap.open( IO_ReadOnly ) )
+	return NotFound;
+
+    char * line_ascii = new char[1025];
+    line_ascii[1024] = '\0';
+
+    QString printerDesc;
+    bool atEnd = FALSE;
+
+    while ( !atEnd ) {
+	if ( printcap.atEnd() || printcap.readLine( line_ascii, 1024 ) <= 0 )
+	    atEnd = TRUE;
+	QString line = line_ascii;
+	line = line.stripWhiteSpace();
+	if ( line.length() >= 1 && line[int(line.length()) - 1] == '\\' )
+	    line.truncate( line.length() - 1 );
+	if ( line[0] == '#' ) {
+	    if ( !atEnd )
+		continue;
+	} else if ( line[0] == '|' || line[0] == ':' ) {
+	    printerDesc += line;
+	    if ( !atEnd )
+		continue;
+	}
+
+	parsePrinterDesc( printerDesc, printers );
+
+	// add the first line of the new printer definition
+	printerDesc = line;
+    }
+    delete[] line_ascii;
+    return Success;
+}
+
+
+// solaris, not 2.6
+static void parseEtcLpPrinters( QListView * printers )
+{
+    QDir lp( QString::fromLatin1("/etc/lp/printers") );
+    const QFileInfoList * dirs = lp.entryInfoList();
+    if ( !dirs )
+	return;
+
+    QFileInfoListIterator it( *dirs );
+    QFileInfo *printer;
+    QString tmp;
+    while ( (printer = it.current()) != 0 ) {
+	++it;
+	if ( printer->isDir() ) {
+	    tmp.sprintf( "/etc/lp/printers/%s/configuration",
+			 printer->fileName().ascii() );
+	    QFile configuration( tmp );
+	    char * line = new char[1025];
+	    QString remote( QString::fromLatin1("Remote:") );
+	    QString contentType( QString::fromLatin1("Content types:") );
+	    QString printerHost;
+	    bool canPrintPostscript = FALSE;
+	    if ( configuration.open( IO_ReadOnly ) ) {
+		while ( !configuration.atEnd() &&
+			configuration.readLine( line, 1024 ) > 0 ) {
+		    if ( QString::fromLatin1(line).startsWith( remote ) ) {
+			const char * p = line;
+			while ( *p != ':' )
+			    p++;
+			p++;
+			while ( isspace((uchar) *p) )
+			    p++;
+			printerHost = QString::fromLocal8Bit(p);
+			printerHost = printerHost.simplifyWhiteSpace();
+		    } else if ( QString::fromLatin1(line).startsWith( contentType ) ) {
+			char * p = line;
+			while ( *p != ':' )
+			    p++;
+			p++;
+			char * e;
+			while ( *p ) {
+			    while ( isspace((uchar) *p) )
+				p++;
+			    if ( *p ) {
+				char s;
+				e = p;
+				while ( isalnum((uchar) *e) )
+				    e++;
+				s = *e;
+				*e = '\0';
+				if ( !qstrcmp( p, "postscript" ) ||
+				     !qstrcmp( p, "any" ) )
+				    canPrintPostscript = TRUE;
+				*e = s;
+				if ( s == ',' )
+				    e++;
+				p = e;
+			    }
+			}
+		    }
+		}
+		if ( canPrintPostscript )
+		    perhapsAddPrinter( printers, printer->fileName(),
+				       printerHost, QString::fromLatin1("") );
+	    }
+	    delete[] line;
+	}
+    }
+}
+
+
+// solaris 2.6
+static char * parsePrintersConf( QListView * printers, bool *found = 0 )
+{
+    QFile pc( QString::fromLatin1("/etc/printers.conf") );
+    if ( !pc.open( IO_ReadOnly ) ) {
+	if ( found )
+	    *found = FALSE;
+	return 0;
+    }
+    if ( found )
+	*found = TRUE;
+
+    char * line = new char[1025];
+    line[1024] = '\0';
+
+    QString printerDesc;
+    int lineLength = 0;
+
+    char * defaultPrinter = 0;
+
+    while ( !pc.atEnd() &&
+	    (lineLength=pc.readLine( line, 1024 )) > 0 ) {
+	if ( *line == '#' ) {
+	    *line = '\0';
+	    lineLength = 0;
+	}
+	if ( lineLength >= 2 && line[lineLength-2] == '\\' ) {
+	    line[lineLength-2] = '\0';
+	    printerDesc += QString::fromLocal8Bit(line);
+	} else {
+	    printerDesc += QString::fromLocal8Bit(line);
+	    printerDesc = printerDesc.simplifyWhiteSpace();
+	    int i = printerDesc.find( ':' );
+	    QString printerName, printerHost, printerComment;
+	    QStringList aliases;
+	    if ( i >= 0 ) {
+		// have : want |
+		int j = printerDesc.find( '|', 0 );
+		if ( j >= i )
+		    j = -1;
+		printerName = printerDesc.mid( 0, j < 0 ? i : j );
+		if ( printerName == QString::fromLatin1("_default") ) {
+		    i = printerDesc.find(
+			QRegExp( QString::fromLatin1(": *use *=") ) );
+		    while ( printerDesc[i] != '=' )
+			i++;
+		    while ( printerDesc[i] == '=' || printerDesc[i].isSpace() )
+			i++;
+		    j = i;
+		    while ( j < (int)printerDesc.length() &&
+			    printerDesc[j] != ':' && printerDesc[j] != ',' )
+			j++;
+		    // that's our default printer
+		    defaultPrinter =
+			qstrdup( printerDesc.mid( i, j-i ).ascii() );
+		    printerName = "";
+		    printerDesc = "";
+		} else if ( printerName == QString::fromLatin1("_all") ) {
+		    // skip it.. any other cases we want to skip?
+		    printerName = "";
+		    printerDesc = "";
+		}
+
+		if ( j > 0 ) {
+		    // try extracting a comment from the aliases
+		    aliases = QStringList::split( '|',
+			    printerDesc.mid(j + 1, i - j - 1) );
+		    printerComment = QPrintDialog::tr( "Aliases: %1" )
+				     .arg( aliases.join(", ") );
+		}
+		// look for signs of this being a remote printer
+		i = printerDesc.find(
+		    QRegExp( QString::fromLatin1(": *bsdaddr *=") ) );
+		if ( i >= 0 ) {
+		    // point k at the end of remote host name
+		    while ( printerDesc[i] != '=' )
+			i++;
+		    while ( printerDesc[i] == '=' || printerDesc[i].isSpace() )
+			i++;
+		    j = i;
+		    while ( j < (int)printerDesc.length() &&
+			    printerDesc[j] != ':' && printerDesc[j] != ',' )
+			j++;
+		    // and stuff that into the string
+		    printerHost = printerDesc.mid( i, j-i );
+		    // maybe stick the remote printer name into the comment
+		    if ( printerDesc[j] == ',' ) {
+			i = ++j;
+			while ( printerDesc[i].isSpace() )
+			    i++;
+			j = i;
+			while ( j < (int)printerDesc.length() &&
+				printerDesc[j] != ':' && printerDesc[j] != ',' )
+			    j++;
+			if ( printerName != printerDesc.mid( i, j-i ) ) {
+			    printerComment =
+				QString::fromLatin1("Remote name: ");
+			    printerComment += printerDesc.mid( i, j-i );
+			}
+		    }
+		}
+	    }
+	    if ( printerComment == ":" )
+		printerComment = ""; // for cups
+	    if ( printerName.length() )
+		perhapsAddPrinter( printers, printerName, printerHost,
+				   printerComment, aliases );
+	    // chop away the line, for processing the next one
+	    printerDesc = "";
+	}
+    }
+    delete[] line;
+    return defaultPrinter;
+}
+
+#ifndef QT_NO_NIS
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+
+static int foreach( int /* status */, char * /* key */, int /* keyLen */,
+		    char * val, int valLen, char * data )
+{
+    parsePrinterDesc( QString::fromLatin1(val, valLen), (QListView *) data );
+    return 0;
+}
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+static int retrieveNisPrinters( QListView * printers )
+{
+    typedef int (*WildCast)( int, char *, int, char *, int, char * );
+    char printersConfByname[] = "printers.conf.byname";
+    char *domain;
+    int err;
+
+    QLibrary lib( "nsl" );
+    typedef int (*ypGetDefaultDomain)(char **);
+    ypGetDefaultDomain _ypGetDefaultDomain = (ypGetDefaultDomain)lib.resolve( "yp_get_default_domain" );
+    typedef int (*ypAll)(const char *, const char *, const struct ypall_callback *);
+    ypAll _ypAll = (ypAll)lib.resolve( "yp_all" );
+
+    if ( _ypGetDefaultDomain && _ypAll ) {
+	err = _ypGetDefaultDomain( &domain );
+	if ( err == 0 ) {
+	    ypall_callback cb;
+	    // wild cast to support K&R-style system headers
+	    (WildCast &) cb.foreach = (WildCast) foreach;
+	    cb.data = (char *) printers;
+	    err = _ypAll( domain, printersConfByname, &cb );
+	}
+	if ( !err )
+	    return Success;
+    }
+    return Unavail;
+}
+
+#endif // QT_NO_NIS
+
+static char *parseNsswitchPrintersEntry( QListView * printers, char *line )
+{
+#define skipSpaces() \
+    while ( isspace((uchar) line[k]) ) \
+	k++
+
+    char *defaultPrinter = 0;
+    bool stop = FALSE;
+    int lastStatus = NotFound;
+
+    int k = 8;
+    skipSpaces();
+    if ( line[k] != ':' )
+	return 0;
+    k++;
+
+    char *cp = strchr( line, '#' );
+    if ( cp != 0 )
+	*cp = '\0';
+
+    while ( line[k] != '\0' ) {
+	if ( isspace((uchar) line[k]) ) {
+	    k++;
+	} else if ( line[k] == '[' ) {
+	    k++;
+	    skipSpaces();
+	    while ( line[k] != '\0' ) {
+		char status = tolower( line[k] );
+		char action = '?';
+
+		while ( line[k] != '=' && line[k] != ']' &&
+			line[k] != '\0' )
+		    k++;
+		if ( line[k] == '=' ) {
+		    k++;
+		    skipSpaces();
+		    action = tolower( line[k] );
+		    while ( line[k] != '\0' && !isspace((uchar) line[k]) && line[k] != ']' )
+			k++;
+		} else if ( line[k] == ']' ) {
+		    k++;
+		    break;
+		}
+		skipSpaces();
+
+		if ( lastStatus == status )
+		    stop = ( action == (char) Return );
+	    }
+	} else {
+	    if ( stop )
+		break;
+
+	    QCString source;
+	    while ( line[k] != '\0' && !isspace((uchar) line[k]) && line[k] != '[' ) {
+		source += line[k];
+		k++;
+	    }
+
+	    if ( source == "user" ) {
+		lastStatus = parsePrintcap( printers,
+			QDir::homeDirPath() + "/.printers" );
+	    } else if ( source == "files" ) {
+		bool found;
+		defaultPrinter = parsePrintersConf( printers, &found );
+		if ( found )
+		    lastStatus = Success;
+#ifndef QT_NO_NIS
+	    } else if ( source == "nis" ) {
+		lastStatus = retrieveNisPrinters( printers );
+#endif
+	    } else {
+		// nisplus, dns, etc., are not implemented yet
+		lastStatus = NotFound;
+	    }
+	    stop = ( lastStatus == Success );
+	}
+    }
+    return defaultPrinter;
+}
+
+static char *parseNsswitchConf( QListView * printers )
+{
+    QFile nc( QString::fromLatin1("/etc/nsswitch.conf") );
+    if ( !nc.open(IO_ReadOnly) )
+	return 0;
+
+    char *defaultPrinter = 0;
+
+    char *line = new char[1025];
+    line[1024] = '\0';
+
+    while ( !nc.atEnd() &&
+	    nc.readLine(line, 1024) > 0 ) {
+	if ( strncmp(line, "printers", 8) == 0 ) {
+	    defaultPrinter = parseNsswitchPrintersEntry( printers, line );
+	    delete[] line;
+	    return defaultPrinter;
+	}
+    }
+
+    strcpy( line, "printers: user files nis nisplus xfn" );
+    defaultPrinter = parseNsswitchPrintersEntry( printers, line );
+    delete[] line;
+    return defaultPrinter;
+}
+
+// HP-UX
+static void parseEtcLpMember( QListView * printers )
+{
+    QDir lp( QString::fromLatin1("/etc/lp/member") );
+    if ( !lp.exists() )
+	return;
+    const QFileInfoList * dirs = lp.entryInfoList();
+    if ( !dirs )
+	return;
+
+    QFileInfoListIterator it( *dirs );
+    QFileInfo *printer;
+    QString tmp;
+    while ( (printer = it.current()) != 0 ) {
+	++it;
+	// I haven't found any real documentation, so I'm guessing that
+	// since lpstat uses /etc/lp/member rather than one of the
+	// other directories, it's the one to use.  I did not find a
+	// decent way to locate aliases and remote printers.
+	if ( printer->isFile() )
+	    perhapsAddPrinter( printers, printer->fileName(),
+			       QPrintDialog::tr("unknown"),
+			       QString::fromLatin1("") );
+    }
+}
+
+// IRIX 6.x
+static void parseSpoolInterface( QListView * printers )
+{
+    QDir lp( QString::fromLatin1("/usr/spool/lp/interface") );
+    if ( !lp.exists() )
+	return;
+    const QFileInfoList * files = lp.entryInfoList();
+    if( !files )
+	return;
+
+    QFileInfoListIterator it( *files );
+    QFileInfo *printer;
+    while ( (printer = it.current()) != 0) {
+	++it;
+
+	if ( !printer->isFile() )
+	    continue;
+
+	// parse out some information
+	QFile configFile( printer->filePath() );
+	if ( !configFile.open( IO_ReadOnly ) )
+	    continue;
+
+	QCString line( 1025 );
+	QString namePrinter;
+	QString hostName;
+	QString hostPrinter;
+	QString printerType;
+
+	QString nameKey( QString::fromLatin1("NAME=") );
+	QString typeKey( QString::fromLatin1("TYPE=") );
+	QString hostKey( QString::fromLatin1("HOSTNAME=") );
+	QString hostPrinterKey( QString::fromLatin1("HOSTPRINTER=") );
+
+	while ( !configFile.atEnd() &&
+		(configFile.readLine(line.data(), 1024)) > 0 ) {
+	    QString uline = line;
+	    if ( uline.startsWith( typeKey )  ) {
+		printerType = line.mid( nameKey.length() );
+		printerType = printerType.simplifyWhiteSpace();
+	    } else if ( uline.startsWith( hostKey ) ) {
+		hostName = line.mid( hostKey.length() );
+		hostName = hostName.simplifyWhiteSpace();
+	    } else if ( uline.startsWith( hostPrinterKey ) ) {
+		hostPrinter = line.mid( hostPrinterKey.length() );
+		hostPrinter = hostPrinter.simplifyWhiteSpace();
+	    } else if ( uline.startsWith( nameKey ) ) {
+		namePrinter = line.mid( nameKey.length() );
+		namePrinter = namePrinter.simplifyWhiteSpace();
+	    }
+	}
+	configFile.close();
+
+	printerType = printerType.stripWhiteSpace();
+	if ( printerType.find("postscript", 0, FALSE) < 0 )
+	    continue;
+
+	int ii = 0;
+	while ( (ii = namePrinter.find('"', ii)) >= 0 )
+	    namePrinter.remove( ii, 1 );
+
+	if ( hostName.isEmpty() || hostPrinter.isEmpty() ) {
+	    perhapsAddPrinter( printers, printer->fileName(),
+			       QString::fromLatin1(""), namePrinter );
+	} else {
+	    QString comment;
+	    comment = namePrinter;
+	    comment += " (";
+	    comment += hostPrinter;
+	    comment += ")";
+	    perhapsAddPrinter( printers, printer->fileName(),
+			       hostName, comment );
+	}
+    }
+}
+
+
+// Every unix must have its own.  It's a standard.  Here is AIX.
+static void parseQconfig( QListView * printers )
+{
+    QFile qconfig( QString::fromLatin1("/etc/qconfig") );
+    if ( !qconfig.open( IO_ReadOnly ) )
+	return;
+
+    QTextStream ts( &qconfig );
+    QString line;
+
+    QString stanzaName; // either a queue or a device name
+    bool up = TRUE; // queue up?  default TRUE, can be FALSE
+    QString remoteHost; // null if local
+    QString deviceName; // null if remote
+
+    QRegExp newStanza( QString::fromLatin1("^[0-z\\-]+:$") );
+
+    // our basic strategy here is to process each line, detecting new
+    // stanzas.  each time we see a new stanza, we check if the
+    // previous stanza was a valid queue for a) a remote printer or b)
+    // a local printer.  if it wasn't, we assume that what we see is
+    // the start of the first stanza, or that the previous stanza was
+    // a device stanza, or that there is some syntax error (we don't
+    // report those).
+
+    do {
+	line = ts.readLine();
+	bool indented = line[0].isSpace();
+	line = line.simplifyWhiteSpace();
+
+        int i = line.find('=');
+        if ( indented && i != -1 ) { // line in stanza
+	    QString variable = line.left( i ).simplifyWhiteSpace();
+	    QString value=line.mid( i+1, line.length() ).simplifyWhiteSpace();
+	    if ( variable == QString::fromLatin1("device") )
+		deviceName = value;
+	    else if ( variable == QString::fromLatin1("host") )
+		remoteHost = value;
+	    else if ( variable == QString::fromLatin1("up") )
+		up = !(value.lower() == QString::fromLatin1("false"));
+	} else if ( line[0] == '*' ) { // comment
+	    // nothing to do
+	} else if ( ts.atEnd() || // end of file, or beginning of new stanza
+		    ( !indented && line.find( newStanza ) != -1 ) ) {
+	    if ( up && stanzaName.length() > 0 && stanzaName.length() < 21 ) {
+		if ( remoteHost.length() ) // remote printer
+		    perhapsAddPrinter( printers, stanzaName, remoteHost,
+                                       QString::null );
+		else if ( deviceName.length() ) // local printer
+		    perhapsAddPrinter( printers, stanzaName, QString::null,
+                                       QString::null );
+	    }
+	    line.truncate( line.length()-1 );
+	    if ( line.length() >= 1 && line.length() <= 20 )
+		stanzaName = line;
+	    up = TRUE;
+	    remoteHost = QString::null;
+	    deviceName = QString::null;
+	} else {
+	    // syntax error?  ignore.
+	}
+    } while ( !ts.atEnd() );
+}
+
+
+#ifndef QT_NO_CUPS
+#include <cups/cups.h>
+
+static char * parseCupsOutput( QListView * printers )
+{
+    char * defaultPrinter = 0;
+    int nd;
+    cups_dest_t * d;
+    QLibrary lib( "cups" );
+    typedef int (*CupsGetDests)(cups_dest_t **dests);
+    CupsGetDests _cupsGetDests = (CupsGetDests)lib.resolve( "cupsGetDests" );
+    if ( _cupsGetDests ) {
+	nd = _cupsGetDests( &d );
+	if ( nd < 1 )
+	    return 0;
+
+	int n = 0;
+	while ( n < nd ) {
+	    perhapsAddPrinter( printers, d[n].name,
+			       QPrintDialog::tr("Unknown Location"), 0 );
+	    if ( d[n].is_default && !defaultPrinter )
+		defaultPrinter = qstrdup( d[n].instance );
+	    n++;
+	}
+    }
+    return defaultPrinter;
+}
+#endif
+
+static QPrintDialog * globalPrintDialog = 0;
+
+static void qpd_cleanup_globaldialog()
+{
+    if ( globalPrintDialog != 0 )
+	delete globalPrintDialog;
+    globalPrintDialog = 0;
+}
+
+/*!
+  \class QPrintDialog qprintdialog.h
+
+  \brief The QPrintDialog class provides a dialog for specifying
+  the printer's configuration.
+
+  \internal
+
+  \warning The use of this class is not recommended since it is not
+  present on all platforms; use QPrinter::setup() instead.
+
+  \omit
+
+  (ingroup dialogs)
+
+  THIS DOCUMENTATION IS Not Revised. It must be revised before
+  becoming public API.
+
+  It encompasses both the sort of details needed for doing a simple
+  print-out and some print configuration setup.
+
+  The easiest way to use the class is through the static
+  function getPrinterSetup().  You can also subclass the QPrintDialog
+  and add some custom buttons with addButton() to extend the
+  functionality of the print dialog.
+
+  <img src="qprintdlg-m.png"><br clear=all>
+  The printer dialog, on a large screen, in Motif style.
+*/
+
+
+/*! Constructs a new modal printer dialog that configures \a prn and is a
+  child of \a parent named \a name.
+*/
+
+QPrintDialog::QPrintDialog( QPrinter *prn, QWidget *parent, const char *name )
+    : QDialog( parent, name, TRUE )
+{
+    d = new QPrintDialogPrivate;
+    d->numCopies = 1;
+
+    QBoxLayout * tll = new QBoxLayout( this, QBoxLayout::Down, 12, 0 );
+
+    // destination
+    QGroupBox * g;
+    g = setupDestination();
+    tll->addWidget( g, 1 );
+
+    tll->addSpacing( 12 );
+
+    // printer and paper settings
+    QBoxLayout * lay = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( lay );
+
+    g = setupPrinterSettings();
+    lay->addWidget( g, 1 );
+
+    lay->addSpacing( 12 );
+
+    g = setupPaper();
+    lay->addWidget( g );
+
+    tll->addSpacing( 12 );
+
+    // options
+    g = setupOptions();
+    tll->addWidget( g );
+    tll->addSpacing( 12 );
+
+    QBoxLayout *l = new QBoxLayout( QBoxLayout::LeftToRight );
+    d->customLayout = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( l );
+    l->addLayout( d->customLayout );
+    l->addStretch();
+    tll->addSpacing( 12 );
+
+    // buttons
+    QBoxLayout *horiz = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( horiz );
+
+    bool rightalign =
+	bool(style().styleHint(QStyle::SH_PrintDialog_RightAlignButtons, this));
+
+    if (rightalign)
+	horiz->addStretch( 1 );
+
+    d->ok = new QPushButton( this, "ok" );
+    d->ok->setText( tr("OK") );
+    d->ok->setDefault( TRUE );
+    horiz->addWidget( d->ok );
+    if (! rightalign)
+	horiz->addStretch( 1 );
+    horiz->addSpacing( 6 );
+
+    QPushButton * cancel = new QPushButton( this, "cancel" );
+    cancel->setText( tr("Cancel") );
+    horiz->addWidget( cancel );
+
+    QSize s1 = d->ok->sizeHint();
+    QSize s2 = cancel->sizeHint();
+    s1 = QSize( QMAX(s1.width(), s2.width()),
+		QMAX(s1.height(), s2.height()) );
+
+    d->ok->setFixedSize( s1 );
+    cancel->setFixedSize( s1 );
+
+    tll->activate();
+
+    connect( d->ok, SIGNAL(clicked()), SLOT(okClicked()) );
+    connect( cancel, SIGNAL(clicked()), SLOT(reject()) );
+
+    QSize ms( minimumSize() );
+    QSize ss( QApplication::desktop()->screenGeometry( pos() ).size() );
+    if ( ms.height() < 512 && ss.height() >= 600 )
+	ms.setHeight( 512 );
+    else if ( ms.height() < 460 && ss.height() >= 480 )
+	ms.setHeight( 460 );
+    resize( ms );
+
+    setPrinter( prn, TRUE );
+    d->printers->setFocus();
+}
+
+
+/*! Destroys the object and frees any allocated resources.  Does not
+  delete the associated QPrinter object.
+*/
+
+QPrintDialog::~QPrintDialog()
+{
+    if ( this == globalPrintDialog )
+	globalPrintDialog = 0;
+    delete d;
+}
+
+/*!
+  This method allows you to specify a global print dialog, given in \a
+  pd, that will be used instead of the default dialog provided by Qt.
+
+  This is useful, since there are many different printing systems on
+  Unix, and we cannot support all of them. Calling this method before
+  using a printer for the first time allows you to set up your own
+  print dialog.
+
+  \sa setupPrinters()
+*/
+void QPrintDialog::setGlobalPrintDialog( QPrintDialog *pd )
+{
+    QPrintDialog *oldPd = globalPrintDialog;
+    globalPrintDialog = pd;
+    if ( oldPd )
+	delete oldPd;
+    else
+	qAddPostRoutine( qpd_cleanup_globaldialog );
+    globalPrintDialog->adjustSize();
+}
+
+QGroupBox * QPrintDialog::setupPrinterSettings()
+{
+    QGroupBox * g = new QGroupBox( 1, Horizontal, tr( "Printer settings"),
+				   this, "settings group box" );
+
+    d->colorMode = new QButtonGroup( this );
+    d->colorMode->hide();
+    connect( d->colorMode, SIGNAL(clicked(int)),
+	     this, SLOT(colorModeSelected(int)) );
+
+    QRadioButton *rb;
+    rb = new QRadioButton( tr( "Print in color if available" ),
+			   g, "color" );
+    d->colorMode->insert( rb, QPrinter::Color );
+    rb->setChecked( TRUE );
+
+    rb = new QRadioButton( tr("Print in grayscale"),
+			   g, "graysacle" );
+    d->colorMode->insert( rb, QPrinter::GrayScale );
+
+    return g;
+}
+
+QGroupBox * QPrintDialog::setupDestination()
+{
+    QGroupBox * g = new QGroupBox( 0, Horizontal, tr( "Print destination"),
+				   this, "destination group box" );
+
+    QBoxLayout * tll = new QBoxLayout( g->layout(), QBoxLayout::Down );
+
+    d->printerOrFile = new QButtonGroup( this );
+    d->printerOrFile->hide();
+    connect( d->printerOrFile, SIGNAL(clicked(int)),
+	     this, SLOT(printerOrFileSelected(int)) );
+
+    // printer radio button, list
+    QRadioButton * rb = new QRadioButton( tr( "Print to printer:" ), g,
+					  "printer" );
+    tll->addWidget( rb );
+    d->printerOrFile->insert( rb, 0 );
+    rb->setChecked( TRUE );
+    d->outputToFile = FALSE;
+
+    QBoxLayout * horiz = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( horiz, 3 );
+    horiz->addSpacing( 19 );
+
+    d->printers = new QListView( g, "list of printers" );
+    d->printers->setAllColumnsShowFocus( TRUE );
+    d->printers->addColumn( tr("Printer"), 125 );
+    d->printers->addColumn( tr("Host"), 125 );
+    d->printers->addColumn( tr("Comment"), 150 );
+
+#if defined(Q_OS_UNIX)
+    char * etcLpDefault = 0;
+
+#ifndef QT_NO_CUPS
+    etcLpDefault = parseCupsOutput( d->printers );
+#endif
+    if ( d->printers->childCount() == 0 ) {
+	// we only use other schemes when cups fails.
+
+	parsePrintcap( d->printers, QString::fromLatin1("/etc/printcap") );
+	parseEtcLpMember( d->printers );
+	parseSpoolInterface( d->printers );
+	parseQconfig( d->printers );
+	if ( addPrinterHook )
+	    (*addPrinterHook)( d->printers );
+
+	QFileInfo f;
+	f.setFile( QString::fromLatin1("/etc/lp/printers") );
+	if ( f.isDir() ) {
+	    parseEtcLpPrinters( d->printers );
+	    QFile def( QString::fromLatin1("/etc/lp/default") );
+	    if ( def.open( IO_ReadOnly ) ) {
+		if ( etcLpDefault )
+		    delete[] etcLpDefault;
+		etcLpDefault = new char[1025];
+		def.readLine( etcLpDefault, 1024 );
+		char * p = etcLpDefault;
+		while ( p && *p ) {
+		    if ( !isprint((uchar) *p) || isspace((uchar) *p) )
+			*p = 0;
+		    else
+			p++;
+		}
+	    }
+	}
+
+	char * def = 0;
+	f.setFile( QString::fromLatin1("/etc/nsswitch.conf") );
+	if ( f.isFile() ) {
+	    def = parseNsswitchConf( d->printers );
+	} else {
+	    f.setFile( QString::fromLatin1("/etc/printers.conf") );
+	    if ( f.isFile() )
+		def = parsePrintersConf( d->printers );
+	}
+
+	if ( def ) {
+	    if ( etcLpDefault )
+		delete[] etcLpDefault;
+	    etcLpDefault = def;
+	}
+    }
+
+    // all printers hopefully known.  try to find a good default
+    QString dollarPrinter;
+    {
+	const char * t = getenv( "PRINTER" );
+	if ( !t || !*t )
+	    t = getenv( "LPDEST" );
+	dollarPrinter = QString::fromLatin1( t );
+	if ( !dollarPrinter.isEmpty() )
+	    perhapsAddPrinter( d->printers, dollarPrinter,
+			       QPrintDialog::tr("unknown"),
+			       QString::fromLatin1("") );
+    }
+    int quality = 0;
+
+    // bang the best default into the listview
+    const QListViewItem * lvi = d->printers->firstChild();
+    d->printers->setCurrentItem( (QListViewItem *)lvi );
+    while ( lvi ) {
+	QRegExp ps( QString::fromLatin1("[^a-z]ps(?:[^a-z]|$)") );
+	QRegExp lp( QString::fromLatin1("[^a-z]lp(?:[^a-z]|$)") );
+
+	if ( quality < 4 && lvi->text(0) == dollarPrinter ) {
+	    d->printers->setCurrentItem( (QListViewItem *)lvi );
+	    quality = 4;
+	} else if ( quality < 3 && etcLpDefault &&
+		    lvi->text(0) == QString::fromLatin1(etcLpDefault) ) {
+	    d->printers->setCurrentItem( (QListViewItem *)lvi );
+	    quality = 3;
+	} else if ( quality < 2 &&
+		    ( lvi->text(0) == QString::fromLatin1("ps") ||
+		      ps.search(lvi->text(2)) != -1 ) ) {
+	    d->printers->setCurrentItem( (QListViewItem *)lvi );
+	    quality = 2;
+	} else if ( quality < 1 &&
+		    ( lvi->text(0) == QString::fromLatin1("lp") ||
+		      lp.search(lvi->text(2)) > -1 ) ) {
+	    d->printers->setCurrentItem( (QListViewItem *)lvi );
+	    quality = 1;
+	}
+	lvi = lvi->nextSibling();
+    }
+
+    if ( d->printers->currentItem() )
+	d->printers->setSelected( d->printers->currentItem(), TRUE );
+
+    if ( etcLpDefault )                 // Avoid purify complaint
+	delete[] etcLpDefault;
+#endif
+
+    int h = fontMetrics().height();
+    if ( d->printers->firstChild() )
+	h = d->printers->firstChild()->height();
+    d->printers->setMinimumSize( d->printers->sizeHint().width(),
+				 d->printers->header()->height() +
+				 3 * h );
+    horiz->addWidget( d->printers, 3 );
+
+    tll->addSpacing( 6 );
+
+    // file radio button, edit/browse
+    d->printToFileButton = new QRadioButton( tr( "Print to file:" ), g, "file" );
+    tll->addWidget( d->printToFileButton );
+    d->printerOrFile->insert( d->printToFileButton, 1 );
+
+    horiz = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( horiz );
+    horiz->addSpacing( 19 );
+
+    d->fileName = new QLineEdit( g, "file name" );
+    connect( d->fileName, SIGNAL( textChanged(const QString&) ),
+	     this, SLOT( fileNameEditChanged(const QString&) ) );
+    horiz->addWidget( d->fileName, 1 );
+    horiz->addSpacing( 6 );
+    d->browse = new QPushButton( tr("Browse..."), g, "browse files" );
+    d->browse->setAutoDefault( FALSE );
+#ifdef QT_NO_FILEDIALOG
+    d->browse->setEnabled( FALSE );
+#endif
+    connect( d->browse, SIGNAL(clicked()),
+	     this, SLOT(browseClicked()) );
+    horiz->addWidget( d->browse );
+
+    d->fileName->setEnabled( FALSE );
+    d->browse->setEnabled( FALSE );
+
+    tll->activate();
+
+    return g;
+}
+
+
+QGroupBox * QPrintDialog::setupOptions()
+{
+    QGroupBox * g = new QGroupBox( 0, Horizontal, tr( "Options"),
+				   this, "options group box" );
+
+    QBoxLayout * tll = new QBoxLayout( g->layout(), QBoxLayout::Down );
+
+    QBoxLayout *lay = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( lay );
+
+    tll = new QBoxLayout( lay, QBoxLayout::Down );
+
+    d->printRange = new QButtonGroup( this );
+    d->printRange->hide();
+    connect( d->printRange, SIGNAL(clicked(int)),
+	     this, SLOT(printRangeSelected(int)) );
+
+    d->pageOrder = new QButtonGroup( this );
+    d->pageOrder->hide();
+    connect( d->pageOrder, SIGNAL(clicked(int)),
+	     this, SLOT(pageOrderSelected(int)) );
+
+    d->printAllButton = new QRadioButton( tr("Print all"), g, "print all" );
+    d->printRange->insert( d->printAllButton, 0 );
+    tll->addWidget( d->printAllButton );
+
+    d->printSelectionButton = new QRadioButton( tr("Print selection"),
+						g, "print selection" );
+    d->printRange->insert( d->printSelectionButton, 1 );
+    tll->addWidget( d->printSelectionButton );
+
+    d->printRangeButton = new QRadioButton( tr("Print range"),
+					    g, "print range" );
+    d->printRange->insert( d->printRangeButton, 2 );
+    tll->addWidget( d->printRangeButton );
+
+    QBoxLayout * horiz = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( horiz );
+
+    d->firstPageLabel = new QLabel( tr("From page:"), g, "first page" );
+    horiz->addSpacing( 19 );
+    horiz->addWidget( d->firstPageLabel );
+
+    d->firstPage = new QPrintDialogSpinBox( 1, 9999, 1, g, "first page" );
+    d->firstPage->setValue( 1 );
+    horiz->addWidget( d->firstPage, 1 );
+    connect( d->firstPage, SIGNAL(valueChanged(int)),
+	     this, SLOT(setFirstPage(int)) );
+
+    horiz = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( horiz );
+
+    d->lastPageLabel = new QLabel( tr("To page:"), g, "last page" );
+    horiz->addSpacing( 19 );
+    horiz->addWidget( d->lastPageLabel );
+
+    d->lastPage = new QPrintDialogSpinBox( 1, 9999, 1, g, "last page" );
+    d->lastPage->setValue( 9999 );
+    horiz->addWidget( d->lastPage, 1 );
+    connect( d->lastPage, SIGNAL(valueChanged(int)),
+	     this, SLOT(setLastPage(int)) );
+
+    lay->addSpacing( 25 );
+    tll = new QBoxLayout( lay, QBoxLayout::Down );
+
+    // print order
+    QRadioButton * rb = new QRadioButton( tr("Print first page first"),
+					  g, "first page first" );
+    tll->addWidget( rb );
+    d->pageOrder->insert( rb, QPrinter::FirstPageFirst );
+    rb->setChecked( TRUE );
+
+    rb = new QRadioButton( tr("Print last page first"),
+			   g, "last page first" );
+    tll->addWidget( rb );
+    d->pageOrder->insert( rb, QPrinter::LastPageFirst );
+
+    tll->addStretch();
+
+    // copies
+
+    horiz = new QBoxLayout( QBoxLayout::LeftToRight );
+    tll->addLayout( horiz );
+
+    QLabel * l = new QLabel( tr("Number of copies:"), g, "Number of copies" );
+    horiz->addWidget( l );
+
+    d->copies = new QPrintDialogSpinBox( 1, 99, 1, g, "copies" );
+    d->copies->setValue( 1 );
+    horiz->addWidget( d->copies, 1 );
+    connect( d->copies, SIGNAL(valueChanged(int)),
+	     this, SLOT(setNumCopies(int)) );
+
+    QSize s = d->firstPageLabel->sizeHint()
+	      .expandedTo( d->lastPageLabel->sizeHint() )
+	      .expandedTo( l->sizeHint() );
+    d->firstPageLabel->setMinimumSize( s );
+    d->lastPageLabel->setMinimumSize( s );
+    l->setMinimumSize( s.width() + 19, s.height() );
+
+    tll->activate();
+
+    return g;
+}
+
+
+void isc( QPrintDialogPrivate * d,
+	  const QString & text,
+	  QPrinter::PageSize ps )
+{
+    if ( d && text && ps < QPrinter::NPageSize ) {
+	d->sizeCombo->insertItem( text, -1 );
+	int index = d->sizeCombo->count()-1;
+	if ( index >= 0 && index < QPrinter::NPageSize )
+	    d->indexToPageSize[index] = ps;
+    }
+}
+
+QGroupBox * QPrintDialog::setupPaper()
+{
+    QGroupBox * g = new QGroupBox( 1, Horizontal, tr( "Paper format"),
+				   this, "Paper format" );
+    d->pageSize = QPrinter::A4;
+
+    // page orientation
+    d->orientationCombo = new QComboBox( FALSE, g );
+    d->orientationCombo->insertItem( tr( "Portrait" ), -1 );
+    d->orientationCombo->insertItem( tr( "Landscape" ), -1 );
+
+    d->orientation = QPrinter::Portrait;
+
+    g->addSpace( 8 );
+
+    connect( d->orientationCombo, SIGNAL( activated(int) ),
+	     this, SLOT( orientSelected(int) ) );
+
+    // paper size
+    d->sizeCombo = new QComboBox( FALSE, g );
+
+    int n;
+    for( n=0; n<QPrinter::NPageSize; n++ )
+	d->indexToPageSize[n] = QPrinter::A4;
+
+    isc( d, tr( "A0 (841 x 1189 mm)" ), QPrinter::A0 );
+    isc( d, tr( "A1 (594 x 841 mm)" ), QPrinter::A1 );
+    isc( d, tr( "A2 (420 x 594 mm)" ), QPrinter::A2 );
+    isc( d, tr( "A3 (297 x 420 mm)" ), QPrinter::A3 );
+    isc( d, tr( "A4 (210x297 mm, 8.26x11.7 inches)" ), QPrinter::A4 );
+    isc( d, tr( "A5 (148 x 210 mm)" ), QPrinter::A5 );
+    isc( d, tr( "A6 (105 x 148 mm)" ), QPrinter::A6 );
+    isc( d, tr( "A7 (74 x 105 mm)" ), QPrinter::A7 );
+    isc( d, tr( "A8 (52 x 74 mm)" ), QPrinter::A8 );
+    isc( d, tr( "A9 (37 x 52 mm)" ), QPrinter::A9 );
+    isc( d, tr( "B0 (1000 x 1414 mm)" ), QPrinter::B0 );
+    isc( d, tr( "B1 (707 x 1000 mm)" ), QPrinter::B1 );
+    isc( d, tr( "B2 (500 x 707 mm)" ), QPrinter::B2 );
+    isc( d, tr( "B3 (353 x 500 mm)" ), QPrinter::B3 );
+    isc( d, tr( "B4 (250 x 353 mm)" ), QPrinter::B4 );
+    isc( d, tr( "B5 (176 x 250 mm, 6.93x9.84 inches)" ), QPrinter::B5 );
+    isc( d, tr( "B6 (125 x 176 mm)" ), QPrinter::B6 );
+    isc( d, tr( "B7 (88 x 125 mm)" ), QPrinter::B7 );
+    isc( d, tr( "B8 (62 x 88 mm)" ), QPrinter::B8 );
+    isc( d, tr( "B9 (44 x 62 mm)" ), QPrinter::B9 );
+    isc( d, tr( "B10 (31 x 44 mm)" ), QPrinter::B10 );
+    isc( d, tr( "C5E (163 x 229 mm)" ), QPrinter::C5E );
+    isc( d, tr( "DLE (110 x 220 mm)" ), QPrinter::DLE );
+    isc( d, tr( "Executive (7.5x10 inches, 191x254 mm)" ), QPrinter::Executive );
+    isc( d, tr( "Folio (210 x 330 mm)" ), QPrinter::Folio );
+    isc( d, tr( "Ledger (432 x 279 mm)" ), QPrinter::Ledger );
+    isc( d, tr( "Legal (8.5x14 inches, 216x356 mm)" ), QPrinter::Legal );
+    isc( d, tr( "Letter (8.5x11 inches, 216x279 mm)" ), QPrinter::Letter );
+    isc( d, tr( "Tabloid (279 x 432 mm)" ), QPrinter::Tabloid );
+    isc( d, tr( "US Common #10 Envelope (105 x 241 mm)" ), QPrinter::Comm10E );
+
+    connect( d->sizeCombo, SIGNAL( activated(int) ),
+	     this, SLOT( paperSizeSelected(int) ) );
+
+    return g;
+}
+
+
+/*!
+  Display a dialog and allow the user to configure the QPrinter \a
+  p for an optional widget \a w. Returns TRUE if the user clicks OK or
+  presses Enter, FALSE if the user clicks Cancel or presses Esc.
+
+  getPrinterSetup() remembers the settings and provides the same
+  settings the next time the dialog is shown.
+*/
+
+bool QPrintDialog::getPrinterSetup( QPrinter * p, QWidget* w  )
+{
+    if ( !globalPrintDialog ) {
+	globalPrintDialog = new QPrintDialog( 0, 0, "global print dialog" );
+#ifndef QT_NO_WIDGET_TOPEXTRA
+	globalPrintDialog->setCaption( QPrintDialog::tr( "Setup Printer" ) );
+#endif
+	qAddPostRoutine( qpd_cleanup_globaldialog );
+	globalPrintDialog->setPrinter( p, TRUE );
+	globalPrintDialog->adjustSize();
+    } else {
+	globalPrintDialog->setPrinter( p, TRUE );
+    }
+    globalPrintDialog->adjustPosition( w );
+ #ifndef QT_NO_WIDGET_TOPEXTRA
+    if ( w ) {
+	const QPixmap *pm = w->icon();
+	if ( pm && !pm->isNull() )
+	    globalPrintDialog->setIcon( *pm );
+	else {
+	    w = w ? w->topLevelWidget() : 0;
+	    pm = w ? w->icon() : 0;
+	    if ( pm && !pm->isNull() )
+		globalPrintDialog->setIcon( *pm );
+	}
+    }
+#endif
+    bool r = globalPrintDialog->exec() == QDialog::Accepted;
+    globalPrintDialog->setPrinter( 0 );
+    return r;
+}
+
+
+void QPrintDialog::printerOrFileSelected( int id )
+{
+    d->outputToFile = id ? TRUE : FALSE;
+    if ( d->outputToFile ) {
+	d->ok->setEnabled( TRUE );
+	fileNameEditChanged( d->fileName->text() );
+	if ( !d->fileName->edited() && d->fileName->text().isEmpty() ) {
+	    QString home = QString::fromLatin1( ::getenv( "HOME" ) );
+	    QString cur = QDir::currentDirPath();
+	    if ( home.at(home.length()-1) != '/' )
+		home += '/';
+	    if ( cur.at(cur.length()-1) != '/' )
+		cur += '/';
+	    if ( cur.left( home.length() ) != home )
+		cur = home;
+#ifdef Q_WS_X11
+	    cur += "print.ps";
+#endif
+	    d->fileName->setText( cur );
+	    d->fileName->setCursorPosition( cur.length() );
+	    d->fileName->selectAll();
+	}
+	d->browse->setEnabled( TRUE );
+	d->fileName->setEnabled( TRUE );
+	d->fileName->setFocus();
+	d->printers->setEnabled( FALSE );
+    } else {
+	d->ok->setEnabled( d->printers->childCount() != 0 );
+	d->printers->setEnabled( TRUE );
+	if ( d->fileName->hasFocus() || d->browse->hasFocus() )
+	    d->printers->setFocus();
+	d->browse->setEnabled( FALSE );
+	d->fileName->setEnabled( FALSE );
+    }
+}
+
+
+void QPrintDialog::landscapeSelected( int id )
+{
+    d->orientation = (QPrinter::Orientation)id;
+}
+
+
+void QPrintDialog::paperSizeSelected( int id )
+{
+    if ( id < QPrinter::NPageSize )
+	d->pageSize = QPrinter::PageSize( d->indexToPageSize[id] );
+}
+
+
+void QPrintDialog::orientSelected( int id )
+{
+    d->orientation = (QPrinter::Orientation)id;
+}
+
+
+void QPrintDialog::pageOrderSelected( int id )
+{
+    d->pageOrder2 = (QPrinter::PageOrder)id;
+}
+
+
+void QPrintDialog::setNumCopies( int copies )
+{
+    d->numCopies = copies;
+}
+
+
+void QPrintDialog::browseClicked()
+{
+#ifndef QT_NO_FILEDIALOG
+    QString fn = QFileDialog::getSaveFileName( d->fileName->text(), tr( "PostScript Files (*.ps);;All Files (*)" ), this );
+    if ( !fn.isNull() )
+	d->fileName->setText( fn );
+#endif
+}
+
+
+void QPrintDialog::okClicked()
+{
+    d->lastPage->interpretText();
+    d->firstPage->interpretText();
+    d->copies->interpretText();
+    if ( d->outputToFile ) {
+	d->printer->setOutputToFile( TRUE );
+	d->printer->setOutputFileName( d->fileName->text() );
+    } else {
+	d->printer->setOutputToFile( FALSE );
+	QListViewItem * l = d->printers->currentItem();
+	if ( l )
+	    d->printer->setPrinterName( l->text( 0 ) );
+    }
+
+    d->printer->setOrientation( d->orientation );
+    d->printer->setPageSize( d->pageSize );
+    d->printer->setPageOrder( d->pageOrder2 );
+    d->printer->setColorMode( d->colorMode2 );
+    d->printer->setNumCopies( d->numCopies );
+    if ( d->printAllButton->isChecked() ) {
+	d->printer->setPrintRange(QPrinter::AllPages);
+	d->printer->setFromTo( d->printer->minPage(), d->printer->maxPage() );
+    } else {
+	if (d->printSelectionButton->isChecked())
+	    d->printer->setPrintRange(QPrinter::Selection);
+	else
+	    d->printer->setPrintRange(QPrinter::PageRange);
+	d->printer->setFromTo( d->firstPage->value(), d->lastPage->value() );
+    }
+
+    accept();
+}
+
+
+void QPrintDialog::printRangeSelected( int id )
+{
+    bool enable = id == 2 ? TRUE : FALSE;
+    d->firstPage->setEnabled( enable );
+    d->lastPage->setEnabled( enable );
+    d->firstPageLabel->setEnabled( enable );
+    d->lastPageLabel->setEnabled( enable );
+}
+
+
+void QPrintDialog::setFirstPage( int fp )
+{
+    if ( d->printer )
+	d->lastPage->setRange( fp, QMAX(fp, QPrintDialog::d->printer->maxPage()) );
+}
+
+
+void QPrintDialog::setLastPage( int lp )
+{
+    if ( d->printer )
+	d->firstPage->setRange( QMIN(lp, QPrintDialog::d->printer->minPage()), lp );
+}
+
+
+/*!
+  Sets this dialog to configure printer \a p, or no printer if \a p
+  is null. If \a pickUpSettings is TRUE, the dialog reads most of
+  its settings from \a p. If \a pickUpSettings is FALSE (the
+  default) the dialog keeps its old settings.
+*/
+
+void QPrintDialog::setPrinter( QPrinter * p, bool pickUpSettings )
+{
+    d->printer = p;
+
+    if ( p && pickUpSettings ) {
+	// top to botton in the old dialog.
+	// printer or file
+	d->printerOrFile->setButton( p->outputToFile() );
+	printerOrFileSelected( p->outputToFile() );
+
+	// printer name
+	if ( !!p->printerName() ) {
+	    QListViewItem * i = d->printers->firstChild();
+	    while ( i && i->text( 0 ) != p->printerName() )
+		i = i->nextSibling();
+	    if ( i ) {
+		d->printers->setSelected( i, TRUE );
+		d->ok->setEnabled( TRUE );
+	    } else if ( d->fileName->text().isEmpty() ) {
+		d->ok->setEnabled( d->printers->childCount() != 0 );
+	    }
+	}
+
+	// print command does not exist any more
+
+	// file name
+	d->printToFileButton->setEnabled( d->printer->isOptionEnabled( QPrinter::PrintToFile ) );
+	d->fileName->setText( p->outputFileName() );
+
+	// orientation
+	d->orientationCombo->setCurrentItem( (int)p->orientation() );
+	orientSelected( p->orientation() );
+
+	// page size
+	int n = 0;
+	while ( n < QPrinter::NPageSize &&
+		d->indexToPageSize[n] != p->pageSize() )
+	    n++;
+	d->sizeCombo->setCurrentItem( n );
+	paperSizeSelected( n );
+
+	// New stuff (Options)
+
+	// page order
+	d->pageOrder->setButton( (int)p->pageOrder() );
+	pageOrderSelected( p->pageOrder() );
+
+	// color mode
+	d->colorMode->setButton( (int)p->colorMode() );
+	colorModeSelected( p->colorMode() );
+
+	// number of copies
+	d->copies->setValue( p->numCopies() );
+	setNumCopies( p->numCopies() );
+    }
+
+    if( p ) {
+	d->printAllButton->setEnabled( TRUE );
+	d->printSelectionButton
+	    ->setEnabled( d->printer->isOptionEnabled( QPrinter::PrintSelection ) );
+	d->printRangeButton
+	    ->setEnabled( d->printer->isOptionEnabled( QPrinter::PrintPageRange ) );
+
+	QPrinter::PrintRange range = p->printRange();
+	switch ( range ) {
+	case QPrinter::AllPages:
+	    d->printAllButton->setChecked(TRUE);
+	    printRangeSelected( d->printRange->id( d->printAllButton ) );
+	    break;
+	case QPrinter::Selection:
+	    d->printSelectionButton->setChecked(TRUE);
+	    printRangeSelected( d->printRange->id( d->printSelectionButton ) );
+	    break;
+	case QPrinter::PageRange:
+	    d->printRangeButton->setChecked(TRUE);
+	    printRangeSelected( d->printRange->id( d->printRangeButton ) );
+	    break;
+	}
+    }
+
+    if ( p && p->maxPage() ) {
+	d->firstPage->setRange( p->minPage(), p->maxPage() );
+	d->lastPage->setRange( p->minPage(), p->maxPage() );
+	if ( p->fromPage() || p->toPage() ) {
+	    setFirstPage( p->fromPage() );
+	    setLastPage( p->toPage() );
+	    d->firstPage->setValue(p->fromPage());
+	    d->lastPage->setValue(p->toPage());
+	}
+    }
+}
+
+
+/*!  Returns a pointer to the printer this dialog configures, or 0 if
+  this dialog does not operate on any printer. */
+
+QPrinter * QPrintDialog::printer() const
+{
+    return d->printer;
+}
+
+
+void QPrintDialog::colorModeSelected( int id )
+{
+    d->colorMode2 = (QPrinter::ColorMode)id;
+}
+
+/*!
+  Adds the button \a but to the layout of the print dialog. The added
+  buttons are arranged from the left to the right below the
+  last groupbox of the printdialog.
+*/
+
+void QPrintDialog::addButton( QPushButton *but )
+{
+    d->customLayout->addWidget( but );
+}
+
+void QPrintDialog::fileNameEditChanged( const QString &text )
+{
+    if ( d->fileName->isEnabled() )
+	d->ok->setEnabled( !text.isEmpty() );
+}
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qprintdialog.h b/main/dependencies/qt3/src/dialogs/qprintdialog.h
new file mode 100644
index 000000000..ea41d0225
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qprintdialog.h
@@ -0,0 +1,103 @@
+/****************************************************************************
+**
+** Definition of print dialog.
+**
+** Created : 950829
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QPRINTDIALOG_H
+#define QPRINTDIALOG_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#endif // QT_H
+
+#ifndef QT_NO_PRINTDIALOG
+
+class QGroupBox;
+class QPrintDialogPrivate;
+class QListView;
+
+class Q_EXPORT QPrintDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    QPrintDialog( QPrinter *, QWidget* parent=0, const char* name=0 );
+    ~QPrintDialog();
+
+    static bool getPrinterSetup( QPrinter *, QWidget* = 0 );
+    static void setGlobalPrintDialog( QPrintDialog * );
+
+    void setPrinter( QPrinter *, bool = FALSE );
+    QPrinter * printer() const;
+
+    void addButton( QPushButton *but );
+
+private slots:
+    void browseClicked();
+    void okClicked();
+
+    void printerOrFileSelected( int );
+    void landscapeSelected( int );
+    void paperSizeSelected( int );
+    void orientSelected( int );
+    void pageOrderSelected( int );
+    void colorModeSelected( int );
+    void setNumCopies( int );
+    void printRangeSelected( int );
+    void setFirstPage( int );
+    void setLastPage( int );
+
+    void fileNameEditChanged( const QString &text );
+
+private:
+    QPrintDialogPrivate *d;
+
+    QGroupBox * setupDestination();
+    QGroupBox * setupOptions();
+    QGroupBox * setupPaper();
+    QGroupBox * setupPrinterSettings();
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QPrintDialog( const QPrintDialog & );
+    QPrintDialog &operator=( const QPrintDialog & );
+#endif
+};
+
+#endif
+
+#endif // QPRINTDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qprogressdialog.cpp b/main/dependencies/qt3/src/dialogs/qprogressdialog.cpp
new file mode 100644
index 000000000..bdae310a0
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qprogressdialog.cpp
@@ -0,0 +1,826 @@
+/****************************************************************************
+**
+** Implementation of QProgressDialog class
+**
+** Created : 970521
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qprogressdialog.h"
+
+#ifndef QT_NO_PROGRESSDIALOG
+
+#include "qaccel.h"
+#include "qpainter.h"
+#include "qdrawutil.h"
+#include "qdatetime.h"
+#include "qapplication.h"
+#include "qstyle.h"
+#include "qpushbutton.h"
+#include "qcursor.h"
+#include "qtimer.h"
+#include <limits.h>
+
+// If the operation is expected to take this long (as predicted by
+// progress time), show the progress dialog.
+static const int defaultShowTime    = 4000;
+// Wait at least this long before attempting to make a prediction.
+static const int minWaitTime = 50;
+
+// Various layout values
+static const int margin_lr   = 10;
+static const int margin_tb   = 10;
+static const int spacing     = 4;
+
+
+class QProgressDialogData
+{
+public:
+    QProgressDialogData( QProgressDialog* that, QWidget* parent,
+		   const QString& labelText,
+		   int totalSteps ) :
+	creator( parent ),
+	label( new QLabel(labelText,that,"label") ),
+	cancel( 0 ),
+	bar( new QProgressBar(totalSteps,that,"bar") ),
+	shown_once( FALSE ),
+	cancellation_flag( FALSE ),
+	showTime( defaultShowTime )
+    {
+	label->setAlignment(that->style().styleHint(QStyle::SH_ProgressDialog_TextLabelAlignment, that));
+    }
+
+    QWidget	 *creator;
+    QLabel	 *label;
+    QPushButton	 *cancel;
+    QProgressBar *bar;
+    bool	  shown_once;
+    bool	  cancellation_flag;
+    QTime	  starttime;
+#ifndef QT_NO_CURSOR
+    QCursor	  parentCursor;
+#endif
+    int		  showTime;
+    bool autoClose;
+    bool autoReset;
+    bool forceHide;
+};
+
+
+/*!
+  \class QProgressDialog qprogressdialog.h
+  \brief The QProgressDialog class provides feedback on the progress of a slow operation.
+  \ingroup dialogs
+  \mainclass
+
+  A progress dialog is used to give the user an indication of how long
+  an operation is going to take, and to demonstrate that the
+  application has not frozen. It can also give the user an opportunity
+  to abort the operation.
+
+  A common problem with progress dialogs is that it is difficult to know
+  when to use them; operations take different amounts of time on different
+  hardware.  QProgressDialog offers a solution to this problem:
+  it estimates the time the operation will take (based on time for
+  steps), and only shows itself if that estimate is beyond minimumDuration()
+  (4 seconds by default).
+
+  Use setTotalSteps() (or the constructor) to set the number of
+  "steps" in the operation and call setProgress() as the operation
+  progresses. The step value can be chosen arbitrarily. It can be the
+  number of files copied, the number of bytes received, the number of
+  iterations through the main loop of your algorithm, or some other
+  suitable unit.  Progress starts at 0, and the progress dialog shows
+  that the operation has finished when you call setProgress() with
+  totalSteps() as its argument.
+
+  The dialog automatically resets and hides itself at the end of the
+  operation. Use setAutoReset() and setAutoClose() to change this
+  behavior.
+
+  There are two ways of using QProgressDialog: modal and modeless.
+
+  Using a modal QProgressDialog is simpler for the programmer, but you
+  must call QApplication::processEvents() or
+  QEventLoop::processEvents(ExcludeUserInput) to keep the event loop
+  running to ensure that the application doesn't freeze. Do the
+  operation in a loop, call \l setProgress() at intervals, and check
+  for cancellation with wasCanceled(). For example:
+\code
+QProgressDialog progress( "Copying files...", "Abort Copy", numFiles,
+                          this, "progress", TRUE );
+for ( int i = 0; i < numFiles; i++ ) {
+    progress.setProgress( i );
+    qApp->processEvents();
+
+    if ( progress.wasCanceled() )
+        break;
+    //... copy one file
+}
+progress.setProgress( numFiles );
+\endcode
+
+  A modeless progress dialog is suitable for operations that take
+  place in the background, where the user is able to interact with the
+  application. Such operations are typically based on QTimer (or
+  QObject::timerEvent()), QSocketNotifier, or QUrlOperator; or performed
+  in a separate thread. A QProgressBar in the status bar of your main window
+  is often an alternative to a modeless progress dialog.
+
+  You need to have an event loop to be running, connect the
+  canceled() signal to a slot that stops the operation, and call \l
+  setProgress() at intervals. For example:
+\code
+Operation::Operation( QObject *parent = 0 )
+    : QObject( parent ), steps( 0 )
+{
+    pd = new QProgressDialog( "Operation in progress.", "Cancel", 100 );
+    connect( pd, SIGNAL(canceled()), this, SLOT(cancel()) );
+    t = new QTimer( this );
+    connect( t, SIGNAL(timeout()), this, SLOT(perform()) );
+    t->start( 0 );
+}
+
+void Operation::perform()
+{
+    pd->setProgress( steps );
+    //... perform one percent of the operation
+    steps++;
+    if ( steps > pd->totalSteps() )
+        t->stop();
+}
+
+void Operation::cancel()
+{
+    t->stop();
+    //... cleanup
+}
+\endcode
+
+
+  In both modes the progress dialog may be customized by
+  replacing the child widgets with custom widgets by using setLabel(),
+  setBar(), and setCancelButton().
+  The functions setLabelText() and setCancelButtonText()
+  set the texts shown.
+
+  <img src=qprogdlg-m.png> <img src=qprogdlg-w.png>
+
+  \sa QDialog QProgressBar
+  \link guibooks.html#fowler GUI Design Handbook: Progress Indicator\endlink
+*/
+
+
+/*!
+  Returns the QLabel currently being displayed above the progress bar.
+  This QLabel is owned by the QProgressDialog.
+
+  \sa setLabel()
+*/
+QLabel *QProgressDialog::label() const
+{
+    return d->label;
+}
+
+/*!
+  Returns the QProgressBar currently being used to display progress.
+  This QProgressBar is owned by the QProgressDialog.
+
+  \sa setBar()
+*/
+QProgressBar *QProgressDialog::bar() const
+{
+    return d->bar;
+}
+
+
+/*!
+  Constructs a progress dialog.
+
+  Default settings:
+  \list
+  \i The label text is empty.
+  \i The cancel button text is (translated) "Cancel".
+  \i The total number of steps is 100.
+  \endlist
+
+  The \a creator argument is the widget to use as the dialog's parent.
+  The \a name, \a modal, and the widget flags, \a f, are
+  passed to the QDialog::QDialog() constructor. If \a modal is FALSE (the
+  default), you must have an event loop proceeding for any redrawing
+  of the dialog to occur. If \a modal is TRUE, the dialog ensures that
+  events are processed when needed.
+
+  \sa setLabelText(), setLabel(), setCancelButtonText(), setCancelButton(),
+  setTotalSteps()
+*/
+
+QProgressDialog::QProgressDialog( QWidget *creator, const char *name,
+				  bool modal, WFlags f )
+    : QDialog( creator, name, modal, f)
+{
+    init( creator, QString::fromLatin1(""), tr("Cancel"), 100 );
+}
+
+/*!
+  Constructs a progress dialog.
+
+   The \a labelText is text used to remind the user what is progressing.
+
+   The \a cancelButtonText is the text to display on the cancel button,
+	    or 0 if no cancel button is to be shown.
+
+   The \a totalSteps is the total number of steps in the operation for
+   which this progress dialog shows progress.  For example, if the
+   operation is to examine 50 files, this value would be 50. Before
+   examining the first file, call setProgress(0). As each file is
+   processed call setProgress(1), setProgress(2), etc., finally
+   calling setProgress(50) after examining the last file.
+
+   The \a creator argument is the widget to use as the dialog's parent.
+   The \a name, \a modal, and widget flags, \a f, are passed to the
+   QDialog::QDialog() constructor. If \a modal is FALSE (the default),
+   you will must have an event loop proceeding for any redrawing of
+   the dialog to occur. If \a modal is TRUE, the dialog ensures that
+   events are processed when needed.
+
+
+  \sa setLabelText(), setLabel(), setCancelButtonText(), setCancelButton(),
+  setTotalSteps()
+*/
+
+QProgressDialog::QProgressDialog( const QString &labelText,
+				  const QString &cancelButtonText,
+				  int totalSteps,
+				  QWidget *creator, const char *name,
+				  bool modal, WFlags f )
+    : QDialog( creator, name, modal, f)
+{
+    init( creator, labelText, cancelButtonText, totalSteps );
+}
+
+
+/*!
+  Destroys the progress dialog.
+*/
+
+QProgressDialog::~QProgressDialog()
+{
+#ifndef QT_NO_CURSOR
+    if ( d->creator )
+	d->creator->setCursor( d->parentCursor );
+#endif
+    delete d;
+}
+
+void QProgressDialog::init( QWidget *creator,
+			    const QString& lbl, const QString& canc,
+			    int totstps)
+{
+    d = new QProgressDialogData(this, creator, lbl, totstps);
+    d->autoClose = TRUE;
+    d->autoReset = TRUE;
+    d->forceHide = FALSE;
+    setCancelButtonText( canc );
+    connect( this, SIGNAL(canceled()), this, SIGNAL(cancelled()) );
+    connect( this, SIGNAL(canceled()), this, SLOT(cancel()) );
+    forceTimer = new QTimer( this );
+    connect( forceTimer, SIGNAL(timeout()), this, SLOT(forceShow()) );
+    layout();
+}
+
+/*!
+  \fn void QProgressDialog::canceled()
+
+  This signal is emitted when the cancel button is clicked.
+  It is connected to the cancel() slot by default.
+
+  \sa wasCanceled()
+*/
+
+/*!
+  \fn void QProgressDialog::cancelled()
+
+  \obsolete
+
+  Use canceled() instead.
+*/
+
+
+/*!
+  Sets the label to \a label. The progress dialog resizes to fit. The
+  label becomes owned by the progress dialog and will be deleted when
+  necessary, so do not pass the address of an object on the stack.
+
+  \sa setLabelText()
+*/
+
+void QProgressDialog::setLabel( QLabel *label )
+{
+    delete d->label;
+    d->label = label;
+    if (label) {
+	if ( label->parentWidget() == this ) {
+	    label->hide(); // until we resize
+	} else {
+	    label->reparent( this, 0, QPoint(0,0), FALSE );
+	}
+    }
+    int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+    int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+    resize( w, h );
+    if (label)
+	label->show();
+}
+
+
+/*!
+  \property QProgressDialog::labelText
+  \brief the label's text
+
+  The default text is QString::null.
+*/
+
+QString QProgressDialog::labelText() const
+{
+    if ( label() )
+	return label()->text();
+    return QString::null;
+}
+
+void QProgressDialog::setLabelText( const QString &text )
+{
+    if ( label() ) {
+	label()->setText( text );
+	int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+	int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+	resize( w, h );
+    }
+}
+
+
+/*!
+  Sets the cancel button to the push button, \a cancelButton. The
+  progress dialog takes ownership of this button which will be deleted
+  when necessary, so do not pass the address of an object that is on
+  the stack, i.e. use new() to create the button.
+
+  \sa setCancelButtonText()
+*/
+
+void QProgressDialog::setCancelButton( QPushButton *cancelButton )
+{
+    delete d->cancel;
+    d->cancel = cancelButton;
+    if (cancelButton) {
+	if ( cancelButton->parentWidget() == this ) {
+	    cancelButton->hide(); // until we resize
+	} else {
+	    cancelButton->reparent( this, 0, QPoint(0,0), FALSE );
+	}
+	connect( d->cancel, SIGNAL(clicked()), this, SIGNAL(canceled()) );
+#ifndef QT_NO_ACCEL
+	QAccel *accel = new QAccel( this );
+	accel->connectItem( accel->insertItem(Key_Escape),
+			    d->cancel, SIGNAL(clicked()) );
+#endif
+    }
+    int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+    int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+    resize( w, h );
+    if (cancelButton)
+	cancelButton->show();
+}
+
+/*!
+  Sets the cancel button's text to \a cancelButtonText.
+  \sa setCancelButton()
+*/
+
+void QProgressDialog::setCancelButtonText( const QString &cancelButtonText )
+{
+    if ( !cancelButtonText.isNull() ) {
+	if ( d->cancel )
+	    d->cancel->setText(cancelButtonText);
+	else
+	    setCancelButton(new QPushButton(cancelButtonText, this, "cancel"));
+    } else {
+	setCancelButton(0);
+    }
+    int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+    int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+    resize( w, h );
+}
+
+
+/*!
+  Sets the progress bar widget to \a bar. The progress dialog resizes to
+  fit. The progress dialog takes ownership of the progress \a bar which
+  will be deleted when necessary, so do not use a progress bar
+  allocated on the stack.
+*/
+
+void QProgressDialog::setBar( QProgressBar *bar )
+{
+    if ( progress() > 0 ) {
+#if defined(QT_CHECK_STATE)
+	qWarning( "QProgrssDialog::setBar: Cannot set a new progress bar "
+		 "while the old one is active" );
+#endif
+    }
+    delete d->bar;
+    d->bar = bar;
+    int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+    int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+    resize( w, h );
+}
+
+
+/*!
+  \property QProgressDialog::wasCancelled
+  \brief whether the dialog was canceled
+
+  \obsolete
+
+  Use \l wasCanceled instead.
+*/
+
+/*!
+  \property QProgressDialog::wasCanceled
+  \brief whether the dialog was canceled
+
+  \sa setProgress()
+*/
+
+bool QProgressDialog::wasCancelled() const
+{
+    return d->cancellation_flag;
+}
+
+
+/*!
+  \property QProgressDialog::totalSteps
+  \brief the total number of steps
+
+  The default is 0.
+*/
+
+int QProgressDialog::totalSteps() const
+{
+    if ( d && d->bar )
+	return bar()->totalSteps();
+    return 0;
+}
+
+void QProgressDialog::setTotalSteps( int totalSteps )
+{
+    bar()->setTotalSteps( totalSteps );
+}
+
+
+/*!
+  Resets the progress dialog.
+  The progress dialog becomes hidden if autoClose() is TRUE.
+
+  \sa setAutoClose(), setAutoReset()
+*/
+
+void QProgressDialog::reset()
+{
+#ifndef QT_NO_CURSOR
+    if ( progress() >= 0 ) {
+	if ( d->creator )
+	    d->creator->setCursor( d->parentCursor );
+    }
+#endif
+    if ( d->autoClose || d->forceHide )
+	hide();
+    bar()->reset();
+    d->cancellation_flag = FALSE;
+    d->shown_once = FALSE;
+    forceTimer->stop();
+}
+
+/*!
+  Resets the progress dialog. wasCanceled() becomes TRUE until
+  the progress dialog is reset.
+  The progress dialog becomes hidden.
+*/
+
+void QProgressDialog::cancel()
+{
+    d->forceHide = TRUE;
+    reset();
+    d->forceHide = FALSE;
+    d->cancellation_flag = TRUE;
+}
+
+/*!
+  \property QProgressDialog::progress
+  \brief the current amount of progress made.
+
+  For the progress dialog to work as expected, you should initially set
+  this property to 0 and finally set it to
+  QProgressDialog::totalSteps(); you can call setProgress() any number of times
+  in-between.
+
+  \warning If the progress dialog is modal
+    (see QProgressDialog::QProgressDialog()),
+    this function calls QApplication::processEvents(), so take care that
+    this does not cause undesirable re-entrancy in your code. For example,
+    don't use a QProgressDialog inside a paintEvent()!
+
+  \sa totalSteps
+*/
+
+int QProgressDialog::progress() const
+{
+    return bar()->progress();
+}
+
+void QProgressDialog::setProgress( int progress )
+{
+    if ( progress == bar()->progress() ||
+	 bar()->progress() == -1 && progress == bar()->totalSteps() )
+	return;
+
+    bar()->setProgress(progress);
+
+    if ( d->shown_once ) {
+	if (testWFlags(WShowModal))
+	    qApp->processEvents();
+    } else {
+	if ( progress == 0 ) {
+#ifndef QT_NO_CURSOR
+	    if ( d->creator ) {
+		d->parentCursor = d->creator->cursor();
+		d->creator->setCursor( waitCursor );
+	    }
+#endif
+	    d->starttime.start();
+	    forceTimer->start( d->showTime );
+	    return;
+	} else {
+	    bool need_show;
+	    int elapsed = d->starttime.elapsed();
+	    if ( elapsed >= d->showTime ) {
+		need_show = TRUE;
+	    } else {
+		if ( elapsed > minWaitTime ) {
+		    int estimate;
+		    if ( (totalSteps() - progress) >= INT_MAX / elapsed )
+			estimate = (totalSteps() - progress) / progress * elapsed;
+		    else
+			estimate = elapsed * (totalSteps() - progress) / progress;
+		    need_show = estimate >= d->showTime;
+		} else {
+		    need_show = FALSE;
+		}
+	    }
+	    if ( need_show ) {
+		int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+		int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+		resize( w, h );
+		show();
+		d->shown_once = TRUE;
+	    }
+	}
+#ifdef Q_WS_MACX
+	QApplication::flush();
+#endif
+    }
+
+    if ( progress == bar()->totalSteps() && d->autoReset )
+	reset();
+}
+
+/*!
+  \overload
+
+  Sets the current amount of progress to \a progress and the total number of
+  steps to \a totalSteps.
+
+  \sa setTotalSteps()
+*/
+
+void QProgressDialog::setProgress( int progress, int totalSteps )
+{
+    setTotalSteps( totalSteps );
+    setProgress( progress );
+}
+
+/*!
+  Returns a size that fits the contents of the progress dialog.
+  The progress dialog resizes itself as required, so you should not
+  need to call this yourself.
+*/
+
+QSize QProgressDialog::sizeHint() const
+{
+    QSize sh = label()->sizeHint();
+    QSize bh = bar()->sizeHint();
+    int h = margin_tb*2 + bh.height() + sh.height() + spacing;
+    if ( d->cancel )
+	h += d->cancel->sizeHint().height() + spacing;
+    return QSize( QMAX(200, sh.width() + 2*margin_lr), h );
+}
+
+/*!\reimp
+*/
+void QProgressDialog::resizeEvent( QResizeEvent * )
+{
+    layout();
+}
+
+/*!
+  \reimp
+*/
+void QProgressDialog::styleChange(QStyle& s)
+{
+    QDialog::styleChange(s);
+    layout();
+}
+
+void QProgressDialog::layout()
+{
+    int sp = spacing;
+    int mtb = margin_tb;
+    int mlr = QMIN(width()/10, margin_lr);
+    const bool centered =
+	bool(style().styleHint(QStyle::SH_ProgressDialog_CenterCancelButton, this));
+
+    QSize cs = d->cancel ? d->cancel->sizeHint() : QSize(0,0);
+    QSize bh = bar()->sizeHint();
+    int cspc;
+    int lh = 0;
+
+    // Find spacing and sizes that fit.  It is important that a progress
+    // dialog can be made very small if the user demands it so.
+    for (int attempt=5; attempt--; ) {
+	cspc = d->cancel ? cs.height() + sp : 0;
+	lh = QMAX(0, height() - mtb - bh.height() - sp - cspc);
+
+	if ( lh < height()/4 ) {
+	    // Getting cramped
+	    sp /= 2;
+	    mtb /= 2;
+	    if ( d->cancel ) {
+		cs.setHeight(QMAX(4,cs.height()-sp-2));
+	    }
+	    bh.setHeight(QMAX(4,bh.height()-sp-1));
+	} else {
+	    break;
+	}
+    }
+
+    if ( d->cancel ) {
+	d->cancel->setGeometry(
+	    centered ? width()/2 - cs.width()/2 : width() - mlr - cs.width(),
+	    height() - mtb - cs.height() + sp,
+	    cs.width(), cs.height() );
+    }
+
+    label()->setGeometry( mlr, 0, width()-mlr*2, lh );
+    bar()->setGeometry( mlr, lh+sp, width()-mlr*2, bh.height() );
+}
+
+/*!
+    \property QProgressDialog::minimumDuration
+    \brief the time that must pass before the dialog appears
+
+    If the expected duration of the task is less than the
+    minimumDuration, the dialog will not appear at all. This prevents
+    the dialog popping up for tasks that are quickly over. For tasks
+    that are expected to exceed the minimumDuration, the dialog will
+    pop up after the minimumDuration time or as soon as any progress
+    is set.
+
+    If set to 0, the dialog is always shown as soon as any progress is
+    set. The default is 4000 milliseconds.
+*/
+void QProgressDialog::setMinimumDuration( int ms )
+{
+    d->showTime = ms;
+    if ( bar()->progress() == 0 ) {
+	forceTimer->stop();
+	forceTimer->start( ms );
+    }
+}
+
+int QProgressDialog::minimumDuration() const
+{
+    return d->showTime;
+}
+
+
+/*!
+  \reimp
+*/
+
+void QProgressDialog::closeEvent( QCloseEvent *e )
+{
+    emit canceled();
+    QDialog::closeEvent( e );
+}
+
+/*!
+  \property QProgressDialog::autoReset
+  \brief whether the progress dialog calls reset() as soon as progress() equals totalSteps()
+
+  The default is TRUE.
+
+  \sa setAutoClose()
+*/
+
+void QProgressDialog::setAutoReset( bool b )
+{
+    d->autoReset = b;
+}
+
+bool QProgressDialog::autoReset() const
+{
+    return d->autoReset;
+}
+
+/*!
+  \property QProgressDialog::autoClose
+  \brief whether the dialog gets hidden by reset()
+
+  The default is TRUE.
+
+  \sa setAutoReset()
+*/
+
+void QProgressDialog::setAutoClose( bool b )
+{
+    d->autoClose = b;
+}
+
+bool QProgressDialog::autoClose() const
+{
+    return d->autoClose;
+}
+
+/*!
+  \reimp
+*/
+
+void QProgressDialog::showEvent( QShowEvent *e )
+{
+    QDialog::showEvent( e );
+    int w = QMAX( isVisible() ? width() : 0, sizeHint().width() );
+    int h = QMAX( isVisible() ? height() : 0, sizeHint().height() );
+    resize( w, h );
+    forceTimer->stop();
+}
+
+/*!
+  Shows the dialog if it is still hidden after the algorithm has been started
+  and minimumDuration milliseconds have passed.
+
+  \sa setMinimumDuration()
+*/
+
+void QProgressDialog::forceShow()
+{
+    if ( d->shown_once || d->cancellation_flag )
+	return;
+
+    show();
+    d->shown_once = TRUE;
+}
+
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qprogressdialog.h b/main/dependencies/qt3/src/dialogs/qprogressdialog.h
new file mode 100644
index 000000000..fb671783f
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qprogressdialog.h
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Definition of QProgressDialog class
+**
+** Created : 970520
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QPROGRESSDIALOG_H
+#define QPROGRESSDIALOG_H
+
+#ifndef QT_H
+#include "qsemimodal.h"
+#include "qlabel.h"       // ### remove or keep for users' convenience?
+#include "qprogressbar.h" // ### remove or keep for users' convenience?
+#endif // QT_H
+
+#ifndef QT_NO_PROGRESSDIALOG
+
+class QPushButton;
+class QTimer;
+class QProgressDialogData;
+
+class Q_EXPORT QProgressDialog : public QDialog
+{
+    Q_OBJECT
+    Q_PROPERTY( bool wasCancelled READ wasCancelled DESIGNABLE false STORED false ) // ### remove in 4.0
+    Q_PROPERTY( bool wasCanceled READ wasCanceled )
+    Q_PROPERTY( int totalSteps READ totalSteps WRITE setTotalSteps )
+    Q_PROPERTY( int progress READ progress WRITE setProgress )
+    Q_PROPERTY( bool autoReset READ autoReset WRITE setAutoReset )
+    Q_PROPERTY( bool autoClose READ autoClose WRITE setAutoClose )
+    Q_PROPERTY( int minimumDuration READ minimumDuration WRITE setMinimumDuration )
+    Q_PROPERTY( QString labelText READ labelText WRITE setLabelText )
+
+public:
+    QProgressDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE,
+		     WFlags f=0 );
+    QProgressDialog( const QString& labelText, const QString &cancelButtonText,
+		     int totalSteps, QWidget* parent=0, const char* name=0,
+		     bool modal=FALSE, WFlags f=0 );
+    ~QProgressDialog();
+
+    void	setLabel( QLabel * );
+    void	setCancelButton( QPushButton * );
+    void	setBar( QProgressBar * );
+
+    // ### Qt 4.0: remove wasCancelled() in 4.0
+    bool	wasCancelled() const;
+    inline bool	wasCanceled() const { return wasCancelled(); }
+
+    int		totalSteps() const;
+    int		progress()   const;
+
+    QSize	sizeHint() const;
+
+    QString     labelText() const;
+
+    void setAutoReset( bool b );
+    bool autoReset() const;
+    void setAutoClose( bool b );
+    bool autoClose() const;
+
+public slots:
+    void	cancel();
+    void	reset();
+    void	setTotalSteps( int totalSteps );
+    void	setProgress( int progress );
+    void	setProgress( int progress, int totalSteps );
+    void	setLabelText( const QString &);
+    void	setCancelButtonText( const QString &);
+
+    void	setMinimumDuration( int ms );
+public:
+    int		minimumDuration() const;
+
+signals:
+    // ### remove cancelled() in 4.0
+    void	cancelled();
+    void	canceled();
+
+protected:
+    void	resizeEvent( QResizeEvent * );
+    void	closeEvent( QCloseEvent * );
+    void	styleChange( QStyle& );
+    void	showEvent( QShowEvent *e );
+
+protected slots:
+    void	forceShow();
+
+private:
+    void	   init( QWidget *creator, const QString& lbl, const QString &canc,
+			 int totstps);
+    void	   layout();
+    QLabel	  *label()  const;
+    QProgressBar  *bar()    const;
+    QProgressDialogData *d;
+    QTimer	  *forceTimer;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QProgressDialog( const QProgressDialog & );
+    QProgressDialog &operator=( const QProgressDialog & );
+#endif
+};
+
+#endif // QT_NO_PROGRESSDIALOG
+
+#endif // QPROGRESSDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qsemimodal.h b/main/dependencies/qt3/src/dialogs/qsemimodal.h
new file mode 100644
index 000000000..52fa0a96b
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qsemimodal.h
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** Definition of QSemiModal class for source compatibility
+**
+** Created : 001010
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QSEMIMODAL_H
+#define QSEMIMODAL_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#endif // QT_H
+
+#ifndef QT_NO_COMPAT
+#ifndef QT_NO_SEMIMODAL
+class Q_EXPORT QSemiModal : public QDialog
+{
+    Q_OBJECT
+public:
+    QSemiModal( QWidget* parent=0, const char* name=0, bool modal=FALSE, WFlags f=0 )
+	: QDialog( parent, name, modal, f ) { }
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QSemiModal( const QSemiModal & );
+    QSemiModal &operator=( const QSemiModal & );
+#endif
+};
+#endif
+#endif
+
+#endif // QSEMIMODAL_H
diff --git a/main/dependencies/qt3/src/dialogs/qt_dialogs.pri b/main/dependencies/qt3/src/dialogs/qt_dialogs.pri
new file mode 100644
index 000000000..9bd899205
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qt_dialogs.pri
@@ -0,0 +1,33 @@
+# Qt dialogs module
+
+dialogs {
+	DIALOGS_P	= dialogs
+
+	HEADERS	+= $$DIALOGS_H/qcolordialog.h \
+		  $$DIALOGS_H/qdialog.h \
+		  $$DIALOGS_H/qerrormessage.h \
+		  $$DIALOGS_H/qfiledialog.h \
+		  $$DIALOGS_H/qfontdialog.h \
+		  $$DIALOGS_H/qmessagebox.h \
+		  $$DIALOGS_H/qprogressdialog.h \
+		  $$DIALOGS_H/qsemimodal.h \
+		  $$DIALOGS_H/qtabdialog.h \
+		  $$DIALOGS_H/qwizard.h \
+		  $$DIALOGS_H/qinputdialog.h
+
+        !embedded:mac:SOURCES  += $$DIALOGS_CPP/qfiledialog_mac.cpp $$DIALOGS_CPP/qcolordialog_mac.cpp
+	win32:SOURCES += $$DIALOGS_CPP/qfiledialog_win.cpp
+	unix:SOURCES += $$DIALOGS_CPP/qprintdialog.cpp
+	unix:HEADERS   += $$DIALOGS_H/qprintdialog.h 
+
+	SOURCES += $$DIALOGS_CPP/qcolordialog.cpp \
+		  $$DIALOGS_CPP/qdialog.cpp \
+		  $$DIALOGS_CPP/qerrormessage.cpp \
+		  $$DIALOGS_CPP/qfiledialog.cpp \
+		  $$DIALOGS_CPP/qfontdialog.cpp \
+		  $$DIALOGS_CPP/qmessagebox.cpp \
+		  $$DIALOGS_CPP/qprogressdialog.cpp \
+		  $$DIALOGS_CPP/qtabdialog.cpp \
+		  $$DIALOGS_CPP/qwizard.cpp \
+		  $$DIALOGS_CPP/qinputdialog.cpp
+}
diff --git a/main/dependencies/qt3/src/dialogs/qtabdialog.cpp b/main/dependencies/qt3/src/dialogs/qtabdialog.cpp
new file mode 100644
index 000000000..e770a4acc
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qtabdialog.cpp
@@ -0,0 +1,1145 @@
+/****************************************************************************
+**
+** Implementation of QTabDialog class
+**
+** Created : 960825
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qtabdialog.h"
+
+#ifndef QT_NO_TABDIALOG
+
+#include "qobjectlist.h"
+#include "qtabbar.h"
+#include "qtabwidget.h"
+#include "qpushbutton.h"
+#include "qpainter.h"
+#include "qpixmap.h"
+#include "qapplication.h"
+#include "qtabwidget.h"
+#include "qwidgetstack.h"
+#include "qlayout.h"
+
+/*!
+  \class QTabDialog qtabdialog.h
+
+  \brief The QTabDialog class provides a stack of tabbed widgets.
+
+  \ingroup dialogs
+  \mainclass
+
+  A tabbed dialog is one in which several "tab pages" are available.
+  By clicking on a tab page's tab or by pressing the indicated
+  Alt+\e{letter} key combination, the user can select which tab page
+  they want to use.
+
+  QTabDialog provides a tab bar consisting of single row of tabs at
+  the top; each tab has an associated widget which is that tab's
+  tab page. In addition, QTabDialog provides an OK button and the
+  following optional buttons: Apply, Cancel, Defaults and Help.
+
+  The normal way to use QTabDialog is to do the following in the
+  constructor:
+  \list 1
+  \i Create a QTabDialog.
+  \i Create a QWidget for each of the pages in the tab dialog, insert
+  children into it, set up geometry management for it, and use
+  addTab() (or insertTab()) to set up a tab and keyboard accelerator
+  for it.
+  \i Set up the buttons for the tab dialog using setOkButton(),
+  setApplyButton(), setDefaultsButton(), setCancelButton() and
+  setHelpButton().
+  \i Connect to the signals and slots.
+  \endlist
+
+  If you don't call addTab() the page you have created will not be
+  visible. Don't confuse the object name you supply to the
+  QWidget constructor and the tab label you supply to addTab();
+  addTab() takes user-visible name that appears on the widget's tab
+  and may identify an accelerator, whereas the widget name is used
+  primarily for debugging.
+
+  Almost all applications have to connect the applyButtonPressed()
+  signal to something. applyButtonPressed() is emitted when either OK
+  or Apply is clicked, and your slot must copy the dialog's state into
+  the application.
+
+  There are also several other signals which may be useful:
+  \list
+  \i cancelButtonPressed() is emitted when the user clicks Cancel.
+  \i defaultButtonPressed() is emitted when the user clicks Defaults;
+  the slot it is connected to should reset the state of the dialog to
+  the application defaults.
+  \i helpButtonPressed() is emitted when the user clicks Help.
+  \i aboutToShow() is emitted at the start of show(); if there is any
+  chance that the state of the application may change between the
+  creation of the tab dialog and the time show() is called, you must
+  connect this signal to a slot that resets the state of the dialog.
+  \i currentChanged() is emitted when the user selects a page.
+  \endlist
+
+  Each tab is either enabled or disabled at any given time (see
+  setTabEnabled()). If a tab is enabled the tab text is drawn in
+  black and the user can select that tab. If it is disabled the tab
+  is drawn in a different way and the user cannot select that tab.
+  Note that even if a tab is disabled, the page can still be visible;
+  for example, if all of the tabs happen to be disabled.
+
+  You can change a tab's label and iconset using changeTab(). A tab
+  page can be removed with removePage() and shown with showPage(). The
+  current page is given by currentPage().
+
+  QTabDialog does not support tabs on the sides or bottom, nor can
+  you set or retrieve the visible page. If you need more functionality
+  than QTabDialog provides, consider creating a QDialog and using a
+  QTabBar with QTabWidgets.
+
+  Most of the functionality in QTabDialog is provided by a QTabWidget.
+
+  <img src=qtabdlg-m.png> <img src=qtabdlg-w.png>
+
+  \sa QDialog
+*/
+
+/*!
+  \fn void QTabDialog::selected( const QString & );
+  \obsolete
+
+  This signal is emitted whenever a tab is selected (raised),
+  including during the first show().
+
+  \sa raise()
+*/
+
+/*! \fn void QTabDialog::currentChanged( QWidget* );
+
+  This signal is emitted whenever the current page changes.
+
+  \sa currentPage(), showPage(), tabLabel()
+*/
+
+
+// add comments about delete, ok and apply
+
+class QTabDialogPrivate
+{
+public:
+    QTabDialogPrivate();
+
+    QTabWidget* tw;
+
+    QPushButton * ok;
+    QPushButton * cb;
+    QPushButton * db;
+    QPushButton * hb;
+    QPushButton * ab;
+
+    QBoxLayout * tll;
+};
+
+QTabDialogPrivate::QTabDialogPrivate()
+	: tw(0),
+	  ok(0), cb(0), db(0), hb(0), ab(0),
+	  tll(0)
+{ }
+
+/*!
+  Constructs a QTabDialog with only an OK button.
+  The \a parent, \a name, \a modal and widget flag, \a f, arguments
+  are passed on to the QDialog constructor.
+*/
+
+QTabDialog::QTabDialog( QWidget *parent, const char *name, bool modal,
+			WFlags f )
+    : QDialog( parent, name, modal, f )
+{
+    d = new QTabDialogPrivate;
+    Q_CHECK_PTR( d );
+
+    d->tw = new QTabWidget( this, "tab widget" );
+    connect ( d->tw, SIGNAL ( selected(const QString&) ), this, SIGNAL( selected(const QString&) ) );
+    connect ( d->tw, SIGNAL ( currentChanged(QWidget*) ), this, SIGNAL( currentChanged(QWidget*) ) );
+
+    d->ok = new QPushButton( this, "ok" );
+    Q_CHECK_PTR( d->ok );
+    d->ok->setText( tr("OK") );
+    d->ok->setDefault( TRUE );
+    connect( d->ok, SIGNAL(clicked()),
+	     this, SIGNAL(applyButtonPressed()) );
+    connect( d->ok, SIGNAL(clicked()),
+	     this, SLOT(accept()) );
+}
+
+
+/*!
+  Destroys the tab dialog.
+*/
+
+QTabDialog::~QTabDialog()
+{
+    delete d;
+}
+
+
+/*!
+  Sets the font for the tabs to \a font.
+
+  If the widget is visible, the display is updated with the new font
+  immediately. There may be some geometry changes, depending on the
+  size of the old and new fonts.
+*/
+
+void QTabDialog::setFont( const QFont & font )
+{
+    QDialog::setFont( font );
+    setSizes();
+}
+
+
+/*!
+  \fn void QTabDialog::applyButtonPressed();
+
+  This signal is emitted when either the Apply or OK button is clicked.
+
+  It should be connected to a slot (or several slots) that change the
+  application's state according to the state of the dialog.
+
+  \sa cancelButtonPressed() defaultButtonPressed() setApplyButton()
+*/
+
+
+/*!
+  Returns TRUE if the tab dialog has a Defaults button; otherwise
+  returns FALSE.
+
+  \sa setDefaultButton() defaultButtonPressed() hasApplyButton()
+  hasCancelButton()
+*/
+
+bool QTabDialog::hasDefaultButton() const
+{
+     return d->db != 0;
+}
+
+
+/*!
+  Returns TRUE if the tab dialog has a Help button; otherwise returns
+  FALSE.
+
+  \sa setHelpButton() helpButtonPressed() hasApplyButton()
+  hasCancelButton()
+*/
+
+bool QTabDialog::hasHelpButton() const
+{
+     return d->hb != 0;
+}
+
+
+/*!
+  \fn void QTabDialog::cancelButtonPressed();
+
+  This signal is emitted when the Cancel button is clicked. It is
+  automatically connected to QDialog::reject(), which will hide the
+  dialog.
+
+  The Cancel button should not change the application's state at all,
+  so you should generally not need to connect it to any slot.
+
+  \sa applyButtonPressed() defaultButtonPressed() setCancelButton()
+*/
+
+
+/*!
+  Returns TRUE if the tab dialog has a Cancel button; otherwise
+  returns FALSE.
+
+  \sa setCancelButton() cancelButtonPressed() hasApplyButton()
+  hasDefaultButton()
+*/
+
+bool QTabDialog::hasCancelButton() const
+{
+     return d->cb != 0;
+}
+
+
+/*!
+  \fn void QTabDialog::defaultButtonPressed();
+
+  This signal is emitted when the Defaults button is pressed. It
+  should reset the dialog (but not the application) to the "factory
+  defaults".
+
+  The application's state should not be changed until the user clicks
+  Apply or OK.
+
+  \sa applyButtonPressed() cancelButtonPressed() setDefaultButton()
+*/
+
+
+/*!
+  \fn void QTabDialog::helpButtonPressed();
+
+  This signal is emitted when the Help button is pressed. It
+  could be used to present information about how to use the dialog.
+
+  \sa applyButtonPressed() cancelButtonPressed() setHelpButton()
+*/
+
+
+/*!
+  Returns TRUE if the tab dialog has an Apply button; otherwise
+  returns FALSE.
+
+  \sa setApplyButton() applyButtonPressed() hasCancelButton()
+  hasDefaultButton()
+*/
+
+bool QTabDialog::hasApplyButton() const
+{
+    return d->ab != 0;
+}
+
+
+/*!
+  Returns TRUE if the tab dialog has an OK button; otherwise returns
+  FALSE.
+
+  \sa setOkButton() hasApplyButton() hasCancelButton()
+  hasDefaultButton()
+*/
+
+bool QTabDialog::hasOkButton() const
+{
+    return d->ok != 0;
+}
+
+
+/*!
+  \fn void QTabDialog::aboutToShow()
+
+  This signal is emitted by show() when it is time to set the state of
+  the dialog's contents. The dialog should reflect the current state
+  of the application when it appears; if there is any possibility that
+  the state of the application may change between the time you call
+  QTabDialog::QTabDialog() and QTabDialog::show(), you should set the
+  dialog's state in a slot and connect this signal to it.
+
+  This applies mainly to QTabDialog objects that are kept around
+  hidden, rather than being created, shown, and deleted afterwards.
+
+  \sa applyButtonPressed(), show(), cancelButtonPressed()
+*/
+
+
+/*!\reimp
+*/
+void QTabDialog::show()
+{
+    //   Reimplemented in order to delay show()'ing of every page
+    //   except the initially visible one, and in order to emit the
+    //   aboutToShow() signal.
+    if ( topLevelWidget() == this )
+	d->tw->setFocus();
+    emit aboutToShow();
+    setSizes();
+    setUpLayout();
+    QDialog::show();
+}
+
+
+/*!
+  Ensures that tab page \a i is visible and appropriately sized.
+*/
+
+void QTabDialog::showTab( int i )
+{
+    d->tw->showTab( i );
+}
+
+
+/*!
+  Adds another tab and page to the tab view.
+
+  The new page is \a child; the tab's label is \a label.
+  Note the difference between the widget name (which you supply to
+  widget constructors and to setTabEnabled(), for example) and the tab
+  label. The name is internal to the program and invariant, whereas
+  the label is shown on-screen and may vary according to language and
+  other factors.
+
+  If the tab's \a label contains an ampersand, the letter following
+  the ampersand is used as an accelerator for the tab, e.g. if the
+  label is "Bro&wse" then Alt+W becomes an accelerator which will
+  move the focus to this tab.
+
+  If you call addTab() after show() the screen will flicker and the
+  user may be confused.
+
+  \sa insertTab()
+*/
+
+void QTabDialog::addTab( QWidget * child, const QString &label )
+{
+    d->tw->addTab( child, label );
+}
+
+
+
+/*! \overload
+
+  This version of the function shows the \a iconset as well as the \a
+  label on the tab of \a child.
+*/
+void QTabDialog::addTab( QWidget *child, const QIconSet& iconset, const QString &label)
+{
+    d->tw->addTab( child, iconset, label );
+}
+
+/*!
+  \overload
+
+  This is a lower-level method for adding tabs, similar to the other
+  addTab() method. It is useful if you are using setTabBar() to set a
+  QTabBar subclass with an overridden QTabBar::paint() function for a
+  subclass of QTab.
+
+  The \a child is the widget to be placed on the new tab page. The \a
+  tab is the tab to display on the tab page -- normally this shows a
+  label or an icon that identifies the tab page.
+
+*/
+void QTabDialog::addTab( QWidget * child, QTab* tab )
+{
+    d->tw->addTab( child, tab );
+}
+
+/*!
+  Inserts another tab and page to the tab view.
+
+  The new page is \a child; the tab's label is \a label.
+  Note the difference between the widget name (which you supply to
+  widget constructors and to setTabEnabled(), for example) and the tab
+  label. The name is internal to the program and invariant, whereas
+  the label is shown on-screen and may vary according to language and
+  other factors.
+
+  If the tab's \a label contains an ampersand, the letter following
+  the ampersand is used as an accelerator for the tab, e.g. if the
+  label is "Bro&wse" then Alt+W becomes an accelerator which will
+  move the focus to this tab.
+
+  If \a index is not specified, the tab is simply added. Otherwise
+  it is inserted at the specified position.
+
+  If you call insertTab() after show(), the screen will flicker and the
+  user may be confused.
+
+  \sa addTab()
+*/
+
+void QTabDialog::insertTab( QWidget * child, const QString &label, int index )
+{
+    d->tw->insertTab( child, label, index );
+}
+
+
+/*! \overload
+
+  This version of the function shows the \a iconset as well as the \a
+  label on the tab of \a child.
+ */
+void QTabDialog::insertTab( QWidget *child, const QIconSet& iconset, const QString &label, int index)
+{
+    d->tw->insertTab( child, iconset, label, index );
+}
+
+/*!
+    \overload
+
+  This is a lower-level method for inserting tabs, similar to the other
+  insertTab() method. It is useful if you are using setTabBar() to set a
+  QTabBar subclass with an overridden QTabBar::paint() function for a
+  subclass of QTab.
+
+  The \a child is the widget to be placed on the new tab page. The \a
+  tab is the tab to display on the tab page -- normally this shows a
+  label or an icon that identifies the tab page. The \a index is the
+  position where this tab page should be inserted.
+
+*/
+void QTabDialog::insertTab( QWidget * child, QTab* tab, int index )
+{
+    d->tw->insertTab( child, tab, index );
+}
+
+/*!
+  Replaces the QTabBar heading the dialog by the given tab bar, \a tb.
+  Note that this must be called \e before any tabs have been added,
+  or the behavior is undefined.
+  \sa tabBar()
+*/
+void QTabDialog::setTabBar( QTabBar* tb )
+{
+    d->tw->setTabBar( tb );
+    setUpLayout();
+}
+
+/*!
+  Returns the currently set QTabBar.
+  \sa setTabBar()
+*/
+QTabBar* QTabDialog::tabBar() const
+{
+    return d->tw->tabBar();
+}
+
+/*!  Ensures that widget \a w is shown. This is mainly useful for accelerators.
+
+  \warning If used carelessly, this function can easily surprise or
+  confuse the user.
+
+  \sa QTabBar::setCurrentTab()
+*/
+
+void QTabDialog::showPage( QWidget * w )
+{
+    d->tw->showPage( w );
+}
+
+
+/*! \obsolete
+  Returns TRUE if the page with object name \a name is enabled and
+  FALSE if it is disabled.
+
+  If \a name is 0 or not the name of any of the pages, isTabEnabled()
+  returns FALSE.
+
+  \sa setTabEnabled(), QWidget::isEnabled()
+*/
+
+bool QTabDialog::isTabEnabled( const char* name ) const
+{
+    if ( !name )
+	return FALSE;
+    QObjectList * l
+	= ((QTabDialog *)this)->queryList( "QWidget", name, FALSE, TRUE );
+    if ( l && l->first() ) {
+	QWidget * w;
+	while( l->current() ) {
+	    while( l->current() && !l->current()->isWidgetType() )
+		l->next();
+	    w = (QWidget *)(l->current());
+	    if ( w ) {
+		bool enabled = d->tw->isTabEnabled( w );
+		delete l;
+		return enabled;
+	    }
+	}
+    }
+    delete l;
+    return FALSE;
+}
+
+
+/*!\obsolete
+
+  Finds the page with object name \a name, enables/disables it
+  according to the value of \a enable and redraws the page's tab
+  appropriately.
+
+  QTabDialog uses QWidget::setEnabled() internally, rather than keeping a
+  separate flag.
+
+  Note that even a disabled tab/page may be visible. If the page is
+  already visible QTabDialog will not hide it; if all the pages
+  are disabled QTabDialog will show one of them.
+
+  The object name is used (rather than the tab label) because the tab
+  text may not be invariant in multi-language applications.
+
+  \sa isTabEnabled(), QWidget::setEnabled()
+*/
+
+void QTabDialog::setTabEnabled( const char* name, bool enable )
+{
+    if ( !name )
+	return;
+    QObjectList * l
+	= ((QTabDialog *)this)->queryList( "QWidget", name, FALSE, TRUE );
+    if ( l && l->first() ) {
+	QObjectListIt it(*l);
+	QObject *o;
+	while( (o = it.current()) ) {
+	    ++it;
+	    if( o->isWidgetType() )
+		d->tw->setTabEnabled( (QWidget*)o, enable );
+	}
+    }
+    delete l;
+}
+
+
+/* ### SHOULD THIS BE HERE?
+  Adds an Apply button to the dialog. The button's text is set to \e
+  text (and defaults to "Apply").
+
+  The Apply button should apply the current settings in the dialog box
+  to the application, while keeping the dialog visible.
+
+  When Apply is clicked, the applyButtonPressed() signal is emitted.
+
+  If \a text is a
+  \link QString::operator!() null string\endlink,
+  no button is shown.
+
+  \sa setCancelButton() setDefaultButton() applyButtonPressed()
+*/
+
+
+/*!
+  Returns TRUE if the page \a w is enabled; otherwise returns FALSE.
+
+  \sa setTabEnabled(), QWidget::isEnabled()
+*/
+
+bool QTabDialog::isTabEnabled( QWidget* w ) const
+{
+    return d->tw->isTabEnabled( w );
+}
+
+/*!
+  If \a enable is TRUE the page \a w is enabled; otherwise \a w is
+  disabled. The page's tab is redrawn appropriately.
+
+  QTabWidget uses QWidget::setEnabled() internally, rather than keeping a
+  separate flag.
+
+  Note that even a disabled tab and tab page may be visible. If the
+  page is already visible QTabWidget will not hide it; if all the
+  pages are disabled QTabWidget will show one of them.
+
+  \sa isTabEnabled(), QWidget::setEnabled()
+*/
+
+void QTabDialog::setTabEnabled( QWidget* w, bool enable)
+{
+    d->tw->setTabEnabled( w, enable );
+}
+
+
+/*!
+  Adds an Apply button to the dialog. The button's text is set to \a
+  text.
+
+  The Apply button should apply the current settings in the dialog box
+  to the application while keeping the dialog visible.
+
+  When Apply is clicked, the applyButtonPressed() signal is emitted.
+
+  If \a text is a
+  \link QString::operator!() null string\endlink,
+  no button is shown.
+
+  \sa setCancelButton() setDefaultButton() applyButtonPressed()
+*/
+void QTabDialog::setApplyButton( const QString &text )
+{
+    if ( !text && d->ab ) {
+	delete d->ab;
+	d->ab = 0;
+	setSizes();
+    } else {
+	if ( !d->ab ) {
+	    d->ab = new QPushButton( this, "apply settings" );
+	    connect( d->ab, SIGNAL(clicked()),
+		     this, SIGNAL(applyButtonPressed()) );
+	    setUpLayout();
+	}
+	d->ab->setText( text );
+	setSizes();
+	//d->ab->show();
+    }
+}
+
+/*!
+    \overload
+
+  Adds an Apply button to the dialog. The button's text is set to
+  a localizable "Apply".
+ */
+void QTabDialog::setApplyButton()
+{
+    setApplyButton( tr("Apply") );
+}
+
+
+/*!
+  Adds a Help button to the dialog. The button's text is set to \a
+  text.
+
+  When Help is clicked, the helpButtonPressed() signal is emitted.
+
+  If \a text is a
+  \link QString::operator!() null string\endlink,
+  no button is shown.
+
+  \sa setApplyButton() setCancelButton() helpButtonPressed()
+*/
+
+void QTabDialog::setHelpButton( const QString &text )
+{
+    if ( !text ) {
+	delete d->hb;
+	d->hb = 0;
+	setSizes();
+    } else {
+	if ( !d->hb ) {
+	    d->hb = new QPushButton( this, "give help" );
+	    connect( d->hb, SIGNAL(clicked()),
+		     this, SIGNAL(helpButtonPressed()) );
+	    setUpLayout();
+	}
+	d->hb->setText( text );
+	setSizes();
+	//d->hb->show();
+    }
+}
+
+
+/*!
+    \overload
+
+  Adds a Help button to the dialog. The button's text is set to
+  a localizable "Help".
+ */
+void QTabDialog::setHelpButton()
+{
+    setHelpButton( tr("Help") );
+}
+
+/*!
+  Adds a Defaults button to the dialog. The button's text is set to \a
+  text.
+
+  The Defaults button should set the dialog (but not the application)
+  back to the application defaults.
+
+  When Defaults is clicked, the defaultButtonPressed() signal is emitted.
+
+  If \a text is a
+  \link QString::operator!() null string\endlink,
+  no button is shown.
+
+  \sa setApplyButton() setCancelButton() defaultButtonPressed()
+*/
+
+void QTabDialog::setDefaultButton( const QString &text )
+{
+    if ( !text ) {
+	delete d->db;
+	d->db = 0;
+	setSizes();
+    } else {
+	if ( !d->db ) {
+	    d->db = new QPushButton( this, "back to default" );
+	    connect( d->db, SIGNAL(clicked()),
+		     this, SIGNAL(defaultButtonPressed()) );
+	    setUpLayout();
+	}
+	d->db->setText( text );
+	setSizes();
+	//d->db->show();
+    }
+}
+
+
+/*!
+    \overload
+
+  Adds a Defaults button to the dialog. The button's text is set to
+  a localizable "Defaults".
+ */
+void QTabDialog::setDefaultButton()
+{
+    setDefaultButton( tr("Defaults") );
+}
+
+/*!
+  Adds a Cancel button to the dialog. The button's text is set to \a
+  text.
+
+  The cancel button should always return the application to the state
+  it was in before the tab view popped up, or if the user has clicked
+  Apply, back to the state immediately after the last Apply.
+
+  When Cancel is clicked, the cancelButtonPressed() signal is emitted.
+  The dialog is closed at the same time.
+
+  If \a text is a
+  \link QString::operator!() null string\endlink,
+  no button is shown.
+
+  \sa setApplyButton() setDefaultButton() cancelButtonPressed()
+*/
+
+void QTabDialog::setCancelButton( const QString &text )
+{
+    if ( !text ) {
+	delete d->cb;
+	d->cb = 0;
+	setSizes();
+    } else {
+	if ( !d->cb ) {
+	    d->cb = new QPushButton( this, "cancel dialog" );
+	    connect( d->cb, SIGNAL(clicked()),
+		     this, SIGNAL(cancelButtonPressed()) );
+	    connect( d->cb, SIGNAL(clicked()),
+		     this, SLOT(reject()) );
+	    setUpLayout();
+	}
+	d->cb->setText( text );
+	setSizes();
+	//d->cb->show();
+    }
+}
+
+
+/*!
+    \overload
+
+  Adds a Cancel button to the dialog. The button's text is set to
+  a localizable "Cancel".
+ */
+
+void QTabDialog::setCancelButton()
+{
+    setCancelButton( tr("Cancel") );
+}
+
+
+/*!  Sets up the layout manager for the tab dialog.
+
+  \sa setSizes() setApplyButton() setCancelButton() setDefaultButton()
+*/
+
+void QTabDialog::setUpLayout()
+{
+    // the next four are probably the same, really?
+    const int topMargin = 6;
+    const int leftMargin = 6;
+    const int rightMargin = 6;
+    const int bottomMargin = 6;
+    const int betweenButtonsMargin = 7;
+    const int aboveButtonsMargin = 8;
+
+    delete d->tll;
+    d->tll = new QBoxLayout( this, QBoxLayout::Down );
+
+    // top margin
+    d->tll->addSpacing( topMargin );
+
+    QBoxLayout * tmp = new QHBoxLayout();
+    d->tll->addLayout( tmp, 1 );
+    tmp->addSpacing( leftMargin );
+    tmp->addWidget( d->tw, 1);
+    tmp->addSpacing( rightMargin + 2 );
+
+    d->tll->addSpacing( aboveButtonsMargin + 2 );
+    QBoxLayout * buttonRow = new QBoxLayout(QBoxLayout::RightToLeft);
+    d->tll->addLayout( buttonRow, 0 );
+    d->tll->addSpacing( bottomMargin );
+
+    buttonRow->addSpacing( rightMargin );
+    if ( d->cb ) {
+	buttonRow->addWidget( d->cb, 0 );
+	buttonRow->addSpacing( betweenButtonsMargin );
+	d->cb->raise();
+    }
+
+    if ( d->ab ) {
+	buttonRow->addWidget( d->ab, 0 );
+	buttonRow->addSpacing( betweenButtonsMargin );
+	d->ab->raise();
+    }
+
+    if ( d->db ) {
+	buttonRow->addWidget( d->db, 0 );
+	buttonRow->addSpacing( betweenButtonsMargin );
+	d->db->raise();
+    }
+
+    if ( d->hb ) {
+	buttonRow->addWidget( d->hb, 0 );
+	buttonRow->addSpacing( betweenButtonsMargin );
+	d->hb->raise();
+    }
+
+    if ( d->ok ) {
+	buttonRow->addWidget( d->ok, 0 );
+	buttonRow->addSpacing( betweenButtonsMargin );
+	d->ok->raise();
+    }
+
+    // add one custom widget here
+    buttonRow->addStretch( 1 );
+    // add another custom widget here
+
+    d->tll->activate();
+}
+
+
+/*!  Sets up the minimum and maximum sizes for each child widget.
+
+  \sa setUpLayout() setFont()
+*/
+
+void QTabDialog::setSizes()
+{
+    // compute largest button size
+    QSize s( 0, 0 );
+    int bw = s.width();
+    int bh = s.height();
+
+    if ( d->ok ) {
+	s = d->ok->sizeHint();
+	if ( s.width() > bw )
+	    bw = s.width();
+	if ( s.height() > bh )
+	    bh = s.height();
+    }
+
+    if ( d->ab ) {
+	s = d->ab->sizeHint();
+	if ( s.width() > bw )
+	    bw = s.width();
+	if ( s.height() > bh )
+	    bh = s.height();
+    }
+
+    if ( d->db ) {
+	s = d->db->sizeHint();
+	if ( s.width() > bw )
+	    bw = s.width();
+	if ( s.height() > bh )
+	    bh = s.height();
+    }
+
+    if ( d->hb ) {
+	s = d->hb->sizeHint();
+	if ( s.width() > bw )
+	    bw = s.width();
+	if ( s.height() > bh )
+	    bh = s.height();
+    }
+
+    if ( d->cb ) {
+	s = d->cb->sizeHint();
+	if ( s.width() > bw )
+	    bw = s.width();
+	if ( s.height() > bh )
+	    bh = s.height();
+    }
+
+    // and set all the buttons to that size
+    if ( d->ok )
+	d->ok->setFixedSize( bw, bh );
+    if ( d->ab )
+	d->ab->setFixedSize( bw, bh );
+    if ( d->db )
+	d->db->setFixedSize( bw, bh );
+    if ( d->hb )
+	d->hb->setFixedSize( bw, bh );
+    if ( d->cb )
+	d->cb->setFixedSize( bw, bh );
+
+    // fiddle the tab chain so the buttons are in their natural order
+    QWidget * w = d->ok;
+
+    if ( d->hb ) {
+	if ( w )
+	    setTabOrder( w, d->hb );
+	w = d->hb;
+    }
+    if ( d->db ) {
+	if ( w )
+	    setTabOrder( w, d->db );
+	w = d->db;
+    }
+    if ( d->ab ) {
+	if ( w )
+	    setTabOrder( w, d->ab );
+	w = d->ab;
+    }
+    if ( d->cb ) {
+	if ( w )
+	    setTabOrder( w, d->cb );
+	w = d->cb;
+    }
+    setTabOrder( w, d->tw );
+}
+
+/*!\reimp
+*/
+void QTabDialog::resizeEvent( QResizeEvent * e )
+{
+    QDialog::resizeEvent( e );
+}
+
+
+/*!\reimp
+*/
+void QTabDialog::paintEvent( QPaintEvent * )
+{
+}
+
+
+/*!
+  Adds an OK button to the dialog and sets the button's text to \a text.
+
+  When the OK button is clicked, the applyButtonPressed() signal is emitted,
+  and the current settings in the dialog box should be applied to
+  the application. The dialog then closes.
+
+  If \a text is a
+  \link QString::operator!() null string\endlink,
+  no button is shown.
+
+  \sa setCancelButton() setDefaultButton() applyButtonPressed()
+*/
+
+void QTabDialog::setOkButton( const QString &text )
+{
+    if ( !text ) {
+	delete d->ok;
+	d->ok = 0;
+	setSizes();
+    } else {
+	if ( !d->ok ) {
+	    d->ok = new QPushButton( this, "ok" );
+	    connect( d->ok, SIGNAL(clicked()),
+		     this, SIGNAL(applyButtonPressed()) );
+	    setUpLayout();
+	}
+	d->ok->setText( text );
+	setSizes();
+	//d->ok->show();
+    }
+}
+/*!
+  \overload
+
+  Adds an OK button to the dialog. The button's text is set to
+  a localizable "OK".
+ */
+
+void QTabDialog::setOkButton()
+{
+    setOkButton( tr("OK") );
+}
+
+
+/*
+    \overload
+  Old version of setOkButton(), provided for backward compatibility.
+*/
+void QTabDialog::setOKButton( const QString &text )
+{
+    // Ugly workaround for original "OK" default argument
+    QString newText( text );
+    if ( text.isNull() )
+	newText = QString::fromLatin1( "OK" );
+    setOkButton( newText );
+}
+
+
+/*!  Returns the text in the tab for page \a w.
+*/
+
+QString QTabDialog::tabLabel( QWidget * w )
+{
+    return d->tw->tabLabel( w );
+}
+
+
+/*!  \reimp
+*/
+void QTabDialog::styleChange( QStyle& s )
+{
+    QDialog::styleChange( s );
+    setSizes();
+}
+
+
+/*!  Returns a pointer to the page currently being displayed by the
+tab dialog. The tab dialog does its best to make sure that this value
+is never 0 (but if you try hard enough, it can be).
+*/
+
+QWidget * QTabDialog::currentPage() const
+{
+    return d->tw->currentPage();
+}
+
+/*!
+ \overload
+  Defines a new \a label for the tab of page \a w
+ */
+void QTabDialog::changeTab( QWidget *w, const QString &label)
+{
+    d->tw->changeTab( w, label );
+}
+
+/*!
+    Changes tab page \a w's iconset to \a iconset and label to \a label.
+
+ */
+void QTabDialog::changeTab( QWidget *w, const QIconSet& iconset, const QString &label)
+{
+    d->tw->changeTab( w, iconset, label );
+}
+
+/*! Removes page \a w from this stack of widgets. Does not
+  delete \a w.
+  \sa showPage(), QTabWidget::removePage(), QWidgetStack::removeWidget()
+*/
+void QTabDialog::removePage( QWidget * w )
+{
+    d->tw->removePage( w );
+}
+
+#endif
diff --git a/main/dependencies/qt3/src/dialogs/qtabdialog.h b/main/dependencies/qt3/src/dialogs/qtabdialog.h
new file mode 100644
index 000000000..3ee83fd02
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qtabdialog.h
@@ -0,0 +1,146 @@
+/****************************************************************************
+**
+** Definition of QTabDialog class
+**
+** Created : 960825
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QTABDIALOG_H
+#define QTABDIALOG_H
+
+#ifndef QT_H
+#include "qdialog.h"
+#include "qiconset.h"
+#endif // QT_H
+
+#ifndef QT_NO_TABDIALOG
+
+class  QTabBar;
+class  QTab;
+class  QTabDialogPrivate;
+
+class Q_EXPORT QTabDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    QTabDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE,
+		WFlags f=0 );
+    ~QTabDialog();
+
+    void show();
+    void setFont( const QFont & font );
+
+    void addTab( QWidget *, const QString &);
+    void addTab( QWidget *child, const QIconSet& iconset, const QString &label);
+    void addTab( QWidget *, QTab* );
+
+    void insertTab( QWidget *, const QString &, int index = -1);
+    void insertTab( QWidget *child, const QIconSet& iconset, const QString &label, int index = -1);
+    void insertTab( QWidget *, QTab*, int index = -1 );
+
+    void changeTab( QWidget *, const QString &);
+    void changeTab( QWidget *child, const QIconSet& iconset, const QString &label);
+
+    bool isTabEnabled(  QWidget * ) const;
+    void setTabEnabled( QWidget *, bool );
+    bool isTabEnabled( const char* ) const; // compatibility
+    void setTabEnabled( const char*, bool ); // compatibility
+
+    void showPage( QWidget * );
+    void removePage( QWidget * );
+    QString tabLabel( QWidget * );
+
+    QWidget * currentPage() const;
+
+    void setDefaultButton( const QString &text );
+    void setDefaultButton();
+    bool hasDefaultButton() const;
+
+    void setHelpButton( const QString &text );
+    void setHelpButton();
+    bool hasHelpButton() const;
+
+    void setCancelButton( const QString &text );
+    void setCancelButton();
+    bool hasCancelButton() const;
+
+    void setApplyButton( const QString &text );
+    void setApplyButton();
+    bool hasApplyButton() const;
+
+#ifndef Q_QDOC
+    void setOKButton( const QString &text = QString::null );
+#endif
+    void setOkButton( const QString &text );
+    void setOkButton();
+    bool hasOkButton() const;
+
+protected:
+    void paintEvent( QPaintEvent * );
+    void resizeEvent( QResizeEvent * );
+    void styleChange( QStyle& );
+    void setTabBar( QTabBar* );
+    QTabBar* tabBar() const;
+
+signals:
+    void aboutToShow();
+
+    void applyButtonPressed();
+    void cancelButtonPressed();
+    void defaultButtonPressed();
+    void helpButtonPressed();
+
+    void currentChanged( QWidget * );
+    void selected( const QString& ); // obsolete
+
+private slots:
+    void showTab( int i );
+
+private:
+    void setSizes();
+    void setUpLayout();
+
+    QTabDialogPrivate *d;
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QTabDialog( const QTabDialog & );
+    QTabDialog& operator=( const QTabDialog & );
+#endif
+};
+
+#endif // QT_NO_TABDIALOG
+
+#endif // QTABDIALOG_H
diff --git a/main/dependencies/qt3/src/dialogs/qwizard.cpp b/main/dependencies/qt3/src/dialogs/qwizard.cpp
new file mode 100644
index 000000000..32c386a16
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qwizard.cpp
@@ -0,0 +1,917 @@
+/****************************************************************************
+**
+** Implementation of QWizard class.
+**
+** Created : 990124
+**
+** Copyright (C) 1999-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qwizard.h"
+
+#ifndef QT_NO_WIZARD
+
+#include "qlayout.h"
+#include "qpushbutton.h"
+#include "qcursor.h"
+#include "qlabel.h"
+#include "qwidgetstack.h"
+#include "qapplication.h"
+#include "qptrlist.h"
+#include "qpainter.h"
+#include "qaccel.h"
+
+/*! \file wizard/wizard.cpp */
+/*! \file wizard/wizard.h */
+
+/*!
+    \class QWizard qwizard.h
+    \brief The QWizard class provides a framework for wizard dialogs.
+
+    \ingroup abstractwidgets
+    \ingroup organizers
+    \ingroup dialogs
+    \mainclass
+
+    A wizard is a special type of input dialog that consists of a
+    sequence of dialog pages. A wizard's purpose is to walk the user
+    through a process step by step. Wizards are useful for complex or
+    infrequently occurring tasks that people may find difficult to
+    learn or do.
+
+    QWizard provides page titles and displays Next, Back, Finish,
+    Cancel, and Help push buttons, as appropriate to the current
+    position in the page sequence. These buttons can be
+    enabled/disabled using setBackEnabled(), setNextEnabled(),
+    setFinishEnabled() and setHelpEnabled().
+
+    Create and populate dialog pages that inherit from QWidget and add
+    them to the wizard using addPage(). Use insertPage() to add a
+    dialog page at a certain position in the page sequence. Use
+    removePage() to remove a page from the page sequence.
+
+    Use currentPage() to retrieve a pointer to the currently displayed
+    page. page() returns a pointer to the page at a certain position
+    in the page sequence.
+
+    Use pageCount() to retrieve the total number of pages in the page
+    sequence. indexOf() will return the index of a page in the page
+    sequence.
+
+    QWizard provides functionality to mark pages as appropriate (or
+    not) in the current context with setAppropriate(). The idea is
+    that a page may be irrelevant and should be skipped depending on
+    the data entered by the user on a preceding page.
+
+    It is generally considered good design to provide a greater number
+    of simple pages with fewer choices rather than a smaller number of
+    complex pages.
+
+    Example code is available here: \l wizard/wizard.cpp \l wizard/wizard.h
+
+    \img qwizard.png A QWizard page
+    \caption A QWizard page
+
+*/
+
+
+class QWizardPrivate
+{
+public:
+    struct Page {
+	Page( QWidget * widget, const QString & title ):
+	    w( widget ), t( title ),
+	    backEnabled( TRUE ), nextEnabled( TRUE ), finishEnabled( FALSE ),
+	    helpEnabled( TRUE ),
+	    appropriate( TRUE )
+	{}
+	QWidget * w;
+	QString t;
+	bool backEnabled;
+	bool nextEnabled;
+	bool finishEnabled;
+	bool helpEnabled;
+	bool appropriate;
+    };
+
+    QVBoxLayout * v;
+    Page * current;
+    QWidgetStack * ws;
+    QPtrList<Page> pages;
+    QLabel * title;
+    QPushButton * backButton;
+    QPushButton * nextButton;
+    QPushButton * finishButton;
+    QPushButton * cancelButton;
+    QPushButton * helpButton;
+
+    QFrame * hbar1, * hbar2;
+
+#ifndef QT_NO_ACCEL
+    QAccel * accel;
+    int backAccel;
+    int nextAccel;
+#endif
+
+    Page * page( const QWidget * w )
+    {
+	if ( !w )
+	    return 0;
+	int i = pages.count();
+	while( --i >= 0 && pages.at( i ) && pages.at( i )->w != w ) { }
+	return i >= 0 ? pages.at( i ) : 0;
+    }
+
+};
+
+
+/*!
+    Constructs an empty wizard dialog. The \a parent, \a name, \a
+    modal and \a f arguments are passed to the QDialog constructor.
+*/
+
+QWizard::QWizard( QWidget *parent, const char *name, bool modal,
+		  WFlags f )
+    : QDialog( parent, name, modal, f )
+{
+    d = new QWizardPrivate();
+    d->current = 0; // not quite true, but...
+    d->ws = new QWidgetStack( this, "qt_widgetstack" );
+    d->pages.setAutoDelete( TRUE );
+    d->title = new QLabel( this, "title label" );
+
+    // create in nice tab order
+    d->nextButton = new QPushButton( this, "next" );
+    d->finishButton = new QPushButton( this, "finish" );
+    d->helpButton = new QPushButton( this, "help" );
+    d->backButton = new QPushButton( this, "back" );
+    d->cancelButton = new QPushButton( this, "cancel" );
+
+    d->ws->installEventFilter( this );
+
+    d->v = 0;
+    d->hbar1 = 0;
+    d->hbar2 = 0;
+
+    d->cancelButton->setText( tr( "&Cancel" ) );
+    d->backButton->setText( tr( "< &Back" ) );
+    d->nextButton->setText( tr( "&Next >" ) );
+    d->finishButton->setText( tr( "&Finish" ) );
+    d->helpButton->setText( tr( "&Help" ) );
+
+    d->nextButton->setDefault( TRUE );
+
+    connect( d->backButton, SIGNAL(clicked()),
+	     this, SLOT(back()) );
+    connect( d->nextButton, SIGNAL(clicked()),
+	     this, SLOT(next()) );
+    connect( d->finishButton, SIGNAL(clicked()),
+	     this, SLOT(accept()) );
+    connect( d->cancelButton, SIGNAL(clicked()),
+	     this, SLOT(reject()) );
+    connect( d->helpButton, SIGNAL(clicked()),
+	     this, SLOT(help()) );
+
+#ifndef QT_NO_ACCEL
+    d->accel = new QAccel( this, "arrow-key accel" );
+    d->backAccel = d->accel->insertItem( Qt::ALT + Qt::Key_Left );
+    d->accel->connectItem( d->backAccel, this, SLOT(back()) );
+    d->nextAccel = d->accel->insertItem( Qt::ALT + Qt::Key_Right );
+    d->accel->connectItem( d->nextAccel, this, SLOT(next()) );
+#endif
+}
+
+
+/*!
+    Destroys the object and frees any allocated resources, including
+    all pages and controllers.
+*/
+
+QWizard::~QWizard()
+{
+    delete d;
+}
+
+
+/*!
+    \reimp
+*/
+
+void QWizard::show()
+{
+    if ( !d->current ) {
+	// No page yet
+	if ( pageCount() > 0 )
+	    showPage( d->pages.at( 0 )->w );
+	else
+	    showPage( 0 );
+    }
+
+    QDialog::show();
+}
+
+
+/*!
+    \reimp
+*/
+
+void QWizard::setFont( const QFont & font )
+{
+    QApplication::postEvent( this, new QEvent( QEvent::LayoutHint ) );
+    QDialog::setFont( font );
+}
+
+
+/*!
+    Adds \a page to the end of the page sequence, with the title, \a
+    title.
+*/
+
+void QWizard::addPage( QWidget * page, const QString & title )
+{
+    if ( !page )
+	return;
+    if ( d->page( page ) ) {
+#if defined(QT_CHECK_STATE)
+	qWarning( "QWizard::addPage(): already added %s/%s to %s/%s",
+		  page->className(), page->name(),
+		  className(), name() );
+#endif
+	return;
+    }
+    int i = d->pages.count();
+
+    if( i > 0 )
+	d->pages.at( i - 1 )->nextEnabled = TRUE;
+
+    QWizardPrivate::Page * p = new QWizardPrivate::Page( page, title );
+    p->backEnabled = ( i > 0 );
+    d->ws->addWidget( page, i );
+    d->pages.append( p );
+}
+
+/*!
+    Inserts \a page at position \a index into the page sequence, with
+    title \a title. If \a index is -1, the page will be appended to
+    the end of the wizard's page sequence.
+*/
+
+void QWizard::insertPage( QWidget * page, const QString & title, int index )
+{
+    if ( !page )
+	return;
+    if ( d->page( page ) ) {
+#if defined(QT_CHECK_STATE)
+	qWarning( "QWizard::insertPage(): already added %s/%s to %s/%s",
+		  page->className(), page->name(),
+		  className(), name() );
+#endif
+	return;
+    }
+
+    if ( index < 0  || index > (int)d->pages.count() )
+	index = d->pages.count();
+
+    if( index > 0 && ( index == (int)d->pages.count() ) )
+	d->pages.at( index - 1 )->nextEnabled = TRUE;
+
+    QWizardPrivate::Page * p = new QWizardPrivate::Page( page, title );
+    p->backEnabled = ( index > 0 );
+    p->nextEnabled = ( index < (int)d->pages.count() );
+
+    d->ws->addWidget( page, index );
+    d->pages.insert( index, p );
+}
+
+/*!
+    \fn void QWizard::selected(const QString&)
+
+    This signal is emitted when the current page changes. The
+    parameter contains the title of the selected page.
+*/
+
+
+/*!
+    Makes \a page the current page and emits the selected() signal.
+
+    This virtual function is called whenever a different page is to
+    be shown, including the first time the QWizard is shown.
+    By reimplementing it (and calling QWizard::showPage()),
+    you can prepare each page prior to it being shown.
+*/
+
+void QWizard::showPage( QWidget * page )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( p ) {
+	int i;
+	for( i = 0; i < (int)d->pages.count() && d->pages.at( i ) != p; i++ );
+	bool notFirst( FALSE );
+
+	if( i ) {
+	    i--;
+	    while( ( i >= 0 ) && !notFirst ) {
+		notFirst |= appropriate( d->pages.at( i )->w );
+		i--;
+	    }
+	}
+	setBackEnabled( notFirst );
+	setNextEnabled( TRUE );
+	d->ws->raiseWidget( page );
+	d->current = p;
+    }
+
+    layOut();
+    updateButtons();
+    emit selected( p ? p->t : QString::null );
+}
+
+
+/*!
+    Returns the number of pages in the wizard.
+*/
+
+int QWizard::pageCount() const
+{
+    return d->pages.count();
+}
+
+/*!
+    Returns the position of page \a page. If the page is not part of
+    the wizard -1 is returned.
+*/
+
+int QWizard::indexOf( QWidget* page ) const
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( !p ) return -1;
+
+    return d->pages.find( p );
+}
+
+/*!
+    Called when the user clicks the Back button; this function shows
+    the preceding relevant page in the sequence.
+
+    \sa appropriate()
+*/
+void QWizard::back()
+{
+    int i = 0;
+
+    while( i < (int)d->pages.count() && d->pages.at( i ) &&
+	   d->current && d->pages.at( i )->w != d->current->w )
+	i++;
+
+    i--;
+    while( i >= 0 && ( !d->pages.at( i ) || !appropriate( d->pages.at( i )->w ) ) )
+	i--;
+
+    if( i >= 0 )
+       if( d->pages.at( i ) )
+	    showPage( d->pages.at( i )->w );
+}
+
+
+/*!
+    Called when the user clicks the Next button, this function shows
+    the next relevant page in the sequence.
+
+    \sa appropriate()
+*/
+void QWizard::next()
+{
+    int i = 0;
+    while( i < (int)d->pages.count() && d->pages.at( i ) &&
+	   d->current && d->pages.at( i )->w != d->current->w )
+	i++;
+    i++;
+    while( i <= (int)d->pages.count()-1 &&
+	   ( !d->pages.at( i ) || !appropriate( d->pages.at( i )->w ) ) )
+	i++;
+    // if we fell of the end of the world, step back
+    while ( i > 0 && (i >= (int)d->pages.count() || !d->pages.at( i ) ) )
+	i--;
+    if ( d->pages.at( i ) )
+	showPage( d->pages.at( i )->w );
+}
+
+
+/*!
+    \fn void QWizard::helpClicked()
+
+    This signal is emitted when the user clicks on the Help button.
+*/
+
+/*!
+    Called when the user clicks the Help button, this function emits
+    the helpClicked() signal.
+*/
+
+void QWizard::help()
+{
+    QWidget * page = d->ws->visibleWidget();
+    if ( !page )
+	return;
+
+#if 0
+    QWizardPage *wpage = ::qt_cast<QWizardPage*>(page);
+    if ( wpage )
+	emit wpage->helpClicked();
+#endif
+    emit helpClicked();
+}
+
+
+void QWizard::setBackEnabled( bool enable )
+{
+    d->backButton->setEnabled( enable );
+#ifndef QT_NO_ACCEL
+    d->accel->setItemEnabled( d->backAccel, enable );
+#endif
+}
+
+
+void QWizard::setNextEnabled( bool enable )
+{
+    d->nextButton->setEnabled( enable );
+#ifndef QT_NO_ACCEL
+    d->accel->setItemEnabled( d->nextAccel, enable );
+#endif
+}
+
+
+void QWizard::setHelpEnabled( bool enable )
+{
+    d->helpButton->setEnabled( enable );
+}
+
+
+/*!
+  \fn void QWizard::setFinish( QWidget *, bool )
+  \obsolete
+
+  Use setFinishEnabled instead
+*/
+
+/*!
+    If \a enable is TRUE, page \a page has a Back button; otherwise \a
+    page has no Back button. By default all pages have this button.
+*/
+void QWizard::setBackEnabled( QWidget * page, bool enable )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( !p )
+	return;
+
+    p->backEnabled = enable;
+    updateButtons();
+}
+
+
+/*!
+    If \a enable is TRUE, page \a page has a Next button; otherwise
+    the Next button on \a page is disabled. By default all pages have
+    this button.
+*/
+
+void QWizard::setNextEnabled( QWidget * page, bool enable )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( !p )
+	return;
+
+    p->nextEnabled = enable;
+    updateButtons();
+}
+
+
+/*!
+    If \a enable is TRUE, page \a page has a Finish button; otherwise
+    \a page has no Finish button. By default \e no page has this
+    button.
+*/
+void QWizard::setFinishEnabled( QWidget * page, bool enable )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( !p )
+	return;
+
+    p->finishEnabled = enable;
+    updateButtons();
+}
+
+
+/*!
+    If \a enable is TRUE, page \a page has a Help button; otherwise \a
+    page has no Help button. By default all pages have this button.
+*/
+void QWizard::setHelpEnabled( QWidget * page, bool enable )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( !p )
+	return;
+
+    p->helpEnabled = enable;
+    updateButtons();
+}
+
+
+/*!
+    Called when the Next button is clicked; this virtual function
+    returns TRUE if \a page is relevant for display in the current
+    context; otherwise it is ignored by QWizard and returns FALSE. The
+    default implementation returns the value set using
+    setAppropriate(). The ultimate default is TRUE.
+
+    \warning The last page of the wizard will be displayed if no page
+    is relevant in the current context.
+*/
+
+bool QWizard::appropriate( QWidget * page ) const
+{
+    QWizardPrivate::Page * p = d->page( page );
+    return p ? p->appropriate : TRUE;
+}
+
+
+/*!
+    If \a appropriate is TRUE then page \a page is considered relevant
+    in the current context and should be displayed in the page
+    sequence; otherwise \a page should not be displayed in the page
+    sequence.
+
+    \sa appropriate()
+*/
+void QWizard::setAppropriate( QWidget * page, bool appropriate )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( p )
+	p->appropriate = appropriate;
+}
+
+
+void QWizard::updateButtons()
+{
+    if ( !d->current )
+	return;
+
+    int i;
+    for( i = 0; i < (int)d->pages.count() && d->pages.at( i ) != d->current; i++ );
+    bool notFirst( FALSE );
+    if( i ) {
+	i--;
+	while( ( i >= 0 ) && !notFirst ) {
+	    notFirst |= appropriate( d->pages.at( i )->w );
+	    i--;
+	}
+    }
+    setBackEnabled( d->current->backEnabled && notFirst );
+    setNextEnabled( d->current->nextEnabled );
+    d->finishButton->setEnabled( d->current->finishEnabled );
+    d->helpButton->setEnabled( d->current->helpEnabled );
+
+    if ( ( d->current->finishEnabled && !d->finishButton->isVisible() ) ||
+	 ( d->current->backEnabled && !d->backButton->isVisible() ) ||
+	 ( d->current->nextEnabled && !d->nextButton->isVisible() ) ||
+	 ( d->current->helpEnabled && !d->helpButton->isVisible() ) )
+	layOut();
+}
+
+
+/*!
+    Returns a pointer to the current page in the sequence. Although
+    the wizard does its best to make sure that this value is never 0,
+    it can be if you try hard enough.
+*/
+
+QWidget * QWizard::currentPage() const
+{
+    return d->ws->visibleWidget();
+}
+
+
+/*!
+    Returns the title of page \a page.
+*/
+
+QString QWizard::title( QWidget * page ) const
+{
+    QWizardPrivate::Page * p = d->page( page );
+    return p ? p->t : QString::null;
+}
+
+/*!
+    Sets the title for page \a page to \a title.
+*/
+
+void QWizard::setTitle( QWidget *page, const QString &title )
+{
+    QWizardPrivate::Page * p = d->page( page );
+    if ( p )
+	p->t = title;
+    if ( page == currentPage() )
+	d->title->setText( title );
+}
+
+/*!
+    \property QWizard::titleFont
+    \brief the font used for page titles
+
+    The default is QApplication::font().
+*/
+QFont QWizard::titleFont() const
+{
+    return d->title->font();
+}
+
+void QWizard::setTitleFont( const QFont & font )
+{
+    d->title->setFont( font );
+}
+
+
+/*!
+    Returns a pointer to the dialog's Back button
+
+    By default, this button is connected to the back() slot, which is
+    virtual so you can reimplement it in a QWizard subclass. Use
+    setBackEnabled() to enable/disable this button.
+*/
+QPushButton * QWizard::backButton() const
+{
+    return d->backButton;
+}
+
+
+/*!
+    Returns a pointer to the dialog's Next button
+
+    By default, this button is connected to the next() slot, which is
+    virtual so you can reimplement it in a QWizard subclass. Use
+    setNextEnabled() to enable/disable this button.
+*/
+QPushButton * QWizard::nextButton() const
+{
+    return d->nextButton;
+}
+
+
+/*!
+    Returns a pointer to the dialog's Finish button
+
+    By default, this button is connected to the QDialog::accept()
+    slot, which is virtual so you can reimplement it in a QWizard
+    subclass. Use setFinishEnabled() to enable/disable this button.
+*/
+QPushButton * QWizard::finishButton() const
+{
+    return d->finishButton;
+}
+
+
+/*!
+    Returns a pointer to the dialog's Cancel button
+
+    By default, this button is connected to the QDialog::reject()
+    slot, which is virtual so you can reimplement it in a QWizard
+    subclass.
+*/
+QPushButton * QWizard::cancelButton() const
+{
+    return d->cancelButton;
+}
+
+
+/*!
+    Returns a pointer to the dialog's Help button
+
+    By default, this button is connected to the help() slot, which is
+    virtual so you can reimplement it in a QWizard subclass. Use
+    setHelpEnabled() to enable/disable this button.
+*/
+QPushButton * QWizard::helpButton() const
+{
+    return d->helpButton;
+}
+
+
+/*!
+    This virtual function is responsible for adding the buttons below
+    the bottom divider.
+
+    \a layout is the horizontal layout of the entire wizard.
+*/
+
+void QWizard::layOutButtonRow( QHBoxLayout * layout )
+{
+    bool hasHelp = FALSE;
+    bool hasEarlyFinish = FALSE;
+
+    int i = d->pages.count() - 2;
+    while ( !hasEarlyFinish && i >= 0 ) {
+	if ( d->pages.at( i ) && d->pages.at( i )->finishEnabled )
+	    hasEarlyFinish = TRUE;
+	i--;
+    }
+    i = 0;
+    while ( !hasHelp && i < (int)d->pages.count() ) {
+	if ( d->pages.at( i ) && d->pages.at( i )->helpEnabled )
+	    hasHelp = TRUE;
+	i++;
+    }
+
+    QBoxLayout * h = new QBoxLayout( QBoxLayout::LeftToRight );
+    layout->addLayout( h );
+
+    if ( hasHelp )
+	h->addWidget( d->helpButton );
+    else
+	d->helpButton->hide();
+
+    h->addStretch( 42 );
+
+    h->addWidget( d->backButton );
+
+    h->addSpacing( 6 );
+
+    if (d->current == d->pages.at( d->pages.count()-1 ))
+        hasEarlyFinish = FALSE;
+
+    if ( hasEarlyFinish ) {
+	d->nextButton->show();
+	d->finishButton->show();
+	h->addWidget( d->nextButton );
+	h->addSpacing( 12 );
+	h->addWidget( d->finishButton );
+    } else if ( d->pages.count() == 0 ||
+		d->current->finishEnabled ||
+		d->current == d->pages.at( d->pages.count()-1 ) ) {
+	d->nextButton->hide();
+	d->finishButton->show();
+	h->addWidget( d->finishButton );
+    } else {
+	d->nextButton->show();
+	d->finishButton->hide();
+	h->addWidget( d->nextButton );
+    }
+
+    // if last page is disabled - show finished btn. at lastpage-1
+    i = d->pages.count()-1;
+    if ( i >= 0 && !appropriate( d->pages.at( i )->w ) &&
+	 d->current == d->pages.at( d->pages.count()-2 ) ) {
+	d->nextButton->hide();
+	d->finishButton->show();
+	h->addWidget( d->finishButton );
+    }
+
+    h->addSpacing( 12 );
+    h->addWidget( d->cancelButton );
+}
+
+
+/*!
+    This virtual function is responsible for laying out the title row.
+
+    \a layout is the horizontal layout for the wizard, and \a
+    title is the title for this page. This function is called every
+    time \a title changes.
+*/
+
+void QWizard::layOutTitleRow( QHBoxLayout * layout, const QString & title )
+{
+    d->title->setText( title );
+    layout->addWidget( d->title, 10 );
+}
+
+
+/*
+
+*/
+
+void QWizard::layOut()
+{
+    delete d->v;
+    d->v = new QVBoxLayout( this, 6, 0, "top-level layout" );
+
+    QHBoxLayout * l;
+    l = new QHBoxLayout( 6 );
+    d->v->addLayout( l, 0 );
+    layOutTitleRow( l, d->current ? d->current->t : QString::null );
+
+    if ( ! d->hbar1 ) {
+	d->hbar1 = new QFrame( this, "<hr>", 0 );
+	d->hbar1->setFrameStyle( QFrame::Sunken + QFrame::HLine );
+	d->hbar1->setFixedHeight( 12 );
+    }
+
+    d->v->addWidget( d->hbar1 );
+
+    d->v->addWidget( d->ws, 10 );
+
+    if ( ! d->hbar2 ) {
+	d->hbar2 = new QFrame( this, "<hr>", 0 );
+	d->hbar2->setFrameStyle( QFrame::Sunken + QFrame::HLine );
+	d->hbar2->setFixedHeight( 12 );
+    }
+    d->v->addWidget( d->hbar2 );
+
+    l = new QHBoxLayout( 6 );
+    d->v->addLayout( l );
+    layOutButtonRow( l );
+    d->v->activate();
+}
+
+
+/*!
+    \reimp
+*/
+
+bool QWizard::eventFilter( QObject * o, QEvent * e )
+{
+    if ( o == d->ws && e && e->type() == QEvent::ChildRemoved ) {
+	QChildEvent * c = (QChildEvent*)e;
+	if ( c->child() && c->child()->isWidgetType() )
+	    removePage( (QWidget *)c->child() );
+    }
+    return QDialog::eventFilter( o, e );
+}
+
+
+/*!
+    Removes \a page from the page sequence but does not delete the
+    page. If \a page is currently being displayed, QWizard will
+    display the page that precedes it, or the first page if this was
+    the first page.
+*/
+
+void QWizard::removePage( QWidget * page )
+{
+    if ( !page )
+	return;
+
+    int i = d->pages.count();
+    QWidget* cp = currentPage();
+    while( --i >= 0 && d->pages.at( i ) && d->pages.at( i )->w != page ) { }
+    if ( i < 0 )
+	return;
+    QWizardPrivate::Page * p = d->pages.at( i );
+    d->pages.removeRef( p );
+    d->ws->removeWidget( page );
+
+    if( cp == page ) {
+	i--;
+	if( i < 0 )
+	    i = 0;
+	if ( pageCount() > 0 )
+	    showPage( QWizard::page( i ) );
+    }
+}
+
+
+/*!
+    Returns a pointer to the page at position \a index in the
+    sequence, or 0 if \a index is out of range. The first page has
+    index 0.
+*/
+
+QWidget* QWizard::page( int index ) const
+{
+    if ( index >= pageCount() || index < 0 )
+      return 0;
+
+    return d->pages.at( index )->w;
+}
+
+#endif // QT_NO_WIZARD
diff --git a/main/dependencies/qt3/src/dialogs/qwizard.h b/main/dependencies/qt3/src/dialogs/qwizard.h
new file mode 100644
index 000000000..537b84334
--- /dev/null
+++ b/main/dependencies/qt3/src/dialogs/qwizard.h
@@ -0,0 +1,142 @@
+/****************************************************************************
+**
+** Definition of the QWizard class.
+**
+** Created : 990101
+**
+** Copyright (C) 1999-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the dialogs module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QWIZARDDIALOG_H
+#define QWIZARDDIALOG_H
+
+
+#ifndef QT_H
+#include "qdialog.h"
+#endif // QT_H
+
+#ifndef QT_NO_WIZARD
+
+class QHBoxLayout;
+class QWizardPrivate;
+
+class Q_EXPORT QWizard : public QDialog
+{
+    Q_OBJECT
+    Q_PROPERTY( QFont titleFont READ titleFont WRITE setTitleFont )
+
+public:
+    QWizard( QWidget* parent=0, const char* name=0, bool modal=FALSE,
+	     WFlags f=0 );
+    ~QWizard();
+
+    void show();
+
+    void setFont( const QFont & font );
+
+    virtual void addPage( QWidget *, const QString & );
+    virtual void insertPage( QWidget*, const QString&, int );
+    virtual void removePage( QWidget * );
+
+    QString title( QWidget * ) const;
+    void setTitle( QWidget *, const QString & );
+    QFont titleFont() const;
+    void setTitleFont( const QFont & );
+
+    virtual void showPage( QWidget * );
+
+    QWidget * currentPage() const;
+
+    QWidget* page( int ) const;
+    int pageCount() const;
+    int indexOf( QWidget* ) const;
+
+    virtual bool appropriate( QWidget * ) const;
+    virtual void setAppropriate( QWidget *, bool );
+
+    QPushButton * backButton() const;
+    QPushButton * nextButton() const;
+    QPushButton * finishButton() const;
+    QPushButton * cancelButton() const;
+    QPushButton * helpButton() const;
+
+    bool eventFilter( QObject *, QEvent * );
+
+public slots:
+    virtual void setBackEnabled( QWidget *, bool );
+    virtual void setNextEnabled( QWidget *, bool );
+    virtual void setFinishEnabled( QWidget *, bool );
+
+    virtual void setHelpEnabled( QWidget *, bool );
+
+    // obsolete
+    virtual void setFinish(  QWidget *, bool ) {}
+
+protected slots:
+    virtual void back();
+    virtual void next();
+    virtual void help();
+
+signals:
+    void helpClicked();
+    void selected( const QString& );
+
+protected:
+    virtual void layOutButtonRow( QHBoxLayout * );
+    virtual void layOutTitleRow( QHBoxLayout *, const QString & );
+
+private:
+    void setBackEnabled( bool );
+    void setNextEnabled( bool );
+
+    void setHelpEnabled( bool );
+
+    void setNextPage( QWidget * );
+
+    void updateButtons();
+
+    void layOut();
+
+    QWizardPrivate *d;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QWizard( const QWizard & );
+    QWizard& operator=( const QWizard & );
+#endif
+};
+
+#endif // QT_NO_WIZARD
+
+#endif // QWIZARD_H