Initial import of statemachine branch from the old kinetic repository

23 files changed, 9282 insertions, 0 deletions

diff --git a/src/qt3support/sql/q3databrowser.cpp b/src/qt3support/sql/q3databrowser.cpp
new file mode 100644
index 0000000..fd20f66
--- /dev/null
+++ b/src/qt3support/sql/q3databrowser.cpp
@@ -0,0 +1,1281 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3databrowser.h"
+
+#ifndef QT_NO_SQL_VIEW_WIDGETS
+
+#include "q3sqlform.h"
+#include "private/q3sqlmanager_p.h"
+#include "qsqlresult.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q3DataBrowserPrivate
+{
+public:
+    Q3DataBrowserPrivate() : boundaryCheck(true), readOnly(false) {}
+    Q3SqlCursorManager cur;
+    Q3SqlFormManager frm;
+    Q3DataManager dat;
+    bool boundaryCheck;
+    bool readOnly;
+};
+
+/*!
+    \class Q3DataBrowser
+    \brief The Q3DataBrowser class provides data manipulation and
+    navigation for data entry forms.
+
+    \compat
+
+    A high-level API is provided for navigating through data records
+    in a cursor, for inserting, updating and deleting records, and for
+    refreshing data in the display.
+
+    If you want a read-only form to present database data use
+    Q3DataView; if you want a table-based presentation of your data use
+    Q3DataTable.
+
+    A Q3DataBrowser is used to associate a dataset with a form in much
+    the same way as a Q3DataTable associates a dataset with a table.
+    Once the data browser has been constructed it can be associated
+    with a dataset with setSqlCursor(), and with a form with
+    setForm(). Boundary checking, sorting and filtering can be set
+    with setBoundaryChecking(), setSort() and setFilter(),
+    respectively.
+
+    The insertCurrent() function reads the fields from the default
+    form into the default cursor and performs the insert. The
+    updateCurrent() and deleteCurrent() functions perform similarly to
+    update and delete the current record respectively.
+
+    The user can be asked to confirm all edits with setConfirmEdits().
+    For more precise control use setConfirmInsert(),
+    setConfirmUpdate(), setConfirmDelete() and setConfirmCancels().
+    Use setAutoEdit() to control the behavior of the form when the
+    user edits a record and then navigates.
+
+    The record set is navigated using first(), next(), prev(), last()
+    and seek(). The form's display is updated with refresh(). When
+    navigation takes place the firstRecordAvailable(),
+    lastRecordAvailable(), nextRecordAvailable() and
+    prevRecordAvailable() signals are emitted. When the cursor record
+    is changed due to navigation the cursorChanged() signal is
+    emitted.
+
+    If you want finer control of the insert, update and delete
+    processes then you can use the lower level functions to perform
+    these operations as described below.
+
+    The form is populated with data from the database with
+    readFields(). If the user is allowed to edit, (see setReadOnly()),
+    write the form's data back to the cursor's edit buffer with
+    writeFields(). You can clear the values in the form with
+    clearValues(). Editing is performed as follows:
+    \list
+    \i \e insert When the data browser enters insertion mode it emits the
+    primeInsert() signal which you can connect to, for example to
+    pre-populate fields. Call writeFields() to write the user's edits to
+    the cursor's edit buffer then call insert() to insert the record
+    into the database. The beforeInsert() signal is emitted just before
+    the cursor's edit buffer is inserted into the database; connect to
+    this for example, to populate fields such as an auto-generated
+    primary key.
+    \i \e update For updates the primeUpdate() signal is emitted when
+    the data browser enters update mode. After calling writeFields()
+    call update() to update the record and connect to the beforeUpdate()
+    signal to manipulate the user's data before the update takes place.
+    \i \e delete For deletion the primeDelete() signal is emitted when
+    the data browser enters deletion mode. After calling writeFields()
+    call del() to delete the record and connect to the beforeDelete()
+    signal, for example to record an audit of the deleted record.
+    \endlist
+
+*/
+
+/*!
+    \enum Q3DataBrowser::Boundary
+
+    This enum describes where the data browser is positioned.
+
+    \value Unknown  the boundary cannot be determined (usually because
+    there is no default cursor, or the default cursor is not active).
+
+    \value None  the browser is not positioned on a boundary, but it is
+    positioned on a record somewhere in the middle.
+
+    \value BeforeBeginning  the browser is positioned before the
+    first available record.
+
+    \value Beginning  the browser is positioned at the first record.
+
+    \value End  the browser is positioned at the last
+    record.
+
+    \value AfterEnd  the browser is positioned after the last
+    available record.
+*/
+
+/*!
+    Constructs a data browser which is a child of \a parent, with the
+    name \a name and widget flags set to \a fl.
+*/
+
+Q3DataBrowser::Q3DataBrowser(QWidget *parent, const char *name, Qt::WindowFlags fl)
+    : QWidget(parent, name, fl)
+{
+    d = new Q3DataBrowserPrivate();
+    d->dat.setMode(QSql::Update);
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+Q3DataBrowser::~Q3DataBrowser()
+{
+    delete d;
+}
+
+
+/*!
+    Returns an enum indicating the boundary status of the browser.
+
+    This is achieved by moving the default cursor and checking the
+    position, however the current default form values will not be
+    altered. After checking for the boundary, the cursor is moved back
+    to its former position. See \l Q3DataBrowser::Boundary.
+
+    \sa Boundary
+*/
+
+Q3DataBrowser::Boundary Q3DataBrowser::boundary()
+{
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!cur || !cur->isActive())
+        return Unknown;
+    if (!cur->isValid()) {
+        if (cur->at() == QSql::BeforeFirst)
+            return BeforeBeginning;
+        if (cur->at() == QSql::AfterLast)
+            return AfterEnd;
+        return Unknown;
+    }
+    if (cur->at() == 0)
+        return Beginning;
+    int currentAt = cur->at();
+
+    Boundary b = None;
+    if (!cur->previous())
+        b = Beginning;
+    else
+        cur->seek(currentAt);
+    if (b == None && !cur->next())
+        b = End;
+    cur->seek(currentAt);
+    return b;
+}
+
+
+/*!
+    \property Q3DataBrowser::boundaryChecking
+    \brief whether boundary checking is active
+
+    When boundary checking is active (the default), signals are
+    emitted indicating the current position of the default cursor.
+
+    \sa boundary()
+*/
+
+void Q3DataBrowser::setBoundaryChecking(bool active)
+{
+    d->boundaryCheck = active;
+}
+
+bool Q3DataBrowser::boundaryChecking() const
+{
+    return d->boundaryCheck;
+}
+
+/*!
+    \property Q3DataBrowser::sort
+    \brief the data browser's sort
+
+    The data browser's sort affects the order in which records are
+    viewed in the browser. Call refresh() to apply the new sort.
+
+    When retrieving the sort property, a string list is returned in
+    the form 'fieldname order', e.g. 'id ASC', 'surname DESC'.
+
+    There is no default sort.
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3databrowser.cpp 0
+*/
+
+void Q3DataBrowser::setSort(const QStringList& sort)
+{
+    d->cur.setSort(sort);
+}
+
+/*!
+    \overload
+
+    Sets the data browser's sort to the QSqlIndex \a sort. To apply
+    the new sort, use refresh().
+
+*/
+void Q3DataBrowser::setSort(const QSqlIndex& sort)
+{
+    d->cur.setSort(sort);
+}
+
+QStringList Q3DataBrowser::sort() const
+{
+    return d->cur.sort();
+}
+
+
+/*!
+    \property Q3DataBrowser::filter
+    \brief the data browser's filter
+
+    The filter applies to the data shown in the browser. Call
+    refresh() to apply the new filter. A filter is a string containing
+    a SQL WHERE clause without the WHERE keyword, e.g. "id>1000",
+    "name LIKE 'A%'", etc.
+
+    There is no default filter.
+
+    \sa sort()
+*/
+
+void Q3DataBrowser::setFilter(const QString& filter)
+{
+    d->cur.setFilter(filter);
+}
+
+
+QString Q3DataBrowser::filter() const
+{
+    return d->cur.filter();
+}
+
+
+/*!
+    Sets the default cursor used by the data browser to \a cursor. If
+    \a autoDelete is true (the default is false), the data browser
+    takes ownership of the \a cursor pointer, which will be deleted
+    when the browser is destroyed, or when setSqlCursor() is called
+    again. To activate the \a cursor use refresh(). The cursor's edit
+    buffer is used in the default form to browse and edit records.
+
+    \sa sqlCursor() form() setForm()
+*/
+
+void Q3DataBrowser::setSqlCursor(Q3SqlCursor* cursor, bool autoDelete)
+{
+    if (!cursor)
+        return;
+    d->cur.setCursor(cursor, autoDelete);
+    d->frm.setRecord(cursor->editBuffer());
+    if (cursor->isReadOnly())
+        setReadOnly(true);
+}
+
+
+/*!
+    Returns the default cursor used for navigation, or 0 if there is
+    no default cursor.
+
+    \sa setSqlCursor()
+*/
+
+Q3SqlCursor* Q3DataBrowser::sqlCursor() const
+{
+    return d->cur.cursor();
+}
+
+
+/*!
+    Sets the browser's default form to \a form. The cursor and all
+    navigation and data manipulation functions that the browser
+    provides become available to the \a form.
+*/
+
+void Q3DataBrowser::setForm(Q3SqlForm* form)
+{
+    d->frm.setForm(form);
+}
+
+
+/*!
+    Returns the data browser's default form or 0 if no form has been
+    set.
+*/
+
+Q3SqlForm* Q3DataBrowser::form()
+{
+    return d->frm.form();
+}
+
+/*!
+    \property Q3DataBrowser::readOnly
+    \brief whether the browser is read-only
+
+    The default is false, i.e. data can be edited. If the data browser
+    is read-only, no database edits will be allowed.
+*/
+
+void Q3DataBrowser::setReadOnly(bool active)
+{
+    d->readOnly = active;
+}
+
+bool Q3DataBrowser::isReadOnly() const
+{
+    return d->readOnly;
+}
+
+void Q3DataBrowser::setConfirmEdits(bool confirm)
+{
+    d->dat.setConfirmEdits(confirm);
+}
+
+/*!
+    \property Q3DataBrowser::confirmInsert
+    \brief whether the data browser confirms insertions
+
+    If this property is true, the browser confirms insertions,
+    otherwise insertions happen immediately.
+
+    \sa confirmCancels() confirmEdits() confirmUpdate() confirmDelete() confirmEdit()
+*/
+
+void Q3DataBrowser::setConfirmInsert(bool confirm)
+{
+    d->dat.setConfirmInsert(confirm);
+}
+
+/*!
+    \property Q3DataBrowser::confirmUpdate
+    \brief whether the browser confirms updates
+
+    If this property is true, the browser confirms updates, otherwise
+    updates happen immediately.
+
+    \sa confirmCancels() confirmEdits() confirmInsert() confirmDelete() confirmEdit()
+*/
+
+void Q3DataBrowser::setConfirmUpdate(bool confirm)
+{
+    d->dat.setConfirmUpdate(confirm);
+}
+
+/*!
+    \property Q3DataBrowser::confirmDelete
+    \brief whether the browser confirms deletions
+
+    If this property is true, the browser confirms deletions,
+    otherwise deletions happen immediately.
+
+    \sa confirmCancels() confirmEdits() confirmUpdate() confirmInsert() confirmEdit()
+*/
+
+void Q3DataBrowser::setConfirmDelete(bool confirm)
+{
+    d->dat.setConfirmDelete(confirm);
+}
+
+/*!
+    \property Q3DataBrowser::confirmEdits
+    \brief whether the browser confirms edits
+
+    If this property is true, the browser confirms all edit operations
+    (insertions, updates and deletions), otherwise all edit operations
+    happen immediately. Confirmation is achieved by presenting the
+    user with a message box -- this behavior can be changed by
+    reimplementing the confirmEdit() function,
+
+    \sa confirmEdit() confirmCancels() confirmInsert() confirmUpdate() confirmDelete()
+*/
+
+bool Q3DataBrowser::confirmEdits() const
+{
+    return (d->dat.confirmEdits());
+}
+
+bool Q3DataBrowser::confirmInsert() const
+{
+    return (d->dat.confirmInsert());
+}
+
+bool Q3DataBrowser::confirmUpdate() const
+{
+    return (d->dat.confirmUpdate());
+}
+
+bool Q3DataBrowser::confirmDelete() const
+{
+    return (d->dat.confirmDelete());
+}
+
+/*!
+    \property Q3DataBrowser::confirmCancels
+    \brief whether the browser confirms cancel operations
+
+    If this property is true, all cancels must be confirmed by the
+    user through a message box (this behavior can be changed by
+    overriding the confirmCancel() function), otherwise all cancels
+    occur immediately. The default is false.
+
+    \sa confirmEdits() confirmCancel()
+*/
+
+void Q3DataBrowser::setConfirmCancels(bool confirm)
+{
+    d->dat.setConfirmCancels(confirm);
+}
+
+bool Q3DataBrowser::confirmCancels() const
+{
+    return d->dat.confirmCancels();
+}
+
+/*!
+    \property Q3DataBrowser::autoEdit
+    \brief whether the browser automatically applies edits
+
+    The default value for this property is true. When the user begins
+    an insertion or an update on a form there are two possible
+    outcomes when they navigate to another record:
+
+    \list
+    \i the insert or update is is performed -- this occurs if autoEdit is true
+    \i the insert or update is discarded -- this occurs if autoEdit is false
+    \endlist
+*/
+
+void Q3DataBrowser::setAutoEdit(bool autoEdit)
+{
+    d->dat.setAutoEdit(autoEdit);
+}
+
+bool Q3DataBrowser::autoEdit() const
+{
+    return d->dat.autoEdit();
+}
+
+/*!
+    \fn void Q3DataBrowser::firstRecordAvailable(bool available)
+
+    This signal is emitted whenever the position of the cursor
+    changes. The \a available parameter indicates whether or not the
+    first record in the default cursor is available.
+*/
+
+/*!
+    \fn void Q3DataBrowser::lastRecordAvailable(bool available)
+
+    This signal is emitted whenever the position of the cursor
+    changes. The \a available parameter indicates whether or not the
+    last record in the default cursor is available.
+*/
+
+/*!
+    \fn void Q3DataBrowser::nextRecordAvailable(bool available)
+
+    This signal is emitted whenever the position of the cursor
+    changes. The \a available parameter indicates whether or not the
+    next record in the default cursor is available.
+*/
+
+
+/*!
+    \fn void Q3DataBrowser::prevRecordAvailable(bool available)
+
+    This signal is emitted whenever the position of the cursor
+    changes. The \a available parameter indicates whether or not the
+    previous record in the default cursor is available.
+*/
+
+
+/*!
+    \fn void Q3DataBrowser::currentChanged(const QSqlRecord* record)
+
+    This signal is emitted whenever the current cursor position
+    changes. The \a record parameter points to the contents of the
+    current cursor's record.
+*/
+
+
+/*!
+    \fn void Q3DataBrowser::primeInsert(QSqlRecord* buf)
+
+    This signal is emitted when the data browser enters insertion
+    mode. The \a buf parameter points to the record buffer that is to
+    be inserted. Connect to this signal to, for example, prime the
+    record buffer with default data values, auto-numbered fields etc.
+    (Note that Q3SqlCursor::primeInsert() is \e not called on the
+    default cursor, as this would corrupt values in the form.)
+
+    \sa insert()
+*/
+
+
+/*!
+    \fn void Q3DataBrowser::primeUpdate(QSqlRecord* buf)
+
+    This signal is emitted when the data browser enters update mode.
+    Note that during navigation (first(), last(), next(), prev()),
+    each record that is shown in the default form is primed for
+    update. The \a buf parameter points to the record buffer being
+    updated. (Note that Q3SqlCursor::primeUpdate() is \e not called on
+    the default cursor, as this would corrupt values in the form.)
+    Connect to this signal in order to, for example, keep track of
+    which records have been updated, perhaps for auditing purposes.
+
+    \sa update()
+*/
+
+/*!
+    \fn void Q3DataBrowser::primeDelete(QSqlRecord* buf)
+
+    This signal is emitted when the data browser enters deletion mode.
+    The \a buf parameter points to the record buffer being deleted.
+    (Note that Q3SqlCursor::primeDelete() is \e not called on the
+    default cursor, as this would corrupt values in the form.)
+    Connect to this signal in order to, for example, save a copy of
+    the deleted record for auditing purposes.
+
+    \sa del()
+*/
+
+
+/*!
+    \fn void Q3DataBrowser::cursorChanged(Q3SqlCursor::Mode mode)
+
+    This signal is emitted whenever the cursor record was changed due
+    to navigation. The \a mode parameter is the edit that just took
+    place, e.g. Insert, Update or Delete. See \l Q3SqlCursor::Mode.
+*/
+
+
+/*!
+    Refreshes the data browser's data using the default cursor. The
+    browser's current filter and sort are applied if they have been
+    set.
+
+    \sa setFilter() setSort()
+*/
+
+void Q3DataBrowser::refresh()
+{
+    d->cur.refresh();
+}
+
+
+/*!
+    Performs an insert operation on the data browser's cursor. If
+    there is no default cursor or no default form, nothing happens.
+
+    If auto-editing is on (see setAutoEdit()), the following happens:
+
+    \list
+    \i If the browser is already actively inserting a record,
+    the current form's data is inserted into the database.
+    \i If the browser is not inserting a record, but the current record
+    was changed by the user, the record is updated in the database with
+    the current form's data (i.e. with the changes).
+    \endlist
+
+    If there is an error handling any of the above auto-edit actions,
+    handleError() is called and no insert or update is performed.
+
+    If no error occurred, or auto-editing is not enabled, the data browser
+    begins actively inserting a record into the database by performing the
+    following actions:
+
+    \list
+    \i The default cursor is primed for insert using Q3SqlCursor::primeInsert().
+    \i The primeInsert() signal is emitted.
+    \i The form is updated with the values in the default cursor's.
+    edit buffer so that the user can fill in the values to be inserted.
+    \endlist
+
+*/
+
+void Q3DataBrowser::insert()
+{
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return;
+    bool doIns = true;
+    QSql::Confirm conf = QSql::Yes;
+    switch (d->dat.mode()) {
+    case QSql::Insert:
+        if (autoEdit()) {
+            if (confirmInsert())
+                conf = confirmEdit(QSql::Insert);
+            switch (conf) {
+            case QSql::Yes:
+                insertCurrent();
+                break;
+            case QSql::No:
+                break;
+            case QSql::Cancel:
+                doIns = false;
+                break;
+            }
+        }
+        break;
+    default:
+        if (autoEdit() && currentEdited()) {
+            if (confirmUpdate())
+                conf = confirmEdit(QSql::Update);
+            switch (conf) {
+            case QSql::Yes:
+                updateCurrent();
+                break;
+            case QSql::No:
+                break;
+            case QSql::Cancel:
+                doIns = false;
+                break;
+            }
+        }
+        break;
+    }
+    if (doIns) {
+        d->dat.setMode(QSql::Insert);
+        sqlCursor()->primeInsert();
+        emit primeInsert(d->frm.record());
+        readFields();
+    }
+}
+
+
+/*!
+    Performs an update operation on the data browser's cursor.
+
+    If there is no default cursor or no default form, nothing happens.
+    Otherwise, the following happens:
+
+    If the data browser is actively inserting a record (see insert()),
+    that record is inserted into the database using insertCurrent().
+    Otherwise, the database is updated with the current form's data
+    using updateCurrent(). If there is an error handling either
+    action, handleError() is called.
+*/
+
+void Q3DataBrowser::update()
+{
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return;
+    QSql::Confirm conf = QSql::Yes;
+    switch (d->dat.mode()){
+    case QSql::Insert:
+        if (confirmInsert())
+            conf = confirmEdit(QSql::Insert);
+        switch (conf) {
+            case QSql::Yes:
+                if (insertCurrent())
+                    d->dat.setMode(QSql::Update);
+            break;
+            case QSql::No:
+                d->dat.setMode(QSql::Update);
+            cur->editBuffer(true);
+            readFields();
+            break;
+            case QSql::Cancel:
+            break;
+        }
+    break;
+    default:
+        d->dat.setMode(QSql::Update);
+        if (confirmUpdate())
+            conf = confirmEdit(QSql::Update);
+        switch (conf) {
+        case QSql::Yes:
+            updateCurrent();
+            break;
+        case QSql::No:
+        case QSql::Cancel:
+            break;
+        }
+        break;
+    }
+}
+
+
+/*!
+    Performs a delete operation on the data browser's cursor. If there
+    is no default cursor or no default form, nothing happens.
+
+    Otherwise, the following happens:
+
+    The current form's record is deleted from the database, providing
+    that the data browser is not in insert mode. If the data browser
+    is actively inserting a record (see insert()), the insert action
+    is canceled, and the browser navigates to the last valid record
+    that was current. If there is an error, handleError() is called.
+*/
+
+void Q3DataBrowser::del()
+{
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return;
+    QSql::Confirm conf = QSql::Yes;
+    switch (d->dat.mode()){
+    case QSql::Insert:
+        if (confirmCancels())
+            conf = confirmCancel(QSql::Insert);
+        if (conf == QSql::Yes) {
+            cur->editBuffer(true); /* restore from cursor */
+            readFields();
+            d->dat.setMode(QSql::Update);
+        } else
+            d->dat.setMode(QSql::Insert);
+        break;
+    default:
+        if (confirmDelete())
+            conf = confirmEdit(QSql::Delete);
+        switch (conf) {
+        case QSql::Yes:
+            emit primeDelete(buf);
+            deleteCurrent();
+            break;
+        case QSql::No:
+        case QSql::Cancel:
+            break;
+        }
+        d->dat.setMode(QSql::Update);
+        break;
+    }
+}
+
+/*!
+  Moves the default cursor to the record specified by index \a i
+  and refreshes the default form to display that record. If there is
+  no default form or no default cursor, nothing happens. If
+  \a relative is true (the default is false), the cursor is moved
+  relative to its current position. If the data browser successfully
+  navigated to the desired record, the default cursor is primed for
+  update and the primeUpdate() signal is emitted.
+  
+  If the browser is already positioned on the desired record nothing
+  happens. Returns false if there is no cursor. Otherwise returns
+  true.
+*/
+
+bool Q3DataBrowser::seek(int i, bool relative)
+{
+    int b = 0;
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!cur)
+        return false;
+    if (preNav())
+        b = cur->seek(i, relative);
+    postNav(b);
+    return b;
+}
+
+/*!
+    Moves the default cursor to the first record and refreshes the
+    default form to display this record. If there is no default form
+    or no default cursor, nothing happens. If the data browser
+    successfully navigated to the first record, the default cursor is
+    primed for update and the primeUpdate() signal is emitted.
+
+    If the browser is already positioned on the first record nothing
+    happens.
+
+*/
+
+void Q3DataBrowser::first()
+{
+    nav(&Q3SqlCursor::first);
+}
+
+
+/*!
+    Moves the default cursor to the last record and refreshes the
+    default form to display this record. If there is no default form
+    or no default cursor, nothing happens. If the data browser
+    successfully navigated to the last record, the default cursor is
+    primed for update and the primeUpdate() signal is emitted.
+
+    If the browser is already positioned on the last record nothing
+    happens.
+*/
+
+void Q3DataBrowser::last()
+{
+    nav(&Q3SqlCursor::last);
+}
+
+
+/*!
+    Moves the default cursor to the next record and refreshes the
+    default form to display this record. If there is no default form
+    or no default cursor, nothing happens. If the data browser
+    successfully navigated to the next record, the default cursor is
+    primed for update and the primeUpdate() signal is emitted.
+
+    If the browser is positioned on the last record nothing happens.
+*/
+
+void Q3DataBrowser::next()
+{
+    nav(&Q3SqlCursor::next);
+}
+
+
+/*!
+    Moves the default cursor to the previous record and refreshes the
+    default form to display this record. If there is no default form
+    or no default cursor, nothing happens. If the data browser
+    successfully navigated to the previous record, the default cursor
+    is primed for update and the primeUpdate() signal is emitted.
+
+    If the browser is positioned on the first record nothing happens.
+*/
+
+void Q3DataBrowser::prev()
+{
+    nav(&Q3SqlCursor::previous);
+}
+
+/*!
+    Reads the fields from the default cursor's edit buffer and
+    displays them in the form. If there is no default cursor or no
+    default form, nothing happens.
+*/
+
+void Q3DataBrowser::readFields()
+{
+    d->frm.readFields();
+}
+
+
+/*!
+    Writes the form's data to the default cursor's edit buffer. If
+    there is no default cursor or no default form, nothing happens.
+*/
+
+void Q3DataBrowser::writeFields()
+{
+    d->frm.writeFields();
+}
+
+
+/*!
+    Clears all the values in the form.
+
+    All the edit buffer field values are set to their 'zero state',
+    e.g. 0 for numeric fields and "" for string fields. Then the
+    widgets are updated using the property map. For example, a
+    combobox that is property-mapped to integers would scroll to the
+    first item. See the \l Q3SqlPropertyMap constructor for the default
+    mappings of widgets to properties.
+*/
+
+void Q3DataBrowser::clearValues()
+{
+    d->frm.clearValues();
+}
+
+/*!
+    Reads the fields from the default form into the default cursor and
+    performs an insert on the default cursor. If there is no default
+    form or no default cursor, nothing happens. If an error occurred
+    during the insert into the database, handleError() is called and
+    false is returned. If the insert was successful, the cursor is
+    refreshed and relocated to the newly inserted record, the
+    cursorChanged() signal is emitted, and true is returned.
+
+    \sa cursorChanged() sqlCursor() form() handleError()
+*/
+
+bool Q3DataBrowser::insertCurrent()
+{
+    if (isReadOnly())
+        return false;
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return false;
+    writeFields();
+    emit beforeInsert(buf);
+    int ar = cur->insert();
+    if (!ar || !cur->isActive()) {
+        handleError(cur->lastError());
+        refresh();
+        updateBoundary();
+    } else {
+        refresh();
+        d->cur.findBuffer(cur->primaryIndex());
+        updateBoundary();
+        cursorChanged(Q3SqlCursor::Insert);
+        return true;
+    }
+    return false;
+}
+
+
+/*!
+    Reads the fields from the default form into the default cursor and
+    performs an update on the default cursor. If there is no default
+    form or no default cursor, nothing happens. If an error occurred
+    during the update on the database, handleError() is called and
+    false is returned. If the update was successful, the cursor is
+    refreshed and relocated to the updated record, the cursorChanged()
+    signal is emitted, and true is returned.
+
+    \sa cursor() form() handleError()
+*/
+
+bool Q3DataBrowser::updateCurrent()
+{
+    if (isReadOnly())
+        return false;
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return false;
+    writeFields();
+    emit beforeUpdate(buf);
+    int ar = cur->update();
+    if (!ar || !cur->isActive()) {
+        handleError(cur->lastError());
+        refresh();
+        updateBoundary();
+    } else {
+        refresh();
+        d->cur.findBuffer(cur->primaryIndex());
+        updateBoundary();
+        cur->editBuffer(true);
+        cursorChanged(Q3SqlCursor::Update);
+        readFields();
+        return true;
+    }
+    return false;
+}
+
+
+/*!
+    Performs a delete on the default cursor using the values from the
+    default form and updates the default form. If there is no default
+    form or no default cursor, nothing happens. If the deletion was
+    successful, the cursor is repositioned to the nearest record and
+    true is returned. The nearest record is the next record if there
+    is one otherwise the previous record if there is one. If an error
+    occurred during the deletion from the database, handleError() is
+    called and false is returned.
+
+    \sa cursor() form() handleError()
+*/
+
+bool Q3DataBrowser::deleteCurrent()
+{
+    if (isReadOnly())
+        return false;
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return false;
+    writeFields();
+    int n = cur->at();
+    emit beforeDelete(buf);
+    int ar = cur->del();
+    if (ar) {
+        refresh();
+        updateBoundary();
+        cursorChanged(Q3SqlCursor::Delete);
+        if (!cur->seek(n))
+            last();
+        if (cur->isValid()) {
+            cur->editBuffer(true);
+            readFields();
+        } else {
+            clearValues();
+        }
+        return true;
+    } else {
+        if (!cur->isActive()) {
+            handleError(cur->lastError());
+            refresh();
+            updateBoundary();
+        }
+    }
+    return false;
+}
+
+
+/*!
+    Returns true if the form's edit buffer differs from the current
+    cursor buffer; otherwise returns false.
+*/
+
+bool Q3DataBrowser::currentEdited()
+{
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return false;
+    if (!cur->isActive() || !cur->isValid())
+        return false;
+    writeFields();
+    for (int i = 0; i < cur->count(); ++i) {
+        if (cur->value(i) != buf->value(i))
+            return true;
+    }
+    return false;
+}
+
+/*! \internal
+
+  Pre-navigation checking.
+*/
+
+bool Q3DataBrowser::preNav()
+{
+    QSqlRecord* buf = d->frm.record();
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!buf || !cur)
+        return false;
+
+    if (!isReadOnly() && autoEdit() && currentEdited()) {
+        bool ok = true;
+        QSql::Confirm conf = QSql::Yes;
+        switch (d->dat.mode()){
+        case QSql::Insert:
+            if (confirmInsert())
+                conf = confirmEdit(QSql::Insert);
+            switch (conf) {
+            case QSql::Yes:
+                ok = insertCurrent();
+                d->dat.setMode(QSql::Update);
+                break;
+            case QSql::No:
+                d->dat.setMode(QSql::Update);
+                break;
+            case QSql::Cancel:
+                return false;
+            }
+            break;
+        default:
+            if (confirmUpdate())
+                conf = confirmEdit(QSql::Update);
+            switch (conf) {
+            case QSql::Yes:
+                ok = updateCurrent();
+                break;
+            case QSql::No:
+                break;
+            case QSql::Cancel:
+                return false;
+            }
+        }
+        return ok;
+    }
+    return true;
+}
+
+/*! \internal
+
+  Handles post-navigation according to \a primeUpd.
+*/
+
+void Q3DataBrowser::postNav(bool primeUpd)
+{
+    if (primeUpd) {
+        QSqlRecord* buf = d->frm.record();
+        Q3SqlCursor* cur = d->cur.cursor();
+        if (!buf || !cur)
+            return;
+        currentChanged(cur);
+        cur->primeUpdate();
+        emit primeUpdate(buf);
+        readFields();
+    }
+    updateBoundary();
+}
+
+/*! \internal
+
+  Navigate default cursor according to \a nav. Handles autoEdit.
+
+*/
+void Q3DataBrowser::nav(Nav nav)
+{
+    int b = 0;
+    Q3SqlCursor* cur = d->cur.cursor();
+    if (!cur)
+        return;
+    if (preNav())
+        b = (cur->*nav)();
+    postNav(b);
+}
+
+/*!
+    If boundaryChecking() is true, checks the boundary of the current
+    default cursor and emits signals which indicate the position of
+    the cursor.
+*/
+
+void Q3DataBrowser::updateBoundary()
+{
+    if (d->boundaryCheck) {
+        Boundary bound = boundary();
+        switch (bound) {
+        case Unknown:
+        case None:
+            emit firstRecordAvailable(true);
+            emit prevRecordAvailable(true);
+            emit nextRecordAvailable(true);
+            emit lastRecordAvailable(true);
+            break;
+
+        case BeforeBeginning:
+            emit firstRecordAvailable(false);
+            emit prevRecordAvailable(false);
+            emit nextRecordAvailable(true);
+            emit lastRecordAvailable(true);
+            break;
+
+        case Beginning:
+            emit firstRecordAvailable(false);
+            emit prevRecordAvailable(false);
+            emit nextRecordAvailable(true);
+            emit lastRecordAvailable(true);
+            break;
+
+        case End:
+            emit firstRecordAvailable(true);
+            emit prevRecordAvailable(true);
+            emit nextRecordAvailable(false);
+            emit lastRecordAvailable(false);
+            break;
+
+        case AfterEnd:
+            emit firstRecordAvailable(true);
+            emit prevRecordAvailable(true);
+            emit nextRecordAvailable(false);
+            emit lastRecordAvailable(false);
+            break;
+        }
+    }
+}
+
+/*!
+    Virtual function which handles the error \a error. The default
+    implementation warns the user with a message box.
+*/
+
+void Q3DataBrowser::handleError(const QSqlError& error)
+{
+    d->dat.handleError(this, error);
+}
+
+/*!
+    Protected virtual function which returns a confirmation for an
+    edit of mode \a m. Derived classes can reimplement this function
+    and provide their own confirmation dialog. The default
+    implementation uses a message box which prompts the user to
+    confirm the edit action.
+*/
+
+QSql::Confirm Q3DataBrowser::confirmEdit(QSql::Op m)
+{
+    return d->dat.confirmEdit(this, m);
+}
+
+/*!
+    Protected virtual function which returns a confirmation for
+    canceling an edit mode \a m. Derived classes can reimplement this
+    function and provide their own confirmation dialog. The default
+    implementation uses a message box which prompts the user to
+    confirm the edit action.
+*/
+
+QSql::Confirm  Q3DataBrowser::confirmCancel(QSql::Op m)
+{
+    return d->dat.confirmCancel(this, m);
+}
+
+/*!
+    \fn void Q3DataBrowser::beforeInsert(QSqlRecord* buf)
+
+    This signal is emitted just before the cursor's edit buffer is
+    inserted into the database. The \a buf parameter points to the
+    edit buffer being inserted. You might connect to this signal to
+    populate a generated primary key for example.
+*/
+
+/*!
+    \fn void Q3DataBrowser::beforeUpdate(QSqlRecord* buf)
+
+    This signal is emitted just before the cursor's edit buffer is
+    updated in the database. The \a buf parameter points to the edit
+    buffer being updated. You might connect to this signal to capture
+    some auditing information about the update.
+*/
+
+/*!
+    \fn void Q3DataBrowser::beforeDelete(QSqlRecord* buf)
+
+    This signal is emitted just before the cursor's edit buffer  is
+    deleted from the database. The \a buf parameter points to the edit
+    buffer being deleted. You might connect to this signal to capture
+    some auditing information about the deletion.
+*/
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/qt3support/sql/q3databrowser.h b/src/qt3support/sql/q3databrowser.h
new file mode 100644
index 0000000..5727a63
--- /dev/null
+++ b/src/qt3support/sql/q3databrowser.h
@@ -0,0 +1,183 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3DATABROWSER_H
+#define Q3DATABROWSER_H
+
+#include <QtGui/qwidget.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qstringlist.h>
+#include <QtSql/qsql.h>
+#include <QtSql/qsqlindex.h>
+#include <Qt3Support/q3sqlcursor.h>
+#include <QtSql/qsqlerror.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_VIEW_WIDGETS
+
+class Q3SqlForm;
+class Q3DataBrowserPrivate;
+
+class Q_COMPAT_EXPORT Q3DataBrowser : public QWidget
+{
+    Q_OBJECT
+    Q_PROPERTY(bool boundaryChecking READ boundaryChecking WRITE setBoundaryChecking)
+    Q_PROPERTY(QString filter READ filter WRITE setFilter)
+    Q_PROPERTY(QStringList sort READ sort WRITE setSort)
+    Q_PROPERTY(bool confirmEdits READ confirmEdits WRITE setConfirmEdits)
+    Q_PROPERTY(bool confirmInsert READ confirmInsert WRITE setConfirmInsert)
+    Q_PROPERTY(bool confirmUpdate READ confirmUpdate WRITE setConfirmUpdate)
+    Q_PROPERTY(bool confirmDelete READ confirmDelete WRITE setConfirmDelete)
+    Q_PROPERTY(bool confirmCancels READ confirmCancels WRITE setConfirmCancels)
+    Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly)
+    Q_PROPERTY(bool autoEdit READ autoEdit WRITE setAutoEdit)
+
+public:
+    Q3DataBrowser(QWidget* parent=0, const char* name=0, Qt::WindowFlags fl = 0);
+    ~Q3DataBrowser();
+
+    enum Boundary {
+        Unknown,
+        None,
+        BeforeBeginning,
+        Beginning,
+        End,
+        AfterEnd
+    };
+
+    Boundary boundary();
+    void setBoundaryChecking(bool active);
+    bool boundaryChecking() const;
+
+    void setSort(const QSqlIndex& sort);
+    void setSort(const QStringList& sort);
+    QStringList  sort() const;
+    void setFilter(const QString& filter);
+    QString filter() const;
+    virtual void setSqlCursor(Q3SqlCursor* cursor, bool autoDelete = false);
+    Q3SqlCursor* sqlCursor() const;
+    virtual void setForm(Q3SqlForm* form);
+    Q3SqlForm* form();
+
+    virtual void setConfirmEdits(bool confirm);
+    virtual void setConfirmInsert(bool confirm);
+    virtual void setConfirmUpdate(bool confirm);
+    virtual void setConfirmDelete(bool confirm);
+    virtual void setConfirmCancels(bool confirm);
+    bool confirmEdits() const;
+    bool confirmInsert() const;
+    bool confirmUpdate() const;
+    bool confirmDelete() const;
+    bool confirmCancels() const;
+
+    virtual void setReadOnly(bool active);
+    bool isReadOnly() const;
+    virtual void setAutoEdit(bool autoEdit);
+    bool autoEdit() const;
+
+    virtual bool seek(int i, bool relative = false);
+
+Q_SIGNALS:
+    void firstRecordAvailable(bool available);
+    void lastRecordAvailable(bool available);
+    void nextRecordAvailable(bool available);
+    void prevRecordAvailable(bool available);
+
+    void currentChanged(const QSqlRecord* record);
+    void primeInsert(QSqlRecord* buf);
+    void primeUpdate(QSqlRecord* buf);
+    void primeDelete(QSqlRecord* buf);
+    void beforeInsert(QSqlRecord* buf);
+    void beforeUpdate(QSqlRecord* buf);
+    void beforeDelete(QSqlRecord* buf);
+    void cursorChanged(Q3SqlCursor::Mode mode);
+
+public Q_SLOTS:
+    virtual void refresh();
+
+    virtual void insert();
+    virtual void update();
+    virtual void del();
+
+    virtual void first();
+    virtual void last();
+    virtual void next();
+    virtual void prev();
+
+    virtual void readFields();
+    virtual void writeFields();
+    virtual void clearValues();
+
+    void updateBoundary();
+
+protected:
+    virtual bool insertCurrent();
+    virtual bool updateCurrent();
+    virtual bool deleteCurrent();
+    virtual bool currentEdited();
+
+    virtual QSql::Confirm confirmEdit(QSql::Op m);
+    virtual QSql::Confirm confirmCancel(QSql::Op m);
+
+    virtual void handleError(const QSqlError& error);
+
+private:
+    typedef bool (Q3SqlCursor::*Nav)();
+    bool preNav();
+    void postNav(bool primeUpd);
+    void nav(Nav nav);
+    Q3DataBrowserPrivate* d;
+
+    Q_DISABLE_COPY(Q3DataBrowser)
+};
+
+#endif // QT_NO_SQL_VIEW_WIDGETS
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3DATABROWSER_H
diff --git a/src/qt3support/sql/q3datatable.cpp b/src/qt3support/sql/q3datatable.cpp
new file mode 100644
index 0000000..559abaf
--- /dev/null
+++ b/src/qt3support/sql/q3datatable.cpp
@@ -0,0 +1,2335 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3datatable.h"
+
+#ifndef QT_NO_SQL_VIEW_WIDGETS
+
+#include "qevent.h"
+#include "qsqldriver.h"
+#include "q3sqleditorfactory.h"
+#include "q3sqlpropertymap.h"
+#include "qapplication.h"
+#include "qlayout.h"
+#include "qpainter.h"
+#include "q3popupmenu.h"
+#include "q3valuelist.h"
+#include "q3sqlmanager_p.h"
+#include "qsqlfield.h"
+#include "qdatetime.h"
+#include "qcursor.h"
+#include "qtimer.h"
+#include "qpointer.h"
+
+QT_BEGIN_NAMESPACE
+
+//#define QT_DEBUG_DATATABLE
+
+class Q3DataTablePrivate
+{
+public:
+    Q3DataTablePrivate()
+        : nullTxtChanged( false ),
+          haveAllRows( false ),
+          continuousEdit( false ),
+          editorFactory( 0 ),
+          propertyMap( 0 ),
+          datefmt( Qt::TextDate ),
+          editRow( -1 ),
+          editCol( -1 ),
+          insertRowLast( -1 ),
+          insertPreRows( -1 ),
+          editBuffer( 0 ),
+          cancelMode( false ),
+          cancelInsert( false ),
+          cancelUpdate( false ),
+          lastAt( -1 )
+    {}
+    ~Q3DataTablePrivate() { if ( propertyMap ) delete propertyMap; }
+
+    QString nullTxt;
+    bool nullTxtChanged;
+    typedef Q3ValueList< uint > ColIndex;
+    ColIndex colIndex;
+    bool haveAllRows;
+    bool continuousEdit;
+    Q3SqlEditorFactory* editorFactory;
+    Q3SqlPropertyMap* propertyMap;
+    QString trueTxt;
+    Qt::DateFormat datefmt;
+    QString falseTxt;
+    int editRow;
+    int editCol;
+    int insertRowLast;
+    QString insertHeaderLabelLast;
+    int insertPreRows;
+    QSqlRecord* editBuffer;
+    bool cancelMode;
+    bool cancelInsert;
+    bool cancelUpdate;
+    int lastAt;
+    QString ftr;
+    QStringList srt;
+    QStringList fld;
+    QStringList fldLabel;
+    Q3ValueList<int> fldWidth;
+    Q3ValueList<QIconSet> fldIcon;
+    Q3ValueList<bool> fldHidden;
+    Q3SqlCursorManager cur;
+    Q3DataManager dat;
+};
+
+#ifdef QT_DEBUG_DATATABLE
+void qt_debug_buffer( const QString& msg, QSqlRecord* cursor )
+{
+    qDebug("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
+    qDebug(msg);
+    for ( uint j = 0; j < cursor->count(); ++j ) {
+	qDebug(cursor->field(j)->name() + " type:" + QString(cursor->field(j)->value().typeName()) + " value:" + cursor->field(j)->value().toString() );
+    }
+}
+#endif
+
+/*!
+    \enum Q3DataTable::Refresh
+
+    This enum describes the refresh options.
+
+    \value RefreshData  refresh the data, i.e. read it from the database
+    \value RefreshColumns  refresh the list of fields, e.g. the column headings
+    \value RefreshAll  refresh both the data and the list of fields
+*/
+
+
+/*!
+    \class Q3DataTable
+    \brief The Q3DataTable class provides a flexible SQL table widget that supports browsing and editing.
+
+    \compat
+
+    Q3DataTable supports various functions for presenting and editing
+    SQL data from a \l Q3SqlCursor in a table.
+
+    If you want a to present your data in a form use QDataBrowser, or
+    for read-only forms, use QDataView instead.
+
+    When displaying data, Q3DataTable only retrieves data for visible
+    rows. If the driver supports the 'query size' property the
+    Q3DataTable will have the correct number of rows and the vertical
+    scroll bar will accurately reflect the number of rows displayed in
+    proportion to the number of rows in the dataset. If the driver
+    does not support the 'query size' property, rows are dynamically
+    fetched from the database on an as-needed basis with the scroll bar
+    becoming more accurate as the user scrolls down through the
+    records. This allows extremely large queries to be displayed as
+    quickly as possible, with minimum memory usage.
+
+    Q3DataTable inherits Q3Table's API and extends it with functions to
+    sort and filter the data and sort columns. See setSqlCursor(),
+    setFilter(), setSort(), setSorting(), sortColumn() and refresh().
+
+    When displaying editable cursors, cell editing will be enabled.
+    (For more information on editable cursors, see \l Q3SqlCursor).
+    Q3DataTable can be used to modify existing data and to add new
+    records. When a user makes changes to a field in the table, the
+    cursor's edit buffer is used. The table will not send changes in
+    the edit buffer to the database until the user moves to a
+    different record in the grid or presses Enter. Cell editing is
+    initiated by pressing F2 (or right clicking and then clicking the
+    appropriate popup menu item) and canceled by pressing Esc. If
+    there is a problem updating or adding data, errors are handled
+    automatically (see handleError() to change this behavior). Note
+    that if autoEdit() is false navigating to another record will
+    cancel the insert or update.
+
+    The user can be asked to confirm all edits with setConfirmEdits().
+    For more precise control use setConfirmInsert(),
+    setConfirmUpdate(), setConfirmDelete() and setConfirmCancels().
+    Use setAutoEdit() to control the behavior of the table when the
+    user edits a record and then navigates. (Note that setAutoDelete()
+    is unrelated; it is used to set whether the Q3SqlCursor is deleted
+    when the table is deleted.)
+
+    Since the data table can perform edits, it must be able to
+    uniquely identify every record so that edits are correctly
+    applied. Because of this the underlying cursor must have a valid
+    primary index to ensure that a unique record is inserted, updated
+    or deleted within the database otherwise the database may be
+    changed to an inconsistent state.
+
+    Q3DataTable creates editors using the default \l Q3SqlEditorFactory.
+    Different editor factories can be used by calling
+    installEditorFactory(). A property map is used to map between the
+    cell's value and the editor. You can use your own property map
+    with installPropertyMap().
+
+    The contents of a cell is available as a QString with text() or as
+    a QVariant with value(). The current record is returned by
+    currentRecord(). Use the find() function to search for a string in
+    the table.
+
+    Editing actions can be applied programmatically. For example, the
+    insertCurrent() function reads the fields from the current record
+    into the cursor and performs the insert. The updateCurrent() and
+    deleteCurrent() functions perform similarly to update and delete
+    the current record respectively.
+
+    Columns in the table can be created automatically based on the
+    cursor (see setSqlCursor()). Columns can be manipulated manually
+    using addColumn(), removeColumn() and setColumn().
+
+    The table automatically copies many of the properties of the
+    cursor to format the display of data within cells (alignment,
+    visibility, etc.). The cursor can be changed with setSqlCursor().
+    The filter (see setFilter()) and sort defined within the table are
+    used instead of the filter and sort set on the cursor. For sorting
+    options see setSort(), sortColumn(), sortAscending() and
+    sortDescending(). Note that sorting operations will not behave as
+    expected if you are using a QSqlSelectCursor because it uses
+    user-defined SQL queries to obtain data.
+
+    The text used to represent NULL, true and false values can be
+    changed with setNullText(), setTrueText() and setFalseText()
+    respectively. You can change the appearance of cells by
+    reimplementing paintField().
+
+    Whenever a new row is selected in the table the currentChanged()
+    signal is emitted. The primeInsert() signal is emitted when an
+    insert is initiated. The primeUpdate() and primeDelete() signals
+    are emitted when update and deletion are initiated respectively.
+    Just before the database is updated a signal is emitted;
+    beforeInsert(), beforeUpdate() or beforeDelete() as appropriate.
+
+*/
+
+/*!
+    Constructs a data table which is a child of \a parent, called
+    name \a name.
+*/
+
+Q3DataTable::Q3DataTable ( QWidget * parent, const char * name )
+    : Q3Table( parent, name )
+{
+    init();
+}
+
+/*!
+    Constructs a data table which is a child of \a parent, called name
+    \a name using the cursor \a cursor.
+
+    If \a autoPopulate is true (the default is false), columns are
+    automatically created based upon the fields in the \a cursor
+    record. Note that \a autoPopulate only governs the creation of
+    columns; to load the cursor's data into the table use refresh().
+
+    If the \a cursor is read-only, the table also becomes read-only.
+    In addition, the table adopts the cursor's driver's definition for
+    representing NULL values as strings.
+*/
+
+Q3DataTable::Q3DataTable ( Q3SqlCursor* cursor, bool autoPopulate, QWidget * parent, const char * name )
+    : Q3Table( parent, name )
+{
+    init();
+    setSqlCursor( cursor, autoPopulate );
+}
+
+/*! \internal
+*/
+
+
+void Q3DataTable::init()
+{
+    d = new Q3DataTablePrivate();
+    setAutoEdit( true );
+    setSelectionMode( SingleRow );
+    setFocusStyle( FollowStyle );
+    d->trueTxt = tr( "True" );
+    d->falseTxt = tr( "False" );
+    d->datefmt = Qt::LocalDate;
+    reset();
+    connect( this, SIGNAL(selectionChanged()),
+	     SLOT(updateCurrentSelection()));
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+Q3DataTable::~Q3DataTable()
+{
+    delete d;
+}
+
+
+/*!
+    Adds the next column to be displayed using the field \a fieldName,
+    column label \a label, width \a width and iconset \a iconset.
+
+    If \a label is specified, it is used as the column's header label,
+    otherwise the field's display label is used when setSqlCursor() is
+    called. The \a iconset is used to set the icon used by the column
+    header; by default there is no icon.
+
+    \sa setSqlCursor() refresh()
+*/
+
+void Q3DataTable::addColumn( const QString& fieldName,
+			    const QString& label,
+			    int width,
+			    const QIconSet& iconset )
+{
+    d->fld += fieldName;
+    d->fldLabel += label;
+    d->fldIcon += iconset;
+    d->fldWidth += width;
+    d->fldHidden += false;
+}
+
+/*!
+    Sets the \a col column to display using the field \a fieldName,
+    column label \a label, width \a width and iconset \a iconset.
+
+    If \a label is specified, it is used as the column's header label,
+    otherwise the field's display label is used when setSqlCursor() is
+    called. The \a iconset is used to set the icon used by the column
+    header; by default there is no icon.
+
+    \sa setSqlCursor() refresh()
+*/
+
+void Q3DataTable::setColumn( uint col, const QString& fieldName,
+			    const QString& label,
+			    int width,
+			    const QIconSet& iconset )
+{
+    d->fld[col]= fieldName;
+    d->fldLabel[col] = label;
+    d->fldIcon[col] = iconset;
+    d->fldWidth[col] = width;
+    d->fldHidden[col] = false;
+}
+
+/*!
+    Removes column \a col from the list of columns to be displayed. If
+    \a col does not exist, nothing happens.
+
+    \sa QSqlField
+*/
+
+void Q3DataTable::removeColumn( int col )
+{
+    if ( d->fld.begin() + col != d->fld.end() ) {
+	d->fld.remove( d->fld.at( col ) );
+	d->fldLabel.remove( d->fldLabel.at( col ) );
+	d->fldIcon.remove( d->fldIcon.at( col ) );
+	d->fldWidth.remove( d->fldWidth.at( col ) );
+	d->fldHidden.remove( d->fldHidden.at( col ) );
+    }
+}
+
+/*!
+    Sets the column \a col to the width \a w. Note that unlike Q3Table
+    the Q3DataTable is not immediately redrawn, you must call
+    refresh(Q3DataTable::RefreshColumns)
+    yourself.
+
+    \sa refresh()
+*/
+void Q3DataTable::setColumnWidth( int col, int w )
+{
+    if ( d->fldWidth.at( col ) != d->fldWidth.end() ) {
+	d->fldWidth[col] = w;
+    }
+}
+
+/*!
+    Resizes column \a col so that the column width is wide enough to
+    display the widest item the column contains (including the column
+    label). If the table's Q3SqlCursor is not currently active, the
+    cursor will be refreshed before the column width is calculated. Be
+    aware that this function may be slow on tables that contain large
+    result sets.
+*/
+void Q3DataTable::adjustColumn( int col )
+{
+    Q3SqlCursor * cur = sqlCursor();
+    if ( !cur || cur->count() <= col )
+	return;
+    if ( !cur->isActive() ) {
+	d->cur.refresh();
+    }
+    int oldRow = currentRow();
+    int w = fontMetrics().width( horizontalHeader()->label( col ) + QLatin1Char('W') );
+    cur->seek( QSql::BeforeFirst );
+    while ( cur->next() ) {
+	w = qMax( w, fontMetrics().width( fieldToString( cur->fieldPtr( indexOf( col ) ) ) ) + 10 );
+    }
+    setColumnWidth( col, w );
+    cur->seek( oldRow );
+    refresh( RefreshColumns );
+}
+
+/*! \reimp
+*/
+void Q3DataTable::setColumnStretchable( int col, bool s )
+{
+    if ( numCols() == 0 ) {
+	refresh( RefreshColumns );
+    }
+    if ( numCols() > col ) {
+	Q3Table::setColumnStretchable( col, s );
+    }
+}
+
+QString Q3DataTable::filter() const
+{
+    return d->cur.filter();
+}
+
+/*!
+    \property Q3DataTable::filter
+    \brief the data filter for the data table
+
+    The filter applies to the data shown in the table. To view data
+    with a new filter, use refresh(). A filter string is an SQL WHERE
+    clause without the WHERE keyword.
+
+    There is no default filter.
+
+    \sa sort()
+
+*/
+
+void Q3DataTable::setFilter( const QString& filter )
+{
+    d->cur.setFilter( filter );
+}
+
+
+/*!
+    \property Q3DataTable::sort
+    \brief the data table's sort
+
+    The table's sort affects the order in which data records are
+    displayed in the table. To apply a sort, use refresh().
+
+    When examining the sort property, a string list is returned with
+    each item having the form 'fieldname order' (e.g., 'id ASC',
+    'surname DESC').
+
+    There is no default sort.
+
+    Note that if you want to iterate over the sort list, you should
+    iterate over a copy, e.g.
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3datatable.cpp 0
+
+    \sa filter() refresh()
+*/
+
+void Q3DataTable::setSort( const QStringList& sort )
+{
+    d->cur.setSort( sort );
+}
+
+/*!
+    \overload
+
+    Sets the sort to be applied to the displayed data to \a sort. If
+    there is no current cursor, nothing happens. A QSqlIndex contains
+    field names and their ordering (ASC or DESC); these are used to
+    compose the ORDER BY clause.
+
+    \sa sort()
+*/
+
+void Q3DataTable::setSort( const QSqlIndex& sort )
+{
+    d->cur.setSort( sort );
+}
+
+QStringList Q3DataTable::sort() const
+{
+    return d->cur.sort();
+}
+
+/*!
+    Returns the cursor used by the data table.
+*/
+
+Q3SqlCursor* Q3DataTable::sqlCursor() const
+{
+    return d->cur.cursor();
+}
+
+void Q3DataTable::setConfirmEdits( bool confirm )
+{
+    d->dat.setConfirmEdits( confirm );
+}
+
+void Q3DataTable::setConfirmInsert( bool confirm )
+{
+    d->dat.setConfirmInsert( confirm );
+}
+
+void Q3DataTable::setConfirmUpdate( bool confirm )
+{
+    d->dat.setConfirmUpdate( confirm );
+}
+
+void Q3DataTable::setConfirmDelete( bool confirm )
+{
+    d->dat.setConfirmDelete( confirm );
+}
+
+/*!
+    \property Q3DataTable::confirmEdits
+    \brief whether the data table confirms edit operations
+
+    If the confirmEdits property is true, the data table confirms all
+    edit operations (inserts, updates and deletes). Finer control of
+    edit confirmation can be achieved using \l confirmCancels, \l
+    confirmInsert, \l confirmUpdate and \l confirmDelete.
+
+    \sa confirmCancels() confirmInsert() confirmUpdate() confirmDelete()
+*/
+
+bool Q3DataTable::confirmEdits() const
+{
+    return ( d->dat.confirmEdits() );
+}
+
+/*!
+    \property Q3DataTable::confirmInsert
+    \brief whether the data table confirms insert operations
+
+    If the confirmInsert property is true, all insertions must be
+    confirmed by the user through a message box (this behavior can be
+    changed by overriding the confirmEdit() function), otherwise all
+    insert operations occur immediately.
+
+    \sa confirmCancels() confirmEdits() confirmUpdate() confirmDelete()
+*/
+
+bool Q3DataTable::confirmInsert() const
+{
+    return ( d->dat.confirmInsert() );
+}
+
+/*!
+    \property Q3DataTable::confirmUpdate
+    \brief whether the data table confirms update operations
+
+    If the confirmUpdate property is true, all updates must be
+    confirmed by the user through a message box (this behavior can be
+    changed by overriding the confirmEdit() function), otherwise all
+    update operations occur immediately.
+
+    \sa confirmCancels() confirmEdits() confirmInsert() confirmDelete()
+*/
+
+bool Q3DataTable::confirmUpdate() const
+{
+    return ( d->dat.confirmUpdate() );
+}
+
+/*!
+    \property Q3DataTable::confirmDelete
+    \brief whether the data table confirms delete operations
+
+    If the confirmDelete property is true, all deletions must be
+    confirmed by the user through a message box (this behavior can be
+    changed by overriding the confirmEdit() function), otherwise all
+    delete operations occur immediately.
+
+    \sa confirmCancels() confirmEdits() confirmUpdate() confirmInsert()
+*/
+
+bool Q3DataTable::confirmDelete() const
+{
+    return ( d->dat.confirmDelete() );
+}
+
+/*!
+    \property Q3DataTable::confirmCancels
+    \brief whether the data table confirms cancel operations
+
+    If the confirmCancel property is true, all cancels must be
+    confirmed by the user through a message box (this behavior can be
+    changed by overriding the confirmCancel() function), otherwise all
+    cancels occur immediately. The default is false.
+
+    \sa confirmEdits() confirmCancel()
+*/
+
+void Q3DataTable::setConfirmCancels( bool confirm )
+{
+    d->dat.setConfirmCancels( confirm );
+}
+
+bool Q3DataTable::confirmCancels() const
+{
+    return d->dat.confirmCancels();
+}
+
+/*!
+    \reimp
+
+    For an editable table, creates an editor suitable for the field in
+    column \a col. The editor is created using the default editor
+    factory, unless a different editor factory was installed with
+    installEditorFactory(). The editor is primed with the value of the
+    field in \a col using a property map. The property map used is the
+    default property map, unless a new property map was installed with
+    installPropertMap(). If \a initFromCell is true then the editor is
+    primed with the value in the Q3DataTable cell.
+*/
+
+QWidget * Q3DataTable::createEditor( int , int col, bool initFromCell ) const
+{
+    if ( d->dat.mode() == QSql::None )
+	return 0;
+
+    Q3SqlEditorFactory * f = (d->editorFactory == 0) ?
+		     Q3SqlEditorFactory::defaultFactory() : d->editorFactory;
+
+    Q3SqlPropertyMap * m = (d->propertyMap == 0) ?
+			  Q3SqlPropertyMap::defaultMap() : d->propertyMap;
+
+    QWidget * w = 0;
+    if( initFromCell && d->editBuffer ){
+	w = f->createEditor( viewport(), d->editBuffer->fieldPtr( indexOf( col ) ) );
+	if ( w )
+	    m->setProperty( w, d->editBuffer->value( indexOf( col ) ) );
+    }
+    return w;
+}
+
+/*! \reimp */
+bool Q3DataTable::eventFilter( QObject *o, QEvent *e )
+{
+    if ( d->cancelMode )
+	return true;
+
+    int r = currentRow();
+    int c = currentColumn();
+
+    if ( d->dat.mode() != QSql::None ) {
+	r = d->editRow;
+	c = d->editCol;
+    }
+
+    d->cancelInsert = false;
+    d->cancelUpdate = false;
+    switch ( e->type() ) {
+    case QEvent::KeyPress: {
+	int conf = QSql::Yes;
+	QKeyEvent *ke = (QKeyEvent*)e;
+	if ( ( ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_BackTab )
+	    && ke->state() & Qt::ControlButton )
+	    return false;
+
+	if ( ke->key() == Qt::Key_Escape && d->dat.mode() == QSql::Insert ){
+	    if ( confirmCancels() && !d->cancelMode ) {
+		d->cancelMode = true;
+		conf = confirmCancel( QSql::Insert );
+		d->cancelMode = false;
+	    }
+	    if ( conf == QSql::Yes ) {
+		d->cancelInsert = true;
+	    } else {
+		QWidget *editorWidget = cellWidget( r, c );
+		if ( editorWidget ) {
+		    editorWidget->setActiveWindow();
+		    editorWidget->setFocus();
+		}
+		return true;
+	    }
+	}
+	if ( ke->key() == Qt::Key_Escape && d->dat.mode() == QSql::Update ) {
+	    if ( confirmCancels() && !d->cancelMode ) {
+		d->cancelMode = true;
+		conf = confirmCancel( QSql::Update );
+		d->cancelMode = false;
+	    }
+	    if ( conf == QSql::Yes ){
+		d->cancelUpdate = true;
+	    } else {
+		QWidget *editorWidget = cellWidget( r, c );
+		if ( editorWidget ) {
+		    editorWidget->setActiveWindow();
+		    editorWidget->setFocus();
+		}
+		return true;
+	    }
+	}
+	if ( ke->key() == Qt::Key_Insert && d->dat.mode() == QSql::None ) {
+	    beginInsert();
+	    return true;
+	}
+	if ( ke->key() == Qt::Key_Delete && d->dat.mode() == QSql::None ) {
+	    deleteCurrent();
+	    return true;
+	}
+	if ( d->dat.mode() != QSql::None ) {
+	    if ( (ke->key() == Qt::Key_Tab) && (c < numCols() - 1) && (!isColumnReadOnly( c+1 ) || d->dat.mode() == QSql::Insert) )
+		d->continuousEdit = true;
+	    else if ( (ke->key() == Qt::Key_BackTab) && (c > 0) && (!isColumnReadOnly( c-1 ) || d->dat.mode() == QSql::Insert) )
+		d->continuousEdit = true;
+	    else
+		d->continuousEdit = false;
+	}
+	Q3SqlCursor * sql = sqlCursor();
+	if ( sql && sql->driver() &&
+	     !sql->driver()->hasFeature( QSqlDriver::QuerySize ) &&
+	     ke->key() == Qt::Key_End && d->dat.mode() == QSql::None ) {
+#ifndef QT_NO_CURSOR
+	    QApplication::setOverrideCursor( Qt::WaitCursor );
+#endif
+	    int i = sql->at();
+	    if ( i < 0 ) {
+		i = 0;
+		sql->seek(0);
+	    }
+	    while ( sql->next() )
+		i++;
+	    setNumRows( i+1 );
+	    setCurrentCell( i+1, currentColumn() );
+#ifndef QT_NO_CURSOR
+	    QApplication::restoreOverrideCursor();
+#endif
+	    return true;
+	}
+	break;
+    }
+    case QEvent::FocusOut: {
+	QWidget *editorWidget = cellWidget( r, c );
+	repaintCell( currentRow(), currentColumn() );
+	if ( !d->cancelMode && editorWidget && o == editorWidget &&
+	     ( d->dat.mode() == QSql::Insert) && !d->continuousEdit) {
+	    setCurrentCell( r, c );
+	    d->cancelInsert = true;
+	}
+	d->continuousEdit = false;
+	break;
+    }
+    case QEvent::FocusIn:
+	repaintCell( currentRow(), currentColumn() );
+	break;
+    default:
+	break;
+    }
+    return Q3Table::eventFilter( o, e );
+}
+
+/*! \reimp */
+void Q3DataTable::resizeEvent ( QResizeEvent * e )
+{
+    if ( sqlCursor() &&
+	 sqlCursor()->driver() &&
+	 !sqlCursor()->driver()->hasFeature( QSqlDriver::QuerySize ) )
+	loadNextPage();
+    Q3Table::resizeEvent( e );
+}
+
+/*! \reimp */
+void Q3DataTable::contentsContextMenuEvent( QContextMenuEvent* e )
+{
+    Q3Table::contentsContextMenuEvent( e );
+    if ( isEditing() && d->dat.mode() != QSql::None )
+	endEdit( d->editRow, d->editCol, autoEdit(), false );
+    if ( !sqlCursor() )
+	return;
+    if ( d->dat.mode() == QSql::None ) {
+	if ( isReadOnly() )
+	    return;
+	enum {
+	    IdInsert,
+	    IdUpdate,
+	    IdDelete
+	};
+	QPointer<Q3PopupMenu> popup = new Q3PopupMenu( this, "qt_datatable_menu" );
+	int id[ 3 ];
+	id[ IdInsert ] = popup->insertItem( tr( "Insert" ) );
+	id[ IdUpdate ] = popup->insertItem( tr( "Update" ) );
+	id[ IdDelete ] = popup->insertItem( tr( "Delete" ) );
+	bool enableInsert = sqlCursor()->canInsert();
+	popup->setItemEnabled( id[ IdInsert ], enableInsert );
+	bool enableUpdate = currentRow() > -1 && sqlCursor()->canUpdate() && !isColumnReadOnly( currentColumn() );
+	popup->setItemEnabled( id[ IdUpdate ], enableUpdate );
+	bool enableDelete = currentRow() > -1 && sqlCursor()->canDelete();
+	popup->setItemEnabled( id[ IdDelete ], enableDelete );
+	int r = popup->exec( e->globalPos() );
+	delete (Q3PopupMenu*) popup;
+	if ( r == id[ IdInsert ] )
+	    beginInsert();
+	else if ( r == id[ IdUpdate ] ) {
+	    if ( beginEdit( currentRow(), currentColumn(), false ) )
+		setEditMode( Editing, currentRow(), currentColumn() );
+	    else
+		endUpdate();
+	}
+	else if ( r == id[ IdDelete ] )
+	    deleteCurrent();
+	e->accept();
+    }
+}
+
+/*! \reimp */
+void Q3DataTable::contentsMousePressEvent( QMouseEvent* e )
+{
+    Q3Table::contentsMousePressEvent( e );
+}
+
+/*! \reimp */
+QWidget* Q3DataTable::beginEdit ( int row, int col, bool replace )
+{
+    d->editRow = -1;
+    d->editCol = -1;
+    if ( !sqlCursor() )
+	return 0;
+    if ( d->dat.mode() == QSql::Insert && !sqlCursor()->canInsert() )
+	return 0;
+    if ( d->dat.mode() == QSql::Update && !sqlCursor()->canUpdate() )
+	return 0;
+    d->editRow = row;
+    d->editCol = col;
+    if ( d->continuousEdit ) {
+	// see comment in beginInsert()
+	bool fakeReadOnly = isColumnReadOnly( col );
+	setColumnReadOnly( col, false );
+	QWidget* w = Q3Table::beginEdit( row, col, replace );
+	setColumnReadOnly( col, fakeReadOnly );
+	return w;
+    }
+    if ( d->dat.mode() == QSql::None && sqlCursor()->canUpdate() && sqlCursor()->primaryIndex().count() > 0 )
+	return beginUpdate( row, col, replace );
+    return 0;
+}
+
+/*! \reimp */
+void Q3DataTable::endEdit( int row, int col, bool, bool )
+{
+    bool accept = autoEdit() && !d->cancelInsert && !d->cancelUpdate;
+
+    QWidget *editor = cellWidget( row, col );
+    if ( !editor )
+	return;
+    if ( d->cancelMode )
+	return;
+    if ( d->dat.mode() != QSql::None && d->editBuffer ) {
+	Q3SqlPropertyMap * m = (d->propertyMap == 0) ?
+			      Q3SqlPropertyMap::defaultMap() : d->propertyMap;
+	d->editBuffer->setValue( indexOf( col ), m->property( editor ) );
+	clearCellWidget( row, col );
+	if ( !d->continuousEdit ) {
+	    switch ( d->dat.mode() ) {
+	    case QSql::Insert:
+		if ( accept )
+		    QTimer::singleShot( 0, this, SLOT(doInsertCurrent()) );
+		else
+		    endInsert();
+		break;
+	    case QSql::Update:
+		if ( accept )
+		    QTimer::singleShot( 0, this, SLOT(doUpdateCurrent()) );
+		else
+		    endUpdate();
+		break;
+	    default:
+		break;
+	    }
+	}
+    } else {
+	setEditMode( NotEditing, -1, -1 );
+    }
+    if ( d->dat.mode() == QSql::None )
+	viewport()->setFocus();
+    updateCell( row, col );
+    emit valueChanged( row, col );
+}
+
+/*! \internal */
+void Q3DataTable::doInsertCurrent()
+{
+    insertCurrent();
+}
+
+/*! \internal */
+void Q3DataTable::doUpdateCurrent()
+{
+    updateCurrent();
+    if ( d->dat.mode() == QSql::None ) {
+	viewport()->setFocus();
+    }
+}
+
+/*! \reimp */
+void Q3DataTable::activateNextCell()
+{
+//     if ( d->dat.mode() == QSql::None )
+//	Q3Table::activateNextCell();
+}
+
+/*! \internal
+*/
+
+void Q3DataTable::endInsert()
+{
+    if ( d->dat.mode() != QSql::Insert )
+	return;
+    d->dat.setMode( QSql::None );
+    d->editBuffer = 0;
+    verticalHeader()->setLabel( d->editRow, QString::number( d->editRow +1 ) );
+    d->editRow = -1;
+    d->editCol = -1;
+    d->insertRowLast = -1;
+    d->insertHeaderLabelLast.clear();
+    setEditMode( NotEditing, -1, -1 );
+    setNumRows( d->insertPreRows );
+    d->insertPreRows = -1;
+    viewport()->setFocus();
+}
+
+/*! \internal
+ */
+void Q3DataTable::endUpdate()
+{
+    d->dat.setMode( QSql::None );
+    d->editBuffer = 0;
+    updateRow( d->editRow );
+    d->editRow = -1;
+    d->editCol = -1;
+    setEditMode( NotEditing, -1, -1 );
+}
+
+/*!
+  Protected virtual function called when editing is about to begin
+  on a new record. If the table is read-only, or if there's no cursor
+  or the cursor does not allow inserts, nothing happens and false
+  is returned. Otherwise returns true.
+  
+  Editing takes place using the cursor's edit buffer(see
+  Q3SqlCursor::editBuffer()).
+  
+  When editing begins, a new row is created in the table marked with
+  an asterisk '*' in the row's vertical header column, i.e. at the
+  left of the row.
+*/
+bool Q3DataTable::beginInsert()
+{
+    if ( !sqlCursor() || isReadOnly() || !numCols() )
+	return false;
+    if ( !sqlCursor()->canInsert() )
+	return false;
+    int i = 0;
+    int row = currentRow();
+
+    d->insertPreRows = numRows();
+    if ( row < 0 || numRows() < 1 )
+	row = 0;
+    setNumRows( d->insertPreRows + 1 );
+    setCurrentCell( row, 0 );
+    d->editBuffer = sqlCursor()->primeInsert();
+    emit primeInsert( d->editBuffer );
+    d->dat.setMode( QSql::Insert );
+    int lastRow = row;
+    int lastY = contentsY() + visibleHeight();
+    for ( i = row; i < numRows() ; ++i ) {
+	QRect cg = cellGeometry( i, 0 );
+	if ( (cg.y()+cg.height()) > lastY ) {
+	    lastRow = i;
+	    break;
+	}
+    }
+    if ( lastRow == row && ( numRows()-1 > row ) )
+	lastRow = numRows() - 1;
+    d->insertRowLast = lastRow;
+    d->insertHeaderLabelLast = verticalHeader()->label( d->insertRowLast );
+    verticalHeader()->setLabel( row, QString(QLatin1Char('*')) );
+    d->editRow = row;
+    // in the db world it's common to allow inserting new records
+    // into a table that has read-only columns - temporarily
+    // switch off read-only mode for such columns
+    bool fakeReadOnly = isColumnReadOnly( 0 );
+    setColumnReadOnly( 0, false );
+    if ( Q3Table::beginEdit( row, 0, false ) )
+	setEditMode( Editing, row, 0 );
+    setColumnReadOnly( 0, fakeReadOnly );
+    return true;
+}
+
+/*!
+    Protected virtual function called when editing is about to begin
+    on an existing row. If the table is read-only, or if there's no
+    cursor, nothing happens.
+
+    Editing takes place using the cursor's edit buffer (see
+    Q3SqlCursor::editBuffer()).
+
+    \a row and \a col refer to the row and column in the Q3DataTable.
+
+    (\a replace is provided for reimplementors and reflects the API of
+    Q3Table::beginEdit().)
+*/
+
+QWidget* Q3DataTable::beginUpdate ( int row, int col, bool replace )
+{
+    if ( !sqlCursor() || isReadOnly() || isColumnReadOnly( col ) )
+	return 0;
+    setCurrentCell( row, col );
+    d->dat.setMode( QSql::Update );
+    if ( sqlCursor()->seek( row ) ) {
+	d->editBuffer = sqlCursor()->primeUpdate();
+	sqlCursor()->seek( currentRow() );
+	emit primeUpdate( d->editBuffer );
+	return Q3Table::beginEdit( row, col, replace );
+    }
+    return 0;
+}
+
+/*!
+    For an editable table, issues an insert on the current cursor
+    using the values in the cursor's edit buffer. If there is no
+    current cursor or there is no current "insert" row, nothing
+    happens. If confirmEdits() or confirmInsert() is true,
+    confirmEdit() is called to confirm the insert. Returns true if the
+    insert succeeded; otherwise returns false.
+
+    The underlying cursor must have a valid primary index to ensure
+    that a unique record is inserted within the database otherwise the
+    database may be changed to an inconsistent state.
+*/
+
+bool Q3DataTable::insertCurrent()
+{
+    if ( d->dat.mode() != QSql::Insert || ! numCols() )
+	return false;
+    if ( !sqlCursor()->canInsert() ) {
+#ifdef QT_CHECK_RANGE
+	qWarning("Q3DataTable::insertCurrent: insert not allowed for %s",
+		 sqlCursor()->name().latin1() );
+#endif
+	endInsert();
+	return false;
+    }
+    int b = 0;
+    int conf = QSql::Yes;
+    if ( confirmEdits() || confirmInsert() )
+	conf = confirmEdit( QSql::Insert );
+    switch ( conf ) {
+    case QSql::Yes: {
+#ifndef QT_NO_CURSOR
+	QApplication::setOverrideCursor( Qt::waitCursor );
+#endif
+	emit beforeInsert( d->editBuffer );
+	b = sqlCursor()->insert();
+#ifndef QT_NO_CURSOR
+	QApplication::restoreOverrideCursor();
+#endif
+	if ( ( !b && !sqlCursor()->isActive() ) || !sqlCursor()->isActive() ) {
+	    handleError( sqlCursor()->lastError() );
+	    endInsert(); // cancel the insert if anything goes wrong
+	    refresh();
+	} else {
+	    endInsert();
+	    refresh();
+	    QSqlIndex idx = sqlCursor()->primaryIndex();
+	    findBuffer( idx, d->lastAt );
+	    repaintContents( contentsX(), contentsY(), visibleWidth(), visibleHeight(), false );
+	    emit cursorChanged( QSql::Insert );
+	}
+	break;
+    }
+    case QSql::No:
+	endInsert();
+	break;
+    case QSql::Cancel:
+	if ( Q3Table::beginEdit( currentRow(), currentColumn(), false ) )
+	    setEditMode( Editing, currentRow(), currentColumn() );
+	break;
+    }
+    return ( b > 0 );
+}
+
+/*! \internal
+
+  Updates the row \a row.
+*/
+
+void Q3DataTable::updateRow( int row )
+{
+    for ( int i = 0; i < numCols(); ++i )
+	updateCell( row, i );
+}
+
+/*!
+    For an editable table, issues an update using the cursor's edit
+    buffer. If there is no current cursor or there is no current
+    selection, nothing happens. If confirmEdits() or confirmUpdate()
+    is true, confirmEdit() is called to confirm the update. Returns
+    true if the update succeeded; otherwise returns false.
+
+    The underlying cursor must have a valid primary index to ensure
+    that a unique record is updated within the database otherwise the
+    database may be changed to an inconsistent state.
+*/
+
+bool Q3DataTable::updateCurrent()
+{
+    if ( d->dat.mode() != QSql::Update )
+	return false;
+    if ( sqlCursor()->primaryIndex().count() == 0 ) {
+#ifdef QT_CHECK_RANGE
+	qWarning("Q3DataTable::updateCurrent: no primary index for %s",
+		 sqlCursor()->name().latin1() );
+#endif
+	endUpdate();
+	return false;
+    }
+    if ( !sqlCursor()->canUpdate() ) {
+#ifdef QT_CHECK_RANGE
+	qWarning("Q3DataTable::updateCurrent: updates not allowed for %s",
+		 sqlCursor()->name().latin1() );
+#endif
+	endUpdate();
+	return false;
+    }
+    int b = 0;
+    int conf = QSql::Yes;
+    if ( confirmEdits() || confirmUpdate() )
+	conf = confirmEdit( QSql::Update );
+    switch ( conf ) {
+    case QSql::Yes: {
+#ifndef QT_NO_CURSOR
+	QApplication::setOverrideCursor( Qt::waitCursor );
+#endif
+	emit beforeUpdate( d->editBuffer );
+	b = sqlCursor()->update();
+#ifndef QT_NO_CURSOR
+	QApplication::restoreOverrideCursor();
+#endif
+	if ( ( !b && !sqlCursor()->isActive() ) || !sqlCursor()->isActive() ) {
+	    handleError( sqlCursor()->lastError() );
+	    endUpdate();
+	    refresh();
+	    setCurrentCell( d->editRow, d->editCol );
+	    if ( Q3Table::beginEdit( d->editRow, d->editCol, false ) )
+		setEditMode( Editing, d->editRow, d->editCol );
+	} else {
+	    emit cursorChanged( QSql::Update );
+	    refresh();
+	    endUpdate();
+	}
+	break;
+    }
+    case QSql::No:
+	endUpdate();
+	setEditMode( NotEditing, -1, -1 );
+	break;
+    case QSql::Cancel:
+	setCurrentCell( d->editRow, d->editCol );
+	if ( Q3Table::beginEdit( d->editRow, d->editCol, false ) )
+	    setEditMode( Editing, d->editRow, d->editCol );
+	break;
+    }
+    return ( b > 0 );
+}
+
+/*!
+    For an editable table, issues a delete on the current cursor's
+    primary index using the values of the currently selected row. If
+    there is no current cursor or there is no current selection,
+    nothing happens. If confirmEdits() or confirmDelete() is true,
+    confirmEdit() is called to confirm the delete. Returns true if the
+    delete succeeded; otherwise false.
+
+    The underlying cursor must have a valid primary index to ensure
+    that a unique record is deleted within the database otherwise the
+    database may be changed to an inconsistent state.
+*/
+
+bool Q3DataTable::deleteCurrent()
+{
+    if ( !sqlCursor() || isReadOnly() )
+	return false;
+    if ( sqlCursor()->primaryIndex().count() == 0 ) {
+#ifdef QT_CHECK_RANGE
+	qWarning("Q3DataTable::deleteCurrent: no primary index %s",
+		 sqlCursor()->name().latin1() );
+#endif
+	return false;
+    }
+    if ( !sqlCursor()->canDelete() )
+	return false;
+
+    int b = 0;
+    int conf = QSql::Yes;
+    if ( confirmEdits() || confirmDelete() )
+	conf = confirmEdit( QSql::Delete );
+
+    // Have to have this here - the confirmEdit() might pop up a
+    // dialog that causes a repaint which the cursor to the
+    // record it has to repaint.
+    if ( !sqlCursor()->seek( currentRow() ) )
+	return false;
+    switch ( conf ) {
+	case QSql::Yes:{
+#ifndef QT_NO_CURSOR
+	    QApplication::setOverrideCursor( Qt::waitCursor );
+#endif
+	    sqlCursor()->primeDelete();
+	    emit primeDelete( sqlCursor()->editBuffer() );
+	    emit beforeDelete( sqlCursor()->editBuffer() );
+	    b = sqlCursor()->del();
+#ifndef QT_NO_CURSOR
+	    QApplication::restoreOverrideCursor();
+#endif
+	    if ( !b )
+		handleError( sqlCursor()->lastError() );
+	    refresh();
+	    emit cursorChanged( QSql::Delete );
+	    setCurrentCell( currentRow(), currentColumn() );
+	    repaintContents( contentsX(), contentsY(), visibleWidth(), visibleHeight(), false );
+	    verticalHeader()->repaint(); // get rid of trailing garbage
+	}
+	break;
+    case QSql::No:
+	setEditMode( NotEditing, -1, -1 );
+	break;
+    }
+    return ( b > 0 );
+}
+
+/*!
+    Protected virtual function which returns a confirmation for an
+    edit of mode \a m. Derived classes can reimplement this function
+    to provide their own confirmation dialog. The default
+    implementation uses a message box which prompts the user to
+    confirm the edit action.
+*/
+
+QSql::Confirm Q3DataTable::confirmEdit( QSql::Op m )
+{
+    return d->dat.confirmEdit( this, m );
+}
+
+/*!
+    Protected virtual function which returns a confirmation for
+    canceling an edit mode of \a m. Derived classes can reimplement
+    this function to provide their own cancel dialog. The default
+    implementation uses a message box which prompts the user to
+    confirm the cancel.
+*/
+
+QSql::Confirm  Q3DataTable::confirmCancel( QSql::Op m )
+{
+    return d->dat.confirmCancel( this, m );
+}
+
+
+/*!
+    Searches the current cursor for a cell containing the string \a
+    str starting at the current cell and working forwards (or
+    backwards if \a backwards is true). If the string is found, the
+    cell containing the string is set as the current cell. If \a
+    caseSensitive is false the case of \a str will be ignored.
+
+    The search will wrap, i.e. if the first (or if backwards is true,
+    last) cell is reached without finding \a str the search will
+    continue until it reaches the starting cell. If \a str is not
+    found the search will fail and the current cell will remain
+    unchanged.
+*/
+void Q3DataTable::find( const QString & str, bool caseSensitive, bool backwards )
+{
+    if ( !sqlCursor() )
+	return;
+
+    Q3SqlCursor * r = sqlCursor();
+    QString tmp, text;
+    uint  row = currentRow(), startRow = row,
+	  col = backwards ? currentColumn() - 1 : currentColumn() + 1;
+    bool  wrap = true, found = false;
+
+    if( str.isEmpty() || str.isNull() )
+	return;
+
+    if( !caseSensitive )
+	tmp = str.lower();
+    else
+	tmp = str;
+
+#ifndef QT_NO_CURSOR
+    QApplication::setOverrideCursor( Qt::waitCursor );
+#endif
+    while( wrap ){
+	while( !found && r->seek( row ) ){
+	    for( int i = col; backwards ? (i >= 0) : (i < (int) numCols());
+		 backwards ? i-- : i++ )
+	    {
+		text = r->value( indexOf( i ) ).toString();
+		if( !caseSensitive ){
+		    text = text.lower();
+		}
+		if( text.contains( tmp ) ){
+		    setCurrentCell( row, i );
+		    col = i;
+		    found = true;
+		}
+	    }
+	    if( !backwards ){
+		col = 0;
+		row++;
+	    } else {
+		col = numCols() - 1;
+		row--;
+	    }
+	}
+	if( !backwards ){
+	    if( startRow != 0 ){
+		startRow = 0;
+	    } else {
+		wrap = false;
+	    }
+	    r->first();
+	    row = 0;
+	} else {
+	    if( startRow != (uint) (numRows() - 1) ){
+		startRow = numRows() - 1;
+	    } else {
+		wrap = false;
+	    }
+	    r->last();
+	    row = numRows() - 1;
+	}
+    }
+#ifndef QT_NO_CURSOR
+    QApplication::restoreOverrideCursor();
+#endif
+}
+
+
+/*!
+    Resets the table so that it displays no data.
+
+    \sa setSqlCursor()
+*/
+
+void Q3DataTable::reset()
+{
+    clearCellWidget( currentRow(), currentColumn() );
+    switch ( d->dat.mode() ) {
+    case QSql::Insert:
+	endInsert();
+	break;
+    case QSql::Update:
+	endUpdate();
+	break;
+    default:
+	break;
+    }
+    ensureVisible( 0, 0 );
+    verticalScrollBar()->setValue(0);
+    setNumRows(0);
+
+    d->haveAllRows = false;
+    d->continuousEdit = false;
+    d->dat.setMode( QSql::None );
+    d->editRow = -1;
+    d->editCol = -1;
+    d->insertRowLast = -1;
+    d->insertHeaderLabelLast.clear();
+    d->cancelMode = false;
+    d->lastAt = -1;
+    d->fld.clear();
+    d->fldLabel.clear();
+    d->fldWidth.clear();
+    d->fldIcon.clear();
+    d->fldHidden.clear();
+    if ( sorting() )
+	horizontalHeader()->setSortIndicator( -1 );
+}
+
+/*!
+    Returns the index of the field within the current SQL query that
+    is displayed in column \a i.
+*/
+
+int Q3DataTable::indexOf( uint i ) const
+{
+    Q3DataTablePrivate::ColIndex::ConstIterator it = d->colIndex.at( i );
+    if ( it != d->colIndex.end() )
+	return *it;
+    return -1;
+}
+
+/*!
+    Returns true if the table will automatically delete the cursor
+    specified by setSqlCursor(); otherwise returns false.
+*/
+
+bool Q3DataTable::autoDelete() const
+{
+    return d->cur.autoDelete();
+}
+
+/*!
+    Sets the cursor auto-delete flag to \a enable. If \a enable is
+    true, the table will automatically delete the cursor specified by
+    setSqlCursor(). If \a enable is false (the default), the cursor
+    will not be deleted.
+*/
+
+void Q3DataTable::setAutoDelete( bool enable )
+{
+    d->cur.setAutoDelete( enable );
+}
+
+/*!
+    \property Q3DataTable::autoEdit
+    \brief whether the data table automatically applies edits
+
+    The default value for this property is true. When the user begins
+    an insert or update in the table there are two possible outcomes
+    when they navigate to another record:
+
+    \list 1
+    \i the insert or update is is performed -- this occurs if autoEdit is true
+    \i the insert or update is abandoned -- this occurs if autoEdit is false
+    \endlist
+*/
+
+void Q3DataTable::setAutoEdit( bool autoEdit )
+{
+    d->dat.setAutoEdit( autoEdit );
+}
+
+bool Q3DataTable::autoEdit() const
+{
+    return d->dat.autoEdit();
+}
+
+/*!
+    \property Q3DataTable::nullText
+    \brief the text used to represent NULL values
+
+    The nullText property will be used to represent NULL values in the
+    table. The default value is provided by the cursor's driver.
+*/
+
+void Q3DataTable::setNullText( const QString& nullText )
+{
+    d->nullTxt = nullText;
+    d->nullTxtChanged = true;
+}
+
+QString Q3DataTable::nullText() const
+{
+    return d->nullTxt;
+}
+
+/*!
+    \property Q3DataTable::trueText
+    \brief the text used to represent true values
+
+    The trueText property will be used to represent NULL values in the
+    table. The default value is "True".
+*/
+
+void Q3DataTable::setTrueText( const QString& trueText )
+{
+    d->trueTxt = trueText;
+}
+
+QString Q3DataTable::trueText() const
+{
+    return d->trueTxt;
+}
+
+/*!
+    \property Q3DataTable::falseText
+    \brief the text used to represent false values
+
+    The falseText property will be used to represent NULL values in
+    the table. The default value is "False".
+*/
+
+void Q3DataTable::setFalseText( const QString& falseText )
+{
+    d->falseTxt = falseText;
+}
+
+QString Q3DataTable::falseText() const
+{
+    return d->falseTxt;
+}
+
+/*!
+    \property Q3DataTable::dateFormat
+    \brief the format used for displaying date/time values
+
+    The dateFormat property is used for displaying date/time values in
+    the table. The default value is Qt::LocalDate.
+*/
+
+void Q3DataTable::setDateFormat( const Qt::DateFormat f )
+{
+    d->datefmt = f;
+}
+
+Qt::DateFormat Q3DataTable::dateFormat() const
+{
+    return d->datefmt;
+}
+
+/*!
+    \property Q3DataTable::numRows
+
+    \brief the number of rows in the table
+*/
+
+int Q3DataTable::numRows() const
+{
+    return Q3Table::numRows();
+}
+
+/*!
+    \reimp
+
+    The number of rows in the table will be determined by the cursor
+    (see setSqlCursor()), so normally this function should never be
+    called. It is included for completeness.
+*/
+
+void Q3DataTable::setNumRows ( int r )
+{
+    Q3Table::setNumRows( r );
+}
+
+/*!
+    \reimp
+
+    The number of columns in the table will be determined
+    automatically (see addColumn()), so normally this function should
+    never be called. It is included for completeness.
+*/
+
+void Q3DataTable::setNumCols ( int r )
+{
+    Q3Table::setNumCols( r );
+}
+
+/*!
+    \property Q3DataTable::numCols
+
+    \brief the number of columns in the table
+*/
+
+int Q3DataTable::numCols() const
+{
+    return Q3Table::numCols();
+}
+
+/*!
+    Returns the text in cell \a row, \a col, or an empty string if the
+    cell is empty. If the cell's value is NULL then nullText() will be
+    returned. If the cell does not exist then an empty string is
+    returned.
+*/
+
+QString Q3DataTable::text ( int row, int col ) const
+{
+    if ( !sqlCursor() )
+	return QString();
+
+    QString s;
+    if ( sqlCursor()->seek( row ) )
+	s = sqlCursor()->value( indexOf( col ) ).toString();
+    sqlCursor()->seek( currentRow() );
+    return s;
+}
+
+/*!
+    Returns the value in cell \a row, \a col, or an invalid value if
+    the cell does not exist or has no value.
+*/
+
+QVariant Q3DataTable::value ( int row, int col ) const
+{
+    if ( !sqlCursor() )
+	return QVariant();
+
+    QVariant v;
+    if ( sqlCursor()->seek( row ) )
+	v = sqlCursor()->value( indexOf( col ) );
+    sqlCursor()->seek( currentRow() );
+    return v;
+}
+
+/*!  \internal
+  Used to update the table when the size of the result set cannot be
+  determined - divide the result set into pages and load the pages as
+  the user moves around in the table.
+*/
+void Q3DataTable::loadNextPage()
+{
+    if ( d->haveAllRows )
+	return;
+    if ( !sqlCursor() )
+	return;
+    int pageSize = 0;
+    int lookAhead = 0;
+    if ( height() ) {
+	pageSize = (int)( height() * 2 / 20 );
+	lookAhead = pageSize / 2;
+    }
+    int startIdx = verticalScrollBar()->value() / 20;
+    int endIdx = startIdx + pageSize + lookAhead;
+    if ( endIdx < numRows() || endIdx < 0 )
+	return;
+
+    // check for empty result set
+    if ( sqlCursor()->at() == QSql::BeforeFirst && !sqlCursor()->next() ) {
+	d->haveAllRows = true;
+	return;
+    }
+
+    while ( endIdx > 0 && !sqlCursor()->seek( endIdx ) )
+	endIdx--;
+    if ( endIdx != ( startIdx + pageSize + lookAhead ) )
+	d->haveAllRows = true;
+    // small hack to prevent Q3Table from moving the view when a row
+    // is selected and the contents is resized
+    SelectionMode m = selectionMode();
+    clearSelection();
+    setSelectionMode( NoSelection );
+    setNumRows( endIdx ? endIdx + 1 : 0 );
+    sqlCursor()->seek( currentRow() );
+    setSelectionMode( m );
+}
+
+/*! \internal */
+void Q3DataTable::sliderPressed()
+{
+    disconnect( verticalScrollBar(), SIGNAL(valueChanged(int)),
+		this, SLOT(loadNextPage()) );
+}
+
+/*! \internal */
+void Q3DataTable::sliderReleased()
+{
+    loadNextPage();
+    connect( verticalScrollBar(), SIGNAL(valueChanged(int)),
+	     this, SLOT(loadNextPage()) );
+}
+
+/*!
+    Sorts column \a col in ascending order if \a ascending is true
+    (the default); otherwise sorts in descending order.
+
+    The \a wholeRows parameter is ignored; Q3DataTable always sorts
+    whole rows by the specified column.
+*/
+
+void Q3DataTable::sortColumn ( int col, bool ascending,
+			      bool  )
+{
+    if ( sorting() ) {
+	if ( isEditing() && d->dat.mode() != QSql::None )
+	    endEdit( d->editRow, d->editCol, autoEdit(), false );
+	if ( !sqlCursor() )
+	    return;
+	QSqlIndex lastSort = sqlCursor()->sort();
+	QSqlIndex newSort( lastSort.cursorName(), QLatin1String("newSort") );
+	const QSqlField *field = sqlCursor()->fieldPtr( indexOf( col ) );
+	if ( field )
+	    newSort.append( *field );
+	newSort.setDescending( 0, !ascending );
+	horizontalHeader()->setSortIndicator( col, ascending );
+	setSort( newSort );
+	refresh();
+    }
+}
+
+/*! \reimp */
+void Q3DataTable::columnClicked ( int col )
+{
+    if ( sorting() ) {
+	if ( !sqlCursor() )
+	    return;
+	QSqlIndex lastSort = sqlCursor()->sort();
+	bool asc = true;
+	if ( lastSort.count() && lastSort.fieldPtr( 0 )->name() == sqlCursor()->fieldPtr( indexOf( col ) )->name() )
+	    asc = lastSort.isDescending( 0 );
+	sortColumn( col, asc );
+	emit currentChanged( sqlCursor() );
+    }
+}
+
+/*!
+    Repaints the cell at \a row, \a col.
+*/
+void Q3DataTable::repaintCell( int row, int col )
+{
+    QRect cg = cellGeometry( row, col );
+    QRect re( QPoint( cg.x() - 2, cg.y() - 2 ),
+	      QSize( cg.width() + 4, cg.height() + 4 ) );
+    repaintContents( re, false );
+}
+
+/*!
+    \reimp
+
+    This function renders the cell at \a row, \a col with the value of
+    the corresponding cursor field on the painter \a p. Depending on
+    the table's current edit mode, paintField() is called for the
+    appropriate cursor field. \a cr describes the cell coordinates in
+    the content coordinate system. If \a selected is true the cell has
+    been selected and would normally be rendered differently than an
+    unselected cell.
+
+    \sa QSql::isNull()
+*/
+
+void Q3DataTable::paintCell( QPainter * p, int row, int col, const QRect & cr,
+			  bool selected, const QColorGroup &cg )
+{
+    Q3Table::paintCell( p, row, col, cr, selected, cg );  // empty cell
+
+    if ( !sqlCursor() )
+	return;
+
+    p->setPen( selected ? cg.highlightedText() : cg.text() );
+    if ( d->dat.mode() != QSql::None ) {
+	if ( row == d->editRow && d->editBuffer ) {
+	    paintField( p, d->editBuffer->fieldPtr( indexOf( col ) ), cr,
+			selected );
+	} else if ( row > d->editRow && d->dat.mode() == QSql::Insert ) {
+	    if ( sqlCursor()->seek( row - 1 ) )
+		paintField( p, sqlCursor()->fieldPtr( indexOf( col ) ), cr,
+			    selected );
+	} else {
+	    if ( sqlCursor()->seek( row ) )
+		paintField( p, sqlCursor()->fieldPtr( indexOf( col ) ), cr,
+			    selected );
+	}
+    } else {
+	if ( sqlCursor()->seek( row ) )
+		paintField( p, sqlCursor()->fieldPtr( indexOf( col ) ), cr, selected );
+
+    }
+}
+
+
+/*!
+    Paints the \a field on the painter \a p. The painter has already
+    been translated to the appropriate cell's origin where the \a
+    field is to be rendered. \a cr describes the cell coordinates in
+    the content coordinate system. The \a selected parameter is
+    ignored.
+
+    If you want to draw custom field content you must reimplement
+    paintField() to do the custom drawing. The default implementation
+    renders the \a field value as text. If the field is NULL,
+    nullText() is displayed in the cell. If the field is Boolean,
+    trueText() or falseText() is displayed as appropriate.
+*/
+
+void Q3DataTable::paintField( QPainter * p, const QSqlField* field,
+			    const QRect & cr, bool )
+{
+    if ( !field )
+	return;
+    p->drawText( 2,2, cr.width()-4, cr.height()-4, fieldAlignment( field ), fieldToString( field ) );
+}
+
+/*!
+    Returns the alignment for \a field.
+*/
+
+int Q3DataTable::fieldAlignment( const QSqlField* /*field*/ )
+{
+    return Qt::AlignLeft | Qt::AlignVCenter; //## Reggie: add alignment to Q3Table
+}
+
+
+/*!
+    If the cursor's \a sql driver supports query sizes, the number of
+    rows in the table is set to the size of the query. Otherwise, the
+    table dynamically resizes itself as it is scrolled. If \a sql is
+    not active, it is made active by issuing a select() on the cursor
+    using the \a sql cursor's current filter and current sort.
+*/
+
+void Q3DataTable::setSize( Q3SqlCursor* sql )
+{
+    // ### what are the connect/disconnect calls doing here!? move to refresh()
+    if ( sql->driver() && sql->driver()->hasFeature( QSqlDriver::QuerySize ) ) {
+	setVScrollBarMode( Auto );
+ 	disconnect( verticalScrollBar(), SIGNAL(sliderPressed()),
+		    this, SLOT(sliderPressed()) );
+ 	disconnect( verticalScrollBar(), SIGNAL(sliderReleased()),
+		    this, SLOT(sliderReleased()) );
+	disconnect( verticalScrollBar(), SIGNAL(valueChanged(int)),
+		    this, SLOT(loadNextPage()) );
+	if ( numRows() != sql->size() )
+	    setNumRows( sql->size() );
+    } else {
+	setVScrollBarMode( AlwaysOn );
+ 	connect( verticalScrollBar(), SIGNAL(sliderPressed()),
+ 		 this, SLOT(sliderPressed()) );
+ 	connect( verticalScrollBar(), SIGNAL(sliderReleased()),
+ 		 this, SLOT(sliderReleased()) );
+	connect( verticalScrollBar(), SIGNAL(valueChanged(int)),
+		 this, SLOT(loadNextPage()) );
+	setNumRows(0);
+	loadNextPage();
+    }
+}
+
+/*!
+    Sets \a cursor as the data source for the table. To force the
+    display of the data from \a cursor, use refresh(). If \a
+    autoPopulate is true, columns are automatically created based upon
+    the fields in the \a cursor record. If \a autoDelete is true (the
+    default is false), the table will take ownership of the \a cursor
+    and delete it when appropriate. If the \a cursor is read-only, the
+    table becomes read-only. The table adopts the cursor's driver's
+    definition for representing NULL values as strings.
+
+    \sa refresh() setReadOnly() setAutoDelete() QSqlDriver::nullText()
+*/
+
+void Q3DataTable::setSqlCursor( Q3SqlCursor* cursor, bool autoPopulate, bool autoDelete )
+{
+    setUpdatesEnabled( false );
+    d->cur.setCursor( 0 );
+    if ( cursor ) {
+	d->cur.setCursor( cursor, autoDelete );
+	if ( autoPopulate ) {
+	    d->fld.clear();
+	    d->fldLabel.clear();
+	    d->fldWidth.clear();
+	    d->fldIcon.clear();
+	    d->fldHidden.clear();
+	    for ( int i = 0; i < sqlCursor()->count(); ++i ) {
+		addColumn( sqlCursor()->fieldPtr( i )->name(), sqlCursor()->fieldPtr( i )->name() );
+		setColumnReadOnly( i, sqlCursor()->fieldPtr( i )->isReadOnly() );
+	    }
+	}
+	setReadOnly( sqlCursor()->isReadOnly() );
+	if ( sqlCursor()->driver() && !d->nullTxtChanged )
+	    setNullText(sqlCursor()->driver()->nullText() );
+	setAutoDelete( autoDelete );
+    } else {
+	setNumRows( 0 );
+	setNumCols( 0 );
+    }
+    setUpdatesEnabled( true );
+}
+
+
+/*!
+    Protected virtual function which is called when an error \a e has
+    occurred on the current cursor(). The default implementation
+    displays a warning message to the user with information about the
+    error.
+*/
+void Q3DataTable::handleError( const QSqlError& e )
+{
+    d->dat.handleError( this, e );
+}
+
+/*! \reimp
+  */
+
+void Q3DataTable::keyPressEvent( QKeyEvent* e )
+{
+    switch( e->key() ) {
+    case Qt::Key_Left:
+    case Qt::Key_Right:
+    case Qt::Key_Up:
+    case Qt::Key_Down:
+    case Qt::Key_Prior:
+    case Qt::Key_Next:
+    case Qt::Key_Home:
+    case Qt::Key_End:
+    case Qt::Key_F2:
+    case Qt::Key_Enter: case Qt::Key_Return:
+    case Qt::Key_Tab: case Qt::Key_BackTab:
+	Q3Table::keyPressEvent( e );
+    default:
+	return;
+    }
+}
+
+/*!  \reimp
+*/
+
+void Q3DataTable::resizeData ( int )
+{
+
+}
+
+/*!  \reimp
+*/
+
+Q3TableItem * Q3DataTable::item ( int, int ) const
+{
+    return 0;
+}
+
+/*!  \reimp
+*/
+
+void Q3DataTable::setItem ( int , int , Q3TableItem * )
+{
+
+}
+
+/*!  \reimp
+*/
+
+void Q3DataTable::clearCell ( int , int )
+{
+
+}
+
+/*!  \reimp
+*/
+
+void Q3DataTable::setPixmap ( int , int , const QPixmap &  )
+{
+
+}
+
+/*! \reimp */
+void Q3DataTable::takeItem ( Q3TableItem * )
+{
+
+}
+
+/*!
+    Installs a new SQL editor factory \a f. This enables the user to
+    create and instantiate their own editors for use in cell editing.
+    Note that Q3DataTable takes ownership of this pointer, and will
+    delete it when it is no longer needed or when
+    installEditorFactory() is called again.
+
+    \sa Q3SqlEditorFactory
+*/
+
+void Q3DataTable::installEditorFactory( Q3SqlEditorFactory * f )
+{
+    if( f ) {
+	delete d->editorFactory;
+	d->editorFactory = f;
+    }
+}
+
+/*!
+    Installs a new property map \a m. This enables the user to create
+    and instantiate their own property maps for use in cell editing.
+    Note that Q3DataTable takes ownership of this pointer, and will
+    delete it when it is no longer needed or when installPropertMap()
+    is called again.
+
+    \sa Q3SqlPropertyMap
+*/
+
+void Q3DataTable::installPropertyMap( Q3SqlPropertyMap* m )
+{
+    if ( m ) {
+	delete d->propertyMap;
+	d->propertyMap = m;
+    }
+}
+
+/*!  \internal
+
+  Sets the current selection to \a row, \a col.
+*/
+
+void Q3DataTable::setCurrentSelection( int row, int )
+{
+    if ( !sqlCursor() )
+	return;
+    if ( row == d->lastAt )
+	return;
+    if ( !sqlCursor()->seek( row ) )
+	return;
+    d->lastAt = row;
+    emit currentChanged( sqlCursor() );
+}
+
+void Q3DataTable::updateCurrentSelection()
+{
+    setCurrentSelection( currentRow(), -1 );
+}
+
+/*!
+    Returns the currently selected record, or 0 if there is no current
+    selection. The table owns the pointer, so do \e not delete it or
+    otherwise modify it or the cursor it points to.
+*/
+
+QSqlRecord* Q3DataTable::currentRecord() const
+{
+    if ( !sqlCursor() || currentRow() < 0 )
+	return 0;
+    if ( !sqlCursor()->seek( currentRow() ) )
+	return 0;
+    return sqlCursor();
+}
+
+/*!
+    Sorts column \a col in ascending order.
+
+    \sa setSorting()
+*/
+
+void Q3DataTable::sortAscending( int col )
+{
+    sortColumn( col, true );
+}
+
+/*!
+    Sorts column \a col in descending order.
+
+    \sa setSorting()
+*/
+
+void Q3DataTable::sortDescending( int col )
+{
+    sortColumn( col, false );
+}
+
+/*!
+    \fn void Q3DataTable::refresh( Refresh mode )
+
+    Refreshes the table. If there is no currently defined cursor (see
+    setSqlCursor()), nothing happens. The \a mode parameter determines
+    which type of refresh will take place.
+
+    \sa Refresh setSqlCursor() addColumn()
+*/
+
+void Q3DataTable::refresh( Q3DataTable::Refresh mode )
+{
+    Q3SqlCursor* cur = sqlCursor();
+    if ( !cur )
+	return;
+    bool refreshData = ( (mode & RefreshData) == RefreshData );
+    bool refreshCol = ( (mode & RefreshColumns) == RefreshColumns );
+    if ( ( (mode & RefreshAll) == RefreshAll ) ) {
+	refreshData = true;
+	refreshCol = true;
+    }
+    if ( !refreshCol && d->fld.count() && numCols() == 0 )
+	refreshCol = true;
+    viewport()->setUpdatesEnabled( false );
+    d->haveAllRows = false;
+    if ( refreshData ) {
+	if ( !d->cur.refresh() && d->cur.cursor() ) {
+	    handleError( d->cur.cursor()->lastError() );
+	}
+	d->lastAt = -1;
+    }
+    if ( refreshCol ) {
+	setNumCols( 0 );
+	d->colIndex.clear();
+	if ( d->fld.count() ) {
+	    const QSqlField* field = 0;
+	    int i;
+	    int fpos = -1;
+	    for ( i = 0; i < (int)d->fld.count(); ++i ) {
+		if ( cur->fieldPtr( i ) && cur->fieldPtr( i )->name() == d->fld[ i ] )
+		    // if there is a field with the desired name on the desired position
+		    // then we take that
+		    fpos = i;
+		else
+		    // otherwise we take the first field that matches the desired name
+		    fpos = cur->position( d->fld[ i ] );
+		field = cur->fieldPtr( fpos );
+		if ( field && ( cur->isGenerated( fpos ) ||
+				cur->isCalculated( field->name() ) ) )
+		{
+		    setNumCols( numCols() + 1 );
+		    d->colIndex.append( fpos );
+		    setColumnReadOnly( numCols()-1, field->isReadOnly() || isColumnReadOnly( numCols()-1 ) );
+		    horizontalHeader()->setLabel( numCols()-1, d->fldIcon[ i ], d->fldLabel[ i ] );
+		    if ( d->fldHidden[ i ] ) {
+			Q3Table::showColumn( i ); // ugly but necessary
+			Q3Table::hideColumn( i );
+		    } else {
+			Q3Table::showColumn( i );
+		    }
+		    if ( d->fldWidth[ i ] > -1 )
+			Q3Table::setColumnWidth( i, d->fldWidth[i] );
+		}
+	    }
+	}
+    }
+    viewport()->setUpdatesEnabled( true );
+    viewport()->repaint( false );
+    horizontalHeader()->repaint();
+    verticalHeader()->repaint();
+    setSize( cur );
+    // keep others aware
+    if ( d->lastAt == -1 )
+ 	setCurrentSelection( -1, -1 );
+    else if ( d->lastAt != currentRow() )
+	setCurrentSelection( currentRow(), currentColumn() );
+    if ( cur->isValid() )
+	emit currentChanged( sqlCursor() );
+}
+
+/*!
+    Refreshes the table. The cursor is refreshed using the current
+    filter, the current sort, and the currently defined columns.
+    Equivalent to calling refresh( Q3DataTable::RefreshData ).
+*/
+
+void Q3DataTable::refresh()
+{
+    refresh( RefreshData );
+}
+
+/*!
+    \internal
+
+    Selects the record in the table using the current cursor edit
+    buffer and the fields specified by the index \a idx. If \a atHint
+    is specified, it will be used as a hint about where to begin
+    searching.
+*/
+
+bool Q3DataTable::findBuffer( const QSqlIndex& idx, int atHint )
+{
+    Q3SqlCursor* cur = sqlCursor();
+    if ( !cur )
+	return false;
+    bool found = d->cur.findBuffer( idx, atHint );
+    if ( found )
+	setCurrentCell( cur->at(), currentColumn() );
+    return found;
+}
+
+/*! \internal
+    Returns the string representation of a database field.
+*/
+QString Q3DataTable::fieldToString( const QSqlField * field )
+{
+    QString text;
+    if ( field->isNull() ) {
+	text = nullText();
+    } else {
+	QVariant val = field->value();
+	switch ( val.type() ) {
+	    case QVariant::Bool:
+		text = val.toBool() ? d->trueTxt : d->falseTxt;
+		break;
+	    case QVariant::Date:
+		text = val.toDate().toString( d->datefmt );
+		break;
+	    case QVariant::Time:
+		text = val.toTime().toString( d->datefmt );
+		break;
+	    case QVariant::DateTime:
+		text = val.toDateTime().toString( d->datefmt );
+		break;
+	    default:
+		text = val.toString();
+		break;
+	}
+    }
+    return text;
+}
+
+/*!
+    \reimp
+*/
+
+void Q3DataTable::swapColumns( int col1, int col2, bool )
+{
+    QString fld = d->fld[ col1 ];
+    QString fldLabel = d->fldLabel[ col1 ];
+    QIconSet fldIcon = d->fldIcon[ col1 ];
+    int fldWidth = d->fldWidth[ col1 ];
+
+    d->fld[ col1 ] = d->fld[ col2 ];
+    d->fldLabel[ col1 ] = d->fldLabel[ col2 ];
+    d->fldIcon[ col1 ] = d->fldIcon[ col2 ];
+    d->fldWidth[ col1 ] = d->fldWidth[ col2 ];
+
+    d->fld[ col2 ] = fld;
+    d->fldLabel[ col2 ] = fldLabel;
+    d->fldIcon[ col2 ] = fldIcon;
+    d->fldWidth[ col2 ] = fldWidth;
+
+    int colIndex = d->colIndex[ col1 ];
+    d->colIndex[ col1 ] = d->colIndex[ col2 ];
+    d->colIndex[ col2 ] = colIndex;
+}
+
+/*!
+    \reimp
+*/
+
+void Q3DataTable::drawContents( QPainter * p, int cx, int cy, int cw, int ch )
+{
+    Q3Table::drawContents( p, cx, cy, cw, ch );
+    if ( sqlCursor() && currentRow() >= 0 )
+	sqlCursor()->seek( currentRow() );
+}
+
+/*!
+    \reimp
+ */
+void Q3DataTable::drawContents(QPainter *)
+{
+}
+
+/*!
+    \reimp
+*/
+
+void Q3DataTable::hideColumn( int col )
+{
+    d->fldHidden[col] = true;
+    refresh( RefreshColumns );
+}
+
+/*!
+    \reimp
+*/
+
+void Q3DataTable::showColumn( int col )
+{
+    d->fldHidden[col] = false;
+    refresh( RefreshColumns );
+}
+
+/*!
+  \reimp
+*/
+void  Q3DataTable::selectRow(int row)
+{
+    setCurrentCell(row, currentColumn());
+}
+
+/*!
+    \fn void Q3DataTable::currentChanged( QSqlRecord* record )
+
+    This signal is emitted whenever a new row is selected in the
+    table. The \a record parameter points to the contents of the newly
+    selected record.
+*/
+
+/*!
+    \fn void Q3DataTable::primeInsert( QSqlRecord* buf )
+
+    This signal is emitted after the cursor is primed for insert by
+    the table, when an insert action is beginning on the table. The \a
+    buf parameter points to the edit buffer being inserted. Connect to
+    this signal in order to, for example, prime the record buffer with
+    default data values.
+*/
+
+/*!
+    \fn void Q3DataTable::primeUpdate( QSqlRecord* buf )
+
+    This signal is emitted after the cursor is primed for update by
+    the table, when an update action is beginning on the table. The \a
+    buf parameter points to the edit buffer being updated. Connect to
+    this signal in order to, for example, provide some visual feedback
+    that the user is in 'edit mode'.
+*/
+
+/*!
+    \fn void Q3DataTable::primeDelete( QSqlRecord* buf )
+
+    This signal is emitted after the cursor is primed for delete by
+    the table, when a delete action is beginning on the table. The \a
+    buf parameter points to the edit buffer being deleted. Connect to
+    this signal in order to, for example, record auditing information
+    on deletions.
+*/
+
+/*!
+    \fn void Q3DataTable::beforeInsert( QSqlRecord* buf )
+
+    This signal is emitted just before the cursor's edit buffer is
+    inserted into the database. The \a buf parameter points to the
+    edit buffer being inserted. Connect to this signal to, for
+    example, populate a key field with a unique sequence number.
+*/
+
+/*!
+    \fn void Q3DataTable::beforeUpdate( QSqlRecord* buf )
+
+    This signal is emitted just before the cursor's edit buffer is
+    updated in the database. The \a buf parameter points to the edit
+    buffer being updated. Connect to this signal when you want to
+    transform the user's data behind-the-scenes.
+*/
+
+/*!
+    \fn void Q3DataTable::beforeDelete( QSqlRecord* buf )
+
+    This signal is emitted just before the currently selected record
+    is deleted from the database. The \a buf parameter points to the
+    edit buffer being deleted. Connect to this signal to, for example,
+    copy some of the fields for later use.
+*/
+
+/*!
+    \fn void Q3DataTable::cursorChanged( QSql::Op mode )
+
+    This signal is emitted whenever the cursor record was changed due
+    to an edit. The \a mode parameter is the type of edit that just
+    took place.
+*/
+
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/qt3support/sql/q3datatable.h b/src/qt3support/sql/q3datatable.h
new file mode 100644
index 0000000..bbfd01c
--- /dev/null
+++ b/src/qt3support/sql/q3datatable.h
@@ -0,0 +1,251 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3DATATABLE_H
+#define Q3DATATABLE_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qvariant.h>
+#include <Qt3Support/q3table.h>
+#include <QtSql/qsql.h>
+#include <Qt3Support/q3sqlcursor.h>
+#include <QtSql/qsqlindex.h>
+#include <Qt3Support/q3sqleditorfactory.h>
+#include <Qt3Support/qiconset.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_VIEW_WIDGETS
+
+class QPainter;
+class QSqlField;
+class Q3SqlPropertyMap;
+class Q3DataTablePrivate;
+
+class Q_COMPAT_EXPORT Q3DataTable : public Q3Table
+{
+    Q_OBJECT
+
+    Q_PROPERTY( QString nullText READ nullText WRITE setNullText )
+    Q_PROPERTY( QString trueText READ trueText WRITE setTrueText )
+    Q_PROPERTY( QString falseText READ falseText WRITE setFalseText )
+    Q_PROPERTY( Qt::DateFormat dateFormat READ dateFormat WRITE setDateFormat )
+    Q_PROPERTY( bool confirmEdits READ confirmEdits WRITE setConfirmEdits )
+    Q_PROPERTY( bool confirmInsert READ confirmInsert WRITE setConfirmInsert )
+    Q_PROPERTY( bool confirmUpdate READ confirmUpdate WRITE setConfirmUpdate )
+    Q_PROPERTY( bool confirmDelete READ confirmDelete WRITE setConfirmDelete )
+    Q_PROPERTY( bool confirmCancels READ confirmCancels WRITE setConfirmCancels )
+    Q_PROPERTY( bool autoEdit READ autoEdit WRITE setAutoEdit )
+    Q_PROPERTY( QString filter READ filter WRITE setFilter )
+    Q_PROPERTY( QStringList sort READ sort WRITE setSort )
+    Q_PROPERTY( int numCols READ numCols )
+    Q_PROPERTY( int numRows READ numRows )
+
+public:
+    Q3DataTable ( QWidget* parent=0, const char* name=0 );
+    Q3DataTable ( Q3SqlCursor* cursor, bool autoPopulate = false, QWidget* parent=0, const char* name=0 );
+    ~Q3DataTable();
+
+    virtual void addColumn( const QString& fieldName,
+			    const QString& label = QString(),
+			    int width = -1,
+			    const QIconSet& iconset = QIconSet() );
+    virtual void removeColumn( int col );
+    virtual void setColumn( uint col, const QString& fieldName,
+			    const QString& label = QString(),
+			    int width = -1,
+			    const QIconSet& iconset = QIconSet() );
+
+    QString      nullText() const;
+    QString      trueText() const;
+    QString      falseText() const;
+    Qt::DateFormat dateFormat() const;
+    bool         confirmEdits() const;
+    bool         confirmInsert() const;
+    bool         confirmUpdate() const;
+    bool         confirmDelete() const;
+    bool         confirmCancels() const;
+    bool         autoDelete() const;
+    bool         autoEdit() const;
+    QString      filter() const;
+    QStringList  sort() const;
+
+    virtual void setSqlCursor( Q3SqlCursor* cursor = 0,
+			    bool autoPopulate = false, bool autoDelete = false );
+    Q3SqlCursor* sqlCursor() const;
+
+    virtual void setNullText( const QString& nullText );
+    virtual void setTrueText( const QString& trueText );
+    virtual void setFalseText( const QString& falseText );
+    virtual void setDateFormat( const Qt::DateFormat f );
+    virtual void setConfirmEdits( bool confirm );
+    virtual void setConfirmInsert( bool confirm );
+    virtual void setConfirmUpdate( bool confirm );
+    virtual void setConfirmDelete( bool confirm );
+    virtual void setConfirmCancels( bool confirm );
+    virtual void setAutoDelete( bool enable );
+    virtual void setAutoEdit( bool autoEdit );
+    virtual void setFilter( const QString& filter );
+    virtual void setSort( const QStringList& sort );
+    virtual void setSort( const QSqlIndex& sort );
+
+    enum Refresh {
+	RefreshData = 1,
+	RefreshColumns = 2,
+	RefreshAll = 3
+    };
+    void         refresh( Refresh mode );
+    void         sortColumn ( int col, bool ascending = true,
+			      bool wholeRows = false );
+    QString      text ( int row, int col ) const;
+    QVariant     value ( int row, int col ) const;
+    QSqlRecord*  currentRecord() const;
+
+    void         installEditorFactory( Q3SqlEditorFactory * f );
+    void         installPropertyMap( Q3SqlPropertyMap* m );
+
+    int          numCols() const;
+    int          numRows() const;
+    void         setNumCols( int c );
+    void         setNumRows ( int r );
+    bool         findBuffer( const QSqlIndex& idx, int atHint = 0 );
+
+    void	 hideColumn( int col );
+    void	 showColumn( int col );
+    int          indexOf( uint i ) const;
+    void selectRow(int row);
+
+Q_SIGNALS:
+    void         currentChanged( QSqlRecord* record );
+    void         primeInsert( QSqlRecord* buf );
+    void         primeUpdate( QSqlRecord* buf );
+    void         primeDelete( QSqlRecord* buf );
+    void         beforeInsert( QSqlRecord* buf );
+    void         beforeUpdate( QSqlRecord* buf );
+    void         beforeDelete( QSqlRecord* buf );
+    void         cursorChanged( QSql::Op mode );
+
+public Q_SLOTS:
+    virtual void find( const QString & str, bool caseSensitive,
+			     bool backwards );
+    virtual void sortAscending( int col );
+    virtual void sortDescending( int col );
+    virtual void refresh();
+    void setColumnWidth( int col, int w );
+    void adjustColumn( int col );
+    void setColumnStretchable( int col, bool stretch );
+    void swapColumns( int col1, int col2, bool swapHeaders = false );
+
+protected:
+    virtual bool insertCurrent();
+    virtual bool updateCurrent();
+    virtual bool deleteCurrent();
+
+    virtual QSql::Confirm confirmEdit( QSql::Op m );
+    virtual QSql::Confirm confirmCancel( QSql::Op m );
+
+    virtual void handleError( const QSqlError& e );
+
+    virtual bool beginInsert();
+    virtual QWidget* beginUpdate ( int row, int col, bool replace );
+
+    bool         eventFilter( QObject *o, QEvent *e );
+    void         keyPressEvent( QKeyEvent* );
+    void         resizeEvent ( QResizeEvent * );
+    void         contentsMousePressEvent( QMouseEvent* e );
+    void         contentsContextMenuEvent( QContextMenuEvent* e );
+    void         endEdit( int row, int col, bool accept, bool replace );
+    QWidget *    createEditor( int row, int col, bool initFromCell ) const;
+    void         activateNextCell();
+    void         reset();
+    void         setSize( Q3SqlCursor* sql );
+    void         repaintCell( int row, int col );
+    void         paintCell ( QPainter * p, int row, int col, const QRect & cr,
+			     bool selected, const QColorGroup &cg );
+    virtual void paintField( QPainter * p, const QSqlField* field, const QRect & cr,
+			     bool selected );
+    void	 drawContents( QPainter * p, int cx, int cy, int cw, int ch );
+    virtual int  fieldAlignment( const QSqlField* field );
+    void         columnClicked ( int col );
+    void         resizeData ( int len );
+
+    Q3TableItem * item ( int row, int col ) const;
+    void         setItem ( int row, int col, Q3TableItem * item );
+    void         clearCell ( int row, int col ) ;
+    void         setPixmap ( int row, int col, const QPixmap & pix );
+    void         takeItem ( Q3TableItem * i );
+
+private Q_SLOTS:
+    void         loadNextPage();
+    void         setCurrentSelection( int row, int col );
+    void         updateCurrentSelection();
+    void	 sliderPressed();
+    void	 sliderReleased();
+    void	 doInsertCurrent();
+    void	 doUpdateCurrent();
+
+private:
+    void         drawContents( QPainter *p);
+    QString	 fieldToString( const QSqlField * field );
+    void         init();
+    QWidget*     beginEdit ( int row, int col, bool replace );
+    void         updateRow( int row );
+    void         endInsert();
+    void         endUpdate();
+    Q3DataTablePrivate* d;
+
+#if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator=
+    Q3DataTable( const Q3DataTable & );
+    Q3DataTable &operator=( const Q3DataTable & );
+#endif
+};
+
+#endif // QT_NO_SQL_VIEW_WIDGETS
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3DATATABLE_H
diff --git a/src/qt3support/sql/q3dataview.cpp b/src/qt3support/sql/q3dataview.cpp
new file mode 100644
index 0000000..fb44996
--- /dev/null
+++ b/src/qt3support/sql/q3dataview.cpp
@@ -0,0 +1,208 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3dataview.h"
+
+#ifndef QT_NO_SQL_VIEW_WIDGETS
+
+#include "private/q3sqlmanager_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q3DataViewPrivate
+{
+public:
+    Q3DataViewPrivate() {}
+    Q3SqlFormManager frm;
+};
+
+
+/*!
+    \class Q3DataView
+    \brief The Q3DataView class provides read-only SQL forms.
+
+    \compat
+
+    This class provides a form which displays SQL field data from a
+    record buffer. Because Q3DataView does not support editing it uses
+    less resources than a Q3DataBrowser. This class is well suited for
+    displaying read-only data from a SQL database.
+
+    If you want a to present your data in an editable form use
+    Q3DataBrowser; if you want a table-based presentation of your data
+    use Q3DataTable.
+
+    The form is associated with the data view with setForm() and the
+    record is associated with setRecord(). You can also pass a
+    QSqlRecord to the refresh() function which will set the record to
+    the given record and read the record's fields into the form.
+*/
+
+/*!
+    Constructs a data view which is a child of \a parent, called \a
+    name, and with widget flags \a fl.
+*/
+
+Q3DataView::Q3DataView(QWidget *parent, const char *name, Qt::WindowFlags fl)
+    : QWidget(parent, name, fl)
+{
+    d = new Q3DataViewPrivate();
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+Q3DataView::~Q3DataView()
+{
+    delete d;
+}
+
+/*!
+    Clears the default form's values. If there is no default form,
+    nothing happens. All the values are set to their 'zero state',
+    e.g. 0 for numeric fields, "" for string fields.
+*/
+
+void Q3DataView::clearValues()
+{
+    d->frm.clearValues();
+}
+
+/*!
+    Sets the form used by the data view to \a form. If a record has
+    already been assigned to the data view, the form will display that
+    record's data.
+
+    \sa form()
+*/
+
+void Q3DataView::setForm(Q3SqlForm* form)
+{
+    d->frm.setForm(form);
+}
+
+
+/*!
+    Returns the default form used by the data view, or 0 if there is
+    none.
+
+    \sa setForm()
+*/
+
+Q3SqlForm* Q3DataView::form()
+{
+    return d->frm.form();
+}
+
+
+/*!
+    Sets the record used by the data view to \a record. If a form has
+    already been assigned to the data view, the form will display the
+    data from \a record in that form.
+
+    \sa record()
+*/
+
+void Q3DataView::setRecord(QSqlRecord* record)
+{
+    d->frm.setRecord(record);
+}
+
+
+/*!
+    Returns the default record used by the data view, or 0 if there is
+    none.
+
+    \sa setRecord()
+*/
+
+QSqlRecord* Q3DataView::record()
+{
+    return d->frm.record();
+}
+
+
+/*!
+    Causes the default form to read its fields from the record buffer.
+    If there is no default form, or no record, nothing happens.
+
+    \sa setForm()
+*/
+
+void Q3DataView::readFields()
+{
+    d->frm.readFields();
+}
+
+/*!
+    Causes the default form to write its fields to the record buffer.
+    If there is no default form, or no record, nothing happens.
+
+    \sa setForm()
+*/
+
+void Q3DataView::writeFields()
+{
+    d->frm.writeFields();
+}
+
+/*!
+    Causes the default form to display the contents of \a buf. If
+    there is no default form, nothing happens.The \a buf also becomes
+    the default record for all subsequent calls to readFields() and
+    writefields(). This slot is equivalant to calling:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3dataview.cpp 0
+
+    \sa setRecord() readFields()
+*/
+
+void Q3DataView::refresh(QSqlRecord* buf)
+{
+    if (buf && buf != record())
+        setRecord(buf);
+    readFields();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SQL_VIEW_WIDGETS
diff --git a/src/qt3support/sql/q3dataview.h b/src/qt3support/sql/q3dataview.h
new file mode 100644
index 0000000..f1b29d1
--- /dev/null
+++ b/src/qt3support/sql/q3dataview.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3DATAVIEW_H
+#define Q3DATAVIEW_H
+
+#include <QtGui/qwidget.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_VIEW_WIDGETS
+
+class Q3SqlForm;
+class QSqlRecord;
+class Q3DataViewPrivate;
+
+class Q_COMPAT_EXPORT Q3DataView : public QWidget
+{
+    Q_OBJECT
+
+public:
+    Q3DataView(QWidget* parent=0, const char* name=0, Qt::WindowFlags fl = 0);
+    ~Q3DataView();
+
+    virtual void setForm(Q3SqlForm* form);
+    Q3SqlForm* form();
+    virtual void setRecord(QSqlRecord* record);
+    QSqlRecord* record();
+
+public Q_SLOTS:
+    virtual void refresh(QSqlRecord* buf);
+    virtual void readFields();
+    virtual void writeFields();
+    virtual void clearValues();
+
+private:
+    Q_DISABLE_COPY(Q3DataView)
+
+    Q3DataViewPrivate* d;
+};
+
+#endif // QT_NO_SQL_VIEW_WIDGETS
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3DATAVIEW_H
diff --git a/src/qt3support/sql/q3editorfactory.cpp b/src/qt3support/sql/q3editorfactory.cpp
new file mode 100644
index 0000000..e5d97c7
--- /dev/null
+++ b/src/qt3support/sql/q3editorfactory.cpp
@@ -0,0 +1,202 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3cleanuphandler.h"
+#include "qlabel.h"
+#include "qlineedit.h"
+#include "qspinbox.h"
+#include "qcombobox.h"
+
+#include "q3editorfactory.h"
+#include "qdatetimeedit.h"
+
+#ifndef QT_NO_SQL_EDIT_WIDGETS
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class Q3EditorFactory
+    \brief The Q3EditorFactory class is used to create editor widgets
+    for QVariant data types.
+
+    \compat
+
+    Each editor factory provides the createEditor() function which
+    given a QVariant will create and return a QWidget that can edit
+    that QVariant. For example if you have a QVariant::String type, a
+    QLineEdit would be the default editor returned, whereas a
+    QVariant::Int's default editor would be a QSpinBox.
+
+    If you want to create different editors for fields with the same
+    data type, subclass Q3EditorFactory and reimplement the
+    createEditor() function.
+*/
+
+/*!
+    Constructs an editor factory with parent \a parent.
+*/
+
+Q3EditorFactory::Q3EditorFactory (QObject * parent)
+    : QObject(parent)
+{
+
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+Q3EditorFactory::~Q3EditorFactory()
+{
+
+}
+
+static Q3EditorFactory * defaultfactory = 0;
+static Q3CleanupHandler< Q3EditorFactory > q_cleanup_editor_factory;
+
+/*!
+    Returns an instance of a default editor factory.
+*/
+
+Q3EditorFactory * Q3EditorFactory::defaultFactory()
+{
+    if(defaultfactory == 0){
+        defaultfactory = new Q3EditorFactory();
+        q_cleanup_editor_factory.add(&defaultfactory);
+    }
+
+    return defaultfactory;
+}
+
+/*!
+    Replaces the default editor factory with \a factory.
+    \e{Q3EditorFactory takes ownership of factory, and destroys it
+    when it is no longer needed.}
+*/
+
+void Q3EditorFactory::installDefaultFactory(Q3EditorFactory * factory)
+{
+    if(factory == 0 || factory == defaultfactory) return;
+
+    if(defaultfactory != 0){
+        q_cleanup_editor_factory.remove(&defaultfactory);
+        delete defaultfactory;
+    }
+    defaultfactory = factory;
+    q_cleanup_editor_factory.add(&defaultfactory);
+}
+
+/*!
+    Creates and returns the appropriate editor for the QVariant \a v.
+    If the QVariant is invalid, 0 is returned. The \a parent is passed
+    to the appropriate editor's constructor.
+*/
+
+QWidget * Q3EditorFactory::createEditor(QWidget * parent, const QVariant & v)
+{
+    QWidget * w = 0;
+    switch(v.type()){
+        case QVariant::Invalid:
+            w = 0;
+            break;
+        case QVariant::Bool:
+            w = new QComboBox(parent, "qt_editor_bool");
+            ((QComboBox *) w)->insertItem(QLatin1String("False"));
+            ((QComboBox *) w)->insertItem(QLatin1String("True"));
+            break;
+        case QVariant::UInt:
+            w = new QSpinBox(0, 999999, 1, parent, "qt_editor_spinbox");
+            break;
+        case QVariant::Int:
+            w = new QSpinBox(-999999, 999999, 1, parent, "qt_editor_int");
+            break;
+        case QVariant::String:
+        case QVariant::Double:
+            w = new QLineEdit(parent, "qt_editor_double");
+            ((QLineEdit*)w)->setFrame(false);
+            break;
+        case QVariant::Date: {
+            QDateTimeEdit *edit = new QDateTimeEdit(parent);
+            edit->setDisplayFormat(QLatin1String("yyyy/MM/dd"));
+            edit->setObjectName(QLatin1String("qt_editor_date"));
+            w = edit; }
+            break;
+        case QVariant::Time: {
+            QDateTimeEdit *edit = new QDateTimeEdit(parent);
+            edit->setDisplayFormat(QLatin1String("hh:mm"));
+            edit->setObjectName(QLatin1String("qt_editor_time"));
+            w = edit; }
+            break;
+        case QVariant::DateTime:
+            w = new QDateTimeEdit(parent);
+            w->setObjectName(QLatin1String("qt_editor_datetime"));
+            break;
+#ifndef QT_NO_LABEL
+        case QVariant::Pixmap:
+            w = new QLabel(parent, QLatin1String("qt_editor_pixmap"));
+            break;
+#endif
+        case QVariant::Palette:
+        case QVariant::Color:
+        case QVariant::Font:
+        case QVariant::Brush:
+        case QVariant::Bitmap:
+        case QVariant::Cursor:
+        case QVariant::Map:
+        case QVariant::StringList:
+        case QVariant::Rect:
+        case QVariant::Size:
+        case QVariant::IconSet:
+        case QVariant::Point:
+        case QVariant::PointArray:
+        case QVariant::Region:
+        case QVariant::SizePolicy:
+        case QVariant::ByteArray:
+        default:
+            w = new QWidget(parent, "qt_editor_default");
+            break;
+    }
+    return w;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SQL
diff --git a/src/qt3support/sql/q3editorfactory.h b/src/qt3support/sql/q3editorfactory.h
new file mode 100644
index 0000000..476b683
--- /dev/null
+++ b/src/qt3support/sql/q3editorfactory.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3EDITORFACTORY_H
+#define Q3EDITORFACTORY_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_EDIT_WIDGETS
+
+class Q_COMPAT_EXPORT Q3EditorFactory : public QObject
+{
+public:
+    Q3EditorFactory (QObject * parent = 0);
+    ~Q3EditorFactory();
+
+    virtual QWidget * createEditor(QWidget * parent, const QVariant & v);
+
+    static Q3EditorFactory * defaultFactory();
+    static void installDefaultFactory(Q3EditorFactory * factory);
+
+private:
+    Q_DISABLE_COPY(Q3EditorFactory)
+};
+
+#endif // QT_NO_SQL_EDIT_WIDGETS
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3EDITORFACTORY_H
diff --git a/src/qt3support/sql/q3sqlcursor.cpp b/src/qt3support/sql/q3sqlcursor.cpp
new file mode 100644
index 0000000..5bc23c1
--- /dev/null
+++ b/src/qt3support/sql/q3sqlcursor.cpp
@@ -0,0 +1,1519 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qplatformdefs.h>
+#include "q3sqlcursor.h"
+
+#ifndef QT_NO_SQL
+
+#include "qsqldriver.h"
+#include "qsqlresult.h"
+#include "qdatetime.h"
+#include "qsqldatabase.h"
+#include "qsql.h"
+#include "q3sqlrecordinfo.h"
+#include "q3sqlfieldinfo.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q3SqlCursorPrivate
+{
+public:
+
+    Q3SqlCursorPrivate(const QString& name, QSqlDatabase sdb)
+        : lastAt(QSql::BeforeFirst), nm(name), srt(name), md(0), db(sdb), q(0)
+    {}
+    ~Q3SqlCursorPrivate()
+    {
+        delete q;
+    }
+
+    QSqlQuery* query()
+    {
+        if (!q)
+            q = new QSqlQuery(QString(), db);
+        return q;
+    }
+
+    int lastAt;
+    QString nm;         //name
+    QSqlIndex srt;        //sort
+    QString ftr;        //filter
+    int md;         //mode
+    QSqlIndex priIndx;    //primary index
+    QSqlRecord editBuffer;
+    // the primary index as it was before the user changed the values in editBuffer
+    QString editIndex;
+    Q3SqlRecordInfo infoBuffer;
+    QSqlDatabase db;
+    QSqlQuery *q;
+};
+
+QString qOrderByClause(const QSqlIndex & i, const QString& prefix = QString())
+{
+    QString str;
+    int k = i.count();
+    if(k == 0)
+        return QString();
+    str = QLatin1String(" order by ") + i.toString(prefix);
+    return str;
+}
+
+QString qWhereClause(const QString& prefix, QSqlField* field, const QSqlDriver* driver)
+{
+    QString f;
+    if (field && driver) {
+        if (!prefix.isEmpty())
+            f += prefix + QLatin1Char('.');
+        f += field->name();
+        if (field->isNull()) {
+            f += QLatin1String(" IS NULL");
+        } else {
+            f += QLatin1String(" = ") + driver->formatValue(field);
+        }
+    }
+    return f;
+}
+
+QString qWhereClause(QSqlRecord* rec, const QString& prefix, const QString& sep,
+                      const QSqlDriver* driver)
+{
+    static QString blank(QLatin1Char(' '));
+    QString filter;
+    bool separator = false;
+    for (int j = 0; j < rec->count(); ++j) {
+        QSqlField f = rec->field(j);
+        if (rec->isGenerated(j)) {
+            if (separator)
+                filter += sep + blank;
+            filter += qWhereClause(prefix, &f, driver);
+            filter += blank;
+            separator = true;
+        }
+    }
+    return filter;
+}
+
+/*!
+    \class Q3SqlCursor
+    \brief The Q3SqlCursor class provides browsing and editing of SQL
+    tables and views.
+
+    \compat
+
+    A Q3SqlCursor is a database record (see \l QSqlRecord) that
+    corresponds to a table or view within an SQL database (see \l
+    QSqlDatabase). There are two buffers in a cursor, one used for
+    browsing and one used for editing records. Each buffer contains a
+    list of fields which correspond to the fields in the table or
+    view.
+
+    When positioned on a valid record, the browse buffer contains the
+    values of the current record's fields from the database. The edit
+    buffer is separate, and is used for editing existing records and
+    inserting new records.
+
+    For browsing data, a cursor must first select() data from the
+    database. After a successful select() the cursor is active
+    (isActive() returns true), but is initially not positioned on a
+    valid record (isValid() returns false). To position the cursor on
+    a valid record, use one of the navigation functions, next(),
+    previous(), first(), last(), or seek(). Once positioned on a valid
+    record, data can be retrieved from the browse buffer using
+    value(). If a navigation function is not successful, it returns
+    false, the cursor will no longer be positioned on a valid record
+    and the values returned by value() are undefined.
+
+    For example:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 0
+
+    In the above example, a cursor is created specifying a table or
+    view name in the database. Then, select() is called, which can be
+    optionally parameterised to filter and order the records
+    retrieved. Each record in the cursor is retrieved using next().
+    When next() returns false, there are no more records to process,
+    and the loop terminates.
+
+    For editing records (rows of data), a cursor contains a separate
+    edit buffer which is independent of the fields used when browsing.
+    The functions insert(), update() and del() operate on the edit
+    buffer. This allows the cursor to be repositioned to other
+    records while simultaneously maintaining a separate buffer for
+    edits. You can get a pointer to the edit buffer using
+    editBuffer(). The primeInsert(), primeUpdate() and primeDelete()
+    functions also return a pointer to the edit buffer and prepare it
+    for insert, update and delete respectively. Edit operations only
+    affect a single row at a time. Note that update() and del()
+    require that the table or view contain a primaryIndex() to ensure
+    that edit operations affect a unique record within the database.
+
+    For example:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 1
+
+    To edit an existing database record, first move to the record you
+    wish to update. Call primeUpdate() to get the pointer to the
+    cursor's edit buffer. Then use this pointer to modify the values
+    in the edit buffer. Finally, call update() to save the changes to
+    the database. The values in the edit buffer will be used to
+    locate the appropriate record when updating the database (see
+    primaryIndex()).
+
+    Similarly, when deleting an existing database record, first move
+    to the record you wish to delete. Then, call primeDelete() to get
+    the pointer to the edit buffer. Finally, call del() to delete the
+    record from the database. Again, the values in the edit buffer
+    will be used to locate and delete the appropriate record.
+
+    To insert a new record, call primeInsert() to get the pointer to
+    the edit buffer. Use this pointer to populate the edit buffer
+    with new values and then insert() the record into the database.
+
+    After calling insert(), update() or del(), the cursor is no longer
+    positioned on a valid record and can no longer be navigated
+    (isValid() return false). The reason for this is that any changes
+    made to the database will not be visible until select() is called
+    to refresh the cursor. You can change this behavior by passing
+    false to insert(), update() or del() which will prevent the cursor
+    from becoming invalid. The edits will still not be visible when
+    navigating the cursor until select() is called.
+
+    Q3SqlCursor contains virtual methods which allow editing behavior
+    to be customized by subclasses. This allows custom cursors to be
+    created that encapsulate the editing behavior of a database table
+    for an entire application. For example, a cursor can be customized
+    to always auto-number primary index fields, or provide fields with
+    suitable default values, when inserting new records. Q3SqlCursor
+    generates SQL statements which are sent to the database engine;
+    you can control which fields are included in these statements
+    using setGenerated().
+
+    Note that Q3SqlCursor does not inherit from QObject. This means
+    that you are responsible for destroying instances of this class
+    yourself. However if you create a Q3SqlCursor and use it in a
+    \l Q3DataTable, \l Q3DataBrowser or a \l Q3DataView these classes will
+    usually take ownership of the cursor and destroy it when they
+    don't need it anymore. The documentation for Q3DataTable,
+    Q3DataBrowser and Q3DataView explicitly states which calls take
+    ownership of the cursor.
+*/
+
+/*!
+    \enum Q3SqlCursor::Mode
+
+    This enum type describes how Q3SqlCursor operates on records in the
+    database.
+
+    \value ReadOnly  the cursor can only SELECT records from the
+    database.
+
+    \value Insert  the cursor can INSERT records into the database.
+
+    \value Update  the cursor can UPDATE records in the database.
+
+    \value Delete  the cursor can DELETE records from the database.
+
+    \value Writable  the cursor can INSERT, UPDATE and DELETE records
+    in the database.
+*/
+
+/*!
+    \fn QVariant Q3SqlCursor::value(const QString &name) const
+
+    \overload
+
+    Returns the value of the field named \a name.
+*/
+
+/*!
+    \fn void Q3SqlCursor::setValue(const QString &name, const QVariant &val)
+
+    \overload
+
+    Sets the value for the field named \a name to \a val.
+*/
+
+/*!
+    Constructs a cursor on database \a db using table or view \a name.
+
+    If \a autopopulate is true (the default), the \a name of the
+    cursor must correspond to an existing table or view name in the
+    database so that field information can be automatically created.
+    If the table or view does not exist, the cursor will not be
+    functional.
+
+    The cursor is created with an initial mode of Q3SqlCursor::Writable
+    (meaning that records can be inserted, updated or deleted using
+    the cursor). If the cursor does not have a unique primary index,
+    update and deletes cannot be performed.
+
+    Note that \a autopopulate refers to populating the cursor with
+    meta-data, e.g. the names of the table's fields, not with
+    retrieving data. The select() function is used to populate the
+    cursor with data.
+
+    \sa setName() setMode()
+*/
+
+Q3SqlCursor::Q3SqlCursor(const QString & name, bool autopopulate, QSqlDatabase db)
+    : QSqlRecord(), QSqlQuery(QString(), db)
+{
+    d = new Q3SqlCursorPrivate(name, db);
+    setMode(Writable);
+    if (!d->nm.isEmpty())
+        setName(d->nm, autopopulate);
+}
+
+/*!
+    Constructs a copy of \a other.
+*/
+
+Q3SqlCursor::Q3SqlCursor(const Q3SqlCursor & other)
+    : QSqlRecord(other), QSqlQuery(other)
+{
+    d = new Q3SqlCursorPrivate(other.d->nm, other.d->db);
+    d->lastAt = other.d->lastAt;
+    d->nm = other.d->nm;
+    d->srt = other.d->srt;
+    d->ftr = other.d->ftr;
+    d->priIndx = other.d->priIndx;
+    d->editBuffer = other.d->editBuffer;
+    d->infoBuffer = other.d->infoBuffer;
+    d->q = 0; // do not share queries
+    setMode(other.mode());
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+Q3SqlCursor::~Q3SqlCursor()
+{
+    delete d;
+}
+
+/*!
+    Sets the cursor equal to \a other.
+*/
+
+Q3SqlCursor& Q3SqlCursor::operator=(const Q3SqlCursor& other)
+{
+    QSqlRecord::operator=(other);
+    QSqlQuery::operator=(other);
+    delete d;
+    d = new Q3SqlCursorPrivate(other.d->nm, other.d->db);
+    d->lastAt = other.d->lastAt;
+    d->nm = other.d->nm;
+    d->srt = other.d->srt;
+    d->ftr = other.d->ftr;
+    d->priIndx = other.d->priIndx;
+    d->editBuffer = other.d->editBuffer;
+    d->infoBuffer = other.d->infoBuffer;
+    d->q = 0; // do not share queries
+    setMode(other.mode());
+    return *this;
+}
+
+/*!
+    Sets the current sort to \a sort. Note that no new records are
+    selected. To select new records, use select(). The \a sort will
+    apply to any subsequent select() calls that do not explicitly
+    specify a sort.
+*/
+
+void Q3SqlCursor::setSort(const QSqlIndex& sort)
+{
+    d->srt = sort;
+}
+
+/*!
+    Returns the current sort, or an empty index if there is no current
+    sort.
+*/
+QSqlIndex Q3SqlCursor::sort() const
+{
+    return d->srt;
+}
+
+/*!
+    Sets the current filter to \a filter. Note that no new records are
+    selected. To select new records, use select(). The \a filter will
+    apply to any subsequent select() calls that do not explicitly
+    specify a filter.
+
+    The filter is a SQL \c WHERE clause without the keyword 'WHERE',
+    e.g. \c{name='Dave'} which will be processed by the DBMS.
+*/
+void Q3SqlCursor::setFilter(const QString& filter)
+{
+    d->ftr = filter;
+}
+
+/*!
+    Returns the current filter, or an empty string if there is no
+    current filter.
+*/
+QString Q3SqlCursor::filter() const
+{
+    return d->ftr;
+}
+
+/*!
+    Sets the name of the cursor to \a name. If \a autopopulate is true
+    (the default), the \a name must correspond to a valid table or
+    view name in the database. Also, note that all references to the
+    cursor edit buffer become invalidated when fields are
+    auto-populated. See the Q3SqlCursor constructor documentation for
+    more information.
+*/
+void Q3SqlCursor::setName(const QString& name, bool autopopulate)
+{
+    d->nm = name;
+    if (autopopulate) {
+        if (driver()) {
+            d->infoBuffer = driver()->record(name);
+            *this = d->infoBuffer.toRecord();
+            d->editBuffer = *this;
+            d->priIndx = driver()->primaryIndex(name);
+        }
+        if (isEmpty())
+            qWarning("Q3SqlCursor::setName: unable to build record, does '%s' exist?", name.latin1());
+    }
+}
+
+/*!
+    Returns the name of the cursor.
+*/
+
+QString Q3SqlCursor::name() const
+{
+    return d->nm;
+}
+
+/*! \internal
+*/
+
+QString Q3SqlCursor::toString(const QString& prefix, const QString& sep) const
+{
+    QString pflist;
+    QString pfix =  prefix.isEmpty() ? prefix : prefix + QLatin1Char('.');
+    bool comma = false;
+
+    for (int i = 0; i < count(); ++i) {
+        const QString fname = fieldName(i);
+        if (isGenerated(i)) {
+            if(comma)
+                pflist += sep + QLatin1Char(' ');
+            pflist += pfix + driver()->escapeIdentifier(fname, QSqlDriver::FieldName);
+            comma = true;
+        }
+    }
+    return pflist;
+}
+
+/*!
+  \internal
+
+  Assigns the record \a list.
+
+*/
+QSqlRecord & Q3SqlCursor::operator=(const QSqlRecord & list)
+{
+    return QSqlRecord::operator=(list);
+}
+
+/*!
+    Append a copy of field \a fieldInfo to the end of the cursor. Note
+    that all references to the cursor edit buffer become invalidated.
+*/
+
+void Q3SqlCursor::append(const Q3SqlFieldInfo& fieldInfo)
+{
+    d->editBuffer.append(fieldInfo.toField());
+    d->infoBuffer.append(fieldInfo);
+    QSqlRecord::append(fieldInfo.toField());
+}
+
+/*!
+    Removes all fields from the cursor. Note that all references to
+    the cursor edit buffer become invalidated.
+*/
+void Q3SqlCursor::clear()
+{
+    d->editBuffer.clear();
+    d->infoBuffer.clear();
+    QSqlRecord::clear();
+}
+
+
+/*!
+    Insert a copy of \a fieldInfo at position \a pos. If a field
+    already exists at \a pos, it is removed. Note that all references
+    to the cursor edit buffer become invalidated.
+*/
+
+void  Q3SqlCursor::insert(int pos, const Q3SqlFieldInfo& fieldInfo)
+{
+    d->editBuffer.replace(pos, fieldInfo.toField());
+    d->infoBuffer[pos] = fieldInfo;
+    QSqlRecord::replace(pos, fieldInfo.toField());
+}
+
+/*!
+    Removes the field at \a pos. If \a pos does not exist, nothing
+    happens. Note that all references to the cursor edit buffer become
+    invalidated.
+*/
+
+void Q3SqlCursor::remove(int pos)
+{
+    d->editBuffer.remove(pos);
+    d->infoBuffer[pos] = Q3SqlFieldInfo();
+    QSqlRecord::remove(pos);
+}
+
+/*!
+    Sets the generated flag for the field \a name to \a generated. If
+    the field does not exist, nothing happens. Only fields that have
+    \a generated set to true are included in the SQL that is
+    generated by insert(), update() or del().
+*/
+
+void Q3SqlCursor::setGenerated(const QString& name, bool generated)
+{
+    int pos = indexOf(name);
+    if (pos == -1)
+        return;
+    QSqlRecord::setGenerated(name, generated);
+    d->editBuffer.setGenerated(name, generated);
+    d->infoBuffer[pos].setGenerated(generated);
+}
+
+/*!
+    \overload
+
+    Sets the generated flag for the field \a i to \a generated.
+*/
+void Q3SqlCursor::setGenerated(int i, bool generated)
+{
+    if (i < 0 || i >= (int)d->infoBuffer.count())
+        return;
+    QSqlRecord::setGenerated(i, generated);
+    d->editBuffer.setGenerated(i, generated);
+    d->infoBuffer[i].setGenerated(generated);
+}
+
+/*!
+    Returns the primary index associated with the cursor as defined in
+    the database, or an empty index if there is no primary index. If
+    \a setFromCursor is true (the default), the index fields are
+    populated with the corresponding values in the cursor's current
+    record.
+*/
+
+QSqlIndex Q3SqlCursor::primaryIndex(bool setFromCursor) const
+{
+    if (setFromCursor) {
+        for (int i = 0; i < d->priIndx.count(); ++i) {
+            const QString fn = d->priIndx.fieldName(i);
+            if (contains(fn))
+                d->priIndx.setValue(i, QSqlRecord::value(fn));
+        }
+    }
+    return d->priIndx;
+}
+
+/*!
+    Sets the primary index associated with the cursor to the index \a
+    idx. Note that this index must contain a field or set of fields
+    which identify a unique record within the underlying database
+    table or view so that update() and del() will execute as expected.
+
+    \sa update() del()
+*/
+
+void Q3SqlCursor::setPrimaryIndex(const QSqlIndex& idx)
+{
+    d->priIndx = idx;
+}
+
+
+/*!
+    Returns an index composed of \a fieldNames, all in ASCending
+    order. Note that all field names must exist in the cursor,
+    otherwise an empty index is returned.
+
+    \sa QSqlIndex
+*/
+
+QSqlIndex Q3SqlCursor::index(const QStringList& fieldNames) const
+{
+    QSqlIndex idx;
+    for (QStringList::ConstIterator it = fieldNames.begin(); it != fieldNames.end(); ++it) {
+        QSqlField f = field((*it));
+        if (!f.isValid()) { /* all fields must exist */
+            idx.clear();
+            break;
+        }
+        idx.append(f);
+    }
+    return idx;
+}
+
+/*!
+    \overload
+
+    Returns an index based on \a fieldName.
+*/
+
+QSqlIndex Q3SqlCursor::index(const QString& fieldName) const
+{
+    QStringList fl(fieldName);
+    return index(fl);
+}
+
+/*!
+    Selects all fields in the cursor from the database matching the
+    filter criteria \a filter. The data is returned in the order
+    specified by the index \a sort. Returns true if the data was
+    successfully selected; otherwise returns false.
+
+    The \a filter is a string containing a SQL \c WHERE clause but
+    without the 'WHERE' keyword. The cursor is initially positioned at
+    an invalid row after this function is called. To move to a valid
+    row, use seek(), first(), last(), previous() or next().
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 2
+
+    The filter will apply to any subsequent select() calls that do not
+    explicitly specify another filter. Similarly the sort will apply
+    to any subsequent select() calls that do not explicitly specify
+    another sort.
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 3
+
+*/
+
+bool Q3SqlCursor::select(const QString & filter, const QSqlIndex & sort)
+{
+    QString fieldList(toString(d->nm));
+    if (fieldList.isEmpty())
+        return false;
+    QString str(QLatin1String("select ") + fieldList);
+    str += QLatin1String(" from ") + d->nm;
+    if (!filter.isEmpty()) {
+        d->ftr = filter;
+        str += QLatin1String(" where ") + filter;
+    } else
+        d->ftr.clear();
+    if (sort.count() > 0)
+        str += QLatin1String(" order by ") + sort.toString(d->nm);
+    d->srt = sort;
+    return exec(str);
+}
+
+/*!
+    \overload
+
+    Selects all fields in the cursor from the database. The rows are
+    returned in the order specified by the last call to setSort() or
+    the last call to select() that specified a sort, whichever is the
+    most recent. If there is no current sort, the order in which the
+    rows are returned is undefined. The records are filtered according
+    to the filter specified by the last call to setFilter() or the
+    last call to select() that specified a filter, whichever is the
+    most recent. If there is no current filter, all records are
+    returned. The cursor is initially positioned at an invalid row. To
+    move to a valid row, use seek(), first(), last(), previous() or
+    next().
+
+    \sa setSort() setFilter()
+*/
+
+bool Q3SqlCursor::select()
+{
+    return select(filter(), sort());
+}
+
+/*!
+    \overload
+
+    Selects all fields in the cursor from the database. The data is
+    returned in the order specified by the index \a sort. The records
+    are filtered according to the filter specified by the last call to
+    setFilter() or the last call to select() that specified a filter,
+    whichever is the most recent. The cursor is initially positioned
+    at an invalid row. To move to a valid row, use seek(), first(),
+    last(), previous() or next().
+*/
+
+bool Q3SqlCursor::select(const QSqlIndex& sort)
+{
+    return select(filter(), sort);
+}
+
+/*!
+    \overload
+
+    Selects all fields in the cursor matching the filter index \a
+    filter. The data is returned in the order specified by the index
+    \a sort. The \a filter index works by constructing a WHERE clause
+    using the names of the fields from the \a filter and their values
+    from the current cursor record. The cursor is initially positioned
+    at an invalid row. To move to a valid row, use seek(), first(),
+    last(), previous() or next(). This function is useful, for example,
+    for retrieving data based upon a table's primary index:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 4
+
+    In this example the QSqlIndex, pk, is used for two different
+    purposes. When used as the filter (first) argument, the field
+    names it contains are used to construct the WHERE clause, each set
+    to the current cursor value, \c{WHERE id=10}, in this case. When
+    used as the sort (second) argument the field names it contains are
+    used for the ORDER BY clause, \c{ORDER BY id} in this example.
+*/
+
+bool Q3SqlCursor::select(const QSqlIndex & filter, const QSqlIndex & sort)
+{
+    return select(toString(filter, this, d->nm, QString(QLatin1Char('=')), QLatin1String("and")), sort);
+}
+
+/*!
+    Sets the cursor mode to \a mode. This value can be an OR'ed
+    combination of \l Q3SqlCursor::Mode values. The default mode for a
+    cursor is Q3SqlCursor::Writable.
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 5
+*/
+
+void Q3SqlCursor::setMode(int mode)
+{
+    d->md = mode;
+}
+
+/*!
+    Returns the current cursor mode.
+
+    \sa setMode()
+*/
+
+int Q3SqlCursor::mode() const
+{
+    return d->md;
+}
+
+/*!
+    Sets field \a name to \a calculated. If the field \a name does not
+    exist, nothing happens. The value of a calculated field is set by
+    the calculateField() virtual function which you must reimplement
+    (or the field value will be an invalid QVariant). Calculated
+    fields do not appear in generated SQL statements sent to the
+    database.
+
+    \sa calculateField()
+*/
+
+void Q3SqlCursor::setCalculated(const QString& name, bool calculated)
+{
+    int pos = indexOf(name);
+    if (pos < 0)
+        return;
+    d->infoBuffer[pos].setCalculated(calculated);
+    if (calculated)
+        setGenerated(pos, false);
+}
+
+/*!
+    Returns true if the field \a name exists and is calculated;
+    otherwise returns false.
+
+    \sa setCalculated()
+*/
+
+bool Q3SqlCursor::isCalculated(const QString& name) const
+{
+    int pos = indexOf(name);
+    if (pos < 0)
+        return false;
+    return d->infoBuffer[pos].isCalculated();
+}
+
+/*!
+    Sets field \a{name}'s trimmed status to \a trim. If the field \a
+    name does not exist, nothing happens.
+
+    When a trimmed field of type string is read from the
+    database any trailing (right-most) spaces are removed.
+
+    \sa isTrimmed() QVariant
+*/
+
+void Q3SqlCursor::setTrimmed(const QString& name, bool trim)
+{
+    int pos = indexOf(name);
+    if (pos < 0)
+        return;
+    d->infoBuffer[pos].setTrim(trim);
+}
+
+/*!
+    Returns true if the field \a name exists and is trimmed; otherwise
+    returns false.
+
+    When a trimmed field of type string or cstring is read from the
+    database any trailing (right-most) spaces are removed.
+
+    \sa setTrimmed()
+*/
+
+bool Q3SqlCursor::isTrimmed(const QString& name) const
+{
+    int pos = indexOf(name);
+    if (pos < 0)
+        return false;
+    return d->infoBuffer[pos].isTrim();
+}
+
+/*!
+    Returns true if the cursor is read-only; otherwise returns false.
+    The default is false. Read-only cursors cannot be edited using
+    insert(), update() or del().
+
+    \sa setMode()
+*/
+
+bool Q3SqlCursor::isReadOnly() const
+{
+    return d->md == 0;
+}
+
+/*!
+    Returns true if the cursor will perform inserts; otherwise returns
+    false.
+
+    \sa setMode()
+*/
+
+bool Q3SqlCursor::canInsert() const
+{
+    return ((d->md & Insert) == Insert) ;
+}
+
+
+/*!
+    Returns true if the cursor will perform updates; otherwise returns
+    false.
+
+    \sa setMode()
+*/
+
+bool Q3SqlCursor::canUpdate() const
+{
+    return ((d->md & Update) == Update) ;
+}
+
+/*!
+    Returns true if the cursor will perform deletes; otherwise returns
+    false.
+
+    \sa setMode()
+*/
+
+bool Q3SqlCursor::canDelete() const
+{
+    return ((d->md & Delete) == Delete) ;
+}
+
+/*!
+    \overload
+
+    Returns a formatted string composed of the \a prefix (e.g. table
+    or view name), ".", the \a field name, the \a fieldSep and the
+    field value. If the \a prefix is empty then the string will begin
+    with the \a field name. This function is useful for generating SQL
+    statements.
+*/
+
+QString Q3SqlCursor::toString(const QString& prefix, QSqlField* field, const QString& fieldSep) const
+{
+    QString f;
+    if (field && driver()) {
+        f = (prefix.length() > 0 ? prefix + QLatin1Char('.') : QString()) + field->name();
+        f += QLatin1Char(' ') + fieldSep + QLatin1Char(' ');
+        if (field->isNull()) {
+            f += QLatin1String("NULL");
+        } else {
+            f += driver()->formatValue(field);
+        }
+    }
+    return f;
+}
+
+/*!
+    Returns a formatted string composed of all the fields in \a rec.
+    Each field is composed of the \a prefix (e.g. table or view name),
+    ".", the field name, the \a fieldSep and the field value. If the
+    \a prefix is empty then each field will begin with the field name.
+    The fields are then joined together separated by \a sep. Fields
+    where isGenerated() returns false are not included. This function
+    is useful for generating SQL statements.
+*/
+
+QString Q3SqlCursor::toString(QSqlRecord* rec, const QString& prefix, const QString& fieldSep,
+                              const QString& sep) const
+{
+    static QString blank(QLatin1Char(' '));
+    QString filter;
+    bool separator = false;
+    for (int j = 0; j < count(); ++j) {
+        QSqlField f = rec->field(j);
+        if (rec->isGenerated(j)) {
+            if (separator)
+                filter += sep + blank;
+            filter += toString(prefix, &f, fieldSep);
+            filter += blank;
+            separator = true;
+        }
+    }
+    return filter;
+}
+
+/*!
+    \overload
+
+    Returns a formatted string composed of all the fields in the index
+    \a i. Each field is composed of the \a prefix (e.g. table or view
+    name), ".", the field name, the \a fieldSep and the field value.
+    If the \a prefix is empty then each field will begin with the field
+    name. The field values are taken from \a rec. The fields are then
+    joined together separated by \a sep. Fields where isGenerated()
+    returns false are ignored. This function is useful for generating
+    SQL statements.
+*/
+
+QString Q3SqlCursor::toString(const QSqlIndex& i, QSqlRecord* rec, const QString& prefix,
+                                const QString& fieldSep, const QString& sep) const
+{
+    QString filter;
+    bool separator = false;
+    for(int j = 0; j < i.count(); ++j){
+        if (rec->isGenerated(j)) {
+            if(separator) {
+                filter += QLatin1Char(' ') + sep + QLatin1Char(' ') ;
+            }
+            QString fn = i.fieldName(j);
+            QSqlField f = rec->field(fn);
+            filter += toString(prefix, &f, fieldSep);
+            separator = true;
+        }
+    }
+    return filter;
+}
+
+/*!
+    Inserts the current contents of the cursor's edit record buffer
+    into the database, if the cursor allows inserts. Returns the
+    number of rows affected by the insert. For error information, use
+    lastError().
+
+    If \a invalidate is true (the default), the cursor will no longer
+    be positioned on a valid record and can no longer be navigated. A
+    new select() call must be made before navigating to a valid
+    record.
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 6
+
+    In the above example, a cursor is created on the 'prices' table
+    and a pointer to the insert buffer is acquired using primeInsert().
+    Each field's value is set to the desired value and then insert()
+    is called to insert the data into the database. Remember: all edit
+    operations (insert(), update() and delete()) operate on the
+    contents of the cursor edit buffer and not on the contents of the
+    cursor itself.
+
+    \sa setMode() lastError()
+*/
+
+int Q3SqlCursor::insert(bool invalidate)
+{
+    if ((d->md & Insert) != Insert || !driver())
+        return false;
+    int k = d->editBuffer.count();
+    if (k == 0)
+        return 0;
+
+    QString fList;
+    QString vList;
+    bool comma = false;
+    // use a prepared query if the driver supports it
+    if (driver()->hasFeature(QSqlDriver::PreparedQueries)) {
+        int cnt = 0;
+        bool oraStyle = driver()->hasFeature(QSqlDriver::NamedPlaceholders);
+        for(int j = 0; j < k; ++j) {
+            QSqlField f = d->editBuffer.field(j);
+            if (d->editBuffer.isGenerated(j)) {
+                if (comma) {
+                    fList += QLatin1Char(',');
+                    vList += QLatin1Char(',');
+                }
+                fList += driver()->escapeIdentifier(f.name(), QSqlDriver::FieldName);
+                vList += (oraStyle == true) ? QLatin1String(":f") + QString::number(cnt) : QString(QLatin1Char('?'));
+                cnt++;
+                comma = true;
+            }
+        }
+        if (!comma) {
+            return 0;
+        }
+        QString str;
+        str.append(QLatin1String("insert into ")).append(name())
+           .append(QLatin1String(" (")).append(fList)
+           .append(QLatin1String(") values (")).append(vList). append(QLatin1Char(')'));
+
+        return applyPrepared(str, invalidate);
+    } else {
+        for(int j = 0; j < k; ++j) {
+            QSqlField f = d->editBuffer.field(j);
+            if (d->editBuffer.isGenerated(j)) {
+                if (comma) {
+                    fList += QLatin1Char(',');
+                    vList += QLatin1Char(',');
+                }
+                fList += driver()->escapeIdentifier(f.name(), QSqlDriver::FieldName);
+                vList += driver()->formatValue(&f);
+                comma = true;
+            }
+        }
+
+        if (!comma) {
+            // no valid fields found
+            return 0;
+        }
+        QString str;
+        str.append(QLatin1String("insert into ")).append(name()).append(QLatin1String(" ("))
+           .append(fList).append(QLatin1String(") values (")).append(vList). append (QLatin1String(")"));
+        return apply(str, invalidate);
+    }
+}
+
+/*!
+    Returns the current internal edit buffer. If \a copy is true (the
+    default is false), the current cursor field values are first
+    copied into the edit buffer. The edit buffer is valid as long as
+    the cursor remains valid. The cursor retains ownership of the
+    returned pointer, so it must not be deleted or modified.
+
+    \sa primeInsert(), primeUpdate() primeDelete()
+*/
+
+QSqlRecord* Q3SqlCursor::editBuffer(bool copy)
+{
+    sync();
+    if (copy) {
+        for(int i = 0; i < d->editBuffer.count(); i++) {
+            if (QSqlRecord::isNull(i)) {
+                d->editBuffer.setNull(i);
+            } else {
+                d->editBuffer.setValue(i, value(i));
+            }
+        }
+    }
+    return &d->editBuffer;
+}
+
+/*!
+    This function primes the edit buffer's field values for update and
+    returns the edit buffer. The default implementation copies the
+    field values from the current cursor record into the edit buffer
+    (therefore, this function is equivalent to calling editBuffer(
+    true)). The cursor retains ownership of the returned pointer, so
+    it must not be deleted or modified.
+
+    \sa editBuffer() update()
+*/
+
+QSqlRecord* Q3SqlCursor::primeUpdate()
+{
+    // memorize the primary keys as they were before the user changed the values in editBuffer
+    QSqlRecord* buf = editBuffer(true);
+    QSqlIndex idx = primaryIndex(false);
+    if (!idx.isEmpty())
+        d->editIndex = toString(idx, buf, d->nm, QString(QLatin1Char('=')), QLatin1String("and"));
+    else
+        d->editIndex = qWhereClause(buf, d->nm, QLatin1String("and"), driver());
+    return buf;
+}
+
+/*!
+    This function primes the edit buffer's field values for delete and
+    returns the edit buffer. The default implementation copies the
+    field values from the current cursor record into the edit buffer
+    (therefore, this function is equivalent to calling editBuffer(
+    true)). The cursor retains ownership of the returned pointer, so
+    it must not be deleted or modified.
+
+    \sa editBuffer() del()
+*/
+
+QSqlRecord* Q3SqlCursor::primeDelete()
+{
+    return editBuffer(true);
+}
+
+/*!
+    This function primes the edit buffer's field values for insert and
+    returns the edit buffer. The default implementation clears all
+    field values in the edit buffer. The cursor retains ownership of
+    the returned pointer, so it must not be deleted or modified.
+
+    \sa editBuffer() insert()
+*/
+
+QSqlRecord* Q3SqlCursor::primeInsert()
+{
+    d->editBuffer.clearValues();
+    return &d->editBuffer;
+}
+
+
+/*!
+    Updates the database with the current contents of the edit buffer.
+    Returns the number of records which were updated.
+    For error information, use lastError().
+
+    Only records which meet the filter criteria specified by the
+    cursor's primary index are updated. If the cursor does not contain
+    a primary index, no update is performed and 0 is returned.
+
+    If \a invalidate is true (the default), the current cursor can no
+    longer be navigated. A new select() call must be made before you
+    can move to a valid record. For example:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 7
+
+    In the above example, a cursor is created on the 'prices' table
+    and is positioned on the record to be updated. Then a pointer to
+    the cursor's edit buffer is acquired using primeUpdate(). A new
+    value is calculated and placed into the edit buffer with the
+    setValue() call. Finally, an update() call is made on the cursor
+    which uses the tables's primary index to update the record in the
+    database with the contents of the cursor's edit buffer. Remember:
+    all edit operations (insert(), update() and delete()) operate on
+    the contents of the cursor edit buffer and not on the contents of
+    the cursor itself.
+
+    Note that if the primary index does not uniquely distinguish
+    records the database may be changed into an inconsistent state.
+
+    \sa setMode() lastError()
+*/
+
+int Q3SqlCursor::update(bool invalidate)
+{
+    if (d->editIndex.isEmpty())
+        return 0;
+    return update(d->editIndex, invalidate);
+}
+
+/*!
+    \overload
+
+    Updates the database with the current contents of the cursor edit
+    buffer using the specified \a filter. Returns the number of
+    records which were updated.
+    For error information, use lastError().
+
+    Only records which meet the filter criteria are updated, otherwise
+    all records in the table are updated.
+
+    If \a invalidate is true (the default), the cursor can no longer
+    be navigated. A new select() call must be made before you can move
+    to a valid record.
+
+    \sa primeUpdate() setMode() lastError()
+*/
+
+int Q3SqlCursor::update(const QString & filter, bool invalidate)
+{
+    if ((d->md & Update) != Update) {
+        return false;
+    }
+    int k = count();
+    if (k == 0) {
+        return 0;
+    }
+    
+    // use a prepared query if the driver supports it
+    if (driver()->hasFeature(QSqlDriver::PreparedQueries)) {
+        QString fList;
+        bool comma = false;
+        int cnt = 0;
+        bool oraStyle = driver()->hasFeature(QSqlDriver::NamedPlaceholders);
+        for(int j = 0; j < k; ++j) {
+            QSqlField f = d->editBuffer.field(j);
+            if (d->editBuffer.isGenerated(j)) {
+                if (comma) {
+                    fList += QLatin1Char(',');
+                }
+                fList += f.name() + QLatin1String(" = ") + (oraStyle == true ? QLatin1String(":f") + QString::number(cnt) : QString(QLatin1Char('?')));
+                cnt++;
+                comma = true;
+            }
+        }
+        if (!comma) {
+            return 0;
+        }
+        QString str(QLatin1String("update ") + name() + QLatin1String(" set ") + fList);
+        if (filter.length()) {
+            str+= QLatin1String(" where ") + filter;
+        }
+        return applyPrepared(str, invalidate);
+    } else {
+        QString str = QLatin1String("update ") + name();
+        str += QLatin1String(" set ") + toString(&d->editBuffer, QString(), QString(QLatin1Char('=')), QString(QLatin1Char(',')));
+        if (filter.length()) {
+            str+= QLatin1String(" where ") + filter;
+        }
+        return apply(str, invalidate);
+    }
+}
+
+/*!
+    Deletes a record from the database using the cursor's primary
+    index and the contents of the cursor edit buffer. Returns the
+    number of records which were deleted.
+    For error information, use lastError().
+
+    Only records which meet the filter criteria specified by the
+    cursor's primary index are deleted. If the cursor does not contain
+    a primary index, no delete is performed and 0 is returned. If \a
+    invalidate is true (the default), the current cursor can no longer
+    be navigated. A new select() call must be made before you can move
+    to a valid record. For example:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 8
+
+    In the above example, a cursor is created on the 'prices' table
+    and positioned to the record to be deleted. First primeDelete() is
+    called to populate the edit buffer with the current cursor values,
+    e.g. with an id of 999, and then del() is called to actually
+    delete the record from the database. Remember: all edit operations
+    (insert(), update() and delete()) operate on the contents of the
+    cursor edit buffer and not on the contents of the cursor itself.
+
+    \sa primeDelete() setMode() lastError()
+*/
+
+int Q3SqlCursor::del(bool invalidate)
+{
+    QSqlIndex idx = primaryIndex(false);
+    if (idx.isEmpty())
+        return del(qWhereClause(&d->editBuffer, d->nm, QLatin1String("and"), driver()), invalidate);
+    return del(toString(primaryIndex(), &d->editBuffer, d->nm, QString(QLatin1Char('=')), QLatin1String("and")), invalidate);
+}
+
+/*!
+    \overload
+
+    Deletes the current cursor record from the database using the
+    filter \a filter. Only records which meet the filter criteria are
+    deleted. Returns the number of records which were deleted. If \a
+    invalidate is true (the default), the current cursor can no longer
+    be navigated. A new select() call must be made before you can move
+    to a valid record. For error information, use lastError().
+
+    The \a filter is an SQL \c WHERE clause, e.g. \c{id=500}.
+
+    \sa setMode() lastError()
+*/
+
+int Q3SqlCursor::del(const QString & filter, bool invalidate)
+{
+    if ((d->md & Delete) != Delete)
+        return 0;
+    int k = count();
+    if(k == 0) return 0;
+    QString str = QLatin1String("delete from ") + name();
+    if (filter.length())
+        str+= QLatin1String(" where ") + filter;
+    return apply(str, invalidate);
+}
+
+/*
+  \internal
+*/
+
+int Q3SqlCursor::apply(const QString& q, bool invalidate)
+{
+    int ar = 0;
+    if (invalidate) {
+        if (exec(q))
+            ar = numRowsAffected();
+    } else if (driver()) {
+        QSqlQuery* sql = d->query();
+        if (sql && sql->exec(q))
+            ar = sql->numRowsAffected();
+    }
+    return ar;
+}
+
+/*
+  \internal
+*/
+
+int Q3SqlCursor::applyPrepared(const QString& q, bool invalidate)
+{
+    int ar = 0;
+    QSqlQuery* sql = 0;
+
+    if (invalidate) {
+        sql = (QSqlQuery*)this;
+        d->lastAt = QSql::BeforeFirst;
+    } else {
+        sql = d->query();
+    }
+    if (!sql)
+        return 0;
+
+    if (invalidate || sql->lastQuery() != q) {
+        if (!sql->prepare(q))
+            return 0;
+    }
+
+    int cnt = 0;
+    int fieldCount = (int)count();
+    for (int j = 0; j < fieldCount; ++j) {
+        const QSqlField f = d->editBuffer.field(j);
+        if (d->editBuffer.isGenerated(j)) {
+            if (f.type() == QVariant::ByteArray)
+                sql->bindValue(cnt, f.value(), QSql::In | QSql::Binary);
+            else
+                sql->bindValue(cnt, f.value());
+            cnt++;
+        }
+    }
+    if (sql->exec()) {
+        ar = sql->numRowsAffected();
+    }
+    return ar;
+}
+
+/*!
+  Executes the SQL query \a sql. Returns true of the cursor is
+  active, otherwise returns false.
+*/
+bool Q3SqlCursor::exec(const QString & sql)
+{
+    d->lastAt = QSql::BeforeFirst;
+    QSqlQuery::exec(sql);
+    return isActive();
+}
+
+/*!
+    Protected virtual function which is called whenever a field needs
+    to be calculated. If calculated fields are being used, derived
+    classes must reimplement this function and return the appropriate
+    value for field \a name. The default implementation returns an
+    invalid QVariant.
+
+    \sa setCalculated()
+*/
+
+QVariant Q3SqlCursor::calculateField(const QString&)
+{
+    return QVariant();
+}
+
+/*! \internal
+   Ensure fieldlist is synced with query.
+
+*/
+
+static QString qTrim(const QString& s)
+{
+    QString result = s;
+    int end = result.length() - 1;
+    while (end >= 0 && result[end].isSpace()) // skip white space from end
+        end--;
+    result.truncate(end + 1);
+    return result;
+}
+
+/*! \internal
+ */
+
+void Q3SqlCursor::sync()
+{
+    if (isActive() && isValid() && d->lastAt != at()) {
+        d->lastAt = at();
+        int i = 0;
+        int j = 0;
+        bool haveCalculatedFields = false;
+        for (; i < count(); ++i) {
+            if (!haveCalculatedFields && d->infoBuffer[i].isCalculated()) {
+                haveCalculatedFields = true;
+            }
+            if (QSqlRecord::isGenerated(i)) {
+                QVariant v = QSqlQuery::value(j);
+                if ((v.type() == QVariant::String) &&
+                        d->infoBuffer[i].isTrim()) {
+                    v = qTrim(v.toString());
+                }
+                QSqlRecord::setValue(i, v);
+                if (QSqlQuery::isNull(j))
+                    QSqlRecord::field(i).clear();
+                j++;
+            }
+        }
+        if (haveCalculatedFields) {
+            for (i = 0; i < count(); ++i) {
+                if (d->infoBuffer[i].isCalculated())
+                    QSqlRecord::setValue(i, calculateField(fieldName(i)));
+            }
+        }
+    }
+}
+
+/*!
+    Returns the value of field number \a i.
+*/
+
+QVariant Q3SqlCursor::value(int i) const
+{
+    const_cast<Q3SqlCursor *>(this)->sync();
+    return QSqlRecord::value(i);
+}
+
+/*! \internal
+  cursors should be filled with Q3SqlFieldInfos...
+*/
+void Q3SqlCursor::append(const QSqlField& field)
+{
+    append(Q3SqlFieldInfo(field));
+}
+
+/*!
+    Returns true if the field \a i is NULL or if there is no field at
+    position \a i; otherwise returns false.
+
+    This is the same as calling QSqlRecord::isNull(\a i)
+*/
+bool Q3SqlCursor::isNull(int i) const
+{
+    const_cast<Q3SqlCursor *>(this)->sync();
+    return QSqlRecord::isNull(i);
+}
+/*!
+    \overload
+
+    Returns true if the field called \a name is NULL or if there is no
+    field called \a name; otherwise returns false.
+
+    This is the same as calling QSqlRecord::isNull(\a name)
+*/
+bool Q3SqlCursor::isNull(const QString& name) const
+{
+    const_cast<Q3SqlCursor *>(this)->sync();
+    return QSqlRecord::isNull(name);
+}
+
+/*! \internal */
+void Q3SqlCursor::setValue(int i, const QVariant& val)
+{
+    sync();
+#ifdef QT_DEBUG
+    qDebug("Q3SqlCursor::setValue(): This will not affect actual database values. Use primeInsert(), primeUpdate() or primeDelete().");
+#endif
+    QSqlRecord::setValue(i, val);
+}
+
+/*! \internal */
+bool Q3SqlCursor::seek(int i, bool relative)
+{
+    bool res = QSqlQuery::seek(i, relative);
+    sync();
+    return res;
+}
+
+/*! \internal */
+bool Q3SqlCursor::next()
+{
+    bool res = QSqlQuery::next();
+    sync();
+    return res;
+}
+
+/*!
+    \fn Q3SqlCursor::previous()
+
+    \internal
+*/
+
+/*! \internal */
+bool Q3SqlCursor::prev()
+{
+    bool res = QSqlQuery::previous();
+    sync();
+    return res;
+}
+
+/*! \internal */
+bool Q3SqlCursor::first()
+{
+    bool res = QSqlQuery::first();
+    sync();
+    return res;
+}
+
+/*! \internal */
+bool Q3SqlCursor::last()
+{
+    bool res = QSqlQuery::last();
+    sync();
+    return res;
+}
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/qt3support/sql/q3sqlcursor.h b/src/qt3support/sql/q3sqlcursor.h
new file mode 100644
index 0000000..9544fb5
--- /dev/null
+++ b/src/qt3support/sql/q3sqlcursor.h
@@ -0,0 +1,167 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLCURSOR_H
+#define Q3SQLCURSOR_H
+
+#include <QtCore/qvariant.h>
+#include <QtSql/qsqldatabase.h>
+#include <QtSql/qsqlrecord.h>
+#include <QtCore/qstringlist.h>
+#include <QtSql/qsqlquery.h>
+#include <QtSql/qsqlindex.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL
+
+class Q3SqlCursorPrivate;
+class Q3SqlFieldInfo;
+
+class Q_COMPAT_EXPORT Q3SqlCursor : public QSqlRecord, public QSqlQuery
+{
+public:
+    Q3SqlCursor(const QString & name = QString(), bool autopopulate = true,
+               QSqlDatabase db = QSqlDatabase());
+    Q3SqlCursor(const Q3SqlCursor & other);
+    Q3SqlCursor& operator=(const Q3SqlCursor& other);
+    virtual ~Q3SqlCursor();
+
+    enum Mode {
+        ReadOnly = 0,
+        Insert = 1,
+        Update = 2,
+        Delete = 4,
+        Writable = 7
+    };
+
+    QVariant value(int i) const;
+    inline QVariant value(const QString &name) const { return value(indexOf(name)); }
+    virtual void setValue(int i, const QVariant &val);
+    inline void setValue(const QString &name, const QVariant &val) { setValue(indexOf(name), val); }
+    virtual QSqlIndex primaryIndex(bool prime = true) const;
+    virtual QSqlIndex index(const QStringList& fieldNames) const;
+    QSqlIndex index(const QString& fieldName) const;
+    virtual void setPrimaryIndex(const QSqlIndex& idx);
+
+    virtual void append(const Q3SqlFieldInfo& fieldInfo);
+    virtual void insert(int pos, const Q3SqlFieldInfo &fieldInfo);
+    virtual void remove(int pos);
+    virtual void clear();
+    virtual void setGenerated(const QString& name, bool generated);
+    virtual void setGenerated(int i, bool generated);
+
+    virtual QSqlRecord*        editBuffer(bool copy = false);
+    virtual QSqlRecord*        primeInsert();
+    virtual QSqlRecord*        primeUpdate();
+    virtual QSqlRecord*        primeDelete();
+    virtual int                insert(bool invalidate = true);
+    virtual int                update(bool invalidate = true);
+    virtual int                del(bool invalidate = true);
+
+    virtual void        setMode(int flags);
+    int                        mode() const;
+    virtual void        setCalculated(const QString& name, bool calculated);
+    bool                isCalculated(const QString& name) const;
+    virtual void        setTrimmed(const QString& name, bool trim);
+    bool                isTrimmed(const QString& name) const;
+
+    bool                isReadOnly() const;
+    bool                canInsert() const;
+    bool                canUpdate() const;
+    bool                canDelete() const;
+
+    bool                select();
+    bool                select(const QSqlIndex& sort);
+    bool                select(const QSqlIndex & filter, const QSqlIndex & sort);
+    virtual bool        select(const QString & filter, const QSqlIndex & sort = QSqlIndex());
+
+    virtual void        setSort(const QSqlIndex& sort);
+    QSqlIndex                sort() const;
+    virtual void        setFilter(const QString& filter);
+    QString                filter() const;
+    virtual void        setName(const QString& name, bool autopopulate = true);
+    QString                name() const;
+    QString                toString(const QString& prefix = QString(),
+                                const QString& sep = QLatin1String(",")) const;
+    bool                 isNull(int i) const;
+    bool                 isNull(const QString& name) const;
+    virtual bool seek(int i, bool relative = false);
+    virtual bool next();
+    inline bool previous() { return prev(); }
+    virtual bool prev();
+    virtual bool first();
+    virtual bool last();
+
+protected:
+    virtual bool        exec(const QString & sql);
+
+    virtual QVariant calculateField(const QString& name);
+    virtual int                update(const QString & filter, bool invalidate = true);
+    virtual int                del(const QString & filter, bool invalidate = true);
+
+    virtual QString        toString(const QString& prefix, QSqlField* field, const QString& fieldSep) const;
+    virtual QString        toString(QSqlRecord* rec, const QString& prefix, const QString& fieldSep,
+                                const QString& sep) const;
+    virtual QString        toString(const QSqlIndex& i, QSqlRecord* rec, const QString& prefix,
+                                const QString& fieldSep, const QString& sep) const;
+
+private:
+    void                sync();
+    int                        apply(const QString& q, bool invalidate);
+    int                        applyPrepared(const QString& q, bool invalidate);
+    QSqlRecord&                operator=(const QSqlRecord & list);
+    void                 append(const QSqlField& field);
+
+    Q3SqlCursorPrivate*        d;
+};
+
+#endif // QT_NO_SQL
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3SQLCURSOR_H
diff --git a/src/qt3support/sql/q3sqleditorfactory.cpp b/src/qt3support/sql/q3sqleditorfactory.cpp
new file mode 100644
index 0000000..5d71ad7
--- /dev/null
+++ b/src/qt3support/sql/q3sqleditorfactory.cpp
@@ -0,0 +1,229 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3sqleditorfactory.h"
+
+#ifndef QT_NO_SQL_EDIT_WIDGETS
+
+#include "qsqlfield.h"
+#include "q3cleanuphandler.h"
+#include "qlabel.h"
+#include "qlineedit.h"
+#include "qspinbox.h"
+#include "qcombobox.h"
+#include "qdatetimeedit.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class Q3SqlEditorFactory
+    \brief The Q3SqlEditorFactory class is used to create the editors
+    used by Q3DataTable and Q3SqlForm.
+
+    \compat
+
+    Q3SqlEditorFactory is used by Q3DataTable and Q3SqlForm to
+    automatically create appropriate editors for a given QSqlField.
+    For example if the field is a QVariant::String a QLineEdit would
+    be the default editor, whereas a QVariant::Int's default editor
+    would be a QSpinBox.
+
+    If you want to create different editors for fields with the same
+    data type, subclass Q3SqlEditorFactory and reimplement the
+    createEditor() function.
+
+    \sa Q3DataTable, Q3SqlForm
+*/
+
+
+/*!
+    Constructs a SQL editor factory with parent \a parent.
+*/
+
+Q3SqlEditorFactory::Q3SqlEditorFactory (QObject * parent)
+    : Q3EditorFactory(parent)
+{
+
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+Q3SqlEditorFactory::~Q3SqlEditorFactory()
+{
+
+}
+
+static Q3SqlEditorFactory * defaultfactory = 0;
+static Q3CleanupHandler< Q3SqlEditorFactory > qsql_cleanup_editor_factory;
+
+/*!
+    Returns an instance of a default editor factory.
+*/
+
+Q3SqlEditorFactory * Q3SqlEditorFactory::defaultFactory()
+{
+    if(defaultfactory == 0){
+        defaultfactory = new Q3SqlEditorFactory();
+        qsql_cleanup_editor_factory.add(&defaultfactory);
+    }
+
+    return defaultfactory;
+}
+
+/*!
+    Replaces the default editor factory with \a factory. All
+    Q3DataTable and Q3SqlForm instantiations will use this new factory
+    for creating field editors. \e{Q3SqlEditorFactory takes ownership
+    of \a factory, and destroys it when it is no longer needed.}
+*/
+
+void Q3SqlEditorFactory::installDefaultFactory(Q3SqlEditorFactory * factory)
+{
+    if(factory == 0) return;
+
+    if(defaultfactory != 0){
+        qsql_cleanup_editor_factory.remove(&defaultfactory);
+        delete defaultfactory;
+    }
+    defaultfactory = factory;
+    qsql_cleanup_editor_factory.add(&defaultfactory);
+}
+
+/*!
+    Creates and returns the appropriate editor widget for the QVariant
+    \a variant.
+
+    The widget that is returned has the parent \a parent (which may be
+    zero). If \a variant is invalid, 0 is returned.
+*/
+
+QWidget * Q3SqlEditorFactory::createEditor(QWidget * parent,
+                                           const QVariant & variant)
+{
+    return Q3EditorFactory::createEditor(parent, variant);
+}
+
+/*!
+    \overload
+
+    Creates and returns the appropriate editor for the QSqlField \a
+    field.
+*/
+
+QWidget * Q3SqlEditorFactory::createEditor(QWidget * parent,
+                                           const QSqlField * field)
+{
+    if (!field) {
+        return 0;
+    }
+
+    QWidget * w = 0;
+    switch(field->type()){
+        case QVariant::Invalid:
+            w = 0;
+            break;
+        case QVariant::Bool:
+            w = new QComboBox(parent, "qt_editor_bool");
+            ((QComboBox *) w)->insertItem(QLatin1String("False"));
+            ((QComboBox *) w)->insertItem(QLatin1String("True"));
+            break;
+        case QVariant::UInt:
+            w = new QSpinBox(0, 2147483647, 1, parent, "qt_editor_spinbox");
+            break;
+        case QVariant::Int:
+            w = new QSpinBox(-2147483647, 2147483647, 1, parent, "qt_editor_int");
+            break;
+        case QVariant::LongLong:
+        case QVariant::ULongLong:
+        case QVariant::String:
+        case QVariant::Double:
+            w = new QLineEdit(parent, "qt_editor_double");
+            ((QLineEdit*)w)->setFrame(false);
+            break;
+        case QVariant::Date: {
+            QDateTimeEdit *edit = new QDateTimeEdit(parent);
+            edit->setDisplayFormat(QLatin1String("yyyy/MM/dd"));
+            edit->setObjectName(QLatin1String("qt_editor_date"));
+            w = edit; }
+            break;
+        case QVariant::Time: {
+            QDateTimeEdit *edit = new QDateTimeEdit(parent);
+            edit->setDisplayFormat(QLatin1String("hh:mm"));
+            edit->setObjectName(QLatin1String("qt_editor_time"));
+            w = edit; }
+            break;
+        case QVariant::DateTime:
+            w = new QDateTimeEdit(parent);
+            w->setObjectName(QLatin1String("qt_editor_datetime"));
+            break;
+#ifndef QT_NO_LABEL
+        case QVariant::Pixmap:
+            w = new QLabel(parent, "qt_editor_pixmap");
+            break;
+#endif
+        case QVariant::Palette:
+        case QVariant::Color:
+        case QVariant::Font:
+        case QVariant::Brush:
+        case QVariant::Bitmap:
+        case QVariant::Cursor:
+        case QVariant::Map:
+        case QVariant::StringList:
+        case QVariant::Rect:
+        case QVariant::Size:
+        case QVariant::IconSet:
+        case QVariant::Point:
+        case QVariant::PointArray:
+        case QVariant::Region:
+        case QVariant::SizePolicy:
+        case QVariant::ByteArray:
+        default:
+            w = new QWidget(parent, "qt_editor_default");
+            break;
+    }
+    return w;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SQL
diff --git a/src/qt3support/sql/q3sqleditorfactory.h b/src/qt3support/sql/q3sqleditorfactory.h
new file mode 100644
index 0000000..803d0eb
--- /dev/null
+++ b/src/qt3support/sql/q3sqleditorfactory.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLEDITORFACTORY_H
+#define Q3SQLEDITORFACTORY_H
+
+#include <Qt3Support/q3editorfactory.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_EDIT_WIDGETS
+
+class QSqlField;
+
+class Q_COMPAT_EXPORT Q3SqlEditorFactory : public Q3EditorFactory
+{
+public:
+    Q3SqlEditorFactory (QObject * parent = 0);
+    ~Q3SqlEditorFactory();
+    virtual QWidget * createEditor(QWidget * parent, const QVariant & variant);
+    virtual QWidget * createEditor(QWidget * parent, const QSqlField * field);
+
+    static Q3SqlEditorFactory * defaultFactory();
+    static void installDefaultFactory(Q3SqlEditorFactory * factory);
+
+private:
+    Q_DISABLE_COPY(Q3SqlEditorFactory)
+};
+
+#endif // QT_NO_SQL_EDIT_WIDGETS
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3SQLEDITORFACTORY_H
diff --git a/src/qt3support/sql/q3sqlfieldinfo.h b/src/qt3support/sql/q3sqlfieldinfo.h
new file mode 100644
index 0000000..e2b4db3
--- /dev/null
+++ b/src/qt3support/sql/q3sqlfieldinfo.h
@@ -0,0 +1,167 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLFIELDINFO_H
+#define Q3SQLFIELDINFO_H
+
+#ifndef QT_NO_SQL
+
+#include <QtCore/qglobal.h>
+#include <QtSql/qsqlfield.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+/* Q3SqlFieldInfo Class
+   obsoleted, use QSqlField instead
+*/
+
+class Q_COMPAT_EXPORT Q3SqlFieldInfo
+{
+    // class is obsoleted, won't change anyways,
+    // so no d pointer
+    int req, len, prec, tID;
+    uint gen: 1;
+    uint trim: 1;
+    uint calc: 1;
+    QString nm;
+    QVariant::Type typ;
+    QVariant defValue;
+
+public:
+    Q3SqlFieldInfo(const QString& name = QString(),
+                   QVariant::Type typ = QVariant::Invalid,
+                   int required = -1,
+                   int len = -1,
+                   int prec = -1,
+                   const QVariant& defValue = QVariant(),
+                   int sqlType = 0,
+                   bool generated = true,
+                   bool trim = false,
+                   bool calculated = false) :
+        req(required), len(len), prec(prec), tID(sqlType),
+        gen(generated), trim(trim), calc(calculated),
+        nm(name), typ(typ), defValue(defValue) {}
+
+    virtual ~Q3SqlFieldInfo() {}
+
+    Q3SqlFieldInfo(const QSqlField & other)
+    {
+        nm = other.name();
+        typ = other.type();
+        switch (other.requiredStatus()) {
+        case QSqlField::Unknown: req = -1; break;
+        case QSqlField::Required: req = 1; break;
+        case QSqlField::Optional: req = 0; break;
+        }
+        len = other.length();
+        prec = other.precision();
+        defValue = other.defaultValue();
+        tID = other.typeID();
+        gen = other.isGenerated();
+        calc = false;
+        trim = false;
+    }
+
+    bool operator==(const Q3SqlFieldInfo& f) const
+    {
+        return (nm == f.nm &&
+                typ == f.typ &&
+                req == f.req &&
+                len == f.len &&
+                prec == f.prec &&
+                defValue == f.defValue &&
+                tID == f.tID &&
+                gen == f.gen &&
+                trim == f.trim &&
+                calc == f.calc);
+    }
+
+    QSqlField toField() const
+    { QSqlField f(nm, typ);
+      f.setRequiredStatus(QSqlField::RequiredStatus(req));
+      f.setLength(len);
+      f.setPrecision(prec);
+      f.setDefaultValue(defValue);
+      f.setSqlType(tID);
+      f.setGenerated(gen);
+      return f;
+    }
+    int isRequired() const
+    { return req; }
+    QVariant::Type type() const
+    { return typ; }
+    int length() const
+    { return len; }
+    int precision() const
+    { return prec; }
+    QVariant defaultValue() const
+    { return defValue; }
+    QString name() const
+    { return nm; }
+    int typeID() const
+    { return tID; }
+    bool isGenerated() const
+    { return gen; }
+    bool isTrim() const
+    { return trim; }
+    bool isCalculated() const
+    { return calc; }
+
+    virtual void setTrim(bool trim)
+    { this->trim = trim; }
+    virtual void setGenerated(bool generated)
+    { gen = generated; }
+    virtual void setCalculated(bool calculated)
+    { calc = calculated; }
+
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_SQL
+
+#endif // Q3SQLFIELDINFO_H
diff --git a/src/qt3support/sql/q3sqlform.cpp b/src/qt3support/sql/q3sqlform.cpp
new file mode 100644
index 0000000..f02e85e
--- /dev/null
+++ b/src/qt3support/sql/q3sqlform.cpp
@@ -0,0 +1,378 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3sqlform.h"
+
+#ifndef QT_NO_SQL_FORM
+
+#include "qsqlfield.h"
+#include "q3sqlpropertymap.h"
+#include "qsqlrecord.h"
+#include "qstringlist.h"
+#include "qwidget.h"
+#include "qhash.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q3SqlFormPrivate
+{
+public:
+    Q3SqlFormPrivate() : propertyMap(0), buf(0), dirty(false) {}
+    ~Q3SqlFormPrivate() { if (propertyMap) delete propertyMap; }
+    QStringList fld;
+    QHash <QString, QWidget*> wgt;
+    QMap <QWidget*, QSqlField *> map;
+    Q3SqlPropertyMap * propertyMap;
+    QSqlRecord* buf;
+    bool dirty;
+};
+
+/*!
+    \class Q3SqlForm
+    \brief The Q3SqlForm class creates and manages data entry forms
+    tied to SQL databases.
+
+    \compat
+
+    Typical use of a Q3SqlForm consists of the following steps:
+    \list
+    \i Create the widgets you want to appear in the form.
+    \i Create a cursor and navigate to the record to be edited.
+    \i Create the Q3SqlForm.
+    \i Set the form's record buffer to the cursor's update buffer.
+    \i Insert each widget and the field it is to edit into the form.
+    \i Use readFields() to update the editor widgets with values from
+    the database's fields.
+    \i Display the form and let the user edit values etc.
+    \i Use writeFields() to update the database's field values with
+    the values in the editor widgets.
+    \endlist
+
+    Note that a Q3SqlForm does not access the database directly, but
+    most often via QSqlFields which are part of a Q3SqlCursor. A
+    Q3SqlCursor::insert(), Q3SqlCursor::update() or Q3SqlCursor::del()
+    call is needed to actually write values to the database.
+
+    Some sample code to initialize a form successfully:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlform.cpp 0
+
+    If you want to use custom editors for displaying and editing data
+    fields, you must install a custom Q3SqlPropertyMap. The form
+    uses this object to get or set the value of a widget.
+
+    \sa installPropertyMap(), Q3SqlPropertyMap
+*/
+
+
+/*!
+    Constructs a Q3SqlForm with parent \a parent.
+*/
+Q3SqlForm::Q3SqlForm(QObject * parent)
+    : QObject(parent)
+{
+    d = new Q3SqlFormPrivate();
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+Q3SqlForm::~Q3SqlForm()
+{
+    delete d;
+}
+
+/*!
+    Installs a custom Q3SqlPropertyMap. This is useful if you plan to
+    create your own custom editor widgets.
+
+    Q3SqlForm takes ownership of \a pmap, so \a pmap is deleted when
+    Q3SqlForm goes out of scope.
+
+    \sa Q3DataTable::installEditorFactory()
+*/
+void Q3SqlForm::installPropertyMap(Q3SqlPropertyMap * pmap)
+{
+    if(d->propertyMap)
+        delete d->propertyMap;
+    d->propertyMap = pmap;
+}
+
+/*!
+    Sets \a buf as the record buffer for the form. To force the
+    display of the data from \a buf, use readFields().
+
+    \sa readFields() writeFields()
+*/
+
+void Q3SqlForm::setRecord(QSqlRecord* buf)
+{
+    d->dirty = true;
+    d->buf = buf;
+}
+
+/*!
+    Inserts a \a widget, and the name of the \a field it is to be
+    mapped to, into the form. To actually associate inserted widgets
+    with an edit buffer, use setRecord().
+
+    \sa setRecord()
+*/
+
+void Q3SqlForm::insert(QWidget * widget, const QString& field)
+{
+    d->dirty = true;
+    d->wgt.insert(field, widget);
+    d->fld += field;
+}
+
+/*!
+    \overload
+
+    Removes \a field from the form.
+*/
+
+void Q3SqlForm::remove(const QString& field)
+{
+    d->dirty = true;
+    int i = d->fld.indexOf(field);
+    if (i >= 0)
+        d->fld.removeAt(i);
+    d->wgt.remove(field);
+}
+
+/*!
+    \overload
+
+    Inserts a \a widget, and the \a field it is to be mapped to, into
+    the form.
+*/
+
+void Q3SqlForm::insert(QWidget * widget, QSqlField * field)
+{
+    d->map[widget] = field;
+}
+
+/*!
+    Removes a \a widget, and hence the field it's mapped to, from the
+    form.
+*/
+
+void Q3SqlForm::remove(QWidget * widget)
+{
+    d->map.remove(widget);
+}
+
+/*!
+    Clears the values in all the widgets, and the fields they are
+    mapped to, in the form, and sets them to NULL.
+*/
+void Q3SqlForm::clearValues()
+{
+    QMap< QWidget *, QSqlField * >::Iterator it;
+    for(it = d->map.begin(); it != d->map.end(); ++it){
+        QSqlField* f = (*it);
+        if (f)
+            f->clear();
+    }
+    readFields();
+}
+
+/*!
+    Removes every widget, and the fields they're mapped to, from the form.
+*/
+void Q3SqlForm::clear()
+{
+    d->dirty = true;
+    d->fld.clear();
+    clearMap();
+}
+
+/*!
+    Returns the number of widgets in the form.
+*/
+int Q3SqlForm::count() const
+{
+    return d->map.size();
+}
+
+/*!
+    Returns the \a{i}-th widget in the form. Useful for traversing
+    the widgets in the form.
+*/
+QWidget * Q3SqlForm::widget(int i) const
+{
+    QMap< QWidget *, QSqlField * >::ConstIterator it;
+    int cnt = 0;
+
+    if(i > d->map.size())
+        return 0;
+    for(it = d->map.constBegin(); it != d->map.constEnd(); ++it){
+        if(cnt++ == i)
+            return it.key();
+    }
+    return 0;
+}
+
+/*!
+    Returns the widget that field \a field is mapped to.
+*/
+QWidget * Q3SqlForm::fieldToWidget(QSqlField * field) const
+{
+    QMap< QWidget *, QSqlField * >::ConstIterator it;
+    for(it = d->map.constBegin(); it != d->map.constEnd(); ++it){
+        if(*it == field)
+            return it.key();
+    }
+    return 0;
+}
+
+/*!
+    Returns the SQL field that widget \a widget is mapped to.
+*/
+QSqlField * Q3SqlForm::widgetToField(QWidget * widget) const
+{
+    return d->map.value(widget, 0);
+}
+
+/*!
+    Updates the widgets in the form with current values from the SQL
+    fields they are mapped to.
+*/
+void Q3SqlForm::readFields()
+{
+    sync();
+    QSqlField * f;
+    QMap< QWidget *, QSqlField * >::Iterator it;
+    Q3SqlPropertyMap * pmap = (d->propertyMap == 0) ?
+                             Q3SqlPropertyMap::defaultMap() : d->propertyMap;
+    for(it = d->map.begin() ; it != d->map.end(); ++it){
+        f = widgetToField(it.key());
+        if(!f)
+            continue;
+        pmap->setProperty(it.key(), f->value());
+    }
+}
+
+/*!
+    Updates the SQL fields with values from the widgets they are
+    mapped to. To actually update the database with the contents of
+    the record buffer, use Q3SqlCursor::insert(), Q3SqlCursor::update()
+    or Q3SqlCursor::del() as appropriate.
+*/
+void Q3SqlForm::writeFields()
+{
+    sync();
+    QSqlField * f;
+    QMap< QWidget *, QSqlField * >::Iterator it;
+    Q3SqlPropertyMap * pmap = (d->propertyMap == 0) ?
+                             Q3SqlPropertyMap::defaultMap() : d->propertyMap;
+
+    for(it = d->map.begin() ; it != d->map.end(); ++it){
+        f = widgetToField(it.key());
+        if(!f)
+            continue;
+        f->setValue(pmap->property(it.key()));
+    }
+}
+
+/*!
+    Updates the widget \a widget with the value from the SQL field it
+    is mapped to. Nothing happens if no SQL field is mapped to the \a
+    widget.
+*/
+void Q3SqlForm::readField(QWidget * widget)
+{
+    sync();
+    QSqlField * field = 0;
+    Q3SqlPropertyMap * pmap = (d->propertyMap == 0) ?
+                             Q3SqlPropertyMap::defaultMap() : d->propertyMap;
+    field = widgetToField(widget);
+    if(field)
+        pmap->setProperty(widget, field->value());
+}
+
+/*!
+    Updates the SQL field with the value from the \a widget it is
+    mapped to. Nothing happens if no SQL field is mapped to the \a
+    widget.
+*/
+void Q3SqlForm::writeField(QWidget * widget)
+{
+    sync();
+    QSqlField * field = 0;
+    Q3SqlPropertyMap * pmap = (d->propertyMap == 0) ?
+                             Q3SqlPropertyMap::defaultMap() : d->propertyMap;
+    field = widgetToField(widget);
+    if(field)
+        field->setValue(pmap->property(widget));
+}
+
+/*! \internal
+*/
+
+void Q3SqlForm::sync()
+{
+    if (d->dirty) {
+        clearMap();
+        if (d->buf) {
+            for (int i = 0; i < d->fld.count(); ++i) {
+                const QSqlField *field = d->buf->fieldPtr(d->fld.at(i));
+                insert(d->wgt.value(d->fld.at(i)), const_cast<QSqlField *>(field));
+            }
+        }
+    }
+    d->dirty = false;
+}
+
+/*! \internal
+
+  Clears the internal map of widget/field associations
+*/
+
+void Q3SqlForm::clearMap()
+{
+    d->map.clear();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SQL
diff --git a/src/qt3support/sql/q3sqlform.h b/src/qt3support/sql/q3sqlform.h
new file mode 100644
index 0000000..b6b76b7
--- /dev/null
+++ b/src/qt3support/sql/q3sqlform.h
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLFORM_H
+#define Q3SQLFORM_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qmap.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_FORM
+
+class QSqlField;
+class QSqlRecord;
+class Q3SqlEditorFactory;
+class Q3SqlPropertyMap;
+class QWidget;
+class Q3SqlFormPrivate;
+
+class Q_COMPAT_EXPORT Q3SqlForm : public QObject
+{
+    Q_OBJECT
+public:
+    Q3SqlForm(QObject * parent = 0);
+    ~Q3SqlForm();
+
+    virtual void insert(QWidget * widget, const QString& field);
+    virtual void remove(const QString& field);
+    int         count() const;
+
+    QWidget *   widget(int i) const;
+    QSqlField * widgetToField(QWidget * widget) const;
+    QWidget *   fieldToWidget(QSqlField * field) const;
+
+    void        installPropertyMap(Q3SqlPropertyMap * map);
+
+    virtual void setRecord(QSqlRecord* buf);
+
+public Q_SLOTS:
+    virtual void readField(QWidget * widget);
+    virtual void writeField(QWidget * widget);
+    virtual void readFields();
+    virtual void writeFields();
+
+    virtual void clear();
+    virtual void clearValues();
+
+protected:
+    virtual void insert(QWidget * widget, QSqlField * field);
+    virtual void remove(QWidget * widget);
+    void clearMap();
+
+private:
+    Q_DISABLE_COPY(Q3SqlForm)
+
+    virtual void sync();
+    Q3SqlFormPrivate* d;
+};
+
+#endif // QT_NO_SQL_FORM
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3SQLFORM_H
diff --git a/src/qt3support/sql/q3sqlmanager_p.cpp b/src/qt3support/sql/q3sqlmanager_p.cpp
new file mode 100644
index 0000000..146be96
--- /dev/null
+++ b/src/qt3support/sql/q3sqlmanager_p.cpp
@@ -0,0 +1,961 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3sqlmanager_p.h"
+
+#ifndef QT_NO_SQL
+
+#include "qapplication.h"
+#include "qcursor.h"
+#include "qwidget.h"
+#include "q3sqlcursor.h"
+#include "qsqlfield.h"
+#include "q3sqlform.h"
+#include "qsqldriver.h"
+#include "qstring.h"
+#include "qmessagebox.h"
+#include "qbitarray.h"
+
+QT_BEGIN_NAMESPACE
+
+//#define QT_DEBUG_DATAMANAGER
+
+class Q3SqlCursorManagerPrivate
+{
+public:
+    Q3SqlCursorManagerPrivate()
+        : cur(0), autoDelete(false)
+    {}
+
+    QString ftr;
+    QStringList srt;
+    Q3SqlCursor* cur;
+    bool autoDelete;
+};
+
+static QSqlIndex indexFromStringList(const QStringList& l, const Q3SqlCursor* cursor)
+{
+    QSqlIndex newSort;
+    for (int i = 0; i < l.count(); ++i) {
+        QString f = l[i];
+        bool desc = false;
+        if (f.mid(f.length()-3) == QLatin1String("ASC"))
+            f = f.mid(0, f.length()-3);
+        if (f.mid(f.length()-4) == QLatin1String("DESC")) {
+            desc = true;
+            f = f.mid(0, f.length()-4);
+        }
+        int dot = f.lastIndexOf(QLatin1Char('.'));
+        if (dot != -1)
+            f = f.mid(dot+1);
+        const QSqlField field = cursor->field(f.trimmed());
+        if (field.isValid())
+            newSort.append(field, desc);
+        else
+            qWarning("QSqlIndex::indexFromStringList: unknown field: '%s'", f.latin1());
+    }
+    return newSort;
+}
+
+
+/*!
+  \class Q3SqlCursorManager
+  \brief The Q3SqlCursorManager class manages a database cursor.
+
+  \compat
+  \internal
+
+  This class provides common cursor management functionality.  This
+  includes saving and applying sorts and filters, refreshing (i.e.,
+  re-selecting) the cursor and searching for records within the
+  cursor.
+
+*/
+
+/*!  \internal
+
+  Constructs a cursor manager.
+
+*/
+
+Q3SqlCursorManager::Q3SqlCursorManager()
+{
+    d = new Q3SqlCursorManagerPrivate;
+}
+
+
+/*! \internal
+
+  Destroys the object and frees any allocated resources.
+
+*/
+
+Q3SqlCursorManager::~Q3SqlCursorManager()
+{
+    if (d->autoDelete)
+        delete d->cur;
+    delete d;
+}
+
+/*! \internal
+
+  Sets the manager's sort to the index \a sort.  To apply the new
+  sort, use refresh().
+
+ */
+
+void Q3SqlCursorManager::setSort(const QSqlIndex& sort)
+{
+    setSort(sort.toStringList());
+}
+
+/*! \internal
+
+  Sets the manager's sort to the stringlist \a sort.  To apply the
+  new sort, use refresh().
+
+ */
+
+void Q3SqlCursorManager::setSort(const QStringList& sort)
+{
+    d->srt = sort;
+}
+
+/*! \internal
+
+  Returns the current sort, or an empty stringlist if there is none.
+
+*/
+
+QStringList  Q3SqlCursorManager::sort() const
+{
+    return d->srt;
+}
+
+/*! \internal
+
+  Sets the manager's filter to the string \a filter.  To apply the
+  new filter, use refresh().
+
+*/
+
+void Q3SqlCursorManager::setFilter(const QString& filter)
+{
+    d->ftr = filter;
+}
+
+/*! \internal
+
+  Returns the current filter, or an empty string if there is none.
+
+*/
+
+QString Q3SqlCursorManager::filter() const
+{
+    return d->ftr;
+}
+
+/*! \internal
+
+  Sets auto-delete to \a enable.  If true, the default cursor will
+  be deleted when necessary.
+
+  \sa autoDelete()
+*/
+
+void Q3SqlCursorManager::setAutoDelete(bool enable)
+{
+    d->autoDelete = enable;
+}
+
+
+/*! \internal
+
+  Returns true if auto-deletion is enabled, otherwise false.
+
+  \sa setAutoDelete()
+
+*/
+
+bool Q3SqlCursorManager::autoDelete() const
+{
+    return d->autoDelete;
+}
+
+/*! \internal
+
+  Sets the default cursor used by the manager to \a cursor.  If \a
+  autoDelete is true (the default is false), the manager takes
+  ownership of the \a cursor pointer, which will be deleted when the
+  manager is destroyed, or when setCursor() is called again. To
+  activate the \a cursor use refresh().
+
+  \sa cursor()
+
+*/
+
+void Q3SqlCursorManager::setCursor(Q3SqlCursor* cursor, bool autoDelete)
+{
+    if (d->autoDelete)
+        delete d->cur;
+    d->cur = cursor;
+    d->autoDelete = autoDelete;
+}
+
+/*! \internal
+
+  Returns a pointer to the default cursor used for navigation, or 0
+  if there is no default cursor.
+
+  \sa setCursor()
+
+*/
+
+Q3SqlCursor* Q3SqlCursorManager::cursor() const
+{
+    return d->cur;
+}
+
+
+/*! \internal
+
+  Refreshes the manager using the default cursor.  The manager's
+  filter and sort are applied.  Returns true on success, false if an
+  error occurred or there is no current cursor.
+
+  \sa setFilter() setSort()
+
+*/
+
+bool Q3SqlCursorManager::refresh()
+{
+    Q3SqlCursor* cur = cursor();
+    if (!cur)
+        return false;
+    QString currentFilter = d->ftr;
+    QStringList currentSort = d->srt;
+    QSqlIndex newSort = indexFromStringList(currentSort, cur);
+    return cur->select(currentFilter, newSort);
+}
+
+/* \internal
+
+   Returns true if the \a buf field values that correspond to \a idx
+   match the field values in \a cur that correspond to \a idx.
+*/
+
+static bool index_matches(const Q3SqlCursor* cur, const QSqlRecord* buf,
+                           const QSqlIndex& idx)
+{
+    bool indexEquals = false;
+    for (int i = 0; i < idx.count(); ++i) {
+        const QString fn(idx.field(i).name());
+        if (cur->value(fn) == buf->value(fn))
+            indexEquals = true;
+        else {
+            indexEquals = false;
+            break;
+        }
+    }
+    return indexEquals;
+}
+
+/*
+  Return less than, equal to or greater than 0 if buf1 is less than,
+  equal to or greater than buf2 according to fields described in idx.
+  (### Currently only uses first field.)
+*/
+
+static int compare_recs(const QSqlRecord* buf1, const QSqlRecord* buf2,
+                         const QSqlIndex& idx)
+{
+    int cmp = 0;
+
+    int i = 0;
+    const QString fn(idx.field(i).name());
+    const QSqlField f1 = buf1->field(fn);
+
+    if (f1.isValid()) {
+        switch (f1.type()) { // ### more types?
+        case QVariant::String:
+            cmp = f1.value().toString().trimmed().compare(
+                          buf2->value(fn).toString().trimmed());
+            break;
+        default:
+            if (f1.value().toDouble() < buf2->value(fn).toDouble())
+                cmp = -1;
+            else if (f1.value().toDouble() > buf2->value(fn).toDouble())
+                cmp = 1;
+        }
+    }
+
+    if (idx.isDescending(i))
+        cmp = -cmp;
+    return cmp;
+}
+
+#ifdef QT_DEBUG_DATAMANAGER
+static void debug_datamanager_buffer(const QString& msg, QSqlRecord* cursor)
+{
+    qDebug("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
+    qDebug("%s", msg.latin1());
+    for (int j = 0; j < cursor->count(); ++j) {
+        qDebug("%s", (cursor->field(j)->name() + " type:"
+                       + QString(cursor->field(j)->value().typeName())
+                       + " value:" + cursor->field(j)->value().toString())
+                       .latin1());
+    }
+}
+#endif
+
+
+/*! \internal
+
+  Relocates the default cursor to the record matching the cursor's
+edit buffer.  Only the field names specified by \a idx are used to
+determine an exact match of the cursor to the edit buffer. However,
+other fields in the edit buffer are also used during the search,
+therefore all fields in the edit buffer should be primed with desired
+values for the record being sought.  This function is typically used
+to relocate a cursor to the correct position after an insert or
+update.  For example:
+
+\snippet doc/src/snippets/code/src_qt3support_sql_q3sqlmanager_p.cpp 0
+
+*/
+
+//## possibly add sizeHint parameter
+bool Q3SqlCursorManager::findBuffer(const QSqlIndex& idx, int atHint)
+{
+#ifdef QT_DEBUG_DATAMANAGER
+    qDebug("Q3SqlCursorManager::findBuffer:");
+#endif
+    Q3SqlCursor* cur = cursor();
+    if (!cur)
+        return false;
+    if (!cur->isActive())
+        return false;
+    if (!idx.count()) {
+        if (cur->at() == QSql::BeforeFirst)
+            cur->next();
+        return false;
+    }
+    QSqlRecord* buf = cur->editBuffer();
+    bool indexEquals = false;
+#ifdef QT_DEBUG_DATAMANAGER
+    qDebug(" Checking hint...");
+#endif
+    /* check the hint */
+    if (cur->seek(atHint))
+        indexEquals = index_matches(cur, buf, idx);
+
+    if (!indexEquals) {
+#ifdef QT_DEBUG_DATAMANAGER
+        qDebug(" Checking current page...");
+#endif
+        /* check current page */
+        int pageSize = 20;
+        int startIdx = qMax(atHint - pageSize, 0);
+        int endIdx = atHint + pageSize;
+        for (int j = startIdx; j <= endIdx; ++j) {
+            if (cur->seek(j)) {
+                indexEquals = index_matches(cur, buf, idx);
+                if (indexEquals)
+                    break;
+            }
+        }
+    }
+
+    if (!indexEquals && cur->driver()->hasFeature(QSqlDriver::QuerySize)
+         && cur->sort().count()) {
+#ifdef QT_DEBUG_DATAMANAGER
+        qDebug(" Using binary search...");
+#endif
+        // binary search based on record buffer and current sort fields
+        int lo = 0;
+        int hi = cur->size();
+        int mid;
+        if (compare_recs(buf, cur, cur->sort()) >= 0)
+            lo = cur->at();
+        while (lo != hi) {
+            mid = lo + (hi - lo) / 2;
+            if (!cur->seek(mid))
+                break;
+            if (index_matches(cur, buf, idx)) {
+                indexEquals = true;
+                break;
+            }
+            int c = compare_recs(buf, cur, cur->sort());
+            if (c < 0) {
+                hi = mid;
+            } else if (c == 0) {
+                // found it, but there may be duplicates
+                int at = mid;
+                do {
+                    mid--;
+                    if (!cur->seek(mid))
+                        break;
+                    if (index_matches(cur, buf, idx)) {
+                        indexEquals = true;
+                        break;
+                    }
+                } while (compare_recs(buf, cur, cur->sort()) == 0);
+
+                if (!indexEquals) {
+                    mid = at;
+                    do {
+                        mid++;
+                        if (!cur->seek(mid))
+                            break;
+                        if (index_matches(cur, buf, idx)) {
+                            indexEquals = true;
+                            break;
+                        }
+                    } while (compare_recs(buf, cur, cur->sort()) == 0);
+                }
+                break;
+            } else if (c > 0) {
+                lo = mid + 1;
+            }
+        }
+    }
+
+    if (!indexEquals) {
+#ifdef QT_DEBUG_DATAMANAGER
+        qDebug(" Using brute search...");
+#endif
+#ifndef QT_NO_CURSOR
+        QApplication::setOverrideCursor(Qt::WaitCursor);
+#endif
+        /* give up, use brute force */
+        int startIdx = 0;
+        if (cur->at() != startIdx) {
+            cur->seek(startIdx);
+        }
+        for (;;) {
+            indexEquals = false;
+            indexEquals = index_matches(cur, buf, idx);
+            if (indexEquals)
+                break;
+            if (!cur->next())
+                break;
+        }
+#ifndef QT_NO_CURSOR
+        QApplication::restoreOverrideCursor();
+#endif
+    }
+#ifdef QT_DEBUG_DATAMANAGER
+        qDebug(" Done, result:" + QString::number(indexEquals));
+#endif
+    return indexEquals;
+}
+
+#ifndef QT_NO_SQL_FORM
+
+class Q3SqlFormManagerPrivate
+{
+public:
+    Q3SqlFormManagerPrivate() : frm(0), rcd(0) {}
+    Q3SqlForm* frm;
+    QSqlRecord* rcd;
+};
+
+
+/*! \internal
+
+  Creates a form manager.
+
+*/
+
+Q3SqlFormManager::Q3SqlFormManager()
+{
+    d = new Q3SqlFormManagerPrivate();
+}
+
+/*! \internal
+
+  Destroys the object and frees any allocated resources.
+
+*/
+
+Q3SqlFormManager::~Q3SqlFormManager()
+{
+    delete d;
+}
+
+/*!  \internal
+
+  Clears the default form values.  If there is no default form,
+  nothing happens,
+
+*/
+
+void Q3SqlFormManager::clearValues()
+{
+    if (form())
+        form()->clearValues();
+}
+
+/*! \internal
+
+  Sets the form used by the form manager to \a form.  If a record has
+  already been assigned to the form manager, that record is also used by
+  the \a form to display data.
+
+  \sa form()
+
+*/
+
+void Q3SqlFormManager::setForm(Q3SqlForm* form)
+{
+    d->frm = form;
+    if (d->rcd && d->frm)
+        d->frm->setRecord(d->rcd);
+}
+
+
+/*! \internal
+
+  Returns the default form used by the form manager, or 0 if there is
+  none.
+
+  \sa setForm()
+
+*/
+
+Q3SqlForm* Q3SqlFormManager::form()
+{
+    return d->frm;
+}
+
+
+/*! \internal
+
+  Sets the record used by the form manager to \a record.  If a form has
+  already been assigned to the form manager, \a record is also used by
+  the default form to display data.
+
+  \sa record()
+
+*/
+
+void Q3SqlFormManager::setRecord(QSqlRecord* record)
+{
+    d->rcd = record;
+    if (d->frm) {
+        d->frm->setRecord(d->rcd);
+    }
+}
+
+
+/*! \internal
+
+  Returns the default record used by the form manager, or 0 if there is
+  none.
+
+  \sa setRecord()
+*/
+
+QSqlRecord* Q3SqlFormManager::record()
+{
+    return d->rcd;
+}
+
+
+/*! \internal
+
+  Causes the default form to read its fields .  If there is no
+  default form, nothing happens.
+
+  \sa setForm()
+
+*/
+
+void Q3SqlFormManager::readFields()
+{
+    if (d->frm) {
+        d->frm->readFields();
+    }
+}
+
+/*! \internal
+
+  Causes the default form to write its fields .  If there is no
+  default form, nothing happens.
+
+  \sa setForm()
+
+*/
+
+void Q3SqlFormManager::writeFields()
+{
+    if (d->frm) {
+        d->frm->writeFields();
+    }
+}
+
+#endif // QT_NO_SQL_FORM
+
+class Q3DataManagerPrivate
+{
+public:
+    Q3DataManagerPrivate()
+        : mode(QSql::None), autoEd(true), confEdits(3),
+          confCancs(false) {}
+    QSql::Op mode;
+    bool autoEd;
+    QBitArray confEdits;
+    bool confCancs;
+
+};
+
+/*!
+  \class Q3DataManager
+
+  \brief The Q3DataManager class is an internal class for implementing
+  the data-aware widgets.
+
+  \internal
+  \compat
+
+  Q3DataManager is a strictly internal class that acts as a base class
+  for other data-aware widgets.
+
+*/
+
+
+/*!  \internal
+
+  Constructs an empty data handler.
+
+*/
+
+Q3DataManager::Q3DataManager()
+{
+    d = new Q3DataManagerPrivate();
+}
+
+
+/*! \internal
+
+  Destroys the object and frees any allocated resources.
+
+*/
+
+Q3DataManager::~Q3DataManager()
+{
+    delete d;
+}
+
+
+/*!  \internal
+
+  Virtual function which is called when an error has occurred The
+  default implementation displays a warning message to the user with
+  information about the error.
+
+*/
+void Q3DataManager::handleError(QWidget* parent, const QSqlError& e)
+{
+#ifndef QT_NO_MESSAGEBOX
+    if (e.driverText().isEmpty() && e.databaseText().isEmpty()) {
+        QMessageBox::warning (parent, QLatin1String("Warning"), QLatin1String("An error occurred while accessing the database"));
+    } else {
+        QMessageBox::warning (parent, QLatin1String("Warning"), e.driverText() + QLatin1Char('\n') + e.databaseText(),
+                           0, 0);
+    }
+#endif // QT_NO_MESSAGEBOX
+}
+
+
+/*! \internal
+
+  Sets the internal mode to \a m.
+
+*/
+
+void Q3DataManager::setMode(QSql::Op m)
+{
+    d->mode = m;
+}
+
+
+/*! \internal
+
+  Returns the current mode.
+
+*/
+
+QSql::Op Q3DataManager::mode() const
+{
+    return d->mode;
+}
+
+
+/*! \internal
+
+  Sets the auto-edit mode to \a auto.
+
+*/
+
+void Q3DataManager::setAutoEdit(bool autoEdit)
+{
+    d->autoEd = autoEdit;
+}
+
+
+
+/*! \internal
+
+  Returns true if auto-edit mode is enabled; otherwise returns false.
+
+*/
+
+bool Q3DataManager::autoEdit() const
+{
+    return d->autoEd;
+}
+
+/*! \internal
+
+  If \a confirm is true, all edit operations (inserts, updates and
+  deletes) will be confirmed by the user.  If \a confirm is false (the
+  default), all edits are posted to the database immediately.
+
+*/
+void Q3DataManager::setConfirmEdits(bool confirm)
+{
+    d->confEdits = QBitArray(d->confEdits.size(), confirm);
+}
+
+/*! \internal
+
+  If \a confirm is true, all inserts will be confirmed by the user.
+  If \a confirm is false (the default), all edits are posted to the
+  database immediately.
+
+*/
+
+void Q3DataManager::setConfirmInsert(bool confirm)
+{
+    d->confEdits[QSql::Insert] = confirm;
+}
+
+/*! \internal
+
+  If \a confirm is true, all updates will be confirmed by the user.
+  If \a confirm is false (the default), all edits are posted to the
+  database immediately.
+
+*/
+
+void Q3DataManager::setConfirmUpdate(bool confirm)
+{
+    d->confEdits[QSql::Update] = confirm;
+}
+
+/*! \internal
+
+  If \a confirm is true, all deletes will be confirmed by the user.
+  If \a confirm is false (the default), all edits are posted to the
+  database immediately.
+
+*/
+
+void Q3DataManager::setConfirmDelete(bool confirm)
+{
+    d->confEdits[QSql::Delete] = confirm;
+}
+
+/*! \internal
+
+  Returns true if the table confirms all edit operations (inserts,
+  updates and deletes), otherwise returns false.
+*/
+
+bool Q3DataManager::confirmEdits() const
+{
+    return (confirmInsert() && confirmUpdate() && confirmDelete());
+}
+
+/*! \internal
+
+  Returns true if the table confirms inserts, otherwise returns
+  false.
+*/
+
+bool Q3DataManager::confirmInsert() const
+{
+    return d->confEdits[QSql::Insert];
+}
+
+/*! \internal
+
+  Returns true if the table confirms updates, otherwise returns
+  false.
+*/
+
+bool Q3DataManager::confirmUpdate() const
+{
+    return d->confEdits[QSql::Update];
+}
+
+/*! \internal
+
+  Returns true if the table confirms deletes, otherwise returns
+  false.
+*/
+
+bool Q3DataManager::confirmDelete() const
+{
+    return d->confEdits[QSql::Delete];
+}
+
+/*! \internal
+
+  If \a confirm is true, all cancels will be confirmed by the user
+  through a message box.  If \a confirm is false (the default), all
+  cancels occur immediately.
+*/
+
+void Q3DataManager::setConfirmCancels(bool confirm)
+{
+    d->confCancs = confirm;
+}
+
+/*! \internal
+
+  Returns true if the table confirms cancels, otherwise returns false.
+*/
+
+bool Q3DataManager::confirmCancels() const
+{
+    return d->confCancs;
+}
+
+/*!  \internal
+
+  Virtual function which returns a confirmation for an edit of mode \a
+  m.  Derived classes can reimplement this function and provide their
+  own confirmation dialog.  The default implementation uses a message
+  box which prompts the user to confirm the edit action.  The dialog
+  is centered over \a parent.
+
+*/
+
+QSql::Confirm Q3DataManager::confirmEdit(QWidget* parent, QSql::Op m)
+{
+    int ans = 2;
+    if (m == QSql::Delete) {
+#ifndef QT_NO_MESSAGEBOX
+        ans = QMessageBox::information(parent,
+                                        qApp->translate("QSql", "Delete"),
+                                        qApp->translate("QSql", "Delete this record?"),
+                                        qApp->translate("QSql", "Yes"),
+                                        qApp->translate("QSql", "No"),
+                                        QString(), 0, 1);
+#else
+        ans = QSql::No;
+#endif // QT_NO_MESSAGEBOX
+    } else if (m != QSql::None) {
+        QString caption;
+        if (m == QSql::Insert) {
+            caption = qApp->translate("QSql", "Insert");
+        } else { // QSql::Update
+            caption = qApp->translate("QSql", "Update");
+        }
+#ifndef QT_NO_MESSAGEBOX
+        ans = QMessageBox::information(parent, caption,
+                                        qApp->translate("QSql", "Save edits?"),
+                                        qApp->translate("QSql", "Yes"),
+                                        qApp->translate("QSql", "No"),
+                                        qApp->translate("QSql", "Cancel"),
+                                        0, 2);
+#else
+        ans = QSql::No;
+#endif // QT_NO_MESSAGEBOX
+    }
+
+    switch (ans) {
+    case 0:
+        return QSql::Yes;
+    case 1:
+        return QSql::No;
+    default:
+        return QSql::Cancel;
+    }
+}
+
+/*!  \internal
+
+  Virtual function which returns a confirmation for canceling an edit
+  mode \a m.  Derived classes can reimplement this function and
+  provide their own confirmation dialog.  The default implementation
+  uses a message box which prompts the user to confirm the edit
+  action. The dialog is centered over \a parent.
+
+
+*/
+
+QSql::Confirm Q3DataManager::confirmCancel(QWidget* parent, QSql::Op)
+{
+#ifndef QT_NO_MESSAGEBOX
+    switch (QMessageBox::information(parent,
+                                       qApp->translate("QSql", "Confirm"),
+                                       qApp->translate("QSql", "Cancel your edits?"),
+                                       qApp->translate("QSql", "Yes"),
+                                       qApp->translate("QSql", "No"),
+                                       QString(), 0, 1)) {
+    case 0:
+        return QSql::Yes;
+    case 1:
+        return QSql::No;
+    default:
+        return QSql::Cancel;
+    }
+#else
+    return QSql::Yes;
+#endif // QT_NO_MESSAGEBOX
+}
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/qt3support/sql/q3sqlmanager_p.h b/src/qt3support/sql/q3sqlmanager_p.h
new file mode 100644
index 0000000..b9ea5c7
--- /dev/null
+++ b/src/qt3support/sql/q3sqlmanager_p.h
@@ -0,0 +1,160 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLMANAGER_P_H
+#define Q3SQLMANAGER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qvariant.h"
+#include "QtCore/qglobal.h"
+#include "QtCore/qstring.h"
+#include "QtCore/qstringlist.h"
+#include "QtSql/qsql.h"
+#include "QtSql/qsqlerror.h"
+#include "QtSql/qsqlindex.h"
+#include "Qt3Support/q3sqlcursor.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_SQL
+
+class Q3SqlCursor;
+class Q3SqlForm;
+class Q3SqlCursorManagerPrivate;
+
+class Q_COMPAT_EXPORT Q3SqlCursorManager
+{
+public:
+    Q3SqlCursorManager();
+    virtual ~Q3SqlCursorManager();
+
+    virtual void setSort(const QSqlIndex& sort);
+    virtual void setSort(const QStringList& sort);
+    QStringList  sort() const;
+    virtual void setFilter(const QString& filter);
+    QString filter() const;
+    virtual void setCursor(Q3SqlCursor* cursor, bool autoDelete = false);
+    Q3SqlCursor* cursor() const;
+
+    virtual void setAutoDelete(bool enable);
+    bool autoDelete() const;
+
+    virtual bool refresh();
+    virtual bool findBuffer(const QSqlIndex& idx, int atHint = 0);
+
+private:
+    Q3SqlCursorManagerPrivate* d;
+};
+
+#ifndef QT_NO_SQL_FORM
+
+class Q3SqlFormManagerPrivate;
+
+class Q_COMPAT_EXPORT Q3SqlFormManager
+{
+public:
+    Q3SqlFormManager();
+    virtual ~Q3SqlFormManager();
+
+    virtual void setForm(Q3SqlForm* form);
+    Q3SqlForm* form();
+    virtual void setRecord(QSqlRecord* record);
+    QSqlRecord* record();
+
+    virtual void clearValues();
+    virtual void readFields();
+    virtual void writeFields();
+
+private:
+    Q3SqlFormManagerPrivate* d;
+};
+
+#endif
+
+class QWidget;
+class Q3DataManagerPrivate;
+
+class Q_COMPAT_EXPORT Q3DataManager
+{
+public:
+    Q3DataManager();
+    virtual ~Q3DataManager();
+
+    virtual void setMode(QSql::Op m);
+    QSql::Op mode() const;
+    virtual void setAutoEdit(bool autoEdit);
+    bool autoEdit() const;
+
+    virtual void handleError(QWidget* parent, const QSqlError& error);
+    virtual QSql::Confirm confirmEdit(QWidget* parent, QSql::Op m);
+    virtual QSql::Confirm confirmCancel(QWidget* parent, QSql::Op m);
+
+    virtual void setConfirmEdits(bool confirm);
+    virtual void setConfirmInsert(bool confirm);
+    virtual void setConfirmUpdate(bool confirm);
+    virtual void setConfirmDelete(bool confirm);
+    virtual void setConfirmCancels(bool confirm);
+
+    bool confirmEdits() const;
+    bool confirmInsert() const;
+    bool confirmUpdate() const;
+    bool confirmDelete() const;
+    bool confirmCancels() const;
+
+private:
+    Q3DataManagerPrivate* d;
+};
+
+#endif // QT_NO_SQL
+
+QT_END_NAMESPACE
+
+#endif // Q3SQLMANAGER_P_H
diff --git a/src/qt3support/sql/q3sqlpropertymap.cpp b/src/qt3support/sql/q3sqlpropertymap.cpp
new file mode 100644
index 0000000..6e55af0
--- /dev/null
+++ b/src/qt3support/sql/q3sqlpropertymap.cpp
@@ -0,0 +1,276 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3sqlpropertymap.h"
+
+#ifndef QT_NO_SQL_FORM
+
+#include "qwidget.h"
+#include "q3cleanuphandler.h"
+#include "qmetaobject.h"
+#include "qmap.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q3SqlPropertyMapPrivate
+{
+public:
+    Q3SqlPropertyMapPrivate() {}
+    QMap<QByteArray, QByteArray> propertyMap;
+};
+
+/*!
+    \class Q3SqlPropertyMap
+    \brief The Q3SqlPropertyMap class is used to map widgets to SQL fields.
+
+    \compat
+
+    The SQL module uses Qt \link properties.html object
+    properties\endlink to insert and extract values from editor
+    widgets.
+
+    This class is used to map editors to SQL fields. This works by
+    associating SQL editor class names to the properties used to
+    insert and extract values to/from the editor.
+
+    For example, a QLineEdit can be used to edit text strings and
+    other data types in Q3DataTables or Q3SqlForms. Several properties
+    are defined in QLineEdit, but only the \e text property is used to
+    insert and extract text from a QLineEdit. Both Q3DataTable and
+    Q3SqlForm use the global Q3SqlPropertyMap for inserting and
+    extracting values to and from an editor widget. The global
+    property map defines several common widgets and properties that
+    are suitable for many applications. You can add and remove widget
+    properties to suit your specific needs.
+
+    If you want to use custom editors with your Q3DataTable or
+    Q3SqlForm, you must install your own Q3SqlPropertyMap for that table
+    or form. Example:
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlpropertymap.cpp 0
+
+    You can also replace the global Q3SqlPropertyMap that is used by
+    default. (Bear in mind that Q3SqlPropertyMap takes ownership of the
+    new default map.)
+
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlpropertymap.cpp 1
+
+    \sa Q3DataTable, Q3SqlForm, Q3SqlEditorFactory
+*/
+
+/*!
+
+Constructs a Q3SqlPropertyMap.
+
+The default property mappings used by Qt widgets are:
+\table
+\header \i Widgets \i Property
+\row \i \l QCheckBox,
+        \l QRadioButton
+     \i checked
+\row \i \l QComboBox,
+        \l Q3ListBox
+     \i currentItem
+\row \i \l Q3DateEdit
+     \i date
+\row \i \l Q3DateTimeEdit
+        \l QDateTimeEdit
+     \i dateTime
+\row \i \l QTextBrowser
+     \i source
+\row \i \l QAbstractButton,
+        \l QDial,
+        \l QLabel,
+        \l QLineEdit,
+        \l Q3MultiLineEdit,
+        \l QPushButton,
+        \l QTextEdit,
+     \i text
+\row \i \l Q3TimeEdit
+     \i time
+\row \i \l QLCDNumber,
+        \l QScrollBar
+        \l QSlider,
+        \l QSpinBox
+     \i value
+\endtable
+*/
+
+Q3SqlPropertyMap::Q3SqlPropertyMap()
+{
+    d = new Q3SqlPropertyMapPrivate();
+    const struct MapData {
+        const char *classname;
+        const char *property;
+    } mapData[] = {
+        { "Q3DateEdit", "date" },
+        { "Q3DateTimeEdit", "dateTime" },
+        { "Q3ListBox", "currentItem" },
+        { "Q3TimeEdit", "time" },
+        { "QAbstractButton", "text" },
+        { "QCheckBox", "checked" },
+        { "QRadioButton", "checked" },
+        { "QComboBox", "currentIndex" },
+        { "QDateTimeEdit", "dateTime" },
+        { "QDial", "value" },
+        { "QLabel", "text" },
+        { "QLCDNumber", "value" },
+        { "QLineEdit", "text" },
+        { "QPushButton", "text" },
+        { "QScrollBar", "value" },
+        { "QSlider", "value" },
+        { "QSpinBox", "value" },
+        { "QTabBar", "currentTab" },
+        { "QTabWidget", "currentPage" },
+        { "QTextBrowser", "source" },
+        { "QTextEdit", "text" },
+        { "QGroupBox", "checked" }
+    };
+
+    const MapData *m = mapData;
+    for (uint i = 0; i < sizeof(mapData)/sizeof(MapData); i++, m++)
+        d->propertyMap.insert(m->classname, m->property);
+}
+
+/*!
+    Destroys the Q3SqlPropertyMap.
+
+    Note that if the Q3SqlPropertyMap is installed with
+    installPropertyMap() the object it was installed into, e.g. the
+    Q3SqlForm, takes ownership and will delete the Q3SqlPropertyMap when
+    necessary.
+*/
+Q3SqlPropertyMap::~Q3SqlPropertyMap()
+{
+    delete d;
+}
+
+/*!
+    Returns the mapped property of \a widget as a QVariant.
+*/
+QVariant Q3SqlPropertyMap::property(QWidget * widget)
+{
+    if(!widget) return QVariant();
+    const QMetaObject* mo = widget->metaObject();
+    while (mo && !d->propertyMap.contains(mo->className()))
+        mo = mo->superClass();
+
+    if (!mo) {
+        qWarning("Q3SqlPropertyMap::property: %s does not exist", widget->metaObject()->className());
+        return QVariant();
+    }
+    return widget->property(d->propertyMap[mo->className()]);
+}
+
+/*!
+    Sets the property of \a widget to \a value.
+*/
+void Q3SqlPropertyMap::setProperty(QWidget * widget, const QVariant & value)
+{
+    if(!widget) return;
+
+    const QMetaObject* mo = widget->metaObject();
+    while (mo && !d->propertyMap.contains(mo->className()))
+        mo = mo->superClass();
+    if (!mo) {
+        qWarning("Q3SqlPropertyMap::setProperty: %s not handled by Q3SqlPropertyMap", widget->metaObject()->className());
+        return;
+    }
+
+    widget->setProperty(d->propertyMap[mo->className()], value);
+}
+
+/*!
+  Insert a new classname/property pair, which is used for custom SQL
+  field editors. There \e must be a Q_PROPERTY() clause in the \a
+  classname class declaration for the \a property.
+*/
+void Q3SqlPropertyMap::insert(const QString & classname,
+                              const QString & property)
+{
+    d->propertyMap[classname.latin1()] = property.latin1();
+}
+
+/*!
+    Removes \a classname from the map.
+*/
+void Q3SqlPropertyMap::remove(const QString & classname)
+{
+    d->propertyMap.remove(classname.latin1());
+}
+
+static Q3SqlPropertyMap * defaultmap = 0;
+static Q3CleanupHandler< Q3SqlPropertyMap > qsql_cleanup_property_map;
+
+/*!
+    Returns the application global Q3SqlPropertyMap.
+*/
+Q3SqlPropertyMap * Q3SqlPropertyMap::defaultMap()
+{
+    if(defaultmap == 0){
+        defaultmap = new Q3SqlPropertyMap();
+        qsql_cleanup_property_map.add(&defaultmap);
+    }
+    return defaultmap;
+}
+
+/*!
+    Replaces the global default property map with \a map. All
+    Q3DataTable and Q3SqlForm instantiations will use this new map for
+    inserting and extracting values to and from editors.
+    \e{Q3SqlPropertyMap takes ownership of \a map, and destroys it
+    when it is no longer needed.}
+*/
+void Q3SqlPropertyMap::installDefaultMap(Q3SqlPropertyMap * map)
+{
+    if(map == 0) return;
+
+    if(defaultmap != 0){
+        qsql_cleanup_property_map.remove(&defaultmap);
+        delete defaultmap;
+    }
+    defaultmap = map;
+    qsql_cleanup_property_map.add(&defaultmap);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SQL_FORM
diff --git a/src/qt3support/sql/q3sqlpropertymap.h b/src/qt3support/sql/q3sqlpropertymap.h
new file mode 100644
index 0000000..88660b4
--- /dev/null
+++ b/src/qt3support/sql/q3sqlpropertymap.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLPROPERTYMAP_H
+#define Q3SQLPROPERTYMAP_H
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qstring.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL_FORM
+
+class QWidget;
+class Q3SqlPropertyMapPrivate;
+
+class Q_COMPAT_EXPORT Q3SqlPropertyMap
+{
+public:
+    Q3SqlPropertyMap();
+    virtual ~Q3SqlPropertyMap();
+
+    QVariant      property(QWidget * widget);
+    virtual void  setProperty(QWidget * widget, const QVariant & value);
+
+    void insert(const QString & classname, const QString & property);
+    void remove(const QString & classname);
+
+    static Q3SqlPropertyMap * defaultMap();
+    static void installDefaultMap(Q3SqlPropertyMap * map);
+
+private:
+    Q_DISABLE_COPY(Q3SqlPropertyMap)
+
+    Q3SqlPropertyMapPrivate* d;
+};
+
+#endif // QT_NO_SQL_FORM
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3SQLPROPERTYMAP_H
diff --git a/src/qt3support/sql/q3sqlrecordinfo.h b/src/qt3support/sql/q3sqlrecordinfo.h
new file mode 100644
index 0000000..a81988d
--- /dev/null
+++ b/src/qt3support/sql/q3sqlrecordinfo.h
@@ -0,0 +1,122 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLRECORDINFO_H
+#define Q3SQLRECORDINFO_H
+
+#include <QtCore/qglobal.h>
+
+#ifndef QT_NO_SQL
+#   include <Qt3Support/q3valuelist.h>
+#   include <QtSql/qsqlrecord.h>
+#   include <Qt3Support/q3sqlfieldinfo.h>
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL
+
+/* Q3SqlRecordInfo Class
+   This class is obsolete, use QSqlRecord instead.
+*/
+
+typedef Q3ValueList<Q3SqlFieldInfo> Q3SqlFieldInfoList;
+
+class Q_COMPAT_EXPORT Q3SqlRecordInfo: public Q3SqlFieldInfoList
+{
+public:
+    Q3SqlRecordInfo(): Q3SqlFieldInfoList() {}
+    Q3SqlRecordInfo(const Q3SqlFieldInfoList& other): Q3SqlFieldInfoList(other) {}
+    Q3SqlRecordInfo(const QSqlRecord& other)
+    {
+        for (int i = 0; i < other.count(); ++i)
+            push_back(Q3SqlFieldInfo(other.field(i)));
+    }
+
+    size_type contains(const QString& fieldName) const;
+    Q3SqlFieldInfo find(const QString& fieldName) const;
+    QSqlRecord toRecord() const;
+};
+
+inline Q3SqlRecordInfo::size_type Q3SqlRecordInfo::contains(const QString& fieldName) const
+{
+    size_type i = 0;
+    QString fName = fieldName.toUpper();
+
+    for(const_iterator it = begin(); it != end(); ++it) {
+        if ((*it).name().toUpper() == fName) {
+            ++i;
+        }
+    }
+    return i;
+}
+
+inline Q3SqlFieldInfo Q3SqlRecordInfo::find(const QString& fieldName) const
+{
+    QString fName = fieldName.toUpper();
+    for(const_iterator it = begin(); it != end(); ++it) {
+        if ((*it).name().toUpper() == fName) {
+            return *it;
+        }
+    }
+    return Q3SqlFieldInfo();
+}
+
+inline QSqlRecord Q3SqlRecordInfo::toRecord() const
+{
+    QSqlRecord buf;
+    for(const_iterator it = begin(); it != end(); ++it) {
+        buf.append((*it).toField());
+    }
+    return buf;
+}
+
+#endif // QT_NO_SQL
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3SQLRECORDINFO_H
diff --git a/src/qt3support/sql/q3sqlselectcursor.cpp b/src/qt3support/sql/q3sqlselectcursor.cpp
new file mode 100644
index 0000000..7726f02
--- /dev/null
+++ b/src/qt3support/sql/q3sqlselectcursor.cpp
@@ -0,0 +1,263 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3sqlselectcursor.h"
+#include "qsqldriver.h"
+#include "q3sqlrecordinfo.h"
+
+#ifndef QT_NO_SQL
+
+QT_BEGIN_NAMESPACE
+
+class Q3SqlSelectCursorPrivate
+{
+public:
+    Q3SqlSelectCursorPrivate() : populated(false) {}
+    QString query;
+    bool populated : 1;
+};
+
+/*!
+    \class Q3SqlSelectCursor
+    \brief The Q3SqlSelectCursor class provides browsing of general SQL SELECT statements.
+
+    \compat
+
+    Q3SqlSelectCursor is a convenience class that makes it possible to
+    display result sets from general SQL \c SELECT statements in
+    data-aware Qt widgets. Q3SqlSelectCursor is read-only and does not
+    support \c INSERT, \c UPDATE or \c DELETE operations.
+
+    Pass the query in at construction time, or use the
+    Q3SqlSelectCursor::exec() function.
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlselectcursor.cpp 0
+*/
+
+/*!
+    Constructs a read only cursor on database \a db using the query \a query.
+ */
+Q3SqlSelectCursor::Q3SqlSelectCursor(const QString& query, QSqlDatabase db)
+    : Q3SqlCursor(QString(), false, db)
+{
+    d = new Q3SqlSelectCursorPrivate;
+    d->query = query;
+    Q3SqlCursor::setMode(ReadOnly);
+    if (!query.isEmpty())
+        exec(query);
+}
+
+/*! Constructs a copy of \a other */
+Q3SqlSelectCursor::Q3SqlSelectCursor(const Q3SqlSelectCursor& other)
+    : Q3SqlCursor(other)
+{
+    d = new Q3SqlSelectCursorPrivate;
+    d->query = other.d->query;
+    d->populated = other.d->populated;
+}
+
+/*! Destroys the object and frees any allocated resources */
+Q3SqlSelectCursor::~Q3SqlSelectCursor()
+{
+    delete d;
+}
+
+/*! \internal */
+bool Q3SqlSelectCursor::exec(const QString& query)
+{
+    d->query = query;
+    bool ret = Q3SqlCursor::exec(query);
+    if (ret) {
+        Q3SqlCursor::clear();
+        populateCursor();
+    }
+    return ret;
+}
+
+/*! \fn bool Q3SqlSelectCursor::select()
+    \internal
+*/
+
+/*! \internal */
+bool Q3SqlSelectCursor::select(const QString&, const QSqlIndex&)
+{
+    bool ret = Q3SqlCursor::exec(d->query);
+    if (ret && !d->populated)
+        populateCursor();
+    return ret;
+}
+
+/*! \internal */
+void Q3SqlSelectCursor::populateCursor()
+{
+    Q3SqlRecordInfo inf = Q3SqlRecordInfo(record());
+    for (Q3SqlRecordInfo::const_iterator it = inf.begin(); it != inf.end(); ++it)
+        Q3SqlCursor::append(*it);
+    d->populated = true;
+}
+
+/*! \fn QSqlIndex Q3SqlSelectCursor::primaryIndex(bool) const
+    \internal
+*/
+
+/*! \fn QSqlIndex Q3SqlSelectCursor::index(const QStringList&) const
+    \internal
+*/
+
+/*! \fn QSqlIndex Q3SqlSelectCursor::index(const QString&) const
+    \internal
+*/
+
+/*! \fn QSqlIndex Q3SqlSelectCursor::index(const char*) const
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setPrimaryIndex(const QSqlIndex&)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::append(const Q3SqlFieldInfo&)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::insert(int, const Q3SqlFieldInfo&)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::remove(int)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::clear()
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setGenerated(const QString&, bool)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setGenerated(int, bool)
+    \internal
+*/
+
+/*! \fn QSqlRecord* Q3SqlSelectCursor::editBuffer(bool)
+    \internal
+*/
+
+/*! \fn QSqlRecord* Q3SqlSelectCursor::primeInsert()
+    \internal
+*/
+
+/*! \fn QSqlRecord* Q3SqlSelectCursor::primeUpdate()
+    \internal
+*/
+
+/*! \fn QSqlRecord* Q3SqlSelectCursor::primeDelete()
+    \internal
+*/
+
+/*! \fn int Q3SqlSelectCursor::insert(bool)
+    \internal
+*/
+
+/*! \fn int Q3SqlSelectCursor::update(bool)
+    \internal
+*/
+
+/*! \fn int Q3SqlSelectCursor::del(bool)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setMode(int)
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setSort(const QSqlIndex&)
+    \internal
+*/
+
+/*! \fn QSqlIndex Q3SqlSelectCursor::sort() const
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setFilter(const QString&)
+    \internal
+*/
+
+/*! \fn QString Q3SqlSelectCursor::filter() const
+    \internal
+*/
+
+/*! \fn void Q3SqlSelectCursor::setName(const QString&, bool)
+    \internal
+*/
+
+/*! \fn QString Q3SqlSelectCursor::name() const
+    \internal
+*/
+
+/*! \fn QString Q3SqlSelectCursor::toString(const QString&, const QString&) const
+    \internal
+*/
+
+/*!
+    \fn int Q3SqlSelectCursor::update(const QString & filter, bool invalidate = true)
+    \overload
+
+    Updates the database with the current contents of the cursor edit
+    buffer using the specified \a filter. Returns the number of
+    records which were updated.
+    For error information, use lastError().
+
+    Only records which meet the filter criteria are updated, otherwise
+    all records in the table are updated.
+
+    If \a invalidate is true (the default), the cursor can no longer
+    be navigated. A new select() call must be made before you can move
+    to a valid record.
+
+    \sa Q3SqlCursor::update() primeUpdate() setMode() lastError()
+*/
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SQL
diff --git a/src/qt3support/sql/q3sqlselectcursor.h b/src/qt3support/sql/q3sqlselectcursor.h
new file mode 100644
index 0000000..26103ba
--- /dev/null
+++ b/src/qt3support/sql/q3sqlselectcursor.h
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3SQLSELECTCURSOR_H
+#define Q3SQLSELECTCURSOR_H
+
+#include <Qt3Support/q3sqlcursor.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Qt3Support)
+
+#ifndef QT_NO_SQL
+
+class Q3SqlSelectCursorPrivate;
+
+class Q_COMPAT_EXPORT Q3SqlSelectCursor : public Q3SqlCursor
+{
+public:
+    Q3SqlSelectCursor(const QString& query = QString(), QSqlDatabase db = QSqlDatabase());
+    Q3SqlSelectCursor(const Q3SqlSelectCursor& other);
+    ~Q3SqlSelectCursor();
+    bool exec(const QString& query);
+    bool select() { return Q3SqlCursor::select(); }
+
+protected:
+    QSqlIndex primaryIndex(bool = true) const { return QSqlIndex(); }
+    QSqlIndex index(const QStringList&) const { return QSqlIndex(); }
+    QSqlIndex index(const QString&) const { return QSqlIndex(); }
+    QSqlIndex index(const char*) const { return QSqlIndex(); }
+    void setPrimaryIndex(const QSqlIndex&) {}
+    void append(const Q3SqlFieldInfo&) {}
+    void insert(int, const Q3SqlFieldInfo&) {}
+    void remove(int) {}
+    void clear() {}
+    void setGenerated(const QString&, bool) {}
+    void setGenerated(int, bool) {}
+    QSqlRecord*        editBuffer(bool = false) { return 0; }
+    QSqlRecord*        primeInsert() { return 0; }
+    QSqlRecord*        primeUpdate() { return 0; }
+    QSqlRecord*        primeDelete() { return 0; }
+    int        insert(bool = true) { return 0; }
+    int        update(bool = true) { return 0; }
+    int        del(bool = true) { return 0; }
+    void setMode(int) {}
+
+    void setSort(const QSqlIndex&) {}
+    QSqlIndex sort() const { return QSqlIndex(); }
+    void setFilter(const QString&) {}
+    QString filter() const { return QString(); }
+    void setName(const QString&, bool = true) {}
+    QString name() const { return QString(); }
+    QString toString(const QString& = QString(), const QString& = QLatin1String(",")) const { return QString(); }
+    bool select(const QString &, const QSqlIndex& = QSqlIndex());
+
+private:
+    void populateCursor();
+
+    Q3SqlSelectCursorPrivate * d;
+
+protected:
+#if !defined(Q_NO_USING_KEYWORD)
+    using Q3SqlCursor::update;
+#else
+    virtual int update(const QString & filter, bool invalidate = true) { return Q3SqlCursor::update(filter, invalidate); }
+#endif
+};
+
+#endif // QT_NO_SQL
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // Q3SQLSELECTCURSOR_H
diff --git a/src/qt3support/sql/sql.pri b/src/qt3support/sql/sql.pri
new file mode 100644
index 0000000..41fd641
--- /dev/null
+++ b/src/qt3support/sql/sql.pri
@@ -0,0 +1,25 @@
+# Qt compat module
+
+HEADERS +=      sql/q3sqlfieldinfo.h \
+                sql/q3sqlrecordinfo.h \
+                sql/q3datatable.h \
+                sql/q3dataview.h \
+                sql/q3sqlcursor.h \
+                sql/q3sqlselectcursor.h \
+                sql/q3sqlform.h \
+                sql/q3sqlmanager_p.h \
+                sql/q3editorfactory.h \
+                sql/q3sqleditorfactory.h \
+                sql/q3sqlpropertymap.h \
+                sql/q3databrowser.h \
+
+SOURCES +=      sql/q3datatable.cpp \
+                sql/q3dataview.cpp \
+                sql/q3sqlcursor.cpp \
+                sql/q3sqlselectcursor.cpp \
+                sql/q3sqlform.cpp \
+                sql/q3sqlmanager_p.cpp \
+                sql/q3editorfactory.cpp \
+                sql/q3sqleditorfactory.cpp \
+                sql/q3sqlpropertymap.cpp \
+                sql/q3databrowser.cpp