File indexing completed on 2024-10-13 07:14:05

 /* This file is part of the KDE project
    Copyright (C) 2006-2016 Jarosław Staniek <staniek@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KDbLookupFieldSchema.h"
 #include "KDb.h"
 #include "kdb_debug.h"
 
 #include <QDomElement>
 #include <QVariant>
 #include <QStringList>
 #include <QHash>
 
 #include <vector>
 
 //! @internal
 class Q_DECL_HIDDEN KDbLookupFieldSchemaRecordSource::Private
 {
 public:
     Private()
             : type(KDbLookupFieldSchemaRecordSource::Type::None) {
     }
     Private(const Private &other) {
         copy(other);
     }
 #define KDbLookupFieldSchemaRecordSourcePrivateArgs(o) std::tie(o.type, o.name, o.values)
     void copy(const Private &other) {
         KDbLookupFieldSchemaRecordSourcePrivateArgs((*this))
                 = KDbLookupFieldSchemaRecordSourcePrivateArgs(other);
     }
     bool operator==(const KDbLookupFieldSchemaRecordSource::Private &other) const {
         return KDbLookupFieldSchemaRecordSourcePrivateArgs((*this))
                 == KDbLookupFieldSchemaRecordSourcePrivateArgs(other);
     }
 
     KDbLookupFieldSchemaRecordSource::Type type;
     QString name;
     QStringList values;
 };
 
 //! @internal
 class Q_DECL_HIDDEN KDbLookupFieldSchema::Private
 {
 public:
     Private()
             : boundColumn(-1)
             , maxVisibleRecords(KDB_LOOKUP_FIELD_DEFAULT_MAX_VISIBLE_RECORDS)
             , displayWidget(KDB_LOOKUP_FIELD_DEFAULT_DISPLAY_WIDGET)
             , columnHeadersVisible(KDB_LOOKUP_FIELD_DEFAULT_HEADERS_VISIBLE)
             , limitToList(KDB_LOOKUP_FIELD_DEFAULT_LIMIT_TO_LIST) {
     }
     Private(const Private &other) {
         copy(other);
     }
 #define KDbLookupFieldSchemaPrivateArgs(o) std::tie(o.recordSource, o.boundColumn, o.visibleColumns, \
                     o.columnWidths, o.maxVisibleRecords, o.displayWidget, \
                     o.columnHeadersVisible, o.limitToList)
     void copy(const Private &other) {
         KDbLookupFieldSchemaPrivateArgs((*this)) = KDbLookupFieldSchemaPrivateArgs(other);
     }
     bool operator==(const KDbLookupFieldSchema::Private &other) const {
         return KDbLookupFieldSchemaPrivateArgs((*this)) == KDbLookupFieldSchemaPrivateArgs(other);
     }
 
     KDbLookupFieldSchemaRecordSource recordSource;
     int boundColumn;
     QList<int> visibleColumns;
     QList<int> columnWidths;
     int maxVisibleRecords;
     DisplayWidget displayWidget;
     bool columnHeadersVisible;
     bool limitToList;
 };
 
 //! Cache
 class LookupFieldSchemaStatic
 {
 public:
     LookupFieldSchemaStatic()
      : typeNames({
             QString(), // no type
             QLatin1String("table"),
             QLatin1String("query"),
             QLatin1String("sql"),
             QLatin1String("valuelist"),
             QLatin1String("fieldlist")})
     {
         typesForNames.insert(QLatin1String("table"), KDbLookupFieldSchemaRecordSource::Type::Table);
         typesForNames.insert(QLatin1String("query"), KDbLookupFieldSchemaRecordSource::Type::Query);
         typesForNames.insert(QLatin1String("sql"), KDbLookupFieldSchemaRecordSource::Type::SQLStatement);
         typesForNames.insert(QLatin1String("valuelist"), KDbLookupFieldSchemaRecordSource::Type::ValueList);
         typesForNames.insert(QLatin1String("fieldlist"), KDbLookupFieldSchemaRecordSource::Type::KDbFieldList);
     }
     const std::vector<QString> typeNames;
     QHash<QString, KDbLookupFieldSchemaRecordSource::Type> typesForNames;
 private:
     Q_DISABLE_COPY(LookupFieldSchemaStatic)
 };
 
 Q_GLOBAL_STATIC(LookupFieldSchemaStatic, KDb_lookupFieldSchemaStatic)
 
 //----------------------------
 
 KDbLookupFieldSchemaRecordSource::KDbLookupFieldSchemaRecordSource()
         : d(new Private)
 {
 }
 
 KDbLookupFieldSchemaRecordSource::KDbLookupFieldSchemaRecordSource(const KDbLookupFieldSchemaRecordSource& other)
         : d(new Private(*other.d))
 {
 }
 
 KDbLookupFieldSchemaRecordSource::~KDbLookupFieldSchemaRecordSource()
 {
     delete d;
 }
 
 KDbLookupFieldSchemaRecordSource::Type KDbLookupFieldSchemaRecordSource::type() const
 {
     return d->type;
 }
 
 void KDbLookupFieldSchemaRecordSource::setType(Type type)
 {
     d->type = type;
 }
 
 QString KDbLookupFieldSchemaRecordSource::name() const
 {
     return d->name;
 }
 
 void KDbLookupFieldSchemaRecordSource::setName(const QString& name)
 {
     d->name = name;
     d->values.clear();
 }
 
 QString KDbLookupFieldSchemaRecordSource::typeName() const
 {
     Q_ASSERT(size_t(d->type) < KDb_lookupFieldSchemaStatic->typeNames.size());
     return KDb_lookupFieldSchemaStatic->typeNames[static_cast<int>(d->type)];
 }
 
 void KDbLookupFieldSchemaRecordSource::setTypeByName(const QString& typeName)
 {
     setType(KDb_lookupFieldSchemaStatic->typesForNames.value(typeName, Type::None));
 }
 
 QStringList KDbLookupFieldSchemaRecordSource::values() const
 {
     return d->values;
 }
 
 void KDbLookupFieldSchemaRecordSource::setValues(const QStringList& values)
 {
     d->name.clear();
     d->values = values;
 }
 
 KDbLookupFieldSchemaRecordSource& KDbLookupFieldSchemaRecordSource::operator=(const KDbLookupFieldSchemaRecordSource & other)
 {
     if (this != &other) {
         *d = *other.d;
     }
     return *this;
 }
 
 bool KDbLookupFieldSchemaRecordSource::operator==(const KDbLookupFieldSchemaRecordSource &other) const
 {
     return *d == *other.d;
 }
 
 QDebug operator<<(QDebug dbg, const KDbLookupFieldSchemaRecordSource& source)
 {
     dbg.nospace() << "LookupFieldSchemaRecordSource TYPE:";
     dbg.space() << source.typeName();
     dbg.space() << "NAME:";
     dbg.space() << source.name();
     dbg.space() << "VALUES:";
     dbg.space() << source.values().join(QLatin1String("|")) << '\n';
     return dbg.nospace();
 }
 
 //----------------------------
 
 KDbLookupFieldSchema::KDbLookupFieldSchema()
         : d(new Private)
 {
 }
 
 KDbLookupFieldSchema::KDbLookupFieldSchema(const KDbLookupFieldSchema &schema)
 : d(new Private(*schema.d))
 {
 }
 
 KDbLookupFieldSchema::~KDbLookupFieldSchema()
 {
     delete d;
 }
 
 static bool setBoundColumn(KDbLookupFieldSchema *lookup, const QVariant &val)
 {
     if (val.isNull()) {
         lookup->setBoundColumn(-1);
     }
     else {
         bool ok;
         const int ival = val.toInt(&ok);
         if (!ok)
             return false;
         lookup->setBoundColumn(ival);
     }
     return true;
 }
 
 static bool setVisibleColumns(KDbLookupFieldSchema *lookup, const QVariant &val)
 {
     QList<QVariant> variantList;
     if (val.canConvert(QVariant::Int)) {
     //! @todo Remove this case: it's for backward compatibility with Kexi's 1.1.2 table designer GUI
     //!       supporting only single lookup column.
         variantList.append(val);
     }
     else {
         variantList = val.toList();
     }
     QList<int> visibleColumns;
     foreach(const QVariant& variant, variantList) {
         bool ok;
         const int ival = variant.toInt(&ok);
         if (!ok) {
             return false;
         }
         visibleColumns.append(ival);
     }
     lookup->setVisibleColumns(visibleColumns);
     return true;
 }
 
 static bool setColumnWidths(KDbLookupFieldSchema *lookup, const QVariant &val)
 {
     QList<int> widths;
     foreach(const QVariant& variant, val.toList()) {
         bool ok;
         const int ival = variant.toInt(&ok);
         if (!ok)
             return false;
         widths.append(ival);
     }
     lookup->setColumnWidths(widths);
     return true;
 }
 
 static bool setDisplayWidget(KDbLookupFieldSchema *lookup, const QVariant &val)
 {
     bool ok;
     const uint ival = val.toUInt(&ok);
     if (!ok || ival > static_cast<uint>(KDbLookupFieldSchema::DisplayWidget::ListBox)) {
         return false;
     }
     lookup->setDisplayWidget(static_cast<KDbLookupFieldSchema::DisplayWidget>(ival));
     return true;
 }
 
 KDbLookupFieldSchemaRecordSource KDbLookupFieldSchema::recordSource() const
 {
     return d->recordSource;
 }
 
 void KDbLookupFieldSchema::setRecordSource(const KDbLookupFieldSchemaRecordSource& recordSource)
 {
     d->recordSource = recordSource;
 }
 
 void KDbLookupFieldSchema::setMaxVisibleRecords(int count)
 {
     if (count == 0)
         d->maxVisibleRecords = KDB_LOOKUP_FIELD_DEFAULT_MAX_VISIBLE_RECORDS;
     else if (count > KDB_LOOKUP_FIELD_LIMIT_MAX_VISIBLE_RECORDS)
         d->maxVisibleRecords = KDB_LOOKUP_FIELD_LIMIT_MAX_VISIBLE_RECORDS;
     else
         d->maxVisibleRecords = count;
 }
 
 QDebug operator<<(QDebug dbg, const KDbLookupFieldSchema& lookup)
 {
     dbg.nospace() << "LookupFieldSchema(";
     dbg.space() << lookup.recordSource();
     dbg.space() << "boundColumn:";
     dbg.space() << lookup.boundColumn();
     dbg.space() << "visibleColumns:";
 
     bool first = true;
     foreach(int visibleColumn, lookup.visibleColumns()) {
         if (first) {
             first = false;
             dbg.nospace();
         }
         else
             dbg.nospace() << ';';
         dbg.nospace() << visibleColumn;
     }
     dbg.space() << "maxVisibleRecords:";
     dbg.space() << lookup.maxVisibleRecords();
     dbg.space() << "displayWidget:";
     dbg.space() << (lookup.displayWidget() == KDbLookupFieldSchema::DisplayWidget::ComboBox
                         ? "ComboBox"
                         : "ListBox");
     dbg.space() << "columnHeadersVisible:";
     dbg.space() << lookup.columnHeadersVisible();
     dbg.space() << "limitToList:";
     dbg.space() << lookup.limitToList();
     dbg.space() << "columnWidths:";
 
     first = true;
     const QList<int> columnWidths(lookup.columnWidths());
     for (int width : columnWidths) {
         if (first)
             first = false;
         else
             dbg.nospace() << ';';
         dbg.space() << width;
     }
     dbg.nospace() << ')';
     return dbg.space();
 }
 
 /* static */
 KDbLookupFieldSchema *KDbLookupFieldSchema::loadFromDom(const QDomElement& lookupEl)
 {
     KDbLookupFieldSchema *lookupFieldSchema = new KDbLookupFieldSchema();
     KDbLookupFieldSchemaRecordSource recordSource;
     for (QDomNode node = lookupEl.firstChild(); !node.isNull(); node = node.nextSibling()) {
         QDomElement el = node.toElement();
         const QByteArray name(el.tagName().toLatin1());
         if (name == "row-source") {
             /*<row-source>
               empty
               | <type>table|query|sql|valuelist|fieldlist</type> #required because there can be
                                                                  #table and query with the same name
                                                                  #"fieldlist" (basically a list of
                                                                  #column names of a table/query,
                                                                  #"Field List" as in MSA)
               <name>string</name> #table/query name, etc. or KDbSQL SELECT QUERY
               <values><value>...</value> #for "valuelist" type
                 <value>...</value>
               </values>
              </row-source> */
             for (el = el.firstChild().toElement(); !el.isNull(); el = el.nextSibling().toElement()) {
                 const QByteArray childName(el.tagName().toLatin1());
                 if (childName == "type") {
                     recordSource.setTypeByName(el.text());
                 }
                 else if (childName == "name") {
                     recordSource.setName(el.text());
 //! @todo handle fieldlist (retrieve from external table or so?), use KDbLookupFieldSchemaRecordSource::setValues()
                 }
             }
         } else if (name == "bound-column") {
             /* <bound-column>
                 <number>number</number> #in later implementation there can be more columns
                </bound-column> */
             bool ok;
             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
             if (!ok || !::setBoundColumn(lookupFieldSchema, val)) {
                 delete lookupFieldSchema;
                 return nullptr;
             }
         } else if (name == "visible-column") {
             /* <visible-column> #a column that has to be visible in the combo box
               <number>number 1</number>
               <number>number 2</number>
               [..]
                </visible-column> */
             QVariantList list;
             for (QDomNode childNode = el.firstChild(); !childNode.isNull();
                  childNode = childNode.nextSibling())
             {
                 bool ok;
                 const QVariant val = KDb::loadPropertyValueFromDom(childNode, &ok);
                 if (!ok) {
                     delete lookupFieldSchema;
                     return nullptr;
                 }
                 list.append(val);
             }
             if (!::setVisibleColumns(lookupFieldSchema, list)) {
                 delete lookupFieldSchema;
                 return nullptr;
             }
         } else if (name == "column-widths") {
             /* <column-widths> #column widths, -1 means 'default'
                 <number>int</number>
                 ...
                 <number>int</number>
                </column-widths> */
             QVariantList columnWidths;
             for (el = el.firstChild().toElement(); !el.isNull(); el = el.nextSibling().toElement()) {
                 bool ok;
                 QVariant val = KDb::loadPropertyValueFromDom(el, &ok);
                 if (!ok) {
                     delete lookupFieldSchema;
                     return nullptr;
                 }
                 columnWidths.append(val);
             }
             if (!::setColumnWidths(lookupFieldSchema, columnWidths)) {
                 delete lookupFieldSchema;
                 return nullptr;
             }
         } else if (name == "show-column-headers") {
             /* <show-column-headers>
                 <bool>true/false</bool>
                </show-column-headers> */
             bool ok;
             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
             if (!ok) {
                 delete lookupFieldSchema;
                 return nullptr;
             }
             if (val.type() == QVariant::Bool)
                 lookupFieldSchema->setColumnHeadersVisible(val.toBool());
         } else if (name == "list-rows") {
             /* <list-rows>
                 <number>1..100</number>
                </list-rows> */
             bool ok;
             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
             if (!ok) {
                 delete lookupFieldSchema;
                 return nullptr;
             }
             if (val.type() == QVariant::Int)
                 lookupFieldSchema->setMaxVisibleRecords(val.toInt());
         } else if (name == "limit-to-list") {
             /* <limit-to-list>
                 <bool>true/false</bool>
                </limit-to-list> */
             bool ok;
             const QVariant val = KDb::loadPropertyValueFromDom(el.firstChild(), &ok);
             if (!ok) {
                 delete lookupFieldSchema;
                 return nullptr;
             }
             if (val.type() == QVariant::Bool)
                 lookupFieldSchema->setLimitToList(val.toBool());
         }
         else if (name == "display-widget") {
             const QByteArray displayWidgetName(el.text().toLatin1());
             if (displayWidgetName == "combobox") {
                 lookupFieldSchema->setDisplayWidget(KDbLookupFieldSchema::DisplayWidget::ComboBox);
             }
             else if (displayWidgetName == "listbox") {
                 lookupFieldSchema->setDisplayWidget(KDbLookupFieldSchema::DisplayWidget::ListBox);
             }
         }
     }
     lookupFieldSchema->setRecordSource(recordSource);
     return lookupFieldSchema;
 }
 
 void KDbLookupFieldSchema::saveToDom(QDomDocument *doc, QDomElement *parentEl)
 {
     if (!doc || !parentEl) {
         return;
     }
     QDomElement lookupColumnEl, recordSourceEl, recordSourceTypeEl, nameEl;
     if (!recordSource().name().isEmpty()) {
         lookupColumnEl = doc->createElement(QLatin1String("lookup-column"));
         parentEl->appendChild(lookupColumnEl);
 
         recordSourceEl = doc->createElement(QLatin1String("row-source"));
         lookupColumnEl.appendChild(recordSourceEl);
 
         recordSourceTypeEl = doc->createElement(QLatin1String("type"));
         recordSourceEl.appendChild(recordSourceTypeEl);
         recordSourceTypeEl.appendChild(doc->createTextNode(recordSource().typeName()));   //can be empty
 
         nameEl = doc->createElement(QLatin1String("name"));
         recordSourceEl.appendChild(nameEl);
         nameEl.appendChild(doc->createTextNode(recordSource().name()));
     }
 
     const QStringList& values(recordSource().values());
     if (!values.isEmpty()) {
         QDomElement valuesEl(doc->createElement(QLatin1String("values")));
         recordSourceEl.appendChild(valuesEl);
         for (QStringList::ConstIterator it = values.constBegin(); it != values.constEnd(); ++it) {
             QDomElement valueEl(doc->createElement(QLatin1String("value")));
             valuesEl.appendChild(valueEl);
             valueEl.appendChild(doc->createTextNode(*it));
         }
     }
 
     if (boundColumn() >= 0) {
         KDb::saveNumberElementToDom(doc, &lookupColumnEl,
                                           QLatin1String("bound-column"), boundColumn());
     }
 
     QList<int> visibleColumns(this->visibleColumns());
     if (!visibleColumns.isEmpty()) {
         QDomElement visibleColumnEl(doc->createElement(QLatin1String("visible-column")));
         lookupColumnEl.appendChild(visibleColumnEl);
         foreach(int visibleColumn, visibleColumns) {
             QDomElement numberEl(doc->createElement(QLatin1String("number")));
             visibleColumnEl.appendChild(numberEl);
             numberEl.appendChild(doc->createTextNode(QString::number(visibleColumn)));
         }
     }
 
     const QList<int> columnWidths(this->columnWidths());
     if (!columnWidths.isEmpty()) {
         QDomElement columnWidthsEl(doc->createElement(QLatin1String("column-widths")));
         lookupColumnEl.appendChild(columnWidthsEl);
         foreach(int columnWidth, columnWidths) {
             QDomElement columnWidthEl(doc->createElement(QLatin1String("number")));
             columnWidthsEl.appendChild(columnWidthEl);
             columnWidthEl.appendChild(doc->createTextNode(QString::number(columnWidth)));
         }
     }
 
     if (columnHeadersVisible() != KDB_LOOKUP_FIELD_DEFAULT_HEADERS_VISIBLE)
         KDb::saveBooleanElementToDom(doc, &lookupColumnEl,
                                            QLatin1String("show-column-headers"),
                                            columnHeadersVisible());
     if (maxVisibleRecords() != KDB_LOOKUP_FIELD_DEFAULT_MAX_VISIBLE_RECORDS)
         KDb::saveNumberElementToDom(doc, &lookupColumnEl,
                                           QLatin1String("list-rows"),
                                           maxVisibleRecords());
     if (limitToList() != KDB_LOOKUP_FIELD_DEFAULT_LIMIT_TO_LIST)
         KDb::saveBooleanElementToDom(doc, &lookupColumnEl,
                                            QLatin1String("limit-to-list"),
                                            limitToList());
 
     if (displayWidget() != KDB_LOOKUP_FIELD_DEFAULT_DISPLAY_WIDGET) {
         QDomElement displayWidgetEl(doc->createElement(QLatin1String("display-widget")));
         lookupColumnEl.appendChild(displayWidgetEl);
         displayWidgetEl.appendChild(
             doc->createTextNode(
                 QLatin1String((displayWidget() == DisplayWidget::ListBox) ? "listbox" : "combobox")));
     }
 }
 
 void KDbLookupFieldSchema::getProperties(QMap<QByteArray, QVariant> *values) const
 {
     values->clear();
     KDb::getProperties(this, values);
 }
 
 bool KDbLookupFieldSchema::setProperty(const QByteArray& propertyName, const QVariant& value)
 {
     bool ok;
     if (   "rowSource" == propertyName
         || "rowSourceType" == propertyName
         || "rowSourceValues" == propertyName)
     {
         KDbLookupFieldSchemaRecordSource recordSource(this->recordSource());
         if ("rowSource" == propertyName)
             recordSource.setName(value.toString());
         else if ("rowSourceType" == propertyName)
             recordSource.setTypeByName(value.toString());
         else if ("rowSourceValues" == propertyName) {
             recordSource.setValues(value.toStringList());
         } else {
             kdbCritical() << "impl. error: unsupported property" << propertyName;
         }
         this->setRecordSource(recordSource);
     }
     else if ("boundColumn" == propertyName) {
         if (!::setBoundColumn(this, value)) {
             return false;
         }
     }
     else if ("visibleColumn" == propertyName) {
         if (!::setVisibleColumns(this, value)) {
             return false;
         }
     } else if ("columnWidths" == propertyName) {
         if (!::setColumnWidths(this, value)) {
             return false;
         }
     } else if ("showColumnHeaders" == propertyName) {
         setColumnHeadersVisible(value.toBool());
     } else if ("listRows" == propertyName) {
         const int ival = value.toInt(&ok);
         if (!ok)
             return false;
         setMaxVisibleRecords(ival);
     } else if ("limitToList" == propertyName) {
         setLimitToList(value.toBool());
     } else if ("displayWidget" == propertyName) {
         if (!::setDisplayWidget(this, value)) {
             return false;
         }
     }
     return true;
 }
 
 bool KDbLookupFieldSchema::setProperties(const QMap<QByteArray, QVariant>& values)
 {
     QMap<QByteArray, QVariant>::ConstIterator it;
     KDbLookupFieldSchemaRecordSource recordSource(this->recordSource());
     bool ok;
     bool updateRecordSource = false;
     if ((it = values.find("rowSource")) != values.constEnd()) {
         recordSource.setName(it.value().toString());
         updateRecordSource = true;
     }
     if ((it = values.find("rowSourceType")) != values.constEnd()) {
         recordSource.setTypeByName(it.value().toString());
         updateRecordSource = true;
     }
     if ((it = values.find("rowSourceValues")) != values.constEnd()) {
         if (!it.value().isNull()) {
             recordSource.setValues(it.value().toStringList());
             updateRecordSource = true;
         }
     }
     if (updateRecordSource) {
         setRecordSource(recordSource);
     }
     if ((it = values.find("boundColumn")) != values.constEnd()) {
         if (!::setBoundColumn(this, it.value())) {
             return false;
         }
     }
     if ((it = values.find("visibleColumn")) != values.constEnd()) {
         if (!::setVisibleColumns(this, it.value())) {
             return false;
         }
     }
     if ((it = values.find("columnWidths")) != values.constEnd()) {
         if (!::setColumnWidths(this, it.value())) {
             return false;
         }
     }
     if ((it = values.find("showColumnHeaders")) != values.constEnd()) {
         setColumnHeadersVisible(it.value().toBool());
     }
     if ((it = values.find("listRows")) != values.constEnd()) {
         int ival = it.value().toInt(&ok);
         if (!ok)
             return false;
         setMaxVisibleRecords(ival);
     }
     if ((it = values.find("limitToList")) != values.constEnd()) {
         setLimitToList(it.value().toBool());
     }
     if ((it = values.find("displayWidget")) != values.constEnd()) {
         if (!::setDisplayWidget(this, it.value())) {
             return false;
         }
     }
     return true;
 }
 
 
 int KDbLookupFieldSchema::boundColumn() const
 {
     return d->boundColumn;
 }
 
 void KDbLookupFieldSchema::setBoundColumn(int column)
 {
     d->boundColumn = column >= 0 ? column : -1;
 }
 
 QList<int> KDbLookupFieldSchema::visibleColumns() const
 {
     return d->visibleColumns;
 }
 
 void KDbLookupFieldSchema::setVisibleColumns(const QList<int>& list)
 {
     d->visibleColumns = list;
 }
 
 int KDbLookupFieldSchema::visibleColumn(int index) const
 {
     if (index >= d->visibleColumns.count()) {
         return -1;
     }
     return index;
 }
 
 QList<int> KDbLookupFieldSchema::columnWidths() const
 {
     return d->columnWidths;
 }
 
 void KDbLookupFieldSchema::setColumnWidths(const QList<int>& widths)
 {
     d->columnWidths = widths;
 }
 
 bool KDbLookupFieldSchema::columnHeadersVisible() const
 {
     return d->columnHeadersVisible;
 }
 
 void KDbLookupFieldSchema::setColumnHeadersVisible(bool set)
 {
     d->columnHeadersVisible = set;
 }
 
 int KDbLookupFieldSchema::maxVisibleRecords() const
 {
     return d->maxVisibleRecords;
 }
 
 bool KDbLookupFieldSchema::limitToList() const
 {
     return d->limitToList;
 }
 
 void KDbLookupFieldSchema::setLimitToList(bool set)
 {
     d->limitToList = set;
 }
 
 KDbLookupFieldSchema::DisplayWidget KDbLookupFieldSchema::displayWidget() const
 {
     return d->displayWidget;
 }
 
 void KDbLookupFieldSchema::setDisplayWidget(DisplayWidget widget)
 {
     d->displayWidget = widget;
 }
 
 KDbLookupFieldSchema& KDbLookupFieldSchema::operator=(const KDbLookupFieldSchema & other)
 {
     if (this != &other) {
         *d = *other.d;
     }
     return *this;
 }
 
 bool KDbLookupFieldSchema::operator==(const KDbLookupFieldSchema &other) const
 {
     return *d == *other.d;
 }