tools/designer/src/lib/shared/widgetdatabase.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/legal
   5 **
   6 ** This file is part of the Qt Designer of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** Commercial License Usage
  10 ** Licensees holding valid commercial Qt licenses may use this file in
  11 ** accordance with the commercial license agreement provided with the
  12 ** Software or, alternatively, in accordance with the terms contained in
  13 ** a written agreement between you and Digia.  For licensing terms and
  14 ** conditions see http://qt.digia.com/licensing.  For further information
  15 ** use the contact form at http://qt.digia.com/contact-us.
  16 **
  17 ** GNU Lesser General Public License Usage
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Digia gives you certain additional
  26 ** rights.  These rights are described in the Digia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** GNU General Public License Usage
  30 ** Alternatively, this file may be used under the terms of the GNU
  31 ** General Public License version 3.0 as published by the Free Software
  32 ** Foundation and appearing in the file LICENSE.GPL included in the
  33 ** packaging of this file.  Please review the following information to
  34 ** ensure the GNU General Public License version 3.0 requirements will be
  35 ** met: http://www.gnu.org/copyleft/gpl.html.
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "widgetdatabase_p.h"
  43 #include "widgetfactory_p.h"
  44 #include "spacer_widget_p.h"
  45 #include "abstractlanguage.h"
  46 #include "pluginmanager_p.h"
  47 #include "qdesigner_widgetbox_p.h"
  48 #include "qdesigner_utils_p.h"
  49 #include <ui4_p.h>
  50
  51 #include <QtDesigner/customwidget.h>
  52 #include <QtDesigner/propertysheet.h>
  53 #include <QtDesigner/QExtensionManager>
  54 #include <QtDesigner/QDesignerFormEditorInterface>
  55
  56 #include <QtXml/QXmlStreamWriter>
  57
  58 #include <QtCore/QScopedPointer>
  59 #include <QtCore/qdebug.h>
  60 #include <QtCore/QMetaProperty>
  61 #include <QtCore/QTextStream>
  62 #include <QtCore/QRegExp>
  63 #include <QtCore/QCoreApplication>
  64
  65 QT_BEGIN_NAMESPACE
  66
  67 namespace {
  68     enum { debugWidgetDataBase = 0 };
  69 }
  70
  71 namespace qdesigner_internal {
  72
  73 // ----------------------------------------------------------
  74 WidgetDataBaseItem::WidgetDataBaseItem(const QString &name, const QString &group)
  75     : m_name(name),
  76       m_group(group),
  77       m_compat(0),
  78       m_container(0),
  79       m_form(0),
  80       m_custom(0),
  81       m_promoted(0)
  82 {
  83 }
  84
  85 QString WidgetDataBaseItem::name() const
  86 {
  87     return m_name;
  88 }
  89
  90 void WidgetDataBaseItem::setName(const QString &name)
  91 {
  92     m_name = name;
  93 }
  94
  95 QString WidgetDataBaseItem::group() const
  96 {
  97     return m_group;
  98 }
  99
 100 void WidgetDataBaseItem::setGroup(const QString &group)
 101 {
 102     m_group = group;
 103 }
 104
 105 QString WidgetDataBaseItem::toolTip() const
 106 {
 107     return m_toolTip;
 108 }
 109
 110 void WidgetDataBaseItem::setToolTip(const QString &toolTip)
 111 {
 112     m_toolTip = toolTip;
 113 }
 114
 115 QString WidgetDataBaseItem::whatsThis() const
 116 {
 117     return m_whatsThis;
 118 }
 119
 120 void WidgetDataBaseItem::setWhatsThis(const QString &whatsThis)
 121 {
 122     m_whatsThis = whatsThis;
 123 }
 124
 125 QString WidgetDataBaseItem::includeFile() const
 126 {
 127     return m_includeFile;
 128 }
 129
 130 void WidgetDataBaseItem::setIncludeFile(const QString &includeFile)
 131 {
 132     m_includeFile = includeFile;
 133 }
 134
 135 QIcon WidgetDataBaseItem::icon() const
 136 {
 137     return m_icon;
 138 }
 139
 140 void WidgetDataBaseItem::setIcon(const QIcon &icon)
 141 {
 142     m_icon = icon;
 143 }
 144
 145 bool WidgetDataBaseItem::isCompat() const
 146 {
 147     return m_compat;
 148 }
 149
 150 void WidgetDataBaseItem::setCompat(bool b)
 151 {
 152     m_compat = b;
 153 }
 154
 155 bool WidgetDataBaseItem::isContainer() const
 156 {
 157     return m_container;
 158 }
 159
 160 void WidgetDataBaseItem::setContainer(bool b)
 161 {
 162     m_container = b;
 163 }
 164
 165 bool WidgetDataBaseItem::isCustom() const
 166 {
 167     return m_custom;
 168 }
 169
 170 void WidgetDataBaseItem::setCustom(bool b)
 171 {
 172     m_custom = b;
 173 }
 174
 175 QString WidgetDataBaseItem::pluginPath() const
 176 {
 177     return m_pluginPath;
 178 }
 179
 180 void WidgetDataBaseItem::setPluginPath(const QString &path)
 181 {
 182     m_pluginPath = path;
 183 }
 184
 185 bool WidgetDataBaseItem::isPromoted() const
 186 {
 187     return m_promoted;
 188 }
 189
 190 void WidgetDataBaseItem::setPromoted(bool b)
 191 {
 192     m_promoted = b;
 193 }
 194
 195 QString WidgetDataBaseItem::extends() const
 196 {
 197     return m_extends;
 198 }
 199
 200 void WidgetDataBaseItem::setExtends(const QString &s)
 201 {
 202     m_extends = s;
 203 }
 204
 205 void WidgetDataBaseItem::setDefaultPropertyValues(const QList<QVariant> &list)
 206 {
 207     m_defaultPropertyValues = list;
 208 }
 209
 210 QList<QVariant> WidgetDataBaseItem::defaultPropertyValues() const
 211 {
 212     return m_defaultPropertyValues;
 213 }
 214
 215 QStringList WidgetDataBaseItem::fakeSlots() const
 216 {
 217     return m_fakeSlots;
 218 }
 219
 220 void WidgetDataBaseItem::setFakeSlots(const QStringList &fs)
 221 {
 222     m_fakeSlots = fs;
 223 }
 224
 225 QStringList WidgetDataBaseItem::fakeSignals() const
 226 {
 227      return m_fakeSignals;
 228 }
 229
 230 void WidgetDataBaseItem::setFakeSignals(const QStringList &fs)
 231 {
 232     m_fakeSignals = fs;
 233 }
 234
 235 QString WidgetDataBaseItem::addPageMethod() const
 236 {
 237     return m_addPageMethod;
 238 }
 239
 240 void WidgetDataBaseItem::setAddPageMethod(const QString &m)
 241 {
 242     m_addPageMethod = m;
 243 }
 244
 245 WidgetDataBaseItem *WidgetDataBaseItem::clone(const QDesignerWidgetDataBaseItemInterface *item)
 246 {
 247     WidgetDataBaseItem *rc = new WidgetDataBaseItem(item->name(), item->group());
 248
 249     rc->setToolTip(item->toolTip());
 250     rc->setWhatsThis(item->whatsThis());
 251     rc->setIncludeFile(item->includeFile());
 252     rc->setIcon(item->icon());
 253     rc->setCompat(item->isCompat());
 254     rc->setContainer(item->isContainer());
 255     rc->setCustom(item->isCustom() );
 256     rc->setPluginPath(item->pluginPath());
 257     rc->setPromoted(item->isPromoted());
 258     rc->setExtends(item->extends());
 259     rc->setDefaultPropertyValues(item->defaultPropertyValues());
 260     // container page method, fake slots and signals ignored here.y
 261     return rc;
 262 }
 263
 264 // ----------------------------------------------------------
 265 WidgetDataBase::WidgetDataBase(QDesignerFormEditorInterface *core, QObject *parent)
 266     : QDesignerWidgetDataBaseInterface(parent),
 267       m_core(core)
 268 {
 269 #define DECLARE_LAYOUT(L, C)
 270 #define DECLARE_COMPAT_WIDGET(W, C) DECLARE_WIDGET(W, C)
 271 #define DECLARE_WIDGET(W, C) append(new WidgetDataBaseItem(QString::fromUtf8(#W)));
 272
 273 #include "widgets.table"
 274
 275 #undef DECLARE_COMPAT_WIDGET
 276 #undef DECLARE_LAYOUT
 277 #undef DECLARE_WIDGET
 278 #undef DECLARE_WIDGET_1
 279
 280     append(new WidgetDataBaseItem(QString::fromUtf8("Line")));
 281     append(new WidgetDataBaseItem(QString::fromUtf8("Spacer")));
 282     append(new WidgetDataBaseItem(QString::fromUtf8("QSplitter")));
 283     append(new WidgetDataBaseItem(QString::fromUtf8("QLayoutWidget")));
 284     // QDesignerWidget is used as central widget and as container for tab widgets, etc.
 285     WidgetDataBaseItem *designerWidgetItem = new WidgetDataBaseItem(QString::fromUtf8("QDesignerWidget"));
 286     designerWidgetItem->setContainer(true);
 287     append(designerWidgetItem);
 288     append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerDialog")));
 289     append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerMenu")));
 290     append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerMenuBar")));
 291     append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerDockWidget")));
 292     append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerQ3WidgetStack")));
 293     append(new WidgetDataBaseItem(QString::fromUtf8("QAction")));
 294     append(new WidgetDataBaseItem(QString::fromUtf8("QButtonGroup")));
 295
 296     // ### remove me
 297     // ### check the casts
 298
 299 #if 0 // ### enable me after 4.1
 300     item(indexOfClassName(QLatin1String("QToolBar")))->setContainer(true);
 301 #endif
 302
 303     item(indexOfClassName(QLatin1String("QTabWidget")))->setContainer(true);
 304     item(indexOfClassName(QLatin1String("QGroupBox")))->setContainer(true);
 305     item(indexOfClassName(QLatin1String("QScrollArea")))->setContainer(true);
 306     item(indexOfClassName(QLatin1String("QStackedWidget")))->setContainer(true);
 307     item(indexOfClassName(QLatin1String("QToolBox")))->setContainer(true);
 308     item(indexOfClassName(QLatin1String("QFrame")))->setContainer(true);
 309     item(indexOfClassName(QLatin1String("QLayoutWidget")))->setContainer(true);
 310     item(indexOfClassName(QLatin1String("QDesignerWidget")))->setContainer(true);
 311     item(indexOfClassName(QLatin1String("QDesignerDialog")))->setContainer(true);
 312     item(indexOfClassName(QLatin1String("QSplitter")))->setContainer(true);
 313     item(indexOfClassName(QLatin1String("QMainWindow")))->setContainer(true);
 314     item(indexOfClassName(QLatin1String("QDockWidget")))->setContainer(true);
 315     item(indexOfClassName(QLatin1String("QDesignerDockWidget")))->setContainer(true);
 316     item(indexOfClassName(QLatin1String("QDesignerQ3WidgetStack")))->setContainer(true);
 317     item(indexOfClassName(QLatin1String("QMdiArea")))->setContainer(true);
 318     item(indexOfClassName(QLatin1String("QWorkspace")))->setContainer(true);
 319     item(indexOfClassName(QLatin1String("QWizard")))->setContainer(true);
 320     item(indexOfClassName(QLatin1String("QWizardPage")))->setContainer(true);
 321
 322     item(indexOfClassName(QLatin1String("QWidget")))->setContainer(true);
 323     item(indexOfClassName(QLatin1String("QDialog")))->setContainer(true);
 324 }
 325
 326 WidgetDataBase::~WidgetDataBase()
 327 {
 328 }
 329
 330 QDesignerFormEditorInterface *WidgetDataBase::core() const
 331 {
 332     return m_core;
 333 }
 334
 335 int WidgetDataBase::indexOfObject(QObject *object, bool /*resolveName*/) const
 336 {
 337     QExtensionManager *mgr = m_core->extensionManager();
 338     QDesignerLanguageExtension *lang = qt_extension<QDesignerLanguageExtension*> (mgr, m_core);
 339
 340     QString id;
 341
 342     if (lang)
 343         id = lang->classNameOf(object);
 344
 345     if (id.isEmpty())
 346         id = WidgetFactory::classNameOf(m_core,object);
 347
 348     return QDesignerWidgetDataBaseInterface::indexOfClassName(id);
 349 }
 350
 351 static WidgetDataBaseItem *createCustomWidgetItem(const QDesignerCustomWidgetInterface *c,
 352                                                   const QDesignerCustomWidgetData &data)
 353 {
 354     WidgetDataBaseItem *item = new WidgetDataBaseItem(c->name(), c->group());
 355     item->setContainer(c->isContainer());
 356     item->setCustom(true);
 357     item->setIcon(c->icon());
 358     item->setIncludeFile(c->includeFile());
 359     item->setToolTip(c->toolTip());
 360     item->setWhatsThis(c->whatsThis());
 361     item->setPluginPath(data.pluginPath());
 362     item->setAddPageMethod(data.xmlAddPageMethod());
 363     item->setExtends(data.xmlExtends());
 364     return item;
 365 }
 366
 367 void WidgetDataBase::loadPlugins()
 368 {
 369     typedef QMap<QString, int> NameIndexMap;
 370     typedef QList<QDesignerWidgetDataBaseItemInterface*> ItemList;
 371     typedef QSet<QString> NameSet;
 372     // 1) create a map of existing custom classes
 373     NameIndexMap existingCustomClasses;
 374     NameSet nonCustomClasses;
 375     const int count = m_items.size();
 376     for (int i = 0; i < count; i++)    {
 377         const QDesignerWidgetDataBaseItemInterface* item =  m_items[i];
 378         if (item->isCustom() && !item->isPromoted())
 379             existingCustomClasses.insert(item->name(), i);
 380         else
 381             nonCustomClasses.insert(item->name());
 382     }
 383     // 2) create a list plugins
 384     ItemList pluginList;
 385     const QDesignerPluginManager *pm = m_core->pluginManager();
 386     foreach(QDesignerCustomWidgetInterface* c, pm->registeredCustomWidgets())
 387         pluginList += createCustomWidgetItem(c, pm->customWidgetData(c));
 388
 389     // 3) replace custom classes or add new ones, remove them from existingCustomClasses,
 390     // leaving behind deleted items
 391     unsigned replacedPlugins = 0;
 392     unsigned addedPlugins = 0;
 393     unsigned removedPlugins = 0;
 394     if (!pluginList.empty()) {
 395         ItemList::const_iterator cend = pluginList.constEnd();
 396         for (ItemList::const_iterator it = pluginList.constBegin();it != cend; ++it )  {
 397             QDesignerWidgetDataBaseItemInterface* pluginItem = *it;
 398             const QString pluginName = pluginItem->name();
 399             NameIndexMap::iterator existingIt = existingCustomClasses.find(pluginName);
 400             if (existingIt == existingCustomClasses.end()) {
 401                 // Add new class.
 402                 if (nonCustomClasses.contains(pluginName)) {
 403                     designerWarning(tr("A custom widget plugin whose class name (%1) matches that of an existing class has been found.").arg(pluginName));
 404                 } else {
 405                     append(pluginItem);
 406                     addedPlugins++;
 407                 }
 408             } else {
 409                 // replace existing info
 410                 const int existingIndex = existingIt.value();
 411                 delete m_items[existingIndex];
 412                 m_items[existingIndex] = pluginItem;
 413                 existingCustomClasses.erase(existingIt);
 414                 replacedPlugins++;
 415
 416             }
 417         }
 418     }
 419     // 4) remove classes that have not been matched. The stored indexes become invalid while deleting.
 420     if (!existingCustomClasses.empty()) {
 421         NameIndexMap::const_iterator cend = existingCustomClasses.constEnd();
 422         for (NameIndexMap::const_iterator it = existingCustomClasses.constBegin();it != cend; ++it )  {
 423             const int index = indexOfClassName(it.key());
 424             if (index != -1) {
 425                 remove(index);
 426                 removedPlugins++;
 427             }
 428         }
 429     }
 430     if (debugWidgetDataBase)
 431         qDebug() << "WidgetDataBase::loadPlugins(): " << addedPlugins << " added, " << replacedPlugins << " replaced, " << removedPlugins << "deleted.";
 432 }
 433
 434 void WidgetDataBase::remove(int index)
 435 {
 436     Q_ASSERT(index < m_items.size());
 437     delete m_items.takeAt(index);
 438 }
 439
 440 QList<QVariant> WidgetDataBase::defaultPropertyValues(const QString &name)
 441 {
 442     WidgetFactory *factory = qobject_cast<WidgetFactory *>(m_core->widgetFactory());
 443     Q_ASSERT(factory);
 444     // Create non-widgets, widgets in order
 445     QObject* object = factory->createObject(name, 0);
 446     if (!object)
 447         object = factory->createWidget(name, 0);
 448     if (!object) {
 449         qDebug() << "** WARNING Factory failed to create " << name;
 450         return QList<QVariant>();
 451     }
 452     // Get properties from sheet.
 453     QList<QVariant> result;
 454     if (const QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(m_core->extensionManager(), object)) {
 455         const int propertyCount = sheet->count();
 456         for (int i = 0; i < propertyCount; ++i) {
 457             result.append(sheet->property(i));
 458         }
 459     }
 460     delete object;
 461     return result;
 462 }
 463
 464 void WidgetDataBase::grabDefaultPropertyValues()
 465 {
 466     const int itemCount = count();
 467     for (int i = 0; i < itemCount; ++i) {
 468         QDesignerWidgetDataBaseItemInterface *dbItem = item(i);
 469         const QList<QVariant> default_prop_values = defaultPropertyValues(dbItem->name());
 470         dbItem->setDefaultPropertyValues(default_prop_values);
 471     }
 472 }
 473
 474 void WidgetDataBase::grabStandardWidgetBoxIcons()
 475 {
 476     // At this point, grab the default icons for the non-custom widgets from
 477     // the widget box. They will show up in the object inspector.
 478     if (const QDesignerWidgetBox *wb = qobject_cast<const QDesignerWidgetBox *>(m_core->widgetBox())) {
 479         const QString qWidgetClass = QLatin1String("QWidget");
 480         const int itemCount = count();
 481         for (int i = 0; i < itemCount; ++i) {
 482             QDesignerWidgetDataBaseItemInterface *dbItem = item(i);
 483             if (!dbItem->isCustom() && dbItem->icon().isNull()) {
 484                 // Careful not to catch the layout icons when looking for
 485                 // QWidget
 486                 const QString name = dbItem->name();
 487                 if (name == qWidgetClass) {
 488                     dbItem->setIcon(wb->iconForWidget(name, QLatin1String("Containers")));
 489                 } else {
 490                     dbItem->setIcon(wb->iconForWidget(name));
 491                 }
 492             }
 493         }
 494     }
 495 }
 496
 497 // --------------------- Functions relevant generation of new forms based on widgets (apart from the standard templates)
 498
 499 enum { NewFormWidth = 400, NewFormHeight = 300 };
 500
 501 // Check if class is suitable to generate a form from
 502 static inline bool isExistingTemplate(const QString &className)
 503 {
 504     return className == QLatin1String("QWidget") || className == QLatin1String("QDialog") || className == QLatin1String("QMainWindow");
 505 }
 506
 507 // Check if class is suitable to generate a form from
 508 static inline bool suitableForNewForm(const QString &className)
 509 {
 510     if (className.isEmpty()) // Missing custom widget information
 511         return false;
 512     if (className == QLatin1String("QWorkspace"))
 513          return false;
 514     if (className == QLatin1String("QSplitter"))
 515          return false;
 516     if (className.startsWith(QLatin1String("QDesigner")) || className.startsWith(QLatin1String("Q3")) ||  className.startsWith(QLatin1String("QLayout")))
 517         return false;
 518     return true;
 519 }
 520
 521 // Return a list of widget classes from which new forms can be generated.
 522 // Suitable for 'New form' wizards in integrations.
 523 QStringList WidgetDataBase::formWidgetClasses(const QDesignerFormEditorInterface *core)
 524 {
 525     static QStringList rc;
 526     if (rc.empty()) {
 527         const QDesignerWidgetDataBaseInterface *wdb = core->widgetDataBase();
 528         const int widgetCount = wdb->count();
 529         for (int i = 0; i < widgetCount; i++) {
 530             const QDesignerWidgetDataBaseItemInterface *item = wdb->item(i);
 531             if (item->isContainer() && !item->isCustom() && !item->isPromoted()) {
 532                 const QString name = item->name(); // Standard Widgets: no existing templates
 533                 if (!isExistingTemplate(name) && suitableForNewForm(name))
 534                     rc += name;
 535             }
 536         }
 537     }
 538     return rc;
 539 }
 540
 541 // Return a list of custom widget classes from which new forms can be generated.
 542 // Suitable for 'New form' wizards in integrations.
 543 QStringList WidgetDataBase::customFormWidgetClasses(const QDesignerFormEditorInterface *core)
 544 {
 545     QStringList rc;
 546     const QDesignerWidgetDataBaseInterface *wdb = core->widgetDataBase();
 547     const int widgetCount = wdb->count();
 548     for (int i = 0; i < widgetCount; i++) { // Custom widgets: check name and base class.
 549         const QDesignerWidgetDataBaseItemInterface *item = wdb->item(i);
 550         if (item->isContainer() && item->isCustom() && !item->isPromoted()) {
 551             if (suitableForNewForm(item->name()) && suitableForNewForm(item->extends()))
 552                 rc += item->name();
 553         }
 554     }
 555     return rc;
 556 }
 557
 558 // Get XML for a new form from the widget box. Change objectName/geometry
 559 // properties to be suitable for new forms
 560 static QString xmlFromWidgetBox(const QDesignerFormEditorInterface *core, const QString &className, const QString &objectName)
 561 {
 562     typedef QList<DomProperty*> PropertyList;
 563
 564     QDesignerWidgetBoxInterface::Widget widget;
 565     const bool found = QDesignerWidgetBox::findWidget(core->widgetBox(), className, QString(), &widget);
 566     if (!found)
 567         return QString();
 568     QScopedPointer<DomUI> domUI(QDesignerWidgetBox::xmlToUi(className, widget.domXml(), false));
 569     if (domUI.isNull())
 570         return QString();
 571     domUI->setAttributeVersion(QLatin1String("4.0"));
 572     DomWidget *domWidget = domUI->elementWidget();
 573     if (!domWidget)
 574         return QString();
 575     // Properties: Remove the "objectName" property in favour of the name attribute and check geometry.
 576     domWidget->setAttributeName(objectName);
 577     const QString geometryProperty = QLatin1String("geometry");
 578     const QString objectNameProperty  = QLatin1String("objectName");
 579     PropertyList properties = domWidget->elementProperty();
 580     for (PropertyList::iterator it = properties.begin(); it != properties.end(); ) {
 581         DomProperty *property = *it;
 582         if (property->attributeName() == objectNameProperty) { // remove  "objectName"
 583             it = properties.erase(it);
 584             delete property;
 585         } else {
 586             if (property->attributeName() == geometryProperty) { // Make sure form is at least 400, 300
 587                 if (DomRect *geom = property->elementRect()) {
 588                     if (geom->elementWidth() < NewFormWidth)
 589                         geom->setElementWidth(NewFormWidth);
 590                     if (geom->elementHeight() < NewFormHeight)
 591                         geom->setElementHeight(NewFormHeight);
 592                 }
 593             }
 594             ++it;
 595         }
 596     }
 597     // Add a window title property
 598     DomString *windowTitleString = new DomString;
 599     windowTitleString->setText(objectName);
 600     DomProperty *windowTitleProperty = new DomProperty;
 601     windowTitleProperty->setAttributeName(QLatin1String("windowTitle"));
 602     windowTitleProperty->setElementString(windowTitleString);
 603     properties.push_back(windowTitleProperty);
 604     // ------
 605     domWidget->setElementProperty(properties);
 606     // Embed in in DomUI and get string. Omit the version number.
 607     domUI->setElementClass(objectName);
 608
 609     QString rc;
 610     { // Serialize domUI
 611         QXmlStreamWriter writer(&rc);
 612         writer.setAutoFormatting(true);
 613         writer.setAutoFormattingIndent(1);
 614         writer.writeStartDocument();
 615         domUI->write(writer);
 616         writer.writeEndDocument();
 617     }
 618     return rc;
 619 }
 620
 621 // Generate default standard ui new form xml based on the class passed on as similarClassName.
 622 static QString generateNewFormXML(const QString &className, const QString &similarClassName, const QString &name)
 623 {
 624     QString rc; {
 625         QTextStream str(&rc);
 626         str << QLatin1String("<ui version=\"4.0\" >\n<class>") << name << QLatin1String("</class>\n")
 627             <<  QLatin1String("<widget class=\"") << className << QLatin1String("\" name=\"") << name << QLatin1String("\" >\n")
 628             <<  QLatin1String("<property name=\"geometry\" >\n<rect><x>0</x><y>0</y><width>")
 629             << NewFormWidth << QLatin1String("</width><height>") << NewFormHeight << QLatin1String("</height></rect>\n</property>\n");
 630         str << QLatin1String("<property name=\"windowTitle\" >\n<string>") << name << QLatin1String("</string>\n</property>\n");
 631
 632         if (similarClassName == QLatin1String("QMainWindow")) {
 633             str << QLatin1String("<widget class=\"QWidget\" name=\"centralwidget\" />\n");
 634         } else {
 635             if (similarClassName == QLatin1String("QWizard"))
 636                 str << QLatin1String("<widget class=\"QWizardPage\" name=\"wizardPage1\" /><widget class=\"QWizardPage\" name=\"wizardPage2\" />\n");
 637         }
 638         str << QLatin1String("</widget>\n</ui>\n");
 639     }
 640     return rc;
 641 }
 642
 643 // Generate a form template using a class name obtained from formWidgetClasses(), customFormWidgetClasses().
 644 QString WidgetDataBase::formTemplate(const QDesignerFormEditorInterface *core, const QString &className, const QString &objectName)
 645 {
 646     // How to find suitable XML for a class:
 647     // 1) Look in widget box (as all the required centralwidgets, tab widget pages, etc. should be there).
 648     const QString widgetBoxXml = xmlFromWidgetBox(core, className, objectName);
 649     if (!widgetBoxXml.isEmpty())
 650         return widgetBoxXml;
 651     // 2) If that fails, only custom main windows, custom dialogs and unsupported Qt Widgets should
 652     //    be left over. Generate something that is similar to the default templates. Find a similar class.
 653     const QDesignerWidgetDataBaseInterface *wdb = core->widgetDataBase();
 654     QString similarClass = QLatin1String("QWidget");
 655     const int index = wdb->indexOfClassName(className);
 656     if (index != -1) {
 657         const QDesignerWidgetDataBaseItemInterface *item = wdb->item(index);
 658         similarClass = item->isCustom() ? item->extends() : item->name();
 659     }
 660     // Generate standard ui based on the class passed on as baseClassName.
 661     const QString rc = generateNewFormXML(className, similarClass, objectName);
 662     return rc;
 663 }
 664
 665 // Set a fixed size on a XML template
 666 QString WidgetDataBase::scaleFormTemplate(const QString &xml, const QSize &size, bool fixed)
 667 {
 668     typedef QList<DomProperty*> PropertyList;
 669     DomUI *domUI = QDesignerWidgetBox::xmlToUi(QLatin1String("Form"), xml, false);
 670     if (!domUI)
 671         return QString();
 672     DomWidget *domWidget = domUI->elementWidget();
 673     if (!domWidget)
 674         return QString();
 675     // Properties: Find/Ensure the geometry, minimum and maximum sizes properties
 676     const QString geometryPropertyName = QLatin1String("geometry");
 677     const QString minimumSizePropertyName = QLatin1String("minimumSize");
 678     const QString maximumSizePropertyName = QLatin1String("maximumSize");
 679     DomProperty *geomProperty = 0;
 680     DomProperty *minimumSizeProperty = 0;
 681     DomProperty *maximumSizeProperty = 0;
 682
 683     PropertyList properties = domWidget->elementProperty();
 684     const PropertyList::const_iterator cend = properties.constEnd();
 685     for (PropertyList::const_iterator it = properties.constBegin(); it != cend; ++it) {
 686         const QString name = (*it)->attributeName();
 687         if (name == geometryPropertyName) {
 688             geomProperty = *it;
 689         } else {
 690             if (name == minimumSizePropertyName) {
 691                 minimumSizeProperty = *it;
 692             } else {
 693                 if (name == maximumSizePropertyName)
 694                     maximumSizeProperty = *it;
 695             }
 696         }
 697     }
 698     if (!geomProperty) {
 699         geomProperty = new DomProperty;
 700         geomProperty->setAttributeName(geometryPropertyName);
 701         geomProperty->setElementRect(new DomRect);
 702         properties.push_front(geomProperty);
 703     }
 704     if (fixed) {
 705         if (!minimumSizeProperty) {
 706             minimumSizeProperty = new DomProperty;
 707             minimumSizeProperty->setAttributeName(minimumSizePropertyName);
 708             minimumSizeProperty->setElementSize(new DomSize);
 709             properties.push_back(minimumSizeProperty);
 710         }
 711         if (!maximumSizeProperty) {
 712             maximumSizeProperty = new DomProperty;
 713             maximumSizeProperty->setAttributeName(maximumSizePropertyName);
 714             maximumSizeProperty->setElementSize(new DomSize);
 715             properties.push_back(maximumSizeProperty);
 716         }
 717     }
 718     // Set values of geometry, minimum and maximum sizes properties
 719     const int width = size.width();
 720     const int height = size.height();
 721     if (DomRect *geom = geomProperty->elementRect()) {
 722         geom->setElementWidth(width);
 723         geom->setElementHeight(height);
 724     }
 725     if (fixed) {
 726         if (DomSize *s = minimumSizeProperty->elementSize()) {
 727             s->setElementWidth(width);
 728             s->setElementHeight(height);
 729         }
 730         if (DomSize *s = maximumSizeProperty->elementSize()) {
 731             s->setElementWidth(width);
 732             s->setElementHeight(height);
 733         }
 734     }
 735     // write back
 736     domWidget->setElementProperty(properties);
 737
 738     QString rc;
 739     { // serialize domUI
 740         QXmlStreamWriter writer(&rc);
 741         writer.setAutoFormatting(true);
 742         writer.setAutoFormattingIndent(1);
 743         writer.writeStartDocument();
 744         domUI->write(writer);
 745         writer.writeEndDocument();
 746     }
 747
 748     delete domUI;
 749     return rc;
 750 }
 751
 752 // ---- free functions
 753 QDESIGNER_SHARED_EXPORT IncludeSpecification  includeSpecification(QString includeFile)
 754 {
 755     const bool global = !includeFile.isEmpty() &&
 756                         includeFile[0] == QLatin1Char('<') &&
 757                         includeFile[includeFile.size() - 1] ==  QLatin1Char('>');
 758     if (global) {
 759         includeFile.remove(includeFile.size() - 1, 1);
 760         includeFile.remove(0, 1);
 761     }
 762     return IncludeSpecification(includeFile, global ? IncludeGlobal : IncludeLocal);
 763 }
 764
 765 QDESIGNER_SHARED_EXPORT QString buildIncludeFile(QString includeFile, IncludeType includeType) {
 766     if (includeType == IncludeGlobal && !includeFile.isEmpty()) {
 767         includeFile.append(QLatin1Char('>'));
 768         includeFile.insert(0, QLatin1Char('<'));
 769     }
 770     return includeFile;
 771 }
 772
 773
 774 /* Appends a derived class to the database inheriting the data of the base class. Used
 775    for custom and promoted widgets.
 776
 777    Depending on whether an entry exists, the existing or a newly created entry is
 778    returned. A return value of 0 indicates that the base class could not be found. */
 779
 780 QDESIGNER_SHARED_EXPORT QDesignerWidgetDataBaseItemInterface *
 781         appendDerived(QDesignerWidgetDataBaseInterface *db,
 782                       const QString &className, const QString &group,
 783                       const QString &baseClassName,
 784                       const QString &includeFile,
 785                       bool promoted, bool custom)
 786 {
 787     if (debugWidgetDataBase)
 788         qDebug() << "appendDerived " << className << " derived from " << baseClassName;
 789     // Check.
 790     if (className.isEmpty() || baseClassName.isEmpty()) {
 791         qWarning("** WARNING %s called with an empty class names: '%s' extends '%s'.",
 792                  Q_FUNC_INFO, className.toUtf8().constData(), baseClassName.toUtf8().constData());
 793         return 0;
 794     }
 795     // Check whether item already exists.
 796     QDesignerWidgetDataBaseItemInterface *derivedItem = 0;
 797     const int existingIndex = db->indexOfClassName(className);
 798     if ( existingIndex != -1)
 799         derivedItem =  db->item(existingIndex);
 800     if (derivedItem) {
 801         // Check the existing item for base class mismatch. This will likely
 802         // happen when loading a file written by an instance with missing plugins.
 803         // In that case, just warn and ignore the file properties.
 804         //
 805         // An empty base class indicates that it is not known (for example, for custom plugins).
 806         // In this case, the widget DB is later updated once the widget is created
 807         // by DOM (by querying the metaobject). Suppress the warning.
 808         const QString existingBaseClass = derivedItem->extends();
 809         if (existingBaseClass.isEmpty() || baseClassName ==  existingBaseClass)
 810             return derivedItem;
 811
 812         // Warn about mismatches
 813         designerWarning(QCoreApplication::translate("WidgetDataBase",
 814           "The file contains a custom widget '%1' whose base class (%2)"
 815           " differs from the current entry in the widget database (%3)."
 816           " The widget database is left unchanged.").
 817                         arg(className, baseClassName, existingBaseClass));
 818         return derivedItem;
 819     }
 820     // Create this item, inheriting its base properties
 821     const int baseIndex = db->indexOfClassName(baseClassName);
 822     if (baseIndex == -1) {
 823         if (debugWidgetDataBase)
 824             qDebug() << "appendDerived failed due to missing base class";
 825         return 0;
 826     }
 827     const QDesignerWidgetDataBaseItemInterface *baseItem = db->item(baseIndex);
 828     derivedItem = WidgetDataBaseItem::clone(baseItem);
 829     // Sort of hack: If base class is QWidget, we most likely
 830     // do not want to inherit the container attribute.
 831     static const QString qWidgetName = QLatin1String("QWidget");
 832     if (baseItem->name() == qWidgetName)
 833         derivedItem->setContainer(false);
 834     // set new props
 835     derivedItem->setName(className);
 836     derivedItem->setGroup(group);
 837     derivedItem->setCustom(custom);
 838     derivedItem->setPromoted(promoted);
 839     derivedItem->setExtends(baseClassName);
 840     derivedItem->setIncludeFile(includeFile);
 841     db->append(derivedItem);
 842     return derivedItem;
 843 }
 844
 845 /* Return a list of database items to which a class can be promoted to. */
 846
 847 QDESIGNER_SHARED_EXPORT WidgetDataBaseItemList
 848         promotionCandidates(const QDesignerWidgetDataBaseInterface *db,
 849                             const QString &baseClassName)
 850 {
 851     WidgetDataBaseItemList rc;
 852     // find existing promoted widgets deriving from base.
 853     const int count = db->count();
 854     for (int i = 0; i < count; ++i) {
 855         QDesignerWidgetDataBaseItemInterface *item = db->item(i);
 856         if (item->isPromoted() && item->extends() == baseClassName) {
 857             rc.push_back(item);
 858         }
 859     }
 860     return rc;
 861 }
 862 } // namespace qdesigner_internal
 863
 864 QT_END_NAMESPACE