kexitableview.h

/* 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)
*/
 
#ifndef KEXITABLEVIEW_H
#define KEXITABLEVIEW_H
 
#include <tqscrollview.h>
#include <tqvariant.h>
#include <tqptrlist.h>
#include <tqheader.h>
#include <tqtooltip.h>
 
#include <kdebug.h>
 
#include "kexitableviewdata.h"
#include "kexitableedit.h"
#include <kexiutils/tristate.h>
#include <widget/utils/kexirecordnavigator.h>
#include <widget/utils/kexisharedactionclient.h>
#include "kexidataawareobjectiface.h"
 
class TDEPopupMenu;
class KPrinter;
class TDEAction;
 
class KexiTableHeader;
class KexiTableItem;
class KexiTableView;
class KexiTableEdit;
class KexiTableViewPrivate;
class TDEActionCollection;
 
namespace KexiDB {
    class RowEditBuffer;
}

#define KEXITV_MINIMUM_COLUMN_WIDTH 10


class KEXIDATATABLE_EXPORT KexiTableView :
    public TQScrollView,
    public KexiRecordNavigatorHandler,
    public KexiSharedActionClient,
    public KexiDataAwareObjectInterface
{
TQ_OBJECT
  
KEXI_DATAAWAREOBJECTINTERFACE
public:

    class KEXIDATATABLE_EXPORT Appearance {
    public:
        Appearance(TQWidget *widget = 0);

        TQColor baseColor;

        TQColor textColor;

        TQColor borderColor;

        TQColor emptyAreaColor;

        TQColor alternateBackgroundColor;

        bool backgroundAltering : 1;

        bool fullRowSelection : 1;

        bool gridEnabled : 1;

        bool navigatorEnabled : 1;

        bool rowHighlightingEnabled : 1;

        bool rowMouseOverHighlightingEnabled : 1;

        bool persistentSelections : 1;

        TQColor rowHighlightingColor;

        TQColor rowHighlightingTextColor;

        TQColor rowMouseOverHighlightingColor;

        TQColor rowMouseOverHighlightingTextColor;

        TQColor rowMouseOverAlternateHighlightingColor;
    };
    
    KexiTableView(KexiTableViewData* data=0, TQWidget* parent=0, const char* name=0);
    virtual ~KexiTableView();

    const Appearance& appearance() const;

    void setAppearance(const Appearance& a);

    TQString columnCaption(int colNum) const;

    KexiDB::Field* field(int colNum) const;

    virtual void setSpreadSheetMode();

//moved bool scrollbarToolTipsEnabled() const;

//moved void setScrollbarToolTipsEnabled(bool set);

    virtual int rowsPerPage() const;
 
    TQRect cellGeometry(int row, int col) const;
    int columnWidth(int col) const;
    int rowHeight() const;
    int columnPos(int col) const;
    int rowPos(int row) const;
    int columnAt(int pos) const;
    int rowAt(int pos, bool ignoreEnd=false) const;

    virtual int lastVisibleRow() const;

    virtual void updateCell(int row, int col);

    virtual void updateCurrentCell();

    virtual void updateRow(int row);
 
    bool editableOnDoubleClick() const;
    void setEditableOnDoubleClick(bool set);

    bool verticalHeaderVisible() const;

    void setVerticalHeaderVisible(bool set);

    bool horizontalHeaderVisible() const;

    void setHorizontalHeaderVisible(bool set);
 
#ifndef KEXI_NO_PRINT
    // printing
//  void        setupPrinter(KPrinter &printer);
    void        print(KPrinter &printer);
#endif
 
    // reimplemented for internal reasons
    virtual TQSizePolicy sizePolicy() const;
    virtual TQSize sizeHint() const;
    virtual TQSize minimumSizeHint() const;

    void setFont(const TQFont &f);
 
    virtual TQSize tableSize() const;
 
    void emitSelected();

    void triggerUpdate();
 
    enum ScrollDirection
    {
        ScrollUp,
        ScrollDown,
        ScrollLeft,
        ScrollRight
    };
 
    virtual bool eventFilter( TQObject *o, TQEvent *e );

    static void initCellEditorFactories();

    int highlightedRow() const;
 
    KexiTableItem *highlightedItem() const;

    virtual TQScrollBar* verticalScrollBar() const { return TQScrollView::verticalScrollBar(); }
 
public slots:
    virtual void setData( KexiTableViewData *data, bool owner = true )
        { KexiDataAwareObjectInterface::setData( data, owner ); }
 
    virtual void clearColumnsInternal(bool repaint);

    void adjustColumnWidthToContents(int colNum = -1);

    void setColumnWidth(int col, int width);

    void setColumnStretchEnabled( bool set, int colNum );

    void maximizeColumnsWidth( const TQValueList<int> &columnList );

    void adjustHorizontalHeaderSize();

    void setHighlightedRow(int row);

    inline void clearHighlightedRow() { setHighlightedRow(-1); }

    virtual void ensureCellVisible(int row, int col/*=-1*/);
 
//  void            gotoNext();
//js    int         findString(const TQString &string);
    
    virtual void deleteCurrentRow() { KexiDataAwareObjectInterface::deleteCurrentRow(); }

    virtual KexiTableItem *insertEmptyRow(int row = -1) 
        { return KexiDataAwareObjectInterface::insertEmptyRow(row); }

    virtual void startEditCurrentCell(const TQString& setText = TQString())
        { KexiDataAwareObjectInterface::startEditCurrentCell(setText); }

    virtual void deleteAndStartEditCurrentCell() 
        { KexiDataAwareObjectInterface::deleteAndStartEditCurrentCell(); }

    virtual bool cancelRowEdit() { return KexiDataAwareObjectInterface::cancelRowEdit(); }

    virtual bool acceptRowEdit() { return KexiDataAwareObjectInterface::acceptRowEdit(); }

    virtual void setAcceptsRowEditAfterCellAccepting(bool set) 
        { KexiDataAwareObjectInterface::setAcceptsRowEditAfterCellAccepting(set); }

    virtual void setDropsAtRowEnabled(bool set) { KexiDataAwareObjectInterface::setDropsAtRowEnabled(set); }
 
    virtual bool cancelEditor() { return KexiDataAwareObjectInterface::cancelEditor(); }
    virtual bool acceptEditor() { return KexiDataAwareObjectInterface::acceptEditor(); }
 
signals:
    virtual void dataSet( KexiTableViewData *data );
 
    virtual void itemSelected(KexiTableItem *);
    virtual void cellSelected(int col, int row);
 
    void itemReturnPressed(KexiTableItem *, int row, int col);
    void itemDblClicked(KexiTableItem *, int row, int col);
    void itemMouseReleased(KexiTableItem *, int row, int col);
 
    void dragOverRow(KexiTableItem *item, int row, TQDragMoveEvent* e);
    void droppedAtRow(KexiTableItem *item, int row, TQDropEvent *e, KexiTableItem*& newItem);

    virtual void dataRefreshed();
 
    virtual void itemChanged(KexiTableItem *, int row, int col);
    virtual void itemChanged(KexiTableItem *, int row, int col, TQVariant oldValue);
    virtual void itemDeleteRequest(KexiTableItem *, int row, int col);
    virtual void currentItemDeleteRequest();
    virtual void newItemAppendedForAfterDeletingInSpreadSheetMode();
//  void addRecordRequest();
//  void contextMenuRequested(KexiTableItem *,  int row, int col, const TQPoint &);
    void sortedColumnChanged(int col);

    void rowEditStarted(int row);

    void rowEditTerminated(int row);

    void reloadActions();
 
protected slots:
    void slotSettingsChanged(int category);
 
    virtual void slotDataDestroying() { KexiDataAwareObjectInterface::slotDataDestroying(); }
 
    virtual void slotRowsDeleted( const TQValueList<int> & ); 

    void slotColumnWidthChanged( int col, int os, int ns );
 
    void slotSectionHandleDoubleClicked( int section );
 
    void slotUpdate();
    virtual void sortColumnInternal(int col, int order = 0)
        { KexiDataAwareObjectInterface::sortColumnInternal(col, order); }
 
    void slotAutoScroll();

    void slotTopHeaderSizeChange( int section, int oldSize, int newSize );

    void slotEditRequested();

    virtual void reloadData();

    virtual void slotRowRepaintRequested(KexiTableItem& item);

    virtual void slotAboutToDeleteRow(KexiTableItem& item, KexiDB::ResultInfo* result, bool repaint)
    { KexiDataAwareObjectInterface::slotAboutToDeleteRow(item, result, repaint); }

    virtual void slotRowDeleted() { KexiDataAwareObjectInterface::slotRowDeleted(); }

    virtual void slotRowInserted(KexiTableItem *item, bool repaint)
    { KexiDataAwareObjectInterface::slotRowInserted(item, repaint); }

    virtual void slotRowInserted(KexiTableItem *item, uint row, bool repaint)
    { KexiDataAwareObjectInterface::slotRowInserted(item, row, repaint); }

    virtual void vScrollBarValueChanged(int v) { KexiDataAwareObjectInterface::vScrollBarValueChanged(v); }

    virtual void vScrollBarSliderReleased() { KexiDataAwareObjectInterface::vScrollBarSliderReleased(); }

    virtual void scrollBarTipTimeout() { KexiDataAwareObjectInterface::scrollBarTipTimeout(); }
 
protected:
    virtual void initDataContents();

    virtual void updateWidgetContentsSize();

    virtual void clearVariables();

    virtual int currentLocalSortingOrder() const;

    virtual int currentLocalSortColumn() const;

    virtual void setLocalSortingOrder(int col, int order);

    virtual void updateGUIAfterSorting();

    virtual void updateWidgetScrollBars() { updateScrollBars(); }
 
//  /*! Implementation for KexiDataAwareObjectInterface */
//  virtual void emitSortedColumnChanged(int col) { emit sortedColumnChanged(col); }
 
//  /*! Implementation for KexiDataAwareObjectInterface */
//  virtual void emitRowEditTerminated(int row) { emit rowEditTerminated(row); }

    virtual void addHeaderColumn(const TQString& caption, const TQString& description, 
        const TQIconSet& icon, int size);

    bool isDefaultValueDisplayed(KexiTableItem *item, int col, TQVariant* value = 0);

    void drawContents(TQPainter *p, int cx, int cy, int cw, int ch);
    void createBuffer(int width, int height);
    void paintCell(TQPainter* p, KexiTableItem *item, int col, int row, const TQRect &cr, bool print=false);
    void paintEmptyArea(TQPainter *p, int cx, int cy, int cw, int ch);
    void updateGeometries();
 
    TQPoint contentsToViewport2( const TQPoint &p );
    void contentsToViewport2( int x, int y, int& vx, int& vy );
    TQPoint viewportToContents2( const TQPoint& vp );
 
    // event handling
    virtual void contentsMousePressEvent(TQMouseEvent* e);
    virtual void contentsMouseReleaseEvent(TQMouseEvent* e);
    bool handleContentsMousePressOrRelease(TQMouseEvent* e, bool release);
    virtual void contentsMouseMoveEvent(TQMouseEvent* e);
    virtual void contentsMouseDoubleClickEvent(TQMouseEvent* e);
    virtual void keyPressEvent(TQKeyEvent* e);
    virtual void focusInEvent(TQFocusEvent* e);
    virtual void focusOutEvent(TQFocusEvent* e);
    virtual void resizeEvent(TQResizeEvent* e);
    virtual void viewportResizeEvent(TQResizeEvent *e);
    virtual void showEvent(TQShowEvent *e);
    virtual void contentsDragMoveEvent(TQDragMoveEvent *e);
    virtual void contentsDropEvent(TQDropEvent *e);
    virtual void viewportDragLeaveEvent(TQDragLeaveEvent *e);
    virtual void paletteChange( const TQPalette &oldPalette );
    
    virtual KexiDataItemInterface *editor( int col, bool ignoreMissingEditor = false );
 
    inline KexiTableEdit *tableEditorWidget(  int col, bool ignoreMissingEditor = false )
    { return dynamic_cast<KexiTableEdit*>( editor( col, ignoreMissingEditor ) ); }

    virtual void editorShowFocus( int row, int col );

    virtual void createEditor(int row, int col, const TQString& addText = TQString(), 
        bool removeOld = false);
 
    bool focusNextPrevChild(bool next);

    bool shortCutPressed( TQKeyEvent *e, const TQCString &action_name );
 
#if 0 //we have now KexiActionProxy
    bool updateContextMenu();
#endif

    void showContextMenu( const TQPoint& pos = TQPoint(-1,-1) );

    inline void paintRow(KexiTableItem *item,
        TQPainter *pb, int r, int rowp, int cx, int cy, 
        int colfirst, int collast, int maxwc);
 
    virtual void setHBarGeometry( TQScrollBar & hbar, int x, int y, int w, int h );

    void setupNavigator();

    int validRowNumber(const TQString& text);

    virtual void removeEditor();

    void updateFonts(bool repaint = false);

    void setBottomMarginInternal(int pixels);
 
    virtual void updateWidgetContents() { update(); }

    virtual void moveToRecordRequested(uint r);
    virtual void moveToLastRecordRequested();
    virtual void moveToPreviousRecordRequested();
    virtual void moveToNextRecordRequested();
    virtual void moveToFirstRecordRequested();
    virtual void addNewRecordRequested() { KexiDataAwareObjectInterface::addNewRecordRequested(); }

    virtual void copySelection();

    virtual void cutSelection();

    virtual void paste();

    virtual void updateAllVisibleRowsBelow(int row);
 
    void updateAfterCancelRowEdit();
    void updateAfterAcceptRowEdit();

    bool getVisibleLookupValue(TQVariant& cellValue, KexiTableEdit *edit, 
        KexiTableItem *item, KexiTableViewColumn *tvcol) const;
 
//  //! Called to repaint contents after a row is deleted.
//  void repaintAfterDelete();
 
    KexiTableViewPrivate *d;
 
    class WhatsThis;
    friend class KexiTableItem;
    friend class WhatsThis;
    friend class KexiTableViewCellToolTip;
};
 
#endif