1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt3Support module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

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

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "q3datatable.h"

    43 

    44 #ifndef QT_NO_SQL_VIEW_WIDGETS

    45 

    46 #include "qevent.h"

    47 #include "qsqldriver.h"

    48 #include "q3sqleditorfactory.h"

    49 #include "q3sqlpropertymap.h"

    50 #include "qapplication.h"

    51 #include "qlayout.h"

    52 #include "qpainter.h"

    53 #include "q3popupmenu.h"

    54 #include "q3valuelist.h"

    55 #include "q3sqlmanager_p.h"

    56 #include "qsqlfield.h"

    57 #include "qdatetime.h"

    58 #include "qcursor.h"

    59 #include "qtimer.h"

    60 #include "qpointer.h"

    61 

    62 QT_BEGIN_NAMESPACE

    63 

    64 //#define QT_DEBUG_DATATABLE

    65 

    66 class Q3DataTablePrivate

    67 {

    68 public:

    69     Q3DataTablePrivate()

    70         : nullTxtChanged( false ),

    71           haveAllRows( false ),

    72           continuousEdit( false ),

    73           editorFactory( 0 ),

    74           propertyMap( 0 ),

    75           datefmt( Qt::TextDate ),

    76           editRow( -1 ),

    77           editCol( -1 ),

    78           insertRowLast( -1 ),

    79           insertPreRows( -1 ),

    80           editBuffer( 0 ),

    81           cancelMode( false ),

    82           cancelInsert( false ),

    83           cancelUpdate( false ),

    84           lastAt( -1 )

    85     {}

    86     ~Q3DataTablePrivate() { if ( propertyMap ) delete propertyMap; }

    87 

    88     QString nullTxt;

    89     bool nullTxtChanged;

    90     typedef Q3ValueList< uint > ColIndex;

    91     ColIndex colIndex;

    92     bool haveAllRows;

    93     bool continuousEdit;

    94     Q3SqlEditorFactory* editorFactory;

    95     Q3SqlPropertyMap* propertyMap;

    96     QString trueTxt;

    97     Qt::DateFormat datefmt;

    98     QString falseTxt;

    99     int editRow;

   100     int editCol;

   101     int insertRowLast;

   102     QString insertHeaderLabelLast;

   103     int insertPreRows;

   104     QSqlRecord* editBuffer;

   105     bool cancelMode;

   106     bool cancelInsert;

   107     bool cancelUpdate;

   108     int lastAt;

   109     QString ftr;

   110     QStringList srt;

   111     QStringList fld;

   112     QStringList fldLabel;

   113     Q3ValueList<int> fldWidth;

   114     Q3ValueList<QIconSet> fldIcon;

   115     Q3ValueList<bool> fldHidden;

   116     Q3SqlCursorManager cur;

   117     Q3DataManager dat;

   118 };

   119 

   120 #ifdef QT_DEBUG_DATATABLE

   121 void qt_debug_buffer( const QString& msg, QSqlRecord* cursor )

   122 {

   123     qDebug("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");

   124     qDebug(msg);

   125     for ( uint j = 0; j < cursor->count(); ++j ) {

   126 	qDebug(cursor->field(j)->name() + " type:" + QString(cursor->field(j)->value().typeName()) + " value:" + cursor->field(j)->value().toString() );

   127     }

   128 }

   129 #endif

   130 

   131 /*!

   132     \enum Q3DataTable::Refresh

   133 

   134     This enum describes the refresh options.

   135 

   136     \value RefreshData  refresh the data, i.e. read it from the database

   137     \value RefreshColumns  refresh the list of fields, e.g. the column headings

   138     \value RefreshAll  refresh both the data and the list of fields

   139 */

   140 

   141 

   142 /*!

   143     \class Q3DataTable

   144     \brief The Q3DataTable class provides a flexible SQL table widget that supports browsing and editing.

   145 

   146     \compat

   147 

   148     Q3DataTable supports various functions for presenting and editing

   149     SQL data from a \l Q3SqlCursor in a table.

   150 

   151     If you want a to present your data in a form use QDataBrowser, or

   152     for read-only forms, use QDataView instead.

   153 

   154     When displaying data, Q3DataTable only retrieves data for visible

   155     rows. If the driver supports the 'query size' property the

   156     Q3DataTable will have the correct number of rows and the vertical

   157     scroll bar will accurately reflect the number of rows displayed in

   158     proportion to the number of rows in the dataset. If the driver

   159     does not support the 'query size' property, rows are dynamically

   160     fetched from the database on an as-needed basis with the scroll bar

   161     becoming more accurate as the user scrolls down through the

   162     records. This allows extremely large queries to be displayed as

   163     quickly as possible, with minimum memory usage.

   164 

   165     Q3DataTable inherits Q3Table's API and extends it with functions to

   166     sort and filter the data and sort columns. See setSqlCursor(),

   167     setFilter(), setSort(), setSorting(), sortColumn() and refresh().

   168 

   169     When displaying editable cursors, cell editing will be enabled.

   170     (For more information on editable cursors, see \l Q3SqlCursor).

   171     Q3DataTable can be used to modify existing data and to add new

   172     records. When a user makes changes to a field in the table, the

   173     cursor's edit buffer is used. The table will not send changes in

   174     the edit buffer to the database until the user moves to a

   175     different record in the grid or presses Enter. Cell editing is

   176     initiated by pressing F2 (or right clicking and then clicking the

   177     appropriate popup menu item) and canceled by pressing Esc. If

   178     there is a problem updating or adding data, errors are handled

   179     automatically (see handleError() to change this behavior). Note

   180     that if autoEdit() is false navigating to another record will

   181     cancel the insert or update.

   182 

   183     The user can be asked to confirm all edits with setConfirmEdits().

   184     For more precise control use setConfirmInsert(),

   185     setConfirmUpdate(), setConfirmDelete() and setConfirmCancels().

   186     Use setAutoEdit() to control the behavior of the table when the

   187     user edits a record and then navigates. (Note that setAutoDelete()

   188     is unrelated; it is used to set whether the Q3SqlCursor is deleted

   189     when the table is deleted.)

   190 

   191     Since the data table can perform edits, it must be able to

   192     uniquely identify every record so that edits are correctly

   193     applied. Because of this the underlying cursor must have a valid

   194     primary index to ensure that a unique record is inserted, updated

   195     or deleted within the database otherwise the database may be

   196     changed to an inconsistent state.

   197 

   198     Q3DataTable creates editors using the default \l Q3SqlEditorFactory.

   199     Different editor factories can be used by calling

   200     installEditorFactory(). A property map is used to map between the

   201     cell's value and the editor. You can use your own property map

   202     with installPropertyMap().

   203 

   204     The contents of a cell is available as a QString with text() or as

   205     a QVariant with value(). The current record is returned by

   206     currentRecord(). Use the find() function to search for a string in

   207     the table.

   208 

   209     Editing actions can be applied programmatically. For example, the

   210     insertCurrent() function reads the fields from the current record

   211     into the cursor and performs the insert. The updateCurrent() and

   212     deleteCurrent() functions perform similarly to update and delete

   213     the current record respectively.

   214 

   215     Columns in the table can be created automatically based on the

   216     cursor (see setSqlCursor()). Columns can be manipulated manually

   217     using addColumn(), removeColumn() and setColumn().

   218 

   219     The table automatically copies many of the properties of the

   220     cursor to format the display of data within cells (alignment,

   221     visibility, etc.). The cursor can be changed with setSqlCursor().

   222     The filter (see setFilter()) and sort defined within the table are

   223     used instead of the filter and sort set on the cursor. For sorting

   224     options see setSort(), sortColumn(), sortAscending() and

   225     sortDescending(). Note that sorting operations will not behave as

   226     expected if you are using a QSqlSelectCursor because it uses

   227     user-defined SQL queries to obtain data.

   228 

   229     The text used to represent NULL, true and false values can be

   230     changed with setNullText(), setTrueText() and setFalseText()

   231     respectively. You can change the appearance of cells by

   232     reimplementing paintField().

   233 

   234     Whenever a new row is selected in the table the currentChanged()

   235     signal is emitted. The primeInsert() signal is emitted when an

   236     insert is initiated. The primeUpdate() and primeDelete() signals

   237     are emitted when update and deletion are initiated respectively.

   238     Just before the database is updated a signal is emitted;

   239     beforeInsert(), beforeUpdate() or beforeDelete() as appropriate.

   240 

   241 */

   242 

   243 /*!

   244     Constructs a data table which is a child of \a parent, called

   245     name \a name.

   246 */

   247 

   248 Q3DataTable::Q3DataTable ( QWidget * parent, const char * name )

   249     : Q3Table( parent, name )

   250 {

   251     init();

   252 }

   253 

   254 /*!

   255     Constructs a data table which is a child of \a parent, called name

   256     \a name using the cursor \a cursor.

   257 

   258     If \a autoPopulate is true (the default is false), columns are

   259     automatically created based upon the fields in the \a cursor

   260     record. Note that \a autoPopulate only governs the creation of

   261     columns; to load the cursor's data into the table use refresh().

   262 

   263     If the \a cursor is read-only, the table also becomes read-only.

   264     In addition, the table adopts the cursor's driver's definition for

   265     representing NULL values as strings.

   266 */

   267 

   268 Q3DataTable::Q3DataTable ( Q3SqlCursor* cursor, bool autoPopulate, QWidget * parent, const char * name )

   269     : Q3Table( parent, name )

   270 {

   271     init();

   272     setSqlCursor( cursor, autoPopulate );

   273 }

   274 

   275 /*! \internal

   276 */

   277 

   278 

   279 void Q3DataTable::init()

   280 {

   281     d = new Q3DataTablePrivate();

   282     setAutoEdit( true );

   283     setSelectionMode( SingleRow );

   284     setFocusStyle( FollowStyle );

   285     d->trueTxt = tr( "True" );

   286     d->falseTxt = tr( "False" );

   287     d->datefmt = Qt::LocalDate;

   288     reset();

   289     connect( this, SIGNAL(selectionChanged()),

   290 	     SLOT(updateCurrentSelection()));

   291 }

   292 

   293 /*!

   294     Destroys the object and frees any allocated resources.

   295 */

   296 

   297 Q3DataTable::~Q3DataTable()

   298 {

   299     delete d;

   300 }

   301 

   302 

   303 /*!

   304     Adds the next column to be displayed using the field \a fieldName,

   305     column label \a label, width \a width and iconset \a iconset.

   306 

   307     If \a label is specified, it is used as the column's header label,

   308     otherwise the field's display label is used when setSqlCursor() is

   309     called. The \a iconset is used to set the icon used by the column

   310     header; by default there is no icon.

   311 

   312     \sa setSqlCursor() refresh()

   313 */

   314 

   315 void Q3DataTable::addColumn( const QString& fieldName,

   316 			    const QString& label,

   317 			    int width,

   318 			    const QIconSet& iconset )

   319 {

   320     d->fld += fieldName;

   321     d->fldLabel += label;

   322     d->fldIcon += iconset;

   323     d->fldWidth += width;

   324     d->fldHidden += false;

   325 }

   326 

   327 /*!

   328     Sets the \a col column to display using the field \a fieldName,

   329     column label \a label, width \a width and iconset \a iconset.

   330 

   331     If \a label is specified, it is used as the column's header label,

   332     otherwise the field's display label is used when setSqlCursor() is

   333     called. The \a iconset is used to set the icon used by the column

   334     header; by default there is no icon.

   335 

   336     \sa setSqlCursor() refresh()

   337 */

   338 

   339 void Q3DataTable::setColumn( uint col, const QString& fieldName,

   340 			    const QString& label,

   341 			    int width,

   342 			    const QIconSet& iconset )

   343 {

   344     d->fld[col]= fieldName;

   345     d->fldLabel[col] = label;

   346     d->fldIcon[col] = iconset;

   347     d->fldWidth[col] = width;

   348     d->fldHidden[col] = false;

   349 }

   350 

   351 /*!

   352     Removes column \a col from the list of columns to be displayed. If

   353     \a col does not exist, nothing happens.

   354 

   355     \sa QSqlField

   356 */

   357 

   358 void Q3DataTable::removeColumn( int col )

   359 {

   360     if ( d->fld.begin() + col != d->fld.end() ) {

   361 	d->fld.remove( d->fld.at( col ) );

   362 	d->fldLabel.remove( d->fldLabel.at( col ) );

   363 	d->fldIcon.remove( d->fldIcon.at( col ) );

   364 	d->fldWidth.remove( d->fldWidth.at( col ) );

   365 	d->fldHidden.remove( d->fldHidden.at( col ) );

   366     }

   367 }

   368 

   369 /*!

   370     Sets the column \a col to the width \a w. Note that unlike Q3Table

   371     the Q3DataTable is not immediately redrawn, you must call

   372     refresh(Q3DataTable::RefreshColumns)

   373     yourself.

   374 

   375     \sa refresh()

   376 */

   377 void Q3DataTable::setColumnWidth( int col, int w )

   378 {

   379     if ( d->fldWidth.at( col ) != d->fldWidth.end() ) {

   380 	d->fldWidth[col] = w;

   381     }

   382 }

   383 

   384 /*!

   385     Resizes column \a col so that the column width is wide enough to

   386     display the widest item the column contains (including the column

   387     label). If the table's Q3SqlCursor is not currently active, the

   388     cursor will be refreshed before the column width is calculated. Be

   389     aware that this function may be slow on tables that contain large

   390     result sets.

   391 */

   392 void Q3DataTable::adjustColumn( int col )

   393 {

   394     Q3SqlCursor * cur = sqlCursor();

   395     if ( !cur || cur->count() <= col )

   396 	return;

   397     if ( !cur->isActive() ) {

   398 	d->cur.refresh();

   399     }

   400     int oldRow = currentRow();

   401     int w = fontMetrics().width( horizontalHeader()->label( col ) + QLatin1Char('W') );

   402     cur->seek( QSql::BeforeFirst );

   403     while ( cur->next() ) {

   404 	w = qMax( w, fontMetrics().width( fieldToString( cur->fieldPtr( indexOf( col ) ) ) ) + 10 );

   405     }

   406     setColumnWidth( col, w );

   407     cur->seek( oldRow );

   408     refresh( RefreshColumns );

   409 }

   410 

   411 /*! \reimp

   412 */

   413 void Q3DataTable::setColumnStretchable( int col, bool s )

   414 {

   415     if ( numCols() == 0 ) {

   416 	refresh( RefreshColumns );

   417     }

   418     if ( numCols() > col ) {

   419 	Q3Table::setColumnStretchable( col, s );

   420     }

   421 }

   422 

   423 QString Q3DataTable::filter() const

   424 {

   425     return d->cur.filter();

   426 }

   427 

   428 /*!

   429     \property Q3DataTable::filter

   430     \brief the data filter for the data table

   431 

   432     The filter applies to the data shown in the table. To view data

   433     with a new filter, use refresh(). A filter string is an SQL WHERE

   434     clause without the WHERE keyword.

   435 

   436     There is no default filter.

   437 

   438     \sa sort()

   439 

   440 */

   441 

   442 void Q3DataTable::setFilter( const QString& filter )

   443 {

   444     d->cur.setFilter( filter );

   445 }

   446 

   447 

   448 /*!

   449     \property Q3DataTable::sort

   450     \brief the data table's sort

   451 

   452     The table's sort affects the order in which data records are

   453     displayed in the table. To apply a sort, use refresh().

   454 

   455     When examining the sort property, a string list is returned with

   456     each item having the form 'fieldname order' (e.g., 'id ASC',

   457     'surname DESC').

   458 

   459     There is no default sort.

   460 

   461     Note that if you want to iterate over the sort list, you should

   462     iterate over a copy, e.g.

   463     \snippet doc/src/snippets/code/src_qt3support_sql_q3datatable.cpp 0

   464 

   465     \sa filter() refresh()

   466 */

   467 

   468 void Q3DataTable::setSort( const QStringList& sort )

   469 {

   470     d->cur.setSort( sort );

   471 }

   472 

   473 /*!

   474     \overload

   475 

   476     Sets the sort to be applied to the displayed data to \a sort. If

   477     there is no current cursor, nothing happens. A QSqlIndex contains

   478     field names and their ordering (ASC or DESC); these are used to

   479     compose the ORDER BY clause.

   480 

   481     \sa sort()

   482 */

   483 

   484 void Q3DataTable::setSort( const QSqlIndex& sort )

   485 {

   486     d->cur.setSort( sort );

   487 }

   488 

   489 QStringList Q3DataTable::sort() const

   490 {

   491     return d->cur.sort();

   492 }

   493 

   494 /*!

   495     Returns the cursor used by the data table.

   496 */

   497 

   498 Q3SqlCursor* Q3DataTable::sqlCursor() const

   499 {

   500     return d->cur.cursor();

   501 }

   502 

   503 void Q3DataTable::setConfirmEdits( bool confirm )

   504 {

   505     d->dat.setConfirmEdits( confirm );

   506 }

   507 

   508 void Q3DataTable::setConfirmInsert( bool confirm )

   509 {

   510     d->dat.setConfirmInsert( confirm );

   511 }

   512 

   513 void Q3DataTable::setConfirmUpdate( bool confirm )

   514 {

   515     d->dat.setConfirmUpdate( confirm );

   516 }

   517 

   518 void Q3DataTable::setConfirmDelete( bool confirm )

   519 {

   520     d->dat.setConfirmDelete( confirm );

   521 }

   522 

   523 /*!

   524     \property Q3DataTable::confirmEdits

   525     \brief whether the data table confirms edit operations

   526 

   527     If the confirmEdits property is true, the data table confirms all

   528     edit operations (inserts, updates and deletes). Finer control of

   529     edit confirmation can be achieved using \l confirmCancels, \l

   530     confirmInsert, \l confirmUpdate and \l confirmDelete.

   531 

   532     \sa confirmCancels() confirmInsert() confirmUpdate() confirmDelete()

   533 */

   534 

   535 bool Q3DataTable::confirmEdits() const

   536 {

   537     return ( d->dat.confirmEdits() );

   538 }

   539 

   540 /*!

   541     \property Q3DataTable::confirmInsert

   542     \brief whether the data table confirms insert operations

   543 

   544     If the confirmInsert property is true, all insertions must be

   545     confirmed by the user through a message box (this behavior can be

   546     changed by overriding the confirmEdit() function), otherwise all

   547     insert operations occur immediately.

   548 

   549     \sa confirmCancels() confirmEdits() confirmUpdate() confirmDelete()

   550 */

   551 

   552 bool Q3DataTable::confirmInsert() const

   553 {

   554     return ( d->dat.confirmInsert() );

   555 }

   556 

   557 /*!

   558     \property Q3DataTable::confirmUpdate

   559     \brief whether the data table confirms update operations

   560 

   561     If the confirmUpdate property is true, all updates must be

   562     confirmed by the user through a message box (this behavior can be

   563     changed by overriding the confirmEdit() function), otherwise all

   564     update operations occur immediately.

   565 

   566     \sa confirmCancels() confirmEdits() confirmInsert() confirmDelete()

   567 */

   568 

   569 bool Q3DataTable::confirmUpdate() const

   570 {

   571     return ( d->dat.confirmUpdate() );

   572 }

   573 

   574 /*!

   575     \property Q3DataTable::confirmDelete

   576     \brief whether the data table confirms delete operations

   577 

   578     If the confirmDelete property is true, all deletions must be

   579     confirmed by the user through a message box (this behavior can be

   580     changed by overriding the confirmEdit() function), otherwise all

   581     delete operations occur immediately.

   582 

   583     \sa confirmCancels() confirmEdits() confirmUpdate() confirmInsert()

   584 */

   585 

   586 bool Q3DataTable::confirmDelete() const

   587 {

   588     return ( d->dat.confirmDelete() );

   589 }

   590 

   591 /*!

   592     \property Q3DataTable::confirmCancels

   593     \brief whether the data table confirms cancel operations

   594 

   595     If the confirmCancel property is true, all cancels must be

   596     confirmed by the user through a message box (this behavior can be

   597     changed by overriding the confirmCancel() function), otherwise all

   598     cancels occur immediately. The default is false.

   599 

   600     \sa confirmEdits() confirmCancel()

   601 */

   602 

   603 void Q3DataTable::setConfirmCancels( bool confirm )

   604 {

   605     d->dat.setConfirmCancels( confirm );

   606 }

   607 

   608 bool Q3DataTable::confirmCancels() const

   609 {

   610     return d->dat.confirmCancels();

   611 }

   612 

   613 /*!

   614     \reimp

   615 

   616     For an editable table, creates an editor suitable for the field in

   617     column \a col. The editor is created using the default editor

   618     factory, unless a different editor factory was installed with

   619     installEditorFactory(). The editor is primed with the value of the

   620     field in \a col using a property map. The property map used is the

   621     default property map, unless a new property map was installed with

   622     installPropertMap(). If \a initFromCell is true then the editor is

   623     primed with the value in the Q3DataTable cell.

   624 */

   625 

   626 QWidget * Q3DataTable::createEditor( int , int col, bool initFromCell ) const

   627 {

   628     if ( d->dat.mode() == QSql::None )

   629 	return 0;

   630 

   631     Q3SqlEditorFactory * f = (d->editorFactory == 0) ?

   632 		     Q3SqlEditorFactory::defaultFactory() : d->editorFactory;

   633 

   634     Q3SqlPropertyMap * m = (d->propertyMap == 0) ?

   635 			  Q3SqlPropertyMap::defaultMap() : d->propertyMap;

   636 

   637     QWidget * w = 0;

   638     if( initFromCell && d->editBuffer ){

   639 	w = f->createEditor( viewport(), d->editBuffer->fieldPtr( indexOf( col ) ) );

   640 	if ( w )

   641 	    m->setProperty( w, d->editBuffer->value( indexOf( col ) ) );

   642     }

   643     return w;

   644 }

   645 

   646 /*! \reimp */

   647 bool Q3DataTable::eventFilter( QObject *o, QEvent *e )

   648 {

   649     if ( d->cancelMode )

   650 	return true;

   651 

   652     int r = currentRow();

   653     int c = currentColumn();

   654 

   655     if ( d->dat.mode() != QSql::None ) {

   656 	r = d->editRow;

   657 	c = d->editCol;

   658     }

   659 

   660     d->cancelInsert = false;

   661     d->cancelUpdate = false;

   662     switch ( e->type() ) {

   663     case QEvent::KeyPress: {

   664 	int conf = QSql::Yes;

   665 	QKeyEvent *ke = (QKeyEvent*)e;

   666 	if ( ( ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_BackTab )

   667 	    && ke->state() & Qt::ControlButton )

   668 	    return false;

   669 

   670 	if ( ke->key() == Qt::Key_Escape && d->dat.mode() == QSql::Insert ){

   671 	    if ( confirmCancels() && !d->cancelMode ) {

   672 		d->cancelMode = true;

   673 		conf = confirmCancel( QSql::Insert );

   674 		d->cancelMode = false;

   675 	    }

   676 	    if ( conf == QSql::Yes ) {

   677 		d->cancelInsert = true;

   678 	    } else {

   679 		QWidget *editorWidget = cellWidget( r, c );

   680 		if ( editorWidget ) {

   681 		    editorWidget->setActiveWindow();

   682 		    editorWidget->setFocus();

   683 		}

   684 		return true;

   685 	    }

   686 	}

   687 	if ( ke->key() == Qt::Key_Escape && d->dat.mode() == QSql::Update ) {

   688 	    if ( confirmCancels() && !d->cancelMode ) {

   689 		d->cancelMode = true;

   690 		conf = confirmCancel( QSql::Update );

   691 		d->cancelMode = false;

   692 	    }

   693 	    if ( conf == QSql::Yes ){

   694 		d->cancelUpdate = true;

   695 	    } else {

   696 		QWidget *editorWidget = cellWidget( r, c );

   697 		if ( editorWidget ) {

   698 		    editorWidget->setActiveWindow();

   699 		    editorWidget->setFocus();

   700 		}

   701 		return true;

   702 	    }

   703 	}

   704 	if ( ke->key() == Qt::Key_Insert && d->dat.mode() == QSql::None ) {

   705 	    beginInsert();

   706 	    return true;

   707 	}

   708 	if ( ke->key() == Qt::Key_Delete && d->dat.mode() == QSql::None ) {

   709 	    deleteCurrent();

   710 	    return true;

   711 	}

   712 	if ( d->dat.mode() != QSql::None ) {

   713 	    if ( (ke->key() == Qt::Key_Tab) && (c < numCols() - 1) && (!isColumnReadOnly( c+1 ) || d->dat.mode() == QSql::Insert) )

   714 		d->continuousEdit = true;

   715 	    else if ( (ke->key() == Qt::Key_BackTab) && (c > 0) && (!isColumnReadOnly( c-1 ) || d->dat.mode() == QSql::Insert) )

   716 		d->continuousEdit = true;

   717 	    else

   718 		d->continuousEdit = false;

   719 	}

   720 	Q3SqlCursor * sql = sqlCursor();

   721 	if ( sql && sql->driver() &&

   722 	     !sql->driver()->hasFeature( QSqlDriver::QuerySize ) &&

   723 	     ke->key() == Qt::Key_End && d->dat.mode() == QSql::None ) {

   724 #ifndef QT_NO_CURSOR

   725 	    QApplication::setOverrideCursor( Qt::WaitCursor );

   726 #endif

   727 	    int i = sql->at();

   728 	    if ( i < 0 ) {

   729 		i = 0;

   730 		sql->seek(0);

   731 	    }

   732 	    while ( sql->next() )

   733 		i++;

   734 	    setNumRows( i+1 );

   735 	    setCurrentCell( i+1, currentColumn() );

   736 #ifndef QT_NO_CURSOR

   737 	    QApplication::restoreOverrideCursor();

   738 #endif

   739 	    return true;

   740 	}

   741 	break;

   742     }

   743     case QEvent::FocusOut: {

   744 	QWidget *editorWidget = cellWidget( r, c );

   745 	repaintCell( currentRow(), currentColumn() );

   746 	if ( !d->cancelMode && editorWidget && o == editorWidget &&

   747 	     ( d->dat.mode() == QSql::Insert) && !d->continuousEdit) {

   748 	    setCurrentCell( r, c );

   749 	    d->cancelInsert = true;

   750 	}

   751 	d->continuousEdit = false;

   752 	break;

   753     }

   754     case QEvent::FocusIn:

   755 	repaintCell( currentRow(), currentColumn() );

   756 	break;

   757     default:

   758 	break;

   759     }

   760     return Q3Table::eventFilter( o, e );

   761 }

   762 

   763 /*! \reimp */

   764 void Q3DataTable::resizeEvent ( QResizeEvent * e )

   765 {

   766     if ( sqlCursor() &&

   767 	 sqlCursor()->driver() &&

   768 	 !sqlCursor()->driver()->hasFeature( QSqlDriver::QuerySize ) )

   769 	loadNextPage();

   770     Q3Table::resizeEvent( e );

   771 }

   772 

   773 /*! \reimp */

   774 void Q3DataTable::contentsContextMenuEvent( QContextMenuEvent* e )

   775 {

   776     Q3Table::contentsContextMenuEvent( e );

   777     if ( isEditing() && d->dat.mode() != QSql::None )

   778 	endEdit( d->editRow, d->editCol, autoEdit(), false );

   779     if ( !sqlCursor() )

   780 	return;

   781     if ( d->dat.mode() == QSql::None ) {

   782 	if ( isReadOnly() )

   783 	    return;

   784 	enum {

   785 	    IdInsert,

   786 	    IdUpdate,

   787 	    IdDelete

   788 	};

   789 	QPointer<Q3PopupMenu> popup = new Q3PopupMenu( this, "qt_datatable_menu" );

   790 	int id[ 3 ];

   791 	id[ IdInsert ] = popup->insertItem( tr( "Insert" ) );

   792 	id[ IdUpdate ] = popup->insertItem( tr( "Update" ) );

   793 	id[ IdDelete ] = popup->insertItem( tr( "Delete" ) );

   794 	bool enableInsert = sqlCursor()->canInsert();

   795 	popup->setItemEnabled( id[ IdInsert ], enableInsert );

   796 	bool enableUpdate = currentRow() > -1 && sqlCursor()->canUpdate() && !isColumnReadOnly( currentColumn() );

   797 	popup->setItemEnabled( id[ IdUpdate ], enableUpdate );

   798 	bool enableDelete = currentRow() > -1 && sqlCursor()->canDelete();

   799 	popup->setItemEnabled( id[ IdDelete ], enableDelete );

   800 	int r = popup->exec( e->globalPos() );

   801 	delete (Q3PopupMenu*) popup;

   802 	if ( r == id[ IdInsert ] )

   803 	    beginInsert();

   804 	else if ( r == id[ IdUpdate ] ) {

   805 	    if ( beginEdit( currentRow(), currentColumn(), false ) )

   806 		setEditMode( Editing, currentRow(), currentColumn() );

   807 	    else

   808 		endUpdate();

   809 	}

   810 	else if ( r == id[ IdDelete ] )

   811 	    deleteCurrent();

   812 	e->accept();

   813     }

   814 }

   815 

   816 /*! \reimp */

   817 void Q3DataTable::contentsMousePressEvent( QMouseEvent* e )

   818 {

   819     Q3Table::contentsMousePressEvent( e );

   820 }

   821 

   822 /*! \reimp */

   823 QWidget* Q3DataTable::beginEdit ( int row, int col, bool replace )

   824 {

   825     d->editRow = -1;

   826     d->editCol = -1;

   827     if ( !sqlCursor() )

   828 	return 0;

   829     if ( d->dat.mode() == QSql::Insert && !sqlCursor()->canInsert() )

   830 	return 0;

   831     if ( d->dat.mode() == QSql::Update && !sqlCursor()->canUpdate() )

   832 	return 0;

   833     d->editRow = row;

   834     d->editCol = col;

   835     if ( d->continuousEdit ) {

   836 	// see comment in beginInsert()

   837 	bool fakeReadOnly = isColumnReadOnly( col );

   838 	setColumnReadOnly( col, false );

   839 	QWidget* w = Q3Table::beginEdit( row, col, replace );

   840 	setColumnReadOnly( col, fakeReadOnly );

   841 	return w;

   842     }

   843     if ( d->dat.mode() == QSql::None && sqlCursor()->canUpdate() && sqlCursor()->primaryIndex().count() > 0 )

   844 	return beginUpdate( row, col, replace );

   845     return 0;

   846 }

   847 

   848 /*! \reimp */

   849 void Q3DataTable::endEdit( int row, int col, bool, bool )

   850 {

   851     bool accept = autoEdit() && !d->cancelInsert && !d->cancelUpdate;

   852 

   853     QWidget *editor = cellWidget( row, col );

   854     if ( !editor )

   855 	return;

   856     if ( d->cancelMode )

   857 	return;

   858     if ( d->dat.mode() != QSql::None && d->editBuffer ) {

   859 	Q3SqlPropertyMap * m = (d->propertyMap == 0) ?

   860 			      Q3SqlPropertyMap::defaultMap() : d->propertyMap;

   861 	d->editBuffer->setValue( indexOf( col ), m->property( editor ) );

   862 	clearCellWidget( row, col );

   863 	if ( !d->continuousEdit ) {

   864 	    switch ( d->dat.mode() ) {

   865 	    case QSql::Insert:

   866 		if ( accept )

   867 		    QTimer::singleShot( 0, this, SLOT(doInsertCurrent()) );

   868 		else

   869 		    endInsert();

   870 		break;

   871 	    case QSql::Update:

   872 		if ( accept )

   873 		    QTimer::singleShot( 0, this, SLOT(doUpdateCurrent()) );

   874 		else

   875 		    endUpdate();

   876 		break;

   877 	    default:

   878 		break;

   879 	    }

   880 	}

   881     } else {

   882 	setEditMode( NotEditing, -1, -1 );

   883     }

   884     if ( d->dat.mode() == QSql::None )

   885 	viewport()->setFocus();

   886     updateCell( row, col );

   887     emit valueChanged( row, col );

   888 }

   889 

   890 /*! \internal */

   891 void Q3DataTable::doInsertCurrent()

   892 {

   893     insertCurrent();

   894 }

   895 

   896 /*! \internal */

   897 void Q3DataTable::doUpdateCurrent()

   898 {

   899     updateCurrent();

   900     if ( d->dat.mode() == QSql::None ) {

   901 	viewport()->setFocus();

   902     }

   903 }

   904 

   905 /*! \reimp */

   906 void Q3DataTable::activateNextCell()

   907 {

   908 //     if ( d->dat.mode() == QSql::None )

   909 //	Q3Table::activateNextCell();

   910 }

   911 

   912 /*! \internal

   913 */

   914 

   915 void Q3DataTable::endInsert()

   916 {

   917     if ( d->dat.mode() != QSql::Insert )

   918 	return;

   919     d->dat.setMode( QSql::None );

   920     d->editBuffer = 0;

   921     verticalHeader()->setLabel( d->editRow, QString::number( d->editRow +1 ) );

   922     d->editRow = -1;

   923     d->editCol = -1;

   924     d->insertRowLast = -1;

   925     d->insertHeaderLabelLast.clear();

   926     setEditMode( NotEditing, -1, -1 );

   927     setNumRows( d->insertPreRows );

   928     d->insertPreRows = -1;

   929     viewport()->setFocus();

   930 }

   931 

   932 /*! \internal

   933  */

   934 void Q3DataTable::endUpdate()

   935 {

   936     d->dat.setMode( QSql::None );

   937     d->editBuffer = 0;

   938     updateRow( d->editRow );

   939     d->editRow = -1;

   940     d->editCol = -1;

   941     setEditMode( NotEditing, -1, -1 );

   942 }

   943 

   944 /*!

   945   Protected virtual function called when editing is about to begin

   946   on a new record. If the table is read-only, or if there's no cursor

   947   or the cursor does not allow inserts, nothing happens and false

   948   is returned. Otherwise returns true.

   949   

   950   Editing takes place using the cursor's edit buffer(see

   951   Q3SqlCursor::editBuffer()).

   952   

   953   When editing begins, a new row is created in the table marked with

   954   an asterisk '*' in the row's vertical header column, i.e. at the

   955   left of the row.

   956 */

   957 bool Q3DataTable::beginInsert()

   958 {

   959     if ( !sqlCursor() || isReadOnly() || !numCols() )

   960 	return false;

   961     if ( !sqlCursor()->canInsert() )

   962 	return false;

   963     int i = 0;

   964     int row = currentRow();

   965 

   966     d->insertPreRows = numRows();

   967     if ( row < 0 || numRows() < 1 )

   968 	row = 0;

   969     setNumRows( d->insertPreRows + 1 );

   970     setCurrentCell( row, 0 );

   971     d->editBuffer = sqlCursor()->primeInsert();

   972     emit primeInsert( d->editBuffer );

   973     d->dat.setMode( QSql::Insert );

   974     int lastRow = row;

   975     int lastY = contentsY() + visibleHeight();

   976     for ( i = row; i < numRows() ; ++i ) {

   977 	QRect cg = cellGeometry( i, 0 );

   978 	if ( (cg.y()+cg.height()) > lastY ) {

   979 	    lastRow = i;

   980 	    break;

   981 	}

   982     }

   983     if ( lastRow == row && ( numRows()-1 > row ) )

   984 	lastRow = numRows() - 1;

   985     d->insertRowLast = lastRow;

   986     d->insertHeaderLabelLast = verticalHeader()->label( d->insertRowLast );

   987     verticalHeader()->setLabel( row, QString(QLatin1Char('*')) );

   988     d->editRow = row;

   989     // in the db world it's common to allow inserting new records

   990     // into a table that has read-only columns - temporarily

   991     // switch off read-only mode for such columns

   992     bool fakeReadOnly = isColumnReadOnly( 0 );

   993     setColumnReadOnly( 0, false );

   994     if ( Q3Table::beginEdit( row, 0, false ) )

   995 	setEditMode( Editing, row, 0 );

   996     setColumnReadOnly( 0, fakeReadOnly );

   997     return true;

   998 }

   999 

  1000 /*!

  1001     Protected virtual function called when editing is about to begin

  1002     on an existing row. If the table is read-only, or if there's no

  1003     cursor, nothing happens.

  1004 

  1005     Editing takes place using the cursor's edit buffer (see

  1006     Q3SqlCursor::editBuffer()).

  1007 

  1008     \a row and \a col refer to the row and column in the Q3DataTable.

  1009 

  1010     (\a replace is provided for reimplementors and reflects the API of

  1011     Q3Table::beginEdit().)

  1012 */

  1013 

  1014 QWidget* Q3DataTable::beginUpdate ( int row, int col, bool replace )

  1015 {

  1016     if ( !sqlCursor() || isReadOnly() || isColumnReadOnly( col ) )

  1017 	return 0;

  1018     setCurrentCell( row, col );

  1019     d->dat.setMode( QSql::Update );

  1020     if ( sqlCursor()->seek( row ) ) {

  1021 	d->editBuffer = sqlCursor()->primeUpdate();

  1022 	sqlCursor()->seek( currentRow() );

  1023 	emit primeUpdate( d->editBuffer );

  1024 	return Q3Table::beginEdit( row, col, replace );

  1025     }

  1026     return 0;

  1027 }

  1028 

  1029 /*!

  1030     For an editable table, issues an insert on the current cursor

  1031     using the values in the cursor's edit buffer. If there is no

  1032     current cursor or there is no current "insert" row, nothing

  1033     happens. If confirmEdits() or confirmInsert() is true,

  1034     confirmEdit() is called to confirm the insert. Returns true if the

  1035     insert succeeded; otherwise returns false.

  1036 

  1037     The underlying cursor must have a valid primary index to ensure

  1038     that a unique record is inserted within the database otherwise the

  1039     database may be changed to an inconsistent state.

  1040 */

  1041 

  1042 bool Q3DataTable::insertCurrent()

  1043 {

  1044     if ( d->dat.mode() != QSql::Insert || ! numCols() )

  1045 	return false;

  1046     if ( !sqlCursor()->canInsert() ) {

  1047 #ifdef QT_CHECK_RANGE

  1048 	qWarning("Q3DataTable::insertCurrent: insert not allowed for %s",

  1049 		 sqlCursor()->name().latin1() );

  1050 #endif

  1051 	endInsert();

  1052 	return false;

  1053     }

  1054     int b = 0;

  1055     int conf = QSql::Yes;

  1056     if ( confirmEdits() || confirmInsert() )

  1057 	conf = confirmEdit( QSql::Insert );

  1058     switch ( conf ) {

  1059     case QSql::Yes: {

  1060 #ifndef QT_NO_CURSOR

  1061 	QApplication::setOverrideCursor( Qt::waitCursor );

  1062 #endif

  1063 	emit beforeInsert( d->editBuffer );

  1064 	b = sqlCursor()->insert();

  1065 #ifndef QT_NO_CURSOR

  1066 	QApplication::restoreOverrideCursor();

  1067 #endif

  1068 	if ( ( !b && !sqlCursor()->isActive() ) || !sqlCursor()->isActive() ) {

  1069 	    handleError( sqlCursor()->lastError() );

  1070 	    endInsert(); // cancel the insert if anything goes wrong

  1071 	    refresh();

  1072 	} else {

  1073 	    endInsert();

  1074 	    refresh();

  1075 	    QSqlIndex idx = sqlCursor()->primaryIndex();

  1076 	    findBuffer( idx, d->lastAt );

  1077 	    repaintContents( contentsX(), contentsY(), visibleWidth(), visibleHeight(), false );

  1078 	    emit cursorChanged( QSql::Insert );

  1079 	}

  1080 	break;

  1081     }

  1082     case QSql::No:

  1083 	endInsert();

  1084 	break;

  1085     case QSql::Cancel:

  1086 	if ( Q3Table::beginEdit( currentRow(), currentColumn(), false ) )

  1087 	    setEditMode( Editing, currentRow(), currentColumn() );

  1088 	break;

  1089     }

  1090     return ( b > 0 );

  1091 }

  1092 

  1093 /*! \internal

  1094 

  1095   Updates the row \a row.

  1096 */

  1097 

  1098 void Q3DataTable::updateRow( int row )

  1099 {

  1100     for ( int i = 0; i < numCols(); ++i )

  1101 	updateCell( row, i );

  1102 }

  1103 

  1104 /*!

  1105     For an editable table, issues an update using the cursor's edit

  1106     buffer. If there is no current cursor or there is no current

  1107     selection, nothing happens. If confirmEdits() or confirmUpdate()

  1108     is true, confirmEdit() is called to confirm the update. Returns

  1109     true if the update succeeded; otherwise returns false.

  1110 

  1111     The underlying cursor must have a valid primary index to ensure

  1112     that a unique record is updated within the database otherwise the

  1113     database may be changed to an inconsistent state.

  1114 */

  1115 

  1116 bool Q3DataTable::updateCurrent()

  1117 {

  1118     if ( d->dat.mode() != QSql::Update )

  1119 	return false;

  1120     if ( sqlCursor()->primaryIndex().count() == 0 ) {

  1121 #ifdef QT_CHECK_RANGE

  1122 	qWarning("Q3DataTable::updateCurrent: no primary index for %s",

  1123 		 sqlCursor()->name().latin1() );

  1124 #endif

  1125 	endUpdate();

  1126 	return false;

  1127     }

  1128     if ( !sqlCursor()->canUpdate() ) {

  1129 #ifdef QT_CHECK_RANGE

  1130 	qWarning("Q3DataTable::updateCurrent: updates not allowed for %s",

  1131 		 sqlCursor()->name().latin1() );

  1132 #endif

  1133 	endUpdate();

  1134 	return false;