uitable.h

Go to the documentation of this file.

#ifndef uitable_h
#define uitable_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H. Lammertink
 Date:          12/02/2003
 RCS:           $Id$
________________________________________________________________________

-*/

#include "uibasemod.h"
#include "uiobj.h"

#include "color.h"
#include "keyenum.h"
#include "rowcol.h"
#include "draw.h"

class BufferStringSet;
class uiPixmap;
class uiGroup;
class uiLabel;
class uiTableBody;


mExpClass(uiBase) uiTable : public uiObject
{ mODTextTranslationClass(uiTable)
friend class            i_tableMessenger;
friend class            uiTableBody;
public:

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

    enum SelectionBehavior
    {
        SelectItems, SelectRows, SelectColumns
    };

    enum ResizeMode
    {
        Interactive, Fixed, Stretch, ResizeToContents
    };

    mExpClass(uiBase) Setup
    {
    public:

                    Setup(int nrrows=-1,int nrcols=-1)
                        : size_(nrrows,nrcols)
                        , rowdesc_("Row")
                        , coldesc_("Column")
                        , insertrowallowed_(true)
                        , removerowallowed_(true)
                        , rowgrow_(false) 
                        , insertcolallowed_(true)
                        , removecolallowed_(true)
                        , colgrow_(false) 
                        , fillrow_(false) 
                        , fillcol_(false) 
                        , minrowhgt_(1.f) 
                        , maxrowhgt_(3.f) 
                        , mincolwdt_(1.f*uiObject::baseFldSize())
                        , maxcolwdt_(2.3f*uiObject::baseFldSize())
                        , selmode_(NoSelection)
                        , removeselallowed_(true)
                        , snglclkedit_(true)
                        , defcollbl_(false)
                        , defrowlbl_(false)
                        , manualresize_(false)
                        , defrowstartidx_(1)
                        , rightclickdisabled_(false)
                        , enablecopytext_(false)
                                {}

        mDefSetupMemb(RowCol,size)
        mDefSetupMemb(BufferString,rowdesc)
        mDefSetupMemb(BufferString,coldesc)
        mDefSetupMemb(bool,rowgrow)
        mDefSetupMemb(bool,colgrow)
        mDefSetupMemb(bool,insertrowallowed)
        mDefSetupMemb(bool,removerowallowed)
        mDefSetupMemb(bool,insertcolallowed)
        mDefSetupMemb(bool,removecolallowed)
        mDefSetupMemb(bool,fillrow)
        mDefSetupMemb(bool,fillcol)
        mDefSetupMemb(float,maxrowhgt)
        mDefSetupMemb(float,minrowhgt)
        mDefSetupMemb(float,maxcolwdt)
        mDefSetupMemb(float,mincolwdt)
        mDefSetupMemb(SelectionMode,selmode)
        mDefSetupMemb(bool,removeselallowed)
        mDefSetupMemb(bool,snglclkedit)
        mDefSetupMemb(bool,defrowlbl)
        mDefSetupMemb(bool,defcollbl)
        mDefSetupMemb(bool,manualresize)
        mDefSetupMemb(int,defrowstartidx)
        mDefSetupMemb(bool,rightclickdisabled)
        mDefSetupMemb(bool,enablecopytext)

        Setup& sizesFixed( bool yn )
        {
            insertrowallowed_ = removerowallowed_ = rowgrow_ =
            insertcolallowed_ = removecolallowed_ = colgrow_ = !yn;
            return *this;
        }
    };

                        uiTable(uiParent*,const Setup&,const char* nm);
    virtual             ~uiTable();

    const char*         text(const RowCol&) const;
    void                setText(const RowCol&,const char*);
    void                setText(const RowCol&,const OD::String&);
    void                setText(const RowCol&,const uiString&);
    void                clearCell(const RowCol&);
    void                clearTable();
    void                showGrid(bool);
    bool                gridShown() const;
    void                setCurrentCell(const RowCol&,bool noselection=false);
    void                setCellObject(const RowCol&,uiObject*);
    uiObject*           getCellObject(const RowCol&) const;
    void                clearCellObject(const RowCol&);
    RowCol              getCell(uiObject*);
    void                setCellGroup(const RowCol&,uiGroup*);
    uiGroup*            getCellGroup(const RowCol&) const;
    RowCol              getCell(uiGroup*);
    void                setCellChecked(const RowCol&,bool yn);
    bool                isCellChecked(const RowCol&) const;

    int                 nrRows() const;
    int                 nrCols() const;
    void                setNrRows(int);
    void                setNrCols(int);
    void                setPrefHeightInRows(int);

    int                 columnWidth(int) const;
    int                 rowHeight(int) const;

    void                setLeftMargin(int);
    void                setColumnWidth(int col,int w);
    void                setColumnWidthInChar(int col,float w);

    void                setTopMargin(int);
    void                setRowHeight(int row,int h);
    void                setRowHeightInChar(int row,float h);

    void                resizeHeaderToContents(bool hor);
    void                resizeColumnToContents(int);
    void                resizeColumnsToContents();
    void                resizeRowToContents(int);
    void                resizeRowsToContents();
    void                setColumnResizeMode(ResizeMode);
    void                setRowResizeMode(ResizeMode);
    void                setColumnStretchable(int,bool);
    void                setRowStretchable(int,bool);
    bool                isColumnStretchable(int) const;
    bool                isRowStretchable(int) const;

    void                setTableReadOnly(bool);
    bool                isTableReadOnly() const;

    void                setColumnReadOnly(int,bool);
    bool                isColumnReadOnly(int) const;
    void                setRowReadOnly(int,bool);
    bool                isRowReadOnly(int) const;

    void                setCellReadOnly(const RowCol&,bool);
    bool                isCellReadOnly(const RowCol&) const;

    void                hideColumn(int,bool);
    void                hideRow(int,bool);
    bool                isColumnHidden(int) const;
    bool                isRowHidden(int) const;

    bool                isTopHeaderHidden() const;
    bool                isLeftHeaderHidden() const;
    void                setTopHeaderHidden(bool);
    void                setLeftHeaderHidden(bool);

    void                insertRows(int row,int count);
    inline void         insertRows( const RowCol& rc, int count )
                            { insertRows( rc.row(), count ); }
    void                insertColumns(int col,int count);
    inline void         insertColumns( const RowCol& rc, int count )
                            { insertColumns( rc.col(), count ); }
    void                removeRow(int);
    void                removeRow( const RowCol& rc )
                                { removeRow( rc.row() ); }
    void                removeRows(const TypeSet<int>&);
    void                removeColumn(int);
    void                removeColumn( const RowCol& rc )
                                { removeColumn( rc.col() ); }
    void                removeColumns(const TypeSet<int>&);

    bool                isSelected(const RowCol&) const;
    bool                isRowSelected(int) const;
    bool                isColumnSelected(int) const;
                        // next 3 return in selected order
    bool                getSelectedRows(TypeSet<int>&) const;
    bool                getSelectedCols(TypeSet<int>&) const;
    bool                getSelectedCells(TypeSet<RowCol>&) const;
    int                 currentRow() const;
    int                 currentCol() const;
    RowCol              currentCell() const
                        { return RowCol( currentRow(), currentCol() ); }
    void                setSelected(const RowCol&,bool yn=true);
    void                selectRow(int row);
    void                selectColumn(int col);
    void                selectItems(const TypeSet<RowCol>&,bool);
    void                removeAllSelections();
    void                ensureCellVisible(const RowCol&);

    const char*         rowLabel(int) const;
    const char*         rowLabel( const RowCol& rc ) const
                            { return rowLabel(rc.row()); }
    void                setRowLabel(int,const char*); // also sets tooltip
    void                setRowLabels(const char**);
    void                setRowLabels(const BufferStringSet&);
    void                setRowLabel( const RowCol& rc, const char* lbl )
                            { setRowLabel( rc.row(), lbl ); }
    void                setRowToolTip(int,const char*);
    void                setTopLeftCornerLabel(const uiString&);

    const char*         columnLabel(int) const;
    const char*         columnLabel( const RowCol& rc ) const
                            { return columnLabel(rc.col()); }
    void                setColumnLabel(int,const uiString&); //also sets tooltip
    void                setColumnLabels(const char**);
    void                setColumnLabels(const BufferStringSet&);
    void                setColumnLabel( const RowCol& rc, const uiString& lbl )
                            { setColumnLabel( rc.col(), lbl ); }
    void                setColumnToolTip(int,const uiString&);

    void                setCellToolTip(const RowCol&,const uiString&);

    void                setDefaultRowLabels();
    void                setDefaultColLabels();
    void                setLabelAlignment(Alignment::HPos,bool cols);
    void                setLabelBGColor(int,Color,bool isrow);


    Setup&              setup()                 { return setup_; }
    const Setup&        setup() const           { return setup_; }

    const RowCol&       notifiedCell() const    { return notifcell_; }
    void                setNotifiedCell(const RowCol& rc)
                                                { notifcell_=rc; }
    const TypeSet<int>& getNotifRCs() const
                        { return seliscols_ ? notifcols_ : notifrows_; }
    const TypeSet<RowCol>& getNotifCells() const { return notifcells_; }

    Notifier<uiTable>   valueChanged;
    Notifier<uiTable>   leftClicked;
    Notifier<uiTable>   rightClicked;
    Notifier<uiTable>   doubleClicked;
    Notifier<uiTable>   selectionChanged;

    const RowCol&       newCell() const         { return newcell_; }
    Notifier<uiTable>   rowInserted;
    Notifier<uiTable>   rowDeleted;
    Notifier<uiTable>   selectionDeleted;
    Notifier<uiTable>   colInserted;
    Notifier<uiTable>   colDeleted;
    CNotifier<uiTable,int> rowClicked;
    CNotifier<uiTable,int> columnClicked;

    void                setPixmap(const RowCol&,const uiPixmap&);
    void                setColor(const RowCol&,const Color&);
    Color               getColor(const RowCol&) const;
    void                setHeaderBackground(int,const Color&,bool isrow);
    Color               getHeaderBackground(int,bool isrow) const;

    int                 getIntValue(const RowCol&) const;
    double              getDValue(const RowCol&) const;
    float               getFValue(const RowCol&) const;
    void                setValue(const RowCol&,int);
    void                setValue(const RowCol&,float);
    void                setValue(const RowCol&,float,int nrdec);
    void                setValue(const RowCol&,double);
    void                setValue(const RowCol&,double,int nrdec);

    void                setSelectionMode(SelectionMode);
    void                setSelectionBehavior(SelectionBehavior);
    void                editCell(const RowCol&,bool replace=false);

    mExpClass(uiBase) SelectionRange
    {
    public:
                        SelectionRange()
                            : firstrow_(-1), lastrow_(-1)
                            , firstcol_(-1), lastcol_(-1)       {}

        int             nrRows() const  { return lastrow_-firstrow_+1; }
        int             nrCols() const  { return lastcol_-firstcol_+1; }

        int             firstrow_;
        int             lastrow_;

        int             firstcol_;
        int             lastcol_;
    };


    const ObjectSet<SelectionRange>&    selectedRanges() const;

    SelectionBehavior   getSelBehavior() const;
    int                 maxNrOfSelections() const;

    bool                handleLongTabletPress();
    bool                needOfVirtualKeyboard() const;
    void                popupVirtualKeyboard(int globalx=-1,int globaly=-1);

protected:

    mutable ObjectSet<SelectionRange> selranges_;
    RowCol              notifcell_;
    TypeSet<RowCol>     notifcells_;
    TypeSet<int>        notifrows_;
    TypeSet<int>        notifcols_;
    bool                seliscols_;
    RowCol              newcell_;

    mutable Setup       setup_;

    virtual void        popupMenu(CallBacker*);
    OD::ButtonState     buttonstate_;

    void                geometrySet_(CallBacker*);
    void                updateCellSizes(const uiSize* sz=0);
    void                cellObjChangedCB(CallBacker*);

    bool                getSelected();
    void                removeRCs(const TypeSet<int>&,bool col);
    void                update(bool row,int nr);

    bool                istablereadonly_;

private:

    uiTableBody*        body_;
    uiTableBody&        mkbody(uiParent*,const char*,int,int);
    uiLabel*            cornerlabel_;

    mutable uiSize      lastsz;

public:
    /*mDeprecated*/ double      getdValue( const RowCol& rc ) const
                        { return getDValue( rc ); }
    /*mDeprecated*/ float       getfValue( const RowCol& rc ) const
                        { return getFValue( rc ); }

    void               setPrefWidthInChars(int);
};

#endif