/****************************************************************************
**
** Implementation of TQDataBrowser class
**
** Created : 2000-11-03
**
** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
**
** This file is part of the sql module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file.  Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/

#include "ntqdatabrowser.h"

#ifndef TQT_NO_SQL_VIEW_WIDGETS

#include "ntqsqlform.h"
#include "qsqlmanager_p.h"
#include "ntqsqlresult.h"

class TQDataBrowserPrivate
{
public:
    TQDataBrowserPrivate() : boundaryCheck( TRUE ), readOnly( FALSE ) {}
    TQSqlCursorManager cur;
    TQSqlFormManager frm;
    TQDataManager dat;
    bool boundaryCheck;
    bool readOnly;
};

/*!
    \class TQDataBrowser ntqdatabrowser.h
    \brief The TQDataBrowser class provides data manipulation and
    navigation for data entry forms.

    \ingroup database
    \mainclass
    \module sql

    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
    TQDataView; if you want a table-based presentation of your data use
    TQDataTable.

    A TQDataBrowser is used to associate a dataset with a form in much
    the same way as a TQDataTable 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 behaviour 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 TQDataBrowser::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.
*/

TQDataBrowser::TQDataBrowser( TQWidget *parent, const char *name, WFlags fl )
    : TQWidget( parent, name, fl )
{
    d = new TQDataBrowserPrivate();
    d->dat.setMode( TQSql::Update );
}

/*!
    Destroys the object and frees any allocated resources.
*/

TQDataBrowser::~TQDataBrowser()
{
    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 TQDataBrowser::Boundary.

    \sa Boundary
*/

TQDataBrowser::Boundary TQDataBrowser::boundary()
{
    TQSqlCursor* cur = d->cur.cursor();
    if ( !cur || !cur->isActive() )
	return Unknown;
    if ( !cur->isValid() ) {
	if ( cur->at() == TQSql::BeforeFirst )
	    return BeforeBeginning;
	if ( cur->at() == TQSql::AfterLast )
	    return AfterEnd;
	return Unknown;
    }
    if ( cur->at() == 0 )
	return Beginning;
    int currentAt = cur->at();

    Boundary b = None;
    if ( !cur->prev() )
	b = Beginning;
    else
	cur->seek( currentAt );
    if ( b == None && !cur->next() )
	b = End;
    cur->seek( currentAt );
    return b;
}


/*!
    \property TQDataBrowser::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 TQDataBrowser::setBoundaryChecking( bool active )
{
    d->boundaryCheck = active;
}

bool TQDataBrowser::boundaryChecking() const
{
    return d->boundaryCheck;
}

/*!
    \property TQDataBrowser::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.
    \code
    TQStringList list = myDataBrowser.sort();
    TQStringList::Iterator it = list.begin();
    while( it != list.end() ) {
	myProcessing( *it );
	++it;
    }
    \endcode
*/

void TQDataBrowser::setSort( const TQStringList& sort )
{
    d->cur.setSort( sort );
}

/*!
    \overload

    Sets the data browser's sort to the TQSqlIndex \a sort. To apply
    the new sort, use refresh().

*/
void TQDataBrowser::setSort( const TQSqlIndex& sort )
{
    d->cur.setSort( sort );
}

TQStringList TQDataBrowser::sort() const
{
    return d->cur.sort();
}


/*!
    \property TQDataBrowser::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 TQDataBrowser::setFilter( const TQString& filter )
{
    d->cur.setFilter( filter );
}


TQString TQDataBrowser::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 TQDataBrowser::setSqlCursor( TQSqlCursor* 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()
*/

TQSqlCursor* TQDataBrowser::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 TQDataBrowser::setForm( TQSqlForm* form )
{
    d->frm.setForm( form );
}


/*!
    Returns the data browser's default form or 0 if no form has been
    set.
*/

TQSqlForm* TQDataBrowser::form()
{
    return d->frm.form();
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::setReadOnly( bool active )
{
    d->readOnly = active;
}

bool TQDataBrowser::isReadOnly() const
{
    return d->readOnly;
}

void TQDataBrowser::setConfirmEdits( bool confirm )
{
    d->dat.setConfirmEdits( confirm );
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::setConfirmInsert( bool confirm )
{
    d->dat.setConfirmInsert( confirm );
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::setConfirmUpdate( bool confirm )
{
    d->dat.setConfirmUpdate( confirm );
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::setConfirmDelete( bool confirm )
{
    d->dat.setConfirmDelete( confirm );
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::confirmEdits() const
{
    return ( d->dat.confirmEdits() );
}

bool TQDataBrowser::confirmInsert() const
{
    return ( d->dat.confirmInsert() );
}

bool TQDataBrowser::confirmUpdate() const
{
    return ( d->dat.confirmUpdate() );
}

bool TQDataBrowser::confirmDelete() const
{
    return ( d->dat.confirmDelete() );
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::setConfirmCancels( bool confirm )
{
    d->dat.setConfirmCancels( confirm );
}

bool TQDataBrowser::confirmCancels() const
{
    return d->dat.confirmCancels();
}

/*!
    \property TQDataBrowser::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 TQDataBrowser::setAutoEdit( bool autoEdit )
{
    d->dat.setAutoEdit( autoEdit );
}

bool TQDataBrowser::autoEdit() const
{
    return d->dat.autoEdit();
}

/*!
    \fn void TQDataBrowser::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 TQDataBrowser::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 TQDataBrowser::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 TQDataBrowser::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 TQDataBrowser::currentChanged( const TQSqlRecord* 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 TQDataBrowser::primeInsert( TQSqlRecord* 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 TQSqlCursor::primeInsert() is \e not called on the
    default cursor, as this would corrupt values in the form.)

    \sa insert()
*/


/*!
    \fn void TQDataBrowser::primeUpdate( TQSqlRecord* 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 TQSqlCursor::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 TQDataBrowser::primeDelete( TQSqlRecord* 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 TQSqlCursor::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 TQDataBrowser::cursorChanged( TQSqlCursor::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 TQSqlCursor::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 TQDataBrowser::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 TQSqlCursor::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 TQDataBrowser::insert()
{
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* cur = d->cur.cursor();
    if ( !buf || !cur )
	return;
    bool doIns = TRUE;
    TQSql::Confirm conf = TQSql::Yes;
    switch ( d->dat.mode() ) {
    case TQSql::Insert:
	if ( autoEdit() ) {
	    if ( confirmInsert() )
		conf = confirmEdit( TQSql::Insert );
	    switch ( conf ) {
	    case TQSql::Yes:
		insertCurrent();
		break;
	    case TQSql::No:
		break;
	    case TQSql::Cancel:
		doIns = FALSE;
		break;
	    }
	}
	break;
    default:
	if ( autoEdit() && currentEdited() ) {
	    if ( confirmUpdate() )
		conf = confirmEdit( TQSql::Update );
	    switch ( conf ) {
	    case TQSql::Yes:
		updateCurrent();
		break;
	    case TQSql::No:
		break;
	    case TQSql::Cancel:
		doIns = FALSE;
		break;
	    }
	}
	break;
    }
    if ( doIns ) {
	d->dat.setMode( TQSql::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 TQDataBrowser::update()
{
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* cur = d->cur.cursor();
    if ( !buf || !cur )
	return;
    TQSql::Confirm conf = TQSql::Yes;
    switch ( d->dat.mode() ){
    case TQSql::Insert:
	if ( confirmInsert() )
	    conf = confirmEdit( TQSql::Insert );		
	switch ( conf ) {
	    case TQSql::Yes:
		if ( insertCurrent() )
		    d->dat.setMode( TQSql::Update );
	    break;
	    case TQSql::No:
		d->dat.setMode( TQSql::Update );
	    cur->editBuffer( TRUE );
	    readFields();
	    break;
	    case TQSql::Cancel:
	    break;
	}
    break;
    default:
	d->dat.setMode( TQSql::Update );
	if ( confirmUpdate() )
	    conf = confirmEdit( TQSql::Update );
	switch ( conf ) {
	case TQSql::Yes:
	    updateCurrent();
	    break;
	case TQSql::No:
	case TQSql::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 TQDataBrowser::del()
{
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* cur = d->cur.cursor();
    if ( !buf || !cur )
	return;
    TQSql::Confirm conf = TQSql::Yes;
    switch ( d->dat.mode() ){
    case TQSql::Insert:
	if ( confirmCancels() )
	    conf = confirmCancel( TQSql::Insert );
	if ( conf == TQSql::Yes ) {
	    cur->editBuffer( TRUE ); /* restore from cursor */
	    readFields();
	    d->dat.setMode( TQSql::Update );
	} else
	    d->dat.setMode( TQSql::Insert );
	break;
    default:
	if ( confirmDelete() )
	    conf = confirmEdit( TQSql::Delete );
	switch ( conf ) {
	case TQSql::Yes:
	    emit primeDelete( buf );
	    deleteCurrent();
	    break;
	case TQSql::No:
	case TQSql::Cancel:
	    break;
	}
	d->dat.setMode( TQSql::Update );
	break;
    }
}

/*!
    Moves the default cursor to the record specified by the index \a i
    and refreshes the default form to display this 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.
*/

bool TQDataBrowser::seek( int i, bool relative )
{
    int b = 0;
    TQSqlCursor* 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 TQDataBrowser::first()
{
    nav( &TQSqlCursor::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 TQDataBrowser::last()
{
    nav( &TQSqlCursor::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 TQDataBrowser::next()
{
    nav( &TQSqlCursor::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 TQDataBrowser::prev()
{
    nav( &TQSqlCursor::prev );
}

/*!
    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 TQDataBrowser::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 TQDataBrowser::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 TQSqlPropertyMap constructor for the default
    mappings of widgets to properties.
*/

void TQDataBrowser::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 successfull, 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 TQDataBrowser::insertCurrent()
{
    if ( isReadOnly() )
	return FALSE;
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* 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( TQSqlCursor::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 successfull, the cursor is
    refreshed and relocated to the updated record, the cursorChanged()
    signal is emitted, and TRUE is returned.

    \sa cursor() form() handleError()
*/

bool TQDataBrowser::updateCurrent()
{
    if ( isReadOnly() )
	return FALSE;
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* 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( TQSqlCursor::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 TQDataBrowser::deleteCurrent()
{
    if ( isReadOnly() )
	return FALSE;
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* 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( TQSqlCursor::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 TQDataBrowser::currentEdited()
{
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* cur = d->cur.cursor();
    if ( !buf || !cur )
	return FALSE;
    if ( !cur->isActive() || !cur->isValid() )
	return FALSE;
    writeFields();
    for ( uint i = 0; i < cur->count(); ++i ) {
	if ( cur->value(i) != buf->value(i) )
	    return TRUE;
    }
    return FALSE;
}

/*! \internal

  Pre-navigation checking.
*/

bool TQDataBrowser::preNav()
{
    TQSqlRecord* buf = d->frm.record();
    TQSqlCursor* cur = d->cur.cursor();
    if ( !buf || !cur )
	return FALSE;

    if ( !isReadOnly() && autoEdit() && currentEdited() ) {
	bool ok = TRUE;
	TQSql::Confirm conf = TQSql::Yes;
	switch ( d->dat.mode() ){
	case TQSql::Insert:
	    if ( confirmInsert() )
		conf = confirmEdit( TQSql::Insert );
	    switch ( conf ) {
	    case TQSql::Yes:
		ok = insertCurrent();
		d->dat.setMode( TQSql::Update );
		break;
	    case TQSql::No:
		d->dat.setMode( TQSql::Update );
		break;
	    case TQSql::Cancel:
		return FALSE;
	    }
	    break;
	default:
	    if ( confirmUpdate() )
		conf = confirmEdit( TQSql::Update );
	    switch ( conf ) {
	    case TQSql::Yes:
		ok = updateCurrent();
		break;
	    case TQSql::No:
		break;
	    case TQSql::Cancel:
		return FALSE;
	    }
	}
	return ok;
    }
    return TRUE;
}

/*! \internal

  Handles post-navigation according to \a primeUpd.
*/

void TQDataBrowser::postNav( bool primeUpd )
{
    if ( primeUpd ) {
	TQSqlRecord* buf = d->frm.record();
	TQSqlCursor* 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 TQDataBrowser::nav( Nav nav )
{
    int b = 0;
    TQSqlCursor* 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 TQDataBrowser::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 TQDataBrowser::handleError( const TQSqlError& 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.
*/

TQSql::Confirm TQDataBrowser::confirmEdit( TQSql::Op m )
{
    return d->dat.confirmEdit( this, m );
}

/*!
    Protected virtual function which returns a confirmation for
    cancelling 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.
*/

TQSql::Confirm  TQDataBrowser::confirmCancel( TQSql::Op m )
{
    return d->dat.confirmCancel( this, m );
}

/*!
    \fn void TQDataBrowser::beforeInsert( TQSqlRecord* 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 TQDataBrowser::beforeUpdate( TQSqlRecord* 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 TQDataBrowser::beforeDelete( TQSqlRecord* 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.
*/

#endif