DynamicMenu.h

Go to the documentation of this file.

#ifndef DYNAMICMENU_H
#define DYNAMICMENU_H

#include <vrecko/Ability.h>

#include <osg/Group>
#include <osg/ShapeDrawable>
#include <osgText/Text>

#include <helpers/DynamicArray.h>
#include <helpers/DynamicTree.h>
//#include <xercesc/dom/DOMErrorHandler.hpp>

#include <vreckoAP/ObjectUtils/Animator.h>

#include <vreckoAP/Menu/osgQ_QSection.h>
#include <vreckoAP/Menu/osgQ_QShapeDrawable.h>


using namespace vrecko;


namespace APMenu
{
    class DynamicMenu;

    // Constants for MenuItem::dwFlags (retreived and set by MenuItem::GetFlags() and MenuItem::SetFlags())
    #define MI_F_SELECTED       0x00000001
        // The item is selected
    #define MI_F_EXPANDED       0x00000002
        // The item is expanded


    /* Internal structure of a single MenuItem


    mainTransform
        |
        \- osgTransform
        |   |
        |   \- osgGeode
        |   |   |
        |   |   \- shapeBox          OR    shapeSection
        |   |   |   |                       |
        |   |   |   \- shapeDraw            \- qshapeDraw
        |   |   |
        |   |   \- osgText                          ( <- only for MenuItemText and descendats)
        |   |
        |   \- modelTransform                       ( <- only for MenuItemText and descendats)
        |       |
        |       \- model                            ( <- only for MenuItemText and descendats)
        |
        \- childMenuObject



    */


    class MenuItem : public DynTreeNode<MenuItem>, public BaseClass {
    public:
        MenuItem(DynamicMenu *_owner);
        virtual MenuItem* createNewItem(DynamicMenu* _owner) = 0;
        virtual ~MenuItem();
            // Note that every child of this class should call Destroy() in its destructor.

        virtual void destroy();
            // Here should be all the code required to destroy the graphics & input/outputs etc.
            // (including call to parent's Destroy())

        virtual bool loadParametersFromNode(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* node);

        // The name can be empty. In such case the item will not send events upon selection.
        inline void setName(const char* newName);
        inline const std::string& getName() { return name; }

        bool setFlags(unsigned long dwNewFlags, bool bForceUpdate = false);
            // Combination of MI_F_*
        inline unsigned long getFlags() { return dwFlags; }

        virtual bool invalidate(bool bIncludeSubItems = false);
            // This method is called if anything changing the graphical representation has been changed.
            // This method will discard (= DESTROY COMPLETELY) old grapical representation.
            // If the item was visible, create new graphics and show it.

        bool isPointed(osg::Vec3 *projPointerPos);
            // Is intersected by the pointer, so it should be selected?
            // [projPointerPos] is a pointer position projected onto thwe menu plane.

        virtual bool canBeClicked() { return true; }
        inline bool isVisible() { return bIsVisible; };
        inline bool isGraphicsCreated() { return bGraphicsCreated; };
        virtual bool show(unsigned long _dwItemIndex, unsigned long _dwNumItems,
            osg::Vec3 *_refPoint1, osg::Vec3 *_refPoint2, osg::Vec3 *_refPoint3);
            // This method should not need to be overriden.
        virtual void hide(bool bIncludeSubItems = false);
            // This method should not need to be overriden.

        virtual bool pointerButtonDown() { return true; };
            // Called when the user clicks presses the pointer button on the item (and the item has no children)
        virtual bool pointerButtonUp() { return true; };
            // Called when the user clicks releases the pointer (and the item has no children).
            // Is only called if the pointerButtonDown() was called previously.
        virtual bool pointerMove(osg::Vec3 *projPointerPos) { return true; };
            // Called when the user moves the pointer over the item with an EXCEPTION:
            //    If user puses the pointer button down on AN ITEM, then before the pointer button gets released
            //    this particular ITEM will get all the pointerMove()'s even if the user is pointin outside the item boundaries.
            // (Similiar behaviour as for components in Borland Delphi and possibly in other Windows development GUIs)
        virtual bool clicked() { return true; };
            // Called when the user clicks [pointer button down + up + confirmation animation] on the item (and the item has no children).

        virtual void getClickedString(char *outClickedEventString, size_t bufferSize) { sprintf_s(outClickedEventString, bufferSize, "%s", name.c_str()); }
            // The method should return a string, that is later sent by DynamicMenu to its "clicked" output.
            //      This is usually a name of the item, but could be something more complex, such as "name;value" in case
            //      of a slider. The string can be "" in whick case the Menu will NOT send any event.

        virtual bool setAndPlayConfirmationEffect();
            // This method has two alternative behaviours.
            // It may return "false"
            //      and do nothing else. The DynamicMenu will take action and executes a command
            //      belonging to this item. (executes clicked() method etc.)
            // It may return "true"
            //      in which case the menu item should set up and play confirmation effect
            //      (an animation if it would like) and after playing IT HAVE TO REPORT EVENT
            //      "ConfirmAnimationEnded" with BOOL value "true" to the DynamicMenu ability.
            //      (The Animator ability is designed to report the "AnimationEnded" event
            //      which exactly suits :) )
        virtual bool resetConfirmationEffect();
            // Called after the effect was played (or maybe even in the middle of it!)
            // This method should reset the menu item to the original position.

        inline bool isExpanded() { return (lpChild && lpChild->isVisible()); }
        inline bool canBeExpanded() { return (NULL != lpChild); }

        vrecko::EnvironmentObject* getChildMenuObject() { return childMenuObject.get(); }

    protected:
        DynamicMenu *owner;
        int pos; // position in the current menu level
        bool bIsVisible, bGraphicsCreated;

        unsigned long dwFlags;
            // combination of MI_F_*

        // following variables are initialized every time the MenuItem::Show() is called:
            // MenuItem::show() parameters:
                unsigned long dwItemIndex, dwNumItems;
                osg::Vec3 refPoint1, refPoint2, refPoint3;
            // cached variables, retreived from [owner]
                float itemSize, itemSize2;

        osg::Vec4 color;

        std::string name; // item name
            // (can be empty, in which case the item will not send events upon selection)

        osg::ref_ptr<osg::MatrixTransform> mainTransform;
//      osg::ref_ptr<vrecko::EnvironmentObject> mainTransform;
        osg::ref_ptr<vrecko::EnvironmentObject> childMenuObject;
//      osg::ref_ptr<osg::MatrixTransform> osgTransform;
        osg::ref_ptr<vrecko::EnvironmentObject> osgTransform;
        osg::ref_ptr<osg::Geode> osgGeode;
        APObjectUtils::Animator* childMenuAnimator;

        bool bConfirmationEndedConnectionCreated;
            // Was the "ConfirmationEnded" interconnection already created?

        osg::ref_ptr<osg::Box> shapeBox;
        osg::ref_ptr<osg::ShapeDrawable> shapeDraw;

        osg::ref_ptr<osgQ::QSection> shapeSection;
        osg::ref_ptr<osgQ::QShapeDrawable> qshapeDraw;

        bool createGraphics();
        bool destroyGraphics();

        float menuRadial_CalcItemAngle(int _iItemIndex);
            // the [_iItemIndex] can be even negative or too large

        unsigned long menuBoxes_CalcItemDisplayIndex();

        virtual bool createGraphicsCore();
            // Creates new graphics according to the owner->GetType().
            // The graphics need not to be set according to the flags.
            // The SetFlags() (thus SetFlagsCore()) will be called afterwards.
        virtual bool destroyGraphicsCore();
        virtual bool showGraphicsAtPoint();
        virtual bool hideGraphics();
        virtual bool setFlagsCore(unsigned long dwOldFlags, unsigned long dwNewFlags);
            // Updates the graphics to include the flags (MI_F_SELECTED especially)
        virtual const osg::BoundingBox& getInnerBoundingBox() = 0;
            // Get the bounding box of the inner contents

        virtual bool addInputOutputs();
            // This function is called after setting the name of the item.
            // It should call addOutput() to create an output to signalize
            // clicking on the item (or its changes).
            // Outputs and inputs mut have exactly the same name as is stored in [name]
        virtual bool removeInputOutputs();
            // This function should call removeOutput() / removeInput()
            // to destroy previously created inputs and outputs.

        virtual int processNotification(BaseClass *sender, unsigned long notificationType,
            void *notificationData);
    };


    class MenuItemNull : public MenuItem {
    public:
        MenuItemNull(DynamicMenu* _owner) : MenuItem(_owner) { name = "null"; }
        virtual MenuItem* createNewItem(DynamicMenu* _owner) { return new MenuItemNull(_owner); }

        virtual bool canBeClicked() { return false; }

    protected:
        osg::BoundingBox bbox;

        virtual bool createGraphicsCore() { return true; }
        virtual bool destroyGraphicsCore() { return true; }
        virtual bool showGraphicsAtPoint() { return true; }
        virtual bool hideGraphics() { return true; }
        virtual const osg::BoundingBox& getInnerBoundingBox() { return bbox; }
    };


    class MenuItemText : public MenuItem {
    public:
        MenuItemText(DynamicMenu *_owner);
        virtual ~MenuItemText();
        virtual MenuItem* createNewItem(DynamicMenu* _owner) { return new MenuItemText(_owner); }

        virtual void destroy();

        virtual bool loadParametersFromNode(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* node);

        virtual bool clicked();

        virtual const std::string& getCaption() { return caption; }
        virtual bool setCaption(const char* newCaption);

        virtual const std::string& getModelFile() { return modelFile; }
        virtual bool setModelFile(const char* newModelFile);

        void setSignName(const char* name);

    protected:
        std::string caption;

        std::string modelFile;
        osg::ref_ptr<osg::Node> model;
        osg::ref_ptr<osg::MatrixTransform> modelTransform;

        osg::ref_ptr<osgText::Text> osgText;

        osg::Vec2 textShift;
            // this variable must be set before initialization of graphics

        std::string signName; // name of the sign from the menu's repository
        osg::ref_ptr<osg::Node> signObject; // sign that is currently loaded
        osg::ref_ptr<osg::PositionAttitudeTransform> signTransform;

        virtual bool createGraphicsCore();
        virtual bool destroyGraphicsCore();
        virtual bool showGraphicsAtPoint();
        virtual const osg::BoundingBox& getInnerBoundingBox();

        bool getTextBoundingBox(osg::BoundingBox *outBox);

        osg::BoundingBox boundingBox;

        virtual bool addInputOutputs();
        virtual bool removeInputOutputs();

        virtual bool createModel();
        virtual void destroyModel();
        virtual void repositionModel();
            // Scales and translates the model according the space of the item left
            // around the text (if any)

        virtual void updateText();

        DECLARE_OUTPUT(Clicked, MessageBool);
    };


    class MenuItemSlider : public MenuItemText {
    public:
        MenuItemSlider(DynamicMenu *_owner);
        virtual ~MenuItemSlider();

        virtual MenuItem* createNewItem(DynamicMenu* _owner) { return new MenuItemSlider(_owner); }

        virtual void destroy();

        virtual bool loadParametersFromNode(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* node);

        virtual bool canBeClicked() { return false; }
        virtual bool clicked() { return true; }

        virtual void getClickedString(char *outClickedEventString, size_t bufferSize);

        virtual bool pointerButtonDown();
        virtual bool pointerButtonUp();
        virtual bool pointerMove(osg::Vec3 *projPointerPos);

        virtual float getSliderPos01() { return fSliderPos01; }
        virtual bool setSliderPos01(float fNewSliderPos01, bool bSendEvent = true);

        virtual float getSliderPosXY();
        virtual bool setSliderPosXY(float fNewSliderPos, bool bSendEvent = true) { return setSliderPos01((fNewSliderPos - fSliderFromX) / (fSliderToY - fSliderFromX), bSendEvent); }

    protected:
        float fSliderPos01; // range: 0.0 to 1.0
        bool bSliding; // is pointer dragged by the mouse movement?

        float fSliderFromX, fSliderToY;
        bool bIntegerOnlySlider; // return integers or floats?

        osg::ref_ptr<osg::Cylinder> sliderNonmovable;
        osg::ref_ptr<osg::ShapeDrawable> sliderDrawNM;
        osg::ref_ptr<osg::Box> sliderMovable;
        osg::ref_ptr<osg::ShapeDrawable> sliderDrawM;

        virtual bool createGraphicsCore();
        virtual bool destroyGraphicsCore();
        virtual bool showGraphicsAtPoint();
        virtual const osg::BoundingBox& getInnerBoundingBox();

        virtual bool addInputOutputs();
        virtual bool removeInputOutputs();

        bool updateSliderGraphicPos();

        float getPointerSliderPos01(bool *bIsOutside);
            // Calculates the position of the pointer (TransPointerPos) on the slider.
            // This method will return a number from 0.0 to 1.0 - even when the mouse pointer is far outside,
            // the position will be clipped to this interval, however the [bIsOutside] will be set to "true".
            // [bIsOutside] can be NULL.

        virtual void updateText();

        DECLARE_OUTPUT(Slide, MessageFloat);
    };


    enum MenuType {RadialBoxes, RadialSections, Boxes, Grid};


    class DynamicMenuSign {
    public:
        std::string value;
        osg::ref_ptr<osg::Node> geometry;
    };


    class DynamicMenu: public Ability
    {
        friend class MenuItem;
    public:
        //
        // constructors / destructors
        //
        DynamicMenu();
        virtual ~DynamicMenu();


        DynamicTree<MenuItem> itemTree;

        EnvironmentObject* getOwner() { return owner; };
        EnvironmentObject* getMainObject() { return mainObject.get(); };

//      EnvironmentObject* getInputOuputEO();
            // Get the EO used


        //
        // methods inherited from VRECKO
        //
        virtual void preInitialize();
        virtual void postInitialize();
        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);
        virtual void update();

//      virtual void processEvent(const std::string &strInputName, void *pValue);
//      virtual void *processRequest(const std::string &strInputName, void *pValue);


        // Sets the new menu items
        bool setMenuString(const char *newMenuString);

        bool addMenuItem(MenuItem *parentItem, MenuItem *itemToAdd);
        bool insertMenuItem(MenuItem *parentItem, MenuItem *prevSibling, MenuItem *itemToAdd);

        // Delete MenuItem including its children ("delete [...];" is called too)
        bool deleteMenuItem(MenuItem *item);

        bool registerNewItemType(MenuItem *itemTemplate);

        MenuType getMenuType() { return menuType; }

        inline void setAttribute(const std::string &name, float value) { attributes[name] = value; }
        inline float getAttribute(const std::string &name) { return attributes[name]; }

        void setSign(const std::string &name, const std::string &value);
        osg::Node* getSignObject(const std::string &name);

        inline bool isMainButtonPressed() { return bMainButtonPressed; }
        inline bool isSelectionLocked() { return isMainButtonPressed() || selectedItem; }

        bool showMenu(osg::Vec3 *_menuPos);
        void hideMenu();

        inline osg::Vec3& getProjPointerPos() { return projPointerPos; }
        inline osg::Vec3& getLastPointerPos() { return lastPointerPos; }

        void sendToClickedOutput(char *eventValue);
            // This is for use by MenuItem-s.
            // [eventValue] can be NULL
            // The [eventValue] will be copied (new memory will be created) and sent away

    protected:
        EnvironmentObject *owner;

        std::string baseDirectory;
            // Base menu directory (from where are signs searched for instance).
            // Is determined automatically from the .xml menu file path, but can be
            // overridden in this file.

        int activePointerID;

        osg::Vec3 origMenuPos, origViewPos, origViewUp, origViewLookAt;
            // The position of the menu.
//      osg::Vec3 lastViewPos, lastViewDir;
            // View position and direction from the last ViewMoved() call to detect whether a change occured.
        osg::Vec3 autoMoveShift;
            // If "AutoMoveWithView" attribute is not 0, then this vector is
            // the difference between the current view position and the menu position.
            // (It have to be rotated)
        osg::ref_ptr<EnvironmentObject> mainObject;
        osg::ref_ptr<EnvironmentObject> shadowEO, dispEO;
            // [mainObject] is the main object containing all menu items
            // [shadowEO] is inserted into the scene with its child being [mainObject].
            //     It's rendered after all other objects (excluding [shadowEO]) to prepare the Z-buffer
            // [dispEO] is inserted into the scene with its child also being [mainObject].
            //     It's rendred after [shadowEO] to fially render the geometry.
        osg::Matrix inverseTransformMatrix;
            // Matrix inverse to the transform matrix of the mainObject.
            // It's calculated in UpdateMainObjectTransformation().

        osg::Vec3 lastPointerPos;
            // last pointer position
        osg::Vec3 lastViewPos;
            // last view position
        osg::Vec3 transPointerPos;
            // pointer position transformed into object coordinates
        osg::Vec3 projPointerPos;
            // pointer position projected to the menu plane (X-Y)
        osg::Vec3 transViewPos;
            // view position transformed into object coordinates

        bool bMainButtonPressed;
            // the current state of the main button
        bool bAllowSelectOnRelease;
            // If true, the user will select an item with the button release even if the
            // selection is not locked. (Useful after the start of the menu caused by
            // a button press).

//      std::string strPointerPosReq, strClickedOutput;

        DynamicArray<MenuItem*> registeredItemTypes;

//      osg::Node * loaded_model;

        std::string menuString;
            // may be either XML string describing the menu ('... <menu> ... </menu> ...') or
            // a .xml file name preceded by an asterisk ('*C:\mymenu.xml')

        std::map<std::string, float> attributes;
            // Some common attributes are:
            //  ItemSize (> 0.0)         ... the size of an item (also dependent on the MenuType)
            //  ItemSize2 (> 0.0)        ... "second size" of an item (on Y coordinate usually)
            //  AutoExpand (0 / 1)       ... expand the menu items after selecting by pointer?
            //  AutoRotateToView (0 / 1) ... rotate automatically (like a billboard)
            //  AutoMoveWithView (0 / 1) ... move automatically so it remains on the same screen position
            //  AutoSameDistance (0 / 1) ... the menu will maintain the same distance from the viewer
            //                               (useful if AutoRotate is specified, but AutoMove is not)
            //  AlwaysOnTop (0 / 1)      ... the menu will be on top of any other graphics
            //  ForceMenuDistance
            //          0.0 or less     - no forced distance, the menu will be displayed where the user will request
            //          more than 0.0   - the menu will be displayed in the direction of user click, but with the specified distance
            //  MenuScale                ... scales the whole menu component


        std::map<std::string, DynamicMenuSign*> signs;
            // Graphical signs

        MenuType menuType;

        MenuItem *pointerSelected;
            // an item that is selected by the pointer
        MenuItem *visibleMenuRoot;
            // root of the visible part of the menu (the root item itself is not visible)

        MenuItem *selectedItem;
            // the KEY variable. It determines whether the menu is in "normal" state (selectedItem = NULL) or
            // the menu item has been already selected and the final confirmation effect is being played
            // (selectedItem != NULL). In the latter case, the menu is irresponsive to the user acions.

        // Variables for the temporary cylinder directing from the menu center to the pointer
            osg::ref_ptr<osg::MatrixTransform> osgPointerTrailTransform;
            osg::ref_ptr<osg::Geode> osgPointerTrailGeode;
            osg::ref_ptr<osg::Cylinder> osgPointerTrail;
            osg::ref_ptr<osg::ShapeDrawable> osgPointerTrailDrawable;
    
        bool mainButtonPressed();
        bool mainButtonReleased();

        bool showChildMenu(MenuItem* parentItem, bool bSetNewRoot);
        void hideChildMenu(MenuItem* parentItem = NULL, bool bIncludeSubMenus = true);
        bool isVisible();

        bool showMainMenuObject();
        void hideMainMenuObject();

        void updatePointerPosition();

        void updateMainObjectTransformation();

        void updateInverseCalc();

        bool pointerMoved(osg::Vec3 *pointerPos);
        bool viewMoved();
        bool pointerViewMovedHelper();

        bool createMenuFromString();
        bool createMenuFromNode(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* paramNode);

        bool loadMenuStructureFromNode (XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* paramNode);
        bool loadSignsFromXML(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* attribsNode);
        bool loadAttributes(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* attribsNode);
        bool loadMenuItems(MenuItem *parentItem, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* parentNode);
        void destroyMenuStructure();

        bool createMainObjects();
        void destroyMainObjects();

        bool createPointerTrail();
        void destroyPointerTrail();
        void showPointerTrail();
        void hidePointerTrail();

        bool pointerUnselectItem(bool bLeaveSelectedIfLocked = true);
            // [bLeaveSelectedIfLocked] will cause the item to remain selected
            // if the menu button is down (so the menu item is "locked")
        bool pointerSelectItem(MenuItem *item);
        bool solvePointerSelection();
            // Search for the menu item that is selected
        MenuItem* getPointedItemRecursive(MenuItem *parent, int *depth);
            // Retreive the pointed MenuItem with the maximum depth.
            // [depth] is the depth of the parent item at the call of the function
            // and depth of the pointed item at the finish of the function.
            // (The [parent] won't be tested)

        bool expandItem(MenuItem *item);
        bool collapseItem(MenuItem *item);
        bool collapseSiblings(MenuItem *item);

        void itemClicked(MenuItem *item);

        void confirmAnimationEnded();

        void resetBaseValues();
        void initStandardSignSet();
        void changeToStructureOccured();


        bool unselectItem();
            // Unselects a selected item (if there is any). Also stops its effect if it is being played
            // and resets is position back to normal.


        int menuGrid_columnsCached, menuGrid_rowsCached;
            // If either of the values is equal to -1, then the values will
            // be recalculated in the menuGrid_getSize() method. Otherwise the
            // method just returns the cached values.
        void menuGrid_getSize(int *columns, int *rows);
            // This method will return both values greater than 0 in every case.

        DECLARE_INPUT(Create, MessageString);
        DECLARE_INPUT(ButtonPress, MessageBool);
        DECLARE_INPUT(ConfirmAnimationEnded, MessageBool);

        DECLARE_OUTPUT(Clicked, MessageString);
        DECLARE_OUTPUT(HidingMenu, MessageBool);

        DECLARE_REQUEST_INPUT(ActivePointerID, MessageInt, MessageInt);

        DECLARE_REQUEST_OUTPUT(PointerPosition, MessageInt, MessageVec3);
    };

}



#endif