AdvancedSearchWidget.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "AdvancedSearchWidget.h"

using UIs::Searching::  AdvancedSearchWidget;

AdvancedSearchWidget::AdvancedSearchWidget (const QString &schemaFileName,
                                            QWidget *parent)
 :  QGroupBox(parent), outputDoc(), elementToString()
{
    QFile           file (schemaFileName);
    QDomDocument    doc;
    QString         errorStr;
    int             errorLine;
    int             errorColumn;

    if (!doc.setContent (&file, true, &errorStr, &errorLine, &errorColumn)) {
        QMessageBox::warning (0, QObject::tr ("XML Schema Parser"),
                              QObject::tr ("Parse error at line %1, ""column %2:\n%3").arg (errorLine).arg (errorColumn).arg (errorStr));
    } else {
        CreateWidget (doc);
    }
}

AdvancedSearchWidget::~AdvancedSearchWidget ()
{

}

void AdvancedSearchWidget::CreateWidget (const QDomDocument &schema)
{
    QVBoxLayout *vLayout;

    QDomElement root = schema.documentElement ();
    if (root.tagName () != "schema")
        return ;

    QDomNode    elementNode = root.firstChild ();

    // loop through all top-level nodes
    while (!elementNode.isNull ()) {
        if (elementNode.toElement ().tagName () == "element"
        && elementNode.attributes ().contains ("name")) {
            QString groupBoxTitle = elementNode.attributes ().namedItem ("name").nodeValue ();
            setTitle (groupBoxTitle);

            // add root element
            outputDoc.appendChild (outputDoc.createElement (groupBoxTitle));

            vLayout = new QVBoxLayout (this);

            QDomNode    node = elementNode.firstChild ();
            if (node.toElement ().tagName () == "complexType") {
                node = node.firstChild ();
                if (node.toElement ().tagName () == "element"
                && node.attributes ().contains ("type")
                && node.attributes ().contains ("name")) {
                    QString     elementName = node.toElement ().attributes ()
                        .namedItem ("name").nodeValue ();
                    QString     elementType = node.toElement ().attributes ()
                        .namedItem ("type").nodeValue ();

                    QGridLayout *typeWidget = CreateWidgetForType (schema,
                                                                   elementType);

                    if (typeWidget == NULL)
                        return ;
                    vLayout->addLayout (typeWidget);

                    QDomElement newType = outputDoc.createElement(elementName);
                    outputDoc.documentElement ().appendChild (newType);
                }
            }
        }

        elementNode = elementNode.nextSibling ();
    }
}

QGridLayout *AdvancedSearchWidget::CreateWidgetForType (const QDomDocument &schema,
                                                        const QString &typeName)
{
    QGridLayout *gridLayout = new QGridLayout ();


    QDomElement root = schema.documentElement ();
    if (root.tagName () != "schema")
        return NULL;

    QDomNodeList    complexTypes = root.elementsByTagName ("complexType");
    int             typeIdx = 0;

    for (; typeIdx < complexTypes.size (); typeIdx++) {
        if (complexTypes.at (typeIdx).attributes ().contains ("name")
        && complexTypes.at (typeIdx).attributes ().namedItem ("name").nodeValue ()
            == typeName)
            break;
    }

    int rowCount = 0;
    if (typeIdx != complexTypes.size ()) {

        QDomNode    requiredType = complexTypes.at (typeIdx);

        if (requiredType.firstChild ().toElement ().tagName () == "all") {
            QDomNodeList    attributes = requiredType.firstChild ().childNodes ();

            for (int atIdx = 0; atIdx < attributes.size (); atIdx++) {
                QDomNode    attribute = attributes.at (atIdx);
                if (attribute.toElement ().tagName () != "attribute")
                    continue;
                if (!attribute.attributes ().contains ("name"))
                    continue;

                if (attribute.attributes ().namedItem ("hidden").nodeValue ()
                        == "true")
                    continue;

                QString attributeName =
                    attribute.attributes ().namedItem ("name").nodeValue ();
                QLabel      *attributeLabel = new QLabel (attributeName);
                QWidget     *editWidget;

                gridLayout->addWidget (attributeLabel, rowCount, 0);

                if (attribute.childNodes ().isEmpty ()) {
                    if (attribute.attributes ().contains ("type")) {
                        QString attributeType =
                            attribute.attributes ().namedItem ("type").nodeValue ();
                    }
                    editWidget = new QLineEdit ();
                    QObject::connect (editWidget, SIGNAL ( editingFinished ()),
                        this, SLOT (elementEditingFinished ()) );
                } else {

                    // unknown complex type
                    if (attribute.childNodes ().isEmpty ())
                        return NULL;

                    QDomNode    simpleType = attribute.childNodes ().item (0);

                    if (simpleType.toElement ().tagName () != "simpleType")
                        return NULL;

                    if (simpleType.attributes ().namedItem("base").nodeValue ()
                        == "string") {
                        QComboBox   *en = new QComboBox ();
                        editWidget = en;

                        for (unsigned int idx = 0; idx < simpleType.childNodes ().length ();
                             idx++) {
                            QDomNode    enumeration = simpleType.childNodes ()
                                .item (idx);

                            if (enumeration.toElement ().tagName ()
                                    != "enumeration")
                                continue;
                            if (enumeration.attributes ().contains ("value"))
                                en->addItem (enumeration.attributes ().namedItem ("value").nodeValue ());
                        }
                    } else {

                        // unknown base type
                        return NULL;
                    }
                }

                elementToString.insert(editWidget, attributeName);
                editWidget->setFixedWidth (150);
                gridLayout->addWidget (editWidget, rowCount++, 1);
            }

            return gridLayout;
        }
    }

    return NULL;
}

QDomDocument const *AdvancedSearchWidget::XMLRequest () const
{
    return &outputDoc;
}


void AdvancedSearchWidget::elementEditingFinished ()
{
    QString text("");
    QString attributeName("");

    QWidget * senderWidget = qobject_cast <QWidget *> (sender ());
    if (senderWidget == 0) return;

    attributeName = elementToString.value (senderWidget);

    QLineEdit *lineedit = qobject_cast <QLineEdit *> (senderWidget);
    if (lineedit != 0)
    {
        text = lineedit->text ();
    }
    QComboBox *combobox = qobject_cast <QComboBox *> (senderWidget);
    if (combobox != 0)
    {
        text = combobox->currentText ();
    }

    if (attributeName != "")
    {
        QDomElement root = outputDoc.documentElement ();
        QDomElement mainElem = root.firstChild ().toElement ();

        if (text != "")
            mainElem.setAttribute (attributeName, text);
        else
            mainElem.removeAttribute (attributeName);
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.