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 <FL/filename.H>
#    include <fstream>
#    include <string>

#    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