← Back to branch summary

~ivaldi/midori/tabby-title-changed

« back to all changes in this revision

Viewing changes to midori/search.c

  • Committer: Christian Dywan
  • Date: 2008-06-01 21:47:27 UTC
  • Revision ID: git-v1:b511f12b9b4b063610161f2229b94a24a86be0fc
Rename folder 'src' to 'midori'

Show diffs side-by-side

added added

removed removed

Lines of Context:
midori/search.c
 
1
/*
 
2
 Copyright (C) 2007 Christian Dywan <christian@twotoasts.de>
 
3
 
 
4
 This library is free software; you can redistribute it and/or
 
5
 modify it under the terms of the GNU Lesser General Public
 
6
 License as published by the Free Software Foundation; either
 
7
 version 2.1 of the License, or (at your option) any later version.
 
8
 
 
9
 See the file COPYING for the full license text.
 
10
*/
 
11
 
 
12
#include "search.h"
 
13
 
 
14
#include "sokoke.h"
 
15
#include <katze/katze.h>
 
16
 
 
17
#include <stdio.h>
 
18
#include <string.h>
 
19
 
 
20
GList* search_engines_new(void)
 
21
{
 
22
    return NULL;
 
23
}
 
24
 
 
25
void search_engines_free(GList* searchEngines)
 
26
{
 
27
    g_list_foreach(searchEngines, (GFunc)search_engine_free, NULL);
 
28
    g_list_free(searchEngines);
 
29
}
 
30
 
 
31
gboolean search_engines_from_file(GList** searchEngines, const gchar* filename
 
32
 , GError** error)
 
33
{
 
34
    g_return_val_if_fail(!g_list_nth(*searchEngines, 0), FALSE);
 
35
    GKeyFile* keyFile = g_key_file_new();
 
36
    g_key_file_load_from_file(keyFile, filename, G_KEY_FILE_KEEP_COMMENTS, error);
 
37
    /*g_key_file_load_from_data_dirs(keyFile, sFilename, NULL
 
38
     , G_KEY_FILE_KEEP_COMMENTS, error);*/
 
39
    gchar** engines = g_key_file_get_groups(keyFile, NULL);
 
40
    guint i;
 
41
    for(i = 0; engines[i] != NULL; i++)
 
42
    {
 
43
        SearchEngine* engine = search_engine_new();
 
44
        search_engine_set_short_name(engine, engines[i]);
 
45
        engine->description = g_key_file_get_string(keyFile, engines[i], "description", NULL);
 
46
        engine->url = g_key_file_get_string(keyFile, engines[i], "url", NULL);
 
47
        engine->inputEncoding = g_key_file_get_string(keyFile, engines[i], "input-encoding", NULL);
 
48
        engine->icon = g_key_file_get_string(keyFile, engines[i], "icon", NULL);
 
49
        engine->keyword = g_key_file_get_string(keyFile, engines[i], "keyword", NULL);
 
50
        *searchEngines = g_list_prepend(*searchEngines, engine);
 
51
    }
 
52
    *searchEngines = g_list_reverse(*searchEngines);
 
53
    g_strfreev(engines);
 
54
    g_key_file_free(keyFile);
 
55
    return !(error && *error);
 
56
}
 
57
 
 
58
static void key_file_set_string(GKeyFile* keyFile, const gchar* group
 
59
 , const gchar* key, const gchar* string)
 
60
{
 
61
    g_return_if_fail(group);
 
62
    if(string)
 
63
        g_key_file_set_string(keyFile, group, key, string);
 
64
}
 
65
 
 
66
gboolean search_engines_to_file(GList* searchEngines, const gchar* filename
 
67
 , GError** error)
 
68
{
 
69
    GKeyFile* keyFile = g_key_file_new();
 
70
    guint n = g_list_length(searchEngines);
 
71
    guint i;
 
72
    for(i = 0; i < n; i++)
 
73
    {
 
74
        SearchEngine* engine = (SearchEngine*)g_list_nth_data(searchEngines, i);
 
75
        const gchar* name = search_engine_get_short_name(engine);
 
76
        key_file_set_string(keyFile, name, "description", engine->description);
 
77
        key_file_set_string(keyFile, name, "url", engine->url);
 
78
        key_file_set_string(keyFile, name, "input-encoding", engine->inputEncoding);
 
79
        key_file_set_string(keyFile, name, "icon", engine->icon);
 
80
        key_file_set_string(keyFile, name, "keyword", engine->keyword);
 
81
    }
 
82
    gboolean bSaved = sokoke_key_file_save_to_file(keyFile, filename, error);
 
83
    g_key_file_free(keyFile);
 
84
 
 
85
    return bSaved;
 
86
}
 
87
 
 
88
SearchEngine* search_engine_new()
 
89
{
 
90
    SearchEngine* engine = g_new0(SearchEngine, 1);
 
91
    engine->shortName = g_strdup("");
 
92
    return engine;
 
93
}
 
94
 
 
95
void search_engine_free(SearchEngine* engine)
 
96
{
 
97
    g_return_if_fail(engine);
 
98
    g_free(engine->shortName);
 
99
    g_free(engine->description);
 
100
    g_free(engine->url);
 
101
    g_free(engine->inputEncoding);
 
102
    g_free(engine->icon);
 
103
    g_free(engine->keyword);
 
104
    g_free(engine);
 
105
}
 
106
 
 
107
SearchEngine* search_engine_copy(SearchEngine* engine)
 
108
{
 
109
    g_return_val_if_fail(engine, NULL);
 
110
    SearchEngine* copy = search_engine_new();
 
111
    search_engine_set_short_name(copy, engine->shortName);
 
112
    search_engine_set_description(copy, engine->description);
 
113
    search_engine_set_url(copy, engine->url);
 
114
    search_engine_set_input_encoding(copy, engine->inputEncoding);
 
115
    search_engine_set_icon(copy, engine->icon);
 
116
    search_engine_set_keyword(copy, engine->keyword);
 
117
    return engine;
 
118
}
 
119
 
 
120
GType search_engine_get_type()
 
121
{
 
122
    static GType type = 0;
 
123
    if(!type)
 
124
        type = g_pointer_type_register_static("search_engine");
 
125
    return type;
 
126
}
 
127
 
 
128
G_CONST_RETURN gchar* search_engine_get_short_name(SearchEngine* engine)
 
129
{
 
130
    g_return_val_if_fail(engine, NULL);
 
131
    return engine->shortName;
 
132
}
 
133
 
 
134
G_CONST_RETURN gchar* search_engine_get_description(SearchEngine* engine)
 
135
{
 
136
    g_return_val_if_fail(engine, NULL);
 
137
    return engine->description;
 
138
}
 
139
 
 
140
G_CONST_RETURN gchar* search_engine_get_url(SearchEngine* engine)
 
141
{
 
142
    g_return_val_if_fail(engine, NULL);
 
143
    return engine->url;
 
144
}
 
145
 
 
146
G_CONST_RETURN gchar* search_engine_get_input_encoding(SearchEngine* engine)
 
147
{
 
148
    g_return_val_if_fail(engine, NULL);
 
149
    return engine->inputEncoding;
 
150
}
 
151
 
 
152
G_CONST_RETURN gchar* search_engine_get_icon(SearchEngine* engine)
 
153
{
 
154
    g_return_val_if_fail(engine, NULL);
 
155
    return engine->icon;
 
156
}
 
157
 
 
158
G_CONST_RETURN gchar* search_engine_get_keyword(SearchEngine* engine)
 
159
{
 
160
    g_return_val_if_fail(engine, NULL);
 
161
    return engine->keyword;
 
162
}
 
163
 
 
164
void search_engine_set_short_name(SearchEngine* engine, const gchar* shortName)
 
165
{
 
166
    g_return_if_fail(engine);
 
167
    g_return_if_fail(shortName);
 
168
    katze_assign(engine->shortName, g_strdup(shortName));
 
169
}
 
170
 
 
171
void search_engine_set_description(SearchEngine* engine, const gchar* description)
 
172
{
 
173
    g_return_if_fail(engine);
 
174
    katze_assign(engine->description, g_strdup(description));
 
175
}
 
176
 
 
177
void search_engine_set_url(SearchEngine* engine, const gchar* url)
 
178
{
 
179
    g_return_if_fail(engine);
 
180
    katze_assign(engine->url, g_strdup(url));
 
181
}
 
182
 
 
183
void search_engine_set_input_encoding(SearchEngine* engine, const gchar* inputEncoding)
 
184
{
 
185
    g_return_if_fail(engine);
 
186
    katze_assign(engine->inputEncoding, g_strdup(inputEncoding));
 
187
}
 
188
 
 
189
void search_engine_set_icon(SearchEngine* engine, const gchar* icon)
 
190
{
 
191
    g_return_if_fail(engine);
 
192
    katze_assign(engine->icon, g_strdup(icon));
 
193
}
 
194
 
 
195
void search_engine_set_keyword(SearchEngine* engine, const gchar* keyword)
 
196
{
 
197
    g_return_if_fail(engine);
 
198
    katze_assign(engine->keyword, g_strdup(keyword));
 
199
}