Widget.H

Go to the documentation of this file.

#ifndef WIDGET_H
#define WIDGET_H

namespace VRG3D {

// forward declaration of WidgetMgr
class WidgetMgr;
typedef ReferenceCountedPointer<WidgetMgr> WidgetMgrRef;



typedef ReferenceCountedPointer<class Widget> WidgetRef;
class Widget : public ReferenceCountedObject
{
public:
  Widget(WidgetMgrRef widgetMgr) {
    _widgetMgr = widgetMgr;
    _isActive = false;
  }
  virtual ~Widget() {}

  virtual bool canReleaseFocus() { return true; }

  virtual bool pointerOverWidget(Vector3 pointerPosRoomSpace) { return false; }

  virtual void activate()   { _isActive = true; }
  virtual void deactivate() { debugAssert(canReleaseFocus()); _isActive = false; }
  virtual void processEvent(EventRef events, Array<EventRef> &generatedEvents) {}
  virtual void doGraphics(RenderDevice *rd) {}
  
  bool isActive() { return _isActive; }

protected:
  bool         _isActive;
  WidgetMgrRef _widgetMgr;
};



class WidgetMgr : public ReferenceCountedObject
{
public:
  WidgetMgr(const std::string &pointerMoveEvent) {
    _pointerEvent = pointerMoveEvent;
  }
  virtual ~WidgetMgr() {}

  void addWidget(WidgetRef widget, bool pointerActivated) {
    _widgets.append(widget);
    if (pointerActivated) {
      _activateOnPointerOver.append(widget);
    }
  }

  void processEvent(EventRef event, Array<EventRef> &generatedEvents) {
    if ((event->getName() == _pointerEvent) && 
        ((_activeWidget.isNull()) || (_activeWidget->canReleaseFocus()))) {
      Vector3 pos = event->getCoordinateFrameData().translation;
      for (int j=0;j<_activateOnPointerOver.size();j++) {
        if (_activateOnPointerOver[j]->pointerOverWidget(pos)) {
          activateWidget(_activateOnPointerOver[j]);
        }
      }
    }
    
    if (_activeWidget.notNull()) {
      _activeWidget->processEvent(event, generatedEvents);
    }
  }

  void doGraphics(RenderDevice *rd) {
    for (int i=0;i<_widgets.size();i++) {
      _widgets[i]->doGraphics(rd);
    }

  }

  bool activateWidget(WidgetRef toActivate) {
    if (_activeWidget.notNull()) {
      if (_activeWidget->canReleaseFocus()) {
        _activeWidget->deactivate();
      }
      else {
        return false;
      }
    }
    _activeWidget = toActivate;
    _activeWidget->activate();
    return true;
  }

private:
  WidgetRef        _activeWidget;
  Array<WidgetRef> _widgets;

  Array<WidgetRef> _activateOnPointerOver;
  std::string      _pointerEvent;
};



} // end namespace

#endif

---