1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the tools applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "ui4.h"

    42 

    43 #ifdef QUILOADER_QDOM_READ

    44 #include <QtXml/QDomElement>

    45 #endif

    46 

    47 QT_BEGIN_NAMESPACE

    48 #ifdef QFORMINTERNAL_NAMESPACE

    49 using namespace QFormInternal;

    50 #endif

    51 

    52 /*******************************************************************************

    53 ** Implementations

    54 */

    55 

    56 void DomUI::clear(bool clear_all)

    57 {

    58     delete m_widget;

    59     delete m_layoutDefault;

    60     delete m_layoutFunction;

    61     delete m_customWidgets;

    62     delete m_tabStops;

    63     delete m_images;

    64     delete m_includes;

    65     delete m_resources;

    66     delete m_connections;

    67     delete m_designerdata;

    68     delete m_slots;

    69     delete m_buttonGroups;

    70 

    71     if (clear_all) {

    72     m_text.clear();

    73     m_has_attr_version = false;

    74     m_has_attr_language = false;

    75     m_has_attr_displayname = false;

    76     m_has_attr_stdsetdef = false;

    77     m_attr_stdsetdef = 0;

    78     m_has_attr_stdSetDef = false;

    79     m_attr_stdSetDef = 0;

    80     }

    81 

    82     m_children = 0;

    83     m_widget = 0;

    84     m_layoutDefault = 0;

    85     m_layoutFunction = 0;

    86     m_customWidgets = 0;

    87     m_tabStops = 0;

    88     m_images = 0;

    89     m_includes = 0;

    90     m_resources = 0;

    91     m_connections = 0;

    92     m_designerdata = 0;

    93     m_slots = 0;

    94     m_buttonGroups = 0;

    95 }

    96 

    97 DomUI::DomUI()

    98 {

    99     m_children = 0;

   100     m_has_attr_version = false;

   101     m_has_attr_language = false;

   102     m_has_attr_displayname = false;

   103     m_has_attr_stdsetdef = false;

   104     m_attr_stdsetdef = 0;

   105     m_has_attr_stdSetDef = false;

   106     m_attr_stdSetDef = 0;

   107     m_widget = 0;

   108     m_layoutDefault = 0;

   109     m_layoutFunction = 0;

   110     m_customWidgets = 0;

   111     m_tabStops = 0;

   112     m_images = 0;

   113     m_includes = 0;

   114     m_resources = 0;

   115     m_connections = 0;

   116     m_designerdata = 0;

   117     m_slots = 0;

   118     m_buttonGroups = 0;

   119 }

   120 

   121 DomUI::~DomUI()

   122 {

   123     delete m_widget;

   124     delete m_layoutDefault;

   125     delete m_layoutFunction;

   126     delete m_customWidgets;

   127     delete m_tabStops;

   128     delete m_images;

   129     delete m_includes;

   130     delete m_resources;

   131     delete m_connections;

   132     delete m_designerdata;

   133     delete m_slots;

   134     delete m_buttonGroups;

   135 }

   136 

   137 void DomUI::read(QXmlStreamReader &reader)

   138 {

   139 

   140     foreach (const QXmlStreamAttribute &attribute, reader.attributes()) {

   141         QStringRef name = attribute.name();

   142         if (name == QLatin1String("version")) {

   143             setAttributeVersion(attribute.value().toString());

   144             continue;

   145         }

   146         if (name == QLatin1String("language")) {

   147             setAttributeLanguage(attribute.value().toString());

   148             continue;

   149         }

   150         if (name == QLatin1String("displayname")) {

   151             setAttributeDisplayname(attribute.value().toString());

   152             continue;

   153         }

   154         if (name == QLatin1String("stdsetdef")) {

   155             setAttributeStdsetdef(attribute.value().toString().toInt());

   156             continue;

   157         }

   158         if (name == QLatin1String("stdSetDef")) {

   159             setAttributeStdSetDef(attribute.value().toString().toInt());

   160             continue;

   161         }

   162         reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString());

   163     }

   164 

   165     for (bool finished = false; !finished && !reader.hasError();) {

   166         switch (reader.readNext()) {

   167         case QXmlStreamReader::StartElement : {

   168             const QString tag = reader.name().toString().toLower();

   169             if (tag == QLatin1String("author")) {

   170                 setElementAuthor(reader.readElementText());

   171                 continue;

   172             }

   173             if (tag == QLatin1String("comment")) {

   174                 setElementComment(reader.readElementText());

   175                 continue;

   176             }

   177             if (tag == QLatin1String("exportmacro")) {

   178                 setElementExportMacro(reader.readElementText());

   179                 continue;

   180             }

   181             if (tag == QLatin1String("class")) {

   182                 setElementClass(reader.readElementText());

   183                 continue;

   184             }

   185             if (tag == QLatin1String("widget")) {

   186                 DomWidget *v = new DomWidget();

   187                 v->read(reader);

   188                 setElementWidget(v);

   189                 continue;

   190             }

   191             if (tag == QLatin1String("layoutdefault")) {

   192                 DomLayoutDefault *v = new DomLayoutDefault();

   193                 v->read(reader);

   194                 setElementLayoutDefault(v);

   195                 continue;

   196             }

   197             if (tag == QLatin1String("layoutfunction")) {

   198                 DomLayoutFunction *v = new DomLayoutFunction();

   199                 v->read(reader);

   200                 setElementLayoutFunction(v);

   201                 continue;

   202             }

   203             if (tag == QLatin1String("pixmapfunction")) {

   204                 setElementPixmapFunction(reader.readElementText());

   205                 continue;

   206             }

   207             if (tag == QLatin1String("customwidgets")) {

   208                 DomCustomWidgets *v = new DomCustomWidgets();

   209                 v->read(reader);

   210                 setElementCustomWidgets(v);

   211                 continue;

   212             }

   213             if (tag == QLatin1String("tabstops")) {

   214                 DomTabStops *v = new DomTabStops();

   215                 v->read(reader);

   216                 setElementTabStops(v);

   217                 continue;

   218             }

   219             if (tag == QLatin1String("images")) {

   220                 DomImages *v = new DomImages();

   221                 v->read(reader);

   222                 setElementImages(v);

   223                 continue;

   224             }

   225             if (tag == QLatin1String("includes")) {

   226                 DomIncludes *v = new DomIncludes();

   227                 v->read(reader);

   228                 setElementIncludes(v);

   229                 continue;

   230             }

   231             if (tag == QLatin1String("resources")) {

   232                 DomResources *v = new DomResources();

   233                 v->read(reader);

   234                 setElementResources(v);

   235                 continue;

   236             }

   237             if (tag == QLatin1String("connections")) {

   238                 DomConnections *v = new DomConnections();

   239                 v->read(reader);

   240                 setElementConnections(v);

   241                 continue;

   242             }

   243             if (tag == QLatin1String("designerdata")) {

   244                 DomDesignerData *v = new DomDesignerData();

   245                 v->read(reader);

   246                 setElementDesignerdata(v);

   247                 continue;

   248             }

   249             if (tag == QLatin1String("slots")) {

   250                 DomSlots *v = new DomSlots();

   251                 v->read(reader);

   252                 setElementSlots(v);

   253                 continue;

   254             }

   255             if (tag == QLatin1String("buttongroups")) {

   256                 DomButtonGroups *v = new DomButtonGroups();

   257                 v->read(reader);

   258                 setElementButtonGroups(v);

   259                 continue;

   260             }

   261             reader.raiseError(QLatin1String("Unexpected element ") + tag);

   262         }

   263             break;

   264         case QXmlStreamReader::EndElement :

   265             finished = true;

   266             break;

   267         case QXmlStreamReader::Characters :

   268             if (!reader.isWhitespace())

   269                 m_text.append(reader.text().toString());

   270             break;

   271         default :

   272             break;

   273         }

   274     }

   275 }

   276 

   277 #ifdef QUILOADER_QDOM_READ

   278 void DomUI::read(const QDomElement &node)

   279 {

   280     if (node.hasAttribute(QLatin1String("version")))

   281         setAttributeVersion(node.attribute(QLatin1String("version")));

   282     if (node.hasAttribute(QLatin1String("language")))

   283         setAttributeLanguage(node.attribute(QLatin1String("language")));

   284     if (node.hasAttribute(QLatin1String("displayname")))

   285         setAttributeDisplayname(node.attribute(QLatin1String("displayname")));

   286     if (node.hasAttribute(QLatin1String("stdsetdef")))

   287         setAttributeStdsetdef(node.attribute(QLatin1String("stdsetdef")).toInt());

   288     if (node.hasAttribute(QLatin1String("stdSetDef")))

   289         setAttributeStdSetDef(node.attribute(QLatin1String("stdSetDef")).toInt());

   290 

   291     for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) {

   292         if (!n.isElement())

   293             continue;

   294         QDomElement e = n.toElement();

   295         QString tag = e.tagName().toLower();

   296             if (tag == QLatin1String("author")) {

   297                 setElementAuthor(e.text());

   298                 continue;

   299             }

   300             if (tag == QLatin1String("comment")) {

   301                 setElementComment(e.text());

   302                 continue;

   303             }

   304             if (tag == QLatin1String("exportmacro")) {

   305                 setElementExportMacro(e.text());

   306                 continue;

   307             }

   308             if (tag == QLatin1String("class")) {

   309                 setElementClass(e.text());

   310                 continue;

   311             }

   312             if (tag == QLatin1String("widget")) {

   313                 DomWidget *v = new DomWidget();

   314                 v->read(e);

   315                 setElementWidget(v);

   316                 continue;

   317             }

   318             if (tag == QLatin1String("layoutdefault")) {

   319                 DomLayoutDefault *v = new DomLayoutDefault();

   320                 v->read(e);

   321                 setElementLayoutDefault(v);

   322                 continue;

   323             }

   324             if (tag == QLatin1String("layoutfunction")) {

   325                 DomLayoutFunction *v = new DomLayoutFunction();

   326                 v->read(e);

   327                 setElementLayoutFunction(v);

   328                 continue;

   329             }

   330             if (tag == QLatin1String("pixmapfunction")) {

   331                 setElementPixmapFunction(e.text());

   332                 continue;

   333             }

   334             if (tag == QLatin1String("customwidgets")) {

   335                 DomCustomWidgets *v = new DomCustomWidgets();

   336                 v->read(e);

   337                 setElementCustomWidgets(v);

   338                 continue;

   339             }

   340             if (tag == QLatin1String("tabstops")) {

   341                 DomTabStops *v = new DomTabStops();

   342                 v->read(e);

   343                 setElementTabStops(v);

   344                 continue;

   345             }

   346             if (tag == QLatin1String("images")) {

   347                 DomImages *v = new DomImages();

   348                 v->read(e);

   349                 setElementImages(v);

   350                 continue;

   351             }

   352             if (tag == QLatin1String("includes")) {

   353                 DomIncludes *v = new DomIncludes();

   354                 v->read(e);

   355                 setElementIncludes(v);

   356                 continue;

   357             }

   358             if (tag == QLatin1String("resources")) {

   359                 DomResources *v = new DomResources();

   360                 v->read(e);

   361                 setElementResources(v);

   362                 continue;

   363             }

   364             if (tag == QLatin1String("connections")) {

   365                 DomConnections *v = new DomConnections();

   366                 v->read(e);

   367                 setElementConnections(v);

   368                 continue;

   369             }

   370             if (tag == QLatin1String("designerdata")) {

   371                 DomDesignerData *v = new DomDesignerData();

   372                 v->read(e);

   373                 setElementDesignerdata(v);

   374                 continue;

   375             }

   376             if (tag == QLatin1String("slots")) {

   377                 DomSlots *v = new DomSlots();

   378                 v->read(e);

   379                 setElementSlots(v);

   380                 continue;

   381             }

   382             if (tag == QLatin1String("buttongroups")) {

   383                 DomButtonGroups *v = new DomButtonGroups();

   384                 v->read(e);

   385                 setElementButtonGroups(v);

   386                 continue;

   387             }

   388     }

   389     m_text.clear();

   390     for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) {

   391         if (child.isText())

   392             m_text.append(child.nodeValue());

   393      }

   394 }

   395 #endif

   396 

   397 void DomUI::write(QXmlStreamWriter &writer, const QString &tagName) const

   398 {

   399     writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("ui") : tagName.toLower());

   400 

   401     if (hasAttributeVersion())

   402         writer.writeAttribute(QLatin1String("version"), attributeVersion());

   403 

   404     if (hasAttributeLanguage())

   405         writer.writeAttribute(QLatin1String("language"), attributeLanguage());

   406 

   407     if (hasAttributeDisplayname())

   408         writer.writeAttribute(QLatin1String("displayname"), attributeDisplayname());

   409 

   410     if (hasAttributeStdsetdef())

   411         writer.writeAttribute(QLatin1String("stdsetdef"), QString::number(attributeStdsetdef()));

   412 

   413     if (hasAttributeStdSetDef())

   414         writer.writeAttribute(QLatin1String("stdsetdef"), QString::number(attributeStdSetDef()));

   415 

   416     if (m_children & Author) {

   417         writer.writeTextElement(QLatin1String("author"), m_author);

   418     }

   419 

   420     if (m_children & Comment) {

   421         writer.writeTextElement(QLatin1String("comment"), m_comment);

   422     }

   423 

   424     if (m_children & ExportMacro) {

   425         writer.writeTextElement(QLatin1String("exportmacro"), m_exportMacro);

   426     }

   427 

   428     if (m_children & Class) {

   429         writer.writeTextElement(QLatin1String("class"), m_class);

   430     }

   431 

   432     if (m_children & Widget) {

   433         m_widget->write(writer, QLatin1String("widget"));

   434     }

   435 

   436     if (m_children & LayoutDefault) {

   437         m_layoutDefault->write(writer, QLatin1String("layoutdefault"));

   438     }

   439 

   440     if (m_children & LayoutFunction) {

   441         m_layoutFunction->write(writer, QLatin1String("layoutfunction"));

   442     }

   443 

   444     if (m_children & PixmapFunction) {

   445         writer.writeTextElement(QLatin1String("pixmapfunction"), m_pixmapFunction);

   446     }

   447 

   448     if (m_children & CustomWidgets) {

   449         m_customWidgets->write(writer, QLatin1String("customwidgets"));

   450     }

   451 

   452     if (m_children & TabStops) {

   453         m_tabStops->write(writer, QLatin1String("tabstops"));

   454     }

   455 

   456     if (m_children & Images) {

   457         m_images->write(writer, QLatin1String("images"));

   458     }

   459 

   460     if (m_children & Includes) {

   461         m_includes->write(writer, QLatin1String("includes"));

   462     }

   463 

   464     if (m_children & Resources) {

   465         m_resources->write(writer, QLatin1String("resources"));

   466     }

   467 

   468     if (m_children & Connections) {

   469         m_connections->write(writer, QLatin1String("connections"));

   470     }

   471 

   472     if (m_children & Designerdata) {

   473         m_designerdata->write(writer, QLatin1String("designerdata"));

   474     }

   475 

   476     if (m_children & Slots) {

   477         m_slots->write(writer, QLatin1String("slots"));

   478     }

   479 

   480     if (m_children & ButtonGroups) {

   481         m_buttonGroups->write(writer, QLatin1String("buttongroups"));

   482     }

   483 

   484     if (!m_text.isEmpty())

   485         writer.writeCharacters(m_text);

   486 

   487     writer.writeEndElement();

   488 }

   489 

   490 void DomUI::setElementAuthor(const QString& a)

   491 {

   492     m_children |= Author;

   493     m_author = a;

   494 }

   495 

   496 void DomUI::setElementComment(const QString& a)

   497 {

   498     m_children |= Comment;

   499     m_comment = a;

   500 }

   501 

   502 void DomUI::setElementExportMacro(const QString& a)

   503 {

   504     m_children |= ExportMacro;

   505     m_exportMacro = a;

   506 }

   507 

   508 void DomUI::setElementClass(const QString& a)

   509 {

   510     m_children |= Class;

   511     m_class = a;

   512 }

   513 

   514 DomWidget* DomUI::takeElementWidget() 

   515 {

   516     DomWidget* a = m_widget;

   517     m_widget = 0;

   518     m_children ^= Widget;

   519     return a;

   520 }

   521 

   522 void DomUI::setElementWidget(DomWidget* a)

   523 {

   524     delete m_widget;

   525     m_children |= Widget;

   526     m_widget = a;

   527 }

   528 

   529 DomLayoutDefault* DomUI::takeElementLayoutDefault() 

   530 {

   531     DomLayoutDefault* a = m_layoutDefault;

   532     m_layoutDefault = 0;

   533     m_children ^= LayoutDefault;

   534     return a;

   535 }

   536 

   537 void DomUI::setElementLayoutDefault(DomLayoutDefault* a)

   538 {

   539     delete m_layoutDefault;

   540     m_children |= LayoutDefault;

   541     m_layoutDefault = a;

   542 }

   543 

   544 DomLayoutFunction* DomUI::takeElementLayoutFunction() 

   545 {

   546     DomLayoutFunction* a = m_layoutFunction;

   547     m_layoutFunction = 0;

   548     m_children ^= LayoutFunction;

   549     return a;

   550 }

   551 

   552 void DomUI::setElementLayoutFunction(DomLayoutFunction* a)

   553 {

   554     delete m_layoutFunction;

   555     m_children |= LayoutFunction;

   556     m_layoutFunction = a;

   557 }

   558 

   559 void DomUI::setElementPixmapFunction(const QString& a)

   560 {

   561     m_children |= PixmapFunction;

   562     m_pixmapFunction = a;

   563 }

   564 

   565 DomCustomWidgets* DomUI::takeElementCustomWidgets() 

   566 {

   567     DomCustomWidgets* a = m_customWidgets;

   568     m_customWidgets = 0;

   569     m_children ^= CustomWidgets;

   570     return a;

   571 }

   572 

   573 void DomUI::setElementCustomWidgets(DomCustomWidgets* a)

   574 {

   575     delete m_customWidgets;

   576     m_children |= CustomWidgets;

   577     m_customWidgets = a;

   578 }

   579 

   580 DomTabStops* DomUI::takeElementTabStops() 

   581 {

   582     DomTabStops* a = m_tabStops;

   583     m_tabStops = 0;

   584     m_children ^= TabStops;

   585     return a;

   586 }

   587 

   588 void DomUI::setElementTabStops(DomTabStops* a)

   589 {

   590     delete m_tabStops;

   591     m_children |= TabStops;

   592     m_tabStops = a;

   593 }

   594 

   595 DomImages* DomUI::takeElementImages() 

   596 {

   597     DomImages* a = m_images;

   598     m_images = 0;

   599     m_children ^= Images;

   600     return a;

   601 }

   602 

   603 void DomUI::setElementImages(DomImages* a)

   604 {

   605     delete m_images;

   606     m_children |= Images;

   607     m_images = a;

   608 }

   609 

   610 DomIncludes* DomUI::takeElementIncludes() 

   611 {

   612     DomIncludes* a = m_includes;

   613     m_includes = 0;

   614     m_children ^= Includes;

   615     return a;

   616 }

   617 

   618 void DomUI::setElementIncludes(DomIncludes* a)

   619 {

   620     delete m_includes;

   621     m_children |= Includes;

   622     m_includes = a;

   623 }

   624 

   625 DomResources* DomUI::takeElementResources() 

   626 {

   627     DomResources* a = m_resources;

   628     m_resources = 0;

   629     m_children ^= Resources;

   630     return a;

   631 }

   632 

   633 void DomUI::setElementResources(DomResources* a)

   634 {

   635     delete m_resources;

   636     m_children |= Resources;

   637     m_resources = a;

   638 }

   639 

   640 DomConnections* DomUI::takeElementConnections() 

   641 {

   642     DomConnections* a = m_connections;

   643     m_connections = 0;

   644     m_children ^= Connections;

   645     return a;

   646 }

   647 

   648 void DomUI::setElementConnections(DomConnections* a)

   649 {

   650     delete m_connections;

   651     m_children |= Connections;

   652     m_connections = a;

   653 }

   654 

   655 DomDesignerData* DomUI::takeElementDesignerdata() 

   656 {

   657     DomDesignerData* a = m_designerdata;

   658     m_designerdata = 0;

   659     m_children ^= Designerdata;

   660     return a;

   661 }

   662 

   663 void DomUI::setElementDesignerdata(DomDesignerData* a)

   664 {

   665     delete m_designerdata;

   666     m_children |= Designerdata;

   667     m_designerdata = a;

   668 }

   669 

   670 DomSlots* DomUI::takeElementSlots() 

   671 {

   672     DomSlots* a = m_slots;

   673     m_slots = 0;

   674     m_children ^= Slots;

   675     return a;

   676 }

   677 

   678 void DomUI::setElementSlots(DomSlots* a)

   679 {

   680     delete m_slots;

   681     m_children |= Slots;

   682     m_slots = a;

   683 }

   684 

   685 DomButtonGroups* DomUI::takeElementButtonGroups() 

   686 {

   687     DomButtonGroups* a = m_buttonGroups;

   688     m_buttonGroups = 0;

   689     m_children ^= ButtonGroups;

   690     return a;

   691 }

   692 

   693 void DomUI::setElementButtonGroups(DomButtonGroups* a)

   694 {

   695     delete m_buttonGroups;

   696     m_children |= ButtonGroups;

   697     m_buttonGroups = a;

   698 }

   699 

   700 void DomUI::clearElementAuthor()

   701 {

   702     m_children &= ~Author;

   703 }

   704 

   705 void DomUI::clearElementComment()

   706 {

   707     m_children &= ~Comment;

   708 }

   709 

   710 void DomUI::clearElementExportMacro()

   711 {

   712     m_children &= ~ExportMacro;

   713 }

   714 

   715 void DomUI::clearElementClass()

   716 {

   717     m_children &= ~Class;

   718 }

   719 

   720 void DomUI::clearElementWidget()

   721 {

   722     delete m_widget;

   723     m_widget = 0;

   724     m_children &= ~Widget;

   725 }

   726 

   727 void DomUI::clearElementLayoutDefault()

   728 {

   729     delete m_layoutDefault;

   730     m_layoutDefault = 0;

   731     m_children &= ~LayoutDefault;

   732 }

   733 

   734 void DomUI::clearElementLayoutFunction()

   735 {

   736     delete m_layoutFunction;

   737     m_layoutFunction = 0;

   738     m_children &= ~LayoutFunction;

   739 }

   740 

   741 void DomUI::clearElementPixmapFunction()

   742 {

   743     m_children &= ~PixmapFunction;

   744 }

   745 

   746 void DomUI::clearElementCustomWidgets()

   747 {

   748     delete m_customWidgets;

   749     m_customWidgets = 0;

   750     m_children &= ~CustomWidgets;

   751 }

   752 

   753 void DomUI::clearElementTabStops()

   754 {

   755     delete m_tabStops;

   756     m_tabStops = 0;

   757     m_children &= ~TabStops;

   758 }

   759 

   760 void DomUI::clearElementImages()

   761 {

   762     delete m_images;

   763     m_images = 0;

   764     m_children &= ~Images;

   765 }

   766 

   767 void DomUI::clearElementIncludes()

   768 {

   769     delete m_includes;

   770     m_includes = 0;

   771     m_children &= ~Includes;

   772 }

   773 

   774 void DomUI::clearElementResources()

   775 {

   776     delete m_resources;

   777     m_resources = 0;

   778     m_children &= ~Resources;

   779 }

   780 

   781 void DomUI::clearElementConnections()

   782 {

   783     delete m_connections;

   784     m_connections = 0;

   785     m_children &= ~Connections;

   786 }

   787 

   788 void DomUI::clearElementDesignerdata()

   789 {

   790     delete m_designerdata;

   791     m_designerdata = 0;

   792     m_children &= ~Designerdata;

   793 }

   794 

   795 void DomUI::clearElementSlots()

   796 {

   797     delete m_slots;

   798     m_slots = 0;

   799     m_children &= ~Slots;

   800 }

   801 

   802 void DomUI::clearElementButtonGroups()

   803 {

   804     delete m_buttonGroups;

   805     m_buttonGroups = 0;

   806     m_children &= ~ButtonGroups;

   807 }

   808 

   809 void DomIncludes::clear(bool clear_all)

   810 {

   811     qDeleteAll(m_include);

   812     m_include.clear();

   813 

   814     if (clear_all) {

   815     m_text.clear();

   816     }

   817 

   818     m_children = 0;

   819 }

   820 

   821 DomIncludes::DomIncludes()

   822 {

   823     m_children = 0;

   824 }

   825 

   826 DomIncludes::~DomIncludes()

   827 {

   828     qDeleteAll(m_include);

   829     m_include.clear();

   830 }

   831 

   832 void DomIncludes::read(QXmlStreamReader &reader)

   833 {

   834 

   835     for (bool finished = false; !finished && !reader.hasError();) {

   836         switch (reader.readNext()) {

   837         case QXmlStreamReader::StartElement : {

   838             const QString tag = reader.name().toString().toLower();

   839             if (tag == QLatin1String("include")) {

   840                 DomInclude *v = new DomInclude();

   841                 v->read(reader);

   842                 m_include.append(v);

   843                 continue;

   844             }

   845             reader.raiseError(QLatin1String("Unexpected element ") + tag);

   846         }

   847             break;

   848         case QXmlStreamReader::EndElement :

   849             finished = true;

   850             break;

   851         case QXmlStreamReader::Characters :

   852             if (!reader.isWhitespace())

   853                 m_text.append(reader.text().toString());

   854             break;

   855         default :

   856             break;

   857         }

   858     }

   859 }

   860 

   861 #ifdef QUILOADER_QDOM_READ

   862 void DomIncludes::read(const QDomElement &node)

   863 {

   864     for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) {

   865         if (!n.isElement())

   866             continue;

   867         QDomElement e = n.toElement();

   868         QString tag = e.tagName().toLower();

   869             if (tag == QLatin1String("include")) {

   870                 DomInclude *v = new DomInclude();

   871                 v->read(e);

   872                 m_include.append(v);

   873                 continue;

   874             }

   875     }

   876     m_text.clear();

   877     for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) {

   878         if (child.isText())

   879             m_text.append(child.nodeValue());

   880      }

   881 }

   882 #endif

   883 

   884 void DomIncludes::write(QXmlStreamWriter &writer, const QString &tagName) const

   885 {

   886     writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("includes") : tagName.toLower());

   887 

   888     for (int i = 0; i < m_include.size(); ++i) {

   889         DomInclude* v = m_include[i];

   890         v->write(writer, QLatin1String("include"));

   891     }

   892     if (!m_text.isEmpty())

   893         writer.writeCharacters(m_text);

   894 

   895     writer.writeEndElement();

   896 }

   897 

   898 void DomIncludes::setElementInclude(const QList<DomInclude*>& a)

   899 {

   900     m_children |= Include;

   901     m_include = a;

   902 }

   903 

   904 void DomInclude::clear(bool clear_all)

   905 {

   906 

   907     if (clear_all) {

   908     m_text = QLatin1String("");

   909     m_has_attr_location = false;

   910     m_has_attr_impldecl = false;

   911     }

   912 

   913     m_children = 0;

   914 }

   915 

   916 DomInclude::DomInclude()

   917 {

   918     m_children = 0;

   919     m_has_attr_location = false;

   920     m_has_attr_impldecl = false;

   921     m_text = QLatin1String("");

   922 }

   923 

   924 DomInclude::~DomInclude()

   925 {

   926 }

   927 

   928 void DomInclude::read(QXmlStreamReader &reader)

   929 {

   930 

   931     foreach (const QXmlStreamAttribute &attribute, reader.attributes()) {

   932         QStringRef name = attribute.name();

   933         if (name == QLatin1String("location")) {

   934             setAttributeLocation(attribute.value().toString());

   935             continue;

   936         }

   937         if (name == QLatin1String("impldecl")) {

   938             setAttributeImpldecl(attribute.value().toString());

   939             continue;

   940         }

   941         reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString());

   942     }

   943 

   944     for (bool finished = false; !finished && !reader.hasError();) {

   945         switch (reader.readNext()) {

   946         case QXmlStreamReader::StartElement : {

   947             const QString tag = reader.name().toString().toLower();

   948             reader.raiseError(QLatin1String("Unexpected element ") + tag);

   949         }

   950             break;

   951         case QXmlStreamReader::EndElement :

   952             finished = true;

   953             break;

   954         case QXmlStreamReader::Characters :

   955             if (!reader.isWhitespace())

   956                 m_text.append(reader.text().toString());

   957             break;

   958         default :

   959             break;

   960         }

   961     }

   962 }

   963 

   964 #ifdef QUILOADER_QDOM_READ

   965 void DomInclude::read(const QDomElement &node)

   966 {

   967     if (node.hasAttribute(QLatin1String("location")))

   968         setAttributeLocation(node.attribute(QLatin1String("location")));

   969     if (node.hasAttribute(QLatin1String("impldecl")))

   970         setAttributeImpldecl(node.attribute(QLatin1String("impldecl")));

   971 

   972     for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) {

   973         if (!n.isElement())

   974             continue;

   975         QDomElement e = n.toElement();

   976         QString tag = e.tagName().toLower();

   977     }

   978     m_text = QLatin1String("");

   979     for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) {

   980         if (child.isText())

   981             m_text.append(child.nodeValue());

   982      }

   983 }

   984 #endif

   985 

   986 void DomInclude::write(QXmlStreamWriter &writer, const QString &tagName) const

   987 {

   988     writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("include") : tagName.toLower());

   989 

   990     if (hasAttributeLocation())

   991         writer.writeAttribute(QLatin1String("location"), attributeLocation());

   992 

   993     if (hasAttributeImpldecl())

   994         writer.writeAttribute(QLatin1String("impldecl"), attributeImpldecl());

   995 

   996     if (!m_text.isEmpty())

   997         writer.writeCharacters(m_text);

   998 

   999     writer.writeEndElement();

  1000 }

  1001 

  1002 void DomResources::clear(bool clear_all)

  1003 {

  1004     qDeleteAll(m_include);

  1005     m_include.clear();

  1006 

  1007     if (clear_all) {

  1008     m_text.clear();

  1009     m_has_attr_name = false;

  1010     }

  1011 

  1012     m_children = 0;

  1013 }

  1014 

  1015 DomResources::DomResources()

  1016 {

  1017     m_children = 0;

  1018     m_has_attr_name = false;

  1019 }

  1020 

  1021 DomResources::~DomResources()

  1022 {

  1023     qDeleteAll(m_include);

  1024     m_include.clear();

  1025 }

  1026 

  1027 void DomResources::read(QXmlStreamReader &reader)

  1028 {

  1029 

  1030     foreach (const QXmlStreamAttribute &attribute, reader.attributes()) {

  1031         QStringRef name = attribute.name();

  1032         if (name == QLatin1String("name")) {

  1033             setAttributeName(attribute.value().toString());

  1034             continue;

  1035         }

  1036         reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString());

  1037     }

  1038 

  1039     for (bool finished = false; !finished && !reader.hasError();) {

  1040         switch (reader.readNext()) {

  1041         case QXmlStreamReader::StartElement : {

  1042             const QString tag = reader.name().toString().toLower();

  1043             if (tag == QLatin1String("include")) {

  1044                 DomResource *v = new DomResource();

  1045                 v->read(reader);

  1046                 m_include.append(v);

  1047                 continue;

  1048             }

  1049             reader.raiseError(QLatin1String("Unexpected element ") + tag);

  1050         }

  1051             break;

  1052         case QXmlStreamReader::EndElement :

  1053             finished = true;

  1054             break;

  1055         case QXmlStreamReader::Characters :

  1056             if (!reader.isWhitespace())

  1057                 m_text.append(reader.text().toString());

  1058             break;

  1059         default :

  1060             break;

  1061         }

  1062     }

  1063 }

  1064 

  1065 #ifdef QUILOADER_QDOM_READ

  1066 void DomResources::read(const QDomElement &node)

  1067 {

  1068     if (node.hasAttribute(QLatin1String("name")))

  1069         setAttributeName(node.attribute(QLatin1String("name")));

  1070 

  1071     for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) {

  1072         if (!n.isElement())

  1073             continue;

  1074         QDomElement e = n.toElement();

  1075         QString tag = e.tagName().toLower();

  1076             if (tag == QLatin1String("include")) {

  1077                 DomResource *v = new DomResource();

  1078                 v->read(e);

  1079                 m_include.append(v);

  1080                 continue;

  1081             }

  1082     }

  1083     m_text.clear();

  1084     for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) {

  1085         if (child.isText())

  1086             m_text.append(child.nodeValue());

  1087      }

  1088 }

  1089 #endif

  1090 

  1091 void DomResources::write(QXmlStreamWriter &writer, const QString &tagName) const

  1092 {

  1093     writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("resources") : tagName.toLower());

  1094 

  1095     if (hasAttributeName())

  1096         writer.writeAttribute(QLatin1String("name"), attributeName());

  1097 

  1098     for (int i = 0; i < m_include.size(); ++i) {

  1099         DomResource* v = m_include[i];

  1100         v->write(writer, QLatin1String("include"));

  1101     }

  1102     if (!m_text.isEmpty())

  1103         writer.writeCharacters(m_text);

  1104 

  1105     writer.writeEndElement();

  1106 }

  1107 

  1108 void DomResources::setElementInclude(const QList<DomResource*>& a)

  1109 {

  1110     m_children |= Include;

  1111     m_include = a;

  1112 }

  1113 

  1114 void DomResource::clear(bool clear_all)

  1115 {

  1116 

  1117     if (clear_all) {

  1118     m_text.clear();

  1119     m_has_attr_location = false;

  1120     }

  1121 

  1122     m_children = 0;

  1123 }

  1124 

  1125 DomResource::DomResource()

  1126 {

  1127     m_children = 0;

  1128     m_has_attr_location = false;

  1129 }

  1130 

  1131 DomResource::~DomResource()

  1132 {

  1133 }

  1134