Added old abandoned KDE3 version of koffice

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 540 insertions, 0 deletions

diff --git a/kexi/widget/tableview/kexitableviewdata.h b/kexi/widget/tableview/kexitableviewdata.h
new file mode 100644
index 00000000..970d1d23
--- /dev/null
+++ b/kexi/widget/tableview/kexitableviewdata.h
@@ -0,0 +1,540 @@
+/* This file is part of the KDE project
+   Copyright (C) 2002   Lucijan Busch <[email protected]>
+   Copyright (C) 2003   Daniel Molkentin <[email protected]>
+   Copyright (C) 2003-2006 Jaroslaw Staniek <[email protected]>
+
+   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 <[email protected]>
+   Original Project: buX (www.bux.at)
+*/
+
+#ifndef KEXITABLEVIEWDATA_H
+#define KEXITABLEVIEWDATA_H
+
+#include <qptrlist.h>
+#include <qvariant.h>
+#include <qvaluevector.h>
+#include <qstring.h>
+#include <qobject.h>
+
+#include "kexitableitem.h"
+
+#include <kexidb/error.h>
+
+namespace KexiDB {
+class Field;
+class QuerySchema;
+class RowEditBuffer;
+class Cursor;
+}
+
+namespace KexiUtils {
+class Validator;
+}
+class KexiTableViewData;
+
+
+/*! Single column definition. */
+class KEXIDATATABLE_EXPORT KexiTableViewColumn {
+	public:
+		typedef QPtrList<KexiTableViewColumn> List;
+		typedef QPtrListIterator<KexiTableViewColumn> ListIterator;
+
+		/*! Not db-aware ctor. if \a owner is true, the field \a will be owned by this column,
+		 so you shouldn't care about destroying this field. */
+		KexiTableViewColumn(KexiDB::Field& f, bool owner = false);
+
+		/*! Not db-aware, convenience ctor, like above. The field is created using specified parameters that are 
+		 equal to these accepted by KexiDB::Field ctor. The column will be the owner 
+		 of this automatically generated field.
+		 */
+		KexiTableViewColumn(const QString& name, KexiDB::Field::Type ctype,
+			uint cconst = KexiDB::Field::NoConstraints,
+			uint options = KexiDB::Field::NoOptions,
+			uint length=0, uint precision=0,
+			QVariant defaultValue=QVariant(),
+			const QString& caption = QString::null,
+			const QString& description = QString::null,
+			uint width = 0);
+
+		/*! Not db-aware, convenience ctor, simplified version of the above. */
+		KexiTableViewColumn(const QString& name, KexiDB::Field::Type ctype, const QString& caption,
+			const QString& description = QString::null);
+
+		//! Db-aware version.
+		KexiTableViewColumn(const KexiDB::QuerySchema &query, KexiDB::QueryColumnInfo& aColumnInfo,
+			KexiDB::QueryColumnInfo* aVisibleLookupColumnInfo = 0);
+
+		virtual ~KexiTableViewColumn();
+
+		virtual bool acceptsFirstChar(const QChar& ch) const;
+
+		/*! \return true if the column is read-only
+		 For db-aware column this can depend on whether the column 
+		 is in parent table of this query. \sa setReadOnly() */
+		bool isReadOnly() const;
+
+//TODO: synchronize this with table view:
+		//! forces readOnly flag to be set to \a ro
+		inline void setReadOnly(bool ro) { m_readOnly=ro; }
+
+		//! Column visibility. By default column is visible.
+		inline bool visible() const { return columnInfo ? columnInfo->visible : m_visible; }
+
+		//! Changes column visibility.
+		inline void setVisible(bool v) {
+			if (columnInfo)
+				columnInfo->visible = v;
+			m_visible=v; 
+		}
+
+		/*! Sets icon for displaying in the caption area (header). */
+		void setIcon(const QIconSet& icon) { m_icon = icon; }
+
+		/*! \return bame of icon displayed in the caption area (header). */
+		QIconSet icon() const { return m_icon; }
+
+		/*! If \a visible is true, caption has to be displayed in the column's header,
+		 (or field's name if caption is empty. True by default. */
+		void setHeaderTextVisible(bool visible) { m_headerTextVisible = visible; }
+
+		/*! \return true if caption has to be displayed in the column's header,
+		 (or field's name if caption is empty. */
+		bool isHeaderTextVisible() const { return m_headerTextVisible; }
+
+		/*! \return whatever is available: 
+		 - field's caption
+		 - or field's alias (from query)
+		 - or finally - field's name */
+		inline QString captionAliasOrName() const { return m_captionAliasOrName; }
+
+		/*! Assigns validator \a v for this column. 
+		 If the validator has no parent object, it will be owned by the column, 
+		 so you shouldn't care about destroying it. */
+		void setValidator( KexiUtils::Validator* v );
+
+		//! \return validator assigned for this column of 0 if there is no validator assigned.
+		inline KexiUtils::Validator* validator() const { return m_validator; }
+
+		/*! For not-db-aware data only:
+		 Sets related data \a data for this column, what defines simple one-field, 
+		 one-to-many relationship between this column and the primary key in \a data. 
+		 The relationship will be used to generate a popup editor instead of just regular editor.
+		 This assignment has no result if \a data has no primary key defined.
+		 \a data is owned, so is will be destroyed when needed. It is also destroyed
+		 when another data (or NULL) is set for the same column. */
+		void setRelatedData(KexiTableViewData *data);
+
+		/*! For not-db-aware data only:
+		 Related data \a data for this column, what defines simple one-field. 
+		 NULL by default. \sa setRelatedData() */
+		inline KexiTableViewData *relatedData() const { return m_relatedData; }
+
+		/*! \return field for this column. 
+		 For db-aware information is taken from \a columnInfo member. */
+		inline KexiDB::Field* field() const { return m_field; }
+
+		/*! Only usable if related data is set (ie. this is for combo boxes).
+		 Sets 'editable' flag for this column, what means a new value can be entered
+		 by hand. This is similar to QComboBox::setEditable(). */
+		void setRelatedDataEditable(bool set);
+
+		/*! Only usable if related data is set (ie. this is for combo boxes).
+		 \return 'editable' flag for this column. 
+		 False by default. @see setRelatedDataEditable(bool). */
+		inline bool relatedDataEditable() const { return m_relatedDataEditable; }
+
+		/*! A rich field information for db-aware data. 
+		 For not-db-aware data it is always 0 (use field() instead). */
+		KexiDB::QueryColumnInfo* columnInfo;
+
+		/*! A rich field information for db-aware data. Specifies information for a column
+		 that should be visible instead of columnInfo. For example case see 
+		 @ref KexiDB::QueryColumnInfo::Vector KexiDB::QuerySchema::fieldsExpanded(KexiDB::QuerySchema::FieldsExpandedOptions options = Default)
+
+		 For not-db-aware data it is always 0. */
+		KexiDB::QueryColumnInfo* visibleLookupColumnInfo;
+
+		bool isDBAware : 1; //!< true if data is stored in DB, not only in memeory
+
+/*		QString caption;
+		int type; //!< one of KexiDB::Field::Type
+		uint width;
+*/
+//		bool isNull() const;
+		
+/*		virtual QString caption() const;
+		virtual void setCaption(const QString& c);
+	*/	
+	protected:
+		//! special ctor that do not allocate d member;
+		KexiTableViewColumn(bool);
+
+		void init();
+
+		QString m_captionAliasOrName;
+
+		QIconSet m_icon;
+
+		KexiUtils::Validator* m_validator;
+
+		//! Data that this column is assigned to.
+		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;
+};
+
+
+/*! List of column definitions. */
+//typedef QValueVector<KexiTableViewColumn> KexiTableViewColumnList;
+
+typedef QPtrList<KexiTableItem> KexiTableViewDataBase;
+
+/*! Reimplements QPtrList to allow configurable sorting and more.
+	Original author: Till Busch.
+	Reimplemented by Jaroslaw Staniek.
+*/
+class KEXIDATATABLE_EXPORT KexiTableViewData : public QObject, protected KexiTableViewDataBase
+{
+	Q_OBJECT
+
+public: 
+	typedef QPtrListIterator<KexiTableItem> Iterator;
+
+	//! not db-aware version
+	KexiTableViewData();
+
+	//! db-aware version
+	KexiTableViewData(KexiDB::Cursor *c);
+
+//TODO: make this more generic: allow to add more columns!
+	/*! Defines two-column table usually used with comboboxes.
+	 First column is invisible and contains key values.
+	 Second column and contains user-visible value.
+	 @param keys a list of keys
+	 @param values a list of text values (must be of the same length as keys list)
+	 @param keyType a type for keys
+	 @param valueType a type for values
+	*/
+	KexiTableViewData(
+		const QValueList<QVariant> &keys, const QValueList<QVariant> &values,
+		KexiDB::Field::Type keyType = KexiDB::Field::Text, 
+		KexiDB::Field::Type valueType = KexiDB::Field::Text);
+
+	/*! Like above constructor, but keys and values are not provided.
+	 You can do this later by calling append(KexiTableItem*) method.
+	 (KexiTableItem object must have exactly two columns)
+	*/
+	KexiTableViewData(KexiDB::Field::Type keyType, KexiDB::Field::Type valueType);
+
+	virtual ~KexiTableViewData();
+//js	void setSorting(int key, bool order=true, short type=1);
+
+	/*! Preloads all rows provided by cursor (only for db-aware version). */
+//! @todo change to bool and return false on error!
+	void preloadAllRows();
+
+	/*! Sets sorting for \a column. If \a column is -1, sorting is disabled. */
+	void setSorting(int column, bool ascending=true);
+
+	/*! \return the column number by which the data is sorted, 
+	 or -1 if sorting is disabled. In this case sortingOrder() will return 0.
+	 Initial sorted column number for data after instantiating object is -1. */
+	inline int sortedColumn() const { return m_sortedColumn; }
+
+	/*! \return 1 if ascending sort order is set, -1 id descending sort order is set,
+	 or 0 if no sorting is set. This is independent of whether data is sorted now. 
+	 Initial sorting for data after instantiating object is 0. */
+	inline int sortingOrder() const { return m_order; }
+
+	/*! Adds column \a col. 
+	 Warning: \a col will be owned by this object, and deleted on its destruction. */
+	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?*/
+	/*! \return true if this db-aware data set. */
+	inline bool isDBAware() { return m_cursor; }
+
+	/*! For db-aware data set only: table name is returned;
+	 equivalent to cursor()->query()->parentTable()->name(). */
+	QString 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); }
+
+	/*! Columns information */
+	KexiTableViewColumn::List columns;
+
+	/*! \return true if data is not editable. Can be set using setReadOnly()
+	 but it's still true if database cursor returned by cursor() 
+	 is not 0 and has read-only connection. */
+	virtual bool isReadOnly() const;
+
+	/*! Sets readOnly flag for this data.
+	 If \a set is true, insertingEnabled flag will be cleared automatically.
+	 \sa isInsertingEnabled() */
+	virtual void setReadOnly(bool set);
+
+	/*! \return true if data inserting is enabled (the default). */
+	virtual bool isInsertingEnabled() const { return m_insertingEnabled; }
+
+	/*! Sets insertingEnabled flag. If true, empty row is available 
+	 If \a set is true, read-only flag will be cleared automatically.
+	 \sa setReadOnly() */
+	virtual void setInsertingEnabled(bool set);
+
+	/*! Clears and initializes internal row edit buffer for incoming editing. 
+	 Creates buffer using KexiDB::RowEditBuffer(false) (false means not db-aware type) 
+	 if our data is not db-aware,
+	 or db-aware buffer if data is db-aware (isDBAware()==true).
+	 \sa KexiDB::RowEditBuffer
+	*/
+	void clearRowEditBuffer();
+
+	/*! Updates internal row edit buffer: currently edited column \a col (number \a colnum) 
+	 has now assigned new value of \a newval.
+	 Uses column's caption to address the column in buffer 
+	 if the buffer is of simple type, or db-aware buffer if (isDBAware()==true).
+	 (then fields are addressed with KexiDB::Field, instead of caption strings).
+	 If \a allowSignals is true (the default), aboutToChangeCell() signal is emitted.
+	 \a visibleValueForLookupField allows to pass visible value (usually a text)
+	 for a lookup field (only reasonable if col->visibleLookupColumnInfo != 0).
+	 Note that \a newval may be changed in aboutToChangeCell() signal handler.
+	 \sa KexiDB::RowEditBuffer */
+	bool updateRowEditBufferRef(KexiTableItem *item, 
+		int colnum, KexiTableViewColumn* col, QVariant& newval, bool allowSignals = true,
+		QVariant *visibleValueForLookupField = 0);
+
+	/*! Added for convenience. Like above but \a newval is passed by value. */
+	inline bool updateRowEditBuffer(KexiTableItem *item, int colnum, KexiTableViewColumn* col, 
+		QVariant newval, bool allowSignals = true)
+	{
+		QVariant newv(newval);
+		return updateRowEditBufferRef(item, colnum, col, newv, allowSignals);
+	}
+
+	/*! Added for convenience. Like above but it's assumed that \a item item's columns are ordered
+	 like in table view, not like in form view. Don't use this with form views. */
+	inline bool updateRowEditBuffer(KexiTableItem *item, int colnum, 
+		QVariant 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; }
+
+	/*! \return last operation's result information (always not null). */
+	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);
+
+	/*! Deletes rows (by number) passed with \a rowsToDelete. 
+	 Currently, this method is only for non data-aware tables. */
+	void deleteRows( const QValueList<int> &rowsToDelete, bool repaint = false );
+
+	/*! Deletes all rows. Works either for db-aware and non db-aware tables.
+	 Column's definition is not changed.
+	 For db-aware version, all rows are removed from a database.
+	 Row-edit buffer is cleared.
+
+	 If \a repaint is true, reloadRequested() signal 
+	 is emitted after deleting (if at least one row was deleted), 
+	 so presenters can repaint their contents. 
+
+	 \return true on success. */
+	virtual bool deleteAllRows(bool repaint = false);
+
+	/*! @internal method, used mostly by specialized classes like KexiTableView.
+	 Clears internal row structures. Row-edit buffer is cleared. 
+	 Does not touch data @ database backend.
+	 Use deleteAllRows() to safely delete all rows. */
+	virtual void clearInternal();
+
+	/*! Inserts new \a item at index \a index. 
+	 \a item will be owned by this data object.
+	 Note: Reasonable only for not not-db-aware version. */
+	void insertRow(KexiTableItem& item, uint index, bool repaint = false);
+
+/*TODO: add this as well? 
+	void insertRow(KexiTableItem& item, KexiTableItem& aboveItem); */
+
+	//! \return index of autoincremented column. The result is cached.
+//! \todo what about multiple autoinc columns?
+//! \todo what about changing column order?
+	int autoIncrementedColumn();
+
+	//! Emits reloadRequested() signal to reload presenters.
+	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); }
+
+	/*! \return true if ROWID information is stored within every row.
+	 Only reasonable for db-aware version. ROWID information is available 
+	 if DriverBehaviour::ROW_ID_FIELD_RETURNS_LAST_AUTOINCREMENTED_VALUE == false
+	 for a KexiDB database driver and a table has no primary key defined. 
+	 Phisically, ROWID information is stored after last KexiTableItem's element,
+	 so every KexiTableItem's length is expanded by one. */
+	inline bool containsROWIDInfo() const { return m_containsROWIDInfo; }
+
+	inline KexiTableItem* createItem() const
+	{ return new KexiTableItem(m_itemSize); }
+
+public slots:
+	//! @internal The same as QObject::deleteLater() but also sets smart pointer m_cursor to 0 to avoid crashes...
+	void deleteLater();
+
+signals:
+	void destroying();
+
+	/*! Emitted before change of the single, currently edited cell.
+	 Connect this signal to your slot and set \a result->success to false
+	 to disallow this change. You can also change \a newValue to other value,
+	 or change other columns in \a item row. */
+	void aboutToChangeCell(KexiTableItem *item, int colnum, QVariant& newValue,
+		KexiDB::ResultInfo* result);
+
+	/*! Emited before inserting of a new, current row.
+	 Connect this signal to your slot and set \a result->success to false 
+	 to disallow this inserting. You can also change columns in \a item row. */
+	void aboutToInsertRow(KexiTableItem *item, KexiDB::ResultInfo* result, bool repaint);
+
+	/*! Emited before changing of an edited, current row.
+	 Connect this signal to your slot and set \a result->success to false 
+	 to disallow this change. You can also change columns in \a item row. */
+	void aboutToUpdateRow(KexiTableItem *item, KexiDB::RowEditBuffer* buffer,
+		KexiDB::ResultInfo* result);
+
+	void rowUpdated(KexiTableItem*); //!< Current row has been updated
+
+	void rowInserted(KexiTableItem*, bool repaint); //!< A row has been inserted
+
+	//! A row has been inserted at \a index position (not db-aware data only)
+	void rowInserted(KexiTableItem*, uint index, bool repaint);
+
+	/*! Emited before deleting of a current row.
+	 Connect this signal to your slot and set \a result->success to false 
+	 to disallow this deleting. */
+	void aboutToDeleteRow(KexiTableItem& item, KexiDB::ResultInfo* result, bool repaint);
+
+	//! Current row has been deleted
+	void rowDeleted(); 
+
+	//! Rows have been deleted
+	void rowsDeleted( const QValueList<int> &rowsToDelete );
+
+	//! Displayed data needs to be reloaded in all presenters.
+	void reloadRequested();
+
+	void rowRepaintRequested(KexiTableItem&);
+
+protected:
+	void init();
+	void init(
+		const QValueList<QVariant> &keys, const QValueList<QVariant> &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);
+
+	//! Compare function for BLOB data (QByteArray). Uses size as the weight.
+	int cmpBLOB(Item item1, Item item2);
+
+	//! internal: for saveRowChanges() and saveNewRow()
+	bool saveRow(KexiTableItem& item, bool insert, bool repaint);
+
+	//! (logical) sorted column number, set by setSorting()
+	//! can differ from m_realSortedColumn if there's lookup column used
+	int m_sortedColumn;
+	//! real sorted column number, set by setSorting(), used by cmp*() methods
+	int m_realSortedColumn;
+	short m_order;
+	short m_type;
+	int m_itemSize;
+	static unsigned short charTable[];
+	KexiDB::RowEditBuffer *m_pRowEditBuffer;
+	QGuardedPtr<KexiDB::Cursor> m_cursor;
+
+	//! used to faster lookup columns of simple type (not dbaware)
+//	QDict<KexiTableViewColumn> *m_simpleColumnsByName;
+
+	KexiDB::ResultInfo m_result;
+
+	uint m_visibleColumnsCount;
+	QValueVector<int> m_visibleColumnsIDs, m_globalColumnsIDs;
+
+	bool m_readOnly : 1;
+	bool m_insertingEnabled : 1;
+
+	/*! Used in acceptEditor() to avoid infinite recursion, 
+	 eg. when we're calling acceptRowEdit() during cell accepting phase. */
+	bool m_inside_acceptEditor : 1;
+
+	//! @see containsROWIDInfo()
+	bool m_containsROWIDInfo : 1;
+
+	int m_autoIncrementedColumn;
+
+	int (KexiTableViewData::*cmpFunc)(void *, void *);
+
+	//! Temporary, used in compare functions like cmpInt(), cmpString() 
+	//! to avoid memory allocations.
+	QVariant m_leftTmp, m_rightTmp;
+};
+
+#endif