a96ad565c7
I added a new tag to p3d called forward_touch_event_to_device and renamed the existing forward_event_to_device to forward_mouse_event_to_device. This new tag will transmit touches to the virtual trackpad as touch events. I added the MultitouchTrackball to the p3d-app so zooming and moving a model remotely should now work, if you use forward_touch_event_to_device. I kept (and fixed) forward_mouse_event_to_device for background compatibility, so old presentations works as in previous versions, without the ability to zoom + scale. of course. forward_touch_event_to_device needs some more testing, (e.g. with image-streams and keystone, afaik there’s no support for touch-events...) but for a first version it works nice. "
387 lines
11 KiB
C++
387 lines
11 KiB
C++
/* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield
|
|
*
|
|
* This software is open source and may be redistributed and/or modified under
|
|
* the terms of the GNU General Public License (GPL) version 2.0.
|
|
* The full license is in LICENSE.txt file included with this distribution,.
|
|
*
|
|
* This software is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* include LICENSE.txt for more details.
|
|
*/
|
|
|
|
#ifndef SLIDEEVENTHANDLER
|
|
#define SLIDEEVENTHANDLER 1
|
|
|
|
#include <osg/Switch>
|
|
#include <osg/Timer>
|
|
#include <osg/ValueObject>
|
|
#include <osg/ImageSequence>
|
|
|
|
#include <osgGA/GUIEventHandler>
|
|
#include <osgViewer/Viewer>
|
|
|
|
#include <osgPresentation/deprecated/CompileSlideCallback>
|
|
#include <osgPresentation/deprecated/PropertyManager>
|
|
|
|
namespace osgPresentation
|
|
{
|
|
|
|
// forward declare
|
|
class SlideEventHandler;
|
|
|
|
/// Operations related to click to run/load/key events.
|
|
enum Operation
|
|
{
|
|
RUN,
|
|
LOAD,
|
|
EVENT,
|
|
JUMP,
|
|
FORWARD_MOUSE_EVENT,
|
|
FORWARD_TOUCH_EVENT
|
|
};
|
|
|
|
struct JumpData
|
|
{
|
|
JumpData():
|
|
relativeJump(true),
|
|
slideNum(0),
|
|
layerNum(0) {}
|
|
|
|
JumpData(bool in_relativeJump, int in_slideNum, int in_layerNum):
|
|
relativeJump(in_relativeJump),
|
|
slideNum(in_slideNum),
|
|
layerNum(in_layerNum) {}
|
|
|
|
JumpData(const std::string& in_slideName, const std::string& in_layerName):
|
|
relativeJump(true),
|
|
slideNum(0),
|
|
layerNum(0),
|
|
slideName(in_slideName),
|
|
layerName(in_layerName) {}
|
|
|
|
JumpData(const JumpData& rhs):
|
|
relativeJump(rhs.relativeJump),
|
|
slideNum(rhs.slideNum),
|
|
layerNum(rhs.layerNum),
|
|
slideName(rhs.slideName),
|
|
layerName(rhs.layerName) {}
|
|
|
|
JumpData& operator = (const JumpData& rhs)
|
|
{
|
|
if (&rhs==this) return *this;
|
|
relativeJump = rhs.relativeJump;
|
|
slideNum = rhs.slideNum;
|
|
layerNum = rhs.layerNum;
|
|
slideName = rhs.slideName;
|
|
layerName = rhs.layerName;
|
|
return *this;
|
|
}
|
|
|
|
bool requiresJump() const
|
|
{
|
|
if (!slideName.empty() || !layerName.empty()) return true;
|
|
return relativeJump ? (slideNum!=0 || layerNum!=0) : true;
|
|
}
|
|
|
|
bool jump(SlideEventHandler* seh) const;
|
|
|
|
bool relativeJump;
|
|
int slideNum;
|
|
int layerNum;
|
|
|
|
std::string slideName;
|
|
std::string layerName;
|
|
};
|
|
|
|
|
|
struct HomePosition : public virtual osg::Referenced
|
|
{
|
|
HomePosition() {}
|
|
|
|
HomePosition(const osg::Vec3& in_eye, const osg::Vec3& in_center, const osg::Vec3& in_up):
|
|
eye(in_eye),
|
|
center(in_center),
|
|
up(in_up) {}
|
|
|
|
osg::Vec3 eye;
|
|
osg::Vec3 center;
|
|
osg::Vec3 up;
|
|
};
|
|
|
|
struct KeyPosition
|
|
{
|
|
KeyPosition(unsigned int key=0, float x=FLT_MAX, float y=FLT_MAX, bool forward_to_devices = false):
|
|
_key((osgGA::GUIEventAdapter::KeySymbol)key),
|
|
_x(x),
|
|
_y(y),
|
|
_forwardToDevices(forward_to_devices) {}
|
|
|
|
|
|
void set(unsigned int key=0, float x=FLT_MAX, float y=FLT_MAX, bool forward_to_devices = false)
|
|
{
|
|
_key = (osgGA::GUIEventAdapter::KeySymbol)key;
|
|
_x = x;
|
|
_y = y;
|
|
_forwardToDevices = forward_to_devices;
|
|
}
|
|
|
|
osgGA::GUIEventAdapter::KeySymbol _key;
|
|
float _x;
|
|
float _y;
|
|
bool _forwardToDevices;
|
|
};
|
|
|
|
struct LayerCallback : public virtual osg::Referenced
|
|
{
|
|
virtual void operator() (osg::Node* node) const = 0;
|
|
};
|
|
|
|
struct OSGPRESENTATION_EXPORT LayerAttributes : public virtual osg::Referenced
|
|
{
|
|
LayerAttributes():_duration(0) {}
|
|
LayerAttributes(double in_duration):_duration(in_duration) {}
|
|
|
|
void setDuration(double duration) { _duration = duration; }
|
|
double getDuration() const { return _duration; }
|
|
|
|
typedef std::vector<KeyPosition> Keys;
|
|
typedef std::vector<std::string> RunStrings;
|
|
|
|
void setKeys(const Keys& keys) { _keys = keys; }
|
|
const Keys& getKeys() const { return _keys; }
|
|
|
|
void addKey(const KeyPosition& kp) { _keys.push_back(kp); }
|
|
|
|
void setRunStrings(const RunStrings& runStrings) { _runStrings = runStrings; }
|
|
const RunStrings& getRunStrings() const { return _runStrings; }
|
|
|
|
void addRunString(const std::string& runString) { _runStrings.push_back(runString); }
|
|
|
|
void setJump(const JumpData& jumpData) { _jumpData = jumpData; }
|
|
const JumpData& getJumpData() const { return _jumpData; }
|
|
|
|
double _duration;
|
|
Keys _keys;
|
|
RunStrings _runStrings;
|
|
JumpData _jumpData;
|
|
|
|
void addEnterCallback(LayerCallback* lc) { _enterLayerCallbacks.push_back(lc); }
|
|
void addLeaveCallback(LayerCallback* lc) { _leaveLayerCallbacks.push_back(lc); }
|
|
|
|
void callEnterCallbacks(osg::Node* node);
|
|
void callLeaveCallbacks(osg::Node* node);
|
|
|
|
typedef std::list< osg::ref_ptr<LayerCallback> > LayerCallbacks;
|
|
LayerCallbacks _enterLayerCallbacks;
|
|
LayerCallbacks _leaveLayerCallbacks;
|
|
};
|
|
|
|
struct FilePathData : public virtual osg::Referenced
|
|
{
|
|
FilePathData(const osgDB::FilePathList& fpl):filePathList(fpl) {}
|
|
|
|
osgDB::FilePathList filePathList;
|
|
};
|
|
|
|
|
|
struct dereference_less
|
|
{
|
|
template<class T, class U>
|
|
inline bool operator() (const T& lhs,const U& rhs) const
|
|
{
|
|
return *lhs < *rhs;
|
|
}
|
|
};
|
|
|
|
struct ObjectOperator : public osg::Referenced
|
|
{
|
|
inline bool operator < (const ObjectOperator& rhs) const { return ptr() < rhs.ptr(); }
|
|
|
|
virtual void* ptr() const = 0;
|
|
|
|
virtual void enter(SlideEventHandler*) = 0;
|
|
virtual void frame(SlideEventHandler*) {} ;
|
|
virtual void maintain(SlideEventHandler*) = 0;
|
|
virtual void leave(SlideEventHandler*) = 0;
|
|
virtual void setPause(SlideEventHandler*, bool pause) = 0;
|
|
virtual void reset(SlideEventHandler*) = 0;
|
|
|
|
virtual ~ObjectOperator() {}
|
|
};
|
|
|
|
class OSGPRESENTATION_EXPORT ActiveOperators
|
|
{
|
|
public:
|
|
ActiveOperators();
|
|
~ActiveOperators();
|
|
|
|
void collect(osg::Node* incommingNode, osg::NodeVisitor::TraversalMode tm = osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN);
|
|
|
|
void process(SlideEventHandler* seh);
|
|
|
|
void frame(SlideEventHandler*);
|
|
|
|
void setPause(SlideEventHandler* seh, bool pause);
|
|
bool getPause() const { return _pause; }
|
|
|
|
void reset(SlideEventHandler* seh);
|
|
|
|
typedef std::set< osg::ref_ptr<ObjectOperator>, dereference_less > OperatorList;
|
|
|
|
protected:
|
|
|
|
void processOutgoing(SlideEventHandler* seh);
|
|
void processIncomming(SlideEventHandler* seh);
|
|
void processMaintained(SlideEventHandler* seh);
|
|
|
|
bool _pause;
|
|
|
|
OperatorList _previous;
|
|
OperatorList _current;
|
|
|
|
OperatorList _outgoing;
|
|
OperatorList _incomming;
|
|
OperatorList _maintained;
|
|
|
|
};
|
|
|
|
class OSGPRESENTATION_EXPORT SlideEventHandler : public osgGA::GUIEventHandler
|
|
{
|
|
public:
|
|
|
|
SlideEventHandler(osgViewer::Viewer* viewer=0);
|
|
|
|
static SlideEventHandler* instance();
|
|
|
|
META_Object(osgslideshowApp,SlideEventHandler);
|
|
|
|
void set(osg::Node* model);
|
|
|
|
virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&);
|
|
|
|
virtual void getUsage(osg::ApplicationUsage& usage) const;
|
|
|
|
osgViewer::Viewer* getViewer() { return _viewer.get(); }
|
|
|
|
osg::Switch* getPresentationSwitch() { return _presentationSwitch.get(); }
|
|
|
|
enum WhichPosition
|
|
{
|
|
FIRST_POSITION = 0,
|
|
LAST_POSITION = -1
|
|
};
|
|
|
|
void compileSlide(unsigned int slideNum);
|
|
void releaseSlide(unsigned int slideNum);
|
|
|
|
unsigned int getNumSlides();
|
|
|
|
int getActiveSlide() const { return _activeSlide; }
|
|
int getActiveLayer() const { return _activeLayer; }
|
|
|
|
osg::Switch* getSlide(int slideNum);
|
|
osg::Node* getLayer(int slideNum, int layerNum);
|
|
|
|
bool selectSlide(int slideNum,int layerNum=FIRST_POSITION);
|
|
bool selectLayer(int layerNum);
|
|
|
|
bool nextLayerOrSlide();
|
|
bool previousLayerOrSlide();
|
|
|
|
bool nextSlide();
|
|
bool previousSlide();
|
|
|
|
bool nextLayer();
|
|
bool previousLayer();
|
|
|
|
bool home();
|
|
|
|
void setAutoSteppingActive(bool flag = true) { _autoSteppingActive = flag; }
|
|
bool getAutoSteppingActive() const { return _autoSteppingActive; }
|
|
|
|
void setTimeDelayBetweenSlides(double dt) { _timePerSlide = dt; }
|
|
double getTimeDelayBetweenSlides() const { return _timePerSlide; }
|
|
|
|
double getDuration(const osg::Node* node) const;
|
|
|
|
double getCurrentTimeDelayBetweenSlides() const;
|
|
|
|
void setReleaseAndCompileOnEachNewSlide(bool flag) { _releaseAndCompileOnEachNewSlide = flag; }
|
|
bool getReleaseAndCompileOnEachNewSlide() const { return _releaseAndCompileOnEachNewSlide; }
|
|
|
|
void setTimeDelayOnNewSlideWithMovies(float t) { _timeDelayOnNewSlideWithMovies = t; }
|
|
float getTimeDelayOnNewSlideWithMovies() const { return _timeDelayOnNewSlideWithMovies; }
|
|
|
|
void setLoopPresentation(bool loop) { _loopPresentation = loop; }
|
|
bool getLoopPresentation() const { return _loopPresentation; }
|
|
|
|
void dispatchEvent(const KeyPosition& keyPosition);
|
|
void forwardEventToDevices(osgGA::Event* event);
|
|
|
|
void setRequestReload(bool flag);
|
|
bool getRequestReload() const { return _requestReload; }
|
|
|
|
double getReferenceTime() const { return _referenceTime; }
|
|
|
|
protected:
|
|
|
|
~SlideEventHandler() {}
|
|
SlideEventHandler(const SlideEventHandler&,const osg::CopyOp&) {}
|
|
|
|
bool home(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa);
|
|
|
|
void updateAlpha(bool, bool, float x, float y);
|
|
void updateLight(float x, float y);
|
|
|
|
void updateOperators();
|
|
|
|
|
|
osg::observer_ptr<osgViewer::Viewer> _viewer;
|
|
|
|
osg::observer_ptr<osg::Switch> _showSwitch;
|
|
int _activePresentation;
|
|
|
|
osg::observer_ptr<osg::Switch> _presentationSwitch;
|
|
int _activeSlide;
|
|
|
|
osg::observer_ptr<osg::Switch> _slideSwitch;
|
|
int _activeLayer;
|
|
|
|
bool _firstTraversal;
|
|
double _referenceTime;
|
|
double _previousTime;
|
|
double _timePerSlide;
|
|
bool _autoSteppingActive;
|
|
bool _loopPresentation;
|
|
bool _pause;
|
|
bool _hold;
|
|
|
|
bool _updateLightActive;
|
|
bool _updateOpacityActive;
|
|
float _previousX, _previousY;
|
|
|
|
bool _cursorOn;
|
|
|
|
bool _releaseAndCompileOnEachNewSlide;
|
|
|
|
bool _firstSlideOrLayerChange;
|
|
osg::Timer_t _tickAtFirstSlideOrLayerChange;
|
|
osg::Timer_t _tickAtLastSlideOrLayerChange;
|
|
|
|
float _timeDelayOnNewSlideWithMovies;
|
|
|
|
double _minimumTimeBetweenKeyPresses;
|
|
double _timeLastKeyPresses;
|
|
|
|
ActiveOperators _activeOperators;
|
|
|
|
osg::ref_ptr<CompileSlideCallback> _compileSlideCallback;
|
|
|
|
bool _requestReload;
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|