gls_menu_set.h

Go to the documentation of this file.

#if !defined(GLS_MENUSET_H)
#define GLS_MENUSET_H

#ifdef WIN32
#pragma warning (disable:4786)
#endif

#include <string>
#include <fstream>
#include <FL/filename.H>

#include "gls_menu_data.h"
#include "util.h"



//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class MenuType_t, class DataFactory_t>
class GlsMenuSet_T
{
public:

    typedef MenuType_t Menu_t;

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    GlsMenuSet_T(GlsMenuDictionary& data) : 
        _currentMenu(0), 
        _menuData(data),
        _menus(new GlsMenuHandlerGroup_T<Menu_t>("Menus", data, _actionHandlers))
    {
        // Register a default action called ShowMenu that chooses a
        // particular menu to currently show.  This allows to navigate
        // a menu system from the menu script files.  A script can
        // contain an action like:
        //    ShowMenu: SUB_MENU
        // which will navigate to a menu named SUB_MENU
        RegisterAction(
            "ShowMenu", 
            GlsFunctor(*this, &GlsMenuSet_T::ShowMenu));

        RegisterAction(
            "Toggle", 
            GlsFunctor(*this, &GlsMenuSet_T::ToggleData));
        RegisterAction(
            "Set", 
            GlsFunctor(*this, &GlsMenuSet_T::SetData));
        RegisterAction(
            "Inc", 
            GlsFunctor(*this, &GlsMenuSet_T::IncData));

        // Deprecated callbacks, still here for backwards support
        RegisterAction(
            "ToggleData", 
            GlsFunctor(*this, &GlsMenuSet_T::ToggleData));
        RegisterAction(
            "SetData", 
            GlsFunctor(*this, &GlsMenuSet_T::SetData));
        RegisterAction(
            "SetDataNoExpand", 
            GlsFunctor(*this, &GlsMenuSet_T::SetDataNoExpand));


        // Initialize the contents of a GlsMenuSet by adding attributes
        // to its attribute dictionary. A menu set has the following 
        // "attributes", each of which are menu data:
        // Data: this is a group of data items that are declared in the
        //       menu script and created at run-time
        // Menus: this defines the menu structure.
        _menuStructure.Add(new DataFactory_t("Data",  _menuData));
        _menuStructure.Add(_menus);
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual ~GlsMenuSet_T()
    {
        std::map<std::string, GlsMenuAction::ActionHandler_t*>::iterator iter;

        for (iter = _actionHandlers.begin(); iter != _actionHandlers.end(); ++iter)
        {
            GlsMenuAction::ActionHandler_t* actionHandler = iter->second;
            if (actionHandler)
            {
                delete actionHandler;
                actionHandler = NULL;
            }
        }

        _actionHandlers.clear();
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Menu_t* Current() const { return _currentMenu; }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void RegisterAction(
        const std::string& name, 
        GlsMenuAction::ActionHandler_t* handler)
    {
        _actionHandlers[name] = handler;
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void SelectItem(const typename Menu_t::ItemId_t& itemId)
    {
        if (_currentMenu)
            _currentMenu->SelectItem(itemId);
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual void Show(const std::string& menuName = "")
    {
        // Ensure there are no leading spaces
        std::string::size_type start(menuName.find_first_not_of(' '));
    
        if (start == std::string::npos)
            start = 0;
    
        // If the menu name is not empty, expand it in case it contains
        // variables.
        disti::AttributeName newMenuName(
            menuName.empty() ? 
                _showMenuName : disti::DecodeString(menuName.substr(start)));

        // If there is no current menu or the current menu's name is not
        // the desired menu to show
        if (!_currentMenu || !(_currentMenu->Name() == newMenuName))
        {
            Menu_t* newMenu = _menus->Item(newMenuName);
            
            if (newMenu)
            {
                // Always invoke hide on the menu being hidden so its
                // actions can be invoked if any.
                if (_currentMenu)
                    _currentMenu->Hide();
                
                _currentMenu = newMenu;
                _showMenuName = _currentMenu->Name();
                
                newMenu->Show();
            }
        }
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual void Read(std::istream& instr)
    {
        _menuStructure.Read(instr);
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void Read(const std::string& filename)
    {
        std::ifstream fstr;
        fstr.open(filename.c_str());

        if (!fstr.is_open())
        {
            fprintf(stderr,"Unable to open file: %s\n", filename.c_str());
            perror("Opening");
            return;
        }

        Read(fstr);
        fstr.close();
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void ReadMenuFiles(
        const std::string& directory, 
        const std::string& ext = "menu")
    {
        const std::string MENU_EXT(disti::Uppercase(ext));
        int fileCount(0);
        dirent** flist = 0;
        std::string fileDir(directory);
        disti::AppendTrailingSlash(fileDir);
        
        fileCount = fl_filename_list(fileDir.c_str(), &flist);

        // Go through the list of files looking for file
        // of type *.{ext} regardless of capitalization.
        for (int fileNum = 0; fileNum < fileCount; ++fileNum)
        {
            std::string fileExt = disti::GetExtension(flist[fileNum]->d_name);
            if( !fileExt.empty() )
            {
                fileExt = disti::Uppercase(fileExt);
            }
            if (fileExt == MENU_EXT)
            {
                std::string menuFile(fileDir + flist[fileNum]->d_name);
                Read(menuFile);

            } // end if
        } // end for
        
        // Free the list of filename strings.
        if (flist)
        {
            for (int i = fileCount - 1; i >= 0; --i)
            {
                free((void*)(flist[i]));
            }
            
            free((void*)flist);
        }
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void Write(std::ostream& outstr)
    {
        _menuStructure.Write(outstr);
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void Write(const std::string& filename)
    {
        std::fstream fstr;
        fstr.open(filename.c_str(), std::ios::out);

        if (!fstr.is_open())
        {
            fprintf(stderr,"Unable to open file: %s\n",filename);
            return;
        }

        // Set some defaults
        fstr.setf(std::ios_base::fixed, std::ios::floatfield);
        fstr.precision(6);

        Write(fstr);
        fstr.close();
    }


protected:

    GlsMenuAction::HandlerCont_t _actionHandlers;

    GlsMenuDictionary  _menuStructure;

    GlsMenuDictionary& _menuData;

    std::string _showMenuName;

    Menu_t* _currentMenu;

    GlsMenuHandlerGroup_T<Menu_t>* _menus;

private:

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void ShowMenu(std::istream& args)
    {
        std::string menuName;
        std::getline(args, menuName);
        Show(menuName);
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void ToggleData(std::istream& args) const
    {
        std::string nameStr;
        std::string val1;
        std::string val2;

        if (   GetQuoted(args, nameStr)
            && GetQuoted(args, val1)
            && GetQuoted(args, val2) )
        {
            disti::AttributeName name(nameStr);

            if (_menuData.ValueString(name) == val1)
                _menuData.ValueString(name, val2);
            else
                _menuData.ValueString(name, val1);
        }

    } 

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void SetData(std::istream& args) const
    {
        std::string name;
        std::string val;

        while (   GetQuoted(args, name)
               && GetQuoted(args, val) )
        {
            _menuData.ValueString(
                disti::AttributeName(name), val);
        }
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void SetDataNoExpand(std::istream& args) const
    {
        std::string name;
        std::string val;

        while (   GetQuoted(args, name)
               && GetQuoted(args, val) )
        {
            _menuData.ValueString(
                disti::AttributeName(name), val);
        }

    } 

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    void IncData(std::istream& args) const
    {
        std::string name;

        if (GetQuoted(args, name))
        {
            int incBy(1);
            args >> incBy;

            GlsMenuData* data = 
                dynamic_cast<GlsMenuData*>(
                _menuData.Get(disti::AttributeName(name)));
            if (data)
                data->Inc(incBy);
        }
    } 

    // = Unimplemented methods, disallow copies
    GlsMenuSet_T (const GlsMenuSet_T&);
    GlsMenuSet_T& operator = (const GlsMenuSet_T&);

}; // end GlsMenuSet_T


#endif // GLS_MENUSET_H