flatview.h

Go to the documentation of this file.

#ifndef flatview_h
#define flatview_h
/*+
________________________________________________________________________

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

-*/

#include "generalmod.h"
#include "coltabmapper.h"
#include "datapackbase.h"
#include "draw.h"
#include "mousecursor.h"

class FlatView_CB_Rcvr;
class ZAxisTransform;
namespace ZDomain { class Def; }
namespace FlatView
{

typedef Geom::Point2D<double> Point;
typedef Geom::PosRectangle<double> Rect;

mExpClass(General) AuxData
{
public:

    mExpClass(General) EditPermissions
    {
    public:
                        EditPermissions();

        bool            onoff_;
        bool            namepos_;
        bool            linestyle_;
        bool            linecolor_;
        bool            fillcolor_;
        bool            markerstyle_;
        bool            markercolor_;
        bool            x1rg_;
        bool            x2rg_;
    };


    virtual                     ~AuxData();
    virtual AuxData*            clone() const { return new AuxData(*this); }
    virtual void                touch()                                 {}

    EditPermissions*            editpermissions_;

    bool                        enabled_;       
    BufferString                name_;
    Alignment                   namealignment_;
    int                         namepos_;       
    bool                        fitnameinview_;
    Interval<double>*           x1rg_;          
    Interval<double>*           x2rg_;          

    TypeSet<Point>              poly_;
    TypeSet<MarkerStyle2D>      markerstyles_;
    OD::LineStyle               linestyle_;
    Color                       fillcolor_;
    FillPattern                 fillpattern_;
    int                         zvalue_; 
    MouseCursor                 cursor_;

    bool                        close_;

    void                        setFillPattern( const FillPattern& fp )
                                                { fillpattern_ = fp; }
    bool                        isEmpty() const;
    void                        empty();
    bool                        turnon_;
    bool                        needsupdatelines_;

    // should be protected, don't use.
                                AuxData( const char* nm );
                                AuxData( const AuxData& );
                                friend class Viewer;
};


mExpClass(General) Annotation
{
public:


    mStruct(General) AxisData
    {
                                AxisData();

        BufferString            name_;
        SamplingData<float>     sampling_;
        bool                    showannot_;
        bool                    showgridlines_;
        bool                    reversed_;
        bool                    annotinint_;
        int                     factor_;
        bool                    showauxannot_;
        uiString                auxlabel_;
        OD::LineStyle           auxlinestyle_;
        OD::LineStyle           auxhllinestyle_;
        TypeSet<PlotAnnotation> auxannot_;
        int                     auxPosIdx(float pos,float eps) const;
        void                    showAll(bool yn);
    };


                                Annotation(bool darkbg);
                                ~Annotation();

    BufferString                title_; 
    Color                       color_; 
    AxisData                    x1_;
    AxisData                    x2_;

    bool                        showaux_;
    bool                        showscalebar_;
    bool                        editable_;
    bool                        allowuserchange_;
    bool                        allowuserchangereversedaxis_;

    inline void         setAxesAnnot( bool yn ) 
                        { x1_.showAll(yn); x2_.showAll(yn); }
    inline bool         haveTitle() const
                        { return !title_.isEmpty(); }
    inline bool         haveAxisAnnot( bool x1dir ) const
                        { return color_.isVisible()
                              && ( ( x1dir && x1_.showannot_)
                                || (!x1dir && x2_.showannot_)); }
    inline bool         haveGridLines( bool x1dir ) const
                        { return color_.isVisible()
                              && ( ( x1dir && x1_.showgridlines_)
                                || (!x1dir && x2_.showgridlines_)); }
    //bool              haveAux() const;

    void                fillPar(IOPar&) const;
    void                usePar(const IOPar&);

    static const char*  sKeyAxes();
    static const char*  sKeyX1Sampl();
    static const char*  sKeyX2Sampl();
    static const char*  sKeyShwAnnot();
    static const char*  sKeyShwGridLines();
    static const char*  sKeyIsRev();
    static const char*  sKeyShwAux();
};


mExpClass(General) DataDispPars
{
public:

    mExpClass(General) Common
    {
    public:
                        Common();

        bool                    show_;     // default=true
        bool                    blocky_;   // default=false
        bool                    allowuserchange_;
        bool                    allowuserchangedata_;
        ColTab::MapperSetup     mappersetup_;
    };

    mExpClass(General) VD : public Common
    {
    public:

                        VD()
                        : lininterp_(false) {}

        BufferString    ctab_;
        bool            lininterp_; // Use bi-linear interpol, not poly
    };
    mExpClass(General) WVA : public Common
    {
    public:

                    WVA()
                        : wigg_(Color::Black())
                        , refline_(Color::NoColor())
                        , lowfill_(Color::NoColor())
                        , highfill_(Color::Black())
                        , overlap_(1)
                        , reflinevalue_(mUdf(float))    {}

        Color           wigg_;
        Color           refline_;
        Color           lowfill_;
        Color           highfill_;
        float           overlap_;
        float           reflinevalue_;
    };

                        DataDispPars()          {}

    VD                  vd_;
    WVA                 wva_;
    void                show( bool wva, bool vd )
                        { wva_.show_ = wva; vd_.show_ = vd; }

    void                fillPar(IOPar&) const;
    void                usePar(const IOPar&);

    static const char*  sKeyVD();
    static const char*  sKeyWVA();
    static const char*  sKeyShow();
    static const char*  sKeyDispRg();
    static const char*  sKeyColTab();
    static const char*  sKeyFlipSequence();
    static const char*  sKeyLinearInter();
    static const char*  sKeyBlocky();
    static const char*  sKeyAutoScale();
    static const char*  sKeyClipPerc();
    static const char*  sKeyWiggCol();
    static const char*  sKeyRefLineCol();
    static const char*  sKeyLowFillCol();
    static const char*  sKeyHighFillCol();
    static const char*  sKeyOverlap();
    static const char*  sKeySymMidValue();
    static const char*  sKeyRefLineValue();
};


mExpClass(General) Appearance
{
public:
                        Appearance( bool drkbg=true )
                            : darkbg_(drkbg)
                            , annot_(drkbg)
                            , secondsetaxes_(drkbg)
                            , anglewithset1_(0)         {}

    virtual             ~Appearance()                   {}

    virtual void        fillPar(IOPar&) const;
    virtual void        usePar(const IOPar&);

    Annotation          annot_;
    DataDispPars        ddpars_;

    //Second set of axes, especially handy in case flat viewer is horizontal
    Annotation          secondsetaxes_;
    float               anglewithset1_;

    void                setDarkBG(bool yn);
    bool                darkBG() const          { return darkbg_; }

    void                setGeoDefaults(bool isvert);

protected:

    bool                darkbg_;        
};


mExpClass(General) Viewer
{
public:

                        Viewer();
    virtual             ~Viewer();

    virtual Appearance& appearance();
    const Appearance&   appearance() const
                        { return const_cast<Viewer*>(this)->appearance(); }

    ZAxisTransform*     getZAxisTransform() const
                        { return datatransform_; }
    bool                setZAxisTransform(ZAxisTransform*);
    bool                hasZAxisTransform() const
                        { return datatransform_; }

    void                addPack(::DataPack::ID);
    void                usePack(bool wva,::DataPack::ID,bool usedefs=true );
    void                removePack(::DataPack::ID);
    void                setPack(bool wva,::DataPack::ID id,bool usedefs=true)
                        { addPack( id ); usePack( wva, id, usedefs ); }
    void                clearAllPacks();

    const FlatDataPack* obtainPack(bool wva,bool checkother=false) const;
    bool                hasPack(bool wva) const
                        { return packID(wva)!=DataPack::cNoID(); }
    DataPack::ID        packID(bool wva) const;

    const TypeSet< ::DataPack::ID>&     availablePacks() const  { return ids_; }

    virtual bool        isVertical() const              { return true; }
    bool                isVisible(bool wva) const;
    void                setVisible(bool wva, bool visibility);

    Coord3              getCoord(const Point&) const;

    enum DataChangeType { All=0xFFFFFFFF, BitmapData=0x0001, DisplayPars=0x0002,
                          Annot=0x0004, Auxdata=0x0008 };
    virtual void        handleChange(unsigned int datachangetype)       = 0;
    virtual void        fillAppearancePar( IOPar& iop ) const
                        { appearance().fillPar( iop ); }
    virtual void        useAppearancePar( const IOPar& iop )
                        { appearance().usePar( iop ); }

    void                storeDefaults(const char* key) const;
    void                useStoredDefaults(const char* key);

    void                getAuxInfo(const Point&,IOPar&) const;
    virtual void        showAuxDataObjects(AuxData&,bool)       {}
    virtual void        updateProperties(const AuxData&)        {}
    virtual void        reGenerate(AuxData&)            {}
    virtual void        remove(const AuxData&)          {}

    StepInterval<double> getDataPackRange(bool forx1) const;
    virtual Interval<float> getDataRange(bool wva) const;

    virtual AuxData*            createAuxData(const char* nm) const     = 0;

    virtual int                 nrAuxData() const                       = 0;
    virtual AuxData*            getAuxData(int idx)                     = 0;
    virtual const AuxData*      getAuxData(int idx) const               = 0;
    virtual void                addAuxData(AuxData* a)                  = 0;
    virtual AuxData*            removeAuxData(AuxData* a)               = 0;
    virtual AuxData*            removeAuxData(int idx)                  = 0;
    void                        removeAuxDatas(ObjectSet<AuxData>&);
    void                        removeAllAuxData();
    virtual void                setAnnotChoice(int selannot)            {}
    virtual int                 getAnnotChoice(BufferStringSet&) const
                                { return -1; }
    void                        enableStatusBarUpdate()
                                { needstatusbarupd_ = true; }
    void                        disableStatusBarUpdate()
                                { needstatusbarupd_ = false; }
    bool                        needStatusBarUpdate() const
                                { return needstatusbarupd_; }
    void                        setSeisGeomidsToViewer(TypeSet<Pos::GeomID>&);
    const TypeSet<Pos::GeomID>& getAllSeisGeomids() const;
    void                        setZDomain(const ZDomain::Def&);
    const ZDomain::Info&        zDomain() const;

protected:

    TypeSet< ::DataPack::ID>    ids_;
    Appearance*                 defapp_;
    DataPackMgr&                dpm_;
    ZAxisTransform*             datatransform_;
    FlatView_CB_Rcvr*           cbrcvr_;
    mutable Threads::Lock       lock_;
    bool                        needstatusbarupd_;
    ZDomain::Info*              zdinfo_;

    void                        addAuxInfo(bool,const Point&,IOPar&) const;

private:

    const FlatDataPack*         wvapack_;
    const FlatDataPack*         vdpack_;
    TypeSet<Pos::GeomID>        geom2dids_;

public:
};

} // namespace FlatView

#endif