uigeninput.h

Go to the documentation of this file.

#ifndef uigeninput_h
#define uigeninput_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H. Bril
 Date:          Oct 2000
 RCS:           $Id$
________________________________________________________________________

-*/

#include "uitoolsmod.h"
#include "uigroup.h"
#include "datainpspec.h"
#include "position.h"
#include "uistring.h"

class BinIDValue;
class uiLineEdit;
class uiLabel;
class uiCheckBox;
class uiString;
class uiButton;
class uiGenInputInputFld;
class uiGenInputFieldIdx;
class DataInpSpec;
class UserInputObj;

mExpClass(uiTools) uiGenInput : public uiGroup
{mODTextTranslationClass(uiGenInput)
public:
                        uiGenInput( uiParent* p, const uiString& disptxt
                                  , const char* inputStr=0 );

                        uiGenInput( uiParent* p, const uiString& disptxt,
                            const DataInpSpec& );

                        uiGenInput( uiParent* p, const uiString&,
                            const DataInpSpec& ,const DataInpSpec& );

                        uiGenInput( uiParent* p, const uiString&,
                            const DataInpSpec&, const DataInpSpec&,
                            const DataInpSpec& );

    virtual             ~uiGenInput();

    void                addInput( const DataInpSpec& );

    const DataInpSpec*  dataInpSpec(int nr=0) const;

    bool                newSpec(const DataInpSpec& nw, int nr);

    void                updateSpecs();

    bool                isUndef( int nr=0 ) const;

#undef mDeclArgs
#define mDeclArgs(type) int nr=0, type undefval=mUdf(type)

    const char*         text( mDeclArgs(const char*) ) const;
    const char*         text( const char* undefval)  const
                            { return text(0,undefval); }

    int                 getIntValue( mDeclArgs(int) ) const;
    bool                getBoolValue( mDeclArgs(bool) ) const;

    double              getDValue( mDeclArgs(double) ) const;
    double              getDValue( double undefval ) const
                            { return getDValue(0,undefval) ; }

    float               getFValue( mDeclArgs(float) ) const;
    float               getFValue( float undefval ) const
                            { return getFValue(0,undefval); }

    inline Interval<int> getIInterval( mDeclArgs(int) ) const
                        { return Interval<int>( getIntValue(nr*2,undefval),
                                                getIntValue(nr*2+1,undefval) );}

    inline Interval<float> getFInterval( mDeclArgs(float) ) const
                        { return Interval<float>( getFValue(nr*2,undefval),
                                                  getFValue(nr*2+1,undefval) );}
    inline Interval<float> getFInterval( float undefval ) const
                        { return getFInterval(0,undefval); }

    inline Interval<double> getDInterval( mDeclArgs(double) ) const
                        { return Interval<double>(getDValue(nr*2,undefval),
                                                  getDValue(nr*2+1,undefval) );}
    inline Interval<double> getDInterval( double undefval ) const
                        { return getDInterval(0,undefval); }

    inline StepInterval<int> getIStepInterval( mDeclArgs(int) ) const
                        { return StepInterval<int>(getIntValue(nr*3,undefval),
                                                   getIntValue(nr*3+1,undefval),
                                                   getIntValue(nr*3+2,undefval)
                                                   ); }
    inline StepInterval<float> getFStepInterval( mDeclArgs(float) ) const
                        { return StepInterval<float>(getFValue(nr*3,undefval),
                                                     getFValue(nr*3+1,undefval),
                                                     getFValue(nr*3+2,undefval)
                                                    ); }
    inline StepInterval<float> getFStepInterval( float undefval ) const
                        { return getFStepInterval(0,undefval); }

    inline StepInterval<double> getDStepInterval( mDeclArgs(double) ) const
                        { return StepInterval<double>(getDValue(nr*3,undefval),
                                                 getDValue(nr*3+1,undefval),
                                                 getDValue(nr*3+2,undefval) ); }
    inline StepInterval<double> getDStepInterval( double undefval ) const
                        { return getDStepInterval(0,undefval); }

    Coord               getCoord( mDeclArgs(double) ) const;
    BinID               getBinID( mDeclArgs(int) ) const;
    int                 getTrcNr( mDeclArgs(int) ) const;
    float               getOffset( mDeclArgs(float) ) const;


#undef mDeclArgs

    void                setText(const char*,int nr=0);
    void                setValue(int,int nr=0);
    void                setValue(double,int nr=0);
    void                setValue(float,int nr=0);
    void                setValue(bool,int nr=0);

    inline void         setTexts( const char* v1, const char* v2 )
                        { setText(v1,0); setText(v2,1); }
    inline void         setValues( int v1, int v2 )
                        { setValue(v1,0); setValue(v2,1); }
    inline void         setValues( double v1, double v2 )
                        { setValue(v1,0); setValue(v2,1); }
    inline void         setValues( float v1, float v2 )
                        { setValue(v1,0); setValue(v2,1); }
    inline void         setValues( bool v1, bool v2 )
                        { setValue(v1,0); setValue(v2,1); }
    inline void         setValue( const Coord& c )
                        { setValue(c.x,0); setValue(c.y,1); }
    inline void         setValue( const BinID& b )
                        { setValue(b.inl(),0); setValue(b.crl(),1); }
    inline void         setValue(const BinIDValue&);
    void                setValue(const Interval<int>&); 
    void                setValue(const Interval<float>&); 
    void                setValue(const Interval<double>&); 

    void                displayField(bool yn=true,int elemnr=-1,int fldnr=-1);
    void                setReadOnly( bool yn=true,int elemnr=-1,int fldnr=-1);
    void                setSensitive(bool yn=true,int elemnr=-1,int fldnr=-1);
    void                setEmpty(int nr=-1);

    UserInputObj*       element(int idx);
    uiObject*           rightObj();                     
    int                 nrElements() const;
    void                setElemSzPol( uiObject::SzPolicy p )    { elemszpol_=p;}
    uiObject::SzPolicy  elemSzPol() const               { return elemszpol_; }
    void                setToolTip(const uiString&,int ielem=0);

    virtual const uiString&     titleText();
    virtual void                setTitleText(const uiString&);

    void                setChecked(bool yn);
    bool                isChecked() const       { return checked_; }
    bool                isCheckable() const     { return withchk_ || cbox_; }

    virtual bool        isSingleLine() const            { return true; }

    void                setWithCheck( bool yn=true )    { withchk_ = yn; }
    void                setWithSelect( bool yn=true );

    void                setNrDecimals(int nrdec,int fldnr=0);
    void                setRequired(bool yn=true);

    Notifier<uiGenInput> checked;
    Notifier<uiGenInput> valuechanging;
    Notifier<uiGenInput> valuechanged;
    Notifier<uiGenInput> updateRequested;

protected:

    ObjectSet<uiGenInputInputFld>       flds_;
    TypeSet<uiGenInputFieldIdx>&        idxes_;

    bool                finalised_;

    uiString            selText_;
    bool                withchk_;
    bool                isrequired_;

    uiLabel*            labl_;
    uiString            titletext_;
    uiCheckBox*         cbox_;
    uiButton*           selbut_;

    void                doSelect_(CallBacker*);
    virtual void        doSelect(CallBacker*)   {}
    void                doClear(CallBacker*);

    void                checkBoxSel(CallBacker*);

    uiGenInputInputFld& createInpFld(const DataInpSpec&);
    void                doFinalise(CallBacker*);
    inline DataInpSpec* spec( int nr )
                        {
                            return const_cast<DataInpSpec*>
                                ( ((const uiGenInput*)this)->dataInpSpec(nr) );
                        }

private:

    bool                checked_;

    bool                rdonly_;
    bool                rdonlyset_;

    ObjectSet<DataInpSpec> inputs_;

    uiObject::SzPolicy  elemszpol_;

    DataInpSpec*        getInputSpecAndIndex(const int,int&) const;
    uiGenInputInputFld* getInputFldAndIndex(const int,int&) const;

public:
    /*mDeprecated*/ double getdValue( int nr=0, double uv=mUdf(double) ) const
                            { return getDValue( nr, uv ); }
    /*mDeprecated*/ double getdValue( float undefval ) const
                            { return getDValue(0,undefval); }
    /*mDeprecated*/ float getfValue( int nr=0, float udfval=mUdf(float) ) const
                            { return getFValue( nr, udfval ); }
    /*mDeprecated*/ float getfValue( float undefval ) const
                            { return getFValue(0,undefval); }
    /*mDeprecated*/ bool isChecked();
    /*mDeprecated*/ bool isCheckable()          { return withchk_ || cbox_; }
};


#endif