// This is the SIP interface definition for TQTable, TQTableItem,
// TQCheckTableItem, TQComboTableItem and TQTableSelection.
//
// Copyright (c) 2007
// 	Riverbank Computing Limited <info@riverbankcomputing.co.uk>
// 
// This file is part of PyTQt.
// 
// This copy of PyTQt is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2, or (at your option) any later
// version.
// 
// PyTQt is supplied 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 General Public License for more
// details.
// 
// You should have received a copy of the GNU General Public License along with
// PyTQt; see the file LICENSE.  If not, write to the Free Software Foundation,
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


%ExportedDoc
<Sect2><Title>TQTable (TQt v2.2+)</Title>
<Para>
<Literal>TQTable</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>TQTableItem (TQt v2.2+)</Title>
<Para>
<Literal>TQTableItem</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>TQCheckTableItem (TQt v3+)</Title>
<Para>
<Literal>TQCheckTableItem</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>TQComboTableItem (TQt v3+)</Title>
<Para>
<Literal>TQComboTableItem</Literal> is fully implemented.
</Para>
</Sect2>

<Sect2><Title>TQTableSelection (TQt v2.2+)</Title>
<Para>
<Literal>TQTableSelection</Literal> is fully implemented.
</Para>
</Sect2>
%End


%If (TQt_TABLE)

class TQTableSelection
{
%TypeHeaderCode
#include <tqtable.h>
%End

public:
	TQTableSelection();
	TQTableSelection(int,int,int,int);

	void init(int,int);
	void expandTo(int,int);

	int topRow() const;
	int bottomRow() const;
	int leftCol() const;
	int rightCol() const;
	int anchorRow() const;
	int anchorCol() const;
	int numRows() const;
	int numCols() const;

	bool isActive() const;
	bool isEmpty() const;
};


class TQTableItem : TQt
{
%TypeHeaderCode
#include <tqtable.h>
%End

public:
	enum EditType {
		Never,
		OnTyping,
		WhenCurrent,
		Always
	};

	// Note that the TQt documentation is wrong.  Ownership is only taken by
	// TQTable::setItem().
	TQTableItem(TQTable *,EditType);
	TQTableItem(TQTable *,EditType,const TQString &);
	TQTableItem(TQTable *,EditType,const TQString &,const TQPixmap &);

%ConvertToSubClassCode
	Py_BEGIN_ALLOW_THREADS

	int rtti = sipCpp -> rtti();

	if (rtti == TQCheckTableItem::RTTI)
		sipClass = sipClass_TQCheckTableItem;
	else if (rtti == TQComboTableItem::RTTI)
		sipClass = sipClass_TQComboTableItem;
	else
		sipClass = 0;

	Py_END_ALLOW_THREADS
%End

	virtual TQPixmap pixmap() const;
	virtual TQString text() const;
	virtual void setPixmap(const TQPixmap &);
	virtual void setText(const TQString &);
	TQTable *table() const;

	virtual int alignment() const;
	virtual void setWordWrap(bool);
	bool wordWrap() const;

	EditType editType() const;
	virtual TQWidget *createEditor() const /Factory/;
	virtual void setContentFromEditor(TQWidget *);
	virtual void setReplaceable(bool);
	bool isReplaceable() const;

	virtual TQString key() const;
	virtual TQSize sizeHint() const;

	virtual void setSpan(int,int);
	int rowSpan() const;
	int colSpan() const;

	virtual void setRow(int);
	virtual void setCol(int);
	int row() const;
	int col() const;

	virtual void paint(TQPainter *,const TQColorGroup &,const TQRect &,bool);

	void updateEditor(int,int);

	virtual void setEnabled(bool);
	bool isEnabled() const;
 
	virtual int rtti() const;
};


class TQComboTableItem : TQTableItem
{
%TypeHeaderCode
#include <tqtable.h>
%End

public:
	// Note that the TQt documentation is wrong.  Ownership is only taken by
	// TQTable::setItem().
	TQComboTableItem(TQTable *,const TQStringList &,bool = 0);

	virtual TQWidget *createEditor() const /Factory/;
	virtual void setContentFromEditor(TQWidget *);
	virtual void paint(TQPainter *,const TQColorGroup &,const TQRect &,bool);
	virtual void setCurrentItem(int);
	virtual void setCurrentItem(const TQString &);
	int currentItem() const;
	TQString currentText() const;
	int count() const;
	TQString text(int) const;
	virtual void setEditable(bool);
	bool isEditable() const;
	virtual void setStringList(const TQStringList &);
 
	int rtti() const;

	TQSize sizeHint() const;
};


class TQCheckTableItem : TQTableItem
{
%TypeHeaderCode
#include <tqtable.h>
%End

public:
	// Note that the TQt documentation is wrong.  Ownership is only taken by
	// TQTable::setItem().
	TQCheckTableItem(TQTable *,const TQString &);

	void setText(const TQString &);
	virtual TQWidget *createEditor() const /Factory/;
	virtual void setContentFromEditor(TQWidget *);
	virtual void paint(TQPainter *,const TQColorGroup &,const TQRect &,bool);
	virtual void setChecked(bool);
	bool isChecked() const;
 
	int rtti() const;

	TQSize sizeHint() const;
};


class TQTable : TQScrollView
{
%TypeHeaderCode
#include <tqtable.h>
%End

public:
	TQTable(TQWidget * /TransferThis/ = 0,const char * = 0);
	TQTable(int,int,TQWidget * /TransferThis/ = 0,const char * = 0);

%ConvertToSubClassCode
	sipClass = (sipCpp->inherits(sipName_TQTable) ? sipClass_TQTable : NULL);
%End

	TQHeader *horizontalHeader() const;
	TQHeader *verticalHeader() const;

	enum SelectionMode {
		Single,
		Multi,
		SingleRow,
		MultiRow,
		NoSelection
	};

	virtual void setSelectionMode(SelectionMode);
	SelectionMode selectionMode() const;

	virtual void setItem(int,int,TQTableItem * /Transfer/);
	virtual void setText(int,int,const TQString &);
	virtual void setPixmap(int,int,const TQPixmap &);
	virtual TQTableItem *item(int,int) const;
	virtual TQString text(int,int) const;
	virtual TQPixmap pixmap(int,int) const;
	virtual void clearCell(int,int);

	virtual TQRect cellGeometry(int,int) const;
	virtual int columnWidth(int) const;
	virtual int rowHeight(int) const;
	virtual int columnPos(int) const;
	virtual int rowPos(int) const;
	virtual int columnAt(int) const;
	virtual int rowAt(int) const;

	virtual int numRows() const;
	virtual int numCols() const;

	void updateCell(int,int);

	bool eventFilter(TQObject *,TQEvent *);

	int currentRow() const;
	int currentColumn() const;
	void ensureCellVisible(int,int);

	bool isSelected(int,int) const;
	bool isRowSelected(int,bool = 0) const;
	bool isColumnSelected(int,bool = 0) const;
	int numSelections() const;
	TQTableSelection selection(int) const;
	virtual int addSelection(const TQTableSelection &);
	virtual void removeSelection(const TQTableSelection &);
	virtual void removeSelection(int);
	virtual int currentSelection() const;

	void selectCells(int,int,int,int);
	void selectRow(int);
	void selectColumn(int);

	bool showGrid() const;

	bool columnMovingEnabled() const;
	bool rowMovingEnabled() const;

	virtual void sortColumn(int,bool = 1,bool = 0);

	bool sorting() const;

	virtual void takeItem(TQTableItem * /TransferBack/);

	virtual void setCellWidget(int,int,TQWidget * /Transfer/);
	virtual TQWidget *cellWidget(int,int) const;
	virtual void clearCellWidget(int,int);

	virtual TQRect cellRect(int,int) const;

	virtual void paintCell(TQPainter *,int,int,const TQRect &,bool);
	virtual void paintCell(TQPainter *,int,int,const TQRect &,bool,
			       const TQColorGroup &);
	virtual void paintFocus(TQPainter *,const TQRect &);
	TQSize sizeHint() const;

	bool isReadOnly() const;
	bool isRowReadOnly(int) const;
	bool isColumnReadOnly(int) const;
 
	void setEnabled(bool);
 
	void repaintSelections();
 
	enum FocusStyle {
		FollowStyle,
		SpreadSheet
	};

	virtual void setFocusStyle(FocusStyle);
	FocusStyle focusStyle() const;

	void updateHeaderStates();

public slots:
	virtual void setNumRows(int);
	virtual void setNumCols(int);
	virtual void setShowGrid(bool);
	virtual void hideRow(int);
	virtual void hideColumn(int);
	virtual void showRow(int);
	virtual void showColumn(int);
	bool isRowHidden(int) const;
	bool isColumnHidden(int) const;

	virtual void setColumnWidth(int,int);
	virtual void setRowHeight(int,int);

	virtual void adjustColumn(int);
	virtual void adjustRow(int);

	virtual void setColumnStretchable(int,bool);
	virtual void setRowStretchable(int,bool);
	bool isColumnStretchable(int) const;
	bool isRowStretchable(int) const;
	virtual void setSorting(bool);
	virtual void swapRows(int,int,bool = 0);
	virtual void swapColumns(int,int,bool = 0);
	virtual void swapCells(int,int,int,int);

	virtual void setLeftMargin(int);
	virtual void setTopMargin(int);
	virtual void setCurrentCell(int,int);
	void clearSelection(bool = 1);
	virtual void setColumnMovingEnabled(bool);
	virtual void setRowMovingEnabled(bool);

	virtual void setReadOnly(bool);
	virtual void setRowReadOnly(int,bool);
	virtual void setColumnReadOnly(int,bool);
 
	virtual void setDragEnabled(bool);
	bool dragEnabled() const;
 
	virtual void insertRows(int,int = 1);
	virtual void insertColumns(int,int = 1);
	virtual void removeRow(int);
	virtual void removeRows(const TQMemArray<int> &);
	virtual void removeColumn(int);
	virtual void removeColumns(const TQMemArray<int> &);
 
	virtual void editCell(int,int,bool = 0);

	void setRowLabels(const TQStringList &);
	void setColumnLabels(const TQStringList &);

protected:
	enum EditMode {
		NotEditing,
		Editing,
		Replacing
	};

	void drawContents(TQPainter *,int,int,int,int);
	void contentsMousePressEvent(TQMouseEvent *);
	void contentsMouseMoveEvent(TQMouseEvent *);
	void contentsMouseDoubleClickEvent(TQMouseEvent *);
	void contentsMouseReleaseEvent(TQMouseEvent *);
	void contentsContextMenuEvent(TQContextMenuEvent *);
	void keyPressEvent(TQKeyEvent *);
	void focusInEvent(TQFocusEvent *);
	void focusOutEvent(TQFocusEvent *);
	void viewportResizeEvent(TQResizeEvent *);
	void showEvent(TQShowEvent *);
	void paintEvent(TQPaintEvent *);
	void setEditMode(EditMode,int,int);
	virtual void contentsDragEnterEvent(TQDragEnterEvent *);
	virtual void contentsDragMoveEvent(TQDragMoveEvent *);
	virtual void contentsDragLeaveEvent(TQDragLeaveEvent *);
	virtual void contentsDropEvent(TQDropEvent *);
	virtual TQDragObject *dragObject();
	virtual void startDrag();

	virtual void paintEmptyArea(TQPainter *,int,int,int,int);
	virtual void activateNextCell();
	virtual TQWidget *createEditor(int,int,bool) const /Factory/;
	virtual void setCellContentFromEditor(int,int);
	virtual TQWidget *beginEdit(int,int,bool);
	virtual void endEdit(int,int,bool,bool);

	virtual void resizeData(int);
	virtual void insertWidget(int,int,TQWidget *);
	int indexOf(int,int) const;

	void windowActivationChange(bool);
	bool isEditing() const;
	EditMode editMode() const;
	int currEditRow() const;
	int currEditCol() const;

protected slots:
	virtual void columnWidthChanged(int);
	virtual void rowHeightChanged(int);
	virtual void columnIndexChanged(int,int,int);
	virtual void rowIndexChanged(int,int,int);
	virtual void columnClicked(int);

signals:
	void currentChanged(int,int);
	void clicked(int,int,int,const TQPoint &);
	void doubleClicked(int,int,int,const TQPoint &);
	void pressed(int,int,int,const TQPoint &);
	void selectionChanged();
	void valueChanged(int,int);
	void contextMenuRequested(int,int,const TQPoint &);
	void dropped(TQDropEvent *);

private:
	TQTable(const TQTable &);
};

%End
