← Back to branch summary

~lubuntu-dev/lxde/libfm-qt-debian-git

« back to all changes in this revision

Viewing changes to src/fm-search.c

  • Committer: Alf Gaida
  • Date: 2015-12-17 15:45:00 UTC
  • Revision ID: git-v1:99d4cf5e0b3761023e2285ffb96a79d050f0bdf4
Tags: upstream/0.10.0+20151214
Adding upstream version 0.10.0+20151214.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/fm-search.c
 
1
/*
 
2
 * fm-search-uri.c
 
3
 * 
 
4
 * Copyright 2015 Hong Jen Yee (PCMan) <pcman.tw@gmail.com>
 
5
 * Copyright 2012-2014 Andriy Grytsenko (LStranger) <andrej@rep.kiev.ua>
 
6
 * 
 
7
 * This library is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU Lesser General Public
 
9
 * License as published by the Free Software Foundation; either
 
10
 * version 2.1 of the License, or (at your option) any later version.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with this library; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
20
 *
 
21
 */
 
22
 
 
23
#include "fm-search.h"
 
24
#include <string.h>
 
25
 
 
26
struct _FmSearch
 
27
{
 
28
    gboolean recursive;
 
29
    gboolean show_hidden;
 
30
    char* name_patterns;
 
31
    gboolean name_ci;
 
32
    gboolean name_regex;
 
33
    char* content_pattern;
 
34
    gboolean content_ci;
 
35
    gboolean content_regex;
 
36
    GList* mime_types;
 
37
    GList* search_path_list;
 
38
    guint64 max_size;
 
39
    guint64 min_size;
 
40
    char* max_mtime;
 
41
    char* min_mtime;
 
42
};
 
43
 
 
44
FmSearch* fm_search_new (void)
 
45
{
 
46
    FmSearch* search = (FmSearch*)g_slice_new0(FmSearch);
 
47
    return search;
 
48
}
 
49
 
 
50
void fm_search_free(FmSearch* search)
 
51
{
 
52
    g_list_free_full(search->mime_types, (GDestroyNotify)g_free);
 
53
    g_list_free_full(search->search_path_list, (GDestroyNotify)g_free);
 
54
    g_free(search->name_patterns);
 
55
    g_free(search->content_pattern);
 
56
    g_free(search->max_mtime);
 
57
    g_free(search->min_mtime);
 
58
    g_slice_free(FmSearch, search);
 
59
}
 
60
 
 
61
gboolean fm_search_get_recursive(FmSearch* search)
 
62
{
 
63
    return search->recursive;
 
64
}
 
65
 
 
66
void fm_search_set_recursive(FmSearch* search, gboolean recursive)
 
67
{
 
68
    search->recursive = recursive;
 
69
}
 
70
 
 
71
gboolean fm_search_get_show_hidden(FmSearch* search)
 
72
{
 
73
    return search->show_hidden;
 
74
}
 
75
 
 
76
void fm_search_set_show_hidden(FmSearch* search, gboolean show_hidden)
 
77
{
 
78
    search->show_hidden = show_hidden;
 
79
}
 
80
 
 
81
const char* fm_search_get_name_patterns(FmSearch* search)
 
82
{
 
83
    return search->name_patterns;
 
84
}
 
85
 
 
86
void fm_search_set_name_patterns(FmSearch* search, const char* name_patterns)
 
87
{
 
88
    g_free(search->name_patterns);
 
89
    search->name_patterns = g_strdup(name_patterns);
 
90
}
 
91
 
 
92
gboolean fm_search_get_name_ci(FmSearch* search)
 
93
{
 
94
    return search->name_ci;
 
95
}
 
96
 
 
97
void fm_search_set_name_ci(FmSearch* search, gboolean name_ci)
 
98
{
 
99
    search->name_ci = name_ci;
 
100
}
 
101
 
 
102
gboolean fm_search_get_name_regex(FmSearch* search)
 
103
{
 
104
    return search->name_regex;
 
105
}
 
106
 
 
107
void fm_search_set_name_regex(FmSearch* search, gboolean name_regex)
 
108
{
 
109
    search->name_regex = name_regex;
 
110
}
 
111
 
 
112
const char* fm_search_get_content_pattern(FmSearch* search)
 
113
{
 
114
    return search->content_pattern;
 
115
}
 
116
 
 
117
void fm_search_set_content_pattern(FmSearch* search, const char* content_pattern)
 
118
{
 
119
    g_free(search->content_pattern);
 
120
    search->content_pattern = g_strdup(content_pattern);
 
121
}
 
122
 
 
123
gboolean fm_search_get_content_ci(FmSearch* search)
 
124
{
 
125
    return search->content_ci;
 
126
}
 
127
 
 
128
void fm_search_set_content_ci(FmSearch* search, gboolean content_ci)
 
129
{
 
130
    search->content_ci = content_ci;
 
131
}
 
132
 
 
133
gboolean fm_search_get_content_regex(FmSearch* search)
 
134
{
 
135
    return search->content_regex;
 
136
}
 
137
 
 
138
void fm_search_set_content_regex(FmSearch* search, gboolean content_regex)
 
139
{
 
140
    search->content_regex = content_regex;
 
141
}
 
142
 
 
143
void fm_search_add_dir(FmSearch* search, const char* dir)
 
144
{
 
145
    GList* l = g_list_find_custom(search->search_path_list, dir, (GCompareFunc)strcmp);
 
146
    if(!l)
 
147
        search->search_path_list = g_list_prepend(search->search_path_list, g_strdup(dir));
 
148
}
 
149
 
 
150
void fm_search_remove_dir(FmSearch* search, const char* dir)
 
151
{
 
152
    GList* l = g_list_find_custom(search->search_path_list, dir, (GCompareFunc)strcmp);
 
153
    if(G_LIKELY(l))
 
154
    {
 
155
        g_free(l->data);
 
156
        search->search_path_list = g_list_delete_link(search->search_path_list, l);
 
157
    }
 
158
}
 
159
 
 
160
GList* fm_search_get_dirs(FmSearch* search)
 
161
{
 
162
    return search->search_path_list;
 
163
}
 
164
 
 
165
void fm_search_add_mime_type(FmSearch* search, const char* mime_type)
 
166
{
 
167
    GList* l = g_list_find_custom(search->mime_types, mime_type, (GCompareFunc)strcmp);
 
168
    if(!l)
 
169
        search->mime_types = g_list_prepend(search->mime_types, g_strdup(mime_type));
 
170
}
 
171
 
 
172
void fm_search_remove_mime_type(FmSearch* search, const char* mime_type)
 
173
{
 
174
    GList* l = g_list_find_custom(search->mime_types, mime_type, (GCompareFunc)strcmp);
 
175
    if(G_LIKELY(l))
 
176
    {
 
177
        g_free(l->data);
 
178
        search->mime_types = g_list_delete_link(search->mime_types, l);
 
179
    }
 
180
}
 
181
 
 
182
GList* fm_search_get_mime_types(FmSearch* search)
 
183
{
 
184
    return search->mime_types;
 
185
}
 
186
 
 
187
guint64 fm_search_get_max_size(FmSearch* search)
 
188
{
 
189
    return search->max_size;
 
190
}
 
191
 
 
192
void fm_search_set_max_size(FmSearch* search, guint64 size)
 
193
{
 
194
    search->max_size = size;
 
195
}
 
196
 
 
197
guint64 fm_search_get_min_size(FmSearch* search)
 
198
{
 
199
    return search->min_size;
 
200
}
 
201
 
 
202
void fm_search_set_min_size(FmSearch* search, guint64 size)
 
203
{
 
204
    search->min_size = size;
 
205
}
 
206
 
 
207
/* format of mtime: YYYY-MM-DD */
 
208
const char* fm_search_get_max_mtime(FmSearch* search)
 
209
{
 
210
    return search->max_mtime;
 
211
}
 
212
 
 
213
void fm_search_set_max_mtime(FmSearch* search, const char* mtime)
 
214
{
 
215
    g_free(search->max_mtime);
 
216
    search->max_mtime = g_strdup(mtime);
 
217
}
 
218
 
 
219
/* format of mtime: YYYY-MM-DD */
 
220
const char* fm_search_get_min_mtime(FmSearch* search)
 
221
{
 
222
    return search->min_mtime;
 
223
}
 
224
 
 
225
void fm_search_set_min_mtime(FmSearch* search, const char* mtime)
 
226
{
 
227
    g_free(search->min_mtime);
 
228
    search->min_mtime = g_strdup(mtime);
 
229
}
 
230
 
 
231
/* really build the path */
 
232
FmPath* fm_search_dup_path(FmSearch* search)
 
233
{
 
234
    FmPath* search_path = NULL;
 
235
    GString* search_str = g_string_sized_new(1024);
 
236
    /* build the search:// URI to perform the search */
 
237
    g_string_append(search_str, "search://");
 
238
 
 
239
    if(search->search_path_list) /* we need to have at least one dir path */
 
240
    {
 
241
        char *escaped;
 
242
        /* add paths */
 
243
        GList* l;
 
244
        for(l = search->search_path_list; ; )
 
245
        {
 
246
            char *path_str = (char*)l->data;
 
247
            /* escape possible '?' and ',' */
 
248
            escaped = g_uri_escape_string(path_str, "!$&'()*+:;=/@", TRUE);
 
249
            g_string_append(search_str, escaped);
 
250
            g_free(escaped);
 
251
 
 
252
            l = l->next;
 
253
            if(!l) /* no more items */
 
254
                break;
 
255
            g_string_append_c(search_str, ','); /* separator for paths */
 
256
        }
 
257
 
 
258
        g_string_append_c(search_str, '?');
 
259
        g_string_append_printf(search_str, "recursive=%c", search->recursive ? '1' : '0');
 
260
        g_string_append_printf(search_str, "&show_hidden=%c", search->show_hidden ? '1' : '0');
 
261
        if(search->name_patterns && *search->name_patterns)
 
262
        {
 
263
            /* escape ampersands in pattern */
 
264
            escaped = g_uri_escape_string(search->name_patterns, ":/?#[]@!$'()*+,;", TRUE);
 
265
            if(search->name_regex)
 
266
                g_string_append_printf(search_str, "&name_regex=%s", escaped);
 
267
            else
 
268
                g_string_append_printf(search_str, "&name=%s", escaped);
 
269
            if(search->name_ci)
 
270
                g_string_append_printf(search_str, "&name_ci=%c", search->name_ci ? '1' : '0');
 
271
            g_free(escaped);
 
272
        }
 
273
 
 
274
        if(search->content_pattern && *search->content_pattern)
 
275
        {
 
276
            /* escape ampersands in pattern */
 
277
            escaped = g_uri_escape_string(search->content_pattern, ":/?#[]@!$'()*+,;^<>{}", TRUE);
 
278
            if(search->content_regex)
 
279
                g_string_append_printf(search_str, "&content_regex=%s", escaped);
 
280
            else
 
281
                g_string_append_printf(search_str, "&content=%s", escaped);
 
282
            g_free(escaped);
 
283
            if(search->content_ci)
 
284
                g_string_append_printf(search_str, "&content_ci=%c", search->content_ci ? '1' : '0');
 
285
        }
 
286
 
 
287
        /* search for the files of specific mime-types */
 
288
        if(search->mime_types)
 
289
        {
 
290
            GList* l;
 
291
            g_string_append(search_str, "&mime_types=");
 
292
            for(l = search->mime_types; l; l=l->next)
 
293
            {
 
294
                const char* mime_type = (const char*)l->data;
 
295
                g_string_append(search_str, mime_type);
 
296
                if(l->next)
 
297
                    g_string_append_c(search_str, ';');
 
298
            }
 
299
        }
 
300
 
 
301
        if(search->min_size)
 
302
            g_string_append_printf(search_str, "&min_size=%llu", (unsigned long long)search->min_size);
 
303
 
 
304
        if(search->max_size)
 
305
            g_string_append_printf(search_str, "&max_size=%llu", (unsigned long long)search->max_size);
 
306
 
 
307
        if(search->min_mtime)
 
308
            g_string_append_printf(search_str, "&min_mtime=%s", search->min_mtime);
 
309
 
 
310
        if(search->max_mtime)
 
311
            g_string_append_printf(search_str, "&max_mtime=%s", search->max_mtime);
 
312
 
 
313
        search_path = fm_path_new_for_uri(search_str->str);
 
314
        g_string_free(search_str, TRUE);
 
315
    }
 
316
    return search_path;
 
317
}