Add Qt3 development HEAD version

4 files changed, 1897 insertions, 0 deletions

diff --git a/tools/designer/plugins/dlg/dlg.pro b/tools/designer/plugins/dlg/dlg.pro
new file mode 100644
index 0000000..ee93cb9
--- /dev/null
+++ b/tools/designer/plugins/dlg/dlg.pro
@@ -0,0 +1,13 @@
+TEMPLATE	= lib
+CONFIG		+= qt warn_on release plugin
+HEADERS		= dlg2ui.h
+SOURCES		= main.cpp dlg2ui.cpp
+DESTDIR		= ../../../../plugins/designer
+DEFINES 	+= QT_INTERNAL_XML
+include( ../../../../src/qt_professional.pri )
+TARGET		= dlgplugin
+INCLUDEPATH	+= ../../interfaces
+
+
+target.path += $$plugins.path/designer
+INSTALLS 	+= target
diff --git a/tools/designer/plugins/dlg/dlg2ui.cpp b/tools/designer/plugins/dlg/dlg2ui.cpp
new file mode 100644
index 0000000..c309eb2
--- /dev/null
+++ b/tools/designer/plugins/dlg/dlg2ui.cpp
@@ -0,0 +1,1632 @@
+/**********************************************************************
+**
+** Converts a Qt Architect 2.1+ .dlg file into a .ui file.
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of Qt Designer.
+**
+** 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.
+**
+** 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 "dlg2ui.h"
+#include <qfile.h>
+#include <qframe.h>
+#include <qmessagebox.h>
+#include <qregexp.h>
+#include <qtextstream.h>
+
+/*
+  Possible improvements:
+
+  1.  Convert layout stretch factors to size policy stretches, now
+      that Qt Designer supports the latter.
+*/
+
+/*
+  These big tables could be more or less eliminated by using Qt's
+  QMetaObject and QMetaProperty classes. However, the interface of
+  these classes is unwieldy for an otherwise non-GUI program like this
+  one, as we would have to create one dummy object for most QObject
+  subclasses in Qt. Let's take the safe road.
+*/
+
+static const char *widgetTypes[] = {
+    "Button", "ButtonGroup", "CheckBox", "ComboBox", "Dial", "DlgWidget",
+    "Frame", "Grid", "GroupBox", "HBox", "HButtonGroup", "HGroupBox",
+    "IconView", "LCDNumber", "Label", "LineEdit", "ListBox", "ListView",
+    "MenuBar", "MultiLineEdit", "ProgressBar", "PushButton", "RadioButton",
+    "ScrollBar", "ScrollView", "Slider", "SpinBox", "Splitter", "TabBar",
+    "TextBrowser", "TextView", "User", "VBox", "VButtonGroup", "VGroupBox", 0
+};
+
+/*
+  This table maps Qt Architect properties to Qt Designer properties.
+  If there is no corresponding Qt Designer property, qtName is 0 and
+  the property can be handled explicitly.
+*/
+static const struct {
+    const char *widgetName;
+    const char *architectName;
+    const char *qtName;
+    const char *type;
+} propertyDefs[] = {
+    { "Button", "AutoRepeat", "autoRepeat", "boolean" },
+    { "Button", "AutoResize", 0, 0 },
+    { "Button", "Text", "text", "qstring" },
+    { "ButtonGroup", "Exclusive", "exclusive", "boolean" },
+    { "ButtonGroup", "RadioButtonExclusive", "radioButtonExclusive",
+      "boolean" },
+    { "CheckBox", "Checked", "checked", "boolean" },
+    { "ComboBox", "AutoCompletion", "autoCompletion", "boolean" },
+    { "ComboBox", "AutoResize", 0, 0 },
+    { "ComboBox", "DuplicatesEnabled", "duplicatesEnabled", "boolean" },
+    { "ComboBox", "MaxCount", "maxCount", "integer" },
+    { "ComboBox", "Policy", "insertionPolicy", "enum" },
+    { "ComboBox", "SizeLimit", "sizeLimit", "integer" },
+    { "ComboBox", "Style", 0, 0 },
+    { "Dial", "Initial", "value", "integer" },
+    { "Dial", "LineStep", "lineStep", "integer" },
+    { "Dial", "MaxValue", "maxValue", "integer" },
+    { "Dial", "MinValue", "minValue", "integer" },
+    { "Dial", "NotchTarget", "notchTarget", "double" },
+    { "Dial", "PageStep", "pageStep", "integer" },
+    { "Dial", "ShowNotches", "notchesVisible", "boolean" },
+    { "Dial", "Tracking", "tracking", "boolean" },
+    { "Dial", "Wrapping", "wrapping", "boolean" },
+    { "DlgWidget", "AdjustSize", 0, 0 },
+    { "DlgWidget", "BackgroundMode", "backgroundMode", "enum" },
+    { "DlgWidget", "BackgroundOrigin", "backgroundOrigin", "enum" },
+    { "DlgWidget", "BackgroundPixmap", "backgroundPixmap", "qpixmap" },
+    { "DlgWidget", "DataLenName", 0, 0 },
+    { "DlgWidget", "DataVarName", 0, 0 },
+    { "DlgWidget", "Enabled", "enabled", "boolean" },
+    { "DlgWidget", "FocusPolicy", "focusPolicy", "enum" },
+    { "DlgWidget", "Font", "font", "qfont" },
+    { "DlgWidget", "FontPropagation", 0, 0 },
+    { "DlgWidget", "MaximumSize", "maximumSize", "qsize" },
+    { "DlgWidget", "MinimumSize", "minimumSize", "qsize" },
+    { "DlgWidget", "Name", 0, 0 },
+    { "DlgWidget", "Palette", "palette", "qpalette" },
+    { "DlgWidget", "PalettePropagation", 0, 0 },
+    { "DlgWidget", "ReadPixmapFromData", 0, 0 },
+    { "DlgWidget", "Rect", 0, 0 },
+    { "DlgWidget", "SignalConnection", 0, 0 },
+    { "DlgWidget", "UseBackgroudPixmap", 0, 0 },
+    { "DlgWidget", "Variable", 0, 0 },
+    { "Frame", "FrameMargin", "margin", "integer" },
+    { "Frame", "LineWidth", "lineWidth", "integer" },
+    { "Frame", "MidLineWidth", "midLineWidth", "integer" },
+    { "Frame", "Style", 0, 0 },
+    { "GroupBox", "Title", "title", "qstring" },
+    { "IconView", "AlignMode", 0, 0 },
+    { "IconView", "Aligning", 0, 0 },
+    { "IconView", "Arrangement", "arrangement", "enum" },
+    { "IconView", "AutoArrange", "autoArrange", "boolean" },
+    { "IconView", "EnableMoveItems", "itemsMovable", "boolean" },
+    { "IconView", "GridX", "gridX", "integer" },
+    { "IconView", "GridY", "gridY", "integer" },
+    { "IconView", "ItemTextPos", "itemTextPos", "enum" },
+    { "IconView", "ItemsMovable", "itemsMovable", "boolean" },
+    { "IconView", "MaxItemTextLength", "maxItemTextLength", "integer" },
+    { "IconView", "MaxItemWidth", "maxItemWidth", "integer" },
+    { "IconView", "ResizeMode", "resizeMode", "enum" },
+    { "IconView", "SelectionMode", "selectionMode", "enum" },
+    { "IconView", "ShowToolTips", "showToolTips", "boolean" },
+    { "IconView", "SortAscending", "sortDirection", "bool" },
+    { "IconView", "Spacing", "spacing", "integer" },
+    { "IconView", "WordWrapIconText", "wordWrapIconText", "boolean" },
+    { "LCDNumber", "Digits", "numDigits", "integer" },
+    { "LCDNumber", "Mode", "mode", "enum" },
+    { "LCDNumber", "SegmentStyle", "segmentStyle", "enum" },
+    { "LCDNumber", "SmallDecimalPoint", "smallDecimalPoint", "boolean" },
+    { "LCDNumber", "Value", 0, 0 },
+    { "Label", "AutoResize", 0, 0 },
+    { "Label", "Indent", "indent", "integer" },
+    { "Label", "Text", "text", "qstring" },
+    { "Label", "TextFormat", "textFormat", "enum" },
+    { "LineEdit", "EchoMode", "echoMode", "enum" },
+    { "LineEdit", "FrameShown", "frame", "boolean"  },
+    { "LineEdit", "MaxLength", "maxLength", "integer" },
+    { "LineEdit", "Text", "text", "qstring" },
+    { "ListBox", "AutoScroll", 0, 0 },
+    { "ListBox", "AutoUpdate", 0, 0 },
+    { "ListBox", "ColumnMode", "columnMode", "enum" },
+    { "ListBox", "DragSelect", 0, 0 },
+    { "ListBox", "RowMode", "rowMode", "enum" },
+    { "ListBox", "SelectionMode", "selectionMode", "enum" },
+    { "ListBox", "SmoothScrolling", 0, 0 },
+    { "ListView", "AllColumnsShowFocus", "allColumnsShowFocus", "boolean" },
+    { "ListView", "HeaderInformation", 0, 0 },
+    { "ListView", "ItemMargin", "itemMargin", "integer" },
+    { "ListView", "MultiSelection", "multiSelection", "boolean" },
+    { "ListView", "RootIsDecorated", "rootIsDecorated", "boolean" },
+    { "ListView", "TreeStepSize", "treeStepSize", "boolean" },
+    { "MultiLineEdit", "AutoUpdate", 0, 0 },
+    { "MultiLineEdit", "EchoMode", 0, 0 },
+    { "MultiLineEdit", "HorizontalMargin", 0, 0 },
+    { "MultiLineEdit", "MaxLength", 0, 0 },
+    { "MultiLineEdit", "MaxLineLength", 0, 0 },
+    { "MultiLineEdit", "MaxLines", 0, 0 },
+    { "MultiLineEdit", "OverwriteMode", 0, 0 },
+    { "MultiLineEdit", "ReadOnly", 0, 0 },
+    { "MultiLineEdit", "Text", 0, 0 },
+    { "MultiLineEdit", "UndoDepth", "undoDepth", "integer" },
+    { "MultiLineEdit", "UndoEnabled", 0, 0 },
+    { "MultiLineEdit", "WordWrap", 0, 0 },
+    { "MultiLineEdit", "WrapColumnOrWidth", 0, 0 },
+    { "MultiLineEdit", "WrapPolicy", 0, 0 },
+    { "ProgressBar", "CenterIndicator", "centerIndicator", "boolean" },
+    { "ProgressBar", "IndicatorFollowsStyle", "indicatorFollowsStyle",
+      "boolean" },
+    { "ProgressBar", "Progress", "progress", "integer" },
+    { "ProgressBar", "TotalSteps", "totalSteps", "integer" },
+    { "PushButton", "AutoDefault", "autoDefault", "boolean" },
+    { "PushButton", "Default", "default", "boolean" },
+    { "PushButton", "IsMenuButton", 0, 0 },
+    { "PushButton", "ToggleButton", "toggleButton", "boolean" },
+    { "RadioButton", "Checked", "checked", "boolean" },
+    { "ScrollBar", "Initial", "value", "integer" },
+    { "ScrollBar", "LineStep", "lineStep", "integer" },
+    { "ScrollBar", "MaxValue", "maxValue", "integer" },
+    { "ScrollBar", "MinValue", "minValue", "integer" },
+    { "ScrollBar", "Orientation", "orientation", "enum" },
+    { "ScrollBar", "PageStep", "pageStep", "integer" },
+    { "ScrollBar", "Tracking", "tracking", "boolean" },
+    { "ScrollView", "DragAutoScroll", "dragAutoScroll", "boolean" },
+    { "ScrollView", "HScrollBarMode", "hScrollBarMode", "enum" },
+    { "ScrollView", "ResizePolicy", "resizePolicy", "enum" },
+    { "ScrollView", "VScrollBarMode", "vScrollBarMode", "enum" },
+    { "Slider", "Initial", "value", "integer" },
+    { "Slider", "LineStep", "lineStep", "integer" },
+    { "Slider", "MaxValue", "maxValue", "integer" },
+    { "Slider", "MinValue", "minValue", "integer" },
+    { "Slider", "Orientation", "orientation", "enum" },
+    { "Slider", "PageStep", "pageStep", "integer" },
+    { "Slider", "TickInterval", "tickInterval", "integer" },
+    { "Slider", "Tickmarks", "tickmarks", "enum" },
+    { "Slider", "Tracking", "tracking", "boolean" },
+    { "SpinBox", "ButtonSymbols", "buttonSymbols", "enum" },
+    { "SpinBox", "MaxValue", "maxValue", "integer" },
+    { "SpinBox", "MinValue", "minValue", "integer" },
+    { "SpinBox", "Prefix", "prefix", "qstring" },
+    { "SpinBox", "SpecialValue", "specialValueText", "qstring" },
+    { "SpinBox", "Step", "lineStep", "integer" },
+    { "SpinBox", "Suffix", "suffix", "qstring" },
+    { "SpinBox", "Wrapping", "wrapping", "boolean" },
+    { "Splitter", "OpaqueResize", 0, 0 },
+    { "Splitter", "Orientation", "orientation", "enum" },
+    { "TabBar", "Shape", "shape", "enum" },
+    { "TabBar", "TabNames", 0, 0 },
+    { "TextView", "Context", 0, 0 },
+    { "TextView", "LinkUnderline", "linkUnderline", "boolean" },
+    { "TextView", "Text", "text", "qstring" },
+    { "TextView", "TextFormat", "textFormat", "enum" },
+    { "User", "UserClassHeader", 0, 0 },
+    { "User", "UserClassName", 0, 0 },
+    { 0, 0, 0, 0 }
+};
+
+/*
+  This is the number of supported color groups in a palette, and
+  supported color roles in a color group. Changing these constants is
+  dangerous.
+*/
+static const int NumColorRoles = 14;
+
+static bool isTrue( const QString& val )
+{
+    return val.lower() == QString( "true" );
+}
+
+static AttributeMap attribute( const QString& name, const QString& val )
+{
+    AttributeMap attr;
+    attr.insert( name, val );
+    return attr;
+}
+
+static QString entitize( const QString& str )
+{
+    QString t = str;
+    t.replace( '&', QString("&amp;") );
+    t.replace( '>', QString("&gt;") );
+    t.replace( '<', QString("&lt;") );
+    t.replace( '"', QString("&quot;") );
+    t.replace( '\'', QString("&apos;") );
+    return t;
+}
+
+QString Dlg2Ui::alias( const QString& name ) const
+{
+    if ( yyAliasMap.contains(name) )
+	return yyAliasMap[name];
+    else
+	return name;
+}
+
+QString Dlg2Ui::opening( const QString& tag, const AttributeMap& attr )
+{
+    QString t = QChar( '<' ) + tag;
+    AttributeMap::ConstIterator a = attr.begin();
+    while ( a != attr.end() ) {
+	t += QChar( ' ' ) + a.key() + QString( "=\"" ) + entitize( *a ) +
+	     QChar( '"' );
+	++a;
+    }
+    t += QChar( '>' );
+    return t;
+}
+
+QString Dlg2Ui::closing( const QString& tag )
+{
+    return opening( QChar('/') + tag );
+}
+
+void Dlg2Ui::error( const QString& message )
+{
+    if ( numErrors++ == 0 )
+	QMessageBox::warning( 0, yyFileName, message );
+}
+
+void Dlg2Ui::syntaxError()
+{
+    error( QString("Sorry, I met a random syntax error. I did what I could, but"
+		   " that was not enough."
+		   "<p>You might want to write to"
+		   " <tt>qt-bugs@trolltech.com</tt> about this incident.") );
+}
+
+QString Dlg2Ui::getTextValue( const QDomNode& node )
+{
+    if ( node.childNodes().count() > 1 ) {
+	syntaxError();
+	return QString::null;
+    }
+
+    if ( node.childNodes().count() == 0 )
+	return QString::null;
+
+    QDomText child = node.firstChild().toText();
+    if ( child.isNull() ) {
+	syntaxError();
+	return QString::null;
+    }
+    QString t = child.data().stripWhiteSpace();
+    t.replace( "\\\\", "\\" );
+    t.replace( "\\n", "\n" );
+    return t;
+}
+
+QVariant Dlg2Ui::getValue( const QDomNodeList& children, const QString& tagName,
+			   const QString& type )
+{
+    for ( int i = 0; i < (int) children.count(); i++ ) {
+	QDomNode n = children.item( i );
+	if ( n.toElement().tagName() == tagName )
+	    return getValue( n.toElement(), tagName, type );
+    }
+    return QVariant();
+}
+
+void Dlg2Ui::emitHeader()
+{
+    yyOut += QString( "<!DOCTYPE UI><UI version=\"3.0\" stdsetdef=\"1\">\n" );
+}
+
+void Dlg2Ui::emitFooter()
+{
+    yyOut += QString( "</UI>\n" );
+}
+
+void Dlg2Ui::emitSimpleValue( const QString& tag, const QString& value,
+			      const AttributeMap& attr )
+{
+    yyOut += yyIndentStr + opening( tag, attr ) + entitize( value ) +
+	     closing( tag ) + QChar( '\n' );
+}
+
+void Dlg2Ui::emitOpening( const QString& tag, const AttributeMap& attr )
+{
+    yyOut += yyIndentStr + opening( tag, attr ) + QChar( '\n' );
+    yyIndentStr += QString( "    " );
+}
+
+void Dlg2Ui::emitClosing( const QString& tag )
+{
+    yyIndentStr.truncate( yyIndentStr.length() - 4 );
+    yyOut += yyIndentStr + closing( tag ) + QChar( '\n' );
+}
+
+void Dlg2Ui::emitOpeningWidget( const QString& className )
+{
+    AttributeMap attr = attribute( QString("class"), className );
+    if ( yyGridColumn >= 0 ) {
+	attr.insert( QString("row"), QString::number(yyGridRow) );
+	attr.insert( QString("column"), QString::number(yyGridColumn) );
+	yyGridColumn = -1;
+    }
+    emitOpening( QString("widget"), attr );
+}
+
+QString Dlg2Ui::widgetClassName( const QDomElement& e )
+{
+    if ( e.tagName() == QString("User") ) {
+	return getValue( e.childNodes(), QString("UserClassName") )
+			 .toString();
+    } else if ( e.tagName() == QString("DlgWidget") ) {
+	return QString( "QWidget" );
+    } else {
+	return QChar( 'Q' ) + e.tagName();
+    }
+}
+
+void Dlg2Ui::emitColor( const QColor& color )
+{
+    emitOpening( QString("color") );
+    emitSimpleValue( QString("red"), QString::number(color.red()) );
+    emitSimpleValue( QString("green"), QString::number(color.green()) );
+    emitSimpleValue( QString("blue"), QString::number(color.blue()) );
+    emitClosing( QString("color") );
+}
+
+void Dlg2Ui::emitColorGroup( const QString& name, const QColorGroup& group )
+{
+    emitOpening( name );
+    for ( int i = 0; i < NumColorRoles; i++ )
+	emitColor( group.color((QColorGroup::ColorRole) i) );
+    emitClosing( name );
+}
+
+void Dlg2Ui::emitVariant( const QVariant& val, const QString& stringType )
+{
+    if ( val.isValid() ) {
+	switch ( val.type() ) {
+	case QVariant::String:
+	    emitSimpleValue( stringType, val.toString() );
+	    break;
+	case QVariant::CString:
+	    emitSimpleValue( QString("cstring"), val.toString() );
+	    break;
+	case QVariant::Bool:
+	    emitSimpleValue( QString("bool"),
+			     QString(val.toBool() ? "true" : "false") );
+	    break;
+	case QVariant::Int:
+	case QVariant::UInt:
+	    emitSimpleValue( QString("number"), val.toString() );
+	    break;
+	case QVariant::Rect:
+	    emitOpening( QString("rect") );
+	    emitSimpleValue( QString("x"), QString::number(val.toRect().x()) );
+	    emitSimpleValue( QString("y"), QString::number(val.toRect().y()) );
+	    emitSimpleValue( QString("width"),
+			     QString::number(val.toRect().width()) );
+	    emitSimpleValue( QString("height"),
+			     QString::number(val.toRect().height()) );
+	    emitClosing( QString("rect") );
+	    break;
+	case QVariant::Point:
+	    emitOpening( QString("point") );
+	    emitSimpleValue( QString("x"), QString::number(val.toPoint().x()) );
+	    emitSimpleValue( QString("y"), QString::number(val.toPoint().y()) );
+	    emitClosing( QString("point") );
+	    break;
+	case QVariant::Size:
+	    emitOpening( QString("size") );
+	    emitSimpleValue( QString("width"),
+			     QString::number(val.toSize().width()) );
+	    emitSimpleValue( QString("height"),
+			     QString::number(val.toSize().height()) );
+	    emitClosing( QString("size") );
+	    break;
+	case QVariant::Color:
+	    emitColor( val.toColor() );
+	    break;
+	case QVariant::Font:
+	    emitOpening( QString("font") );
+	    emitSimpleValue( QString("family"), val.toFont().family() );
+	    emitSimpleValue( QString("pointsize"),
+			     QString::number(val.toFont().pointSize()) );
+	    if ( val.toFont().bold() )
+		emitSimpleValue( QString("bold"), QChar('1') );
+	    if ( val.toFont().italic() )
+		emitSimpleValue( QString("italic"), QChar('1') );
+	    if ( val.toFont().underline() )
+		emitSimpleValue( QString("underline"), QChar('1') );
+	    if ( val.toFont().strikeOut() )
+		emitSimpleValue( QString("strikeout"), QChar('1') );
+	    emitClosing( QString("font") );
+	    break;
+	case QVariant::Palette:
+	    emitOpening( QString("palette") );
+	    emitColorGroup( QString("active"), val.toPalette().active() );
+	    emitColorGroup( QString("disabled"), val.toPalette().disabled() );
+	    emitColorGroup( QString("inactive"), val.toPalette().inactive() );
+	    emitClosing( QString("palette") );
+	    break;
+	default:
+	    emitSimpleValue( QString("fnord"), QString::null );
+	}
+    }
+}
+
+void Dlg2Ui::emitProperty( const QString& prop, const QVariant& val,
+			   const QString& stringType )
+{
+    emitOpening( QString("property"), attribute(QString("name"), prop) );
+    emitVariant( val, stringType );
+    emitClosing( QString("property") );
+}
+
+void Dlg2Ui::emitAttribute( const QString& attr, const QVariant& val,
+			    const QString& stringType )
+{
+    emitOpening( QString("attribute"), attribute(QString("name"), attr) );
+    emitVariant( val, stringType );
+    emitClosing( QString("attribute") );
+}
+
+void Dlg2Ui::emitOpeningLayout( bool needsWidget, const QString& layoutKind,
+				const QString& name, int border,
+				int autoBorder )
+{
+    QString namex = name;
+
+    if ( namex.isEmpty() )
+	namex = QString( "Layout%1" ).arg( uniqueLayout++ );
+
+    if ( needsWidget ) {
+	emitOpeningWidget( QString("QLayoutWidget") );
+	emitProperty( QString("name"), namex.latin1() );
+    }
+    emitOpening( layoutKind );
+    if ( !needsWidget )
+	emitProperty( QString("name"), namex.latin1() );
+    if ( border != 5 )
+	emitProperty( QString("margin"), border );
+    if ( autoBorder != 5 )
+	emitProperty( QString("spacing"), autoBorder );
+    yyLayoutDepth++;
+}
+
+void Dlg2Ui::flushWidgets()
+{
+    QRegExp widgetForLayout( QString("Q(?:[HV]Box|Grid)") );
+
+    while ( !yyWidgetMap.isEmpty() ) {
+	QString className = widgetClassName( *yyWidgetMap.begin() );
+	if ( !widgetForLayout.exactMatch(className) ) {
+	    emitOpeningWidget( className );
+	    emitWidgetBody( *yyWidgetMap.begin(), FALSE );
+	    emitClosing( QString("widget") );
+	}
+	yyWidgetMap.remove( yyWidgetMap.begin() );
+    }
+}
+
+void Dlg2Ui::emitClosingLayout( bool needsWidget, const QString& layoutKind )
+{
+    yyLayoutDepth--;
+    /*
+      Qt Designer can deal with layouted widgets and with
+      fixed-position widgets, but not both at the same time. If such a
+      thing happens, we arbitrarily put the fixed-position widgets in
+      the layout so that they at least show up in Qt Designer.
+    */
+    if ( yyLayoutDepth == 0 )
+	flushWidgets();
+
+    emitClosing( layoutKind );
+    if ( needsWidget )
+	emitClosing( QString("widget") );
+}
+
+bool Dlg2Ui::isWidgetType( const QDomElement& e )
+{
+    return yyWidgetTypeSet.contains( e.tagName() );
+}
+
+void Dlg2Ui::emitSpacer( int spacing, int stretch )
+{
+    QString orientationStr;
+    QSize sizeHint;
+    QString sizeType = QString( "Fixed" );
+
+    if ( yyBoxKind == QString("hbox") ) {
+	orientationStr = QString( "Horizontal" );
+	sizeHint = QSize( spacing, 20 );
+    } else {
+	orientationStr = QString( "Vertical" );
+	sizeHint = QSize( 20, spacing );
+    }
+    if ( stretch > 0 )
+	sizeType = QString( "Expanding" );
+
+    emitOpening( QString("spacer") );
+    emitProperty( QString("name"),
+		  QString("Spacer%1").arg(uniqueSpacer++).latin1() );
+    emitProperty( QString("orientation"), orientationStr, QString("enum") );
+    if ( spacing > 0 )
+	emitProperty( QString("sizeHint"), sizeHint, QString("qsize") );
+    emitProperty( QString("sizeType"), sizeType, QString("enum") );
+    emitClosing( QString("spacer") );
+}
+
+QString Dlg2Ui::filteredFlags( const QString& flags, const QRegExp& filter )
+{
+    QRegExp evil( QString("[^0-9A-Z_a-z|]") );
+
+    QString f = flags;
+    f.replace( evil, QString::null );
+    QStringList splitted = QStringList::split( QChar('|'), f );
+    return splitted.grep( filter ).join( QChar('|') );
+}
+
+void Dlg2Ui::emitFrameStyleProperty( int style )
+{
+    QString shape;
+    QString shadow;
+
+    switch ( style & QFrame::MShape ) {
+    case QFrame::Box:
+	shape = QString( "Box" );
+	break;
+    case QFrame::Panel:
+	shape = QString( "Panel" );
+	break;
+    case QFrame::WinPanel:
+	shape = QString( "WinPanel" );
+	break;
+    case QFrame::HLine:
+	shape = QString( "HLine" );
+	break;
+    case QFrame::VLine:
+	shape = QString( "VLine" );
+	break;
+    case QFrame::StyledPanel:
+	shape = QString( "StyledPanel" );
+	break;
+    case QFrame::PopupPanel:
+	shape = QString( "PopupPanel" );
+	break;
+    case QFrame::MenuBarPanel:
+	shape = QString( "MenuBarPanel" );
+	break;
+    case QFrame::ToolBarPanel:
+	shape = QString( "ToolBarPanel" );
+	break;
+    case QFrame::LineEditPanel:
+	shape = QString( "LineEditPanel" );
+	break;
+    case QFrame::TabWidgetPanel:
+	shape = QString( "TabWidgetPanel" );
+	break;
+    case QFrame::GroupBoxPanel:
+	shape = QString( "GroupBoxPanel" );
+	break;
+    default:
+	shape = QString( "NoFrame" );
+    }
+
+    switch ( style & QFrame::MShadow ) {
+    case QFrame::Raised:
+	shadow = QString( "Raised" );
+	break;
+    case QFrame::Sunken:
+	shadow = QString( "Sunken" );
+	break;
+    default:
+	shadow = QString( "Plain" );
+    }
+
+    emitProperty( QString("frameShape"), shape, QString("enum") );
+    emitProperty( QString("frameShadow"), shadow, QString("enum") );
+}
+
+void Dlg2Ui::emitWidgetBody( const QDomElement& e, bool layouted )
+{
+    QRegExp align( QString("^(?:Align|WordBreak$)") );
+    QRegExp frameShape( QString(
+	    "^(?:NoFrame|Box|(?:Win|Styled|Popup|(?:Menu|Tool)Bar)?Panel|"
+	    "[HV]Line)$") );
+    QRegExp frameShadow( QString( "^(?:Plain|Raised|Sunken)$") );
+    QRegExp numeric( QString("[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+") );
+    QRegExp connex( QString(
+	    "\\s*\\[(BaseClass|P(?:ublic|rotected))\\]\\s*([0-9A-Z_a-z]+)\\s*"
+	    "-->\\s*([0-9A-Z_a-z]+)\\s*(\\([^()]*\\))\\s*") );
+    QRegExp qdialogSlots( QString(
+	    "done\\(\\s*int\\s*\\)|(?:accept|reject)\\(\\s*\\)") );
+
+    QString userClassHeader;
+    QString userClassName;
+    QString parentTagName;
+    QString name;
+    QString variableName;
+    QMap<QString, int> pp;
+
+    QDomNode n = e;
+    while ( !n.isNull() ) {
+	if ( isWidgetType(n.toElement()) ) {
+	    parentTagName = n.toElement().tagName();
+	    pp = yyPropertyMap[parentTagName];
+	    n = n.firstChild();
+	} else {
+	    QString tagName = n.toElement().tagName();
+
+	    QMap<QString, int>::ConstIterator p = pp.find( tagName );
+	    if ( p == pp.end() ) {
+		/*
+		  These properties are not in the propertyDefs table,
+		  since they are found in many classes anyway and need
+		  to be treated the same in each case.
+		*/
+		if ( tagName == QString("Alignement") ||
+		     tagName == QString("Alignment") ) {
+		    QString flags = getValue( n.toElement(), tagName )
+				    .toString();
+		    flags = filteredFlags( flags, align );
+		    if ( !flags.isEmpty() )
+			emitProperty( QString("alignment"), flags,
+				      QString("set") );
+		} else if ( tagName == QString("ItemList") ) {
+		    QDomNode child = n.firstChild();
+		    while ( !child.isNull() ) {
+			if ( child.toElement().tagName() == QString("Item") ) {
+			    QString text = getTextValue( child );
+			    emitOpening( QString("item") );
+			    emitProperty( QString("text"), text );
+			    emitClosing( QString("item") );
+			}
+			child = child.nextSibling();
+		    }
+		}
+	    } else {
+		QString propertyName( propertyDefs[*p].qtName );
+
+		if ( propertyName.isEmpty() ) {
+		    /*
+		      These properties are in the propertyDefs table,
+		      but they have no direct Qt equivalent.
+		    */
+		    if ( parentTagName == QString("ComboBox") ) {
+			if ( tagName == QString("Style") ) {
+			    if ( getTextValue(n) == QString("ReadWrite") )
+				emitProperty( QString("editable"),
+					      QVariant(TRUE, 0) );
+			}
+		    } else if ( parentTagName == QString("DlgWidget") ) {
+			if ( tagName == QString("Name") ) {
+			    name = getTextValue( n );
+			} else if ( tagName == QString("Rect") ) {
+			    QRect rect = getValue( n.toElement(), tagName,
+						   QString("qrect") )
+					 .toRect();
+			    if ( !layouted )
+				emitProperty( QString("geometry"), rect,
+					      QString("qrect") );
+			} else if ( tagName == QString("SignalConnection") ) {
+			    QDomNode child = n.firstChild();
+			    while ( !child.isNull() ) {
+				if ( child.toElement().tagName() ==
+				     QString("Signal") ) {
+				    QString text = getTextValue( child );
+				    if ( connex.exactMatch(text) ) {
+					DlgConnection c;
+					c.sender = getValue(
+						n.parentNode().childNodes(),
+						QString("Name") ).toString();
+					c.signal = connex.cap( 2 ) +
+						   connex.cap( 4 );
+					c.slot = connex.cap( 3 ) +
+						 connex.cap( 4 );
+					yyConnections.append( c );
+
+					if ( connex.cap(1) !=
+					     QString("BaseClass") &&
+					     !qdialogSlots.exactMatch(c.slot) )
+					    yySlots.insert( c.slot,
+							    connex.cap(1) );
+				    }
+				}
+				child = child.nextSibling();
+			    }
+			} else if ( tagName == QString("Variable") ) {
+			    variableName = getTextValue( n );
+			}
+		    } else if ( parentTagName == QString("Frame") ) {
+			if ( tagName == QString("Style") ) {
+			    int style = getValue( n.toElement(), tagName,
+						  QString("integer") ).toInt();
+			    emitFrameStyleProperty( style );
+			}
+		    } else if ( parentTagName == QString("LCDNumber") ) {
+			if ( tagName == QString("Value") ) {
+			    QString text = getValue( n.toElement(), tagName )
+					   .toString();
+			    if ( numeric.exactMatch(text) )
+				emitProperty( QString("value"),
+					      text.toDouble() );
+			}
+		    } else if ( parentTagName == QString("ListView") ) {
+			if ( tagName == QString("HeaderInformation") ) {
+			    int columnNo = 1;
+			    QDomNode child = n.firstChild();
+			    while ( !child.isNull() ) {
+				if ( child.toElement().tagName() ==
+				     QString("Header") ) {
+				    QString text = getValue( child.childNodes(),
+							     QString("Text") )
+						   .toString();
+				    if ( text.isEmpty() )
+					text = QString( "Column %1" )
+					       .arg( columnNo );
+				    emitOpening( QString("column") );
+				    emitProperty( QString("text"), text );
+				    emitClosing( QString("column") );
+				}
+				child = child.nextSibling();
+				columnNo++;
+			    }
+			}
+		    } else if ( parentTagName == QString("TabBar") ) {
+			if ( tagName == QString("TabNames") ) {
+			    QDomNode child = n.firstChild();
+			    while ( !child.isNull() ) {
+				if ( child.toElement().tagName() ==
+				     QString("Tab") ) {
+				    QString text = getTextValue( child );
+				    emitOpeningWidget( QString("QWidget") );
+				    emitProperty( QString("name"), "tab" );
+				    emitAttribute( QString("title"), text );
+				    emitClosing( QString("widget") );
+				}
+				child = child.nextSibling();
+			    }
+			}
+		    } else if ( parentTagName == QString("User") ) {
+			if ( tagName == QString("UserClassHeader") ) {
+			    userClassHeader = getTextValue( n );
+			} else if ( tagName == QString("UserClassName") ) {
+			    userClassName = getTextValue( n );
+			}
+		    }
+		} else {
+		    /*
+		      These properties are in the propertyDefs table;
+		      they have a direct Qt equivalent.
+		    */
+		    QString type( propertyDefs[*p].type );
+		    QVariant val = getValue( n.toElement(), tagName, type );
+
+		    if ( type == QString("qstring") )
+			type = QString( "string" );
+
+		    bool omit = FALSE;
+		    if ( propertyName == QString("backgroundOrigin") &&
+			 val.toString() == QString("WidgetOrigin") )
+			omit = TRUE;
+		    if ( propertyName == QString("enabled") && val.toBool() )
+			omit = TRUE;
+		    if ( propertyName == QString("minimumSize") &&
+			 val.toSize() == QSize(-1, -1) )
+			omit = TRUE;
+		    if ( propertyName == QString("maximumSize") &&
+			 val.toSize() == QSize(32767, 32767) )
+			omit = TRUE;
+
+		    if ( !omit )
+			emitProperty( propertyName, val, type );
+		}
+	    }
+	    n = n.nextSibling();
+	}
+    }
+
+    if ( !variableName.isEmpty() ) {
+	yyAliasMap.insert( name, variableName );
+	name = variableName;
+    }
+    if ( !name.isEmpty() )
+	emitProperty( QString("name"), name.latin1() );
+
+    if ( !userClassName.isEmpty() )
+	yyCustomWidgets.insert( userClassName, userClassHeader );
+}
+
+bool Dlg2Ui::checkTagName( const QDomElement& e, const QString& tagName )
+{
+    bool ok = ( e.tagName() == tagName );
+    if ( !ok )
+	syntaxError();
+    return ok;
+}
+
+QString Dlg2Ui::normalizeType( const QString& type )
+{
+    QString t = type;
+    if ( t.isEmpty() || t == QString("enum") || t == QString( "qcstring" ) ||
+	 t == QString("set") )
+	t = QString( "qstring" );
+    return t;
+}
+
+QVariant Dlg2Ui::getValue( const QDomElement& e, const QString& tagName,
+			   const QString& type )
+{
+    QVariant val;
+
+    if ( e.tagName() != tagName )
+	return val;
+
+    QString t = e.attributes().namedItem( "type" ).toAttr().value();
+    if ( normalizeType(t) != normalizeType(type) )
+	return val;
+
+    if ( type == QString("integer") ) {
+	return getTextValue( e ).toInt();
+    } else if ( type == QString("boolean") ) {
+	return QVariant( isTrue(getTextValue(e)), 0 );
+    } else if ( type == QString("double") ) {
+	return getTextValue( e ).toDouble();
+    } else if ( type == QString("qcstring") ) {
+	return getTextValue( e ).latin1();
+    } else if ( type == QString("enum") || type == QString("qstring") ||
+		type == QString("set") ) {
+	return getTextValue( e );
+    } else {
+	QDomNodeList children = e.childNodes();
+
+	if ( type == QString("qsize") ) {
+	    int width = getValue( children, QString("Width"),
+				  QString("integer") ).toInt();
+	    int height = getValue( children, QString("Height"),
+				   QString("integer") ).toInt();
+	    return QSize( width, height );
+	} else if ( type == QString("qrect") ) {
+	    int x = getValue( children, QString("X"), QString("integer") )
+		    .toInt();
+	    int y = getValue( children, QString("Y"), QString("integer") )
+		    .toInt();
+	    int width = getValue( children, QString("Width"),
+				  QString("integer") ).toInt();
+	    int height = getValue( children, QString("Height"),
+				   QString("integer") ).toInt();
+	    return QRect( x, y, width, height );
+	} else if ( type == QString("qpoint") ) {
+	    int x = getValue( children, QString("X"), QString("integer") )
+		    .toInt();
+	    int y = getValue( children, QString("Y"), QString("integer") )
+		    .toInt();
+	    return QPoint( x, y );
+	} else if ( type == QString("qpalette") ) {
+	    QColorGroup active = getValue( children, QString("Active"),
+					   QString("qcolorgroup") )
+					   .toColorGroup();
+	    QColorGroup disabled = getValue( children, QString("Disabled"),
+					   QString("qcolorgroup") )
+					   .toColorGroup();
+	    QColorGroup inactive = getValue( children, QString("Inactive"),
+					   QString("qcolorgroup") )
+					   .toColorGroup();
+	    return QPalette( active, disabled, inactive );
+	} else if ( type == QString("qfont") ) {
+	    QString family = getValue( children, QString("Family"),
+				       QString("qstring") ).toString();
+	    int pointSize = getValue( children, QString("PointSize"),
+				      QString("integer") ).toInt();
+	    int weight = getValue( children, QString("weight"),
+				   QString("integer") ).toInt();
+	    bool italic = getValue( children, QString("Italic"),
+				    QString("boolean") ).toBool();
+	    bool underline = getValue( children, QString("Underline"),
+				       QString("boolean") ).toBool();
+	    bool strikeOut = getValue( children, QString("StrikeOut"),
+				       QString("boolean") ).toBool();
+	    int styleHint = getValue( children, QString("StyleHint"),
+				      QString("integer") ).toInt();
+
+	    QFont f;
+	    if ( !family.isEmpty() )
+		f.setFamily( family );
+	    if ( pointSize != 0 )
+		f.setPointSize( pointSize );
+	    if ( weight != 0 )
+		f.setWeight( weight );
+	    f.setItalic( italic );
+	    f.setUnderline( underline );
+	    f.setStrikeOut( strikeOut );
+	    if ( styleHint != 0 )
+		f.setStyleHint( (QFont::StyleHint) styleHint );
+	    return f;
+	} else if ( type == QString("qcolor") ) {
+	    // if any component missing, zero is to be assumed
+	    int red = getValue( children, QString("Red"), QString("integer") )
+		      .toInt();
+	    int green = getValue( children, QString("Green"),
+				  QString("integer") ).toInt();
+	    int blue = getValue( children, QString("Blue"), QString("integer") )
+		       .toInt();
+	    return QColor( red, green, blue );
+	} else if ( type == QString("qcolorgroup") ) {
+	    static const QColorGroup::ColorRole roles[NumColorRoles] = {
+		QColorGroup::Foreground, QColorGroup::Button,
+		QColorGroup::Light, QColorGroup::Midlight, QColorGroup::Dark,
+		QColorGroup::Mid, QColorGroup::Text, QColorGroup::BrightText,
+		QColorGroup::ButtonText, QColorGroup::Base,
+		QColorGroup::Background, QColorGroup::Shadow,
+		QColorGroup::Highlight, QColorGroup::HighlightedText
+	    };
+	    static const char * const roleNames[NumColorRoles] = {
+		"Foreground", "Button", "Light", "MidLight", "Dark", "Mid",
+		"Text", "BrightText", "ButtonText", "Base", "Background",
+		"Shadow", "HighLighted", "HighLightedText"
+	    };
+	    QColorGroup group;
+
+	    for ( int i = 0; i < NumColorRoles; i++ )
+		group.setColor( roles[i],
+				getValue(children, QString(roleNames[i]),
+					 QString("qcolor")).toColor() );
+	    return group;
+	} else {
+	    syntaxError();
+	}
+    }
+    return val;
+}
+
+void Dlg2Ui::matchDialogCommon( const QDomElement& dialogCommon )
+{
+    if ( !checkTagName(dialogCommon, QString("DialogCommon")) )
+	return;
+
+    QString sourceDir;
+    QString classHeader;
+    QString classSource;
+    QString dataHeader;
+    QString dataSource;
+    QString dataName;
+    QString windowBaseClass( "QDialog" );
+    bool isCustom = FALSE;
+    QString customBaseHeader;
+    QString windowCaption;
+
+    yyClassName = "Form1";
+
+    QDomNode n = dialogCommon.firstChild();
+    while ( !n.isNull() ) {
+	QString tagName = n.toElement().tagName();
+	QString val = getTextValue( n );
+
+	if ( tagName == QString("SourceDir") ) {
+	    sourceDir = val;
+	} else if ( tagName == QString("ClassHeader") ) {
+	    classHeader = val;
+	} else if ( tagName == QString("ClassSource") ) {
+	    classSource = val;
+	} else if ( tagName == QString("ClassName") ) {
+	    yyClassName = val;
+	} else if ( tagName == QString("DataHeader") ) {
+	    dataHeader = val;
+	} else if ( tagName == QString("DataSource") ) {
+	    dataSource = val;
+	} else if ( tagName == QString("DataName") ) {
+	    dataName = val;
+	} else if ( tagName == QString("WindowBaseClass") ) {
+	    if ( val == QString("Custom") )
+		isCustom = TRUE;
+	    else
+		windowBaseClass = val;
+	} else if ( tagName == QString("IsModal") ) {
+	} else if ( tagName == QString("CustomBase") ) {
+	    windowBaseClass = val;
+	} else if ( tagName == QString("CustomBaseHeader") ) {
+	    customBaseHeader = val;
+	} else if ( tagName == QString("WindowCaption") ) {
+	    windowCaption = val;
+	}
+	n = n.nextSibling();
+    }
+
+    emitSimpleValue( QString("class"), yyClassName );
+    emitOpeningWidget( windowBaseClass );
+
+    if ( windowCaption.isEmpty() )
+	windowCaption = yyClassName;
+    emitProperty( QString("name"), yyClassName.latin1() );
+    emitProperty( QString("caption"), windowCaption );
+
+    if ( isCustom )
+	yyCustomWidgets.insert( windowBaseClass, customBaseHeader );
+}
+
+bool Dlg2Ui::needsQLayoutWidget( const QDomElement& e )
+{
+    QRegExp widgetExists( QString("WidgetLayout|Layout_Widget") );
+
+    // we should also check that the widget is not a QHBox, QVBox, or QGrid
+    QString grandpa = e.parentNode().parentNode().toElement().tagName();
+    return !widgetExists.exactMatch( grandpa );
+}
+
+void Dlg2Ui::matchBoxLayout( const QDomElement& boxLayout )
+{
+    QString directionStr;
+    QString prevBoxKind = yyBoxKind;
+    int border = 5;
+    int autoBorder = 5;
+    QString name;
+    bool needsWidget = needsQLayoutWidget( boxLayout );
+    bool opened = FALSE;
+
+    QDomNode n = boxLayout.firstChild();
+    while ( !n.isNull() ) {
+	QString tagName = n.toElement().tagName();
+
+	if ( tagName == QString("Children") ) {
+	    if ( !opened ) {
+		emitOpeningLayout( needsWidget, yyBoxKind, name, border,
+				   autoBorder );
+		if ( !directionStr.isEmpty() )
+		    emitProperty( QString("direction"), directionStr,
+				  QString("enum") );
+		opened = TRUE;
+	    }
+	    matchLayout( n.toElement() );
+	} else {
+	    QString val = getTextValue( n );
+
+	    if ( tagName == QString("Direction") ) {
+		if ( val == QString("LeftToRight") ) {
+		    yyBoxKind = QString( "hbox" );
+		} else if ( val == QString("RightToLeft") ) {
+		    directionStr = val;
+		    yyBoxKind = QString( "hbox" );
+		} else if ( val == QString("TopToBottom") ) {
+		    yyBoxKind = QString( "vbox" );
+		} else if ( val == QString("BottomToTop") ) {
+		    directionStr = val;
+		    yyBoxKind = QString( "vbox" );
+		} else {
+		    syntaxError();
+		}
+	    } else if ( tagName == QString("Border") ) {
+		border = val.toInt();
+	    } else if ( tagName == QString("AutoBorder") ) {
+		autoBorder = val.toInt();
+	    } else if ( tagName == QString("Name") ) {
+		name = val;
+	    }
+	}
+
+	n = n.nextSibling();
+    }
+    if ( opened ) {
+	emitClosingLayout( needsWidget, yyBoxKind );
+	yyBoxKind = prevBoxKind;
+    }
+}
+
+void Dlg2Ui::matchBoxSpacing( const QDomElement& boxSpacing )
+{
+    int spacing = 7;
+
+    QDomNode n = boxSpacing.firstChild();
+    while ( !n.isNull() ) {
+	QString val = getTextValue( n );
+
+	if ( n.toElement().tagName() == QString("Spacing") )
+	    spacing = val.toInt();
+	n = n.nextSibling();
+    }
+    emitSpacer( spacing, 0 );
+}
+
+void Dlg2Ui::matchBoxStretch( const QDomElement& boxStretch )
+{
+    int stretch = 1;
+
+    QDomNode n = boxStretch.firstChild();
+    while ( !n.isNull() ) {
+	QString val = getTextValue( n );
+
+	if ( n.toElement().tagName() == QString("Stretch") )
+	    stretch = val.toInt();
+	n = n.nextSibling();
+    }
+    emitSpacer( 0, stretch );
+}
+
+void Dlg2Ui::matchGridLayout( const QDomElement& gridLayout )
+{
+    int oldGridRow = yyGridRow;
+    int oldGridColumn = yyGridColumn;
+    int border = 5;
+    int autoBorder = 5;
+    QString name;
+    QString menu;
+    bool needsWidget = needsQLayoutWidget( gridLayout );
+    bool opened = FALSE;
+
+    QDomNode n = gridLayout.firstChild();
+    while ( !n.isNull() ) {
+	QString tagName = n.toElement().tagName();
+
+	if ( tagName == QString("Children") ) {
+	    if ( !opened ) {
+		emitOpeningLayout( needsWidget, QString("grid"), name, border,
+				   autoBorder );
+		yyGridRow = -1;
+		yyGridColumn = -1;
+		opened = TRUE;
+	    }
+	    matchLayout( n.toElement() );
+	} else {
+	    if ( tagName == QString("Border") ) {
+		border = getTextValue( n ).toInt();
+	    } else if ( tagName == QString("AutoBorder") ) {
+		autoBorder = getTextValue( n ).toInt();
+	    } else if ( tagName == QString("Name") ) {
+		name = getTextValue( n );
+	    } else if ( tagName == QString("Menu") ) {
+		menu = getTextValue( n );
+	    }
+	}
+	n = n.nextSibling();
+    }
+    if ( opened )
+	emitClosingLayout( needsWidget, QString("grid") );
+    yyGridRow = oldGridRow;
+    yyGridColumn = oldGridColumn;
+}
+
+void Dlg2Ui::matchGridRow( const QDomElement& gridRow )
+{
+    yyGridRow++;
+
+    QDomNode n = gridRow.firstChild();
+    while ( !n.isNull() ) {
+	QString tagName = n.toElement().tagName();
+
+	if ( tagName == QString("Children") ) {
+	    yyGridColumn = 0;
+	    matchLayout( n.toElement() );
+	}
+	n = n.nextSibling();
+    }
+}
+
+void Dlg2Ui::matchGridSpacer( const QDomElement& gridSpacer )
+{
+    if ( !gridSpacer.firstChild().isNull() )
+	syntaxError();
+}
+
+void Dlg2Ui::matchLayoutWidget( const QDomElement& layoutWidget )
+{
+    QDomElement children;
+    QString widget;
+
+    QDomNode n = layoutWidget.firstChild();
+    while ( !n.isNull() ) {
+	QString tagName = n.toElement().tagName();
+
+	if ( tagName == QString("Children") )
+	    children = n.toElement();
+	else if ( tagName == QString("Widget") )
+	    widget = getTextValue( n );
+	n = n.nextSibling();
+    }
+
+    if ( !widget.isEmpty() ) {
+	QMap<QString, QDomElement>::Iterator w = yyWidgetMap.find( widget );
+	if ( w == yyWidgetMap.end() ) {
+	    syntaxError();
+	} else {
+	    QString className = widgetClassName( *w );
+	    if ( className == QString("QHBox") ||
+		 className == QString("QVBox") ) {
+		bool needsWidget = needsQLayoutWidget( layoutWidget );
+
+		QString prevBoxKind = yyBoxKind;
+		yyBoxKind = className.mid( 1 ).lower();
+
+		int spacing = getValue( (*w).childNodes(), QString("Spacing"),
+					QString("integer") ).toInt();
+		if ( spacing < 1 )
+		    spacing = 5;
+
+		emitOpeningLayout( needsWidget, yyBoxKind, widget, 0, spacing );
+		if ( !children.isNull() )
+		    matchLayout( children );
+		emitClosingLayout( needsWidget, yyBoxKind );
+		yyBoxKind = prevBoxKind;
+	    } else if ( className == QString("QGrid") ) {
+		bool needsWidget = needsQLayoutWidget( layoutWidget );
+		int n = 0;
+
+		QString direction = getValue( (*w).childNodes(),
+					      QString("Direction") ).toString();
+		int rowsCols = getValue( (*w).childNodes(), QString("RowCols"),
+					 QString("integer") ).toInt();
+		if ( rowsCols == 0 )
+		    rowsCols = getValue( (*w).childNodes(),
+					 QString("RowsCols"),
+					 QString("integer") ).toInt();
+		if ( rowsCols < 1 )
+		    rowsCols = 5;
+		int spacing = getValue( (*w).childNodes(), QString("Spacing"),
+					QString("integer") ).toInt();
+		if ( spacing < 1 )
+		    spacing = 5;
+
+		emitOpeningLayout( needsWidget, QString("grid"), widget, 0,
+				   spacing );
+
+		QDomNode child = children.firstChild();
+		while ( !child.isNull() ) {
+		    if ( direction == QString("Vertical") ) {
+			yyGridColumn = n / rowsCols;
+			yyGridRow = n % rowsCols;
+		    } else {
+			yyGridColumn = n % rowsCols;
+			yyGridRow = n / rowsCols;
+		    }
+		    matchBox( child.toElement() );
+		    n++;
+		    child = child.nextSibling();
+		}
+		yyGridColumn = -1;
+		yyGridRow = -1;
+		emitClosingLayout( needsWidget, QString("grid") );
+	    } else {
+		emitOpeningWidget( widgetClassName(*w) );
+		emitWidgetBody( *w, TRUE );
+		if ( !children.isNull() )
+		    matchLayout( children );
+		emitClosing( QString("widget") );
+	    }
+	    yyWidgetMap.remove( w );
+	}
+    }
+}
+
+void Dlg2Ui::matchBox( const QDomElement& box )
+{
+    /*
+      What is this jump table doing in here?
+    */
+    static const struct {
+	const char *tagName;
+	void (Dlg2Ui::*matchFunc)( const QDomElement& );
+    } jumpTable[] = {
+	{ "Box_Layout", &Dlg2Ui::matchBoxLayout },
+	{ "Box_Spacing", &Dlg2Ui::matchBoxSpacing },
+	{ "Box_Stretch", &Dlg2Ui::matchBoxStretch },
+	{ "Grid_Layout", &Dlg2Ui::matchGridLayout },
+	{ "Grid_Row", &Dlg2Ui::matchGridRow },
+	{ "Grid_Spacer", &Dlg2Ui::matchGridSpacer },
+	{ "Layout_Widget", &Dlg2Ui::matchLayoutWidget },
+	{ 0, 0 }
+    };
+
+    int i = 0;
+    while ( jumpTable[i].tagName != 0 ) {
+	if ( QString(jumpTable[i].tagName) == box.tagName() ) {
+	    (this->*jumpTable[i].matchFunc)( box );
+	    break;
+	}
+	i++;
+    }
+    if ( jumpTable[i].tagName == 0 )
+	syntaxError();
+}
+
+void Dlg2Ui::matchLayout( const QDomElement& layout )
+{
+    int column = yyGridColumn;
+
+    QDomNode n = layout.firstChild();
+    while ( !n.isNull() ) {
+	if ( column != -1 )
+	    yyGridColumn = column++;
+	matchBox( n.toElement() );
+	n = n.nextSibling();
+    }
+}
+
+void Dlg2Ui::matchWidgetLayoutCommon( const QDomElement& widgetLayoutCommon )
+{
+    QDomNodeList children = widgetLayoutCommon.childNodes();
+
+    /*
+      Since we do not respect the spacing and margins specified in
+      the .dlg file, the specified geometry is slightly wrong (too
+      small). It still seems to be better to take it in.
+    */
+#if 1
+    QPoint initialPos = getValue( children, QString("InitialPos"),
+				  QString("qpoint") ).toPoint();
+    QSize size = getValue( children, QString("Size"), QString("qsize") )
+		 .toSize();
+#endif
+    QSize minSize = getValue( children, QString("MinSize"), QString("qsize") )
+		    .toSize();
+    QSize maxSize = getValue( children, QString("MaxSize"), QString("qsize") )
+		    .toSize();
+
+#if 1
+    if ( initialPos == QPoint(-1, -1) )
+	initialPos = QPoint( 0, 0 );
+
+    emitProperty( QString("geometry"), QRect(initialPos, size) );
+#endif
+    if ( minSize != QSize(-1, -1) )
+	emitProperty( QString("minimumSize"), minSize );
+    if ( maxSize != QSize(32767, 32767) )
+	emitProperty( QString("maximumSize"), maxSize );
+}
+
+void Dlg2Ui::matchWidget( const QDomElement& widget )
+{
+    QString name;
+
+    QDomNode n = widget;
+    while ( !n.isNull() ) {
+	if ( isWidgetType(n.toElement()) ) {
+	    n = n.firstChild();
+	} else {
+	    if ( n.toElement().tagName() == QString("Name") ) {
+		name = getTextValue( n );
+		break;
+	    }
+	    n = n.nextSibling();
+	}
+    }
+    if ( name.isEmpty() )
+	name = QString( "Widget%1" ).arg( uniqueWidget++ );
+
+    if ( yyWidgetMap.contains(name) )
+	syntaxError();
+    yyWidgetMap.insert( name, widget );
+}
+
+void Dlg2Ui::matchWidgets( const QDomElement& widgets )
+{
+    QDomNode n = widgets.firstChild();
+    while ( !n.isNull() ) {
+	matchWidget( n.toElement() );
+	n = n.nextSibling();
+    }
+}
+
+void Dlg2Ui::matchTabOrder( const QDomElement& tabOrder )
+{
+    QDomNode n = tabOrder.firstChild();
+    while ( !n.isNull() ) {
+	if ( n.toElement().tagName() == QString("Widget") )
+	    yyTabStops.append( getTextValue(n.toElement()) );
+	n = n.nextSibling();
+    }
+}
+
+void Dlg2Ui::matchWidgetLayout( const QDomElement& widgetLayout )
+{
+    if ( !checkTagName(widgetLayout, QString("WidgetLayout")) )
+	return;
+
+    QDomNode n = widgetLayout.firstChild();
+    while ( !n.isNull() ) {
+	QString tagName = n.toElement().tagName();
+
+	if ( tagName == QString("WidgetLayoutCommon") ) {
+	    matchWidgetLayoutCommon( n.toElement() );
+	} else if ( tagName == QString("Widgets") ) {
+	    matchWidgets( n.toElement() );
+	} else if ( tagName == QString("TabOrder") ) {
+	    matchTabOrder( n.toElement() );
+	} else if ( tagName == QString("Layout") ) {
+	    matchLayout( n.toElement() );
+	}
+	n = n.nextSibling();
+    }
+}
+
+void Dlg2Ui::matchDialog( const QDomElement& dialog )
+{
+    if ( !checkTagName(dialog, QString("Dialog")) )
+	return;
+
+    QDomNodeList nodes = dialog.childNodes();
+    if ( nodes.count() == 2 ) {
+	matchDialogCommon( nodes.item(0).toElement() );
+	matchWidgetLayout( nodes.item(1).toElement() );
+	flushWidgets();
+	emitClosing( QString("widget") );
+
+	if ( !yyCustomWidgets.isEmpty() ) {
+	    emitOpening( QString("customwidgets") );
+
+	    QMap<QString, QString>::Iterator w = yyCustomWidgets.begin();
+	    while ( w != yyCustomWidgets.end() ) {
+		emitOpening( QString("customwidget") );
+		emitSimpleValue( QString("class"), w.key() );
+		if ( !(*w).isEmpty() )
+		    emitSimpleValue( QString("header"), *w,
+				     attribute(QString("location"),
+					       QString("local")) );
+		emitClosing( QString("customwidget") );
+		++w;
+	    }
+	    emitClosing( QString("customwidgets") );
+	}
+
+	if ( yyConnections.count() + yySlots.count() > 0 ) {
+	    emitOpening( QString("connections") );
+
+	    QValueList<DlgConnection>::Iterator c = yyConnections.begin();
+	    while ( c != yyConnections.end() ) {
+		emitOpening( QString("connection") );
+		emitSimpleValue( QString("sender"), alias((*c).sender) );
+		emitSimpleValue( QString("signal"), (*c).signal );
+		emitSimpleValue( QString("receiver"), yyClassName );
+		emitSimpleValue( QString("slot"), (*c).slot );
+		emitClosing( QString("connection") );
+		++c;
+	    }
+
+	    QMap<QString, QString>::Iterator s = yySlots.begin();
+	    while ( s != yySlots.end() ) {
+		AttributeMap attr;
+		attr.insert( QString("access"), *s );
+		attr.insert( QString("language"), QString("C++") );
+		attr.insert( QString("returntype"), QString("void") );
+		emitSimpleValue( QString("slot"), s.key(), attr );
+		++s;
+	    }
+	    emitClosing( QString("connections") );
+	}
+
+	if ( !yyTabStops.isEmpty() ) {
+	    emitOpening( QString("tabstops") );
+	    QStringList::ConstIterator t = yyTabStops.begin();
+	    while ( t != yyTabStops.end() ) {
+		emitSimpleValue( QString("tabstop"), alias(*t) );
+		++t;
+	    }
+	    emitClosing( QString("tabstops") );
+	}
+    }
+}
+
+QStringList Dlg2Ui::convertQtArchitectDlgFile( const QString& fileName )
+{
+    int i;
+
+    yyFileName = fileName;
+    yyLayoutDepth = 0;
+    yyGridRow = -1;
+    yyGridColumn = -1;
+
+    numErrors = 0;
+    uniqueLayout = 1;
+    uniqueSpacer = 1;
+    uniqueWidget = 1;
+
+    i = 0;
+    while ( widgetTypes[i] != 0 ) {
+	yyWidgetTypeSet.insert( QString(widgetTypes[i]), 0 );
+	i++;
+    }
+
+    i = 0;
+    while ( propertyDefs[i].widgetName != 0 ) {
+	yyPropertyMap[QString(propertyDefs[i].widgetName)]
+		.insert( QString(propertyDefs[i].architectName), i );
+	i++;
+    }
+
+    QDomDocument doc( QString("QtArch") );
+    QFile f( fileName );
+    if ( !f.open(IO_ReadOnly) ) {
+	return QStringList();
+    }
+    if ( !doc.setContent(&f) ) {
+	QString firstLine;
+	f.at( 0 );
+	f.readLine( firstLine, 128 );
+	firstLine = firstLine.stripWhiteSpace();
+	if ( firstLine.startsWith(QString("DlgEdit:v1")) ) {
+	    error( QString("This file is a Qt Architect 1.x file. Qt Designer"
+			   " can only read XML dialog files, as generated by Qt"
+			   " Architect 2.1 or above."
+			   "<p>To convert this file to the right format,"
+			   " first install Qt Architect 2.1 (available at"
+			   " <tt>http://qtarch.sourceforge.net/</tt>). Use the"
+			   " <i>update20.pl</i> Perl script to update the file"
+			   " to the 2.0 format. Load that file in Qt"
+			   " Architect and save it. The file should now be in"
+			   " XML format and loadable in Qt Designer.") );
+	} else if ( firstLine.startsWith(QString("DlgEdit::v2")) ) {
+	    error( QString("This file is a Qt Architect 2.0 file. Qt Designer"
+			   " can only read XML dialog files, as generated by Qt"
+			   " Architect 2.1 or above."
+			   "<p>To convert this file to the right format,"
+			   " first install Qt Architect 2.1 (available at"
+			   " <tt>http://qtarch.sourceforge.net/</tt>). Load the"
+			   " 2.0 file in Qt Architect and save it. The file"
+			   " should now be in XML format and loadable in Qt"
+			   " Designer.") );
+	} else {
+	    error( QString("The file you gave me is not an XML file, as far as"
+			   " I can tell.") );
+	}
+
+	f.close();
+	return QStringList();
+    }
+    f.close();
+
+    QDomElement root = doc.documentElement();
+    if ( root.tagName() != QString("QtArch") ||
+	 root.attributeNode("type").value() != QString("Dialog") ) {
+	error( QString("The file you gave me is not a Qt Architect dialog"
+		       " file.") );
+	return QStringList();
+    }
+
+    emitHeader();
+
+    QDomNode n = root.firstChild();
+    while ( !n.isNull() ) {
+	// there should be only one
+	matchDialog( n.toElement() );
+	n = n.nextSibling();
+    }
+
+    emitFooter();
+
+    QFile outf;
+    QString outFileName = yyClassName + QString( ".ui" );
+
+    outf.setName( outFileName );
+    if ( !outf.open(IO_WriteOnly) ) {
+	qWarning( "dlg2ui: Could not open output file '%s'",
+		  outFileName.latin1() );
+	return QStringList();
+    }
+
+    QTextStream out;
+    out.setEncoding( QTextStream::Latin1 );
+    out.setDevice( &outf );
+    out << yyOut;
+    outf.close();
+
+    return QStringList( outFileName );
+}
diff --git a/tools/designer/plugins/dlg/dlg2ui.h b/tools/designer/plugins/dlg/dlg2ui.h
new file mode 100644
index 0000000..9fb206a
--- /dev/null
+++ b/tools/designer/plugins/dlg/dlg2ui.h
@@ -0,0 +1,144 @@
+/**********************************************************************
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of Qt Designer.
+**
+** 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.
+**
+** 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 DLG2UI_H
+#define DLG2UI_H
+
+#include <qdom.h>
+#include <qmap.h>
+#include <qstring.h>
+#include <qvariant.h>
+
+typedef QMap<QString, QString> AttributeMap;
+
+struct DlgConnection
+{
+    QString sender;
+    QString signal;
+    QString slot;
+
+#if defined(Q_FULL_TEMPLATE_INSTANTIATION)
+    bool operator==( const DlgConnection& ) const {
+        return sender == sender && signal == signal && slot == slot;
+    }
+#endif
+};
+
+class Dlg2Ui
+{
+public:
+    QStringList convertQtArchitectDlgFile( const QString& fileName );
+
+private:
+    QString alias( const QString& name ) const;
+    QString opening( const QString& tag,
+		     const AttributeMap& attr = AttributeMap() );
+    QString closing( const QString& tag );
+    void error( const QString& message );
+    void syntaxError();
+    QString getTextValue( const QDomNode& node );
+    QVariant getValue( const QDomNodeList& children, const QString& tagName,
+		       const QString& type = "qstring" );
+    void emitHeader();
+    void emitFooter();
+    void emitSimpleValue( const QString& tag, const QString& value,
+			  const AttributeMap& attr = AttributeMap() );
+    void emitOpening( const QString& tag,
+		      const AttributeMap& attr = AttributeMap() );
+    void emitClosing( const QString& tag );
+    void emitOpeningWidget( const QString& className );
+    QString widgetClassName( const QDomElement& e );
+    void emitColor( const QColor& color );
+    void emitColorGroup( const QString& name, const QColorGroup& group );
+    void emitVariant( const QVariant& val,
+		      const QString& stringType = "string" );
+    void emitProperty( const QString& prop, const QVariant& val,
+		       const QString& stringType = "string" );
+    void emitAttribute( const QString& attr, const QVariant& val,
+			   const QString& stringType = "string" );
+    void emitOpeningLayout( bool needsWidget, const QString& layoutKind,
+			    const QString& name, int border, int autoBorder );
+    void flushWidgets();
+    void emitClosingLayout( bool needsWidget, const QString& layoutKind );
+    bool isWidgetType( const QDomElement& e );
+    void emitSpacer( int spacing, int stretch );
+    QString filteredFlags( const QString& flags, const QRegExp& filter );
+    void emitFrameStyleProperty( int style );
+    void emitWidgetBody( const QDomElement& e, bool layouted );
+    bool checkTagName( const QDomElement& e, const QString& tagName );
+    QString normalizeType( const QString& type );
+    QVariant getValue( const QDomElement& e, const QString& tagName,
+		       const QString& type = "qstring" );
+    void matchDialogCommon( const QDomElement& dialogCommon );
+    bool needsQLayoutWidget( const QDomElement& e );
+    void matchBoxLayout( const QDomElement& boxLayout );
+    void matchBoxSpacing( const QDomElement& boxSpacing );
+    void matchBoxStretch( const QDomElement& boxStretch );
+    void matchGridLayout( const QDomElement& gridLayout );
+    void matchGridRow( const QDomElement& gridRow );
+    void matchGridSpacer( const QDomElement& gridSpacer );
+    void matchLayoutWidget( const QDomElement& layoutWidget );
+    void matchBox( const QDomElement& box );
+    void matchLayout( const QDomElement& layout );
+    void matchWidgetLayoutCommon( const QDomElement& widgetLayoutCommon );
+    void matchWidget( const QDomElement& widget );
+    void matchWidgets( const QDomElement& widgets );
+    void matchTabOrder( const QDomElement& tabOrder );
+    void matchWidgetLayout( const QDomElement& widgetLayout );
+    void matchDialog( const QDomElement& dialog );
+
+    QString yyOut;
+    QString yyIndentStr;
+    QString yyFileName;
+    QString yyClassName;
+    QMap<QString, int> yyWidgetTypeSet;
+    QMap<QString, QMap<QString, int> > yyPropertyMap;
+    QMap<QString, QDomElement> yyWidgetMap;
+    QMap<QString, QString> yyCustomWidgets;
+    QValueList<DlgConnection> yyConnections;
+    QMap<QString, QString> yySlots;
+    QMap<QString, QString> yyAliasMap;
+    QStringList yyTabStops;
+    QString yyBoxKind;
+    int yyLayoutDepth;
+    int yyGridRow;
+    int yyGridColumn;
+
+    int numErrors;
+    int uniqueLayout;
+    int uniqueSpacer;
+    int uniqueWidget;
+};
+
+#endif
diff --git a/tools/designer/plugins/dlg/main.cpp b/tools/designer/plugins/dlg/main.cpp
new file mode 100644
index 0000000..b698bad
--- /dev/null
+++ b/tools/designer/plugins/dlg/main.cpp
@@ -0,0 +1,108 @@
+/**********************************************************************
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of Qt Designer.
+**
+** 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.
+**
+** 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 <filterinterface.h>
+#include <qapplication.h>
+
+#include "dlg2ui.h"
+
+class DlgFilter : public ImportFilterInterface, public QLibraryInterface
+{
+public:
+    DlgFilter();
+
+    QRESULT queryInterface( const QUuid&, QUnknownInterface **iface );
+    Q_REFCOUNT;
+
+    QStringList featureList() const;
+    QStringList import( const QString& filter, const QString& filename );
+
+    bool init();
+    void cleanup();
+    bool canUnload() const;
+};
+
+DlgFilter::DlgFilter()
+{
+}
+
+QRESULT DlgFilter::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
+{
+    *iface = 0;
+    if ( uuid == IID_QUnknown )
+	*iface = (QUnknownInterface*)(ImportFilterInterface*)this;
+    else if ( uuid == IID_QFeatureList )
+	*iface = (QFeatureListInterface*)this;
+    else if ( uuid == IID_ImportFilter )
+	*iface = (ImportFilterInterface*)this;
+    else if ( uuid == IID_QLibrary )
+	*iface = (QLibraryInterface*)this;
+    else
+	return QE_NOINTERFACE;
+
+    (*iface)->addRef();
+    return QS_OK;
+}
+
+QStringList DlgFilter::featureList() const
+{
+    QStringList list;
+    list << "Qt Architect Dialog Files (*.dlg)" ;
+    return list;
+}
+
+QStringList DlgFilter::import( const QString &, const QString& filename )
+{
+    Dlg2Ui d;
+    return d.convertQtArchitectDlgFile( filename );
+}
+
+bool DlgFilter::init()
+{
+    return TRUE;
+}
+
+void DlgFilter::cleanup()
+{
+}
+
+bool DlgFilter::canUnload() const
+{
+    return TRUE;
+}
+
+Q_EXPORT_COMPONENT()
+{
+    Q_CREATE_INSTANCE( DlgFilter )
+}