Generated/html/ui3dviewerbody_8h_source.html

#pragma once


/*+

________________________________________________________________________


 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt

 Author:        K. Tingdahl

 Date:          Dec 2011

 RCS:           $Id$

________________________________________________________________________


-*/


#include "uiobjbody.h"


#include "mousecursor.h"

#include "refcount.h"

#include "visosg.h"

#include "uieventfilter.h"


class QGestureEvent;


namespace visBase

{

    class Axes;

    class Camera;

    class PolygonSelection;

    class Scene;

    class SceneColTab;

    class Transformation;

    class ThumbWheel;

    class DataObjectGroup;

}


namespace osgViewer { class CompositeViewer; class View; class GraphicsWindow; }

namespace osgGeo { class TrackballManipulator; }


class ui3DViewer;

class TrackBallManipulatorMessenger;

class KeyBindMan;

class uiMouseEventBlockerByGestures;

class SwapCallback;


namespace osg

{

    class Group;

    class GraphicsContext;

    class Camera;

    class MatrixTransform;

    class Projection;

    class Vec3f;

    class Viewport;

}


namespace osgViewer { class View; }


mClass(uiOSG) ui3DViewerBody : public uiObjectBody

{

    friend class TrackBallManipulatorMessenger;


public:

                                ui3DViewerBody(ui3DViewer&,uiParent*);

    virtual                     ~ui3DViewerBody();


    void                        viewAll(bool animate);


    void                        setSceneID(int);

    visBase::Scene*             getScene()              { return scene_; }

    const visBase::Scene*       getScene() const        { return scene_; }


    bool                        serializeScene(const char*) const;


    void                        setBackgroundColor(const Color&);

    Color                       getBackgroundColor() const;

    Geom::Size2D<int>           getViewportSizePixels() const;


    float                       getMouseWheelZoomFactor() const;

    void                        setMouseWheelZoomFactor(float);


    void                        setReversedMouseWheelDirection(bool);

    bool                        getReversedMouseWheelDirection() const;


    void                        setHomePos(const IOPar&);

    void                        resetToHomePosition();


    void                        toggleCameraType();

    bool                        isCameraPerspective() const;

    bool                        isCameraOrthographic() const;


    void                        align();

    void                        viewPlaneX();

    void                        viewPlaneY();

    void                        viewPlaneZ();

    void                        viewPlaneInl();

    void                        viewPlaneCrl();

    void                        viewPlaneN();

    void                        viewPlaneYZ();


    void                        uiRotate(float angle,bool horizontal);

    void                        uiZoom(float rel,const osg::Vec3f* dir=0);

    void                        setCameraZoom(float val);

    float                       getCameraZoom() const;


                                //Not sure were to put these

    bool                        isViewMode() const;

    virtual void                setViewMode(bool viewmode,bool trigger);


    Coord3                      getCameraPosition() const;

    visBase::Camera*            getVisCamera()          { return camera_; }


    virtual void                reSizeEvent(CallBacker*);

    void                        toggleViewMode(CallBacker*);


    enum WheelMode              { Never, Always, OnHover };

    void                        setWheelDisplayMode(WheelMode);

    WheelMode                   getWheelDisplayMode() const;


    void                        setAnimationEnabled(bool);

    bool                        isAnimationEnabled() const;

    void                        showRotAxis(bool);

    bool                        isAxisShown() const;

    void                        setAnnotColor(const Color&);

    void                        setAnnotationFont(const FontData&);

    visBase::PolygonSelection*  getPolygonSelector();

    visBase::SceneColTab*       getSceneColTab();


    void                        toHomePos();

    void                        saveHomePos();

    bool                        isHomePosEmpty() { return homepos_.isEmpty(); }

    void                        fillCameraPos(IOPar&) const;

    bool                        useCameraPos(const IOPar&);

    const osgViewer::View*      getOsgViewerMainView() const { return view_; }

    const osgViewer::View*      getOsgViewerHudView() const { return hudview_; }

    void                        setScenesPixelDensity(float dpi);


    enum StereoType             { None, RedCyan, QuadBuffer };


    bool                        setStereoType(StereoType);

    StereoType                  getStereoType() const;

    void                        setStereoOffset(float);

    float                       getStereoOffset() const;


    void                        setMapView(bool yn);

    bool                        isMapView() const       { return mapview_; }


    KeyBindMan&                 keyBindMan()            { return keybindman_; }


    void                        removeSwapCallback(CallBacker*);


protected:

    void                                enableDragging( bool yn );


    enum ViewModeCursor                 { RotateCursor, PanCursor, ZoomCursor,

                                          HoverCursor };

    virtual void                        setViewModeCursor( ViewModeCursor );


    virtual void                        updateActModeCursor();

    void                                mouseCursorChg(CallBacker*);

    MouseCursor                         actmodecursor_;


    void                                notifyManipulatorMovement(

                                                    float dh,float dv,float df);

    void                                setupTouch();

    void                                setupHUD();

    void                                setupView();

    void                                qtEventCB(CallBacker*);

    void                                setFocusCB(CallBacker*);

    void                                handleGestureEvent(QGestureEvent*);

    static osgViewer::CompositeViewer*  getCompositeViewer();

    osgGeo::TrackballManipulator*       getCameraManipulator() const;


    virtual osgViewer::GraphicsWindow&  getGraphicsWindow()     = 0;

    virtual osg::GraphicsContext*       getGraphicsContext()    = 0;


    uiObject&                           uiObjHandle();


    void                                requestRedraw();


    osg::Camera*                        getOsgCamera();

    const osg::Camera*                  getOsgCamera() const;

    void                                setCameraPos(const osg::Vec3f&,

                                                     const osg::Vec3f&,bool);


    void                                thumbWheelRotationCB(CallBacker*);

    void                                enableThumbWheelHandling(bool yn,

                                            const visBase::ThumbWheel* tw=0);


    ui3DViewer&                         handle_;

    IOPar&                              printpar_;


    RefMan<visBase::Camera>             camera_;

    RefMan<visBase::Scene>              scene_;

    RefMan<visBase::ThumbWheel>         horthumbwheel_;

    RefMan<visBase::ThumbWheel>         verthumbwheel_;

    RefMan<visBase::ThumbWheel>         distancethumbwheel_;

    int                                 wheeldisplaymode_;


    osg::Switch*                        offscreenrenderswitch_;

    osgViewer::CompositeViewer*         compositeviewer_;

    osgViewer::View*                    view_;

    osg::Viewport*                      viewport_;

    StereoType                          stereotype_;

    float                               stereooffset_;


    osgViewer::View*                    hudview_;

    osg::Switch*                        offscreenrenderhudswitch_;

    RefMan<visBase::DataObjectGroup>    hudscene_;


    uiEventFilter                       eventfilter_;

    uiMouseEventBlockerByGestures&      mouseeventblocker_;

    RefMan<visBase::Axes>               axes_;

    RefMan<visBase::PolygonSelection>   polygonselection_;

    TrackBallManipulatorMessenger*      manipmessenger_;


    SwapCallback*                       swapcallback_;


    IOPar                               homepos_;

    RefMan<visBase::SceneColTab>        visscenecoltab_;


    KeyBindMan&                         keybindman_;


    bool                                mapview_;

};