---

component_manager_generic.cpp

Go to the documentation of this file.

/*
        ClanGUI, copyrights by various people. Have a look in the CREDITS file.
        
        This sourcecode is distributed using the Library GNU Public Licence,
        version 2 or (at your option) any later version. Please read LICENSE
        for details.
*/

#include "precomp.h"
#include "API/Core/System/clanstring.h"
#include "API/Core/Resources/resource_manager.h"
#include "API/Core/IOData/inputsource.h"
#include "API/GUI/component_style.h"
#include "component_manager_generic.h"
#include "component_tokenizer.h"
#include "componentfile_preprocess.h"

std::map<std::string, CL_ComponentType *> CL_ComponentManager::component_types;

CL_ComponentManager *CL_ComponentManager::create(const char *resource_id, CL_ResourceManager *res_manager, CL_StyleManager *style)
{
        return new CL_ComponentManager_Generic(resource_id, res_manager, style);
}

CL_ComponentManager *CL_ComponentManager::create(const char *filename, bool is_datafile, CL_StyleManager *style)
{
        return new CL_ComponentManager_Generic(filename, is_datafile, style);
}

CL_ComponentManager_Generic::CL_ComponentManager_Generic(const char *filename, CL_ResourceManager *resources, CL_StyleManager *style)
{
        this->filename = filename;
        this->resources = resources;
        style_manager = style;
//      init_style_manager(style_id);

        input = resources->get_resource_provider()->open_source(filename);
        parse();
}

CL_ComponentManager_Generic::CL_ComponentManager_Generic(const char *filename, bool is_datafile, CL_StyleManager *style)
{
        this->filename = filename;
        style_manager = style;
//      init_style_manager(style_id);

        if (is_datafile)
        {
                input = CL_InputSourceProvider::create_datafile_provider(filename)->open_source(filename);
        }
        else
        {
                input = CL_InputSourceProvider::create_file_provider(".")->open_source(filename);
        }
        
        parse();
}

CL_ComponentManager_Generic::~CL_ComponentManager_Generic()
{
        std::vector<CL_Component *> components;
        get_root_component_list(components);
        
        std::vector<CL_Component *>::iterator it;
        for (it = components.begin(); it != components.end(); it++)
                delete *it;
}

void CL_ComponentManager_Generic::init_style_manager(const char *style_id)
{
/*
        if (style_id == NULL)
        {
                style_manager = CL_StyleManager::default_style_manager;
        }
        else
        {
                std::map<std::string, CL_StyleManager *>::iterator style_it = CL_StyleManager::style_managers.find(style_id);
                if (style_it == CL_StyleManager::style_managers.end()) throw CL_Error("Specified style manager does not exist");
                style_manager = (*style_it).second;
        }
*/
}

void CL_ComponentManager_Generic::create_components(std::multimap<int, CL_ComponentInfo *> &creation_sort_map)
{
        std::multimap<int, CL_ComponentInfo *>::iterator it;
        for (it=creation_sort_map.begin();it!=creation_sort_map.end();it++)
        {
                CL_ComponentInfo *info = (*it).second;

                if (info->component == NULL)
                {
                        info->component = style_manager->create_component(
                                info->type,
                                info->options,
                                NULL);
                }

                if (!info->children.empty())
                {
                        if (!info->component_type->is_container()) 
                        {
                                throw CL_Error("Internal component manager error");
                        }

                        std::list<CL_ComponentInfo *>::iterator c_it;
                        for (c_it=info->children.begin();c_it!=info->children.end();c_it++)
                        {
                                CL_ComponentInfo *child_info = *c_it;
                                if (child_info->component == NULL)
                                {
                                        child_info->component = style_manager->create_component(
                                                child_info->type,
                                                child_info->options,
                                                info->component);
                                }

                                info->component->add_child(child_info->component, true);
                        }
                        info->children.clear();
                }
        }
}

CL_Component *CL_ComponentManager_Generic::get_component(const char *component_id)
{
        std::map<std::string, CL_ComponentManager_Generic::CL_ComponentInfo>::iterator it = component_map.find(component_id);
        if (it != component_map.end()) 
        {
                return (*it).second.component;
        }
        throw CL_Error("Unable to locate component");
}

void CL_ComponentManager_Generic::get_root_component_list(std::vector<CL_Component *> &components)
{
        std::map<std::string, CL_ComponentInfo>::iterator it;
        for (it = component_map.begin(); it != component_map.end();it++)
        {
                if ((*it).second.component->get_parent() == NULL)
                {
                        components.push_back((*it).second.component);
                }
        }
}

std::string CL_ComponentManager_Generic::preprocess_templates()
{
        char *temp_data = new char[input->size()+1];
        input->read(temp_data, input->size());
        temp_data[input->size()] = 0;
        std::string file_data(temp_data);
        delete[] temp_data;

        CL_Componentfile_Preprocess preprocessor(file_data, filename);
        return preprocessor;
}

void CL_ComponentManager_Generic::parse()
{
        CL_ComponentTokenizer lexer(preprocess_templates(), filename);

        typedef std::pair<std::string, CL_ComponentInfo> named_component_t;
        std::stack<named_component_t> component_stack;
        std::multimap<int, CL_ComponentInfo *> creation_sort_map;
        std::map<std::string, int> component_id_enumerator;

        enum EParseState
        {
                PARSE_GLOBAL,
                PARSE_COMPONENT_TYPE,
                PARSE_COMPONENT_NAME,
                PARSE_COMPONENT,
                PARSE_VARIABLE_NAME,
                PARSE_VARIABLE_VALUE
        };
        EParseState state = PARSE_GLOBAL;
        EParseState prev_state = PARSE_GLOBAL;
        std::string component_type;
        std::string component_name;
        std::string variable_name;
        std::list<std::string> variable_value;
        std::string toplevel_style = "";

        while (true)
        {
                const std::string &token = lexer.peek_next_token();
                if (token == "") break;

                CL_ComponentType *comp_type = NULL;
                switch (state)
                {
                case PARSE_GLOBAL:
                        if (token == "style")
                        {
                                if (lexer.peek_next_token() != "=")
                                {
                                        throw CL_Error(lexer.write_error("Missing '=' following global style-declaration"));
                                }
                                prev_state = PARSE_GLOBAL;
                                state = PARSE_VARIABLE_VALUE;
                                variable_name = token;
                        }
                        else if ((comp_type = is_component_type(token)))
                        {
                                state = PARSE_COMPONENT_TYPE;
                                component_type = token;
                                component_name = "";

                                CL_ComponentManager_Generic::CL_ComponentInfo info;
                                info.type = token;
                                info.component = NULL;
                                info.component_type = comp_type;
                                component_stack.push(named_component_t("", info));
                        }
                        else
                        {
                                throw CL_Error(lexer.write_error("Syntax error"));
                        }
                        break;
                case PARSE_COMPONENT_TYPE:
                        if (token == "{")
                        {
                                int next_id = component_id_enumerator[token]++;
                                char buf[20];
                                sprintf(buf, "%d", next_id);
                                if (strlen(buf) == 1) component_name = token+"0"+buf;
                                else component_name = token+buf;
                                component_stack.top().first = component_name;

                                state = PARSE_COMPONENT;
                        }
                        else
                        {
                                component_name = token;
                                component_stack.top().first = component_name;
                                state = PARSE_COMPONENT_NAME;
                        }
                        break;
                case PARSE_COMPONENT_NAME:
                        if (token != "{")
                        {
                                char buf[1000];
                                sprintf(buf, "Missing '{' following declaration of component '%s'", component_name.c_str());
                                throw CL_Error(lexer.write_error(buf));
                        }
                        state = PARSE_COMPONENT;
                        break;
                case PARSE_COMPONENT:
                        {
                                comp_type = is_component_type(token);
                                if (comp_type != NULL)
                                {
                                        if (component_stack.empty())
                                        {
                                                throw CL_Error("Internal component manager parser error");
                                        }
                                        if (!component_stack.top().second.component_type->is_container()) throw CL_Error("Tried to add child to non-container component");

                                        CL_ComponentManager_Generic::CL_ComponentInfo info;
                                        info.type = token;
                                        info.component = NULL;
                                        info.component_type = comp_type;

                                        component_stack.push(named_component_t("", info));
                                        component_type = token;
                                        component_name = "";
                                        state = PARSE_COMPONENT_TYPE;
                                }
                                else if (token == "}")
                                {
                                        if (component_stack.empty())
                                        {
                                                throw CL_Error(lexer.write_error("Found '}' outside component"));
                                        }
                                        named_component_t comp = component_stack.top();
                                        component_stack.pop();

                                        std::pair<std::map<std::string, CL_ComponentManager_Generic::CL_ComponentInfo>::iterator, bool> it = 
                                                component_map.insert(
                                                        std::make_pair(comp.first, comp.second));
                                        
                                        if (!it.second)
                                        {
                                                throw CL_Error("All component names must be unique");
                                        }

                                        // This creation map is used to make sure that components get
                                        // pointers to their parent upon creation.
                                        // This map controls the ordering of component-creations using
                                        // component-nesting level as sorter.
                                        creation_sort_map.insert(std::make_pair(
                                                component_stack.size(),
                                                &(*it.first).second));

                                        if (!component_stack.empty())
                                        {
                                                named_component_t &parent_comp = component_stack.top();
                                                if (!parent_comp.second.component_type->is_container())
                                                {
                                                        throw CL_Error(lexer.write_error("Found component inside other component (must be container)"));
                                                }
                                                else
                                                {
                                                        parent_comp.second.children.push_back(&(*it.first).second);
                                                }
                                        }
                                        else
                                        {
                                                state = PARSE_GLOBAL;
                                        }
                                }
                                else if (token.length() == 1 && lexer.is_operator(token[0]))
                                {
                                        throw CL_Error(lexer.write_error("Expected variable-name or component-type"));
                                }
                                else
                                {
                                        prev_state = PARSE_COMPONENT;
                                        state = PARSE_VARIABLE_NAME;
                                        variable_name = token;
                                        variable_value.clear();
                                }
                        }
                        break;
                case PARSE_VARIABLE_NAME:
                        if (token == "=")
                        {
                                state = PARSE_VARIABLE_VALUE;
                        }
                        else if (token == ";")
                        {
                                if (!component_stack.top().second.component_type->has_option(variable_name))
                                {
                                        char buf[1000];
                                        sprintf(buf, "Failed to add '%s' to component of type '%s'",
                                                variable_name.c_str(),
                                                component_stack.top().second.type.c_str());
                                        throw CL_Error(lexer.write_error(buf));
                                }
                                #ifdef BORLAND
                                component_stack.top().second.options.options.insert(std::make_pair(std::string(variable_name), std::string("")));
                                #else
                                component_stack.top().second.options.options.insert(std::make_pair<std::string, std::string>(variable_name, ""));
                                #endif
                                variable_name = "";
                                variable_value.clear();
                                state = prev_state;
                        }
                        else
                        {
                                throw CL_Error(lexer.write_error("Expected ';' following variable declaration"));
                        }
                        break;
                case PARSE_VARIABLE_VALUE:
                        if (token != ";")
                        {
                                variable_value.push_back(token);
                        }
                        else
                        {
                                if (component_stack.empty())
                                {
                                        globals.push_back(variable_pair_t(variable_name, evaluate_expression(variable_value)));
                                }
                                else if (!component_stack.top().second.component_type->has_option(variable_name))
                                {
                                        std::string variable_value_str;
                                        int size_list = variable_value.size();
                                        std::list<std::string>::iterator it;
                                        for (it=variable_value.begin();it!=variable_value.end();it++)
                                        {
                                                variable_value_str.append(*it);
                                                size_list--;
                                                if (size_list > 0) variable_value_str.append(1, ' ');
                                        }
                                        char buf[1000];
                                        sprintf(buf, "Failed to add '%s = %s' to component of type '%s'",
                                                variable_name.c_str(), 
                                                variable_value_str.c_str(),
                                                component_stack.top().second.type.c_str());
                                        throw CL_Error(lexer.write_error(buf));
                                }
                                else
                                {
                                        component_stack.top().second.options.options.insert(std::make_pair(variable_name, evaluate_expression(variable_value)));
                                }
                                variable_name = "";
                                variable_value.clear();
                                state = prev_state;
                        }
                        break;
                }
                lexer.pop_to_peek();
        }
        create_components(creation_sort_map);
}

CL_ComponentType *CL_ComponentManager_Generic::is_component_type(const std::string &token)
{
        std::map<std::string, CL_ComponentType *>::iterator it = CL_ComponentManager::component_types.find(token);
        if (it == CL_ComponentManager::component_types.end()) return NULL;

        return (*it).second;
}

std::string CL_ComponentManager_Generic::concatenate_stringlist(std::list<std::string> &expression)
{
        std::string result;
        int size_list = expression.size();
        std::list<std::string>::iterator it;
        for (it=expression.begin();it!=expression.end();it++)
        {
                result.append(*it);
                size_list--;
                if (size_list > 0) result.append(1, ' ');
        }
        return result;
}

std::string CL_ComponentManager_Generic::evaluate_expression(std::list<std::string> &expression)
{
        bool is_expression = true;
        std::string result;
        std::list<std::string>::iterator it = expression.begin();
        for (;it!=expression.end();it++)
        {
                std::string &s = *it;
                if (s == "+" || s == "-" || s == "*" || s == "/" || s == "(" || s == ")")
                {
                        continue;
                }
                const char *str = s.c_str();
                for (;*str;str++)
                {
                        if ((*str < '0' || *str > '9') && *str != '.')
                        {
                                break;
                        }
                }
                if (*str)
                {
                        is_expression = false;
                        break;
                }
        }

        if (!is_expression)
        {
                return concatenate_stringlist(expression);
        }

        std::string test = concatenate_stringlist(expression);
        /*
                Please note:
                This expression evaluation function is NOT FINISHED!
                This is a totally basic no-operator-precedence implementation
                that disregards paranthesis and just plain sucks, but 
                I don't have the willpower to complete it - someone else feel free :-)
        */
        int op = 0;
        float result_val = 0.0f;
        for (it=expression.begin();it!=expression.end();it++)
        {
                std::string &s = *it;
                if (s == "+") op = 0;
                else if (s == "-") op = 1;
                else if (s == "*") op = 2;
                else if (s == "/") op = 3;
                else if (s == "(" || s == ")")
                {
                        continue;
                }
                else
                {
                        if (op == -1) throw CL_Error("Could not evaluate expression");
                        float val = atof(s.c_str());
                        switch (op)
                        {
                        case 0:
                                result_val += val;
                                break;
                        case 1:
                                result_val -= val;
                                break;
                        case 2:
                                result_val *= val;
                                break;
                        case 3:
                                result_val /= val;
                                break;
                        default:
                                result_val = val;
                                break;
                        }
                        op = -1;
                }
        }

        int rval = int(result_val+0.5);
        return CL_String(rval);
}

---