File indexing completed on 2022-11-29 19:02:25

0001 /* This file is part of the KDE project
0002    Copyright (C) 2006-2016 Jarosław Staniek <staniek@kde.org>
0003 
0004    This program is free software; you can redistribute it and/or
0005    modify it under the terms of the GNU Library General Public
0006    License as published by the Free Software Foundation; either
0007    version 2 of the License, or (at your option) any later version.
0008 
0009    This program is distributed in the hope that it will be useful,
0010    but WITHOUT ANY WARRANTY; without even the implied warranty of
0011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0012    Library General Public License for more details.
0013 
0014    You should have received a copy of the GNU Library General Public License
0015    along with this program; see the file COPYING.  If not, write to
0016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
0017  * Boston, MA 02110-1301, USA.
0018 */
0019 
0020 #include "KDbLookupFieldSchema.h"
0021 #include "KDb.h"
0022 #include "kdb_debug.h"
0023 
0024 #include <QDomElement>
0025 #include <QVariant>
0026 #include <QStringList>
0027 #include <QHash>
0028 
0029 #include <vector>
0030 
0031 //! @internal
0032 class Q_DECL_HIDDEN KDbLookupFieldSchemaRecordSource::Private
0033 {
0034 public:
0035     Private()
0036             : type(KDbLookupFieldSchemaRecordSource::Type::None) {
0037     }
0038     Private(const Private &other) {
0039         copy(other);
0040     }
0041 #define KDbLookupFieldSchemaRecordSourcePrivateArgs(o) std::tie(o.type, o.name, o.values)
0042     void copy(const Private &other) {
0043         KDbLookupFieldSchemaRecordSourcePrivateArgs((*this))
0044                 = KDbLookupFieldSchemaRecordSourcePrivateArgs(other);
0045     }
0046     bool operator==(const KDbLookupFieldSchemaRecordSource::Private &other) const {
0047         return KDbLookupFieldSchemaRecordSourcePrivateArgs((*this))
0048                 == KDbLookupFieldSchemaRecordSourcePrivateArgs(other);
0049     }
0050 
0051     KDbLookupFieldSchemaRecordSource::Type type;
0052     QString name;
0053     QStringList values;
0054 };
0055 
0056 //! @internal
0057 class Q_DECL_HIDDEN KDbLookupFieldSchema::Private
0058 {
0059 public:
0060     Private()
0061             : boundColumn(-1)
0062             , maxVisibleRecords(KDB_LOOKUP_FIELD_DEFAULT_MAX_VISIBLE_RECORDS)
0063             , displayWidget(KDB_LOOKUP_FIELD_DEFAULT_DISPLAY_WIDGET)
0064             , columnHeadersVisible(KDB_LOOKUP_FIELD_DEFAULT_HEADERS_VISIBLE)
0065             , limitToList(KDB_LOOKUP_FIELD_DEFAULT_LIMIT_TO_LIST) {
0066     }
0067     Private(const Private &other) {
0068         copy(other);
0069     }
0070 #define KDbLookupFieldSchemaPrivateArgs(o) std::tie(o.recordSource, o.boundColumn, o.visibleColumns, \
0071                     o.columnWidths, o.maxVisibleRecords, o.displayWidget, \
0072                     o.columnHeadersVisible, o.limitToList)
0073     void copy(const Private &other) {
0074         KDbLookupFieldSchemaPrivateArgs((*this)) = KDbLookupFieldSchemaPrivateArgs(other);
0075     }
0076     bool operator==(const KDbLookupFieldSchema::Private &other) const {
0077         return KDbLookupFieldSchemaPrivateArgs((*this)) == KDbLookupFieldSchemaPrivateArgs(other);
0078     }
0079 
0080     KDbLookupFieldSchemaRecordSource recordSource;
0081     int boundColumn;
0082     QList<int> visibleColumns;
0083     QList<int> columnWidths;
0084     int maxVisibleRecords;
0085     DisplayWidget displayWidget;
0086     bool columnHeadersVisible;
0087     bool limitToList;
0088 };
0089 
0090 //! Cache
0091 class LookupFieldSchemaStatic
0092 {
0093 public:
0094     LookupFieldSchemaStatic()
0095      : typeNames({
0096             QString(), // no type
0097             QLatin1String("table"),
0098             QLatin1String("query"),
0099             QLatin1String("sql"),
0100             QLatin1String("valuelist"),
0101             QLatin1String("fieldlist")})
0102     {
0103         typesForNames.insert(QLatin1String("table"), KDbLookupFieldSchemaRecordSource::Type::Table);
0104         typesForNames.insert(QLatin1String("query"), KDbLookupFieldSchemaRecordSource::Type::Query);
0105         typesForNames.insert(QLatin1String("sql"), KDbLookupFieldSchemaRecordSource::Type::SQLStatement);
0106         typesForNames.insert(QLatin1String("valuelist"), KDbLookupFieldSchemaRecordSource::Type::ValueList);
0107         typesForNames.insert(QLatin1String("fieldlist"), KDbLookupFieldSchemaRecordSource::Type::KDbFieldList);
0108     }
0109     const std::vector<QString> typeNames;
0110     QHash<QString, KDbLookupFieldSchemaRecordSource::Type> typesForNames;
0111 private:
0112     Q_DISABLE_COPY(LookupFieldSchemaStatic)
0113 };
0114 
0115 Q_GLOBAL_STATIC(LookupFieldSchemaStatic, KDb_lookupFieldSchemaStatic)
0116 
0117 //----------------------------
0118 
0119 KDbLookupFieldSchemaRecordSource::KDbLookupFieldSchemaRecordSource()
0120         : d(new Private)
0121 {
0122 }
0123 
0124 KDbLookupFieldSchemaRecordSource::KDbLookupFieldSchemaRecordSource(const KDbLookupFieldSchemaRecordSource& other)
0125         : d(new Private(*other.d))
0126 {
0127 }
0128 
0129 KDbLookupFieldSchemaRecordSource::~KDbLookupFieldSchemaRecordSource()
0130 {
0131     delete d;
0132 }
0133 
0134 KDbLookupFieldSchemaRecordSource::Type KDbLookupFieldSchemaRecordSource::type() const
0135 {
0136     return d->type;
0137 }
0138 
0139 void KDbLookupFieldSchemaRecordSource::setType(Type type)
0140 {
0141     d->type = type;
0142 }
0143 
0144 QString KDbLookupFieldSchemaRecordSource::name() const
0145 {
0146     return d->name;
0147 }
0148 
0149 void KDbLookupFieldSchemaRecordSource::setName(const QString& name)
0150 {
0151     d->name = name;
0152     d->values.clear();
0153 }
0154 
0155 QString KDbLookupFieldSchemaRecordSource::typeName() const
0156 {
0157     Q_ASSERT(size_t(d->type) < KDb_lookupFieldSchemaStatic->typeNames.size());
0158     return KDb_lookupFieldSchemaStatic->typeNames[static_cast<int>(d->type)];
0159 }
0160 
0161 void KDbLookupFieldSchemaRecordSource::setTypeByName(const QString& typeName)
0162 {
0163     setType(KDb_lookupFieldSchemaStatic->typesForNames.value(typeName, Type::None));
0164 }
0165 
0166 QStringList KDbLookupFieldSchemaRecordSource::values() const
0167 {
0168     return d->values;
0169 }
0170 
0171 void KDbLookupFieldSchemaRecordSource::setValues(const QStringList& values)
0172 {
0173     d->name.clear();
0174     d->values = values;
0175 }
0176 
0177 KDbLookupFieldSchemaRecordSource& KDbLookupFieldSchemaRecordSource::operator=(const KDbLookupFieldSchemaRecordSource & other)
0178 {
0179     if (this != &other) {
0180         *d = *other.d;
0181     }
0182     return *this;
0183 }
0184 
0185 bool KDbLookupFieldSchemaRecordSource::operator==(const KDbLookupFieldSchemaRecordSource &other) const
0186 {
0187     return *d == *other.d;
0188 }
0189 
0190 QDebug operator<<(QDebug dbg, const KDbLookupFieldSchemaRecordSource& source)
0191 {
0192     dbg.nospace() << "LookupFieldSchemaRecordSource TYPE:";
0193     dbg.space() << source.typeName();
0194     dbg.space() << "NAME:";
0195     dbg.space() << source.name();
0196     dbg.space() << "VALUES:";
0197     dbg.space() << source.values().join(QLatin1String("|")) << '\n';
0198     return dbg.nospace();
0199 }
0200 
0201 //----------------------------
0202 
0203 KDbLookupFieldSchema::KDbLookupFieldSchema()
0204         : d(new Private)
0205 {
0206 }
0207 
0208 KDbLookupFieldSchema::KDbLookupFieldSchema(const KDbLookupFieldSchema &schema)
0209 : d(new Private(*schema.d))
0210 {
0211 }
0212 
0213 KDbLookupFieldSchema::~KDbLookupFieldSchema()
0214 {
0215     delete d;
0216 }
0217 
0218 static bool setBoundColumn(KDbLookupFieldSchema *lookup, const QVariant &val)
0219 {
0220     if (val.isNull()) {
0221         lookup->setBoundColumn(-1);
0222     }
0223     else {
0224         bool ok;
0225         const int ival = val.toInt(&ok);
0226         if (!ok)
0227             return false;
0228         lookup->setBoundColumn(ival);
0229     }
0230     return true;
0231 }
0232 
0233 static bool setVisibleColumns(KDbLookupFieldSchema *lookup, const QVariant &val)
0234 {
0235     QList<QVariant> variantList;
0236     if (val.canConvert(QVariant::Int)) {
0237     //! @todo Remove this case: it's for backward compatibility with Kexi's 1.1.2 table designer GUI
0238     //!       supporting only single lookup column.
0239         variantList.append(val);
0240     }
0241     else {
0242         variantList = val.toList();
0243     }
0244     QList<int> visibleColumns;
0245     foreach(const QVariant& variant, variantList) {
0246         bool ok;
0247         const int ival = variant.toInt(&ok);
0248         if (!ok) {
0249             return false;
0250         }
0251         visibleColumns.append(ival);
0252     }
0253     lookup->setVisibleColumns(visibleColumns);
0254     return true;
0255 }
0256 
0257 static bool setColumnWidths(KDbLookupFieldSchema *lookup, const QVariant &val)
0258 {
0259     QList<int> widths;
0260     foreach(const QVariant& variant, val.toList()) {
0261         bool ok;
0262         const int ival = variant.toInt(&ok);
0263         if (!ok)
0264             return false;
0265         widths.append(ival);
0266     }
0267     lookup->setColumnWidths(widths);
0268     return true;
0269 }
0270 
0271 static bool setDisplayWidget(KDbLookupFieldSchema *lookup, const QVariant &val)
0272 {
0273     bool ok;
0274     const uint ival = val.toUInt(&ok);
0275     if (!ok || ival > static_cast<uint>(KDbLookupFieldSchema::DisplayWidget::ListBox)) {
0276         return false;
0277     }
0278     lookup->setDisplayWidget(static_cast<KDbLookupFieldSchema::DisplayWidget>(ival));
0279     return true;
0280 }
0281 
0282 KDbLookupFieldSchemaRecordSource KDbLookupFieldSchema::recordSource() const
0283 {
0284     return d->recordSource;
0285 }
0286 
0287 void KDbLookupFieldSchema::setRecordSource(const KDbLookupFieldSchemaRecordSource& recordSource)
0288 {
0289     d->recordSource = recordSource;
0290 }
0291 
0292 void KDbLookupFieldSchema::setMaxVisibleRecords(int count)
0293 {
0294     if (count == 0)
0295         d->maxVisibleRecords = KDB_LOOKUP_FIELD_DEFAULT_MAX_VISIBLE_RECORDS;
0296     else if (count > KDB_LOOKUP_FIELD_LIMIT_MAX_VISIBLE_RECORDS)
0297         d->maxVisibleRecords = KDB_LOOKUP_FIELD_LIMIT_MAX_VISIBLE_RECORDS;
0298     else
0299         d->maxVisibleRecords = count;
0300 }
0301 
0302 QDebug operator<<(QDebug dbg, const KDbLookupFieldSchema& lookup)
0303 {
0304     dbg.nospace() << "LookupFieldSchema(";
0305     dbg.space() << lookup.recordSource();
0306     dbg.space() << "boundColumn:";
0307     dbg.space() << lookup.boundColumn();
0308     dbg.space() << "visibleColumns:";
0309 
0310     bool first = true;
0311     foreach(int visibleColumn, lookup.visibleColumns()) {
0312         if (first) {
0313             first = false;
0314             dbg.nospace();
0315         }
0316         else
0317             dbg.nospace() << ';';
0318         dbg.nospace() << visibleColumn;
0319     }
0320     dbg.space() << "maxVisibleRecords:";
0321     dbg.space() << lookup.maxVisibleRecords();
0322     dbg.space() << "displayWidget:";
0323     dbg.space() << (lookup.displayWidget() == KDbLookupFieldSchema::DisplayWidget::ComboBox
0324                         ? "ComboBox"
0325                         : "ListBox");
0326     dbg.space() << "columnHeadersVisible:";
0327     dbg.space() << lookup.columnHeadersVisible();
0328     dbg.space() << "limitToList:";
0329     dbg.space() << lookup.limitToList();
0330     dbg.space() << "columnWidths:";
0331 
0332     first = true;
0333     const QList<int> columnWidths(lookup.columnWidths());
0334     for (int width : columnWidths) {
0335         if (first)
0336             first = false;
0337         else
0338             dbg.nospace() << ';';
0339         dbg.space() << width;
0340     }
0341     dbg.nospace() << ')';
0342     return dbg.space();
0343 }
0344 
0345 /* static */
0346 KDbLookupFieldSchema *KDbLookupFieldSchema::loadFromDom(const QDomElement& lookupEl)
0347 {
0348     KDbLookupFieldSchema *lookupFieldSchema = new KDbLookupFieldSchema();
0349     KDbLookupFieldSchemaRecordSource recordSource;
0350     for (QDomNode node = lookupEl.firstChild(); !node.isNull(); node = node.nextSibling()) {
0351         QDomElement el = node.toElement();
0352         const QByteArray name(el.tagName().toLatin1());
0353         if (name == "row-source") {
0354             /*<row-source>
0355               empty
0356               | <type>table|query|sql|valuelist|fieldlist</type> #required because there can be
0357                                                                  #table and query with the same name
0358                                                                  #"fieldlist" (basically a list of
0359                                                                  #column names of a table/query,
0360                                                                  #"Field List" as in MSA)
0361               <name>string</name> #table/query name, etc. or KDbSQL SELECT QUERY
0362               <values><value>...</value> #for "valuelist" type
0363                 <value>...</value>
0364               </values>
0365              </row-source> */
0366             for (el = el.firstChild().toElement(); !el.isNull(); el = el.nextSibling().toElement()) {
0367                 const QByteArray childName(el.tagName().toLatin1());
0368                 if (childName == "type") {
0369                     recordSource.setTypeByName(el.text());
0370                 }
0371                 else if (childName == "name") {
0372                     recordSource.setName(el.text());
0373 //! @todo handle fieldlist (retrieve from external table or so?), use KDbLookupFieldSchemaRecordSource::setValues()
0374                 }
0375             }
0376         } else if (name == "bound-column") {
0377             /* <bound-column>
0378                 <number>number</number> #in later implementation there can be more columns
0379                </bound-column> */
0380             bool ok;
0381             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
0382             if (!ok || !::setBoundColumn(lookupFieldSchema, val)) {
0383                 delete lookupFieldSchema;
0384                 return nullptr;
0385             }
0386         } else if (name == "visible-column") {
0387             /* <visible-column> #a column that has to be visible in the combo box
0388               <number>number 1</number>
0389               <number>number 2</number>
0390               [..]
0391                </visible-column> */
0392             QVariantList list;
0393             for (QDomNode childNode = el.firstChild(); !childNode.isNull();
0394                  childNode = childNode.nextSibling())
0395             {
0396                 bool ok;
0397                 const QVariant val = KDb::loadPropertyValueFromDom(childNode, &ok);
0398                 if (!ok) {
0399                     delete lookupFieldSchema;
0400                     return nullptr;
0401                 }
0402                 list.append(val);
0403             }
0404             if (!::setVisibleColumns(lookupFieldSchema, list)) {
0405                 delete lookupFieldSchema;
0406                 return nullptr;
0407             }
0408         } else if (name == "column-widths") {
0409             /* <column-widths> #column widths, -1 means 'default'
0410                 <number>int</number>
0411                 ...
0412                 <number>int</number>
0413                </column-widths> */
0414             QVariantList columnWidths;
0415             for (el = el.firstChild().toElement(); !el.isNull(); el = el.nextSibling().toElement()) {
0416                 bool ok;
0417                 QVariant val = KDb::loadPropertyValueFromDom(el, &ok);
0418                 if (!ok) {
0419                     delete lookupFieldSchema;
0420                     return nullptr;
0421                 }
0422                 columnWidths.append(val);
0423             }
0424             if (!::setColumnWidths(lookupFieldSchema, columnWidths)) {
0425                 delete lookupFieldSchema;
0426                 return nullptr;
0427             }
0428         } else if (name == "show-column-headers") {
0429             /* <show-column-headers>
0430                 <bool>true/false</bool>
0431                </show-column-headers> */
0432             bool ok;
0433             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
0434             if (!ok) {
0435                 delete lookupFieldSchema;
0436                 return nullptr;
0437             }
0438             if (val.type() == QVariant::Bool)
0439                 lookupFieldSchema->setColumnHeadersVisible(val.toBool());
0440         } else if (name == "list-rows") {
0441             /* <list-rows>
0442                 <number>1..100</number>
0443                </list-rows> */
0444             bool ok;
0445             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
0446             if (!ok) {
0447                 delete lookupFieldSchema;
0448                 return nullptr;
0449             }
0450             if (val.type() == QVariant::Int)
0451                 lookupFieldSchema->setMaxVisibleRecords(val.toInt());
0452         } else if (name == "limit-to-list") {
0453             /* <limit-to-list>
0454                 <bool>true/false</bool>
0455                </limit-to-list> */
0456             bool ok;
0457             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
0458             if (!ok) {
0459                 delete lookupFieldSchema;
0460                 return nullptr;
0461             }
0462             if (val.type() == QVariant::Bool)
0463                 lookupFieldSchema->setLimitToList(val.toBool());
0464         }
0465         else if (name == "display-widget") {
0466             const QByteArray displayWidgetName(el.text().toLatin1());
0467             if (displayWidgetName == "combobox") {
0468                 lookupFieldSchema->setDisplayWidget(KDbLookupFieldSchema::DisplayWidget::ComboBox);
0469             }
0470             else if (displayWidgetName == "listbox") {
0471                 lookupFieldSchema->setDisplayWidget(KDbLookupFieldSchema::DisplayWidget::ListBox);
0472             }
0473         }
0474     }
0475     lookupFieldSchema->setRecordSource(recordSource);
0476     return lookupFieldSchema;
0477 }
0478 
0479 void KDbLookupFieldSchema::saveToDom(QDomDocument *doc, QDomElement *parentEl)
0480 {
0481     if (!doc || !parentEl) {
0482         return;
0483     }
0484     QDomElement lookupColumnEl, recordSourceEl, recordSourceTypeEl, nameEl;
0485     if (!recordSource().name().isEmpty()) {
0486         lookupColumnEl = doc->createElement(QLatin1String("lookup-column"));
0487         parentEl->appendChild(lookupColumnEl);
0488 
0489         recordSourceEl = doc->createElement(QLatin1String("row-source"));
0490         lookupColumnEl.appendChild(recordSourceEl);
0491 
0492         recordSourceTypeEl = doc->createElement(QLatin1String("type"));
0493         recordSourceEl.appendChild(recordSourceTypeEl);
0494         recordSourceTypeEl.appendChild(doc->createTextNode(recordSource().typeName()));   //can be empty
0495 
0496         nameEl = doc->createElement(QLatin1String("name"));
0497         recordSourceEl.appendChild(nameEl);
0498         nameEl.appendChild(doc->createTextNode(recordSource().name()));
0499     }
0500 
0501     const QStringList& values(recordSource().values());
0502     if (!values.isEmpty()) {
0503         QDomElement valuesEl(doc->createElement(QLatin1String("values")));
0504         recordSourceEl.appendChild(valuesEl);
0505         for (QStringList::ConstIterator it = values.constBegin(); it != values.constEnd(); ++it) {
0506             QDomElement valueEl(doc->createElement(QLatin1String("value")));
0507             valuesEl.appendChild(valueEl);
0508             valueEl.appendChild(doc->createTextNode(*it));
0509         }
0510     }
0511 
0512     if (boundColumn() >= 0) {
0513         KDb::saveNumberElementToDom(doc, &lookupColumnEl,
0514                                           QLatin1String("bound-column"), boundColumn());
0515     }
0516 
0517     QList<int> visibleColumns(this->visibleColumns());
0518     if (!visibleColumns.isEmpty()) {
0519         QDomElement visibleColumnEl(doc->createElement(QLatin1String("visible-column")));
0520         lookupColumnEl.appendChild(visibleColumnEl);
0521         foreach(int visibleColumn, visibleColumns) {
0522             QDomElement numberEl(doc->createElement(QLatin1String("number")));
0523             visibleColumnEl.appendChild(numberEl);
0524             numberEl.appendChild(doc->createTextNode(QString::number(visibleColumn)));
0525         }
0526     }
0527 
0528     const QList<int> columnWidths(this->columnWidths());
0529     if (!columnWidths.isEmpty()) {
0530         QDomElement columnWidthsEl(doc->createElement(QLatin1String("column-widths")));
0531         lookupColumnEl.appendChild(columnWidthsEl);
0532         foreach(int columnWidth, columnWidths) {
0533             QDomElement columnWidthEl(doc->createElement(QLatin1String("number")));
0534             columnWidthsEl.appendChild(columnWidthEl);
0535             columnWidthEl.appendChild(doc->createTextNode(QString::number(columnWidth)));
0536         }
0537     }
0538 
0539     if (columnHeadersVisible() != KDB_LOOKUP_FIELD_DEFAULT_HEADERS_VISIBLE)
0540         KDb::saveBooleanElementToDom(doc, &lookupColumnEl,
0541                                            QLatin1String("show-column-headers"),
0542                                            columnHeadersVisible());
0543     if (maxVisibleRecords() != KDB_LOOKUP_FIELD_DEFAULT_MAX_VISIBLE_RECORDS)
0544         KDb::saveNumberElementToDom(doc, &lookupColumnEl,
0545                                           QLatin1String("list-rows"),
0546                                           maxVisibleRecords());
0547     if (limitToList() != KDB_LOOKUP_FIELD_DEFAULT_LIMIT_TO_LIST)
0548         KDb::saveBooleanElementToDom(doc, &lookupColumnEl,
0549                                            QLatin1String("limit-to-list"),
0550                                            limitToList());
0551 
0552     if (displayWidget() != KDB_LOOKUP_FIELD_DEFAULT_DISPLAY_WIDGET) {
0553         QDomElement displayWidgetEl(doc->createElement(QLatin1String("display-widget")));
0554         lookupColumnEl.appendChild(displayWidgetEl);
0555         displayWidgetEl.appendChild(
0556             doc->createTextNode(
0557                 QLatin1String((displayWidget() == DisplayWidget::ListBox) ? "listbox" : "combobox")));
0558     }
0559 }
0560 
0561 void KDbLookupFieldSchema::getProperties(QMap<QByteArray, QVariant> *values) const
0562 {
0563     values->clear();
0564     KDb::getProperties(this, values);
0565 }
0566 
0567 bool KDbLookupFieldSchema::setProperty(const QByteArray& propertyName, const QVariant& value)
0568 {
0569     bool ok;
0570     if (   "rowSource" == propertyName
0571         || "rowSourceType" == propertyName
0572         || "rowSourceValues" == propertyName)
0573     {
0574         KDbLookupFieldSchemaRecordSource recordSource(this->recordSource());
0575         if ("rowSource" == propertyName)
0576             recordSource.setName(value.toString());
0577         else if ("rowSourceType" == propertyName)
0578             recordSource.setTypeByName(value.toString());
0579         else if ("rowSourceValues" == propertyName) {
0580             recordSource.setValues(value.toStringList());
0581         } else {
0582             kdbCritical() << "impl. error: unsupported property" << propertyName;
0583         }
0584         this->setRecordSource(recordSource);
0585     }
0586     else if ("boundColumn" == propertyName) {
0587         if (!::setBoundColumn(this, value)) {
0588             return false;
0589         }
0590     }
0591     else if ("visibleColumn" == propertyName) {
0592         if (!::setVisibleColumns(this, value)) {
0593             return false;
0594         }
0595     } else if ("columnWidths" == propertyName) {
0596         if (!::setColumnWidths(this, value)) {
0597             return false;
0598         }
0599     } else if ("showColumnHeaders" == propertyName) {
0600         setColumnHeadersVisible(value.toBool());
0601     } else if ("listRows" == propertyName) {
0602         const int ival = value.toInt(&ok);
0603         if (!ok)
0604             return false;
0605         setMaxVisibleRecords(ival);
0606     } else if ("limitToList" == propertyName) {
0607         setLimitToList(value.toBool());
0608     } else if ("displayWidget" == propertyName) {
0609         if (!::setDisplayWidget(this, value)) {
0610             return false;
0611         }
0612     }
0613     return true;
0614 }
0615 
0616 bool KDbLookupFieldSchema::setProperties(const QMap<QByteArray, QVariant>& values)
0617 {
0618     QMap<QByteArray, QVariant>::ConstIterator it;
0619     KDbLookupFieldSchemaRecordSource recordSource(this->recordSource());
0620     bool ok;
0621     bool updateRecordSource = false;
0622     if ((it = values.find("rowSource")) != values.constEnd()) {
0623         recordSource.setName(it.value().toString());
0624         updateRecordSource = true;
0625     }
0626     if ((it = values.find("rowSourceType")) != values.constEnd()) {
0627         recordSource.setTypeByName(it.value().toString());
0628         updateRecordSource = true;
0629     }
0630     if ((it = values.find("rowSourceValues")) != values.constEnd()) {
0631         if (!it.value().isNull()) {
0632             recordSource.setValues(it.value().toStringList());
0633             updateRecordSource = true;
0634         }
0635     }
0636     if (updateRecordSource) {
0637         setRecordSource(recordSource);
0638     }
0639     if ((it = values.find("boundColumn")) != values.constEnd()) {
0640         if (!::setBoundColumn(this, it.value())) {
0641             return false;
0642         }
0643     }
0644     if ((it = values.find("visibleColumn")) != values.constEnd()) {
0645         if (!::setVisibleColumns(this, it.value())) {
0646             return false;
0647         }
0648     }
0649     if ((it = values.find("columnWidths")) != values.constEnd()) {
0650         if (!::setColumnWidths(this, it.value())) {
0651             return false;
0652         }
0653     }
0654     if ((it = values.find("showColumnHeaders")) != values.constEnd()) {
0655         setColumnHeadersVisible(it.value().toBool());
0656     }
0657     if ((it = values.find("listRows")) != values.constEnd()) {
0658         int ival = it.value().toInt(&ok);
0659         if (!ok)
0660             return false;
0661         setMaxVisibleRecords(ival);
0662     }
0663     if ((it = values.find("limitToList")) != values.constEnd()) {
0664         setLimitToList(it.value().toBool());
0665     }
0666     if ((it = values.find("displayWidget")) != values.constEnd()) {
0667         if (!::setDisplayWidget(this, it.value())) {
0668             return false;
0669         }
0670     }
0671     return true;
0672 }
0673 
0674 
0675 int KDbLookupFieldSchema::boundColumn() const
0676 {
0677     return d->boundColumn;
0678 }
0679 
0680 void KDbLookupFieldSchema::setBoundColumn(int column)
0681 {
0682     d->boundColumn = column >= 0 ? column : -1;
0683 }
0684 
0685 QList<int> KDbLookupFieldSchema::visibleColumns() const
0686 {
0687     return d->visibleColumns;
0688 }
0689 
0690 void KDbLookupFieldSchema::setVisibleColumns(const QList<int>& list)
0691 {
0692     d->visibleColumns = list;
0693 }
0694 
0695 int KDbLookupFieldSchema::visibleColumn(int index) const
0696 {
0697     if (index >= d->visibleColumns.count()) {
0698         return -1;
0699     }
0700     return index;
0701 }
0702 
0703 QList<int> KDbLookupFieldSchema::columnWidths() const
0704 {
0705     return d->columnWidths;
0706 }
0707 
0708 void KDbLookupFieldSchema::setColumnWidths(const QList<int>& widths)
0709 {
0710     d->columnWidths = widths;
0711 }
0712 
0713 bool KDbLookupFieldSchema::columnHeadersVisible() const
0714 {
0715     return d->columnHeadersVisible;
0716 }
0717 
0718 void KDbLookupFieldSchema::setColumnHeadersVisible(bool set)
0719 {
0720     d->columnHeadersVisible = set;
0721 }
0722 
0723 int KDbLookupFieldSchema::maxVisibleRecords() const
0724 {
0725     return d->maxVisibleRecords;
0726 }
0727 
0728 bool KDbLookupFieldSchema::limitToList() const
0729 {
0730     return d->limitToList;
0731 }
0732 
0733 void KDbLookupFieldSchema::setLimitToList(bool set)
0734 {
0735     d->limitToList = set;
0736 }
0737 
0738 KDbLookupFieldSchema::DisplayWidget KDbLookupFieldSchema::displayWidget() const
0739 {
0740     return d->displayWidget;
0741 }
0742 
0743 void KDbLookupFieldSchema::setDisplayWidget(DisplayWidget widget)
0744 {
0745     d->displayWidget = widget;
0746 }
0747 
0748 KDbLookupFieldSchema& KDbLookupFieldSchema::operator=(const KDbLookupFieldSchema & other)
0749 {
0750     if (this != &other) {
0751         *d = *other.d;
0752     }
0753     return *this;
0754 }
0755 
0756 bool KDbLookupFieldSchema::operator==(const KDbLookupFieldSchema &other) const
0757 {
0758     return *d == *other.d;
0759 }