ofxsInteract.h

Go to the documentation of this file.

#ifndef _ofxsInteract_H_
#define _ofxsInteract_H_
/*
OFX Support Library, a library that skins the OFX plug-in API with C++ classes.
Copyright (C) 2004-2005 The Foundry Visionmongers Ltd
Author Bruno Nicoletti bruno@thefoundry.co.uk

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name The Foundry Visionmongers Ltd, nor the names of its 
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The Foundry Visionmongers Ltd
1 Wardour St
London W1D 6PA
England



*/

#include "ofxsParam.h"

#include <list>

#define mDeclareProtectedAssignAndCC(CLASS) \
  CLASS &operator=(const CLASS &v1) {assert(false); return *this;}      \
  CLASS(const CLASS &v) {assert(false); } 

namespace OFX {

  class ImageEffect;

  struct InteractArgs {
    InteractArgs(const PropertySet &props);
    double          time;              
    OfxPointD       renderScale;       
  };

  struct DrawArgs : public InteractArgs {
    DrawArgs(const PropertySet &props);

    OfxPointD       pixelScale;        
    OfxRGBColourD   backGroundColour;  
  };

  struct PenArgs : public InteractArgs {
    PenArgs(const PropertySet &props);

    OfxPointD       pixelScale;        
    OfxPointD       penPosition;       
    double          penPressure;       
  };

  struct KeyArgs : public InteractArgs {
    KeyArgs(const PropertySet &props);

    int             keySymbol;         
    std::string     keyString;         
  };

  struct FocusArgs : public InteractArgs {
    FocusArgs(const PropertySet &props);

    OfxPointD       pixelScale;        
    OfxRGBColourD   backGroundColour;  
  };

  class Interact {
  protected :
    OfxInteractHandle  _interactHandle;     
    PropertySet        _interactProperties; 
    std::list<Param *> _slaveParams;        
    ImageEffect *_effect;                   
  public : 
    Interact(OfxInteractHandle handle);

    virtual ~Interact(); 

    PropertySet &getProperties() { return _interactProperties; }

    int getBitDepth(void) const;

    bool hasAlpha(void) const;

    OfxPointD getPixelScale(void) const;

    OfxRGBColourD getBackgroundColour(void) const;

    void addParamToSlaveTo(Param *p);

    void removeParamToSlaveTo(Param *p);

    void requestRedraw(void) const;

    void swapBuffers(void) const;

    // override the below in derived classes to do something useful

    virtual bool draw(const DrawArgs &args);

    virtual bool penMotion(const PenArgs &args);

    virtual bool penDown(const PenArgs &args);

    virtual bool penUp(const PenArgs &args);

    virtual bool keyDown(const KeyArgs &args);

    virtual bool keyUp(const KeyArgs &args);

    virtual bool keyRepeat(const KeyArgs &args);

    virtual void gainFocus(const FocusArgs &args);

    virtual void loseFocus(const FocusArgs &args);
  };

  class OverlayInteract : public Interact {
  public :
    OverlayInteract(OfxInteractHandle handle);

    virtual ~OverlayInteract();
  };

  class InteractDescriptor
  {
  public:
    InteractDescriptor():_props(0) {}
    virtual ~InteractDescriptor() {}
    void setPropertySet(OFX::PropertySet* props){ _props = props; }
    virtual Interact* createInstance(OfxInteractHandle handle, ImageEffect *effect) = 0;
    void setHasAlpha();
    bool getHasAlpha() const;
    void setBitDepth();
    int getBitDepth() const;
    virtual OfxPluginEntryPoint* getMainEntry() = 0;
    virtual void describe() {}
  protected:
    OFX::PropertySet* _props;
  };

  typedef InteractDescriptor EffectOverlayDescriptor;

  class ParamInteractDescriptor : public InteractDescriptor
  {
  public:
    ParamInteractDescriptor():InteractDescriptor(){}
    virtual ~ParamInteractDescriptor() {}
    void setInteractSizeAspect(double asp);
    void setInteractMinimumSize(int x, int y);
    void setInteractPreferredSize(int x, int y);
    virtual void setParamName(const std::string& pName) { _paramName = pName; }
  protected:
    std::string _paramName;
  };

  class ParamInteract : public Interact 
  {
  public:
    ParamInteract(OfxInteractHandle handle, ImageEffect* effect);
    virtual ~ParamInteract() {}
    double getInteractSizeAspect() const;
    OfxPointI getInteractMinimumSize() const;
    OfxPointI getInteractPreferredSize() const;
    OfxPointI getInteractSize() const;
  protected:
    ImageEffect* _effect;
  };

  namespace Private
  {
    OfxStatus interactMainEntry(const char              *actionRaw,
      const void                *handleRaw,
      OfxPropertySetHandle       inArgsRaw,
      OfxPropertySetHandle       outArgsRaw,
      InteractDescriptor& desc);
  }

  template<class DESC>
  class InteractMainEntry
  {
  protected:
    static OfxStatus overlayInteractMainEntry(const char *action, const void* handle, OfxPropertySetHandle in, OfxPropertySetHandle out)
    {
      static DESC desc;
      return OFX::Private::interactMainEntry(action, handle, in, out, desc);
    }
  };

  template<class DESC, class INSTANCE>
  class DefaultEffectOverlayDescriptor : public EffectOverlayDescriptor, public InteractMainEntry<DESC>
  {
  public:
    Interact* createInstance(OfxInteractHandle handle, ImageEffect *effect) { return new INSTANCE(handle, effect); }
    virtual OfxPluginEntryPoint* getMainEntry() { return InteractMainEntry<DESC>::overlayInteractMainEntry; }
  };

  template<class DESC, class INSTANCE>
  class DefaultParamInteractDescriptor : public ParamInteractDescriptor, public InteractMainEntry<DESC>
  {
  public:
    Interact* createInstance(OfxInteractHandle handle, ImageEffect *effect) { return new INSTANCE(handle, effect, _paramNameStatic); }
    virtual OfxPluginEntryPoint* getMainEntry() { return InteractMainEntry<DESC>::overlayInteractMainEntry; }
    virtual void setParamName(const std::string& pName) { _paramNameStatic = pName; }
  protected:
    static std::string _paramNameStatic;
  };

  template<class DESC, class INSTANCE> std::string OFX::DefaultParamInteractDescriptor<DESC, INSTANCE>::_paramNameStatic;
};


#undef mDeclareProtectedAssignAndCC

#endif

---