Diffstat (limited to 'qtcompat/qcombotableitem.cpp') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | qtcompat/qcombotableitem.cpp | 481 |
1 files changed, 481 insertions, 0 deletions
diff --git a/qtcompat/qcombotableitem.cpp b/qtcompat/qcombotableitem.cpp new file mode 100644 index 0000000..348ea24 --- a/dev/null +++ b/qtcompat/qcombotableitem.cpp @@ -0,0 +1,481 @@ +/**************************************************************************** +** +** Implementation of QTable widget class +** +** Created : 000607 +** +** Copyright (C) 1992-2002 Trolltech AS. All rights reserved. +** +** This file is part of the table module of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition licenses may use this +** file in accordance with the Qt Commercial License Agreement provided +** with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ +/*US +#include "qglobal.h" +#if defined(Q_CC_BOR) +// needed for qsort() because of a std namespace problem on Borland +#include "qplatformdefs.h" +#endif +*/ +#include "qcombotableitem.h" + +#include "qcombobox.h" +#include "qstyle.h" + +/*US + +#ifndef QT_NO_TABLE + +#include "qpainter.h" +#include "qlineedit.h" +#include "qcursor.h" +#include "qapplication.h" +#include "qtimer.h" +#include "qobjectlist.h" +#include "qiconset.h" +#include "qcombobox.h" +#include "qcheckbox.h" +#include "qdragobject.h" +#include "qevent.h" +#include "qlistbox.h" +#include "qstyle.h" + +#include <stdlib.h> +#include <limits.h> + +static bool qt_update_cell_widget = TRUE; + +class QM_EXPORT_TABLE QTableHeader : public QHeader +{ + friend class QTable; + Q_OBJECT + +public: + enum SectionState { + Normal, + Bold, + Selected + }; + + QTableHeader( int, QTable *t, QWidget* parent=0, const char* name=0 ); + ~QTableHeader() {}; + void addLabel( const QString &s, int size ); + void setLabel( int section, const QString & s, int size = -1 ); + void setLabel( int section, const QIconSet & iconset, const QString & s, + int size = -1 ); + void removeLabel( int section ); + + void setSectionState( int s, SectionState state ); + void setSectionStateToAll( SectionState state ); + SectionState sectionState( int s ) const; + + int sectionSize( int section ) const; + int sectionPos( int section ) const; + int sectionAt( int section ) const; + + void setSectionStretchable( int s, bool b ); + bool isSectionStretchable( int s ) const; + + void updateCache(); + +signals: + void sectionSizeChanged( int s ); + +protected: + void paintEvent( QPaintEvent *e ); + void paintSection( QPainter *p, int index, const QRect& fr ); + void mousePressEvent( QMouseEvent *e ); + void mouseMoveEvent( QMouseEvent *e ); + void mouseReleaseEvent( QMouseEvent *e ); + void mouseDoubleClickEvent( QMouseEvent *e ); + void resizeEvent( QResizeEvent *e ); + +private slots: + void doAutoScroll(); + void sectionWidthChanged( int col, int os, int ns ); + void indexChanged( int sec, int oldIdx, int newIdx ); + void updateStretches(); + void updateWidgetStretches(); + +private: + void updateSelections(); + void saveStates(); + void setCaching( bool b ); + void swapSections( int oldIdx, int newIdx, bool swapTable = TRUE ); + bool doSelection( QMouseEvent *e ); + void sectionLabelChanged( int section ); + void resizeArrays( int n ); + +private: + QMemArray<int> states, oldStates; + QMemArray<bool> stretchable; + QMemArray<int> sectionSizes, sectionPoses; + bool mousePressed; + int pressPos, startPos, endPos; + QTable *table; + QTimer *autoScrollTimer; + QWidget *line1, *line2; + bool caching; + int resizedSection; + bool isResizing; + int numStretches; + QTimer *stretchTimer, *widgetStretchTimer; + QTableHeaderPrivate *d; + +}; + +#ifdef _WS_QWS_ +# define NO_LINE_WIDGET +#endif + + + +struct QTablePrivate +{ + QTablePrivate() : hasRowSpan( FALSE ), hasColSpan( FALSE ), + redirectMouseEvent( FALSE ) + { + hiddenRows.setAutoDelete( TRUE ); + hiddenCols.setAutoDelete( TRUE ); + } + uint hasRowSpan : 1; + uint hasColSpan : 1; + uint redirectMouseEvent : 1; + QIntDict<int> hiddenRows, hiddenCols; + QTimer *geomTimer; +}; + +struct QTableHeaderPrivate +{ +#ifdef NO_LINE_WIDGET + int oldLinePos; +#endif +}; + +static bool isRowSelection( QTable::SelectionMode selMode ) +{ + return selMode == QTable::SingleRow || selMode == QTable::MultiRow; +} +*/ + + +/*! + \class QComboTableItem + \brief The QComboTableItem class provides a means of using + comboboxes in QTables. + + \ingroup advanced + \module table + + A QComboTableItem is a table item which looks and behaves like a + combobox. The advantage of using QComboTableItems rather than real + comboboxes is that a QComboTableItem uses far less resources than + real comboboxes in \l{QTable}s. When the cell has the focus it + displays a real combobox which the user can interact with. When + the cell does not have the focus the cell \e looks like a + combobox. Only text items (i.e. no pixmaps) may be used in + QComboTableItems. + + QComboTableItem items have the edit type \c WhenCurrent (see + \l{EditType}). The QComboTableItem's list of items is provided by + a QStringList passed to the constructor. + + The list of items may be changed using setStringList(). The + current item can be set with setCurrentItem() and retrieved with + currentItem(). The text of the current item can be obtained with + currentText(), and the text of a particular item can be retrieved + with text(). + + If isEditable() is TRUE the QComboTableItem will permit the user + to either choose an existing list item, or create a new list item + by entering their own text; otherwise the user may only choose one + of the existing list items. + + To populate a table cell with a QComboTableItem use + QTable::setItem(). + + QComboTableItems may be deleted with QTable::clearCell(). + + QComboTableItems can be distinguished from \l{QTableItem}s and + \l{QCheckTableItem}s using their Run Time Type Identification + number (see rtti()). + + \img qtableitems.png Table Items + + \sa QCheckTableItem QTableItem QComboBox +*/ + +QComboBox *QComboTableItem::fakeCombo = 0; +QWidget *fakeComboWidget = 0; + +/*! + Creates a combo table item for the table \a table. The combobox's + list of items is passed in the \a list argument. If \a editable is + TRUE the user may type in new list items; if \a editable is FALSE + the user may only select from the list of items provided. + + By default QComboTableItems cannot be replaced by other table + items since isReplaceable() returns FALSE by default. + + \sa QTable::clearCell() EditType +*/ + +QComboTableItem::QComboTableItem( QTable *table, const QStringList &list, bool editable ) + : QTableItem( table, WhenCurrent, "" ), entries( list ), current( 0 ), edit( editable ) +{ + setReplaceable( FALSE ); + if ( !fakeCombo ) { + fakeComboWidget = new QWidget( 0, 0 ); + fakeCombo = new QComboBox( FALSE, fakeComboWidget, 0 ); + fakeCombo->hide(); + } +} + +/*! + Sets the list items of this QComboTableItem to the strings in the + string list \a l. +*/ + +void QComboTableItem::setStringList( const QStringList &l ) +{ + entries = l; + current = 0; + if ( table()->cellWidget( row(), col() ) ) { + cb->clear(); + cb->insertStringList( entries ); + } + table()->updateCell( row(), col() ); +} + +/*! \reimp */ + +QWidget *QComboTableItem::createEditor() const +{ + // create an editor - a combobox in our case + ( (QComboTableItem*)this )->cb = new QComboBox( edit, table()->viewport(), "qt_editor_cb" ); + cb->insertStringList( entries ); + cb->setCurrentItem( current ); + QObject::connect( cb, SIGNAL( activated( int ) ), table(), SLOT( doValueChanged() ) ); + return cb; +} + +/*! \reimp */ + +void QComboTableItem::setContentFromEditor( QWidget *w ) +{ + if ( w->inherits( "QComboBox" ) ) { + QComboBox *cb = (QComboBox*)w; + entries.clear(); + for ( int i = 0; i < cb->count(); ++i ) + entries << cb->text( i ); + current = cb->currentItem(); + setText( *entries.at( current ) ); + } +} + +/*! \reimp */ + +void QComboTableItem::paint( QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected ) +{ + fakeCombo->resize( cr.width(), cr.height() ); + + QColorGroup c( cg ); + if ( selected ) { + c.setBrush( QColorGroup::Base, cg.brush( QColorGroup::Highlight ) ); + c.setColor( QColorGroup::Text, cg.highlightedText() ); + } + +/*US QStyle::SFlags flags = QStyle::Style_Default; + if(isEnabled() && table()->isEnabled()) + flags |= QStyle::Style_Enabled; +*/ +//US table()->style().drawComplexControl( QStyle::CC_ComboBox, p, fakeCombo, fakeCombo->rect(), c, flags ); + + table()->style().drawComboButton(p, fakeCombo->x(), fakeCombo->y(), fakeCombo->width(), fakeCombo->height(), c, FALSE, FALSE, (/*US isEnabled() && */table()->isEnabled()), 0); + p->save(); +/*US + QRect textR = table()->style().querySubControlMetrics(QStyle::CC_ComboBox, fakeCombo, + QStyle::SC_ComboBoxEditField); + +*/ + int align = alignment(); // alignment() changes entries +//US p->drawText( textR, wordWrap() ? ( align | WordBreak ) : align, *entries.at( current ) ); + QRect textR = QRect( fakeCombo->x()+2, fakeCombo->y(), fakeCombo->width()- 17, fakeCombo->height() ); + //qDebug("x %d -- %d wid %d -- %d ", cr.x(),fakeCombo->x(), cr.width(), fakeCombo->width() ); + p->drawText( textR, wordWrap() ? ( align | WordBreak ) : align, *entries.at( current ) ); + p->restore(); +} + +/*! + Sets the list item \a i to be the combo table item's current list + item. + + \sa currentItem() +*/ + +void QComboTableItem::setCurrentItem( int i ) +{ + QWidget *w = table()->cellWidget( row(), col() ); + if ( w && w->inherits( "QComboBox" ) ) { + ( (QComboBox*)w )->setCurrentItem( i ); + current = i; + setText( ( (QComboBox*)w )->currentText() ); + } else { + current = i; + setText( *entries.at( i ) ); + table()->updateCell( row(), col() ); + } +} + +/*! + \overload + + Sets the list item whose text is \a s to be the combo table item's + current list item. Does nothing if no list item has the text \a s. + + \sa currentItem() +*/ + +void QComboTableItem::setCurrentItem( const QString &s ) +{ + int i = entries.findIndex( s ); + if ( i != -1 ) + setCurrentItem( i ); +} + +/*! + Returns the index of the combo table item's current list item. + + \sa setCurrentItem() +*/ + +int QComboTableItem::currentItem() const +{ + QWidget *w = table()->cellWidget( row(), col() ); + if ( w && w->inherits( "QComboBox" ) ) + return ( (QComboBox*)w )->currentItem(); + return current; +} + +/*! + Returns the text of the combo table item's current list item. + + \sa currentItem() text() +*/ + +QString QComboTableItem::currentText() const +{ + QWidget *w = table()->cellWidget( row(), col() ); + if ( w && w->inherits( "QComboBox" ) ) + return ( (QComboBox*)w )->currentText(); + return *entries.at( current ); +} + +/*! + Returns the total number of list items in the combo table item. +*/ + +int QComboTableItem::count() const +{ + QWidget *w = table()->cellWidget( row(), col() ); + if ( w && w->inherits( "QComboBox" ) ) + return ( (QComboBox*)w )->count(); + return (int)entries.count(); //### size_t/int cast +} + +/*! + Returns the text of the combo's list item at index \a i. + + \sa currentText() +*/ + +QString QComboTableItem::text( int i ) const +{ + QWidget *w = table()->cellWidget( row(), col() ); + if ( w && w->inherits( "QComboBox" ) ) + return ( (QComboBox*)w )->text( i ); + return *entries.at( i ); +} + +/*! + If \a b is TRUE the combo table item can be edited, i.e. the user + may enter a new text item themselves. If \a b is FALSE the user may + may only choose one of the existing items. + + \sa isEditable() +*/ + +void QComboTableItem::setEditable( bool b ) +{ + edit = b; +} + +/*! + Returns TRUE if the user can add their own list items to the + combobox's list of items; otherwise returns FALSE. + + \sa setEditable() +*/ + +bool QComboTableItem::isEditable() const +{ + return edit; +} + +int QComboTableItem::RTTI = 1; + +/*! + \fn int QComboTableItem::rtti() const + + Returns 1. + + Make your derived classes return their own values for rtti()to + distinguish between different table item subclasses. You should + use values greater than 1000, preferably a large random number, to + allow for extensions to this class. + + + \sa QTableItem::rtti() +*/ + +int QComboTableItem::rtti() const +{ + return RTTI; +} + +/*! \reimp */ + +QSize QComboTableItem::sizeHint() const +{ + fakeCombo->insertItem( currentText() ); + fakeCombo->setCurrentItem( fakeCombo->count() - 1 ); + QSize sh = fakeCombo->sizeHint(); + fakeCombo->removeItem( fakeCombo->count() - 1 ); +//US return sh.expandedTo( QApplication::globalStrut() ); + return sh; +} + |