示例#1
0
文件: common.c 项目: sfionov/mc-dev
gboolean
mc_config_read_file (mc_config_t * mc_config, const gchar * ini_path)
{
    mc_config_t *tmp_config;
    gchar **groups, **curr_grp;
    gchar **keys, **curr_key;
    gchar *value;

    if (mc_config == NULL) {
        return FALSE;
    }

    tmp_config = mc_config_init (ini_path);
    if (tmp_config == NULL)
        return FALSE;

    groups = mc_config_get_groups (tmp_config, NULL);

    for (curr_grp = groups; *curr_grp != NULL; curr_grp++) {
        keys = mc_config_get_keys (tmp_config, *curr_grp, NULL);
        for (curr_key = keys; *curr_key != NULL; curr_key++) {
            value = g_key_file_get_value (tmp_config->handle, *curr_grp, *curr_key, NULL);
            if (value == NULL)
                continue;

            g_key_file_set_value (mc_config->handle, *curr_grp, *curr_key, value);
            g_free (value);
        }
        g_strfreev (keys);
    }
    g_strfreev (groups);
    mc_config_deinit (tmp_config);
    return TRUE;
}
示例#2
0
文件: setup.c 项目: ginggs/maemo-mc
static void
load_keymap_from_section (const char *section_name, GArray * keymap, mc_config_t * cfg)
{
    gchar **profile_keys, **keys;

    if (section_name == NULL)
        return;

    keys = mc_config_get_keys (cfg, section_name, NULL);

    for (profile_keys = keys; *profile_keys != NULL; profile_keys++)
    {
        gchar **values;

        values = mc_config_get_string_list (cfg, section_name, *profile_keys, NULL);
        if (values != NULL)
        {
            int action;

            action = keybind_lookup_action (*profile_keys);
            if (action > 0)
            {
                gchar **curr_values;

                for (curr_values = values; *curr_values != NULL; curr_values++)
                    keybind_cmd_bind (keymap, *curr_values, action);
            }

            g_strfreev (values);
        }
    }

    g_strfreev (keys);
}
示例#3
0
文件: history.c 项目: BrEacK/mc
/**
 * Load history form the mc_config
 */
GList *
history_load (struct mc_config_t * cfg, const char *name)
{
    size_t i;
    GList *hist = NULL;
    char **keys;
    size_t keys_num = 0;
    GIConv conv = INVALID_CONV;
    GString *buffer;

    if (name == NULL || *name == '\0')
        return NULL;

    /* get number of keys */
    keys = mc_config_get_keys (cfg, name, &keys_num);
    g_strfreev (keys);

    /* create charset conversion handler to convert strings
       from utf-8 to system codepage */
    if (!mc_global.utf8_display)
        conv = str_crt_conv_from ("UTF-8");

    buffer = g_string_sized_new (64);

    for (i = 0; i < keys_num; i++)
    {
        char key[BUF_TINY];
        char *this_entry;

        g_snprintf (key, sizeof (key), "%lu", (unsigned long) i);
        this_entry = mc_config_get_string_raw (cfg, name, key, "");

        if (this_entry == NULL)
            continue;

        if (conv == INVALID_CONV)
            hist = list_append_unique (hist, this_entry);
        else
        {
            g_string_set_size (buffer, 0);
            if (str_convert (conv, this_entry, buffer) == ESTR_FAILURE)
                hist = list_append_unique (hist, this_entry);
            else
            {
                hist = list_append_unique (hist, g_strdup (buffer->str));
                g_free (this_entry);
            }
        }
    }

    g_string_free (buffer, TRUE);
    if (conv != INVALID_CONV)
        str_close_conv (conv);

    /* return pointer to the last entry in the list */
    return g_list_last (hist);
}
示例#4
0
文件: setup.c 项目: ginggs/maemo-mc
static void
load_keys_from_section (const char *terminal, mc_config_t * cfg)
{
    char *section_name;
    gchar **profile_keys, **keys;
    char *valcopy, *value;
    long key_code;

    if (terminal == NULL)
        return;

    section_name = g_strconcat ("terminal:", terminal, (char *) NULL);
    keys = mc_config_get_keys (cfg, section_name, NULL);

    for (profile_keys = keys; *profile_keys != NULL; profile_keys++)
    {
        /* copy=other causes all keys from [terminal:other] to be loaded. */
        if (g_ascii_strcasecmp (*profile_keys, "copy") == 0)
        {
            valcopy = mc_config_get_string (cfg, section_name, *profile_keys, "");
            load_keys_from_section (valcopy, cfg);
            g_free (valcopy);
            continue;
        }

        key_code = lookup_key (*profile_keys, NULL);
        if (key_code != 0)
        {
            gchar **values;

            values = mc_config_get_string_list (cfg, section_name, *profile_keys, NULL);
            if (values != NULL)
            {
                gchar **curr_values;

                for (curr_values = values; *curr_values != NULL; curr_values++)
                {
                    valcopy = convert_controls (*curr_values);
                    define_sequence (key_code, valcopy, MCKEY_NOACTION);
                    g_free (valcopy);
                }

                g_strfreev (values);
            }
            else
            {
                value = mc_config_get_string (cfg, section_name, *profile_keys, "");
                valcopy = convert_controls (value);
                define_sequence (key_code, valcopy, MCKEY_NOACTION);
                g_free (valcopy);
                g_free (value);
            }
        }
    }
    g_strfreev (keys);
    g_free (section_name);
}
示例#5
0
gboolean
mc_skin_color_parse_ini_file (mc_skin_t * mc_skin)
{
    gsize items_count;
    gchar **groups, **orig_groups;
    gchar **keys, **orig_keys;
    mc_skin_color_t *mc_skin_color;

    mc_skin_color_check_bw_mode (mc_skin);

    orig_groups = groups = mc_config_get_groups (mc_skin->config, &items_count);
    if (groups == NULL || groups[0] == NULL)
    {
        g_strfreev (groups);
        return FALSE;
    }

    /* as first, need to set up default colors */
    mc_skin_color_set_default_for_terminal (mc_skin);
    mc_skin_color = mc_skin_color_get_from_ini_file (mc_skin, "core", "_default_");
    if (mc_skin_color == NULL)
        return FALSE;

    tty_color_set_defaults (mc_skin_color->fgcolor, mc_skin_color->bgcolor, mc_skin_color->attrs);
    mc_skin_color_add_to_hash (mc_skin, "core", "_default_", mc_skin_color);

    for (; *groups != NULL; groups++)
    {
        if (!mc_skin_color_check_inisection (*groups))
            continue;

        orig_keys = keys = mc_config_get_keys (mc_skin->config, *groups, &items_count);
        if (keys == NULL)
            continue;

        for (; *keys != NULL; keys++)
        {
            mc_skin_color = mc_skin_color_get_from_ini_file (mc_skin, *groups, *keys);
            if (mc_skin_color != NULL)
                mc_skin_color_add_to_hash (mc_skin, *groups, *keys, mc_skin_color);
        }
        g_strfreev (orig_keys);
    }
    g_strfreev (orig_groups);

    mc_skin_color_cache_init ();
    return TRUE;
}
示例#6
0
static void
load_keymap_from_section (const char *section_name, GArray * keymap, mc_config_t * cfg)
{
    gchar **profile_keys, **keys;
    gchar **values, **curr_values;
    char *valcopy, *value;
    int action;
    gsize len, values_len;

    if (section_name == NULL)
        return;

    profile_keys = keys = mc_config_get_keys (cfg, section_name, &len);

    while (*profile_keys != NULL)
    {
        curr_values = values =
                          mc_config_get_string_list (cfg, section_name, *profile_keys, &values_len);

        action = keybind_lookup_action (*profile_keys);

        if (action > 0)
        {
            if (curr_values != NULL)
            {
                while (*curr_values != NULL)
                {
                    valcopy = convert_controls (*curr_values);
                    keybind_cmd_bind (keymap, valcopy, action);
                    g_free (valcopy);
                    curr_values++;
                }
            }
            else
            {
                value = mc_config_get_string (cfg, section_name, *profile_keys, "");
                valcopy = convert_controls (value);
                /* define_sequence (key_code, valcopy, MCKEY_NOACTION); */
                g_free (valcopy);
                g_free (value);
            }
        }

        profile_keys++;
        g_strfreev (values);
    }
    g_strfreev (keys);
}
示例#7
0
文件: common.c 项目: Chainie/mc
gboolean
mc_config_read_file (mc_config_t * mc_config, const gchar * ini_path, gboolean read_only,
                     gboolean remove_empty)
{
    mc_config_t *tmp_config;
    gchar **groups, **curr_grp;
    gchar **keys, **curr_key;
    gchar *value;

    if (mc_config == NULL)
        return FALSE;

    tmp_config = mc_config_init (ini_path, read_only);
    if (tmp_config == NULL)
        return FALSE;

    groups = mc_config_get_groups (tmp_config, NULL);

    if (groups == NULL)
    {
        mc_config_deinit (tmp_config);
        return FALSE;
    }

    for (curr_grp = groups; *curr_grp != NULL; curr_grp++)
    {
        keys = mc_config_get_keys (tmp_config, *curr_grp, NULL);
        for (curr_key = keys; *curr_key != NULL; curr_key++)
        {
            value = g_key_file_get_value (tmp_config->handle, *curr_grp, *curr_key, NULL);
            if (value != NULL)
            {
                if (*value == '\0' && remove_empty)
                    g_key_file_remove_key (mc_config->handle, *curr_grp, *curr_key, NULL);
                else
                    g_key_file_set_value (mc_config->handle, *curr_grp, *curr_key, value);
                g_free (value);
            }
            else if (remove_empty)
                g_key_file_remove_key (mc_config->handle, *curr_grp, *curr_key, NULL);
        }
        g_strfreev (keys);
    }
    g_strfreev (groups);
    mc_config_deinit (tmp_config);
    return TRUE;
}
示例#8
0
文件: setup.c 项目: CyberShadow/mc
static void
load_keymap_from_section (const char *section_name, GArray * keymap, mc_config_t * cfg)
{
    gchar **profile_keys, **keys;
    gsize len;

    if (section_name == NULL)
        return;

    profile_keys = keys = mc_config_get_keys (cfg, section_name, &len);

    while (*profile_keys != NULL)
    {
        gchar **values, **curr_values;

        curr_values = values = mc_config_get_string_list (cfg, section_name, *profile_keys, &len);

        if (curr_values != NULL)
        {
            int action;

            action = keybind_lookup_action (*profile_keys);
            if (action > 0)
                while (*curr_values != NULL)
                {
                    keybind_cmd_bind (keymap, *curr_values, action);
                    curr_values++;
                }

            g_strfreev (values);
        }

        profile_keys++;
    }

    g_strfreev (keys);
}
示例#9
0
char *
mc_serialize_config (const mc_config_t * data, GError ** error)
{
    gchar **groups, **group_iterator;
    size_t group_count;
    GString *buffer;

    buffer = g_string_new ("");
    group_iterator = groups = mc_config_get_groups (data, &group_count);

    while (group_count-- != 0)
    {
        char *serialized_str;
        gchar **params, **param_iterator;
        size_t param_count;

        serialized_str = mc_serialize_str ('g', *group_iterator, error);
        if (serialized_str == NULL)
        {
            g_string_free (buffer, TRUE);
            g_strfreev (groups);
            return NULL;
        }
        g_string_append (buffer, serialized_str);
        g_free (serialized_str);

        param_iterator = params = mc_config_get_keys (data, *group_iterator, &param_count);

        while (param_count-- != 0)
        {
            char *value;
            serialized_str = mc_serialize_str ('p', *param_iterator, error);
            if (serialized_str == NULL)
            {
                g_string_free (buffer, TRUE);
                g_strfreev (params);
                g_strfreev (groups);
                return NULL;
            }
            g_string_append (buffer, serialized_str);
            g_free (serialized_str);

            value = mc_config_get_string_raw (data, *group_iterator, *param_iterator, "");
            serialized_str = mc_serialize_str ('v', value, error);
            g_free (value);

            if (serialized_str == NULL)
            {
                g_string_free (buffer, TRUE);
                g_strfreev (params);
                g_strfreev (groups);
                return NULL;
            }

            g_string_append (buffer, serialized_str);
            g_free (serialized_str);

            param_iterator++;
        }

        g_strfreev (params);

        group_iterator++;
    }
    return g_string_free (buffer, FALSE);
}