/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

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

** Nokia at qt-info@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