You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1633 lines
51 KiB
1633 lines
51 KiB
/**********************************************************************
|
|
**
|
|
** 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("&") );
|
|
t.replace( '>', QString(">") );
|
|
t.replace( '<', QString("<") );
|
|
t.replace( '"', QString(""") );
|
|
t.replace( '\'', QString("'") );
|
|
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) );
|
|
}
|
|
} 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)) );
|
|
} 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 );
|
|
}
|