kexitableviewdata.h

/* This file is part of the KDE project
   Copyright (C) 2002   Lucijan Busch <lucijan@gmx.at>
   Copyright (C) 2003   Daniel Molkentin <molkentin@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 KEXITABLEVIEWDATA_H
#define KEXITABLEVIEWDATA_H
 
#include <tqptrlist.h>
#include <tqvariant.h>
#include <tqvaluevector.h>
#include <tqstring.h>
#include <tqobject.h>
 
#include "kexitableitem.h"
 
#include <kexidb/error.h>
 
namespace KexiDB {
class Field;
class QuerySchema;
class RowEditBuffer;
class Cursor;
}
 
namespace KexiUtils {
class Validator;
}
class KexiTableViewData;
 

class KEXIDATATABLE_EXPORT KexiTableViewColumn {
    public:
        typedef TQPtrList<KexiTableViewColumn> List;
        typedef TQPtrListIterator<KexiTableViewColumn> ListIterator;

        KexiTableViewColumn(KexiDB::Field& f, bool owner = false);

        KexiTableViewColumn(const TQString& name, KexiDB::Field::Type ctype,
            uint cconst = KexiDB::Field::NoConstraints,
            uint options = KexiDB::Field::NoOptions,
            uint length=0, uint precision=0,
            TQVariant defaultValue=TQVariant(),
            const TQString& caption = TQString(),
            const TQString& description = TQString(),
            uint width = 0);

        KexiTableViewColumn(const TQString& name, KexiDB::Field::Type ctype, const TQString& caption,
            const TQString& description = TQString());

        KexiTableViewColumn(const KexiDB::QuerySchema &query, KexiDB::QueryColumnInfo& aColumnInfo,
            KexiDB::QueryColumnInfo* aVisibleLookupColumnInfo = 0);
 
        virtual ~KexiTableViewColumn();
 
        virtual bool acceptsFirstChar(const TQChar& ch) const;

        bool isReadOnly() const;
 
//TODO: synchronize this with table view:
        inline void setReadOnly(bool ro) { m_readOnly=ro; }

        inline bool visible() const { return columnInfo ? columnInfo->visible : m_visible; }

        inline void setVisible(bool v) {
            if (columnInfo)
                columnInfo->visible = v;
            m_visible=v; 
        }

        void setIcon(const TQIconSet& icon) { m_icon = icon; }

        TQIconSet icon() const { return m_icon; }

        void setHeaderTextVisible(bool visible) { m_headerTextVisible = visible; }

        bool isHeaderTextVisible() const { return m_headerTextVisible; }

        inline TQString captionAliasOrName() const { return m_captionAliasOrName; }

        void setValidator( KexiUtils::Validator* v );

        inline KexiUtils::Validator* validator() const { return m_validator; }

        void setRelatedData(KexiTableViewData *data);

        inline KexiTableViewData *relatedData() const { return m_relatedData; }

        inline KexiDB::Field* field() const { return m_field; }

        void setRelatedDataEditable(bool set);

        inline bool relatedDataEditable() const { return m_relatedDataEditable; }

        KexiDB::QueryColumnInfo* columnInfo;

        KexiDB::QueryColumnInfo* visibleLookupColumnInfo;
 
        bool isDBAware : 1; 
 
/*      TQString caption;
        int type; //!< one of KexiDB::Field::Type
        uint width;
*/
//      bool isNull() const;
        
/*      virtual TQString caption() const;
        virtual void setCaption(const TQString& c);
    */  
    protected:
        KexiTableViewColumn(bool);
 
        void init();
 
        TQString m_captionAliasOrName;
 
        TQIconSet m_icon;
 
        KexiUtils::Validator* m_validator;

        KexiTableViewData* m_data;
 
        KexiTableViewData* m_relatedData;
        uint m_relatedDataPKeyID;
 
        KexiDB::Field* m_field;
 
        bool m_readOnly : 1;
        bool m_fieldOwned : 1;
        bool m_visible : 1;
        bool m_relatedDataEditable : 1;
        bool m_headerTextVisible : 1;
        
    friend class KexiTableViewData;
};
 

//typedef TQValueVector<KexiTableViewColumn> KexiTableViewColumnList;
 
typedef TQPtrList<KexiTableItem> KexiTableViewDataBase;

class KEXIDATATABLE_EXPORT KexiTableViewData : public TQObject, protected KexiTableViewDataBase
{
    TQ_OBJECT
  
 
public: 
    typedef TQPtrListIterator<KexiTableItem> Iterator;

    KexiTableViewData();

    KexiTableViewData(KexiDB::Cursor *c);
 
//TODO: make this more generic: allow to add more columns!
    KexiTableViewData(
        const TQValueList<TQVariant> &keys, const TQValueList<TQVariant> &values,
        KexiDB::Field::Type keyType = KexiDB::Field::Text, 
        KexiDB::Field::Type valueType = KexiDB::Field::Text);

    KexiTableViewData(KexiDB::Field::Type keyType, KexiDB::Field::Type valueType);
 
    virtual ~KexiTableViewData();
//js    void setSorting(int key, bool order=true, short type=1);

    void preloadAllRows();

    void setSorting(int column, bool ascending=true);

    inline int sortedColumn() const { return m_sortedColumn; }

    inline int sortingOrder() const { return m_order; }

    void addColumn( KexiTableViewColumn* col );
 
    inline int globalColumnID(int visibleID) { return m_globalColumnsIDs.at( visibleID ); }
    inline int visibleColumnID(int globalID) { return m_visibleColumnsIDs.at( globalID ); }
 
    /*virtual?*/
    inline bool isDBAware() { return m_cursor; }

    TQString dbTableName() const;
 
    inline KexiDB::Cursor* cursor() const { return m_cursor; }
 
    inline uint columnsCount() const { return columns.count(); }
 
    inline KexiTableViewColumn* column(uint c) { return columns.at(c); }

    KexiTableViewColumn::List columns;

    virtual bool isReadOnly() const;

    virtual void setReadOnly(bool set);

    virtual bool isInsertingEnabled() const { return m_insertingEnabled; }

    virtual void setInsertingEnabled(bool set);

    void clearRowEditBuffer();

    bool updateRowEditBufferRef(KexiTableItem *item, 
        int colnum, KexiTableViewColumn* col, TQVariant& newval, bool allowSignals = true,
        TQVariant *visibleValueForLookupField = 0);

    inline bool updateRowEditBuffer(KexiTableItem *item, int colnum, KexiTableViewColumn* col, 
        TQVariant newval, bool allowSignals = true)
    {
        TQVariant newv(newval);
        return updateRowEditBufferRef(item, colnum, col, newv, allowSignals);
    }

    inline bool updateRowEditBuffer(KexiTableItem *item, int colnum, 
        TQVariant newval, bool allowSignals = true)
    {
        KexiTableViewColumn* col = columns.at(colnum);
        return col ? updateRowEditBufferRef(item, colnum, col, newval, allowSignals) : false;
    }
 
    inline KexiDB::RowEditBuffer* rowEditBuffer() const { return m_pRowEditBuffer; }

    inline KexiDB::ResultInfo* result() { return &m_result; }
 
    bool saveRowChanges(KexiTableItem& item, bool repaint = false);
 
    bool saveNewRow(KexiTableItem& item, bool repaint = false);
 
    bool deleteRow(KexiTableItem& item, bool repaint = false);

    void deleteRows( const TQValueList<int> &rowsToDelete, bool repaint = false );

    virtual bool deleteAllRows(bool repaint = false);

    virtual void clearInternal();

    void insertRow(KexiTableItem& item, uint index, bool repaint = false);
 
/*TODO: add this as well? 
    void insertRow(KexiTableItem& item, KexiTableItem& aboveItem); */

    int autoIncrementedColumn();

    void reload() { emit reloadRequested(); }
 
    inline KexiTableItem* at( uint index ) { return KexiTableViewDataBase::at(index); }
    inline virtual uint count() const { return KexiTableViewDataBase::count(); }
    inline bool isEmpty () const { return KexiTableViewDataBase::isEmpty(); }
    inline KexiTableItem* first() { return KexiTableViewDataBase::first(); }
    inline KexiTableItem* last() { return KexiTableViewDataBase::last(); }
    inline int findRef( const KexiTableItem* item ) { return KexiTableViewDataBase::findRef(item); }
    inline void sort() { KexiTableViewDataBase::sort(); }
    inline bool removeFirst() { return KexiTableViewDataBase::removeFirst(); }
    inline bool removeLast() { return KexiTableViewDataBase::removeLast(); }
    inline void append( const KexiTableItem* item ) { KexiTableViewDataBase::append(item); }
    inline void prepend( const KexiTableItem* item ) { KexiTableViewDataBase::prepend(item); }
    inline Iterator iterator() { return Iterator(*this); }
    inline Iterator* createIterator() { return new Iterator(*this); }

    inline bool containsROWIDInfo() const { return m_containsROWIDInfo; }
 
    inline KexiTableItem* createItem() const
    { return new KexiTableItem(m_itemSize); }
 
public slots:
    void deleteLater();
 
signals:
    void destroying();

    void aboutToChangeCell(KexiTableItem *item, int colnum, TQVariant& newValue,
        KexiDB::ResultInfo* result);

    void aboutToInsertRow(KexiTableItem *item, KexiDB::ResultInfo* result, bool repaint);

    void aboutToUpdateRow(KexiTableItem *item, KexiDB::RowEditBuffer* buffer,
        KexiDB::ResultInfo* result);
 
    void rowUpdated(KexiTableItem*); 
 
    void rowInserted(KexiTableItem*, bool repaint); 

    void rowInserted(KexiTableItem*, uint index, bool repaint);

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

    void rowDeleted(); 

    void rowsDeleted( const TQValueList<int> &rowsToDelete );

    void reloadRequested();
 
    void rowRepaintRequested(KexiTableItem&);
 
protected:
    void init();
    void init(
        const TQValueList<TQVariant> &keys, const TQValueList<TQVariant> &values,
        KexiDB::Field::Type keyType, KexiDB::Field::Type valueType);
 
    virtual int compareItems(Item item1, Item item2);
    int cmpStr(Item item1, Item item2);
    int cmpInt(Item item1, Item item2);
    int cmpUInt(Item item1, Item item2);
    int cmpLongLong(Item item1, Item item2);
    int cmpULongLong(Item item1, Item item2);
    int cmpDouble(Item item1, Item item2);
    int cmpDate(Item item1, Item item2);
    int cmpDateTime(Item item1, Item item2);
    int cmpTime(Item item1, Item item2);

    int cmpBLOB(Item item1, Item item2);

    bool saveRow(KexiTableItem& item, bool insert, bool repaint);

    int m_sortedColumn;
    int m_realSortedColumn;
    short m_order;
    short m_type;
    int m_itemSize;
    static unsigned short charTable[];
    KexiDB::RowEditBuffer *m_pRowEditBuffer;
    TQGuardedPtr<KexiDB::Cursor> m_cursor;

//  TQDict<KexiTableViewColumn> *m_simpleColumnsByName;
 
    KexiDB::ResultInfo m_result;
 
    uint m_visibleColumnsCount;
    TQValueVector<int> m_visibleColumnsIDs, m_globalColumnsIDs;
 
    bool m_readOnly : 1;
    bool m_insertingEnabled : 1;

    bool m_inside_acceptEditor : 1;

    bool m_containsROWIDInfo : 1;
 
    int m_autoIncrementedColumn;
 
    int (KexiTableViewData::*cmpFunc)(void *, void *);

    TQVariant m_leftTmp, m_rightTmp;
};
 
#endif