Controller.h

Go to the documentation of this file.

#pragma once
#include <gmi/iface/GmiInterface.h>
#include <misc/gen/PropertySheetDialog.h>
#include <misc/gen/TClassRegistration.h>
 
namespace sf::gmi
{
 
class _GMI_CLASS Controller
{
  public:
    typedef Value::flt_type value_type;
 
    struct Parameters
    {
        Parameters() = default;
 
        explicit Parameters(int mode)
          : _mode(mode)
        {}
 
        int _mode{0};
    };
 
    Controller(const Parameters&);
 
    virtual ~Controller();
 
    void destroy();
 
    bool initialize();
 
    bool uninitialize();
 
    const ControllerListener::emitter_type& getEventEmitter() const;
 
    bool storeSettings(bool rd);
 
    class _GMI_CLASS Axis
    {
      public:
        EAxisLocation getLocation() const;
 
        AxisMovements getMovements() const;
 
        const char* getName() const;
 
        const char* getDescription() const;
 
        value_type getCurrent(EAxisValueType avt) const;
 
        bool setCurrent(EAxisValueType avt, value_type val);
 
        value_type getAccuracy() const;
 
        value_type getResolution() const;
 
        value_type getMinMax(EAxisMinMax amm) const;
 
        bool setOffset(double ofs);
 
        value_type setOffset() const;
 
        double getTarget(EAxisValueType avt) const;
 
        bool setTarget(EAxisValueType avt, value_type val);
 
        bool setPosition(value_type value);
 
        value_type normalized(value_type pos) const;
 
        bool setMode(EAxisMode mode);
 
        EAxisMode getMode() const;
 
        bool canModeChange(EAxisMode cur_mode, EAxisMode new_mode, bool pos_complete, bool vel_complete, bool con_complete);
 
        typedef TVector<Axis*> PtrVector;
 
      protected:
        Axis(Controller* mc, EAxisLocation);
 
        virtual ~Axis();
 
        AxisMovements _movements;
 
      private:
        Controller& _controller;
        EAxisLocation _location;
 
        friend Controller;
    };
 
    bool homeAxes(bool skip);
 
    bool setJoystick(EJoystickCmd jsc);
 
    EJoystickCmd getJoystick() const;
 
    EAxisLocation getJoystickAxis() const;
 
    bool setJoystickAxis(EAxisLocation axis_loc);
 
    EAxisLocation getPopAxis() const;
 
    bool setPopAxis(EAxisLocation al);
 
    bool setTriggerEnable(bool enable);
 
    bool getTriggerEnable() const;
 
    value_type setTriggerFreq(value_type freq);
 
    value_type getTriggerFreq() const;
 
    //
    // Movement execution related functions and properties.
    //
 
    bool setMovePos(EMovePosCmd mpc);
 
    EMovePosCmd getMovePos() const;
 
    bool setMoveVel(EMoveVelCmd mvc);
 
    EMoveVelCmd getMoveVel() const;
 
    bool setMoveCon(EMoveConCmd mcc);
 
    EMoveConCmd getMoveCon() const;
 
    Axis& getAxis(int axis_loc);
 
    const Axis& getAxis(int axis_loc) const;
 
    Axis& getPhysicalAxis(int axis_num);
 
    virtual void addPropertyPages(PropertySheetDialog* sheet);
 
    bool getCurrent(EAxisValueType avt, AxesCoord& ac) const;
 
    bool setCurrent(EAxisValueType avt, const AxesCoord& coord);
 
    bool getTarget(EAxisValueType avt, AxesCoord& coord) const;
 
    bool setTarget(EAxisValueType avt, const AxesCoord& coord);
 
    bool setTarget(const AxesCoord& pos, const AxesCoord& vel, const AxesCoord& acc, bool linear);
 
    bool setMode(EAxisMode am, const AxesCoord& ac, EAxisMode am_def = amDISABLED);
 
    bool setTriggerAxis(EAxisLocation al);
 
    EAxisLocation getTriggerAxis() const;
 
    value_type getTriggerDensity() const;
 
    bool setTriggerDensity(value_type td);
 
    bool setTriggerMode(bool intern);
 
    bool getTriggerMode() const;
 
    bool setChuckJaw(EChuckJaw cj);
 
    EChuckJaw getChuckJaw() const;
 
    bool isMovePosCompleted() const;
 
    bool isMoveVelCompleted() const;
 
    bool isMoveConCompleted() const;
 
    bool isMoving() const;
 
    bool setPosition(EAxisLocation al, value_type value);
 
    bool setPosition(const AxesCoord& ac);
 
    AxesCoord& normalize(AxesCoord& pos) const;
 
    AxesCoord normalized(const AxesCoord& dist) const;
 
    AxisLocations getRadialUnlimited() const;
 
    virtual void openDebugger() {}
 
    // Information retrieval functions.
    enum EStatus : int
    {
      csError = -1,
      csUninitialized = 0,
      csInitialized,
      csUnhomed,
      csHoming,
      csReady
    };
 
    inline bool isReady() const;
 
    static const char* getAxisName(int axis_loc);
 
    static const char* getAxisDescription(int axis_loc);
 
    static const char* getStatusName(EStatus status);
 
    const char* getStatusName() const;
 
    unsigned getAxisCount() const;
 
    std::string getLastErrorText() const;
 
    /*
     * Parameter manipulation and retrieval functions.
     */
 
    bool getParamInfo(IdType id, ParamInfo& info) const;
 
    bool getParam(IdType id, Value& value) const;
 
    bool setParam(IdType id, const Value& value, bool skip_event);
 
    bool setGetParam(IdType id, Value& value, bool skip_event);
 
    virtual bool handleParam(IdType id, ParamInfo* info, const Value* setval, Value* getval) = 0;
 
    virtual IdType getParamId(EParam param, int axis = std::numeric_limits<int>::max()) const = 0;
 
    virtual bool enumParamIds(IdList& ids) const = 0;
 
    void setParamHook(NotifyProc proc, void* data);
 
    void setResultHook(NotifyProc proc, void* data);
 
    virtual IdType getResultId(EResult result, int axis = std::numeric_limits<int>::max()) const = 0;
 
    virtual bool enumResultIds(IdList& ids) const = 0;
 
    bool getResultInfo(IdType id, ResultInfo& info) const;
 
    virtual bool handleResult(IdType id, ResultInfo* info, BufferInfo* buf_info) = 0;
 
    bool getResultBuffer(IdType id, BufferInfo& buf_info);
 
    bool getAccuracy(AxesCoord& accuracy) const;
 
    bool getResolution(AxesCoord& resolution) const;
 
    bool getMinMax(EAxisMinMax amm, AxesCoord& coord) const;
 
    bool setOffset(const AxesCoord& coord);
 
    bool getOffset(AxesCoord& coord) const;
 
    std::string getProfilePath() const;
 
  protected:
    virtual bool doInitialize(bool) = 0;
 
    virtual bool doSetPosition(EAxisLocation al, value_type);
 
    virtual bool doHomeAxes(bool skip);
 
    void setLastErrorText(const char* text);
 
    void setStatus(EStatus status);
 
    EStatus getStatus() const;
 
    void callParamHook(IdType id);
 
    void callResultHook(IdType id);
 
    void sendPopEvent();
 
  private:
    void sendEvent(EControllerEvent ce);
 
    bool setParam(EParam param, int axis, const Value& value, bool skip_event);
 
    bool getParam(EParam param, int axis, Value& value) const;
 
    void attach(Axis* axis);
 
    Axis* getAxisPtr(int axis_loc);
 
    bool _flagDestroying;
    Axis::PtrVector _axes;
    Axis* _axesMap[alLastEntry];
    Axis _nullAxis;
    std::string _lastErrorText;
    EStatus _status;
    NotifyProc _paramNotifyProc;
    NotifyProc _resultNotifyProc;
    void* _paramNotifyData;
    void* _resultNotifyData;
    bool _noEventGeneration;
    ControllerListener::emitter_type _eventEmitter;
 
    friend Axis;
 
    // Declarations of static functions and data members to be able to create registered RSA implementations.
    SF_DECL_IFACE(Controller, Controller::Parameters, Interface)
};
 
}// namespace sf::gmi
 
// Include all inlined functions and template implementations.
#include <gmi/iface/Controller.hpp>