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