Kexi API Documentation (2.0 alpha)
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files

kexitableview.cpp

Go to the documentation of this file.

/* This file is part of the KDE project
   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>
   Copyright (C) 2003-2006 Jaroslaw Staniek <js@iidea.pl>

   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.

   Original Author:  Till Busch <till@bux.at>
   Original Project: buX (www.bux.at)
*/

#include <qpainter.h>
#include <qkeycode.h>
#include <qlineedit.h>
#include <qcombobox.h>
#include <qwmatrix.h>
#include <qtimer.h>
#include <qpopupmenu.h>
#include <qcursor.h>
#include <qstyle.h>
#include <qlayout.h>
#include <qlabel.h>
#include <qwhatsthis.h>

#include <kglobal.h>
#include <klocale.h>
#include <kdebug.h>
#include <kapplication.h>
#include <kiconloader.h>
#include <kmessagebox.h>

#ifndef KEXI_NO_PRINT
# include <kprinter.h>
#endif

#include "kexitableview.h"
#include <kexiutils/utils.h>
#include <kexiutils/validator.h>

#include "kexicelleditorfactory.h"
#include "kexitableviewheader.h"
#include "kexitableview_p.h"
#include <widget/utils/kexirecordmarker.h>
#include <widget/utils/kexidisplayutils.h>
#include <kexidb/cursor.h>

KexiTableView::Appearance::Appearance(QWidget *widget)
 : alternateBackgroundColor( KGlobalSettings::alternateBackgroundColor() )
{
    //set defaults
    if (qApp) {
        QPalette p = widget ? widget->palette() : qApp->palette();
        baseColor = p.active().base();
        textColor = p.active().text();
        borderColor = QColor(200,200,200);
        emptyAreaColor = p.active().color(QColorGroup::Base);
        rowHighlightingColor = KexiUtils::blendedColors(p.active().highlight(), baseColor, 33, 66);
        rowMouseOverHighlightingColor = KexiUtils::blendedColors(p.active().highlight(), baseColor, 10, 90);
        rowMouseOverAlternateHighlightingColor = KexiUtils::blendedColors(p.active().highlight(), alternateBackgroundColor, 10, 90);
        rowHighlightingTextColor = textColor;
        rowMouseOverHighlightingTextColor = textColor;
    }
    backgroundAltering = true;
    rowMouseOverHighlightingEnabled = true;
    rowHighlightingEnabled = true;
    persistentSelections = true;
    navigatorEnabled = true;
    fullRowSelection = false;
    gridEnabled = true;
}

//-----------------------------------------

class KexiTableView::WhatsThis : public QWhatsThis
{
    public:
        WhatsThis(KexiTableView* tv) : QWhatsThis(tv), m_tv(tv)
        {
            Q_ASSERT(tv);
        }
        virtual ~WhatsThis()
        {
        }
        virtual QString text( const QPoint & pos)
        {
            const int leftMargin = m_tv->verticalHeaderVisible() ? m_tv->verticalHeader()->width() : 0;
            //const int topMargin = m_tv->horizontalHeaderVisible() ? m_tv->d->pTopHeader->height() : 0;
            //const int bottomMargin = m_tv->d->appearance.navigatorEnabled ? m_tv->m_navPanel->height() : 0;
            if (KexiUtils::hasParent(m_tv->verticalHeader(), m_tv->childAt(pos))) {
                return i18n("Contains a pointer to the currently selected row");
            }
            else if (KexiUtils::hasParent(m_tv->m_navPanel, m_tv->childAt(pos))) {
                return i18n("Row navigator");
//              return QWhatsThis::textFor(m_tv->m_navPanel, QPoint( pos.x(), pos.y() - m_tv->height() + bottomMargin ));
            }
            KexiDB::Field *f = m_tv->field( m_tv->columnAt(pos.x()-leftMargin) );
            if (!f)
                return QString::null;
            return f->description().isEmpty() ? f->captionOrName() : f->description();
        }
        protected:
            KexiTableView *m_tv;
};

//-----------------------------------------

KexiTableViewCellToolTip::KexiTableViewCellToolTip( KexiTableView * tableView )
 : QToolTip(tableView->viewport())
 , m_tableView(tableView)
{
}

KexiTableViewCellToolTip::~KexiTableViewCellToolTip()
{
    remove(parentWidget());
}

void KexiTableViewCellToolTip::maybeTip( const QPoint & p )
{
    const QPoint cp( m_tableView->viewportToContents( p ) );
    const int row = m_tableView->rowAt( cp.y(), true/*ignoreEnd*/ );
    const int col = m_tableView->columnAt( cp.x() );

    //show tooltip if needed
    if (col>=0 && row>=0) {
        KexiTableEdit *editor = m_tableView->tableEditorWidget( col );
        const bool insertRowSelected = m_tableView->isInsertingEnabled() && row==m_tableView->rows();
        KexiTableItem *item = insertRowSelected ? m_tableView->m_insertItem : m_tableView->itemAt( row );
        if (editor && item && (col < (int)item->count())) {
            int w = m_tableView->columnWidth( col );
            int h = m_tableView->rowHeight();
            int x = 0;
            int y_offset = 0;
            int align = Qt::SingleLine | Qt::AlignVCenter;
            QString txtValue;
            QVariant cellValue;
            KexiTableViewColumn *tvcol = m_tableView->column(col);
            if (!m_tableView->getVisibleLookupValue(cellValue, editor, item, tvcol))
                cellValue = insertRowSelected ? editor->displayedField()->defaultValue() : item->at(col); //display default value if available
            const bool focused = m_tableView->selectedItem() == item && col == m_tableView->currentColumn();
            editor->setupContents( 0, focused, cellValue, txtValue, align, x, y_offset, w, h );
            QRect realRect(m_tableView->columnPos(col)-m_tableView->contentsX(), 
                m_tableView->rowPos(row)-m_tableView->contentsY(), w, h); //m_tableView->cellGeometry( row, col ));
            if (editor->showToolTipIfNeeded(
                txtValue.isEmpty() ? item->at(col) : QVariant(txtValue), 
                realRect, m_tableView->fontMetrics(), focused))
            {
                QString squeezedTxtValue;
                if (txtValue.length() > 50)
                    squeezedTxtValue = txtValue.left(100) + "...";
                else
                    squeezedTxtValue = txtValue;
                tip( realRect, squeezedTxtValue );
            }
        }
    }
}

//-----------------------------------------

KexiTableView::KexiTableView(KexiTableViewData* data, QWidget* parent, const char* name)
: QScrollView(parent, name, /*Qt::WRepaintNoErase | */Qt::WStaticContents /*| Qt::WResizeNoErase*/)
, KexiRecordNavigatorHandler()
, KexiSharedActionClient()
, KexiDataAwareObjectInterface()
{
//not needed    KexiTableView::initCellEditorFactories();

    d = new KexiTableViewPrivate(this);

    connect( kapp, SIGNAL( settingsChanged(int) ), SLOT( slotSettingsChanged(int) ) );
    slotSettingsChanged(KApplication::SETTINGS_SHORTCUTS);

    m_data = new KexiTableViewData(); //to prevent crash because m_data==0
    m_owner = true;                   //-this will be deleted if needed

    setResizePolicy(Manual);
    viewport()->setBackgroundMode(Qt::NoBackground);
//  viewport()->setFocusPolicy(StrongFocus);
    viewport()->setFocusPolicy(WheelFocus);
    setFocusPolicy(WheelFocus); //<--- !!!!! important (was NoFocus), 
    //                             otherwise QApplication::setActiveWindow() won't activate 
    //                             this widget when needed!
//  setFocusProxy(viewport());
    viewport()->installEventFilter(this);

    //setup colors defaults
    setBackgroundMode(Qt::PaletteBackground);
//  setEmptyAreaColor(d->appearance.baseColor);//palette().active().color(QColorGroup::Base));

//  d->baseColor = colorGroup().base();
//  d->textColor = colorGroup().text();

//  d->altColor = KGlobalSettings::alternateBackgroundColor();
//  d->grayColor = QColor(200,200,200);
    d->diagonalGrayPattern = QBrush(d->appearance.borderColor, Qt::BDiagPattern);

    setLineWidth(1);
    horizontalScrollBar()->installEventFilter(this);
    horizontalScrollBar()->raise();
    verticalScrollBar()->raise();

    //context menu
    m_popupMenu = new KPopupMenu(this, "contextMenu");
#if 0 //moved to mainwindow's actions
    d->menu_id_addRecord = m_popupMenu->insertItem(i18n("Add Record"), this, SLOT(addRecord()), Qt::CTRL+Qt::Key_Insert);
    d->menu_id_removeRecord = m_popupMenu->insertItem(
        kapp->iconLoader()->loadIcon("button_cancel", KIcon::Small),
        i18n("Remove Record"), this, SLOT(removeRecord()), Qt::CTRL+Qt::Key_Delete);
#endif

#ifdef Q_WS_WIN
    d->rowHeight = fontMetrics().lineSpacing() + 4;
#else
    d->rowHeight = fontMetrics().lineSpacing() + 1;
#endif

    if(d->rowHeight < 17)
        d->rowHeight = 17;

    d->pUpdateTimer = new QTimer(this);

//  setMargins(14, fontMetrics().height() + 4, 0, 0);

    // Create headers
    m_horizontalHeader = new KexiTableViewHeader(this, "topHeader");
    m_horizontalHeader->setSelectionBackgroundColor( palette().active().highlight() );
    m_horizontalHeader->setOrientation(Qt::Horizontal);
    m_horizontalHeader->setTracking(false);
    m_horizontalHeader->setMovingEnabled(false);
    connect(m_horizontalHeader, SIGNAL(sizeChange(int,int,int)), this, SLOT(slotTopHeaderSizeChange(int,int,int)));

    m_verticalHeader = new KexiRecordMarker(this, "rm");
    m_verticalHeader->setSelectionBackgroundColor( palette().active().highlight() );
    m_verticalHeader->setCellHeight(d->rowHeight);
//  m_verticalHeader->setFixedWidth(d->rowHeight);
    m_verticalHeader->setCurrentRow(-1);

    setMargins(
        QMIN(m_horizontalHeader->sizeHint().height(), d->rowHeight),
        m_horizontalHeader->sizeHint().height(), 0, 0);

    setupNavigator();

//  setMinimumHeight(horizontalScrollBar()->height() + d->rowHeight + topMargin());

//  navPanelLyr->addStretch(25);
//  enableClipper(true);

    if (data)
        setData( data );

#if 0//(js) doesn't work!
    d->scrollTimer = new QTimer(this);
    connect(d->scrollTimer, SIGNAL(timeout()), this, SLOT(slotAutoScroll()));
#endif

//  setBackgroundAltering(true);
//  setFullRowSelectionEnabled(false);

    setAcceptDrops(true);
    viewport()->setAcceptDrops(true);

    // Connect header, table and scrollbars
    connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), m_horizontalHeader, SLOT(setOffset(int)));
    connect(verticalScrollBar(), SIGNAL(valueChanged(int)), m_verticalHeader, SLOT(setOffset(int)));
    connect(m_horizontalHeader, SIGNAL(sizeChange(int, int, int)), this, SLOT(slotColumnWidthChanged(int, int, int)));
    connect(m_horizontalHeader, SIGNAL(sectionHandleDoubleClicked(int)), this, SLOT(slotSectionHandleDoubleClicked(int)));
    connect(m_horizontalHeader, SIGNAL(clicked(int)), this, SLOT(sortColumnInternal(int)));

    connect(d->pUpdateTimer, SIGNAL(timeout()), this, SLOT(slotUpdate()));
    
//  horizontalScrollBar()->show();
    updateScrollBars();
//  resize(sizeHint());
//  updateContents();
//  setMinimumHeight(horizontalScrollBar()->height() + d->rowHeight + topMargin());

//TMP
//setVerticalHeaderVisible(false);
//setHorizontalHeaderVisible(false);

//will be updated by setAppearance: updateFonts();
    setAppearance(d->appearance); //refresh

    d->cellToolTip = new KexiTableViewCellToolTip(this);
    new WhatsThis(this);
}

KexiTableView::~KexiTableView()
{
    cancelRowEdit();

    KexiTableViewData *data = m_data;
    m_data = 0;
    if (m_owner) {
        if (data)
            data->deleteLater();
    }
    delete d;
}

void KexiTableView::clearVariables()
{
    KexiDataAwareObjectInterface::clearVariables();
    d->clearVariables();
}

/*void KexiTableView::initActions(KActionCollection *ac)
{
    emit reloadActions(ac);
}*/

void KexiTableView::setupNavigator()
{
    updateScrollBars();
    
    m_navPanel = new KexiRecordNavigator(this, leftMargin(), "navPanel");
    m_navPanel->setRecordHandler(this);
    m_navPanel->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Preferred);
}

void KexiTableView::initDataContents()
{
    updateWidgetContentsSize();

    KexiDataAwareObjectInterface::initDataContents();

    m_navPanel->showEditingIndicator(false);
}

void KexiTableView::addHeaderColumn(const QString& caption, const QString& description, 
    const QIconSet& icon, int width)
{
    const int nr = m_horizontalHeader->count();
    if (icon.isNull())
        m_horizontalHeader->addLabel(caption, width);
    else
        m_horizontalHeader->addLabel(icon, caption, width);

    if (!description.isEmpty())
        m_horizontalHeader->setToolTip(nr, description);
}

void KexiTableView::updateWidgetContentsSize()
{
    QSize s(tableSize());
    resizeContents(s.width(), s.height());
}

void KexiTableView::slotRowsDeleted( const QValueList<int> &rows )
{
    viewport()->repaint();
    updateWidgetContentsSize();
    setCursorPosition(QMAX(0, (int)m_curRow - (int)rows.count()), -1, true);
}


/*void KexiTableView::addDropFilter(const QString &filter)
{
    d->dropFilters.append(filter);
    viewport()->setAcceptDrops(true);
}*/

void KexiTableView::setFont( const QFont &font )
{
    QScrollView::setFont(font);
    updateFonts(true);
}

void KexiTableView::updateFonts(bool repaint)
{
#ifdef Q_WS_WIN
    d->rowHeight = fontMetrics().lineSpacing() + 4;
#else
    d->rowHeight = fontMetrics().lineSpacing() + 1;
#endif
    if (d->appearance.fullRowSelection) {
        d->rowHeight -= 1;
    }
    if(d->rowHeight < 17)
        d->rowHeight = 17;
//  if(d->rowHeight < 22)
//      d->rowHeight = 22;
    setMargins(
        QMIN(m_horizontalHeader->sizeHint().height(), d->rowHeight),
        m_horizontalHeader->sizeHint().height(), 0, 0);
//  setMargins(14, d->rowHeight, 0, 0);
    m_verticalHeader->setCellHeight(d->rowHeight);

    KexiDisplayUtils::initDisplayForAutonumberSign(d->autonumberSignDisplayParameters, this);
    KexiDisplayUtils::initDisplayForDefaultValue(d->defaultValueDisplayParameters, this);

    if (repaint)
        updateContents();
}

void KexiTableView::updateAllVisibleRowsBelow(int row)
{
    //get last visible row
    int r = rowAt(clipper()->height()+contentsY());
    if (r==-1) {
        r = rows()+1+(isInsertingEnabled()?1:0);
    }
    //update all visible rows below 
    int leftcol = m_horizontalHeader->sectionAt( m_horizontalHeader->offset() );
//  int row = m_curRow;
    updateContents( columnPos( leftcol ), rowPos(row), 
        clipper()->width(), clipper()->height() - (rowPos(row) - contentsY()) );
}

void KexiTableView::clearColumnsInternal(bool /*repaint*/)
{
    while(m_horizontalHeader->count()>0)
        m_horizontalHeader->removeLabel(0);
}

void KexiTableView::slotUpdate()
{
//  kdDebug(44021) << " KexiTableView::slotUpdate() -- " << endl;
//  QSize s(tableSize());
//  viewport()->setUpdatesEnabled(false);
//  viewport()->setUpdatesEnabled(true);

    updateContents();
    updateScrollBars();
    if (m_navPanel)
        m_navPanel->updateGeometry(leftMargin());
//  updateNavPanelGeometry();

    updateWidgetContentsSize();
//  updateContents(0, contentsY()+clipper()->height()-2*d->rowHeight, clipper()->width(), d->rowHeight*3);
    
    //updateGeometries();
//  updateContents(0, 0, viewport()->width(), contentsHeight());
//  updateGeometries();
}

int KexiTableView::currentLocalSortingOrder() const
{
    if (m_horizontalHeader->sortIndicatorSection()==-1)
        return 0;
    return (m_horizontalHeader->sortIndicatorOrder() == Qt::Ascending) ? 1 : -1;
}

void KexiTableView::setLocalSortingOrder(int col, int order)
{
    if (order == 0)
        col = -1;
    if (col>=0)
        m_horizontalHeader->setSortIndicator(col, (order==1) ? Qt::Ascending : Qt::Descending);
}

int KexiTableView::currentLocalSortColumn() const
{
    return m_horizontalHeader->sortIndicatorSection();
}

void KexiTableView::updateGUIAfterSorting()
{
    int cw = columnWidth(m_curCol);
    int rh = rowHeight();

//  m_verticalHeader->setCurrentRow(m_curRow);
    center(columnPos(m_curCol) + cw / 2, rowPos(m_curRow) + rh / 2);
//  updateCell(oldRow, m_curCol);
//  updateCell(m_curRow, m_curCol);
//  slotUpdate();

    updateContents();
//  d->pUpdateTimer->start(1,true);
}

QSizePolicy KexiTableView::sizePolicy() const
{
    // this widget is expandable
    return QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}

QSize KexiTableView::sizeHint() const
{
    const QSize &ts = tableSize();
    int w = QMAX( ts.width() + leftMargin()+ verticalScrollBar()->sizeHint().width() + 2*2, 
        (m_navPanel->isVisible() ? m_navPanel->width() : 0) );
    int h = QMAX( ts.height()+topMargin()+horizontalScrollBar()->sizeHint().height(), 
        minimumSizeHint().height() );
    w = QMIN( w, qApp->desktop()->width()*3/4 ); //stretch
    h = QMIN( h, qApp->desktop()->height()*3/4 ); //stretch

//  kexidbg << "KexiTableView::sizeHint()= " <<w <<", " <<h << endl;

    return QSize(w, h);
        /*QSize(
        QMAX( ts.width() + leftMargin() + 2*2, (m_navPanel ? m_navPanel->width() : 0) ),
        //+ QMIN(m_verticalHeader->width(),d->rowHeight) + margin()*2,
        QMAX( ts.height()+topMargin()+horizontalScrollBar()->sizeHint().height(), 
            minimumSizeHint().height() )
    );*/
//      QMAX(ts.height() + topMargin(), minimumSizeHint().height()) );
}

QSize KexiTableView::minimumSizeHint() const
{
    return QSize(
        leftMargin() + ((columns()>0)?columnWidth(0):KEXI_DEFAULT_DATA_COLUMN_WIDTH) + 2*2, 
        d->rowHeight*5/2 + topMargin() + (m_navPanel && m_navPanel->isVisible() ? m_navPanel->height() : 0)
    );
}

void KexiTableView::createBuffer(int width, int height)
{
    if(!d->pBufferPm)
        d->pBufferPm = new QPixmap(width, height);
    else
        if(d->pBufferPm->width() < width || d->pBufferPm->height() < height)
            d->pBufferPm->resize(width, height);
//  d->pBufferPm->fill();
}

//internal
inline void KexiTableView::paintRow(KexiTableItem *item,
    QPainter *pb, int r, int rowp, int cx, int cy, 
    int colfirst, int collast, int maxwc)
{
    if (!item)
        return;
    // Go through the columns in the row r
    // if we know from where to where, go through [colfirst, collast],
    // else go through all of them
    if (colfirst==-1)
        colfirst=0;
    if (collast==-1)
        collast=columns()-1;

    int transly = rowp-cy;

    if (d->appearance.rowHighlightingEnabled && r == m_curRow && !d->appearance.fullRowSelection) {
        pb->fillRect(0, transly, maxwc, d->rowHeight, d->appearance.rowHighlightingColor);
    }
    else if (d->appearance.rowMouseOverHighlightingEnabled && r == d->highlightedRow) {
        if(d->appearance.backgroundAltering && (r%2 != 0))
            pb->fillRect(0, transly, maxwc, d->rowHeight, d->appearance.rowMouseOverAlternateHighlightingColor);
        else
            pb->fillRect(0, transly, maxwc, d->rowHeight, d->appearance.rowMouseOverHighlightingColor);
    }
    else {
        if(d->appearance.backgroundAltering && (r%2 != 0))
            pb->fillRect(0, transly, maxwc, d->rowHeight, d->appearance.alternateBackgroundColor);
        else
            pb->fillRect(0, transly, maxwc, d->rowHeight, d->appearance.baseColor);
    }

    for(int c = colfirst; c <= collast; c++)
    {
        // get position and width of column c
        int colp = columnPos(c);
        if (colp==-1)
            continue; //invisible column?
        int colw = columnWidth(c);
        int translx = colp-cx;

        // Translate painter and draw the cell
        pb->saveWorldMatrix();
        pb->translate(translx, transly);
            paintCell( pb, item, c, r, QRect(colp, rowp, colw, d->rowHeight));
        pb->restoreWorldMatrix();
    }

    if (m_dragIndicatorLine>=0) {
        int y_line = -1;
        if (r==(rows()-1) && m_dragIndicatorLine==rows()) {
            y_line = transly+d->rowHeight-3; //draw at last line
        }
        if (m_dragIndicatorLine==r) {
            y_line = transly+1;
        }
        if (y_line>=0) {
            RasterOp op = pb->rasterOp();
            pb->setRasterOp(XorROP);
            pb->setPen( QPen(Qt::white, 3) );
            pb->drawLine(0, y_line, maxwc, y_line);
            pb->setRasterOp(op);
        }
    }
}

void KexiTableView::drawContents( QPainter *p, int cx, int cy, int cw, int ch)
{
    if (d->disableDrawContents)
        return;
    int colfirst = columnAt(cx);
    int rowfirst = rowAt(cy);
    int collast = columnAt(cx + cw-1);
    int rowlast = rowAt(cy + ch-1);
    bool inserting = isInsertingEnabled();
    bool plus1row = false; //true if we should show 'inserting' row at the end
    bool paintOnlyInsertRow = false;

/*  kdDebug(44021) << QString(" KexiTableView::drawContents(cx:%1 cy:%2 cw:%3 ch:%4)")
            .arg(cx).arg(cy).arg(cw).arg(ch) << endl;*/

    if (rowlast == -1) {
        rowlast = rows() - 1;
        plus1row = inserting;
        if (rowfirst == -1) {
            if (rowAt(cy - d->rowHeight) != -1) {
                paintOnlyInsertRow = true;
//              kdDebug(44021) << "-- paintOnlyInsertRow --" << endl;
            }
        }
    }
//  kdDebug(44021) << "rowfirst="<<rowfirst<<" rowlast="<<rowlast<<" rows()="<<rows()<<endl;
//  kdDebug(44021)<<" plus1row=" << plus1row<<endl;
    
    if ( collast == -1 )
        collast = columns() - 1;

    if (colfirst>collast) {
        int tmp = colfirst;
        colfirst = collast;
        collast = tmp;
    }
    if (rowfirst>rowlast) {
        int tmp = rowfirst;
        rowfirst = rowlast;
        rowlast = tmp;
    }

//  qDebug("cx:%3d cy:%3d w:%3d h:%3d col:%2d..%2d row:%2d..%2d tsize:%4d,%4d", 
//  cx, cy, cw, ch, colfirst, collast, rowfirst, rowlast, tableSize().width(), tableSize().height());
//  triggerUpdate();

    if (rowfirst == -1 || colfirst == -1) {
        if (!paintOnlyInsertRow && !plus1row) {
            paintEmptyArea(p, cx, cy, cw, ch);
            return;
        }
    }

    createBuffer(cw, ch);
    if(d->pBufferPm->isNull())
        return;
    QPainter *pb = new QPainter(d->pBufferPm, this);
//  pb->fillRect(0, 0, cw, ch, colorGroup().base());

//  int maxwc = QMIN(cw, (columnPos(d->numCols - 1) + columnWidth(d->numCols - 1)));
    int maxwc = columnPos(columns() - 1) + columnWidth(columns() - 1);
//  kdDebug(44021) << "KexiTableView::drawContents(): maxwc: " << maxwc << endl;

    pb->fillRect(cx, cy, cw, ch, d->appearance.baseColor);

    int rowp;
    int r;
    if (paintOnlyInsertRow) {
        r = rows();
        rowp = rowPos(r); // 'insert' row's position
    }
    else {
        QPtrListIterator<KexiTableItem> it = m_data->iterator();
        it += rowfirst;//move to 1st row
        rowp = rowPos(rowfirst); // row position 
        for (r = rowfirst;r <= rowlast; r++, ++it, rowp+=d->rowHeight) {
            paintRow(it.current(), pb, r, rowp, cx, cy, colfirst, collast, maxwc);
        }
    }

    if (plus1row) { //additional - 'insert' row
        paintRow(m_insertItem, pb, r, rowp, cx, cy, colfirst, collast, maxwc);
    }

    delete pb;

    p->drawPixmap(cx,cy,*d->pBufferPm, 0,0,cw,ch);

  //(js)
    paintEmptyArea(p, cx, cy, cw, ch);
}

bool KexiTableView::isDefaultValueDisplayed(KexiTableItem *item, int col, QVariant* value)
{
    const bool cursorAtInsertRowOrEditingNewRow = (item == m_insertItem || (m_newRowEditing && m_currentItem == item));
    KexiTableViewColumn *tvcol;
    if (cursorAtInsertRowOrEditingNewRow 
        && (tvcol = m_data->column(col)) 
        && hasDefaultValueAt(*tvcol) 
        && !tvcol->field()->isAutoIncrement())
    {
        if (value)
            *value = tvcol->field()->defaultValue();
        return true;
    }
    return false;
}

void KexiTableView::paintCell(QPainter* p, KexiTableItem *item, int col, int row, const QRect &cr, bool print)
{
    p->save();
    Q_UNUSED(print);
    int w = cr.width();
    int h = cr.height();
    int x2 = w - 1;
    int y2 = h - 1;

/*  if (0==qstrcmp("KexiComboBoxPopup",parentWidget()->className())) {
      kexidbg  << parentWidget()->className() << " >>>>>> KexiTableView::paintCell(col=" << col <<"row="<<row<<") w="<<w<<endl;
    }*/

    //  Draw our lines
    QPen pen(p->pen());

    if (d->appearance.gridEnabled) {
        p->setPen(d->appearance.borderColor);
        p->drawLine( x2, 0, x2, y2 );   // right
        p->drawLine( 0, y2, x2, y2 );   // bottom
    }
    p->setPen(pen);

    if (m_editor && row == m_curRow && col == m_curCol //don't paint contents of edited cell
        && m_editor->hasFocusableWidget() //..if it's visible
       ) {
        p->restore();
        return;
    }

    KexiTableEdit *edit = tableEditorWidget( col, /*ignoreMissingEditor=*/true );
//  if (!edit)
//      return;

    int x = edit ? edit->leftMargin() : 0;
    int y_offset=0;

    int align = Qt::SingleLine | Qt::AlignVCenter;
    QString txt; //text to draw

    KexiTableViewColumn *tvcol = m_data->column(col);

    QVariant cellValue;
    if (col < (int)item->count()) {
        if (m_currentItem == item) {
            if (m_editor && row == m_curRow && col == m_curCol 
                && !m_editor->hasFocusableWidget())
            {
                //we're over editing cell and the editor has no widget
                // - we're displaying internal values, not buffered
//              bool ok;
                cellValue = m_editor->value();
            }
            else {
                //we're displaying values from edit buffer, if available
                // this assignment will also get default value if there's no actual value set
                cellValue = *bufferedValueAt(col);
            }
        }
        else {
            cellValue = item->at(col);
        }
    }

    bool defaultValueDisplayed = isDefaultValueDisplayed(item, col);

    if ((item == m_insertItem /*|| m_newRowEditing*/) && cellValue.isNull()) {
        if (!tvcol->field()->isAutoIncrement() && !tvcol->field()->defaultValue().isNull()) {
            //display default value in the "insert row", if available
            //(but not if there is autoincrement flag set)
            cellValue = tvcol->field()->defaultValue();
            defaultValueDisplayed = true;
        }
    }

    const bool columnReadOnly = tvcol->isReadOnly();
    const bool dontPaintNonpersistentSelectionBecauseDifferentRowHasBeenHighlighted 
        = d->appearance.rowHighlightingEnabled && !d->appearance.persistentSelections 
            && m_curRow /*d->highlightedRow*/ >= 0 && row != m_curRow; //d->highlightedRow;

    // setup default pen
    QPen defaultPen;
    const bool usesSelectedTextColor = edit && edit->usesSelectedTextColor();
    if (defaultValueDisplayed) {
        if (col == m_curCol && row == m_curRow && usesSelectedTextColor)
            defaultPen = d->defaultValueDisplayParameters.selectedTextColor;
        else
            defaultPen = d->defaultValueDisplayParameters.textColor;
    }
    else if (d->appearance.fullRowSelection 
        && (row == d->highlightedRow || (row == m_curRow && d->highlightedRow==-1)) 
        && usesSelectedTextColor )
    {
        defaultPen = d->appearance.rowHighlightingTextColor; //special case: highlighted row
    }
    else if (d->appearance.fullRowSelection && row == m_curRow && usesSelectedTextColor)
    {
        defaultPen = d->appearance.textColor; //special case for full row selection
    }
    else if (m_currentItem == item && col == m_curCol && !columnReadOnly 
        && !dontPaintNonpersistentSelectionBecauseDifferentRowHasBeenHighlighted
        && usesSelectedTextColor)
    {
        defaultPen = colorGroup().highlightedText(); //selected text
    }
    else if (d->appearance.rowHighlightingEnabled && row == m_curRow 
        && !dontPaintNonpersistentSelectionBecauseDifferentRowHasBeenHighlighted
        && usesSelectedTextColor)
    {
        defaultPen = d->appearance.rowHighlightingTextColor;
    }
    else if (d->appearance.rowMouseOverHighlightingEnabled && row == d->highlightedRow 
        && !dontPaintNonpersistentSelectionBecauseDifferentRowHasBeenHighlighted
        && usesSelectedTextColor)
    {
        defaultPen = d->appearance.rowMouseOverHighlightingTextColor;
    }
    else
        defaultPen = d->appearance.textColor;

    if (edit) {
        if (defaultValueDisplayed)
            p->setFont( d->defaultValueDisplayParameters.font );
        p->setPen( defaultPen );

        //get visible lookup value if available
        getVisibleLookupValue(cellValue, edit, item, tvcol);

        edit->setupContents( p, m_currentItem == item && col == m_curCol, 
            cellValue, txt, align, x, y_offset, w, h );
    }
    if (!d->appearance.gridEnabled)
        y_offset++; //correction because we're not drawing cell borders

    if (d->appearance.fullRowSelection && d->appearance.fullRowSelection) {
//      p->fillRect(x, y_offset, x+w-1, y_offset+h-1, red);
    }
    if (m_currentItem == item && (col == m_curCol || d->appearance.fullRowSelection)) {
        if (edit && ((d->appearance.rowHighlightingEnabled && !d->appearance.fullRowSelection) || (row == m_curRow && d->highlightedRow==-1 && d->appearance.fullRowSelection))) 
            edit->paintSelectionBackground( p, isEnabled(), txt, align, x, y_offset, w, h,
                isEnabled() ? colorGroup().highlight() : QColor(200,200,200),//d->grayColor,
                p->fontMetrics(), columnReadOnly, d->appearance.fullRowSelection );
    }

    if (!edit) {
        p->fillRect(0, 0, x2, y2, d->diagonalGrayPattern);
    }

//  If we are in the focus cell, draw indication
    if(m_currentItem == item && col == m_curCol //js: && !d->recordIndicator)
        && !d->appearance.fullRowSelection) 
    {
//      kexidbg << ">>> CURRENT CELL ("<<m_curCol<<"," << m_curRow<<") focus="<<has_focus<<endl;
//      if (has_focus) {
        if (isEnabled()) {
            p->setPen(d->appearance.textColor);
        }
        else {
            QPen gray_pen(p->pen());
            gray_pen.setColor(d->appearance.borderColor);
            p->setPen(gray_pen);
        }
        if (edit)
            edit->paintFocusBorders( p, cellValue, 0, 0, x2, y2 );
        else
            p->drawRect(0, 0, x2, y2);
    }

    if ((!m_newRowEditing && item == m_insertItem) 
        || (m_newRowEditing && item == m_currentItem && cellValue.isNull())) {
        //we're in "insert row"
        if (tvcol->field()->isAutoIncrement()) {
            //"autonumber" column
//          txt = i18n("(autonumber)");
//          autonumber = true;
//      if (autonumber) {
            KexiDisplayUtils::paintAutonumberSign(d->autonumberSignDisplayParameters, p, 
                x, y_offset, w - x - x - ((align & Qt::AlignLeft)?2:0), h, align);
//      }
        }
    }
    
    // draw text
    if (!txt.isEmpty()) {
        if (defaultValueDisplayed)
            p->setFont( d->defaultValueDisplayParameters.font );
        p->setPen( defaultPen );
        p->drawText(x, y_offset, w - (x + x)- ((align & Qt::AlignLeft)?2:0)/*right space*/, h,
            align, txt);
    }
    p->restore();
}

QPoint KexiTableView::contentsToViewport2( const QPoint &p )
{
    return QPoint( p.x() - contentsX(), p.y() - contentsY() );
}

void KexiTableView::contentsToViewport2( int x, int y, int& vx, int& vy )
{
    const QPoint v = contentsToViewport2( QPoint( x, y ) );
    vx = v.x();
    vy = v.y();
}

QPoint KexiTableView::viewportToContents2( const QPoint& vp )
{
    return QPoint( vp.x() + contentsX(),
           vp.y() + contentsY() );
}

void KexiTableView::paintEmptyArea( QPainter *p, int cx, int cy, int cw, int ch )
{
//  qDebug("%s: paintEmptyArea(x:%d y:%d w:%d h:%d)", (const char*)parentWidget()->caption(),cx,cy,cw,ch);

    // Regions work with shorts, so avoid an overflow and adjust the
    // table size to the visible size
    QSize ts( tableSize() );
//  ts.setWidth( QMIN( ts.width(), visibleWidth() ) );
//  ts.setHeight( QMIN( ts.height() - (m_navPanel ? m_navPanel->height() : 0), visibleHeight()) );
/*  kdDebug(44021) << QString(" (cx:%1 cy:%2 cw:%3 ch:%4)")
            .arg(cx).arg(cy).arg(cw).arg(ch) << endl;
    kdDebug(44021) << QString(" (w:%3 h:%4)")
            .arg(ts.width()).arg(ts.height()) << endl;*/
    
    // Region of the rect we should draw, calculated in viewport
    // coordinates, as a region can't handle bigger coordinates
    contentsToViewport2( cx, cy, cx, cy );
    QRegion reg( QRect( cx, cy, cw, ch ) );

//kexidbg << "---cy-- " << contentsY() << endl;

    // Subtract the table from it
//  reg = reg.subtract( QRect( QPoint( 0, 0 ), ts-QSize(0,m_navPanel->isVisible() ? m_navPanel->height() : 0) ) );
    reg = reg.subtract( QRect( QPoint( 0, 0 ), ts
        -QSize(0,QMAX((m_navPanel ? m_navPanel->height() : 0), horizontalScrollBar()->sizeHint().height())
            - (horizontalScrollBar()->isVisible() ? horizontalScrollBar()->sizeHint().height()/2 : 0)
            + (horizontalScrollBar()->isVisible() ? 0 : 
                d->internal_bottomMargin
//  horizontalScrollBar()->sizeHint().height()/2
        )
//- /*d->bottomMargin */ horizontalScrollBar()->sizeHint().height()*3/2
            + contentsY()
//          - (verticalScrollBar()->isVisible() ? horizontalScrollBar()->sizeHint().height()/2 : 0)
            )
        ) );
//  reg = reg.subtract( QRect( QPoint( 0, 0 ), ts ) );

    // And draw the rectangles (transformed inc contents coordinates as needed)
    QMemArray<QRect> r = reg.rects();
    for ( int i = 0; i < (int)r.count(); i++ ) {
        QRect rect( viewportToContents2(r[i].topLeft()), r[i].size() );
/*      kdDebug(44021) << QString("- pEA: p->fillRect(x:%1 y:%2 w:%3 h:%4)")
            .arg(rect.x()).arg(rect.y())
            .arg(rect.width()).arg(rect.height()) << endl;*/
//      p->fillRect( QRect(viewportToContents2(r[i].topLeft()),r[i].size()), d->emptyAreaColor );
        p->fillRect( rect, d->appearance.emptyAreaColor );
//      p->fillRect( QRect(viewportToContents2(r[i].topLeft()),r[i].size()), viewport()->backgroundBrush() );
    }
}

void KexiTableView::contentsMouseDoubleClickEvent(QMouseEvent *e)
{
//  kdDebug(44021) << "KexiTableView::contentsMouseDoubleClickEvent()" << endl;
    m_contentsMousePressEvent_dblClick = true;
    contentsMousePressEvent(e);
    m_contentsMousePressEvent_dblClick = false;

    if(m_currentItem)
    {
        if(d->editOnDoubleClick && columnEditable(m_curCol) && columnType(m_curCol) != KexiDB::Field::Boolean) {
            KexiTableEdit *edit = tableEditorWidget( m_curCol, /*ignoreMissingEditor=*/true );
            if (edit && edit->handleDoubleClick()) {
                //nothing to do: editors like BLOB editor has custom handling of double clicking
            }
            else {
                startEditCurrentCell();
    //          createEditor(m_curRow, m_curCol, QString::null);
            }
        }

        emit itemDblClicked(m_currentItem, m_curRow, m_curCol);
    }
}

void KexiTableView::contentsMousePressEvent( QMouseEvent* e )
{
//  kdDebug(44021) << "KexiTableView::contentsMousePressEvent() ??" << endl;
    setFocus();
    if(m_data->count()==0 && !isInsertingEnabled()) {
        QScrollView::contentsMousePressEvent( e );
        return;
    }

    if (columnAt(e->pos().x())==-1) { //outside a colums
        QScrollView::contentsMousePressEvent( e );
        return;
    }
//  d->contentsMousePressEvent_ev = *e;
//  d->contentsMousePressEvent_enabled = true;
//  QTimer::singleShot(2000, this, SLOT( contentsMousePressEvent_Internal() ));
//  d->contentsMousePressEvent_timer.start(100,true);
    
//  if (!d->contentsMousePressEvent_enabled)
//      return;
//  d->contentsMousePressEvent_enabled=false;

    if (!d->moveCursorOnMouseRelease) {
        if (!handleContentsMousePressOrRelease(e, false))
            return;
    }

//  kdDebug(44021)<<"void KexiTableView::contentsMousePressEvent( QMouseEvent* e ) by now the current items should be set, if not -> error + crash"<<endl;
    if(e->button() == Qt::RightButton)
    {
        showContextMenu(e->globalPos());
    }
    else if(e->button() == Qt::LeftButton)
    {
        if(columnType(m_curCol) == KexiDB::Field::Boolean && columnEditable(m_curCol))
        {
            //only accept clicking on the [x] rect (copied from KexiBoolTableEdit::setupContents())
            int s = QMAX(d->rowHeight - 5, 12);
            s = QMIN( d->rowHeight-3, s );
            s = QMIN( columnWidth(m_curCol)-3, s ); //avoid too large box
            const QRect r( columnPos(m_curCol) + QMAX( columnWidth(m_curCol)/2 - s/2, 0 ), rowPos(m_curRow) +d->rowHeight/2 - s/2 /*- 1*/, s, s);
            //kexidbg << r << endl;
            if (r.contains(e->pos())) {
//              kexidbg << "e->x:" << e->x() << " e->y:" << e->y() << " " << rowPos(m_curRow) << 
//                  " " << columnPos(m_curCol) << endl;
                boolToggled();
            }
        }
#if 0 //js: TODO
        else if(columnType(m_curCol) == QVariant::StringList && columnEditable(m_curCol))
        {
            createEditor(m_curRow, m_curCol);
        }
#endif
    }
//ScrollView::contentsMousePressEvent( e );
}

void KexiTableView::contentsMouseReleaseEvent( QMouseEvent* e )
{
//  kdDebug(44021) << "KexiTableView::contentsMousePressEvent() ??" << endl;
    if(m_data->count()==0 && !isInsertingEnabled())
        return;

    if (d->moveCursorOnMouseRelease)
        handleContentsMousePressOrRelease(e, true);

    int col = columnAt(e->pos().x());
    int row = rowAt(e->pos().y());

    if (!m_currentItem || col==-1 || row==-1 || col!=m_curCol || row!=m_curRow)//outside a current cell
        return;

    QScrollView::contentsMouseReleaseEvent( e );

    emit itemMouseReleased(m_currentItem, m_curRow, m_curCol);
}

bool KexiTableView::handleContentsMousePressOrRelease(QMouseEvent* e, bool release)
{
    // remember old focus cell
    int oldRow = m_curRow;
    int oldCol = m_curCol;
    kdDebug(44021) << "oldRow=" << oldRow <<" oldCol=" << oldCol <<endl;
    bool onInsertItem = false;

    int newrow, newcol;
    //compute clicked row nr
    if (isInsertingEnabled()) {
        if (rowAt(e->pos().y())==-1) {
            newrow = rowAt(e->pos().y() - d->rowHeight);
            if (newrow==-1 && m_data->count()>0) {
                if (release)
                    QScrollView::contentsMouseReleaseEvent( e );
                else
                    QScrollView::contentsMousePressEvent( e );
                return false;
            }
            newrow++;
            kdDebug(44021) << "Clicked just on 'insert' row." << endl;
            onInsertItem=true;
        }
        else {
            // get new focus cell
            newrow = rowAt(e->pos().y());
        }
    }
    else {
        if (rowAt(e->pos().y())==-1 || columnAt(e->pos().x())==-1) {
            if (release)
                QScrollView::contentsMouseReleaseEvent( e );
            else
                QScrollView::contentsMousePressEvent( e );
            return false; //clicked outside a grid
        }
        // get new focus cell
        newrow = rowAt(e->pos().y());
    }
    newcol = columnAt(e->pos().x());

    if(e->button() != Qt::NoButton) {
        setCursorPosition(newrow,newcol);
    }
    return true;
}

void KexiTableView::showContextMenu(const QPoint& _pos)
{
    if (!d->contextMenuEnabled || m_popupMenu->count()<1)
        return;
    QPoint pos(_pos);
    if (pos==QPoint(-1,-1)) {
        pos = viewport()->mapToGlobal( QPoint( columnPos(m_curCol), rowPos(m_curRow) + d->rowHeight ) );
    }
    //show own context menu if configured
//  if (updateContextMenu()) {
        selectRow(m_curRow);
        m_popupMenu->exec(pos);
/*  }
    else {
        //request other context menu
        emit contextMenuRequested(m_currentItem, m_curCol, pos);
    }*/
}

void KexiTableView::contentsMouseMoveEvent( QMouseEvent *e )
{
    int row;
    const int col = columnAt(e->x());
    if (col < 0) {
        row = -1;
    } else {
        row = rowAt( e->y(), true /*ignoreEnd*/ );
        if (row > (rows() - 1 + (isInsertingEnabled()?1:0)))
            row = -1; //no row to paint
    }
//  kexidbg << " row="<<row<< " col="<<col<<endl;
    //update row highlight if needed
    if (d->appearance.rowMouseOverHighlightingEnabled) {
        if (row != d->highlightedRow) {
            const int oldRow = d->highlightedRow;
            d->highlightedRow = row;
            updateRow(oldRow);
            updateRow(d->highlightedRow);
            //currently selected (not necessary highlighted) row needs to be repainted
            updateRow(m_curRow);
            m_verticalHeader->setHighlightedRow(d->highlightedRow);
        }
    }

#if 0//(js) doesn't work!

    // do the same as in mouse press
    int x,y;
    contentsToViewport(e->x(), e->y(), x, y);

    if(y > visibleHeight())
    {
        d->needAutoScroll = true;
        d->scrollTimer->start(70, false);
        d->scrollDirection = ScrollDown;
    }
    else if(y < 0)
    {
        d->needAutoScroll = true;
        d->scrollTimer->start(70, false);
        d->scrollDirection = ScrollUp;
    }
    else if(x > visibleWidth())
    {
        d->needAutoScroll = true;
        d->scrollTimer->start(70, false);
        d->scrollDirection = ScrollRight;
    }
    else if(x < 0)
    {
        d->needAutoScroll = true;
        d->scrollTimer->start(70, false);
        d->scrollDirection = ScrollLeft;
    }
    else
    {
        d->needAutoScroll = false;
        d->scrollTimer->stop();
        contentsMousePressEvent(e);
    }
#endif
    QScrollView::contentsMouseMoveEvent(e);
}

#if 0//(js) doesn't work!
void KexiTableView::contentsMouseReleaseEvent(QMouseEvent *)
{
    if(d->needAutoScroll)
    {
        d->scrollTimer->stop();
    }
}
#endif

static bool overrideEditorShortcutNeeded(QKeyEvent *e)
{
    //perhaps more to come...
    return e->key() == Qt::Key_Delete && e->state()==Qt::ControlButton;
}

bool KexiTableView::shortCutPressed( QKeyEvent *e, const QCString &action_name )
{
    const int k = e->key();
    KAction *action = m_sharedActions[action_name];
    if (action) {
        if (!action->isEnabled())//this action is disabled - don't process it!
            return false; 
        if (action->shortcut() == KShortcut( KKey(e) )) {
            //special cases when we need to override editor's shortcut
            if (overrideEditorShortcutNeeded(e)) {
                return true;
            }
            return false;//this shortcut is owned by shared action - don't process it!
        }
    }

    //check default shortcut (when user app has no action shortcuts defined
    // but we want these shortcuts to still work)
    if (action_name=="data_save_row")
        return (k == Qt::Key_Return || k == Qt::Key_Enter) && e->state()==Qt::ShiftButton;
    if (action_name=="edit_delete_row")
        return k == Qt::Key_Delete && e->state()==Qt::ControlButton;
    if (action_name=="edit_delete")
        return k == Qt::Key_Delete && e->state()==Qt::NoButton;
    if (action_name=="edit_edititem")
        return k == Qt::Key_F2 && e->state()==Qt::NoButton;
    if (action_name=="edit_insert_empty_row")
        return k == Qt::Key_Insert && e->state()==(Qt::ShiftButton | Qt::ControlButton);

    return false;
}

void KexiTableView::keyPressEvent(QKeyEvent* e)
{
    if (!hasData())
        return;
//  kexidbg << "KexiTableView::keyPressEvent: key=" <<e->key() << " txt=" <<e->text()<<endl;

    const int k = e->key();
    const bool ro = isReadOnly();
    QWidget *w = focusWidget();
//  if (!w || w!=viewport() && w!=this && (!m_editor || w!=m_editor->view() && w!=m_editor)) {
//  if (!w || w!=viewport() && w!=this && (!m_editor || w!=m_editor->view())) {
    if (!w || w!=viewport() && w!=this && (!m_editor || !KexiUtils::hasParent(dynamic_cast<QObject*>(m_editor), w))) {
        //don't process stranger's events
        e->ignore();
        return;
    }
    if (d->skipKeyPress) {
        d->skipKeyPress=false;
        e->ignore();
        return;
    }
    
    if(m_curre