kexidataawareobjectiface.h

/* 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.
*/
 
#ifndef KEXIDATAAWAREOBJECTINTERFACE_H
#define KEXIDATAAWAREOBJECTINTERFACE_H
 
#include <tqguardedptr.h>
 
#include <tqtimer.h>
#include <kdebug.h>
#include <widget/utils/kexiarrowtip.h>
#include <kexisearchandreplaceiface.h> 
#include "kexitableviewdata.h"
 
class TQObject;
class TQScrollBar;
class TDEPopupMenu;
class KexiTableItem;
class KexiTableViewData;
class KexiRecordMarker;
class KexiTableViewHeader;
class KexiRecordNavigator;
#include <kexidataiteminterface.h>
 
namespace KexiDB {
    class RowEditBuffer;
}

#define KEXI_DEFAULT_DATA_COLUMN_WIDTH 120


class KEXIDATATABLE_EXPORT KexiDataAwareObjectInterface
{
    public:
        KexiDataAwareObjectInterface();
        virtual ~KexiDataAwareObjectInterface();

        void setData( KexiTableViewData *data, bool owner = true );

        inline KexiTableViewData *data() const { return m_data; }

        inline int currentColumn() const { return m_curCol; }

        inline int currentRow() const { return m_curRow; }

        virtual int lastVisibleRow() const = 0;

        KexiTableItem *selectedItem() const { return m_currentItem; }

        int rows() const;

        virtual int columns() const { return dataColumns(); }

        int dataColumns() const;

        virtual bool isReadOnly() const;

        void setReadOnly(bool set);

        inline bool isSortingEnabled() const { return m_isSortingEnabled; }

        virtual void setSorting(int col, bool ascending=true);

        virtual void setSortingEnabled(bool set);

        int dataSortedColumn() const;

        int dataSortingOrder() const;

        virtual bool sort();

        void sortAscending();

        void sortDescending();

        virtual bool isInsertingEnabled() const;

        void setInsertingEnabled(bool set);

        bool isDeleteEnabled() const;

        bool isEmptyRowInsertingEnabled() const { return m_emptyRowInsertingEnabled; }

        void setEmptyRowInsertingEnabled(bool set);

        virtual void setFilteringEnabled(bool set);

        inline bool isFilteringEnabled() const { return m_isFilteringEnabled; }

        virtual void setSpreadSheetMode();

        bool spreadSheetMode() const { return m_spreadSheetMode; }

        inline bool rowEditing() const { return m_rowEditing; }
 
        enum DeletionPolicy
        {
            NoDelete = 0,
            AskDelete = 1,
            ImmediateDelete = 2,
            SignalDelete = 3
        };

        DeletionPolicy deletionPolicy() const { return m_deletionPolicy; }
 
        virtual void setDeletionPolicy(DeletionPolicy policy);

        virtual void deleteCurrentRow();

        virtual KexiTableItem *insertEmptyRow(int row = -1);

        virtual bool beforeDeleteItem(KexiTableItem *item);

        bool deleteItem(KexiTableItem *item);//, bool moveCursor=true);

        void insertItem(KexiTableItem *newItem, int row = -1);

        tristate deleteAllRows(bool ask = false, bool repaint = true);

        virtual int rowsPerPage() const = 0;
 
        virtual void selectRow(int row);
        virtual void selectNextRow();
        virtual void selectPrevRow();
        virtual void selectNextPage(); 
        virtual void selectPrevPage(); 
        virtual void selectFirstRow();
        virtual void selectLastRow();
        virtual void addNewRecordRequested();

        virtual void clearSelection();

        virtual void setCursorPosition(int row, int col = -1, bool forceSet = false);

        virtual void ensureCellVisible(int row, int col/*=-1*/) = 0;

        virtual void setAcceptsRowEditAfterCellAccepting(bool set);

        bool acceptsRowEditAfterCellAccepting() const { return m_acceptsRowEditAfterCellAccepting; }

        bool dropsAtRowEnabled() const { return m_dropsAtRowEnabled; }

        virtual void setDropsAtRowEnabled(bool set);

        inline KexiDataItemInterface *editor() const { return m_editor; }

        virtual bool cancelRowEdit();

        virtual bool acceptRowEdit();
 
        virtual void removeEditor();

        virtual bool cancelEditor();

        virtual bool acceptEditor();

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

        virtual void startEditCurrentCell(const TQString& setText = TQString());

        virtual void deleteAndStartEditCurrentCell();
 
        inline KexiTableItem *itemAt(int row) const;

        virtual KexiTableViewColumn* column(int col);

        virtual int fieldNumberForColumn(int col) { return col; }
 
        bool hasDefaultValueAt(const KexiTableViewColumn& tvcol);
 
        const TQVariant* bufferedValueAt(int col, bool useDefaultValueIfPossible = true);

        int columnType(int col);

        TQVariant columnDefaultValue(int col) const;

        virtual bool columnEditable(int col);

        virtual void updateCurrentCell() = 0;
 
        inline KexiRecordMarker* verticalHeader() const { return m_verticalHeader; }

        virtual void itemChanged(KexiTableItem *, int row, int col) = 0;
        virtual void itemChanged(KexiTableItem *, int row, int col, TQVariant oldValue) = 0;
        virtual void itemDeleteRequest(KexiTableItem *, int row, int col) = 0;
        virtual void currentItemDeleteRequest() = 0;
        virtual void newItemAppendedForAfterDeletingInSpreadSheetMode() = 0;

        virtual void dataRefreshed() = 0;
        virtual void dataSet( KexiTableViewData *data ) = 0;

        TDEPopupMenu* contextMenu() const { return m_popupMenu; }

        bool contextMenuEnabled() const { return m_contextMenuEnabled; }

        void setContextMenuEnabled(bool set) { m_contextMenuEnabled = set; }

        bool scrollbarToolTipsEnabled() const;

        void setScrollbarToolTipsEnabled(bool set);

        void startEditOrToggleValue();

        inline bool newRowEditing() const { return m_newRowEditing; }

        virtual void boolToggled();
 
        virtual void connectCellSelectedSignal(const TQObject* receiver, 
            const char* intIntMember) = 0;
 
        virtual void connectRowEditStartedSignal(const TQObject* receiver, 
            const char* intMember) = 0;
 
        virtual void connectRowEditTerminatedSignal(const TQObject* receiver, 
            const char* voidMember) = 0;
 
        virtual void connectReloadActionsSignal(const TQObject* receiver, 
            const char* voidMember) = 0;
 
        virtual void connectDataSetSignal(const TQObject* receiver, 
            const char* kexiTableViewDataMember) = 0;
 
        virtual void connectToReloadDataSlot(const TQObject* sender, 
            const char* voidSignal) = 0;
 
        virtual void slotDataDestroying();

        virtual void copySelection() = 0;

        virtual void cutSelection() = 0;

        virtual void paste() = 0;

        virtual tristate find(const TQVariant& valueToFind, 
            const KexiSearchAndReplaceViewInterface::Options& options, bool next);

        virtual tristate findNextAndReplace(const TQVariant& valueToFind, 
            const TQVariant& replacement, 
            const KexiSearchAndReplaceViewInterface::Options& options, bool replaceAll);

        virtual TQScrollBar* verticalScrollBar() const = 0;

        virtual bool handleKeyPress(TQKeyEvent *e, int &curRow, int &curCol, bool fullRowSelection,
            bool *moveToFirstField = 0, bool *moveToLastField = 0);
 
    protected:
        virtual void initDataContents();

        virtual void clearColumns(bool repaint = true);

        virtual void clearColumnsInternal(bool repaint) = 0;

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

        virtual int currentLocalSortingOrder() const = 0;

        virtual int currentLocalSortColumn() const = 0;

        virtual void setLocalSortingOrder(int col, int order) = 0;

        virtual void sortColumnInternal(int col, int order = 0);

        virtual void updateGUIAfterSorting() = 0;

        virtual void reloadActions() = 0;

        virtual void reloadData();

        virtual void itemSelected(KexiTableItem *) = 0;

        virtual void cellSelected(int col, int row) = 0;

        virtual void sortedColumnChanged(int col) = 0;

        virtual void rowEditTerminated(int row) = 0;

        virtual void clearVariables();

        virtual KexiDataItemInterface *editor( int col, bool ignoreMissingEditor = false ) = 0;

        virtual void editorShowFocus( int row, int col ) = 0;

        virtual void updateCell(int row, int col) = 0;

        virtual void updateRow(int row) = 0;

        virtual void updateWidgetContents() = 0;

        virtual void updateWidgetContentsSize() = 0;

        virtual void updateWidgetScrollBars() = 0;

        virtual void updateAfterCancelRowEdit();

        virtual void updateAfterAcceptRowEdit();

        virtual void slotRowRepaintRequested(KexiTableItem& item) { Q_UNUSED( item ); }

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

        virtual void slotRowDeleted();

        virtual void slotRowInserted(KexiTableItem *item, bool repaint);

        virtual void slotRowInserted(KexiTableItem *item, uint row, bool repaint);
 
        virtual void slotRowsDeleted( const TQValueList<int> & ) {}

        inline bool hasData() const;

        virtual void selectCellInternal() {}

        virtual void updateAllVisibleRowsBelow(int row) { Q_UNUSED( row ); }

        virtual void focusOutEvent(TQFocusEvent* e);

        virtual void vScrollBarValueChanged(int v);

        virtual void vScrollBarSliderReleased();

        virtual void scrollBarTipTimeout();

        int showErrorMessageForResult(KexiDB::ResultInfo* resultInfo);

        void updateIndicesForVisibleValues();

        KexiTableViewData *m_data;

        bool m_owner : 1;

        int m_curRow, m_curCol;

        KexiTableItem *m_currentItem;

        KexiTableViewData::Iterator *m_itemIterator;

        KexiTableItem *m_insertItem;

//      KexiDB::RowEditBuffer *m_rowEditBuffer; 

        bool m_rowEditing : 1;

        bool m_newRowEditing : 1;

        bool m_isSortingEnabled : 1;

        bool m_isFilteringEnabled : 1;

        bool m_acceptsRowEditAfterCellAccepting : 1;

        bool m_inside_acceptEditor : 1;

        bool m_internal_acceptsRowEditAfterCellAccepting : 1;

        bool m_emptyRowInsertingEnabled : 1;

        int m_readOnly;


        bool m_contentsMousePressEvent_dblClick : 1;

        int m_insertingEnabled;

        bool m_initDataContentsOnShow : 1;

        bool m_cursorPositionSetExplicityBeforeShow : 1;

        bool m_spreadSheetMode : 1;

        bool m_dropsAtRowEnabled : 1;

        bool m_updateEntireRowWhenMovingToOtherRow : 1;
 
        DeletionPolicy m_deletionPolicy;

        KexiRecordMarker *m_verticalHeader;

        KexiTableViewHeader *m_horizontalHeader;
 
        KexiDataItemInterface *m_editor;
//      KexiTableEdit *m_editor;

        KexiRecordNavigator *m_navPanel; 
 
        bool m_navPanelEnabled : 1;

        bool m_verticalHeaderAlreadyAdded : 1;

        int m_dragIndicatorLine;

        TDEPopupMenu *m_popupMenu;
 
        bool m_contextMenuEnabled : 1;

        bool m_alsoUpdateNextRow : 1;

        int m_rowWillBeDeleted;

        TQGuardedPtr<KexiArrowTip> m_errorMessagePopup;

        bool m_vScrollBarValueChanged_enabled : 1;

        bool m_scrollbarToolTipsEnabled : 1;
 
        TQLabel* m_scrollBarTip; 
        TQTimer m_scrollBarTipTimer; 
        uint m_scrollBarTipTimerCnt; 

        class PositionOfValue {
            public:
                PositionOfValue() : firstCharacter(0), lastCharacter(0), exists(false)
                {}
            uint firstCharacter;
            uint lastCharacter;
            bool exists : 1;
        };

        PositionOfValue m_positionOfRecentlyFoundValue;

        TQVariant m_recentlySearchedValue;

        KexiSearchAndReplaceViewInterface::Options::SearchDirection m_recentSearchDirection;

        TQValueVector<uint> m_indicesForVisibleValues;
};
 
inline bool KexiDataAwareObjectInterface::hasData() const
{
    if (!m_data)
        kdDebug() << "KexiDataAwareObjectInterface: No data assigned!" << endl;
    return m_data!=0;
}
 
inline KexiTableItem *KexiDataAwareObjectInterface::itemAt(int row) const
{
    KexiTableItem *item = m_data->at(row);
    if (!item)
        kdDebug() << "KexiTableView::itemAt(" << row << "): NO ITEM!!" << endl;
    else {
/*      kdDebug() << "KexiTableView::itemAt(" << row << "):" << endl;
        int i=1;
        for (KexiTableItem::Iterator it = item->begin();it!=item->end();++it,i++)
            kdDebug() << i<<": " << (*it).toString()<< endl;*/
    }
    return item;
}

#define KEXI_DATAAWAREOBJECTINTERFACE \
public: \
    void connectCellSelectedSignal(const TQObject* receiver, const char* intIntMember) { \
        connect(this, TQ_SIGNAL(cellSelected(int,int)), receiver, intIntMember); \
    } \
    void connectRowEditStartedSignal(const TQObject* receiver, const char* intMember) { \
        connect(this, TQ_SIGNAL(rowEditStarted(int)), receiver, intMember); \
    } \
    void connectRowEditTerminatedSignal(const TQObject* receiver, const char* voidMember) { \
        connect(this, TQ_SIGNAL(rowEditTerminated(int)), receiver, voidMember); \
    } \
    void connectReloadActionsSignal(const TQObject* receiver, const char* voidMember) { \
        connect(this, TQ_SIGNAL(reloadActions()), receiver, voidMember); \
    } \
    void connectDataSetSignal(const TQObject* receiver, \
        const char* kexiTableViewDataMember) { \
        connect(this, TQ_SIGNAL(dataSet(KexiTableViewData*)), receiver, kexiTableViewDataMember); \
    } \
    void connectToReloadDataSlot(const TQObject* sender, const char* voidSignal) { \
        connect(sender, voidSignal, this, TQ_SLOT(reloadData())); \
    }
 
#endif