kexidataawareobjectiface.cpp

/* This file is part of the KDE project
   Copyright (C) 2005-2007 Jaroslaw Staniek <js@iidea.pl>
 
   Based on KexiTableView code.
   Copyright (C) 2002 Till Busch <till@bux.at>
   Copyright (C) 2003 Lucijan Busch <lucijan@gmx.at>
   Copyright (C) 2003 Daniel Molkentin <molkentin@kde.org>
   Copyright (C) 2003 Joseph Wenninger <jowenn@kde.org>
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#include "kexidataawareobjectiface.h"
 
#include <tqscrollview.h>
#include <tqlabel.h>
#include <tqtooltip.h>
 
#include <tdemessagebox.h>
 
#include <kexi.h>
#include <kexiutils/validator.h>
#include <widget/utils/kexirecordnavigator.h>
#include <widget/utils/kexirecordmarker.h>
#include <kexidb/roweditbuffer.h>
#include <kexidataiteminterface.h>
 
#include "kexitableviewheader.h"
 
using namespace KexiUtils;
 
KexiDataAwareObjectInterface::KexiDataAwareObjectInterface()
{
    m_data = 0;
    m_itemIterator = 0;
    m_readOnly = -1; //don't know
    m_insertingEnabled = -1; //don't know
    m_isSortingEnabled = true;
    m_isFilteringEnabled = true;
    m_deletionPolicy = AskDelete;
    m_inside_acceptEditor = false;
    m_acceptsRowEditAfterCellAccepting = false;
    m_internal_acceptsRowEditAfterCellAccepting = false;
    m_contentsMousePressEvent_dblClick = false;
    m_navPanel = 0;
    m_initDataContentsOnShow = false;
    m_cursorPositionSetExplicityBeforeShow = false;
    m_verticalHeader = 0;
    m_horizontalHeader = 0;
    m_insertItem = 0;
//  m_rowEditBuffer = 0;
    m_spreadSheetMode = false;
    m_dropsAtRowEnabled = false;
    m_updateEntireRowWhenMovingToOtherRow = false;
    m_dragIndicatorLine = -1;
    m_emptyRowInsertingEnabled = false;
    m_popupMenu = 0;
    m_contextMenuEnabled = true;
    m_rowWillBeDeleted = -1;
    m_alsoUpdateNextRow = false;
    m_verticalHeaderAlreadyAdded = false;
    m_vScrollBarValueChanged_enabled = true;
    m_scrollbarToolTipsEnabled = true;
    m_scrollBarTipTimerCnt = 0;
    m_scrollBarTip = 0;
    m_recentSearchDirection = KexiSearchAndReplaceViewInterface::Options::DefaultSearchDirection;
 
    // setup scrollbar tooltip and related members
    m_scrollBarTip = new TQLabel("",0, "vScrollBarToolTip",
        TQt::WStyle_Customize |TQt::WStyle_NoBorder|TQt::WX11BypassWM|TQt::WStyle_StaysOnTop|TQt::WStyle_Tool);
    m_scrollBarTip->setPalette(TQToolTip::palette());
    m_scrollBarTip->setMargin(2);
    m_scrollBarTip->setIndent(0);
    m_scrollBarTip->setAlignment(TQt::AlignCenter);
    m_scrollBarTip->setFrameStyle( TQFrame::Plain | TQFrame::Box );
    m_scrollBarTip->setLineWidth(1);
 
    clearVariables();
}
 
KexiDataAwareObjectInterface::~KexiDataAwareObjectInterface()
{
    delete m_insertItem;
//  delete m_rowEditBuffer;
    delete m_itemIterator;
    delete m_scrollBarTip;
    //we cannot delete m_data here... subclasses should do this
}
 
void KexiDataAwareObjectInterface::clearVariables()
{
    m_editor = 0;
//  m_rowEditBuffer = 0;
    m_rowEditing = false;
    m_newRowEditing = false;
    m_curRow = -1;
    m_curCol = -1;
    m_currentItem = 0;
}
 
void KexiDataAwareObjectInterface::setData( KexiTableViewData *data, bool owner )
{
    const bool theSameData = m_data && m_data==data;
    if (m_owner && m_data && m_data!=data/*don't destroy if it's the same*/) {
        kexidbg << "KexiDataAwareObjectInterface::setData(): destroying old data (owned)" << endl;
        delete m_itemIterator;
        delete m_data; //destroy old data
        m_data = 0;
        m_itemIterator = 0;
    }
    m_owner = owner;
    m_data = data;
    if (m_data)
        m_itemIterator = m_data->createIterator();
 
    kdDebug(44021) << "KexiDataAwareObjectInterface::setData(): using shared data" << endl;
        //add columns
//OK?
    clearColumnsInternal(false);
    if (m_data) {
        int i = 0;
        for (KexiTableViewColumn::ListIterator it(m_data->columns);
            it.current(); ++it, i++) 
        {
            KexiDB::Field *f = it.current()->field();
            if (it.current()->visible()) {
                int wid = f->width();
                if (wid==0)
                    wid=KEXI_DEFAULT_DATA_COLUMN_WIDTH;//default col width in pixels
                addHeaderColumn(it.current()->isHeaderTextVisible()
                    ? it.current()->captionAliasOrName() : TQString(),
                    f->description(), it.current()->icon(), wid);
            }
        }
    }
    if (m_verticalHeader) {
        m_verticalHeader->clear();
        if (m_data)
            m_verticalHeader->addLabels(m_data->count());
    }
    if (m_data && m_data->count()==0)
        m_navPanel->setCurrentRecordNumber(0+1);
    
    if (m_data && !theSameData) {
        setSorting(-1);
//      connect(m_data, TQ_SIGNAL(refreshRequested()), this, TQ_SLOT(slotRefreshRequested()));
        connectToReloadDataSlot(m_data, TQ_SIGNAL(reloadRequested()));
        TQObject* thisObject = dynamic_cast<TQObject*>(this);
        if (thisObject) {
            TQObject::connect(m_data, TQ_SIGNAL(destroying()), thisObject, TQ_SLOT(slotDataDestroying()));
            TQObject::connect(m_data, TQ_SIGNAL(rowsDeleted( const TQValueList<int> & )), 
                thisObject, TQ_SLOT(slotRowsDeleted( const TQValueList<int> & )));
            TQObject::connect(m_data, TQ_SIGNAL(aboutToDeleteRow(KexiTableItem&,KexiDB::ResultInfo*,bool)),
                thisObject, TQ_SLOT(slotAboutToDeleteRow(KexiTableItem&,KexiDB::ResultInfo*,bool)));
            TQObject::connect(m_data, TQ_SIGNAL(rowDeleted()), thisObject, TQ_SLOT(slotRowDeleted()));
            TQObject::connect(m_data, TQ_SIGNAL(rowInserted(KexiTableItem*,bool)), 
                thisObject, TQ_SLOT(slotRowInserted(KexiTableItem*,bool)));
            TQObject::connect(m_data, TQ_SIGNAL(rowInserted(KexiTableItem*,uint,bool)), 
                thisObject, TQ_SLOT(slotRowInserted(KexiTableItem*,uint,bool))); //not db-aware
            TQObject::connect(m_data, TQ_SIGNAL(rowRepaintRequested(KexiTableItem&)), 
                thisObject, TQ_SLOT(slotRowRepaintRequested(KexiTableItem&)));
            // setup scrollbar's tooltip
            TQObject::connect(verticalScrollBar(),TQ_SIGNAL(sliderReleased()),
                thisObject,TQ_SLOT(vScrollBarSliderReleased()));
            TQObject::connect(verticalScrollBar(),TQ_SIGNAL(valueChanged(int)),
                thisObject,TQ_SLOT(vScrollBarValueChanged(int)));
            TQObject::connect(&m_scrollBarTipTimer,TQ_SIGNAL(timeout()),
                thisObject,TQ_SLOT(scrollBarTipTimeout()));
        }
    }
 
    if (!m_data) {
//      clearData();
        cancelRowEdit();
        //m_data->clearInternal();
        clearVariables();
    }
    else {
        if (!m_insertItem) {//first setData() call - add 'insert' item
            m_insertItem = m_data->createItem(); //new KexiTableItem(m_data->columns.count());
        }
        else {//just reinit
            m_insertItem->init(m_data->columns.count());
        }
    }
 
    //update gui mode
    m_navPanel->setInsertingEnabled(m_data && isInsertingEnabled());
    if (m_verticalHeader)
        m_verticalHeader->showInsertRow(m_data && isInsertingEnabled());
 
    initDataContents();
    updateIndicesForVisibleValues();
 
    if (m_data)
        /*emit*/ dataSet( m_data );
}
 
void KexiDataAwareObjectInterface::initDataContents()
{
    m_editor = 0;
//  TQSize s(tableSize());
//  resizeContents(s.width(),s.height());
 
    m_navPanel->setRecordCount(rows());
 
    if (m_data && !m_cursorPositionSetExplicityBeforeShow) {
        //set current row:
        m_currentItem = 0;
        int curRow = -1, curCol = -1;
        if (m_data->columnsCount()>0) {
            if (rows()>0) {
                m_itemIterator->toFirst();
                m_currentItem = **m_itemIterator;
                curRow = 0;
                curCol = 0;
            }
            else {//no data
                if (isInsertingEnabled()) {
                    m_currentItem = m_insertItem;
                    curRow = 0;
                    curCol = 0;
                }
            }
        }
        setCursorPosition(curRow, curCol, true/*force*/);
    }
    ensureCellVisible(m_curRow, m_curCol);
//  updateRowCountInfo();
//  setNavRowCount(rows());
 
//OK?
// updateContents();
    updateWidgetContents();
 
    m_cursorPositionSetExplicityBeforeShow = false;
 
    /*emit*/ dataRefreshed();
}
 
void KexiDataAwareObjectInterface::setSortingEnabled(bool set)
{
    if (m_isSortingEnabled && !set)
        setSorting(-1);
    m_isSortingEnabled = set;
    /*emit*/ reloadActions();
}
 
void KexiDataAwareObjectInterface::setSorting(int col, bool ascending)
{
    if (!m_data || !m_isSortingEnabled)
        return;
//  d->pTopHeader->setSortIndicator(col, ascending ? Ascending : Descending);
    setLocalSortingOrder(col, ascending ? 1 : -1);
    m_data->setSorting(col, ascending);
}
 
int KexiDataAwareObjectInterface::dataSortedColumn() const
{
    if (m_data && m_isSortingEnabled)
        return m_data->sortedColumn();
    return -1;
}
 
int KexiDataAwareObjectInterface::dataSortingOrder() const
{
    return m_data ? m_data->sortingOrder() : 0;
}
 
bool KexiDataAwareObjectInterface::sort()
{
    if (!m_data || !m_isSortingEnabled)
        return false;
 
    if (rows() < 2)
        return true;
 
    if (!acceptRowEdit())
        return false;
 
    const int oldRow = m_curRow;
    if (m_data->sortedColumn()!=-1)
        m_data->sort();
 
    //locate current record
    if (!m_currentItem) {
        m_itemIterator->toFirst();
        m_currentItem = **m_itemIterator; //m_data->first();
        m_curRow = 0;
        if (!m_currentItem)
            return true;
    }
    if (m_currentItem != m_insertItem) {
        m_curRow = m_data->findRef(m_currentItem);
        int jump = m_curRow - oldRow;
        if (jump<0)
            (*m_itemIterator) -= -jump;
        else
            (*m_itemIterator) += jump;
    }
 
    updateGUIAfterSorting();
    editorShowFocus( m_curRow, m_curCol );
    if (m_verticalHeader)
        m_verticalHeader->setCurrentRow(m_curRow);
    if (m_horizontalHeader)
        m_horizontalHeader->setSelectedSection(m_curCol);
    if (m_navPanel)
        m_navPanel->setCurrentRecordNumber(m_curRow+1);
    return true;
}
 
void KexiDataAwareObjectInterface::sortAscending()
{
    if (currentColumn()<0)
        return;
    sortColumnInternal( currentColumn(), 1 );
}
 
void KexiDataAwareObjectInterface::sortDescending()
{
    if (currentColumn()<0)
        return;
    sortColumnInternal( currentColumn(), -1 );
}
 
void KexiDataAwareObjectInterface::sortColumnInternal(int col, int order)
{
    //-select sorting 
    bool asc;
    if (order == 0) {// invert
        if (col==dataSortedColumn() && dataSortingOrder()==1)
            asc = dataSortingOrder()==-1; //inverse sorting for this column -> descending order
        else
            asc = true;
    }
    else
        asc = (order==1);
    
    int prevSortOrder = currentLocalSortingOrder();
    const int prevSortColumn = currentLocalSortingOrder();
    setSorting( col, asc );
    //-perform sorting 
    if (!sort())
        setLocalSortingOrder(prevSortColumn, prevSortOrder); //this will also remove indicator
                                                             //if prevSortColumn==-1
    if (col != prevSortColumn)
        /*emit*/ sortedColumnChanged(col);
}
 
bool KexiDataAwareObjectInterface::isInsertingEnabled() const
{
    if (isReadOnly())
        return false;
    if (m_insertingEnabled == 1 || m_insertingEnabled == 0)
        return (bool)m_insertingEnabled;
    if (!hasData())
        return true;
    return m_data->isInsertingEnabled();
}
 
void KexiDataAwareObjectInterface::setFilteringEnabled(bool set)
{
    m_isFilteringEnabled = set;
}
 
bool KexiDataAwareObjectInterface::isDeleteEnabled() const
{
    return (m_deletionPolicy != NoDelete) && !isReadOnly();
}
 
void KexiDataAwareObjectInterface::setDeletionPolicy(DeletionPolicy policy)
{
    m_deletionPolicy = policy;
//  updateContextMenu();
}
 
void KexiDataAwareObjectInterface::setReadOnly(bool set)
{
    if (isReadOnly() == set || (m_data && m_data->isReadOnly() && !set))
        return; //not allowed!
    m_readOnly = (set ? 1 : 0);
    if (set)
        setInsertingEnabled(false);
    updateWidgetContents();
    /*emit*/ reloadActions();
}
 
bool KexiDataAwareObjectInterface::isReadOnly() const
{
    if (!hasData())
        return true;
    if (m_readOnly == 1 || m_readOnly == 0)
        return (bool)m_readOnly;
    if (!hasData())
        return true;
    return m_data->isReadOnly();
}
 
void KexiDataAwareObjectInterface::setInsertingEnabled(bool set)
{
    if (isInsertingEnabled() == set || (m_data && !m_data->isInsertingEnabled() && set))
        return; //not allowed!
    m_insertingEnabled = (set ? 1 : 0);
    m_navPanel->setInsertingEnabled(set);
    if (m_verticalHeader)
        m_verticalHeader->showInsertRow(set);
    if (set)
        setReadOnly(false);
//  update();
    updateWidgetContents();
    /*emit*/ reloadActions();
}
 
void KexiDataAwareObjectInterface::setSpreadSheetMode()
{
    m_spreadSheetMode = true;
    setSortingEnabled( false );
    setInsertingEnabled( false );
    setAcceptsRowEditAfterCellAccepting( true );
    setFilteringEnabled( false );
    setEmptyRowInsertingEnabled( true );
    m_navPanelEnabled = false;
}
 
void KexiDataAwareObjectInterface::selectNextRow()
{
    selectRow( TQMIN( rows() - 1 +(isInsertingEnabled()?1:0), m_curRow + 1 ) );
}
 
void KexiDataAwareObjectInterface::selectPrevPage()
{
    selectRow( 
        TQMAX( 0, m_curRow - rowsPerPage() )
    );
}
 
void KexiDataAwareObjectInterface::selectNextPage()
{
    selectRow( 
        TQMIN( 
            rows() - 1 + (isInsertingEnabled()?1:0),
            m_curRow + rowsPerPage()
        )
    );
}
 
void KexiDataAwareObjectInterface::selectFirstRow()
{
    selectRow(0);
}
 
void KexiDataAwareObjectInterface::selectLastRow()
{
//  selectRow(rows() - 1 + (isInsertingEnabled()?1:0));
    selectRow(rows() - 1);
}
 
void KexiDataAwareObjectInterface::selectRow(int row)
{
    m_vScrollBarValueChanged_enabled = false; //disable tooltip
    setCursorPosition(row, -1);
    m_vScrollBarValueChanged_enabled = true;
}
 
void KexiDataAwareObjectInterface::selectPrevRow()
{
    selectRow( TQMAX( 0, m_curRow - 1 ) );
}
 
void KexiDataAwareObjectInterface::clearSelection()
{
//  selectRow( -1 );
    int oldRow = m_curRow;
//  int oldCol = m_curCol;
    m_curRow = -1;
    m_curCol = -1;
    m_currentItem = 0;
    updateRow( oldRow );
    m_navPanel->setCurrentRecordNumber(0);
//  setNavRowNumber(-1);
}
 
void KexiDataAwareObjectInterface::setCursorPosition(int row, int col/*=-1*/, bool forceSet)
{
    int newrow = row;
    int newcol = col;
 
    if(rows() <= 0) {
        if (m_verticalHeader)
            m_verticalHeader->setCurrentRow(-1);
        if (m_horizontalHeader)
            m_horizontalHeader->setSelectedSection(-1);
        if (isInsertingEnabled()) {
            m_currentItem=m_insertItem;
            newrow=0;
            if (col>=0)
                newcol=col;
            else
                newcol=0;
        }
        else {
            m_currentItem=0;
            m_curRow=-1;
            m_curCol=-1;
            return;
        }
    }
 
    if(col>=0)
    {
        newcol = TQMAX(0, col);
        newcol = TQMIN(columns() - 1, newcol);
    }
    else {
        newcol = m_curCol; //no changes
        newcol = TQMAX(0, newcol); //may not be < 0 !
    }
    newrow = TQMAX(0, row);
    newrow = TQMIN(rows() - 1 + (isInsertingEnabled()?1:0), newrow);
 
//  d->pCurrentItem = itemAt(d->curRow);
//  kdDebug(44021) << "setCursorPosition(): d->curRow=" << d->curRow << " oldRow=" << oldRow << " d->curCol=" << d->curCol << " oldCol=" << oldCol << endl;
 
    if ( forceSet || m_curRow != newrow || m_curCol != newcol )
    {
        kexidbg << "setCursorPosition(): " <<TQString("old:%1,%2 new:%3,%4").arg(m_curCol)
            .arg(m_curRow).arg(newcol).arg(newrow) << endl;
        
        // cursor moved: get rid of editor
        if (m_editor) {
            if (!m_contentsMousePressEvent_dblClick) {
                if (!acceptEditor()) {
                    return;
                }
                //update row num. again
                newrow = TQMIN( rows() - 1 + (isInsertingEnabled()?1:0), newrow);
            }
        }
        if (m_errorMessagePopup) {
            m_errorMessagePopup->close();
        }
 
        if (m_curRow != newrow || forceSet)  {//update current row info
            m_navPanel->setCurrentRecordNumber(newrow+1);
//          setNavRowNumber(newrow);
//          d->navBtnPrev->setEnabled(newrow>0);
//          d->navBtnFirst->setEnabled(newrow>0);
//          d->navBtnNext->setEnabled(newrow<(rows()-1+(isInsertingEnabled()?1:0)));
//          d->navBtnLast->setEnabled(newrow!=(rows()-1));
        }
 
        // cursor moved to other row: end of row editing
        bool newRowInserted = false;
        if (m_rowEditing && m_curRow != newrow) {
            newRowInserted = m_newRowEditing;
            if (!acceptRowEdit()) {
                //accepting failed: cancel setting the cursor
                return;
            }
            //update row number, because number of rows changed
            newrow = TQMIN( rows() - 1 + (isInsertingEnabled()?1:0), newrow);
 
            m_navPanel->setCurrentRecordNumber(newrow+1); //refresh
        }
 
        //change position
        int oldRow = m_curRow;
        int oldCol = m_curCol;
        m_curRow = newrow;
        m_curCol = newcol;
 
//      int cw = columnWidth( d->curCol );
//      int rh = rowHeight();
//      ensureVisible( columnPos( d->curCol ) + cw / 2, rowPos( d->curRow ) + rh / 2, cw / 2, rh / 2 );
//      center(columnPos(d->curCol) + cw / 2, rowPos(d->curRow) + rh / 2, cw / 2, rh / 2);
//  kdDebug(44021) << " contentsY() = "<< contentsY() << endl;
 
//js        if (oldRow > d->curRow)
//js            ensureVisible(columnPos(d->curCol), rowPos(d->curRow) + rh, columnWidth(d->curCol), rh);
//js        else// if (oldRow <= d->curRow)
//js        ensureVisible(columnPos(d->curCol), rowPos(d->curRow), columnWidth(d->curCol), rh);
 
 
        //show editor-dependent focus, if we're changing the current column
        if (oldCol>=0 && oldCol<columns() && m_curCol!=oldCol) {
            //find the editor for this column
            KexiDataItemInterface *edit = editor( oldCol );
            if (edit) {
                edit->hideFocus();
            }
        }
 
        // position changed, so subsequent searching should be started from scratch 
        // (e.g. from the current cell or the top-left cell)
        m_positionOfRecentlyFoundValue.exists = false;
 
        //show editor-dependent focus, if needed
        editorShowFocus( m_curRow, m_curCol );
 
        if (m_updateEntireRowWhenMovingToOtherRow)
            updateRow( oldRow );
        else
            updateCell( oldRow, oldCol );
 
//      //quite clever: ensure the cell is visible:
//      ensureCellVisible(m_curRow, m_curCol);
 
//      TQPoint pcenter = TQRect( columnPos(d->curCol), rowPos(d->curRow), columnWidth(d->curCol), rh).center();
//      ensureVisible(pcenter.x(), pcenter.y(), columnWidth(d->curCol)/2, rh/2);
 
//      ensureVisible(columnPos(d->curCol), rowPos(d->curRow) - contentsY(), columnWidth(d->curCol), rh);
        if (m_verticalHeader && (oldRow != m_curRow || forceSet))
            m_verticalHeader->setCurrentRow(m_curRow);
 
        if (m_updateEntireRowWhenMovingToOtherRow)
            updateRow( m_curRow );
        else
            updateCell( m_curRow, m_curCol );
 
        if (m_curCol != oldCol || m_curRow != oldRow || forceSet) {//ensure this is also refreshed
            if (!m_updateEntireRowWhenMovingToOtherRow) //only if entire row has not been updated
                updateCell( oldRow, m_curCol );
        }
        //update row
        if (forceSet || m_curRow != oldRow) {
            if (isInsertingEnabled() && m_curRow == rows()) {
                kdDebug(44021) << "NOW insert item is current" << endl;
                m_currentItem = m_insertItem;
            }
            else {
                kdDebug(44021) << TQString("NOW item at %1 (%2) is current")
                    .arg(m_curRow).arg((ulong)itemAt(m_curRow)) << endl;
    //NOT EFFECTIVE!!!!!!!!!!!
                //set item iterator
                if (!newRowInserted && isInsertingEnabled() && m_currentItem == m_insertItem && m_curRow == (rows()-1)) {
                    //moving from 'insert item' to last item
                    m_itemIterator->toLast();
                }
                else if (!newRowInserted && !forceSet && m_currentItem != m_insertItem && 0==m_curRow)
                    m_itemIterator->toFirst();
                else if (!newRowInserted && !forceSet && m_currentItem != m_insertItem && oldRow>=0 && (oldRow+1)==m_curRow) //just move next
                    ++(*m_itemIterator);
                else if (!newRowInserted && !forceSet && m_currentItem != m_insertItem && oldRow>=0 && (oldRow-1)==m_curRow) //just move back
                    --(*m_itemIterator);
                else { //move at:
                    m_itemIterator->toFirst();
                    (*m_itemIterator)+=m_curRow;
                }
                if (!**m_itemIterator) { //sanity
                    m_itemIterator->toFirst();
                    (*m_itemIterator)+=m_curRow;
                }
                m_currentItem = **m_itemIterator;
                    //itemAt(m_curRow);
            }
        }
 
        //quite clever: ensure the cell is visible:
        ensureCellVisible(m_curRow, m_curCol);
 
        if (m_horizontalHeader && (oldCol != m_curCol || forceSet))
            m_horizontalHeader->setSelectedSection(m_curCol);
 
        /*emit*/ itemSelected(m_currentItem);
        /*emit*/ cellSelected(m_curCol, m_curRow);
        /* only needed for forms */
        selectCellInternal();
    }
    else {
            kexidbg << "setCursorPosition(): NO CHANGE" << endl;
    }
 
    if(m_initDataContentsOnShow) {
        m_cursorPositionSetExplicityBeforeShow = true;
    }
}
 
bool KexiDataAwareObjectInterface::acceptRowEdit()
{
    if (!m_rowEditing || /*sanity*/!m_data->rowEditBuffer())
        return true;
    if (m_inside_acceptEditor) {
        m_internal_acceptsRowEditAfterCellAccepting = true;
        return true;
    }
    m_internal_acceptsRowEditAfterCellAccepting = false;
 
    const int columnEditedBeforeAccepting = m_editor ? currentColumn() : -1;
    if (!acceptEditor())
        return false;
    kdDebug() << "EDIT ROW ACCEPTING..." << endl;
 
    bool success = true;
//  bool allow = true;
//  int faultyColumn = -1; // will be !=-1 if cursor has to be moved to that column
    const bool inserting = m_newRowEditing;
//  TQString msg, desc;
//  bool inserting = d->pInsertItem && d->pInsertItem==d->pCurrentItem;
 
    if (m_data->rowEditBuffer()->isEmpty() && !m_newRowEditing) {
/*      if (d->newRowEditing) {
            cancelRowEdit();
            kdDebug() << "-- NOTHING TO INSERT!!!" << endl;
            return true;
        }
        else {*/
            kdDebug() << "-- NOTHING TO ACCEPT!!!" << endl;
//      }
    }
    else {//not empty edit buffer or new row to insert:
        if (m_newRowEditing) {
//          emit aboutToInsertRow(d->pCurrentItem, m_data->rowEditBuffer(), success, &faultyColumn);
//          if (success) {
            kdDebug() << "-- INSERTING: " << endl;
            m_data->rowEditBuffer()->debug();
            success = m_data->saveNewRow(*m_currentItem);
//              if (!success) {
//              }
//          }
        }
        else {
//          emit aboutToUpdateRow(d->pCurrentItem, m_data->rowEditBuffer(), success, &faultyColumn);
            if (success) {
                //accept changes for this row:
                kdDebug() << "-- UPDATING: " << endl;
                m_data->rowEditBuffer()->debug();
                kdDebug() << "-- BEFORE: " << endl;
                m_currentItem->debug();
                success = m_data->saveRowChanges(*m_currentItem);//, &msg, &desc, &faultyColumn);
                kdDebug() << "-- AFTER: " << endl;
                m_currentItem->debug();
 
//              if (!success) {
//              }
            }
        }
    }
 
    if (success) {
        //editing is finished:
        if (m_newRowEditing) {
            //update current-item-iterator
            m_itemIterator->toLast();
            m_currentItem = **m_itemIterator;
        }
        m_rowEditing = false;
        m_newRowEditing = false;
        //indicate on the vheader that we are not editing
        if (m_verticalHeader)
            m_verticalHeader->setEditRow(-1);
 
        updateAfterAcceptRowEdit();
 
        kdDebug() << "EDIT ROW ACCEPTED:" << endl;
//      /*debug*/itemAt(m_curRow);
 
        if (inserting) {
//          emit rowInserted(d->pCurrentItem);
            //update navigator's data
            m_navPanel->setRecordCount(rows());
        }
        else {
//          emit rowUpdated(d->pCurrentItem);
        }
 
        /*emit*/ rowEditTerminated(m_curRow);
    }
    else {
//      if (!allow) {
//          kdDebug() << "INSERT/EDIT ROW - DISALLOWED by signal!" << endl;
//      }
//      else {
//          kdDebug() << "EDIT ROW - ERROR!" << endl;
//      }
        int faultyColumn = -1;
        if (m_data->result()->column >= 0 && m_data->result()->column < columns())
            faultyColumn = m_data->result()->column;
        else if (columnEditedBeforeAccepting >= 0)
            faultyColumn = columnEditedBeforeAccepting;
        if (faultyColumn >= 0) {
            setCursorPosition(m_curRow, faultyColumn);
        }
 
        const int button = showErrorMessageForResult( m_data->result() );
        if (KMessageBox::No == button) {
            //discard changes
            cancelRowEdit();
        }
        else {
            if (faultyColumn >= 0) {
                //edit this cell
                startEditCurrentCell();
            }
        }
    }
 
    return success;
}
 
bool KexiDataAwareObjectInterface::cancelRowEdit()
{
    if (!hasData())
        return false;
    if (!m_rowEditing)
        return false;
    cancelEditor();
    m_rowEditing = false;
    //indicate on the vheader that we are not editing
    if (m_verticalHeader)
        m_verticalHeader->setEditRow(-1);
    m_alsoUpdateNextRow = m_newRowEditing;
    if (m_newRowEditing) {
        m_newRowEditing = false;
        //remove current edited row (it is @ the end of list)
        m_data->removeLast();
        //current item is now empty, last row
        m_currentItem = m_insertItem;
        //update visibility
        if (m_verticalHeader)
            m_verticalHeader->removeLabel(false); //-1 label
//      updateContents(columnPos(0), rowPos(rows()), 
//          viewport()->width(), d->rowHeight*3 + (m_navPanel ? m_navPanel->height() : 0)*3 );
//      updateContents(); //js: above did not work well so we do that dirty
        updateWidgetContents();
//TODO: still doesn't repaint properly!!
//      TQSize s(tableSize());
//      resizeContents(s.width(), s.height());
        updateWidgetContentsSize();
//      m_verticalHeader->update();
        //--no cancel action is needed for datasource, 
        //  because the row was not yet stored.
    }
 
    m_data->clearRowEditBuffer();
    updateAfterCancelRowEdit();
    
    kexidbg << "EDIT ROW CANCELLED." << endl;
 
    /*emit*/ rowEditTerminated(m_curRow);
    return true;
}
 
void KexiDataAwareObjectInterface::updateAfterCancelRowEdit()
{
    updateRow(m_curRow);
    if (m_alsoUpdateNextRow)
        updateRow(m_curRow+1);
    m_alsoUpdateNextRow = false;
}
 
void KexiDataAwareObjectInterface::updateAfterAcceptRowEdit()
{
    updateRow(m_curRow);
}
 
void KexiDataAwareObjectInterface::removeEditor()
{
    if (!m_editor)
        return;
    m_editor->hideWidget();
    m_editor = 0;
}
 
bool KexiDataAwareObjectInterface::cancelEditor()
{
    if (m_errorMessagePopup) {
        m_errorMessagePopup->close();
    }
    if (!m_editor)
        return false;
    removeEditor();
    return true;
}
 
class KexiDataAwareObjectInterfaceToolTip : public TQToolTip {
    public:
    KexiDataAwareObjectInterfaceToolTip( const TQString & text, const TQPoint & pos, TQWidget * widget )
        : TQToolTip(widget), m_text(text)
    {
        tip( TQRect(pos, TQSize(100, 100)), text );
    }
    virtual void maybeTip(const TQPoint & p) {
        tip( TQRect(p, TQSize(100, 100)), m_text);
    }
    TQString m_text;
};
 
bool KexiDataAwareObjectInterface::acceptEditor()
{
    if (!hasData())
        return true;
    if (!m_editor || m_inside_acceptEditor)
        return true;
 
    m_inside_acceptEditor = true;//avoid recursion
 
    TQVariant newval;
    Validator::Result res = Validator::Ok;
    TQString msg, desc;
    bool setNull = false;
//  bool allow = true;
//  static const TQString msg_NOT_NULL = i18n("\"%1\" column requires a value to be entered.");
 
    //autoincremented field can be omitted (left as null or empty) if we're inserting a new row
    const bool autoIncColumnCanBeOmitted = m_newRowEditing && m_editor->field()->isAutoIncrement();
//  const bool autoIncColumnCanBeOmitted = m_newRowEditing && m_editor->columnInfo()->field->isAutoIncrement();
 
    bool valueChanged = m_editor->valueChanged();
    bool editCurrentCellAgain = false;
 
    if (valueChanged) {
        if (!m_editor->valueIsValid()) {
            //used e.g. for date or time values - the value can be null but not necessary invalid
            res = Validator::Error;
            editCurrentCellAgain = true;
            TQWidget *par = dynamic_cast<TQScrollView*>(this) ? dynamic_cast<TQScrollView*>(this)->viewport() :
                    dynamic_cast<TQWidget*>(this);
            TQWidget *edit = dynamic_cast<TQWidget*>(m_editor);
            if (par && edit) {
                if (!m_errorMessagePopup) {
//                  m_errorMessagePopup->close();
                    m_errorMessagePopup = new KexiArrowTip(
                        i18n("Error: %1").arg(m_editor->columnInfo()->field->typeName())+"?", 
                        dynamic_cast<TQWidget*>(this));
                    m_errorMessagePopup->move( 
                        par->mapToGlobal(edit->pos()) + TQPoint(6, edit->height() + 0) );
                    m_errorMessagePopup->show();
                }
                m_editor->setFocus();
            }
        }
        else if (m_editor->valueIsNull()) {//null value entered
//          if (m_editor->columnInfo()->field->isNotNull() && !autoIncColumnCanBeOmitted) {
            if (m_editor->field()->isNotNull() && !autoIncColumnCanBeOmitted) {
                kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): NULL NOT ALLOWED!" << endl;
                res = Validator::Error;
//              msg = Validator::msgColumnNotEmpty().arg(m_editor->columnInfo()->field->captionOrName())
                msg = Validator::msgColumnNotEmpty().arg(m_editor->field()->captionOrName())
                    + "\n\n" + Kexi::msgYouCanImproveData();
                desc = i18n("The column's constraint is declared as NOT NULL.");
                editCurrentCellAgain = true;
    //          allow = false;
    //          removeEditor();
    //          return true;
            }
            else {
                kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): NULL VALUE WILL BE SET" << endl;
                //ok, just leave newval as NULL
                setNull = true;
            }
        }
        else if (m_editor->valueIsEmpty()) {//empty value entered
//          if (m_editor->columnInfo()->field->hasEmptyProperty()) {
            if (m_editor->field()->hasEmptyProperty()) {
//              if (m_editor->columnInfo()->field->isNotEmpty() && !autoIncColumnCanBeOmitted) {
                if (m_editor->field()->isNotEmpty() && !autoIncColumnCanBeOmitted) {
                    kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): EMPTY NOT ALLOWED!" << endl;
                    res = Validator::Error;
//                  msg = Validator::msgColumnNotEmpty().arg(m_editor->columnInfo()->field->captionOrName())
                    msg = Validator::msgColumnNotEmpty().arg(m_editor->field()->captionOrName())
                        + "\n\n" + Kexi::msgYouCanImproveData();
                    desc = i18n("The column's constraint is declared as NOT EMPTY.");
                    editCurrentCellAgain = true;
    //              allow = false;
    //              removeEditor();
    //              return true;
                }
                else {
                    kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): EMPTY VALUE WILL BE SET" << endl;
                }
            }
            else {
//              if (m_editor->columnInfo()->field->isNotNull() && !autoIncColumnCanBeOmitted) {
                if (m_editor->field()->isNotNull() && !autoIncColumnCanBeOmitted) {
                    kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): NEITHER NULL NOR EMPTY VALUE CAN BE SET!" << endl;
                    res = Validator::Error;
//                  msg = Validator::msgColumnNotEmpty().arg(m_editor->columnInfo()->field->captionOrName())
                    msg = Validator::msgColumnNotEmpty().arg(m_editor->field()->captionOrName())
                        + "\n\n" + Kexi::msgYouCanImproveData();
                    desc = i18n("The column's constraint is declared as NOT EMPTY and NOT NULL.");
                    editCurrentCellAgain = true;
//              allow = false;
    //              removeEditor();
    //              return true;
                }
                else {
                    kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): NULL VALUE WILL BE SET BECAUSE EMPTY IS NOT ALLOWED" << endl;
                    //ok, just leave newval as NULL
                    setNull = true;
                }
            }
        }
    }//changed
 
    const int realFieldNumber = fieldNumberForColumn(m_curCol);
    if (realFieldNumber < 0) {
        kdWarning() << "KexiDataAwareObjectInterface::acceptEditor(): fieldNumberForColumn(m_curCol) < 0" << endl;
        m_inside_acceptEditor = false;
        return false;
    }
 
    KexiTableViewColumn *currentTVColumn = column(m_curCol);
 
    //try to get the value entered:
    if (res == Validator::Ok) {
        if ((!setNull && !valueChanged)
            || (m_editor->field()->type()!=KexiDB::Field::Boolean && setNull && m_currentItem->at( realFieldNumber ).isNull())) {
            kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): VALUE NOT CHANGED." << endl;
            removeEditor();
            if (m_acceptsRowEditAfterCellAccepting || m_internal_acceptsRowEditAfterCellAccepting)
                acceptRowEdit();
            m_inside_acceptEditor = false;
            return true;
        }
        if (!setNull) {//get the new value 
//          bool ok;
            newval = m_editor->value();
/*
            if (!ok) {
                kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): INVALID VALUE - NOT CHANGED." << endl;
                res = KexiValidator::Error;
//js: TODO get detailed info on why m_editor->value() failed
                msg = i18n("Entered value is invalid.")
                    + "\n\n" + KexiValidator::msgYouCanImproveData();
                editCurrentCellAgain = true;
//              removeEditor();
//              return true;
            }*/
        }
 
        //Check other validation rules:
        //1. check using validator
//      KexiValidator *validator = m_data->column(m_curCol)->validator();
        Validator *validator = currentTVColumn->validator();
        if (validator) {
//          res = validator->check(m_data->column(m_curCol)->field()->captionOrName(), 
            res = validator->check(currentTVColumn->field()->captionOrName(), 
                newval, msg, desc);
        }
    }
 
    //show the validation result if not OK:
    if (res == Validator::Error) {
        if (!msg.isEmpty()) {
            if (desc.isEmpty())
                KMessageBox::sorry(dynamic_cast<TQWidget*>(this), msg);
            else
                KMessageBox::detailedSorry(dynamic_cast<TQWidget*>(this), msg, desc);
        }
        editCurrentCellAgain = true;
//      allow = false;
    }
    else if (res == Validator::Warning) {
        //js: todo: message!!!
        KMessageBox::messageBox(dynamic_cast<TQWidget*>(this), KMessageBox::Sorry, msg + "\n" + desc);
        editCurrentCellAgain = true;
    }
 
    if (res == Validator::Ok) {
        //2. check using signal
        //bool allow = true;
//      emit aboutToChangeCell(d->pCurrentItem, newval, allow);
//      if (allow) {
        //send changes to the backend
        TQVariant visibleValue;
        if (!newval.isNull()/* visible value should be null if value is null */ 
            && currentTVColumn->visibleLookupColumnInfo)
        {
            visibleValue = m_editor->visibleValue(); //visible value for lookup field 
        }
        //should be also added to the buffer
        if (m_data->updateRowEditBufferRef(m_currentItem, m_curCol, currentTVColumn, 
            newval, /*allowSignals*/true, currentTVColumn->visibleLookupColumnInfo ? &visibleValue : 0))
        {
            kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): ------ EDIT BUFFER CHANGED TO:" << endl;
            m_data->rowEditBuffer()->debug();
        } else {
            kdDebug() << "KexiDataAwareObjectInterface::acceptEditor(): ------ CHANGE FAILED in KexiDataAwareObjectInterface::updateRowEditBuffer()" << endl;
            res = Validator::Error;
 
            //now: there might be called cancelEditor() in updateRowEditBuffer() handler,
            //if this is true, d->pEditor is NULL.
 
            if (m_editor && m_data->result()->column>=0 && m_data->result()->column<columns()) {
                //move to faulty column (if m_editor is not cleared)
                setCursorPosition(m_curRow, m_data->result()->column);
            }
            if (!m_data->result()->msg.isEmpty()) {
                const int button = showErrorMessageForResult( m_data->result() );
                if (KMessageBox::No == button) {
                    //discard changes
                    cancelEditor();
                    if (m_acceptsRowEditAfterCellAccepting)
                        cancelRowEdit();
                    m_inside_acceptEditor = false;
                    return false;
                }
            }
        }
    }
 
    if (res == Validator::Ok) {
        removeEditor();
        /*emit*/ itemChanged(m_currentItem, m_curRow, m_curCol, 
            m_currentItem->at( realFieldNumber ));
        /*emit*/ itemChanged(m_currentItem, m_curRow, m_curCol);
    }
    m_inside_acceptEditor = false;
    if (res == Validator::Ok) {
        if (m_acceptsRowEditAfterCellAccepting || m_internal_acceptsRowEditAfterCellAccepting)
            acceptRowEdit();
        return true;
    }
    if (m_editor) {
        //allow to edit the cell again, (if m_pEditor is not cleared)
 
        if (m_editor->hasFocusableWidget()) {
            m_editor->showWidget();
            m_editor->setFocus();
        }
//      startEditCurrentCell(newval.type()==TQVariant::String ? newval.toString() : TQString());
//      m_editor->setFocus();
    }
    return false;
}
 
void KexiDataAwareObjectInterface::startEditCurrentCell(const TQString &setText)
{
    kdDebug() << "** KexiDataAwareObjectInterface::startEditCurrentCell("<<setText<<")"<<endl;
//  if (columnType(d->curCol) == KexiDB::Field::Boolean)
//      return;
    if (isReadOnly() || !columnEditable(m_curCol))
        return;
    if (m_editor) {
        if (m_editor->hasFocusableWidget()) {
            m_editor->showWidget();
            m_editor->setFocus();
        }
    }
//  ensureVisible(columnPos(m_curCol), rowPos(m_curRow)+rowHeight(), 
//      columnWidth(m_curCol), rowHeight());
//OK?   
    //ensureCellVisible(m_curRow+1, m_curCol);
    if (!m_editor)
        createEditor(m_curRow, m_curCol, setText, !setText.isEmpty());
}
 
void KexiDataAwareObjectInterface::deleteAndStartEditCurrentCell()
{
    if (isReadOnly() || !columnEditable(m_curCol))
        return;
    if (m_editor) {//if we've editor - just clear it
        m_editor->clear();
        return;
    }
//js    if (columnType(m_curCol) == KexiDB::Field::Boolean)
//js        return;
//  ensureVisible(columnPos(m_curCol), rowPos(m_curRow) + rowHeight(), 
//      columnWidth(m_curCol), rowHeight());
//OK?
    ensureCellVisible(m_curRow+1, m_curCol);
    createEditor(m_curRow, m_curCol, TQString(), false/*removeOld*/);
    if (!m_editor)
        return;
    m_editor->clear();
    if (m_editor->acceptEditorAfterDeleteContents())
        acceptEditor();
    if (!m_editor || !m_editor->hasFocusableWidget())
        updateCell(m_curRow, m_curCol);
}
 
void KexiDataAwareObjectInterface::deleteCurrentRow()
{
    if (m_newRowEditing) {//we're editing fresh new row: just cancel this!
        cancelRowEdit();
        return;
    }
 
    if (!acceptRowEdit())
        return;
 
    if (!isDeleteEnabled() || !m_currentItem || m_currentItem == m_insertItem)
        return;
    switch (m_deletionPolicy) {
    case NoDelete:
        return;
    case ImmediateDelete:
        break;
    case AskDelete:
        if (KMessageBox::Cancel == KMessageBox::warningContinueCancel(dynamic_cast<TQWidget*>(this), 
            i18n("Do you want to delete selected row?"), 0, 
            KGuiItem(i18n("&Delete Row"),"edit-delete"),
            "dontAskBeforeDeleteRow"/*config entry*/,
            KMessageBox::Notify|KMessageBox::Dangerous))
            return;
        break;
    case SignalDelete:
        /*emit*/ itemDeleteRequest(m_currentItem, m_curRow, m_curCol);
        /*emit*/ currentItemDeleteRequest();
        return;
    default:
        return;
    }
 
    if (!deleteItem(m_currentItem)) {//nothing
    }
}
 
KexiTableItem *KexiDataAwareObjectInterface::insertEmptyRow(int row)
{
    if ( !acceptRowEdit() || !isEmptyRowInsertingEnabled() 
        || (row!=-1 && row >= ((int)rows()+(isInsertingEnabled()?1:0) ) ) )
        return 0;
 
    KexiTableItem *newItem = m_data->createItem(); //new KexiTableItem(m_data->columns.count());
    insertItem(newItem, row);
    return newItem;
}
 
void KexiDataAwareObjectInterface::insertItem(KexiTableItem *newItem, int row)
{
    const bool changeCurrentRow = row==-1 || row==m_curRow;
    if (changeCurrentRow) {
        //change current row
        row = (m_curRow >= 0 ? m_curRow : 0);
        m_currentItem = newItem;
        m_curRow = row;
    }
    else if (m_curRow >= row) {
        m_curRow++;
    }
 
    m_data->insertRow(*newItem, row, true /*repaint*/);
 
    if (changeCurrentRow) {
        //update iter...
        m_itemIterator->toFirst();
        (*m_itemIterator)+=m_curRow;
    }
/*
    TQSize s(tableSize());
    resizeContents(s.width(),s.height());
 
    //redraw only this row and below:
    int leftcol = d->pTopHeader->sectionAt( d->pTopHeader->offset() );
//  updateContents( columnPos( leftcol ), rowPos(d->curRow), 
//      clipper()->width(), clipper()->height() - (rowPos(d->curRow) - contentsY()) );
    updateContents( columnPos( leftcol ), rowPos(row), 
        clipper()->width(), clipper()->height() - (rowPos(row) - contentsY()) );
 
    m_verticalHeader->addLabel();
 
    //update navigator's data
    setNavRowCount(rows());
 
    if (d->curRow >= row) {
        //update
        editorShowFocus( d->curRow, d->curCol );
    }
    */
}
 
void KexiDataAwareObjectInterface::slotRowInserted(KexiTableItem *item, bool repaint)
{
    int row = m_data->findRef(item);
    slotRowInserted( item, row, repaint );
}
 
void KexiDataAwareObjectInterface::slotRowInserted(KexiTableItem * /*item*/, uint row, bool repaint)
{
    if (repaint && (int)row<rows()) {
        updateWidgetContentsSize();
 
/* updateAllVisibleRowsBelow() used instead
        //redraw only this row and below:
        int leftcol = d->pTopHeader->sectionAt( d->pTopHeader->offset() );
        updateContents( columnPos( leftcol ), rowPos(row), 
            clipper()->width(), clipper()->height() - (rowPos(row) - contentsY()) );
*/
        updateAllVisibleRowsBelow(row);
 
        if (!m_verticalHeaderAlreadyAdded) {
            if (m_verticalHeader)
                m_verticalHeader->addLabel();
        }
        else //it was added because this inserting was interactive
            m_verticalHeaderAlreadyAdded = false;
 
        //update navigator's data
        m_navPanel->setRecordCount(rows());
 
        if (m_curRow >= (int)row) {
            //update
            editorShowFocus( m_curRow, m_curCol );
        }
    }
}
 
tristate KexiDataAwareObjectInterface::deleteAllRows(bool ask, bool repaint)
{
    if (!hasData())
        return true;
    if (m_data->count()<1)
        return true;
 
    if (ask) {
        TQString tableName = m_data->dbTableName();
        if (!tableName.isEmpty()) {
            tableName.prepend(" \"");
            tableName.append("\"");
        }
        if (KMessageBox::Cancel == KMessageBox::warningContinueCancel(dynamic_cast<TQWidget*>(this),
                i18n("Do you want to clear the contents of table %1?").arg(tableName),
                0, KGuiItem(i18n("&Clear Contents")) ))
            return cancelled;
    }
 
    cancelRowEdit();
//  acceptRowEdit();
//  m_verticalHeader->clear();
    const bool repaintLater = repaint && m_spreadSheetMode;
    const int oldRows = rows();
 
    bool res = m_data->deleteAllRows(repaint && !repaintLater);
 
    if (res) {
        if (m_spreadSheetMode) {
//          const uint columns = m_data->columns.count();
            for (int i=0; i<oldRows; i++) {
                m_data->append(m_data->createItem());//new KexiTableItem(columns));
            }
        }
    }
    if (repaintLater)
        m_data->reload();
 
//  d->clearVariables();
//  m_verticalHeader->setCurrentRow(-1);
 
//  d->pUpdateTimer->start(1,true);
//  if (repaint)
//      viewport()->repaint();
    return res;
}
 
void KexiDataAwareObjectInterface::clearColumns(bool repaint)
{
    cancelRowEdit();
    m_data->clearInternal();
 
    clearColumnsInternal(repaint);
    updateIndicesForVisibleValues();
 
    if (repaint)
//      viewport()->repaint();
//OK?
        updateWidgetContents();
 
/*  for(int i=0; i < rows(); i++)
    {
        m_verticalHeader->removeLabel();
    }
 
    editorCancel();
    m_contents->clear();
 
    d->clearVariables();
    d->numCols = 0;
 
    while(d->pTopHeader->count()>0)
        d->pTopHeader->removeLabel(0);
 
    m_verticalHeader->setCurrentRow(-1);
 
    viewport()->repaint();
 
//  d->pColumnTypes.resize(0);
//  d->pColumnModes.resize(0);
//  d->pColumnDefaults.clear();*/
}
 
void KexiDataAwareObjectInterface::reloadData()
{
//  cancelRowEdit();
    acceptRowEdit();
    if (m_verticalHeader)
        m_verticalHeader->clear();
 
    if (m_curCol>=0 && m_curCol<columns()) {
        //find the editor for this column
        KexiDataItemInterface *edit = editor( m_curCol );
        if (edit) {
            edit->hideFocus();
        }
    }
//  setCursorPosition(-1, -1, true);
    clearVariables();
    if (m_verticalHeader)
        m_verticalHeader->setCurrentRow(-1);
    
    if (dynamic_cast<TQWidget*>(this) && dynamic_cast<TQWidget*>(this)->isVisible())
        initDataContents();
    else
        m_initDataContentsOnShow = true;
 
    if (m_verticalHeader)
        m_verticalHeader->addLabels(m_data->count());
 
    updateWidgetScrollBars();
}
 
int KexiDataAwareObjectInterface::columnType(int col)
{
    KexiTableViewColumn* c = m_data ? column(col) : 0;
    return c ? c->field()->type() : KexiDB::Field::InvalidType;
}
 
bool KexiDataAwareObjectInterface::columnEditable(int col)
{
    KexiTableViewColumn* c = m_data ? column(col) : 0;
    return c ? (! c->isReadOnly()) : false;
}
 
int KexiDataAwareObjectInterface::rows() const
{
    if (!hasData())
        return 0;
    return m_data->count();
}
 
int KexiDataAwareObjectInterface::dataColumns() const
{
    if (!hasData())
        return 0;
    return m_data->columns.count();
}
 
TQVariant KexiDataAwareObjectInterface::columnDefaultValue(int /*col*/) const
{
    return TQVariant(0);
//TODO(js)  
//  return m_data->columns[col].defaultValue;
}
 
void KexiDataAwareObjectInterface::setAcceptsRowEditAfterCellAccepting(bool set)
{
    m_acceptsRowEditAfterCellAccepting = set;
}
 
void KexiDataAwareObjectInterface::setDropsAtRowEnabled(bool set)
{
//  const bool old = d->dropsAtRowEnabled;
    if (!set)
        m_dragIndicatorLine = -1;
    if (m_dropsAtRowEnabled && !set) {
        m_dropsAtRowEnabled = false;
//      update();
        updateWidgetContents();
    }
    else {
        m_dropsAtRowEnabled = set;
    }
}
 
void KexiDataAwareObjectInterface::setEmptyRowInsertingEnabled(bool set)
{
    m_emptyRowInsertingEnabled = set;
    /*emit*/ reloadActions();
}
 
void KexiDataAwareObjectInterface::slotAboutToDeleteRow(KexiTableItem& item, 
    KexiDB::ResultInfo* /*result*/, bool repaint)
{
    if (repaint) {
        m_rowWillBeDeleted = m_data->findRef(&item);
    }
}
 
void KexiDataAwareObjectInterface::slotRowDeleted()
{
    if (m_rowWillBeDeleted >= 0) {
        if (m_rowWillBeDeleted > 0 && m_rowWillBeDeleted >= (rows()-1) && !m_spreadSheetMode)
            m_rowWillBeDeleted = rows()-1; //move up if it's the last row
        updateWidgetContentsSize();
 
        if (! (m_spreadSheetMode && m_rowWillBeDeleted>=(rows()-1)))
            setCursorPosition(m_rowWillBeDeleted, m_curCol, true/*forceSet*/);
        if (m_verticalHeader)
            m_verticalHeader->removeLabel();
 
        updateAllVisibleRowsBelow(m_curRow); //needed for KexiTableView
 
        //update navigator's data
        m_navPanel->setRecordCount(rows());
 
        m_rowWillBeDeleted = -1;
    }
}
 
bool KexiDataAwareObjectInterface::beforeDeleteItem(KexiTableItem *)
{
    //always return
    return true;
}
 
bool KexiDataAwareObjectInterface::deleteItem(KexiTableItem *item)/*, bool moveCursor)*/
{
    if (!item || !beforeDeleteItem(item))
        return false;
 
    TQString msg, desc;
//  bool current = (item == d->pCurrentItem);
    const bool lastRowDeleted = m_spreadSheetMode && m_data->last() == item; //we need to know this so we
                                                                             //can return to the last row 
                                                                             //after reinserting it
    if (!m_data->deleteRow(*item, true /*repaint*/)) {
        /*const int button =*/ 
        showErrorMessageForResult( m_data->result() );
//      if (KMessageBox::No == button) {
            //discard changes
    //  }
        return false;
    }
    else {
//setCursorPosition() wil lset this!        if (current)
            //d->pCurrentItem = m_data->current();
    }
 
//  repaintAfterDelete();
    if (m_spreadSheetMode) { //append empty row for spreadsheet mode
        m_data->append(m_data->createItem());//new KexiTableItem(m_data->columns.count()));
        if (m_verticalHeader)
            m_verticalHeader->addLabels(1);
        if (lastRowDeleted) //back to the last row
            setCursorPosition(rows()-1, m_curCol, true/*forceSet*/);
        /*emit*/ newItemAppendedForAfterDeletingInSpreadSheetMode();
    }
    return true;
}
 
KexiTableViewColumn* KexiDataAwareObjectInterface::column(int col)
{
    return m_data->column(col);
}
 
bool KexiDataAwareObjectInterface::hasDefaultValueAt(const KexiTableViewColumn& tvcol)
{
    if (m_rowEditing && m_data->rowEditBuffer() && m_data->rowEditBuffer()->isDBAware()) {
        return m_data->rowEditBuffer()->hasDefaultValueAt( *tvcol.columnInfo );
    }
    return false;
}
 
const TQVariant* KexiDataAwareObjectInterface::bufferedValueAt(int col, bool useDefaultValueIfPossible)
{
    if (m_rowEditing && m_data->rowEditBuffer())
    {
        KexiTableViewColumn* tvcol = column(col);
        if (tvcol->isDBAware) {
            //get the stored value
            const int realFieldNumber = fieldNumberForColumn(col);
            if (realFieldNumber < 0) {
                kdWarning() << "KexiDataAwareObjectInterface::bufferedValueAt(): "
                    "fieldNumberForColumn(m_curCol) < 0" << endl;
                return 0;
            }
            TQVariant *storedValue = &m_currentItem->at( realFieldNumber );
        
            //db-aware data: now, try to find a buffered value (or default one)
            const TQVariant *cv = m_data->rowEditBuffer()->at( *tvcol->columnInfo, 
                storedValue->isNull() && useDefaultValueIfPossible);
            if (cv)
                return cv;
            return storedValue;
        }
        //not db-aware data:
        const TQVariant *cv = m_data->rowEditBuffer()->at( tvcol->field()->name() );
        if (cv)
            return cv;
    }
    //not db-aware data:
    const int realFieldNumber = fieldNumberForColumn(col);
    if (realFieldNumber < 0) {
        kdWarning() << "KexiDataAwareObjectInterface::bufferedValueAt(): "
            "fieldNumberForColumn(m_curCol) < 0" << endl;
        return 0;
    }
    return &m_currentItem->at( realFieldNumber );
}
 
void KexiDataAwareObjectInterface::startEditOrToggleValue()
{
    if ( !isReadOnly() && columnEditable(m_curCol) ) {
        if (columnType(m_curCol) == KexiDB::Field::Boolean) {
            boolToggled();
        }
        else {
            startEditCurrentCell();
            return;
        }
    }
}
 
void KexiDataAwareObjectInterface::boolToggled()
{
    startEditCurrentCell();
    if (m_editor) {
        m_editor->clickedOnContents();
    }
    acceptEditor();
    updateCell(m_curRow, m_curCol);
 
/*  int s = m_currentItem->at(m_curCol).toInt();
    TQVariant oldValue=m_currentItem->at(m_curCol);
    (*m_currentItem)[m_curCol] = TQVariant(s ? 0 : 1);
    updateCell(m_curRow, m_curCol);
//  emit itemChanged(m_currentItem, m_curRow, m_curCol, oldValue);
//  emit itemChanged(m_currentItem, m_curRow, m_curCol);*/
}
 
void KexiDataAwareObjectInterface::slotDataDestroying()
{
    m_data = 0;
    m_itemIterator = 0;
}
 
void KexiDataAwareObjectInterface::addNewRecordRequested()
{
    if (!isInsertingEnabled())
        return;
    if (m_rowEditing) {
        if (!acceptRowEdit())
            return;
    }
//  setFocus();
    selectRow(rows());
    startEditCurrentCell();
    if (m_editor)
        m_editor->setFocus();
}
 
bool KexiDataAwareObjectInterface::handleKeyPress(TQKeyEvent *e, int &curRow, int &curCol, 
    bool fullRowSelection, bool *moveToFirstField, bool *moveToLastField)
{
    if (moveToFirstField)
        *moveToFirstField = false;
    if (moveToLastField)
        *moveToLastField = false;
 
    const bool nobtn = e->state()==TQt::NoButton;
    const int k = e->key();
    //kdDebug() << "-----------" << e->state() << " " << k << endl;
 
    if ((k == TQt::Key_Up && nobtn) || (k == TQt::Key_PageUp && e->state()==TQt::ControlButton)) {
        selectPrevRow();
        e->accept();
    }
    else if ((k == TQt::Key_Down && nobtn) || (k == TQt::Key_PageDown && e->state()==TQt::ControlButton)) {
        selectNextRow();
        e->accept();
    }
    else if (k == TQt::Key_PageUp && nobtn) {
        selectPrevPage();
        e->accept();
    }
    else if (k == TQt::Key_PageDown && nobtn) {
        selectNextPage();
        e->accept();
    }
    else if (k == TQt::Key_Home) {
        if (fullRowSelection) {
            //we're in row-selection mode: home key always moves to 1st row
            curRow = 0;//to 1st row
        }
        else {//cell selection mode: different actions depending on ctrl and shift keys state
            if (nobtn) {
                curCol = 0;//to 1st col
            }
            else if (e->state()==TQt::ControlButton) {
                curRow = 0;//to 1st row and col
                curCol = 0;
            }
            else
                return false;
        }
        if (moveToFirstField)
            *moveToFirstField = true;
        //do not accept yet
        e->ignore();
    }
    else if (k == TQt::Key_End) {
        if (fullRowSelection) {
            //we're in row-selection mode: home key always moves to last row
            curRow = m_data->count()-1+(isInsertingEnabled()?1:0);//to last row
        }
        else {//cell selection mode: different actions depending on ctrl and shift keys state
            if (nobtn) {
                curCol = columns()-1;//to last col
            }
            else if (e->state()==TQt::ControlButton) {
                curRow = m_data->count()-1 /*+(isInsertingEnabled()?1:0)*/; //to last row and col
                curCol = columns()-1;//to last col
            }
            else
                return false;
        }
        if (moveToLastField)
            *moveToLastField = true;
        //do not accept yet
        e->ignore();
    }
    else if (isInsertingEnabled() && (e->state()==TQt::ControlButton && k == TQt::Key_Equal
        || e->state()==(TQt::ControlButton|TQt::ShiftButton) && k == TQt::Key_Equal)) {
        curRow = m_data->count(); //to the new row
        curCol = 0;//to first col
        if (moveToFirstField)
            *moveToFirstField = true;
        //do not accept yet
        e->ignore();
    }
    else
        return false;
 
    return true;
}
 
void KexiDataAwareObjectInterface::vScrollBarValueChanged(int v)
{
    Q_UNUSED(v);
    if (!m_vScrollBarValueChanged_enabled)
        return;
 
    if (m_scrollbarToolTipsEnabled) {
        const TQRect r( verticalScrollBar()->sliderRect() );
        const int row = lastVisibleRow()+1;
        if (row<=0) {
            m_scrollBarTipTimer.stop();
            m_scrollBarTip->hide();
            return;
        }
        m_scrollBarTip->setText( i18n("Row: ") + TQString::number(row) );
        m_scrollBarTip->adjustSize();
        TQWidget* thisWidget = dynamic_cast<TQWidget*>(this);
        m_scrollBarTip->move( 
            thisWidget->mapToGlobal( r.topLeft() + verticalScrollBar()->pos() ) 
                + TQPoint( - m_scrollBarTip->width()-5, 
            r.height()/2 - m_scrollBarTip->height()/2) );
        if (verticalScrollBar()->draggingSlider()) {
            kdDebug(44021) << "  draggingSlider()  " << endl;
            m_scrollBarTipTimer.stop();
            m_scrollBarTip->show();
            m_scrollBarTip->raise();
        }
        else {
            m_scrollBarTipTimerCnt++;
            if (m_scrollBarTipTimerCnt>4) {
                m_scrollBarTipTimerCnt=0;
                m_scrollBarTip->show();
                m_scrollBarTip->raise();
                m_scrollBarTipTimer.start(500, true);
            }
        }
    }
    //update bottom view region
/*  if (m_navPanel && (contentsHeight() - contentsY() - clipper()->height()) <= TQMAX(d->rowHeight,m_navPanel->height())) {
        slotUpdate();
        triggerUpdate();
    }*/
}
 
bool KexiDataAwareObjectInterface::scrollbarToolTipsEnabled() const
{
    return m_scrollbarToolTipsEnabled;
}
 
void KexiDataAwareObjectInterface::setScrollbarToolTipsEnabled(bool set)
{
    m_scrollbarToolTipsEnabled = set;
}
 
void KexiDataAwareObjectInterface::vScrollBarSliderReleased()
{
    kdDebug(44021) << "vScrollBarSliderReleased()" << endl;
    m_scrollBarTip->hide();
}
 
void KexiDataAwareObjectInterface::scrollBarTipTimeout()
{
    if (m_scrollBarTip->isVisible()) {
//      kdDebug(44021) << "TIMEOUT! - hide" << endl;
        if (m_scrollBarTipTimerCnt>0) {
            m_scrollBarTipTimerCnt=0;
            m_scrollBarTipTimer.start(500, true);
            return;
        }
        m_scrollBarTip->hide();
    }
    m_scrollBarTipTimerCnt=0;
}
 
void KexiDataAwareObjectInterface::focusOutEvent(TQFocusEvent* e)
{
    Q_UNUSED(e);
    m_scrollBarTipTimer.stop();
    m_scrollBarTip->hide();
    
    updateCell(m_curRow, m_curCol);
}
 
int KexiDataAwareObjectInterface::showErrorMessageForResult(KexiDB::ResultInfo* resultInfo)
{
    TQWidget *thisWidget = dynamic_cast<TQWidget*>(this);
    if (resultInfo->allowToDiscardChanges) {
        return KMessageBox::questionYesNo(thisWidget, resultInfo->msg 
            + (resultInfo->desc.isEmpty() ? TQString() : ("\n"+resultInfo->desc)),
            TQString(), 
            KGuiItem(i18n("Correct Changes", "Correct"), TQString(), i18n("Correct changes")),
            KGuiItem(i18n("Discard Changes")) );
    }
 
    if (resultInfo->desc.isEmpty())
        KMessageBox::sorry(thisWidget, resultInfo->msg);
    else
        KMessageBox::detailedSorry(thisWidget, resultInfo->msg, resultInfo->desc);
    
    return KMessageBox::Ok;
}
 
void KexiDataAwareObjectInterface::updateIndicesForVisibleValues()
{
    m_indicesForVisibleValues.resize( m_data ? m_data->columnsCount() : 0 );
    if (!m_data)
        return;
    for (uint i=0; i < m_data->columnsCount(); i++) {
        KexiTableViewColumn* tvCol = m_data->column(i);
        if (tvCol->columnInfo && tvCol->columnInfo->indexForVisibleLookupValue()!=-1)
            // retrieve visible value from lookup field
            m_indicesForVisibleValues[ i ] = tvCol->columnInfo->indexForVisibleLookupValue();
        else
            m_indicesForVisibleValues[ i ] = i;
    }
}
 
static inline bool findInString(const TQString& stringValue, int stringLength, const TQString& where, 
    int& firstCharacter, bool matchAnyPartOfField, bool matchWholeField, 
    bool caseSensitive, bool wholeWordsOnly, bool forward)
{
    if (where.isEmpty()) {
        firstCharacter = -1;
        return false;
    }
 
    if (matchAnyPartOfField) {
        if (forward) {
            int pos = firstCharacter == -1 ? 0 : firstCharacter;
            if (wholeWordsOnly) {
                const int whereLength = where.length();
                while (true) {
                    pos = where.find( stringValue, pos, caseSensitive );
                    if (pos == -1)
                        break;
                    if ((pos > 0 && where.at(pos-1).isLetterOrNumber())
                        ||((pos+stringLength-1) < (whereLength-1) && where.at(pos+stringLength-1+1).isLetterOrNumber()))
                    {
                        pos++; // invalid match because before or after the string there is non-white space
                    }
                    else
                        break;
                }//while
                firstCharacter = pos;
            }
            else {// !wholeWordsOnly
                firstCharacter = where.find( stringValue, pos, caseSensitive );
            }
            return firstCharacter != -1;
        }
        else { // !matchAnyPartOfField
            if (firstCharacter == INT_MAX) {
                firstCharacter = -1; //next time we'll be looking at different cell
                return false;
            }
            int pos = firstCharacter;
            if (wholeWordsOnly) {
                const int whereLength = where.length();
                while (true) {
                    pos = where.findRev( stringValue, pos, caseSensitive );
                    if (pos == -1)
                        break;
                    if ((pos > 0 && where.at(pos-1).isLetterOrNumber())
                        ||((pos+stringLength-1) < (whereLength-1) && where.at(pos+stringLength-1+1).isLetterOrNumber()))
                    {
                        // invalid match because before or after the string there is non-white space
                        pos--;
                        if (pos < 0) // it can make pos < 0
                            break;
                    }
                    else
                        break;
                }//while
                firstCharacter = pos;
            }
            else {// !wholeWordsOnly
                firstCharacter = where.findRev( stringValue, pos, caseSensitive );
            }
            return firstCharacter != -1;
        }
    }
    else if (matchWholeField) {
        if (firstCharacter != -1 && firstCharacter != 0) { //we're not at 0-th char
            firstCharacter = -1;
        }
        else if ( (caseSensitive ? where : where.lower()) == stringValue) {
            firstCharacter = 0;
            return true;
        }
    }
    else {// matchStartOfField
        if (firstCharacter != -1 && firstCharacter != 0) { //we're not at 0-th char
            firstCharacter = -1;
        }
        else if (where.startsWith(stringValue, caseSensitive)) {
            if (wholeWordsOnly) {
                // If where.length() < stringValue.length(), true will be returned too - fine.
                return !where.at( stringValue.length() ).isLetterOrNumber();
            }
            firstCharacter = 0;
            return true;
        }
    }
    return false;
}
 
tristate KexiDataAwareObjectInterface::find(const TQVariant& valueToFind, 
    const KexiSearchAndReplaceViewInterface::Options& options, bool next)
{
    if (!hasData())
        return cancelled;
    const TQVariant prevSearchedValue( m_recentlySearchedValue );
    m_recentlySearchedValue = valueToFind;
    const KexiSearchAndReplaceViewInterface::Options::SearchDirection prevSearchDirection = m_recentSearchDirection;
    m_recentSearchDirection = options.searchDirection;
    if (valueToFind.isNull() || valueToFind.toString().isEmpty())
        return cancelled;
 
    const bool forward = (options.searchDirection == KexiSearchAndReplaceViewInterface::Options::SearchUp) 
        ? !next : next; //direction can be reversed
 
    if ((!prevSearchedValue.isNull() && prevSearchedValue!=valueToFind)
        || (prevSearchDirection!=options.searchDirection && options.searchDirection==KexiSearchAndReplaceViewInterface::Options::SearchAllRows))
    {
        // restart searching when value has been changed or new direction is SearchAllRows
        m_positionOfRecentlyFoundValue.exists = false;
    }
 
    const bool startFrom1stRowAndCol = !m_positionOfRecentlyFoundValue.exists && next
        && options.searchDirection == KexiSearchAndReplaceViewInterface::Options::SearchAllRows;
    const bool startFromLastRowAndCol = 
          (!m_positionOfRecentlyFoundValue.exists && !next && options.searchDirection == KexiSearchAndReplaceViewInterface::Options::SearchAllRows)
        ||(m_curRow >= rows() && !forward); //we're at "insert" row, and searching backwards: move to the last cell
 
    if (!startFrom1stRowAndCol && !startFromLastRowAndCol && m_curRow >= rows()) {
        //we're at "insert" row, and searching forward: no chances to find something
        return false;
    }
    KexiTableViewData::Iterator it( (startFrom1stRowAndCol || startFromLastRowAndCol)
        ? m_data->iterator() : *m_itemIterator /*start from the current cell*/ );
    if (startFromLastRowAndCol)
        it.toLast();
    int firstCharacter;
    if (m_positionOfRecentlyFoundValue.exists) {// start after the next/prev char position
        if (forward)
            firstCharacter = m_positionOfRecentlyFoundValue.lastCharacter + 1;
        else {
            firstCharacter = (m_positionOfRecentlyFoundValue.firstCharacter > 0) ? 
                (m_positionOfRecentlyFoundValue.firstCharacter - 1) : INT_MAX /* this means 'before first'*/;
        }
    }
    else {
        firstCharacter = -1; //forward ? -1 : INT_MAX;
    }
 
    const int columnsCount = m_data->columnsCount();
    int row, col;
    if (startFrom1stRowAndCol) {
        row = 0;
        col = 0;
    }
    else if (startFromLastRowAndCol) {
        row = rows()-1;
        col = columnsCount-1;
    }
    else {
        row = m_curRow;
        col = m_curCol;
    }
 
    //sache some flags for efficiency
    const bool matchAnyPartOfField 
        = options.textMatching == KexiSearchAndReplaceViewInterface::Options::MatchAnyPartOfField;
    const bool matchWholeField 
        = options.textMatching == KexiSearchAndReplaceViewInterface::Options::MatchWholeField;
    const bool caseSensitive = options.caseSensitive;
    const bool wholeWordsOnly = options.wholeWordsOnly;
//unused    const bool promptOnReplace = options.promptOnReplace;
    int columnNumber = (options.columnNumber == KexiSearchAndReplaceViewInterface::Options::CurrentColumn) 
        ? m_curCol : options.columnNumber;
    if (columnNumber>=0)
        col = columnNumber;
    const bool lookInAllColumns = columnNumber == KexiSearchAndReplaceViewInterface::Options::AllColumns;
    int firstColumn; // real number of the first column, can be smaller than lastColumn if forward==true
    int lastColumn; // real number of the last column
    if (lookInAllColumns) {
        firstColumn = forward ? 0 : columnsCount-1;
        lastColumn = forward ? columnsCount-1 : 0;
    }
    else {
        firstColumn = columnNumber;
        lastColumn = columnNumber;
    }
    const TQString stringValue( caseSensitive ? valueToFind.toString() : valueToFind.toString().lower() );
    const int stringLength = stringValue.length();
 
    // search
    const int prevRow = m_curRow;
    KexiTableItem *item;
    while ( (item = it.current()) ) {
        for (; forward ? col <= lastColumn : col >= lastColumn; 
            col = forward ? (col+1) : (col-1))
        {
            const TQVariant cell( item->at( m_indicesForVisibleValues[ col ] ) );
            if (findInString(stringValue, stringLength, cell.toString(), firstCharacter, 
                matchAnyPartOfField, matchWholeField, caseSensitive, wholeWordsOnly, forward))
            {
                //*m_itemIterator = it;
                //m_currentItem = *it;
                //m_curRow = row;
                //m_curCol = col;
                setCursorPosition(row, col, true/*forceSet*/);
                if (prevRow != m_curRow)
                    updateRow(prevRow);
                // remember the exact position for the found value
                m_positionOfRecentlyFoundValue.exists = true;
                m_positionOfRecentlyFoundValue.firstCharacter = firstCharacter;
                m_positionOfRecentlyFoundValue.lastCharacter = firstCharacter + stringLength - 1;
                return true;
            }
        }//for
        if (forward) {
            ++it;
            ++row;
        }
        else {
            --it;
            --row;
        }
        col = firstColumn;
    }//while
    return false;
}
 
tristate KexiDataAwareObjectInterface::findNextAndReplace(
    const TQVariant& valueToFind, const TQVariant& replacement, 
    const KexiSearchAndReplaceViewInterface::Options& options, bool replaceAll)
{
    Q_UNUSED(replacement);
    Q_UNUSED(options);
    Q_UNUSED(replaceAll);
    
    if (isReadOnly())
        return cancelled;
    if (valueToFind.isNull() || valueToFind.toString().isEmpty())
        return cancelled;
    return false;
}