| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the tools applications of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "ui3reader.h" |
| #include "parser.h" |
| #include "domtool.h" |
| #include "ui4.h" |
| #include "widgetinfo.h" |
| #include "globaldefs.h" |
| #include "qt3to4.h" |
| #include "utils.h" |
| #include "option.h" |
| #include "cppextractimages.h" |
| |
| #include <QtDebug> |
| #include <QFile> |
| #include <QHash> |
| #include <QPair> |
| #include <QStringList> |
| #include <QDateTime> |
| #include <QRegExp> |
| #include <QSizePolicy> |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| enum { warnHeaderGeneration = 0 }; |
| |
| #define CONVERT_PROPERTY(o, n) \ |
| do { \ |
| if (name == QLatin1String(o) \ |
| && !WidgetInfo::isValidProperty(className, (o)) \ |
| && WidgetInfo::isValidProperty(className, (n))) { \ |
| prop->setAttributeName((n)); \ |
| } \ |
| } while (0) |
| |
| static QString classNameForObjectName(const QDomElement &widget, const QString &objectName) |
| { |
| QList<QDomElement> widgetStack; |
| widgetStack.append(widget); |
| while (!widgetStack.isEmpty()) { |
| QDomElement w = widgetStack.takeFirst(); |
| QDomElement child = w.firstChild().toElement(); |
| while (!child.isNull()) { |
| if (child.tagName() == QLatin1String("property") |
| && child.attribute(QLatin1String("name")) == QLatin1String("name")) { |
| QDomElement name = child.firstChild().toElement(); |
| DomString str; |
| str.read(name); |
| if (str.text() == objectName) |
| return w.attribute(QLatin1String("class")); |
| } else if (child.tagName() == QLatin1String("widget") |
| || child.tagName() == QLatin1String("vbox") |
| || child.tagName() == QLatin1String("hbox") |
| || child.tagName() == QLatin1String("grid")) { |
| widgetStack.prepend(child); |
| } |
| child = child.nextSibling().toElement(); |
| } |
| } |
| return QString(); |
| } |
| |
| // Check for potential KDE classes like |
| // K3ListView or KLineEdit as precise as possible |
| static inline bool isKDEClass(const QString &className) |
| { |
| if (className.indexOf(QLatin1Char(':')) != -1) |
| return false; |
| const int size = className.size(); |
| if (size < 3 || className.at(0) != QLatin1Char('K')) |
| return false; |
| // K3ListView |
| if (className.at(1) == QLatin1Char('3')) { |
| if (size < 4) |
| return false; |
| return className.at(2).isUpper() && className.at(3).isLower(); |
| } |
| // KLineEdit |
| return className.at(1) .isUpper() && className.at(2).isLower(); |
| } |
| |
| DomUI *Ui3Reader::generateUi4(const QDomElement &widget) |
| { |
| QDomNodeList nl; |
| candidateCustomWidgets.clear(); |
| |
| QString objClass = getClassName(widget); |
| if (objClass.isEmpty()) |
| return 0; |
| QString objName = getObjectName(widget); |
| |
| DomUI *ui = new DomUI; |
| ui->setAttributeVersion(QLatin1String("4.0")); |
| |
| QString pixmapFunction = QLatin1String("qPixmapFromMimeSource"); |
| QStringList ui_tabstops; |
| QStringList ui_custom_slots; |
| QList<DomInclude*> ui_includes; |
| QList<DomWidget*> ui_toolbars; |
| QList<DomWidget*> ui_menubars; |
| QList<DomAction*> ui_action_list; |
| QList<DomActionGroup*> ui_action_group_list; |
| QList<DomCustomWidget*> ui_customwidget_list; |
| QList<DomConnection*> ui_connection_list; |
| QList<QPair<int, int> > ui_connection_lineinfo_list; |
| QString author, comment, exportMacro; |
| QString klass; |
| |
| for (QDomElement n = root.firstChild().toElement(); !n.isNull(); n = n.nextSibling().toElement()) { |
| QString tagName = n.tagName().toLower(); |
| |
| if (tagName == QLatin1String("tabstops")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| if (n2.tagName().toLower() == QLatin1String("tabstop")) { |
| QString name = n2.firstChild().toText().data(); |
| ui_tabstops.append(name); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("pixmapfunction")) { |
| pixmapFunction = n.firstChild().toText().data(); |
| } else if (tagName == QLatin1String("class")) { |
| klass = n.firstChild().toText().data(); |
| } else if (tagName == QLatin1String("author")) { |
| author = n.firstChild().toText().data(); |
| } else if (tagName == QLatin1String("comment")) { |
| comment = n.firstChild().toText().data(); |
| } else if (tagName == QLatin1String("exportmacro")) { |
| exportMacro = n.firstChild().toText().data(); |
| } else if ( n.tagName() == QLatin1String("includehints") ) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while ( !n2.isNull() ) { |
| if ( n2.tagName() == QLatin1String("includehint") ) { |
| QString name = n2.firstChild().toText().data(); |
| |
| DomInclude *incl = new DomInclude(); |
| incl->setText(fixHeaderName(name)); |
| incl->setAttributeLocation(n.attribute(QLatin1String("location"), QLatin1String("local"))); |
| ui_includes.append(incl); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("includes")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| if (n2.tagName().toLower() == QLatin1String("include")) { |
| QString name = n2.firstChild().toText().data(); |
| if (n2.attribute(QLatin1String("impldecl"), QLatin1String("in implementation")) == QLatin1String("in declaration")) { |
| if (name.right(5) == QLatin1String(".ui.h")) |
| continue; |
| |
| DomInclude *incl = new DomInclude(); |
| incl->setText(fixHeaderName(name)); |
| incl->setAttributeLocation(n2.attribute(QLatin1String("location"), QLatin1String("global"))); |
| ui_includes.append(incl); |
| } |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("include")) { |
| QString name = n.firstChild().toText().data(); |
| if (n.attribute(QLatin1String("impldecl"), QLatin1String("in implementation")) == QLatin1String("in declaration")) { |
| if (name.right(5) == QLatin1String(".ui.h")) |
| continue; |
| |
| DomInclude *incl = new DomInclude(); |
| incl->setText(fixHeaderName(name)); |
| incl->setAttributeLocation(n.attribute(QLatin1String("location"), QLatin1String("global"))); |
| ui_includes.append(incl); |
| } |
| } else if (tagName == QLatin1String("layoutdefaults")) { |
| QString margin = n.attribute(QLatin1String("margin")); |
| QString spacing = n.attribute(QLatin1String("spacing")); |
| |
| DomLayoutDefault *layoutDefault = new DomLayoutDefault(); |
| |
| if (!margin.isEmpty()) |
| layoutDefault->setAttributeMargin(margin.toInt()); |
| |
| if (!spacing.isEmpty()) |
| layoutDefault->setAttributeSpacing(spacing.toInt()); |
| |
| ui->setElementLayoutDefault(layoutDefault); |
| } else if (tagName == QLatin1String("layoutfunctions")) { |
| QString margin = n.attribute(QLatin1String("margin")); |
| QString spacing = n.attribute(QLatin1String("spacing")); |
| |
| DomLayoutFunction *layoutDefault = new DomLayoutFunction(); |
| |
| if (!margin.isEmpty()) |
| layoutDefault->setAttributeMargin(margin); |
| |
| if (!spacing.isEmpty()) |
| layoutDefault->setAttributeSpacing(spacing); |
| |
| ui->setElementLayoutFunction(layoutDefault); |
| } else if (tagName == QLatin1String("images")) { |
| QDomNodeList nl = n.elementsByTagName(QLatin1String("image")); |
| QList<DomImage*> ui_image_list; |
| for (int i=0; i<(int)nl.length(); i++) { |
| QDomElement e = nl.item(i).toElement(); |
| |
| QDomElement tmp = e.firstChild().toElement(); |
| if (tmp.tagName().toLower() != QLatin1String("data")) |
| continue; |
| |
| // create the image |
| DomImage *img = new DomImage(); |
| img->setAttributeName(e.attribute(QLatin1String("name"))); |
| |
| // create the data |
| DomImageData *data = new DomImageData(); |
| img->setElementData(data); |
| |
| if (tmp.hasAttribute(QLatin1String("format"))) |
| data->setAttributeFormat(tmp.attribute(QLatin1String("format"), QLatin1String("PNG"))); |
| |
| if (tmp.hasAttribute(QLatin1String("length"))) |
| data->setAttributeLength(tmp.attribute(QLatin1String("length")).toInt()); |
| |
| data->setText(tmp.firstChild().toText().data()); |
| |
| ui_image_list.append(img); |
| QString format = img->elementData()->attributeFormat(); |
| QString extension = format.left(format.indexOf('.')).toLower(); |
| m_imageMap[img->attributeName()] = img->attributeName() + QLatin1Char('.') + extension; |
| } |
| |
| if (ui_image_list.size()) { |
| DomImages *images = new DomImages(); |
| images->setElementImage(ui_image_list); |
| ui->setElementImages(images); |
| } |
| } else if (tagName == QLatin1String("actions")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| QString tag = n2.tagName().toLower(); |
| |
| if (tag == QLatin1String("action")) { |
| DomAction *action = new DomAction(); |
| action->read(n2); |
| |
| QList<DomProperty*> properties = action->elementProperty(); |
| QString actionName = fixActionProperties(properties); |
| action->setAttributeName(actionName); |
| action->setElementProperty(properties); |
| |
| if (actionName.isEmpty()) { |
| delete action; |
| } else |
| ui_action_list.append(action); |
| } else if (tag == QLatin1String("actiongroup")) { |
| DomActionGroup *g= new DomActionGroup(); |
| g->read(n2); |
| |
| fixActionGroup(g); |
| ui_action_group_list.append(g); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("toolbars")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| if (n2.tagName().toLower() == QLatin1String("toolbar")) { |
| DomWidget *tb = createWidget(n2, QLatin1String("QToolBar")); |
| ui_toolbars.append(tb); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("menubar")) { |
| DomWidget *tb = createWidget(n, QLatin1String("QMenuBar")); |
| ui_menubars.append(tb); |
| } else if (tagName == QLatin1String("customwidgets")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| if (n2.tagName().toLower() == QLatin1String("customwidget")) { |
| |
| DomCustomWidget *customWidget = new DomCustomWidget; |
| customWidget->read(n2); |
| |
| if (!customWidget->hasElementExtends()) |
| customWidget->setElementExtends(QLatin1String("QWidget")); |
| |
| QDomElement n3 = n2.firstChild().toElement(); |
| QString cl; |
| |
| QList<DomPropertyData*> ui_property_list; |
| |
| while (!n3.isNull()) { |
| QString tagName = n3.tagName().toLower(); |
| |
| if (tagName == QLatin1String("property")) { |
| DomPropertyData *p = new DomPropertyData(); |
| p->read(n3); |
| |
| ui_property_list.append(p); |
| } |
| |
| n3 = n3.nextSibling().toElement(); |
| } |
| |
| if (ui_property_list.size()) { |
| DomProperties *properties = new DomProperties(); |
| properties->setElementProperty(ui_property_list); |
| customWidget->setElementProperties(properties); |
| } |
| |
| ui_customwidget_list.append(customWidget); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("connections")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| if (n2.tagName().toLower() == QLatin1String("connection")) { |
| |
| DomConnection *connection = new DomConnection; |
| connection->read(n2); |
| |
| QString signal = fixMethod(connection->elementSignal()); |
| QString slot = fixMethod(connection->elementSlot()); |
| connection->setElementSignal(signal); |
| connection->setElementSlot(slot); |
| |
| ui_connection_list.append(connection); |
| ui_connection_lineinfo_list.append( |
| QPair<int, int>(n2.lineNumber(), n2.columnNumber())); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } else if (tagName == QLatin1String("slots")) { |
| QDomElement n2 = n.firstChild().toElement(); |
| while (!n2.isNull()) { |
| if (n2.tagName().toLower() == QLatin1String("slot")) { |
| QString name = n2.firstChild().toText().data(); |
| ui_custom_slots.append(fixMethod(Parser::cleanArgs(name))); |
| } |
| n2 = n2.nextSibling().toElement(); |
| } |
| } |
| } |
| |
| // validate the connections |
| for (int i = 0; i < ui_connection_list.size(); ++i) { |
| DomConnection *conn = ui_connection_list.at(i); |
| QPair<int, int> lineinfo = ui_connection_lineinfo_list.at(i); |
| QString sender = conn->elementSender(); |
| QString senderClass = fixClassName(classNameForObjectName(widget, sender)); |
| QString signal = conn->elementSignal(); |
| QString receiver = conn->elementReceiver(); |
| QString receiverClass = fixClassName(classNameForObjectName(widget, receiver)); |
| QString slot = conn->elementSlot(); |
| |
| if (!WidgetInfo::isValidSignal(senderClass, signal)) { |
| errorInvalidSignal(signal, sender, senderClass, |
| lineinfo.first, lineinfo.second); |
| } else if (!WidgetInfo::isValidSlot(receiverClass, slot)) { |
| bool resolved = false; |
| if (objName == receiver) { |
| // see if it's a custom slot |
| foreach (const QString &cs, ui_custom_slots) { |
| if (cs == slot) { |
| resolved = true; |
| break; |
| } |
| } |
| } |
| if (!resolved) { |
| errorInvalidSlot(slot, receiver, receiverClass, |
| lineinfo.first, lineinfo.second); |
| } |
| } |
| } |
| |
| DomWidget *w = createWidget(widget); |
| Q_ASSERT(w != 0); |
| |
| QList<DomWidget*> l = w->elementWidget(); |
| l += ui_toolbars; |
| l += ui_menubars; |
| w->setElementWidget(l); |
| |
| if (ui_action_group_list.size()) |
| w->setElementActionGroup(ui_action_group_list); |
| |
| if (ui_action_list.size()) |
| w->setElementAction(ui_action_list); |
| |
| ui->setElementWidget(w); |
| |
| if (klass.isEmpty()) |
| klass = w->attributeName(); |
| |
| ui->setElementClass(klass); |
| ui->setElementAuthor(author); |
| ui->setElementComment(comment); |
| ui->setElementExportMacro(exportMacro); |
| |
| if (!ui->elementImages()) |
| ui->setElementPixmapFunction(pixmapFunction); |
| |
| for (int i=0; i<ui_customwidget_list.size(); ++i) { |
| const QString name = ui_customwidget_list.at(i)->elementClass(); |
| if (candidateCustomWidgets.contains(name)) |
| candidateCustomWidgets.remove(name); |
| } |
| |
| |
| QMapIterator<QString, bool> it(candidateCustomWidgets); |
| while (it.hasNext()) { |
| it.next(); |
| |
| const QString customClass = it.key(); |
| QString baseClass; |
| |
| if (customClass.endsWith(QLatin1String("ListView"))) |
| baseClass = QLatin1String("Q3ListView"); |
| else if (customClass.endsWith(QLatin1String("ListBox"))) |
| baseClass = QLatin1String("Q3ListBox"); |
| else if (customClass.endsWith(QLatin1String("IconView"))) |
| baseClass = QLatin1String("Q3IconView"); |
| else if (customClass.endsWith(QLatin1String("ComboBox"))) |
| baseClass = QLatin1String("QComboBox"); |
| |
| if (baseClass.isEmpty()) |
| continue; |
| |
| DomCustomWidget *customWidget = new DomCustomWidget(); |
| customWidget->setElementClass(customClass); |
| customWidget->setElementExtends(baseClass); |
| |
| // Magic header generation feature for legacy KDE forms |
| // (for example, filesharing/advanced/kcm_sambaconf/share.ui) |
| if ((m_options & ImplicitIncludes) && isKDEClass(customClass)) { |
| QString header = customClass.toLower(); |
| header += QLatin1String(".h"); |
| DomHeader *domHeader = new DomHeader; |
| domHeader->setText(header); |
| domHeader->setAttributeLocation(QLatin1String("global")); |
| customWidget->setElementHeader(domHeader); |
| if (warnHeaderGeneration) { |
| const QString msg = QString::fromUtf8("Warning: generated header '%1' for class '%2'.").arg(header).arg(customClass); |
| qWarning("%s", qPrintable(msg)); |
| } |
| } |
| ui_customwidget_list.append(customWidget); |
| } |
| |
| if (ui_customwidget_list.size()) { |
| DomCustomWidgets *customWidgets = new DomCustomWidgets(); |
| customWidgets->setElementCustomWidget(ui_customwidget_list); |
| ui->setElementCustomWidgets(customWidgets); |
| } |
| |
| if (ui_tabstops.size()) { |
| DomTabStops *tabStops = new DomTabStops(); |
| tabStops->setElementTabStop(ui_tabstops); |
| ui->setElementTabStops(tabStops); |
| } |
| |
| if (ui_includes.size()) { |
| DomIncludes *includes = new DomIncludes(); |
| includes->setElementInclude(ui_includes); |
| ui->setElementIncludes(includes); |
| } |
| |
| if (ui_connection_list.size()) { |
| DomConnections *connections = new DomConnections(); |
| connections->setElementConnection(ui_connection_list); |
| ui->setElementConnections(connections); |
| } |
| |
| ui->setAttributeStdSetDef(stdsetdef); |
| |
| if (m_extractImages) { |
| Option opt; |
| opt.extractImages = m_extractImages; |
| opt.limitXPM_LineLength = (m_options & LimitXPM_LineLength) ? 1 : 0; |
| opt.qrcOutputFile = m_qrcOutputFile; |
| CPP::ExtractImages(opt).acceptUI(ui); |
| |
| ui->clearElementImages(); |
| |
| DomResources *res = ui->elementResources(); |
| if (!res) { |
| res = new DomResources(); |
| } |
| DomResource *incl = new DomResource(); |
| incl->setAttributeLocation(m_qrcOutputFile); |
| QList<DomResource *> inclList = res->elementInclude(); |
| inclList.append(incl); |
| res->setElementInclude(inclList); |
| if (!ui->elementResources()) |
| ui->setElementResources(res); |
| } |
| |
| return ui; |
| } |
| |
| |
| |
| QString Ui3Reader::fixActionProperties(QList<DomProperty*> &properties, |
| bool isActionGroup) |
| { |
| QString objectName; |
| |
| QMutableListIterator<DomProperty*> it(properties); |
| while (it.hasNext()) { |
| DomProperty *prop = it.next(); |
| QString name = prop->attributeName(); |
| |
| if (name == QLatin1String("name")) { |
| objectName = prop->elementCstring(); |
| } else if (isActionGroup && name == QLatin1String("exclusive")) { |
| // continue |
| } else if (isActionGroup) { |
| errorInvalidProperty(name, objectName, isActionGroup ? QLatin1String("QActionGroup") : QLatin1String("QAction"), -1, -1); |
| delete prop; |
| it.remove(); |
| } else if (name == QLatin1String("menuText")) { |
| prop->setAttributeName(QLatin1String("text")); |
| } else if (name == QLatin1String("text")) { |
| prop->setAttributeName(QLatin1String("iconText")); |
| } else if (name == QLatin1String("iconSet")) { |
| prop->setAttributeName(QLatin1String("icon")); |
| } else if (name == QLatin1String("accel")) { |
| prop->setAttributeName(QLatin1String("shortcut")); |
| } else if (name == QLatin1String("toggleAction")) { |
| prop->setAttributeName(QLatin1String("checkable")); |
| } else if (name == QLatin1String("on")) { |
| prop->setAttributeName(QLatin1String("checked")); |
| } else if (!WidgetInfo::isValidProperty(QLatin1String("QAction"), name)) { |
| errorInvalidProperty(name, objectName, isActionGroup ? QLatin1String("QActionGroup") : QLatin1String("QAction"), -1, -1); |
| delete prop; |
| it.remove(); |
| } |
| } |
| |
| return objectName; |
| } |
| |
| void Ui3Reader::fixActionGroup(DomActionGroup *g) |
| { |
| QList<DomActionGroup*> groups = g->elementActionGroup(); |
| for (int i=0; i<groups.size(); ++i) { |
| fixActionGroup(groups.at(i)); |
| } |
| |
| QList<DomAction*> actions = g->elementAction(); |
| for (int i=0; i<actions.size(); ++i) { |
| DomAction *a = actions.at(i); |
| |
| QList<DomProperty*> properties = a->elementProperty(); |
| QString name = fixActionProperties(properties); |
| a->setElementProperty(properties); |
| |
| if (name.size()) |
| a->setAttributeName(name); |
| } |
| |
| QList<DomProperty*> properties = g->elementProperty(); |
| QString name = fixActionProperties(properties, true); |
| g->setElementProperty(properties); |
| |
| if (name.size()) |
| g->setAttributeName(name); |
| } |
| |
| QString Ui3Reader::fixClassName(const QString &className) const |
| { |
| return m_porting->renameClass(className); |
| } |
| |
| QString Ui3Reader::fixHeaderName(const QString &headerName) const |
| { |
| return m_porting->renameHeader(headerName); |
| } |
| |
| DomWidget *Ui3Reader::createWidget(const QDomElement &w, const QString &widgetClass) |
| { |
| DomWidget *ui_widget = new DomWidget; |
| |
| QString className = widgetClass; |
| if (className.isEmpty()) |
| className = w.attribute(QLatin1String("class")); |
| className = fixClassName(className); |
| |
| if ((className.endsWith(QLatin1String("ListView")) && className != QLatin1String("Q3ListView")) |
| || (className.endsWith(QLatin1String("ListBox")) && className != QLatin1String("Q3ListBox")) |
| || (className.endsWith(QLatin1String("ComboBox")) && className != QLatin1String("QComboBox")) |
| || (className.endsWith(QLatin1String("IconView")) && className != QLatin1String("Q3IconView"))) |
| candidateCustomWidgets.insert(className, true); |
| |
| bool isMenu = (className == QLatin1String("QMenuBar") || className == QLatin1String("QMenu")); |
| |
| ui_widget->setAttributeClass(className); |
| |
| QList<DomWidget*> ui_child_list; |
| QList<DomRow*> ui_row_list; |
| QList<DomColumn*> ui_column_list; |
| QList<DomItem*> ui_item_list; |
| QList<DomProperty*> ui_property_list; |
| QList<DomProperty*> ui_attribute_list; |
| QList<DomLayout*> ui_layout_list; |
| QList<DomActionRef*> ui_action_list; |
| QList<DomWidget*> ui_mainwindow_child_list; |
| |
| createProperties(w, &ui_property_list, className); |
| createAttributes(w, &ui_attribute_list, className); |
| |
| DomWidget *ui_mainWindow = 0; |
| DomWidget *ui_centralWidget = 0; |
| if (className == QLatin1String("QMainWindow") || className == QLatin1String("Q3MainWindow")) { |
| ui_centralWidget = new DomWidget; |
| ui_centralWidget->setAttributeClass(QLatin1String("QWidget")); |
| ui_mainwindow_child_list.append(ui_centralWidget); |
| ui_mainWindow = ui_widget; |
| } |
| |
| QDomElement e = w.firstChild().toElement(); |
| const bool inQ3ToolBar = className == QLatin1String("Q3ToolBar"); |
| while (!e.isNull()) { |
| QString t = e.tagName().toLower(); |
| if (t == QLatin1String("vbox") || t == QLatin1String("hbox") || t == QLatin1String("grid")) { |
| DomLayout *lay = createLayout(e); |
| Q_ASSERT(lay != 0); |
| |
| if (ui_layout_list.isEmpty()) { |
| ui_layout_list.append(lay); |
| } else { |
| // it's not possible to have more than one layout for widget! |
| delete lay; |
| } |
| } else if (t == QLatin1String("spacer")) { |
| // hmm, spacer as child of a widget.. it doesn't make sense, so skip it! |
| } else if (t == QLatin1String("widget")) { |
| DomWidget *ui_child = createWidget(e); |
| Q_ASSERT(ui_child != 0); |
| |
| bool isLayoutWidget = ui_child->attributeClass() == QLatin1String("QLayoutWidget"); |
| if (isLayoutWidget) |
| ui_child->setAttributeClass(QLatin1String("QWidget")); |
| |
| foreach (DomLayout *layout, ui_child->elementLayout()) { |
| fixLayoutMargin(layout); |
| } |
| |
| QString widgetClass = ui_child->attributeClass(); |
| if (widgetClass == QLatin1String("QMenuBar") || widgetClass == QLatin1String("QToolBar") |
| || widgetClass == QLatin1String("QStatusBar")) { |
| ui_mainwindow_child_list.append(ui_child); |
| } else { |
| ui_child_list.append(ui_child); |
| } |
| |
| if (inQ3ToolBar) { |
| DomActionRef *ui_action_ref = new DomActionRef(); |
| ui_action_ref->setAttributeName(ui_child->attributeName()); |
| ui_action_list.append(ui_action_ref); |
| } |
| } else if (t == QLatin1String("action")) { |
| DomActionRef *a = new DomActionRef(); |
| a->read(e); |
| ui_action_list.append(a); |
| } else if (t == QLatin1String("separator")) { |
| DomActionRef *a = new DomActionRef(); |
| a->setAttributeName(QLatin1String("separator")); |
| ui_action_list.append(a); |
| } else if (t == QLatin1String("property")) { |
| // skip the property it is already handled by createProperties |
| const QString name = e.attribute(QLatin1String("name")); // change the varname this widget |
| if (name == QLatin1String("name")) { |
| // Do not name QLayoutWidget if layout names are to be used. |
| const bool applyName = !(m_options & PreserveLayoutNames) || className != QLatin1String("QLayoutWidget"); |
| if (applyName) |
| ui_widget->setAttributeName(DomTool::readProperty(w, QLatin1String("name"), QVariant()).toString()); |
| } |
| } else if (t == QLatin1String("row")) { |
| DomRow *row = new DomRow(); |
| row->read(e); |
| ui_row_list.append(row); |
| } else if (t == QLatin1String("column")) { |
| DomColumn *column = new DomColumn(); |
| column->read(e); |
| ui_column_list.append(column); |
| } else if (isMenu && t == QLatin1String("item")) { |
| QString text = e.attribute(QLatin1String("text")); |
| QString name = e.attribute(QLatin1String("name")); |
| QString accel = e.attribute(QLatin1String("accel")); |
| |
| QList<DomProperty*> properties; |
| |
| DomProperty *atitle = new DomProperty(); |
| atitle->setAttributeName(QLatin1String("title")); |
| DomString *str = new DomString(); |
| str->setText(text); |
| atitle->setElementString(str); |
| properties.append(atitle); |
| |
| DomWidget *menu = createWidget(e, QLatin1String("QMenu")); |
| menu->setAttributeName(name); |
| menu->setElementProperty(properties); |
| ui_child_list.append(menu); |
| |
| DomActionRef *a = new DomActionRef(); |
| a->setAttributeName(name); |
| ui_action_list.append(a); |
| |
| } else if (t == QLatin1String("item")) { |
| DomItem *item = new DomItem(); |
| item->read(e); |
| ui_item_list.append(item); |
| } |
| |
| e = e.nextSibling().toElement(); |
| } |
| |
| ui_widget->setElementProperty(ui_property_list); |
| ui_widget->setElementAttribute(ui_attribute_list); |
| |
| if (ui_centralWidget != 0) { |
| Q_ASSERT(ui_mainWindow != 0); |
| ui_mainWindow->setElementWidget(ui_mainwindow_child_list); |
| ui_widget = ui_centralWidget; |
| } |
| |
| ui_widget->setElementWidget(ui_child_list); |
| ui_widget->setElementAddAction(ui_action_list); |
| ui_widget->setElementRow(ui_row_list); |
| ui_widget->setElementColumn(ui_column_list); |
| ui_widget->setElementItem(ui_item_list); |
| ui_widget->setElementLayout(ui_layout_list); |
| |
| //ui_widget->setAttributeName(p->elementCstring()); |
| |
| return ui_mainWindow ? ui_mainWindow : ui_widget; |
| } |
| |
| DomLayout *Ui3Reader::createLayout(const QDomElement &w) |
| { |
| DomLayout *lay = new DomLayout(); |
| |
| QList<DomLayoutItem*> ui_item_list; |
| QList<DomProperty*> ui_property_list; |
| QList<DomProperty*> ui_attribute_list; |
| |
| QString tagName = w.tagName().toLower(); |
| |
| QString className; |
| if (tagName == QLatin1String("vbox")) |
| className = QLatin1String("QVBoxLayout"); |
| else if (tagName == QLatin1String("hbox")) |
| className = QLatin1String("QHBoxLayout"); |
| else |
| className = QLatin1String("QGridLayout"); |
| |
| lay->setAttributeClass(className); |
| |
| createProperties(w, &ui_property_list, className); |
| createAttributes(w, &ui_attribute_list, className); |
| if (m_options & PreserveLayoutNames) { |
| const QString layoutName = getLayoutName(w); |
| if (!layoutName.isEmpty()) |
| lay->setAttributeName(layoutName); |
| } |
| |
| QDomElement e = w.firstChild().toElement(); |
| while (!e.isNull()) { |
| QString t = e.tagName().toLower(); |
| if (t == QLatin1String("vbox") |
| || t == QLatin1String("hbox") |
| || t == QLatin1String("grid") |
| || t == QLatin1String("spacer") |
| || t == QLatin1String("widget")) { |
| DomLayoutItem *lay_item = createLayoutItem(e); |
| Q_ASSERT(lay_item != 0); |
| ui_item_list.append(lay_item); |
| } |
| |
| e = e.nextSibling().toElement(); |
| } |
| |
| lay->setElementItem(ui_item_list); |
| lay->setElementProperty(ui_property_list); |
| lay->setElementAttribute(ui_attribute_list); |
| |
| return lay; |
| } |
| |
| DomLayoutItem *Ui3Reader::createLayoutItem(const QDomElement &e) |
| { |
| DomLayoutItem *lay_item = new DomLayoutItem; |
| |
| QString tagName = e.tagName().toLower(); |
| if (tagName == QLatin1String("widget")) { |
| DomWidget *ui_widget = createWidget(e); |
| Q_ASSERT(ui_widget != 0); |
| |
| if (ui_widget->attributeClass() == QLatin1String("QLayoutWidget") |
| && ui_widget->elementLayout().size() == 1) { |
| QList<DomLayout*> layouts = ui_widget->elementLayout(); |
| |
| ui_widget->setElementLayout(QList<DomLayout*>()); |
| delete ui_widget; |
| |
| DomLayout *layout = layouts.first(); |
| fixLayoutMargin(layout); |
| lay_item->setElementLayout(layout); |
| } else { |
| if (ui_widget->attributeClass() == QLatin1String("QLayoutWidget")) |
| ui_widget->setAttributeClass(QLatin1String("QWidget")); |
| |
| lay_item->setElementWidget(ui_widget); |
| } |
| } else if (tagName == QLatin1String("spacer")) { |
| DomSpacer *ui_spacer = new DomSpacer(); |
| QList<DomProperty*> properties; |
| |
| QByteArray name = DomTool::readProperty(e, QLatin1String("name"), QLatin1String("spacer")).toByteArray(); |
| |
| Variant var; |
| var.createSize(0, 0); |
| |
| QVariant def = qVariantFromValue(var); |
| |
| Size size = asVariant(DomTool::readProperty(e, QLatin1String("sizeHint"), def)).size; |
| QString sizeType = QLatin1String("QSizePolicy::") + DomTool::readProperty(e, QLatin1String("sizeType"), QLatin1String("Expanding")).toString(); |
| QString orientation = QLatin1String("Qt::") + DomTool::readProperty(e, QLatin1String("orientation"), QLatin1String("Horizontal")).toString(); |
| |
| ui_spacer->setAttributeName(QLatin1String(name)); |
| |
| DomProperty *prop = 0; |
| |
| // sizeHint |
| prop = new DomProperty(); |
| prop->setAttributeName(QLatin1String("sizeHint")); |
| prop->setElementSize(new DomSize()); |
| prop->elementSize()->setElementWidth(size.width); |
| prop->elementSize()->setElementHeight(size.height); |
| properties.append(prop); |
| |
| // sizeType |
| prop = new DomProperty(); |
| prop->setAttributeName(QLatin1String("sizeType")); |
| prop->setElementEnum(sizeType); |
| properties.append(prop); |
| |
| // orientation |
| prop = new DomProperty(); |
| prop->setAttributeName(QLatin1String("orientation")); |
| prop->setElementEnum(orientation); |
| properties.append(prop); |
| |
| ui_spacer->setElementProperty(properties); |
| lay_item->setElementSpacer(ui_spacer); |
| } else { |
| DomLayout *ui_layout = createLayout(e); |
| Q_ASSERT(ui_layout != 0); |
| |
| fixLayoutMargin(ui_layout); |
| lay_item->setElementLayout(ui_layout); |
| } |
| |
| if (e.hasAttribute(QLatin1String("row"))) |
| lay_item->setAttributeRow(e.attribute(QLatin1String("row")).toInt()); |
| if (e.hasAttribute(QLatin1String("column"))) |
| lay_item->setAttributeColumn(e.attribute(QLatin1String("column")).toInt()); |
| if (e.hasAttribute(QLatin1String("rowspan"))) |
| lay_item->setAttributeRowSpan(e.attribute(QLatin1String("rowspan")).toInt()); |
| if (e.hasAttribute(QLatin1String("colspan"))) |
| lay_item->setAttributeColSpan(e.attribute(QLatin1String("colspan")).toInt()); |
| |
| return lay_item; |
| } |
| |
| void Ui3Reader::fixLayoutMargin(DomLayout *ui_layout) |
| { |
| Q_UNUSED(ui_layout) |
| } |
| |
| static void addBooleanFontSubProperty(QDomDocument &doc, |
| const QString &name, const QString &value, |
| QDomElement &fontElement) |
| { |
| if (value == QLatin1String("true") || value == QLatin1String("1")) { |
| QDomElement child = doc.createElement(name); |
| child.appendChild(doc.createTextNode(QLatin1String("true"))); |
| fontElement.appendChild(child); |
| } else { |
| if (value == QLatin1String("false") || value == QLatin1String("0")) { |
| QDomElement child = doc.createElement(name); |
| child.appendChild(doc.createTextNode(QLatin1String("false"))); |
| fontElement.appendChild(child); |
| } |
| } |
| } |
| |
| QDomElement Ui3Reader::findDerivedFontProperties(const QDomElement &n) const |
| { |
| bool italic = false; |
| bool bold = false; |
| bool underline = false; |
| bool strikeout = false; |
| bool family = false; |
| bool pointsize = false; |
| |
| QDomDocument doc = n.ownerDocument(); |
| QDomElement result = doc.createElement(QLatin1String("font")); |
| |
| QDomNode pn = n.parentNode(); |
| while (!pn.isNull()) { |
| for (QDomElement e = pn.firstChild().toElement(); !e.isNull(); e = e.nextSibling().toElement()) { |
| if (e.tagName().toLower() == QLatin1String("property") && |
| e.attribute(QLatin1String("name")) == QLatin1String("font")) { |
| QDomElement f = e.firstChild().toElement(); |
| for (QDomElement fp = f.firstChild().toElement(); !fp.isNull(); fp = fp.nextSibling().toElement()) { |
| QString name = fp.tagName().toLower(); |
| QString text = fp.text(); |
| if (!italic && name == QLatin1String("italic")) { |
| italic = true; |
| addBooleanFontSubProperty(doc, name, text, result); |
| } else if (!bold && name == QLatin1String("bold")) { |
| bold = true; |
| addBooleanFontSubProperty(doc, name, text, result); |
| } else if (!underline && name == QLatin1String("underline")) { |
| underline = true; |
| addBooleanFontSubProperty(doc, name, text, result); |
| } else if (!strikeout && name == QLatin1String("strikeout")) { |
| strikeout = true; |
| addBooleanFontSubProperty(doc, name, text, result); |
| } else if (!family && name == QLatin1String("family")) { |
| family = true; |
| QDomElement child = doc.createElement(name); |
| child.appendChild(doc.createTextNode(text)); |
| result.appendChild(child); |
| } else if (!pointsize && name == QLatin1String("pointsize")) { |
| pointsize = true; |
| QDomElement child = doc.createElement(name); |
| child.appendChild(doc.createTextNode(text)); |
| result.appendChild(child); |
| } |
| } |
| } |
| } |
| pn = pn.parentNode(); |
| } |
| |
| return result; |
| } |
| |
| void Ui3Reader::createProperties(const QDomElement &n, QList<DomProperty*> *properties, |
| const QString &className) |
| { |
| QString objectName; |
| |
| bool wordWrapFound = false; |
| bool wordWrapPropertyFound = false; |
| |
| for (QDomElement e=n.firstChild().toElement(); !e.isNull(); e = e.nextSibling().toElement()) { |
| if (e.tagName().toLower() == QLatin1String("property")) { |
| QString name = e.attribute(QLatin1String("name")); |
| |
| // changes in QPalette |
| if (name == QLatin1String("colorGroup") |
| || name == QLatin1String("paletteForegroundColor") |
| || name == QLatin1String("paletteBackgroundColor") |
| || name == QLatin1String("backgroundMode") |
| || name == QLatin1String("backgroundOrigin") |
| || name == QLatin1String("paletteBackgroundPixmap") |
| || name == QLatin1String("backgroundBrush")) { |
| errorInvalidProperty(name, objectName, className, n.lineNumber(), n.columnNumber()); |
| continue; |
| } |
| |
| // changes in QFrame |
| if (name == QLatin1String("contentsRect")) { |
| errorInvalidProperty(name, objectName, className, n.lineNumber(), n.columnNumber()); |
| continue; |
| } |
| |
| // changes in QWidget |
| if (name == QLatin1String("underMouse") |
| || name == QLatin1String("ownFont")) { |
| errorInvalidProperty(name, objectName, className, n.lineNumber(), n.columnNumber()); |
| continue; |
| } |
| |
| if (name == QLatin1String("font")) { |
| QDomElement f = e.firstChild().toElement(); |
| e.appendChild(findDerivedFontProperties(f)); |
| e.removeChild(f); |
| } |
| |
| DomProperty *prop = readProperty(e); |
| if (!prop) |
| continue; |
| |
| if (prop->kind() == DomProperty::String) { |
| QDomNodeList comments = e.elementsByTagName(QLatin1String("comment")); |
| if (comments.length()) { |
| QString comment = comments.item(0).firstChild().toText().data(); |
| if (!comment.isEmpty()) |
| prop->elementString()->setAttributeComment(comment); |
| } |
| } |
| |
| // objectName |
| if (name == QLatin1String("name")) { |
| objectName = prop->elementCstring(); |
| continue; |
| } |
| |
| if (className == QLatin1String("Line") |
| && prop->attributeName() == QLatin1String("orientation")) { |
| delete prop; |
| continue; |
| } |
| |
| if (className.mid(1) == QLatin1String("LineEdit")) { |
| if (name == QLatin1String("hasMarkedText")) { |
| prop->setAttributeName(QLatin1String("hasSelectedText")); |
| } else if (name == QLatin1String("edited")) { |
| prop->setAttributeName(QLatin1String("modified")); |
| } else if (name == QLatin1String("markedText")) { |
| prop->setAttributeName(QLatin1String("selectedText")); |
| } |
| } |
| |
| if (className.endsWith(QLatin1String("ComboBox"))) { |
| CONVERT_PROPERTY(QLatin1String("currentItem"), QLatin1String("currentIndex")); |
| CONVERT_PROPERTY(QLatin1String("insertionPolicy"), QLatin1String("insertPolicy")); |
| } |
| |
| if (className == QLatin1String("QToolBar")) { |
| if (name == QLatin1String("label")) { |
| prop->setAttributeName(QLatin1String("windowTitle")); |
| } |
| } |
| |
| CONVERT_PROPERTY(QLatin1String("customWhatsThis"), QLatin1String("whatsThis")); |
| CONVERT_PROPERTY(QLatin1String("icon"), QLatin1String("windowIcon")); |
| CONVERT_PROPERTY(QLatin1String("iconText"), QLatin1String("windowIconText")); |
| CONVERT_PROPERTY(QLatin1String("caption"), QLatin1String("windowTitle")); |
| |
| if (name == QLatin1String("name")) { |
| continue; // skip the property name |
| } |
| |
| if (name == QLatin1String("accel")) { |
| prop->setAttributeName(QLatin1String("shortcut")); |
| } |
| |
| CONVERT_PROPERTY(QLatin1String("pixmap"), QLatin1String("icon")); |
| CONVERT_PROPERTY(QLatin1String("iconSet"), QLatin1String("icon")); |
| CONVERT_PROPERTY(QLatin1String("textLabel"), QLatin1String("text")); |
| |
| CONVERT_PROPERTY(QLatin1String("toggleButton"), QLatin1String("checkable")); |
| CONVERT_PROPERTY(QLatin1String("on"), QLatin1String("checked")); |
| |
| CONVERT_PROPERTY(QLatin1String("maxValue"), QLatin1String("maximum")); |
| CONVERT_PROPERTY(QLatin1String("minValue"), QLatin1String("minimum")); |
| CONVERT_PROPERTY(QLatin1String("lineStep"), QLatin1String("singleStep")); |
| |
| // QSlider |
| CONVERT_PROPERTY(QLatin1String("tickmarks"), QLatin1String("tickPosition")); |
| |
| name = prop->attributeName(); // sync the name |
| |
| if (className == QLatin1String("QLabel")) { |
| if (name == QLatin1String("alignment")) { |
| const QString v = prop->elementSet(); |
| if (v.contains(QRegExp(QLatin1String("\\bWordBreak\\b")))) |
| wordWrapFound = true; |
| } else if (name == QLatin1String("wordWrap")) { |
| wordWrapPropertyFound = true; |
| } |
| } |
| |
| // resolve the flags and enumerator |
| if (prop->kind() == DomProperty::Set) { |
| QStringList flags = prop->elementSet().split(QLatin1Char('|')); |
| QStringList v; |
| foreach (const QString &fl, flags) { |
| QString e = WidgetInfo::resolveEnumerator(className, fl); |
| if (e.isEmpty()) { |
| e = m_porting->renameEnumerator(className + QLatin1String("::") + fl); |
| } |
| |
| if (e.isEmpty()) { |
| fprintf(stderr, "uic3: flag '%s' for widget '%s' is not supported\n", fl.latin1(), className.latin1()); |
| continue; |
| } |
| |
| v.append(e); |
| } |
| |
| if (v.isEmpty()) { |
| delete prop; |
| continue; |
| } |
| |
| prop->setElementSet(v.join(QLatin1String("|"))); |
| } else if (prop->kind() == DomProperty::Enum) { |
| QString e = WidgetInfo::resolveEnumerator(className, prop->elementEnum()); |
| if (e.isEmpty()) { |
| e = m_porting->renameEnumerator(className + QLatin1String("::") + prop->elementEnum()); |
| } |
| |
| if (e.isEmpty()) { |
| fprintf(stderr, "uic3: enumerator '%s' for widget '%s' is not supported\n", |
| prop->elementEnum().latin1(), className.latin1()); |
| |
| delete prop; |
| continue; |
| } |
| prop->setElementEnum(e); |
| } |
| |
| |
| if (className.size() |
| && !(className == QLatin1String("QLabel") && name == QLatin1String("buddy")) |
| && !(name == QLatin1String("buttonGroupId")) |
| && !(name == QLatin1String("frameworkCode")) |
| && !(name == QLatin1String("database"))) { |
| if (!WidgetInfo::isValidProperty(className, name)) { |
| errorInvalidProperty(name, objectName, className, n.lineNumber(), n.columnNumber()); |
| delete prop; |
| } else { |
| properties->append(prop); |
| } |
| } else { |
| properties->append(prop); |
| } |
| } |
| } |
| if (className == QLatin1String("QLabel") && !wordWrapPropertyFound) { |
| DomProperty *wordWrap = new DomProperty(); |
| wordWrap->setAttributeName(QLatin1String("wordWrap")); |
| if (wordWrapFound) |
| wordWrap->setElementBool(QLatin1String("true")); |
| else |
| wordWrap->setElementBool(QLatin1String("false")); |
| properties->append(wordWrap); |
| } |
| } |
| |
| static int toQt4SizePolicy(int qt3SizePolicy) |
| { |
| if (qt3SizePolicy == 2) // qt 3 Ignored value |
| return QSizePolicy::Ignored; |
| return qt3SizePolicy; |
| } |
| |
| DomProperty *Ui3Reader::readProperty(const QDomElement &e) |
| { |
| QString name = e.firstChild().toElement().tagName().toLower(); |
| |
| if (name == QLatin1String("class")) // skip class |
| name = e.firstChild().nextSibling().toElement().tagName().toLower(); |
| |
| DomProperty *p = new DomProperty; |
| p->read(e); |
| |
| if (p->kind() == DomProperty::Number) { |
| QString value = e.firstChild().toElement().firstChild().nodeValue(); |
| |
| if (value.contains(QLatin1Char('.'))) { |
| p->setElementDouble(value.toDouble()); |
| } |
| } else if (p->kind() == DomProperty::Pixmap) { |
| DomResourcePixmap *domPix = p->elementPixmap(); |
| if (m_extractImages) { |
| QString imageFile = domPix->text() + QLatin1String(".xpm"); |
| if (m_imageMap.contains(domPix->text())) |
| imageFile = m_imageMap.value(domPix->text()); |
| domPix->setAttributeResource(m_qrcOutputFile); |
| domPix->setText(QLatin1String(":/") + nameOfClass + QLatin1String("/images/") + imageFile); |
| } |
| } else if (p->kind() == DomProperty::SizePolicy) { |
| DomSizePolicy *sp = p->elementSizePolicy(); |
| if (sp) { |
| if (sp->hasElementHSizeType()) |
| sp->setElementHSizeType(toQt4SizePolicy(sp->elementHSizeType())); |
| if (sp->hasElementVSizeType()) |
| sp->setElementVSizeType(toQt4SizePolicy(sp->elementVSizeType())); |
| } |
| } else if (p->kind() == DomProperty::Unknown) { |
| delete p; |
| p = 0; |
| } |
| |
| return p; |
| } |
| |
| void Ui3Reader::createAttributes(const QDomElement &n, QList<DomProperty*> *properties, |
| const QString &className) |
| { |
| Q_UNUSED(className); |
| |
| for (QDomElement e=n.firstChild().toElement(); !e.isNull(); e = e.nextSibling().toElement()) { |
| if (e.tagName().toLower() == QLatin1String("attribute")) { |
| QString name = e.attribute(QLatin1String("name")); |
| |
| DomProperty *prop = readProperty(e); |
| if (!prop) |
| continue; |
| |
| properties->append(prop); |
| } |
| } |
| } |
| |
| QString Ui3Reader::fixDeclaration(const QString &d) const |
| { |
| QString text; |
| |
| int i = 0; |
| while (i < d.size()) { |
| QChar ch = d.at(i); |
| |
| if (ch.isLetter() || ch == QLatin1Char('_')) { |
| int start = i; |
| while (i < d.size() && (d.at(i).isLetterOrNumber() || d.at(i) == QLatin1Char('_'))) |
| ++i; |
| |
| text += fixClassName(d.mid(start, i-start)); |
| } else { |
| text += ch; |
| ++i; |
| } |
| } |
| |
| return text; |
| } |
| |
| /* |
| fixes a (possible composite) type name |
| */ |
| QString Ui3Reader::fixType(const QString &t) const |
| { |
| QString newText = t; |
| //split type name on <>*& and whitespace |
| QStringList typeNames = t.split(QRegExp(QLatin1String("<|>|\\*|&| ")), QString::SkipEmptyParts); |
| foreach(const QString &typeName , typeNames) { |
| QString newName = fixClassName(typeName); |
| if( newName != typeName ) { |
| newText.replace(typeName, newName); |
| } |
| } |
| return newText; |
| } |
| |
| QString Ui3Reader::fixMethod(const QString &method) const |
| { |
| const QByteArray normalized = QMetaObject::normalizedSignature(method.toLatin1()); |
| QByteArray result; |
| int index = normalized.indexOf('('); |
| if (index == -1) |
| return QLatin1String(normalized); |
| result.append(normalized.left(++index)); |
| int limit = normalized.length()-1; |
| while (index < limit) { |
| QByteArray type; |
| while ((index < limit) && (normalized.at(index) != ',')) |
| type.append(normalized.at(index++)); |
| result.append(fixType(QLatin1String(type)).toLatin1()); |
| if ((index < limit) && (normalized.at(index) == ',')) |
| result.append(normalized.at(index++)); |
| } |
| result.append(normalized.mid(index)); |
| return QLatin1String(result); |
| } |
| |
| QT_END_NAMESPACE |