moConfig.h

Go to the documentation of this file.

/*******************************************************************************

                               moConfig.h

  ****************************************************************************
  *                                                                          *
  *   This source 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.                                    *
  *                                                                          *
  *   This code 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.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa

*******************************************************************************/

#ifndef __MO_CONFIG_H__
#define __MO_CONFIG_H__

#include "moTypes.h"
#include "moText.h"
#include "moParam.h"
#include "moArray.h"
#include "moPreConfig.h"

#define MO_PARAM_NOT_SEL  -1
#define MO_PARAM_NOT_FOUND  -1
#define MO_CONFIGFILE_NOT_FOUND  -1
#define MO_CONFIG_OK 0
#define MO_SELECTED -1


class LIBMOLDEO_API moConfigDefinition : public moAbstract
{
    public:

        moConfigDefinition();

        virtual ~moConfigDefinition();

    moConfigDefinition( const moConfigDefinition& p_src );

    moConfigDefinition& operator =( const moConfigDefinition& p_src );


    void Add( const moText& p_name, moParamType p_type, int p_index=-1, const moValue& p_defaultvalue = moValue("INVALID",MO_VALUE_UNDEFINED), const moText& p_OptionsStr = moText("") );


    moParamDefinitions* GetParamDefinitions() {
    return &m_ParamDefinitions;
    }


    moParamIndexes& ParamIndexes() { return m_ParamIndexes; }


    void Set( moText p_objectname, moText p_objectclass ) {
        m_ObjectName = p_objectname;
        m_ObjectClass = p_objectclass;
    }


    const moText& GetObjectName() {
        return m_ObjectName;
    }


    const moText& GetObjectClass() {
        return m_ObjectClass;
    }


    bool SetParamIndex( int defined_array_index, moParamIndex paramindex );
    bool SetIndex( moText p_name, MOint p_index);


    bool Exists( moText p_name );

    const moParamDefinition& GetParamDefinition( const moText& p_param_name );

    const moText& ToJSON();

    private:

        moParamDefinitions  m_ParamDefinitions;

        moParamIndexes      m_ParamIndexes;

        moText              m_ObjectName;
        moText              m_ObjectClass;

    moText              m_FullJSON;
};

#define moDefineParamIndex(X,Y) if ( m_Config.GetConfigDefinition()!=NULL) {\
                                    int pidx = (MOint)m_Config.GetParamIndex(Y);\
                                    if (pidx>-1) {\
                                      if (!m_Config.GetConfigDefinition()->SetParamIndex( (int)X, moParamIndex(pidx))) {\
                                        MODebug2->Warning( "<"+m_Config.GetObjectClass()+">["+m_Config.GetObjectName()+"]::Init()_moDefineParamIndex > Config parameter \"" + moText(Y) + moText("\"  warning. Bad indexation could cause errors."));\
                                      }\
                                    } else MODebug2->Error( m_Config.GetObjectClass()+": "+m_Config.GetObjectName()+ " parameter \"" + moText(Y) + moText("\" not found."));\
                                }

class LIBMOLDEO_API moConfig
{
    public:

        moConfig();

        virtual ~moConfig();


        void Set( moText p_objectname, moText p_objectclass ) {
            m_ConfigDefinition.Set( p_objectname, p_objectclass);
        }


        const moText& GetObjectName() {
            return m_ConfigDefinition.GetObjectName();
        }


        const moText& GetObjectClass() {
            return m_ConfigDefinition.GetObjectClass();
        }


        const moText& GetName() { return m_FileName; }


        moParams&               GetParams();



        MOboolean               IsConfigLoaded();


        int                     LoadConfig( moText p_filename );


        void                        FixConfig();


        void        Indexation();


        MOboolean               CreateDefault( const moText &p_fullconfigfilename );


        void                    UnloadConfig();


        int                     SaveConfig( moText p_filename = moText(""));


        void                    DeleteConfig();


        moText                  GetFullText();


        MOuint                      GetValuesCount( int p_paramindex );


        moValue&                GetValue( moText nameparam, int indexvalue = -1 );//el valor seleccionado del parametro


        moValue&                GetValue( int indexparam, int indexvalue = -1 );//el valor seleccionado del parametro



        MOint                   Int( moParamReference p_paramreference );
        MOint                   Int( moText p_param_name );


        MOdouble                   Double( moParamReference p_paramreference );
        MOdouble                   Double( moText p_param_name );


        moText                   Text( moParamReference p_paramreference );
        moText                   Text( moText p_param_name );
        moText                   Text( int p_param_index );


        MOdouble                   Eval( moParamReference p_paramreference, double x, ... );
        MOdouble                   Eval( moParamReference p_paramreference);
        MOdouble                   Eval( moText p_param_name, double x, ... );
        MOdouble                   Eval( moText p_param_name );

        moVector4d                 EvalColor( moParamReference p_paramreference );
        moVector4d                 EvalColor( moParamReference p_paramreference, double x, ... );


        GLint       GetGLId( moParamReference p_paramreference, MOfloat p_cycle, MOfloat p_fade, const moTextFilterParam &p_filterparam );
        GLint       GetGLId( moParamReference p_paramreference, moTempo *p_tempo, MOfloat p_fade, const moTextFilterParam &p_filterparam );
        GLint       GetGLId( moParamReference p_paramreference, MOuint p_i, MOfloat p_fade, const moTextFilterParam &p_filterparam );
        GLint       GetGLId( moParamReference p_paramreference, MOfloat p_fade, const moTextFilterParam &p_filterparam );
    
    GLint       GetGLId( moParamReference p_paramreference, MOfloat p_cycle);
    GLint       GetGLId( moParamReference p_paramreference, moTempo *p_tempo );
    GLint       GetGLId( moParamReference p_paramreference, MOuint p_i );
    GLint       GetGLId( moParamReference p_paramreference );


        moMathFunction&               Fun(  moParamReference p_paramreference );
        const moFont&                 Font( moParamReference p_paramreference );
        const moTextureBuffer&        TextureBuffer(  moParamReference p_paramreference );
        const moSceneNode&            Model(  moParamReference p_paramreference );
        const moVector2d&             Vector2d( moParamReference p_paramreference );
        const moVector2i&             Vector2i( moParamReference p_paramreference );
        const moVector3d&             Vector3d( moParamReference p_paramreference );
        const moVector3i&             Vector3i( moParamReference p_paramreference );
        const moVector4d&             Vector4d( moParamReference p_paramreference );
        const moVector4i&             Vector4i( moParamReference p_paramreference );
        const moDataMessage&          Message(  moParamReference p_paramreference );
        const moDataMessages&         Messages( moParamReference p_paramreference );
        moSound&                Sound(  moParamReference p_paramreference );
        const moTexture&              Texture(  moParamReference p_paramreference );



        moParam&                operator [] ( MOint p_paramindex ) {
          return GetParam( p_paramindex );
        }


        moParam&                operator [] ( moText p_paramname ) {
          return GetParam( p_paramname );
        }


        moParam&                operator [] ( moParamIndex p_paramindex ) {
          return GetParam(p_paramindex.index );
        }


        moParam&                operator [] ( moParamReference p_paramreference ) {
          return GetParam( m_ConfigDefinition.ParamIndexes().Get(p_paramreference.reference) );
        }


        moParam&                GetCurrentParam();


        moParam&                GetParam( MOint p_paramindex = -1 );


        moParam&                GetParam( moText    p_paramname );


        moParam&                GetParam( moParamIndex p_paramindex ) {
          return GetParam(p_paramindex.index );
        }


        moParam&                GetParam( moParamReference p_paramreference ) {
          return GetParam( m_ConfigDefinition.ParamIndexes().Get(p_paramreference.reference) );
        }



        int                     GetParamsCount();


        int                     GetCurrentValueIndex( MOint p_paramindex );


        int                     GetParamIndex( moText p_paramname);


        int                     GetCurrentParamIndex() const;


        bool                    SetCurrentParamIndex( int);

        bool                    SetCurrentParam( const moText& p_param_name ) {
          return SetCurrentParamIndex( GetParamIndex( p_param_name ) );
        }

        void                    FirstParam();

        void                    NextParam();

        void                    PrevParam();


        void                    SetCurrentValueIndex( int p_paramindex, int p_valueindex );


        moValue&                GetCurrentValue();

        bool                    FirstValue();

        bool                    NextValue();

        bool                    PreviousValue();


        moConfigDefinition*     GetConfigDefinition();



        MOint                   GetPreConfCount();


        MOint                   GetCurrentPreConf();


        void                    SetCurrentPreConf( MOint p_actual );

        void                    PreConfFirst();

        void                    PreConfNext();

        void                    PreConfPrev();





        void                    AddValue( int paramindex,  moValue& p_value );

        void                    InsertValue( int paramindex,  int valueindex, moValue& p_value );

        void                    SetValue( int paramindex,  int valueindex, moValue& p_value );

        void                    DeleteValue( int paramindex,  int valueindex );


        const moPreConfig& GetPreconfig( int valueindex );

        void                    AddPreconfig( moPreconfigIndexes& p_preconfindexes );

        void AddPreconfig( int preconfig_index);

        void                    InsertPreconfig( int valueindex, moPreconfigIndexes& p_preconfindexes );

        void                    SetPreconfig( int valueindex, moPreconfigIndexes& p_preconfindexes );

        void                    DeletePreconfig( int valueindex );

        const moText&  ToJSON();

    private:

        MOboolean               m_ConfigLoaded;
        moParams                m_Params;//los parametros del config
        moPreConfigs            m_PreConfigs;
        moConfigDefinition      m_ConfigDefinition;

        MOint                   m_MajorVersion;
        MOint                   m_MinorVersion;
        moText                  m_FileName;

        int                     m_CurrentParam;// el indice que indica cual es el parametro actual.
        MOint                   m_PreconfParamNum;
        MOint                   m_PreconfActual;

    static moFont*         m_pFont;
        static moMathFunction* m_pFun;
        static moTextureBuffer* m_pTextureBuffer;
        static moSceneNode*            m_pModel;
        static moVector2d*             m_pVector2d;
        static moVector2i*             m_pVector2i;
        static moVector3d*             m_pVector3d;
        static moVector3i*             m_pVector3i;
        static moVector4d*             m_pVector4d;
        static moVector4i*             m_pVector4i;
        static moDataMessage*          m_pMessage;
        static moDataMessages*         m_pMessages;
        static moSound*                m_pSound;
        static moTexture*              m_pTexture;


    void CreateParam( moParamDefinition& p_ParamDef );

    moText        m_FullJSON;
};

#endif