X3DPointingDeviceSensorNode.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API 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
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __X3DPOINTINGDEVICESENSORNODE_H__
#define __X3DPOINTINGDEVICESENSORNODE_H__
 
#include <H3D/X3DSensorNode.h>
#include <H3D/X3DGeometryNode.h>
#include <H3D/SFString.h>
 
namespace H3D {
 
  class H3DAPI_API X3DPointingDeviceSensorNode : 
    public X3DSensorNode {
  public:
 
    X3DPointingDeviceSensorNode( Inst< SFString > _description = 0,
                                 Inst< SFBool   > _enabled  = 0,
                                 Inst< SFNode   > _metadata = 0,
                                 Inst< SFBool   > _isActive = 0,
                                 Inst< SFBool   > _isOver = 0 );
 
    virtual ~X3DPointingDeviceSensorNode();
 
    // Fields
    H3DUniquePtr< SFString > description;
 
    H3DUniquePtr< SFBool > isOver;
 
    static void updateX3DPointingDeviceSensors( Node * n,
                                                const Vec3f &from,
                                                const Vec3f &to );
 
    static void updateButtonDependentFields( bool primary_button );
 
    static bool anyIsOver();
 
    static bool anyIsActive();
 
    static inline bool instancesExists() {
      return !instances.empty();
    }
 
    static H3DNodeDatabase database;
 
  protected:
 
    // The SetIsEnabled class is specialized to call setIsEnabled function
    // when the enabled field chances value. If enabled is set to true while
    // the primary pointing device button is pressed then no events are sent
    // until the primary pointing device button is released.
    // If the enabled field is set to false and isActive and isOver are true
    // then those are set to false.
    //
    // - routes_in[0] is the enabled field of X3DPointingDeviceSensorNode
    class H3DAPI_API SetIsEnabled: 
      public AutoUpdate< SFBool > {
    public:
      virtual void setValue( const bool &b, int _id = 0 ) {
        AutoUpdate< SFBool >::setValue( b, _id );
        X3DPointingDeviceSensorNode *pdsn =
          static_cast< X3DPointingDeviceSensorNode * >(owner);
        pdsn->setIsEnabled( pdsn->last_primary_button_value );
      }
    protected:
      virtual void update() {
        AutoUpdate< SFBool >::update();
        X3DPointingDeviceSensorNode *pdsn =
          static_cast< X3DPointingDeviceSensorNode * >(owner);
        pdsn->setIsEnabled( pdsn->last_primary_button_value );
      }
    };
#ifdef __BORLANDC__
    friend class SetIsEnabled;
#endif
 
    // This value is used in onIsOver. Set here instead of sending as argument
    // cause it is more effective to go through all instances of
    // X3DPointingDeviceSensorNodes twice than it is to compare pointers for
    // all devices to know if it should be true or not.
    bool new_value;
 
    // This value must be true for a sensor to become active.
    bool lowest_enabled;
 
    // Called to generate isOver events if they should be
    // generated.
    virtual void onIsOver( NodeIntersectResult * /*result*/ = 0, unsigned int /*closest_index*/ = 0,
                           Matrix4f * /*global_to_local*/ = 0 ) {
      if( is_enabled && ( isActive->getValue() || number_of_active == 0 ) ) {
        if( new_value != isOver->getValue() )
          isOver->setValue( new_value, id );
      }
    }
 
    // To indicate how many active devices there are.
    static int number_of_active;
    
    // used instead of enabled to enable and disable X3DPointingDeviceSensors.
    // correctly.
    bool is_enabled;
 
    // C++ only field.
    H3DUniquePtr< SetIsEnabled > setIsEnabledField;
 
    // Contains information about the last value of the primary button of the
    // pointing device sensor and the intersection points.
    static bool last_primary_button_value;
    static Vec3f last_from;
    static Vec3f last_to;
 
    void setIsEnabled( bool primary_button );
    void setIsActive( bool primary_button );
 
    // Virtual function that should check the isActive field and if it
    // is true then update specific fields. If isActive field is false then
    // reset state of internal variables. Do not call enabled->getValue() in
    // this function.
    // _enabled - Should be treated as enabled->getValue().
    // from - The start of the line segment for which to intersect with.
    // to - The end of the line segment for which to intersect with.
    virtual void setDragOutputEvents( bool /*_enabled*/,
                                      const Vec3f &/*from*/,
                                      const Vec3f &/*to*/ ) {};
 
  private:
    // The instances of X3DPointingDeviceSensorNode that has been created.
    static vector< X3DPointingDeviceSensorNode * > instances;
  };
}
 
#endif