root/trunk/ElSettings/ElephantSettings.h

#ifndef ELEPHANT_SETTINGS
#define ELEPHANT_SETTINGS

#include "ElSettings.h"
#include "../stdincludes.h"
#include "../StringFunctions.h"

class ElephantBaseSettings : public ISettings { 
public:
    ElephantBaseSettings(const string& p,const string& m = "BaseSettings") : ISettings(p,m) {} 
};


struct ElephantColor
{
    COLORREF fore;
    COLORREF back;
};

class ColorSettings : public ISettings {
public:
    ISettings* settings;
    map<string,ElephantColor> colors;
public:
    ColorSettings(ISettings* _settings) : ISettings("","") , settings(_settings)
    {

    }
    void Restore()
    {

        string keywordTypes = settings->GetCache("keywordTypes");
        vector<string> keywords;
        Split(keywordTypes,",",keywords );      
        for ( int i = 0;i < keywords.size();i++ ) 
        {
            string key = keywords[i] + "_color";
            string colorFore, colorBack, strColors = settings->GetCache(key);
            Split(strColors,colorFore,colorBack);
            
            ElephantColor color;
            color.fore = atol(colorFore.c_str());
            color.back = atol(colorBack.c_str());
            
            colors[key] = color;
            
            
        }       

    }
    void Save()
    {
        std::map<string,ElephantColor>::iterator p = colors.begin();
        while ( p != colors.end() )
        {

            string key = (*p).first;
            ElephantColor color = (*p).second;
//          AfxMessageBox(string(ITOA(color.fore) + " " + ITOA(color.back) ).c_str() );
            settings->SetCache(key,ITOA(color.fore) + " " + ITOA(color.back) );
            p++;
        }

    }
};

class AStyleSettings : public ISettings {
public:
    AStyleSettings(const string& p,const string& m = "AstyleSettings") : ISettings(p,m) {} 
};

class FileExtensions : public ISettings 
{
public:
    FileExtensions(const string& p,const string& m = "FileExtensions") : ISettings(p,m) {} 

};


class EditorSettings : public ISettings 
{
public:
    EditorSettings(const string& p,const string& m = "EditorSettings") : ISettings(p,m) {} 

};


class ScriptSettings : public ISettings 
{
public:
    ScriptSettings(const string& p,const string& m = "ScriptSettings") : ISettings(p,m) {} 

};


class ElephantSettings {
public:
    //vector<string> importPaths;
    //vector<string> keywords;
    map<string,vector<string> > tagSets;
    map<string,string> abbreviations;

    FileExtensions* extensionSettings;
    EditorSettings* editorSettings;
    AStyleSettings* astyleSettings;
    ElephantBaseSettings *baseSettings;
    ColorSettings* colorSettings;
    ScriptSettings* scriptSettings;
    ProjectSpecSettings* pspecSettings;
    string path;
    string fileName;


    ElephantSettings(const string& _path , const string& file) : path(_path) , fileName(file)
    {

        string p = path + "\\" + fileName;
        
        extensionSettings = new FileExtensions(p);
        editorSettings = new EditorSettings(p);
        astyleSettings = new AStyleSettings(p);
        baseSettings = new ElephantBaseSettings(p);
        scriptSettings = new ScriptSettings(p);
        colorSettings = new ColorSettings(editorSettings);
        pspecSettings = new ProjectSpecSettings(path + "\\pspec.ini");

        

        extensionSettings->Restore();
        editorSettings->Restore();
        astyleSettings->Restore();
        baseSettings->Restore();
        colorSettings->Restore();       
        scriptSettings->Restore();
        pspecSettings->Restore();

        vector<string> rp , newRp;
        Split(baseSettings->GetCache("recentProjects"),",",rp);
        for ( int i = 0 ; i < 5; i++ )
        {
            if ( i >= rp.size() ) break;
            else newRp.push_back(rp[i]);
        }

        baseSettings->SetCache("recentProjects",Join(newRp,",") );

//      string imports = baseSettings->GetCache("importPaths");
//      Split(imports,",",importPaths );
//
//      string keys = baseSettings->GetCache("keywords");
//      Split(keys,",",keywords );

        RestoreTagSets(baseSettings->GetCache("tagSets"));
        RestoreAbbs(baseSettings->GetCache("abbreviations") );
    }

    ~ElephantSettings()
    {

        SaveTagSets();
        SaveAbbs();

//      baseSettings->SetCache("importPaths",Join(importPaths,",") );
//      baseSettings->SetCache("keywords",Join(keywords,",") );

SaveAll();

        delete extensionSettings;
        delete astyleSettings;
        delete editorSettings;
        delete baseSettings;
        delete colorSettings;
        delete scriptSettings;
        delete pspecSettings;
        
    }

void SaveAll()
{

    

    baseSettings->Save();
    extensionSettings->Save();
    astyleSettings->Save();
    colorSettings->Save();  
    editorSettings->Save();
    scriptSettings->Save();
    pspecSettings->Save();

} 

private:

    void RestoreTagSets(const string& s ) {
        vector<string> sets ;

        Split(s,",",sets);
        for ( int i = 0; i < sets.size();i++ ) 
        { 
//          AfxMessageBox(sets[i].c_str() );
            string f = baseSettings->GetCache(sets[i]) ;
            vector<string> files;
            Split(f,",",files);
            tagSets[sets[i]] = files;
        }

        

    }

    void RestoreAbbs(const string& s ) {
        abbreviations.clear();
        string p = path + "\\" + fileName;
        //AfxMessageBox(string(p + ".abbs" ).c_str() );
        if (!FileExists(p + ".abbs")) return;
        ifstream in (string(p + ".abbs").c_str() );
        string line, abvs = "";
        while (!in.eof() ) {
            std::getline(in,line);
            abvs += line + "\n";
        }



            
        if ( abvs != "" ) {
                
            Strtok token(&abvs,"||~");
            while (token.HasMoreTokens() ) {
                string key = token.NextToken();

                if (!token.HasMoreTokens() ) break; // last ||~
                    
                abbreviations[key] = token.NextToken();
                abbreviations[key] += "||~" + token.NextToken(); // for CUROSR
                abbreviations[key] += "||~" + token.NextToken(); // for MAINTAIN

            }
        }
        
        
        in.close();
        

    }

    void SaveTagSets()
    {
        vector<string> keys;
        GetKeysForMap(tagSets,keys);
        string tagSetsKey = Join(keys,",");
        baseSettings->SetCache("tagSets",tagSetsKey);
        string files = "";

        for ( int i = 0;i < keys.size();i++)
        {
            baseSettings->SetCache(keys[i],Join(tagSets[keys[i] ],",") );

        }


    }

    void SaveAbbs()
    {
        ofstream out(string(path + ".abbs").c_str() );
        std::map<string,string>::iterator p = abbreviations.begin();
        while ( p != abbreviations.end() )
        {

            string key = (*p).first;
            out << key << "||~"  << abbreviations[key] << "||~"; // this string has ||~CURSOR||~MAINTAIN appended to it,
                                         // which we strip out when we insert it
            p++;
        }
        out.close();

    }

};


#endif