#define __FGEVENTINPUT_HXX
#include "FGCommonInput.hxx"
+
+#include <vector>
+
#include "FGButton.hxx"
#include "FGDeviceConfigurationMap.hxx"
#include <simgear/structure/subsystem_mgr.hxx>
};
typedef SGSharedPtr<FGEventSetting> FGEventSetting_ptr;
-typedef vector<FGEventSetting_ptr> setting_list_t;
+typedef std::vector<FGEventSetting_ptr> setting_list_t;
/*
* A wrapper class for a configured event.
class FGInputDevice;
class FGInputEvent : public SGReferenced,FGCommonInput {
public:
+
/*
* Constructor for the class. The arg node shall point
* to the property corresponding to the <event> node
/*
* access for the name property
*/
- string GetName() const { return name; }
+ std::string GetName() const { return name; }
/*
* access for the description property
*/
- string GetDescription() const { return desc; }
+ std::string GetDescription() const { return desc; }
virtual void update( double dt );
static FGInputEvent * NewObject( FGInputDevice * device, SGPropertyNode_ptr node );
protected:
+ virtual void fire( SGBinding * binding, FGEventData & eventData );
/* A more or less meaningfull description of the event */
- string desc;
+ std::string desc;
/* One of the predefined names of the event */
- string name;
+ std::string name;
/* A list of SGBinding objects */
binding_list_t bindings[KEYMOD_MAX];
class FGAxisEvent : public FGInputEvent {
public:
FGAxisEvent( FGInputDevice * device, SGPropertyNode_ptr node );
+ void SetMaxRange( double value ) { maxRange = value; }
+ void SetMinRange( double value ) { minRange = value; }
+ void SetRange( double min, double max ) { minRange = min; maxRange = max; }
protected:
virtual void fire( FGEventData & eventData );
double tolerance;
double lastValue;
};
+class FGRelAxisEvent : public FGAxisEvent {
+public:
+ FGRelAxisEvent( FGInputDevice * device, SGPropertyNode_ptr node );
+protected:
+ virtual void fire( SGBinding * binding, FGEventData & eventData );
+};
+
+class FGAbsAxisEvent : public FGAxisEvent {
+public:
+ FGAbsAxisEvent( FGInputDevice * device, SGPropertyNode_ptr node ) : FGAxisEvent( device, node ) {}
+protected:
+ virtual void fire( SGBinding * binding, FGEventData & eventData );
+};
+
typedef class SGSharedPtr<FGInputEvent> FGInputEvent_ptr;
/*
*/
class FGInputDevice : public SGReferenced {
public:
- FGInputDevice() : debugEvents(false) {}
- FGInputDevice( string aName ) : name(aName) {}
+ FGInputDevice() : debugEvents(false), grab(false) {}
+ FGInputDevice( std::string aName ) : name(aName), debugEvents(false), grab(false) {}
virtual ~FGInputDevice();
virtual void Send( const char * eventName, double value ) = 0;
- inline void Send( const string & eventName, double value ) {
+ inline void Send( const std::string & eventName, double value ) {
Send( eventName.c_str(), value );
}
virtual const char * TranslateEventName( FGEventData & eventData ) = 0;
- void SetName( string name );
- string & GetName() { return name; }
+ void SetName( std::string name );
+ std::string & GetName() { return name; }
void HandleEvent( FGEventData & eventData );
handledEvents[handledEvent->GetName()] = handledEvent;
}
+ virtual void Configure( SGPropertyNode_ptr deviceNode );
+
virtual void update( double dt );
bool GetDebugEvents () const { return debugEvents; }
- void SetDebugEvents( bool value ) { debugEvents = value; }
+
+ bool GetGrab() const { return grab; }
+
+ const std::string & GetNasalModule() const { return nasalModule; }
private:
// A map of events, this device handles
- map<string,FGInputEvent_ptr> handledEvents;
+ std::map<std::string,FGInputEvent_ptr> handledEvents;
// the device has a name to be recognized
- string name;
+ std::string name;
// print out events comming in from the device
// if true
bool debugEvents;
+
+ // grab the device exclusively, if O/S supports this
+ // so events are not sent to other applications
+ bool grab;
+
+ SGPropertyNode_ptr deviceNode;
+ std::string nasalModule;
};
typedef SGSharedPtr<FGInputDevice> FGInputDevice_ptr;
virtual void postinit();
virtual void update( double dt );
+ const static unsigned MAX_DEVICES = 1000;
+ const static unsigned INVALID_DEVICE_INDEX = MAX_DEVICES + 1;
protected:
static const char * PROPERTY_ROOT;
- void AddDevice( FGInputDevice * inputDevice );
- map<int,FGInputDevice*> input_devices;
+ unsigned AddDevice( FGInputDevice * inputDevice );
+ void RemoveDevice( unsigned index );
+
+ std::map<int,FGInputDevice*> input_devices;
FGDeviceConfigurationMap configMap;
+
+ SGPropertyNode_ptr nasalClose;
};
#endif