~ubuntu-desktop/unity-lens-files/ubuntu

« back to all changes in this revision

Viewing changes to src/utils.c

  • Committer: Didier Roche
  • Date: 2011-08-11 08:52:55 UTC
  • mfrom: (14.4.24 upstream)
  • Revision ID: didier.roche@canonical.com-20110811085255-jiqd2j7uf549mj24
* New upstream release.
* Fix some conflicts in src/config.vala and src/daemon.vala after
  merge-upstream. Get it back to sane values (no home dir)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* utils.c generated by valac 0.11.7, the Vala compiler
 
1
/* utils.c generated by valac 0.12.1, the Vala compiler
2
2
 * generated from utils.vala, do not modify */
3
3
 
4
4
/*
26
26
#include <string.h>
27
27
#include <gio/gio.h>
28
28
#include <glib/gi18n-lib.h>
29
 
#include <zeitgeist.h>
 
29
#include <gee.h>
30
30
#include <dee.h>
31
 
#include <gee.h>
32
31
#include <unity.h>
 
32
#include <zeitgeist.h>
33
33
 
34
34
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
35
35
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
36
36
#define _g_free0(var) (var = (g_free (var), NULL))
37
 
typedef struct _UnityFilesPlaceUtilsGetIconForUriAsyncData UnityFilesPlaceUtilsGetIconForUriAsyncData;
38
 
 
39
 
#define UNITY_FILES_PLACE_TYPE_GROUP (unity_files_place_group_get_type ())
 
37
typedef struct _UnityFilesLensUtilsGetIconForUriAsyncData UnityFilesLensUtilsGetIconForUriAsyncData;
40
38
#define __g_slist_free__g_object_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_slist_free__g_object_unref0_ (var), NULL)))
41
39
#define __g_list_free__g_object_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__g_object_unref0_ (var), NULL)))
42
 
typedef struct _UnityFilesPlaceUtilsListDirData UnityFilesPlaceUtilsListDirData;
43
 
 
44
 
#define UNITY_FILES_PLACE_TYPE_RESULTS_COLUMN (unity_files_place_results_column_get_type ())
45
 
 
46
 
struct _UnityFilesPlaceUtilsGetIconForUriAsyncData {
 
40
typedef struct _UnityFilesLensUtilsListDirData UnityFilesLensUtilsListDirData;
 
41
 
 
42
#define UNITY_FILES_LENS_TYPE_RESULTS_COLUMN (unity_files_lens_results_column_get_type ())
 
43
 
 
44
struct _UnityFilesLensUtilsGetIconForUriAsyncData {
47
45
        int _state_;
48
46
        GObject* _source_object_;
49
47
        GAsyncResult* _res_;
63
61
        GError * _inner_error_;
64
62
};
65
63
 
66
 
typedef enum  {
67
 
        UNITY_FILES_PLACE_GROUP_TOP_RESULTS,
68
 
        UNITY_FILES_PLACE_GROUP_RECENT,
69
 
        UNITY_FILES_PLACE_GROUP_DOWNLOADS,
70
 
        UNITY_FILES_PLACE_GROUP_FAVORITE_FOLDERS,
71
 
        UNITY_FILES_PLACE_GROUP_FILES,
72
 
        UNITY_FILES_PLACE_GROUP_EMPTY_SEARCH,
73
 
        UNITY_FILES_PLACE_GROUP_EMPTY_SECTION,
74
 
        UNITY_FILES_PLACE_GROUP_TODAY,
75
 
        UNITY_FILES_PLACE_GROUP_YESTERDAY,
76
 
        UNITY_FILES_PLACE_GROUP_THIS_WEEK,
77
 
        UNITY_FILES_PLACE_GROUP_LAST_WEEK,
78
 
        UNITY_FILES_PLACE_GROUP_THIS_MONTH,
79
 
        UNITY_FILES_PLACE_GROUP_PAST_SIX_MONTHS,
80
 
        UNITY_FILES_PLACE_GROUP_THIS_YEAR,
81
 
        UNITY_FILES_PLACE_GROUP_LAST_YEAR
82
 
} UnityFilesPlaceGroup;
83
 
 
84
 
struct _UnityFilesPlaceUtilsListDirData {
 
64
struct _UnityFilesLensUtilsListDirData {
85
65
        int _state_;
86
66
        GObject* _source_object_;
87
67
        GAsyncResult* _res_;
109
89
};
110
90
 
111
91
typedef enum  {
112
 
        UNITY_FILES_PLACE_RESULTS_COLUMN_URI = 0,
113
 
        UNITY_FILES_PLACE_RESULTS_COLUMN_ICON_HINT,
114
 
        UNITY_FILES_PLACE_RESULTS_COLUMN_GROUP_ID,
115
 
        UNITY_FILES_PLACE_RESULTS_COLUMN_MIMETYPE,
116
 
        UNITY_FILES_PLACE_RESULTS_COLUMN_DISPLAY_NAME,
117
 
        UNITY_FILES_PLACE_RESULTS_COLUMN_COMMENT
118
 
} UnityFilesPlaceResultsColumn;
119
 
 
120
 
 
121
 
 
122
 
#define UNITY_FILES_PLACE_UTILS_icon_attribs G_FILE_ATTRIBUTE_PREVIEW_ICON "," G_FILE_ATTRIBUTE_STANDARD_ICON "," G_FILE_ATTRIBUTE_THUMBNAIL_PATH
123
 
#define UNITY_FILES_PLACE_UTILS_file_attribs G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," G_FILE_ATTRIBUTE_TIME_MODIFIED "," G_FILE_ATTRIBUTE_TIME_ACCESS
124
 
#define UNITY_FILES_PLACE_UTILS_hide_attribs G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN
125
 
#define UNITY_FILES_PLACE_UTILS_all_attribs UNITY_FILES_PLACE_UTILS_icon_attribs "," UNITY_FILES_PLACE_UTILS_file_attribs "," UNITY_FILES_PLACE_UTILS_hide_attribs
126
 
gchar* unity_files_place_utils_get_icon_for_uri (const gchar* uri, const gchar* mimetype);
127
 
gchar* unity_files_place_utils_check_icon_string (const gchar* uri, const gchar* mimetype, GFileInfo* info);
128
 
static void unity_files_place_utils_get_icon_for_uri_async_data_free (gpointer _data);
129
 
void unity_files_place_utils_get_icon_for_uri_async (const gchar* uri, const gchar* mimetype, GAsyncReadyCallback _callback_, gpointer _user_data_);
130
 
gchar* unity_files_place_utils_get_icon_for_uri_finish (GAsyncResult* _res_);
131
 
static gboolean unity_files_place_utils_get_icon_for_uri_async_co (UnityFilesPlaceUtilsGetIconForUriAsyncData* data);
132
 
static void unity_files_place_utils_get_icon_for_uri_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
133
 
gint unity_files_place_utils_cmp_file_info_by_mtime (GFileInfo* info1, GFileInfo* info2);
134
 
gchar* unity_files_place_utils_get_month_name (GDateMonth month);
135
 
gchar* unity_files_place_utils_get_day_name (GDateWeekday weekday);
136
 
guint unity_files_place_utils_get_time_group (ZeitgeistEvent* event, DeeModel* groups_model, gchar** comment);
137
 
GType unity_files_place_group_get_type (void) G_GNUC_CONST;
 
92
        UNITY_FILES_LENS_RESULTS_COLUMN_URI = 0,
 
93
        UNITY_FILES_LENS_RESULTS_COLUMN_ICON_HINT,
 
94
        UNITY_FILES_LENS_RESULTS_COLUMN_GROUP_ID,
 
95
        UNITY_FILES_LENS_RESULTS_COLUMN_MIMETYPE,
 
96
        UNITY_FILES_LENS_RESULTS_COLUMN_DISPLAY_NAME,
 
97
        UNITY_FILES_LENS_RESULTS_COLUMN_COMMENT
 
98
} UnityFilesLensResultsColumn;
 
99
 
 
100
 
 
101
 
 
102
#define UNITY_FILES_LENS_UTILS_icon_attribs G_FILE_ATTRIBUTE_PREVIEW_ICON "," G_FILE_ATTRIBUTE_STANDARD_ICON "," G_FILE_ATTRIBUTE_THUMBNAIL_PATH
 
103
#define UNITY_FILES_LENS_UTILS_file_attribs G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," G_FILE_ATTRIBUTE_TIME_MODIFIED "," G_FILE_ATTRIBUTE_TIME_ACCESS
 
104
#define UNITY_FILES_LENS_UTILS_hide_attribs G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN
 
105
#define UNITY_FILES_LENS_UTILS_all_attribs UNITY_FILES_LENS_UTILS_icon_attribs "," UNITY_FILES_LENS_UTILS_file_attribs "," UNITY_FILES_LENS_UTILS_hide_attribs
 
106
gchar* unity_files_lens_utils_get_icon_for_uri (const gchar* uri, const gchar* mimetype);
 
107
gchar* unity_files_lens_utils_check_icon_string (const gchar* uri, const gchar* mimetype, GFileInfo* info);
 
108
static void unity_files_lens_utils_get_icon_for_uri_async_data_free (gpointer _data);
 
109
void unity_files_lens_utils_get_icon_for_uri_async (const gchar* uri, const gchar* mimetype, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
110
gchar* unity_files_lens_utils_get_icon_for_uri_finish (GAsyncResult* _res_);
 
111
static gboolean unity_files_lens_utils_get_icon_for_uri_async_co (UnityFilesLensUtilsGetIconForUriAsyncData* data);
 
112
static void unity_files_lens_utils_get_icon_for_uri_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
113
gint unity_files_lens_utils_cmp_file_info_by_mtime (GFileInfo* info1, GFileInfo* info2);
 
114
gchar* unity_files_lens_utils_get_month_name (GDateMonth month);
 
115
gchar* unity_files_lens_utils_get_day_name (GDateWeekday weekday);
138
116
static void _g_object_unref0_ (gpointer var);
139
117
static void _g_slist_free__g_object_unref0_ (GSList* self);
140
 
static void unity_files_place_utils_list_dir_data_free (gpointer _data);
141
 
void unity_files_place_utils_list_dir (GFile* folder, GAsyncReadyCallback _callback_, gpointer _user_data_);
142
 
GSList* unity_files_place_utils_list_dir_finish (GAsyncResult* _res_, GError** error);
143
 
static gboolean unity_files_place_utils_list_dir_co (UnityFilesPlaceUtilsListDirData* data);
144
 
static void unity_files_place_utils_list_dir_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
118
static void unity_files_lens_utils_list_dir_data_free (gpointer _data);
 
119
void unity_files_lens_utils_list_dir (GFile* folder, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
120
GSList* unity_files_lens_utils_list_dir_finish (GAsyncResult* _res_, GError** error);
 
121
static gboolean unity_files_lens_utils_list_dir_co (UnityFilesLensUtilsListDirData* data);
 
122
static void unity_files_lens_utils_list_dir_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
145
123
static void _g_list_free__g_object_unref0_ (GList* self);
146
124
static gint _lambda2_ (gconstpointer info1, gconstpointer info2);
147
125
static gint __lambda2__gcompare_func (gconstpointer a, gconstpointer b);
148
 
void unity_files_place_utils_apply_uri_filter (GeeSet* valid_uris, DeeResultSet* filter_set);
149
 
GType unity_files_place_results_column_get_type (void) G_GNUC_CONST;
150
 
gboolean unity_files_place_utils_check_is_filter_search (UnityPlaceSearch* new_search, UnityPlaceSearch* old_search);
151
 
GeeSet* unity_files_place_utils_get_uri_set (ZeitgeistResultSet* results);
152
 
gboolean unity_files_place_utils_search_has_really_changed (UnityPlaceSearch* old_search, UnityPlaceSearch* new_search);
153
 
gchar* unity_files_place_utils_normalize_string (const gchar* input);
154
 
 
155
 
 
156
 
gchar* unity_files_place_utils_get_icon_for_uri (const gchar* uri, const gchar* mimetype) {
 
126
void unity_files_lens_utils_apply_uri_filter (GeeSet* valid_uris, DeeResultSet* filter_set);
 
127
GType unity_files_lens_results_column_get_type (void) G_GNUC_CONST;
 
128
gboolean unity_files_lens_utils_check_is_filter_search (UnityLensSearch* new_search, UnityLensSearch* old_search);
 
129
GeeSet* unity_files_lens_utils_get_uri_set (ZeitgeistResultSet* results);
 
130
gboolean unity_files_lens_utils_search_has_really_changed (UnityLensSearch* old_search, UnityLensSearch* new_search);
 
131
gchar* unity_files_lens_utils_normalize_string (const gchar* input);
 
132
 
 
133
 
 
134
gchar* unity_files_lens_utils_get_icon_for_uri (const gchar* uri, const gchar* mimetype) {
157
135
        gchar* result = NULL;
158
136
        GFile* _tmp0_ = NULL;
159
137
        GFile* f;
181
159
                _g_object_unref0 (f);
182
160
                return result;
183
161
        }
184
 
        _tmp6_ = g_file_query_info (f, UNITY_FILES_PLACE_UTILS_icon_attribs, G_FILE_QUERY_INFO_NONE, NULL, &_inner_error_);
 
162
        _tmp6_ = g_file_query_info (f, UNITY_FILES_LENS_UTILS_icon_attribs, G_FILE_QUERY_INFO_NONE, NULL, &_inner_error_);
185
163
        info = _tmp6_;
186
164
        if (_inner_error_ != NULL) {
187
165
                _g_object_unref0 (f);
188
 
                goto __catch15_g_error;
 
166
                goto __catch11_g_error;
189
167
        }
190
 
        _tmp7_ = unity_files_place_utils_check_icon_string (uri, mimetype, info);
 
168
        _tmp7_ = unity_files_lens_utils_check_icon_string (uri, mimetype, info);
191
169
        result = _tmp7_;
192
170
        _g_object_unref0 (info);
193
171
        _g_object_unref0 (f);
194
172
        return result;
195
173
        _g_object_unref0 (info);
196
174
        _g_object_unref0 (f);
197
 
        goto __finally15;
198
 
        __catch15_g_error:
 
175
        goto __finally11;
 
176
        __catch11_g_error:
199
177
        {
200
178
                GError * e;
201
179
                GIcon* _tmp8_ = NULL;
211
189
                _g_error_free0 (e);
212
190
                return result;
213
191
        }
214
 
        __finally15:
 
192
        __finally11:
215
193
        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
216
194
        g_clear_error (&_inner_error_);
217
195
        return NULL;
218
196
}
219
197
 
220
198
 
221
 
static void unity_files_place_utils_get_icon_for_uri_async_data_free (gpointer _data) {
222
 
        UnityFilesPlaceUtilsGetIconForUriAsyncData* data;
 
199
static void unity_files_lens_utils_get_icon_for_uri_async_data_free (gpointer _data) {
 
200
        UnityFilesLensUtilsGetIconForUriAsyncData* data;
223
201
        data = _data;
224
202
        _g_free0 (data->uri);
225
203
        _g_free0 (data->mimetype);
226
204
        _g_free0 (data->result);
227
 
        g_slice_free (UnityFilesPlaceUtilsGetIconForUriAsyncData, data);
 
205
        g_slice_free (UnityFilesLensUtilsGetIconForUriAsyncData, data);
228
206
}
229
207
 
230
208
 
231
 
void unity_files_place_utils_get_icon_for_uri_async (const gchar* uri, const gchar* mimetype, GAsyncReadyCallback _callback_, gpointer _user_data_) {
232
 
        UnityFilesPlaceUtilsGetIconForUriAsyncData* _data_;
233
 
        _data_ = g_slice_new0 (UnityFilesPlaceUtilsGetIconForUriAsyncData);
234
 
        _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, unity_files_place_utils_get_icon_for_uri_async);
235
 
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, unity_files_place_utils_get_icon_for_uri_async_data_free);
 
209
void unity_files_lens_utils_get_icon_for_uri_async (const gchar* uri, const gchar* mimetype, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
210
        UnityFilesLensUtilsGetIconForUriAsyncData* _data_;
 
211
        _data_ = g_slice_new0 (UnityFilesLensUtilsGetIconForUriAsyncData);
 
212
        _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, unity_files_lens_utils_get_icon_for_uri_async);
 
213
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, unity_files_lens_utils_get_icon_for_uri_async_data_free);
236
214
        _data_->uri = g_strdup (uri);
237
215
        _data_->mimetype = g_strdup (mimetype);
238
 
        unity_files_place_utils_get_icon_for_uri_async_co (_data_);
 
216
        unity_files_lens_utils_get_icon_for_uri_async_co (_data_);
239
217
}
240
218
 
241
219
 
242
 
gchar* unity_files_place_utils_get_icon_for_uri_finish (GAsyncResult* _res_) {
 
220
gchar* unity_files_lens_utils_get_icon_for_uri_finish (GAsyncResult* _res_) {
243
221
        gchar* result;
244
 
        UnityFilesPlaceUtilsGetIconForUriAsyncData* _data_;
 
222
        UnityFilesLensUtilsGetIconForUriAsyncData* _data_;
245
223
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
246
224
        result = _data_->result;
247
225
        _data_->result = NULL;
249
227
}
250
228
 
251
229
 
252
 
static void unity_files_place_utils_get_icon_for_uri_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
253
 
        UnityFilesPlaceUtilsGetIconForUriAsyncData* data;
 
230
static void unity_files_lens_utils_get_icon_for_uri_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
231
        UnityFilesLensUtilsGetIconForUriAsyncData* data;
254
232
        data = _user_data_;
255
233
        data->_source_object_ = source_object;
256
234
        data->_res_ = _res_;
257
 
        unity_files_place_utils_get_icon_for_uri_async_co (data);
 
235
        unity_files_lens_utils_get_icon_for_uri_async_co (data);
258
236
}
259
237
 
260
238
 
261
 
static gboolean unity_files_place_utils_get_icon_for_uri_async_co (UnityFilesPlaceUtilsGetIconForUriAsyncData* data) {
 
239
static gboolean unity_files_lens_utils_get_icon_for_uri_async_co (UnityFilesLensUtilsGetIconForUriAsyncData* data) {
262
240
        switch (data->_state_) {
263
241
                case 0:
264
242
                goto _state_0;
272
250
        data->_tmp0_ = g_file_new_for_uri (data->uri);
273
251
        data->f = data->_tmp0_;
274
252
        data->_state_ = 1;
275
 
        g_file_query_info_async (data->f, UNITY_FILES_PLACE_UTILS_icon_attribs, G_FILE_QUERY_INFO_NONE, G_PRIORITY_LOW, NULL, unity_files_place_utils_get_icon_for_uri_async_ready, data);
 
253
        g_file_query_info_async (data->f, UNITY_FILES_LENS_UTILS_icon_attribs, G_FILE_QUERY_INFO_NONE, G_PRIORITY_LOW, NULL, unity_files_lens_utils_get_icon_for_uri_async_ready, data);
276
254
        return FALSE;
277
255
        _state_1:
278
256
        data->_tmp1_ = NULL;
280
258
        data->info = data->_tmp1_;
281
259
        if (data->_inner_error_ != NULL) {
282
260
                _g_object_unref0 (data->f);
283
 
                goto __catch16_g_error;
 
261
                goto __catch12_g_error;
284
262
        }
285
263
        data->_tmp2_ = NULL;
286
 
        data->_tmp2_ = unity_files_place_utils_check_icon_string (data->uri, data->mimetype, data->info);
 
264
        data->_tmp2_ = unity_files_lens_utils_check_icon_string (data->uri, data->mimetype, data->info);
287
265
        data->result = data->_tmp2_;
288
266
        _g_object_unref0 (data->info);
289
267
        _g_object_unref0 (data->f);
296
274
        return FALSE;
297
275
        _g_object_unref0 (data->info);
298
276
        _g_object_unref0 (data->f);
299
 
        goto __finally16;
300
 
        __catch16_g_error:
 
277
        goto __finally12;
 
278
        __catch12_g_error:
301
279
        {
302
280
                data->e = data->_inner_error_;
303
281
                data->_inner_error_ = NULL;
317
295
                g_object_unref (data->_async_result);
318
296
                return FALSE;
319
297
        }
320
 
        __finally16:
 
298
        __finally12:
321
299
        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
322
300
        g_clear_error (&data->_inner_error_);
323
301
        return FALSE;
336
314
}
337
315
 
338
316
 
339
 
gchar* unity_files_place_utils_check_icon_string (const gchar* uri, const gchar* mimetype, GFileInfo* info) {
 
317
gchar* unity_files_lens_utils_check_icon_string (const gchar* uri, const gchar* mimetype, GFileInfo* info) {
340
318
        gchar* result = NULL;
341
319
        GIcon* _tmp0_ = NULL;
342
320
        GIcon* _tmp1_;
385
363
}
386
364
 
387
365
 
388
 
gint unity_files_place_utils_cmp_file_info_by_mtime (GFileInfo* info1, GFileInfo* info2) {
 
366
gint unity_files_lens_utils_cmp_file_info_by_mtime (GFileInfo* info1, GFileInfo* info2) {
389
367
        gint result = 0;
390
368
        GTimeVal tv1 = {0};
391
369
        GTimeVal tv2 = {0};
416
394
}
417
395
 
418
396
 
419
 
gchar* unity_files_place_utils_get_month_name (GDateMonth month) {
 
397
gchar* unity_files_lens_utils_get_month_name (GDateMonth month) {
420
398
        gchar* result = NULL;
421
399
        gchar* _tmp26_;
422
400
        switch (month) {
546
524
}
547
525
 
548
526
 
549
 
gchar* unity_files_place_utils_get_day_name (GDateWeekday weekday) {
 
527
gchar* unity_files_lens_utils_get_day_name (GDateWeekday weekday) {
550
528
        gchar* result = NULL;
551
529
        switch (weekday) {
552
530
                case G_DATE_MONDAY:
623
601
}
624
602
 
625
603
 
626
 
guint unity_files_place_utils_get_time_group (ZeitgeistEvent* event, DeeModel* groups_model, gchar** comment) {
627
 
        gchar* _comment = NULL;
628
 
        guint result = 0U;
629
 
        gint64 _tmp0_;
630
 
        gint64 t;
631
 
        gint64 _tmp1_;
632
 
        gint64 now;
633
 
        gint64 delta;
634
 
        gint64 _tmp2_;
635
 
        gint64 limit;
636
 
        GDate date = {0};
637
 
        GDate _tmp19_ = {0};
638
 
        GDateWeekday _tmp20_;
639
 
        GDate datethen = {0};
640
 
        GDate _tmp21_ = {0};
641
 
        GDateWeekday _tmp22_;
642
 
        gchar* _tmp23_ = NULL;
643
 
        gint64 _tmp24_;
644
 
        GDateMonth _tmp30_;
645
 
        gchar* _tmp31_ = NULL;
646
 
        gint64 _tmp32_;
647
 
        GDate _tmp33_ = {0};
648
 
        gint64 _tmp34_;
649
 
        g_return_val_if_fail (event != NULL, 0U);
650
 
        g_return_val_if_fail (groups_model != NULL, 0U);
651
 
        _tmp0_ = zeitgeist_event_get_timestamp (event);
652
 
        t = _tmp0_;
653
 
        _tmp1_ = zeitgeist_timestamp_for_now ();
654
 
        now = _tmp1_;
655
 
        delta = now - t;
656
 
        _tmp2_ = zeitgeist_timestamp_prev_midnight (now);
657
 
        limit = _tmp2_;
658
 
        if (t > limit) {
659
 
                gint64 hour;
660
 
                hour = ZEITGEIST_TIMESTAMP_HOUR;
661
 
                if (delta > (hour * 7)) {
662
 
                        const gchar* _tmp3_ = NULL;
663
 
                        gchar* _tmp4_;
664
 
                        _tmp3_ = _ ("Earlier today");
665
 
                        _tmp4_ = g_strdup (_tmp3_);
666
 
                        _g_free0 (_comment);
667
 
                        _comment = _tmp4_;
668
 
                } else {
669
 
                        if (delta > (hour * 6)) {
670
 
                                const gchar* _tmp5_ = NULL;
671
 
                                gchar* _tmp6_;
672
 
                                _tmp5_ = _ ("Five hours ago");
673
 
                                _tmp6_ = g_strdup (_tmp5_);
674
 
                                _g_free0 (_comment);
675
 
                                _comment = _tmp6_;
676
 
                        } else {
677
 
                                if (delta > (hour * 5)) {
678
 
                                        const gchar* _tmp7_ = NULL;
679
 
                                        gchar* _tmp8_;
680
 
                                        _tmp7_ = _ ("Four hours ago");
681
 
                                        _tmp8_ = g_strdup (_tmp7_);
682
 
                                        _g_free0 (_comment);
683
 
                                        _comment = _tmp8_;
684
 
                                } else {
685
 
                                        if (delta > (hour * 4)) {
686
 
                                                const gchar* _tmp9_ = NULL;
687
 
                                                gchar* _tmp10_;
688
 
                                                _tmp9_ = _ ("Three hours ago");
689
 
                                                _tmp10_ = g_strdup (_tmp9_);
690
 
                                                _g_free0 (_comment);
691
 
                                                _comment = _tmp10_;
692
 
                                        } else {
693
 
                                                if (delta > (hour * 3)) {
694
 
                                                        const gchar* _tmp11_ = NULL;
695
 
                                                        gchar* _tmp12_;
696
 
                                                        _tmp11_ = _ ("Two hours ago");
697
 
                                                        _tmp12_ = g_strdup (_tmp11_);
698
 
                                                        _g_free0 (_comment);
699
 
                                                        _comment = _tmp12_;
700
 
                                                } else {
701
 
                                                        if (delta > (hour * 2)) {
702
 
                                                                const gchar* _tmp13_ = NULL;
703
 
                                                                gchar* _tmp14_;
704
 
                                                                _tmp13_ = _ ("1 hour ago");
705
 
                                                                _tmp14_ = g_strdup (_tmp13_);
706
 
                                                                _g_free0 (_comment);
707
 
                                                                _comment = _tmp14_;
708
 
                                                        } else {
709
 
                                                                const gchar* _tmp15_ = NULL;
710
 
                                                                gchar* _tmp16_;
711
 
                                                                _tmp15_ = _ ("Past hour");
712
 
                                                                _tmp16_ = g_strdup (_tmp15_);
713
 
                                                                _g_free0 (_comment);
714
 
                                                                _comment = _tmp16_;
715
 
                                                        }
716
 
                                                }
717
 
                                        }
718
 
                                }
719
 
                        }
720
 
                }
721
 
                result = (guint) UNITY_FILES_PLACE_GROUP_TODAY;
722
 
                if (comment) {
723
 
                        *comment = _comment;
724
 
                } else {
725
 
                        _g_free0 (_comment);
726
 
                }
727
 
                return result;
728
 
        } else {
729
 
                if (t > (limit - ZEITGEIST_TIMESTAMP_DAY)) {
730
 
                        const gchar* _tmp17_ = NULL;
731
 
                        gchar* _tmp18_;
732
 
                        _tmp17_ = _ ("Yesterday");
733
 
                        _tmp18_ = g_strdup (_tmp17_);
734
 
                        _g_free0 (_comment);
735
 
                        _comment = _tmp18_;
736
 
                        result = (guint) UNITY_FILES_PLACE_GROUP_YESTERDAY;
737
 
                        if (comment) {
738
 
                                *comment = _comment;
739
 
                        } else {
740
 
                                _g_free0 (_comment);
741
 
                        }
742
 
                        return result;
743
 
                }
744
 
        }
745
 
        memset (&date, 0, sizeof (GDate));
746
 
        zeitgeist_timestamp_to_date (now, &_tmp19_);
747
 
        date = _tmp19_;
748
 
        _tmp20_ = g_date_get_weekday (&date);
749
 
        limit = limit - ((_tmp20_ - 1) * ZEITGEIST_TIMESTAMP_DAY);
750
 
        memset (&datethen, 0, sizeof (GDate));
751
 
        zeitgeist_timestamp_to_date (t, &_tmp21_);
752
 
        datethen = _tmp21_;
753
 
        _tmp22_ = g_date_get_weekday (&datethen);
754
 
        _tmp23_ = unity_files_place_utils_get_day_name (_tmp22_);
755
 
        _g_free0 (_comment);
756
 
        _comment = _tmp23_;
757
 
        if (t > limit) {
758
 
                result = (guint) UNITY_FILES_PLACE_GROUP_THIS_WEEK;
759
 
                if (comment) {
760
 
                        *comment = _comment;
761
 
                } else {
762
 
                        _g_free0 (_comment);
763
 
                }
764
 
                return result;
765
 
        } else {
766
 
                if (t > (limit - ZEITGEIST_TIMESTAMP_WEEK)) {
767
 
                        result = (guint) UNITY_FILES_PLACE_GROUP_LAST_WEEK;
768
 
                        if (comment) {
769
 
                                *comment = _comment;
770
 
                        } else {
771
 
                                _g_free0 (_comment);
772
 
                        }
773
 
                        return result;
774
 
                }
775
 
        }
776
 
        g_date_set_day (&date, (GDateDay) 1);
777
 
        _tmp24_ = zeitgeist_timestamp_from_date (&date);
778
 
        limit = _tmp24_;
779
 
        if (t > limit) {
780
 
                gint _tmp25_;
781
 
                gint days;
782
 
                _tmp25_ = g_date_days_between (&datethen, &date);
783
 
                days = _tmp25_;
784
 
                if (days < (7 * 3)) {
785
 
                        const gchar* _tmp26_ = NULL;
786
 
                        gchar* _tmp27_;
787
 
                        _tmp26_ = _ ("Three weeks ago");
788
 
                        _tmp27_ = g_strdup (_tmp26_);
789
 
                        _g_free0 (_comment);
790
 
                        _comment = _tmp27_;
791
 
                } else {
792
 
                        if (days < (7 * 4)) {
793
 
                                const gchar* _tmp28_ = NULL;
794
 
                                gchar* _tmp29_;
795
 
                                _tmp28_ = _ ("A month ago");
796
 
                                _tmp29_ = g_strdup (_tmp28_);
797
 
                                _g_free0 (_comment);
798
 
                                _comment = _tmp29_;
799
 
                        }
800
 
                }
801
 
                result = (guint) UNITY_FILES_PLACE_GROUP_THIS_MONTH;
802
 
                if (comment) {
803
 
                        *comment = _comment;
804
 
                } else {
805
 
                        _g_free0 (_comment);
806
 
                }
807
 
                return result;
808
 
        }
809
 
        _tmp30_ = g_date_get_month (&datethen);
810
 
        _tmp31_ = unity_files_place_utils_get_month_name (_tmp30_);
811
 
        _g_free0 (_comment);
812
 
        _comment = _tmp31_;
813
 
        g_date_subtract_months (&date, (guint) 1);
814
 
        _tmp32_ = zeitgeist_timestamp_from_date (&date);
815
 
        limit = _tmp32_;
816
 
        if (t > (now - ((6 * 30) * ZEITGEIST_TIMESTAMP_DAY))) {
817
 
                result = (guint) UNITY_FILES_PLACE_GROUP_PAST_SIX_MONTHS;
818
 
                if (comment) {
819
 
                        *comment = _comment;
820
 
                } else {
821
 
                        _g_free0 (_comment);
822
 
                }
823
 
                return result;
824
 
        }
825
 
        zeitgeist_timestamp_to_date (now, &_tmp33_);
826
 
        date = _tmp33_;
827
 
        g_date_set_month (&date, G_DATE_JANUARY);
828
 
        g_date_set_day (&date, (GDateDay) 1);
829
 
        _tmp34_ = zeitgeist_timestamp_from_date (&date);
830
 
        limit = _tmp34_;
831
 
        if (t > limit) {
832
 
                result = (guint) UNITY_FILES_PLACE_GROUP_THIS_YEAR;
833
 
                if (comment) {
834
 
                        *comment = _comment;
835
 
                } else {
836
 
                        _g_free0 (_comment);
837
 
                }
838
 
                return result;
839
 
        } else {
840
 
                result = (guint) UNITY_FILES_PLACE_GROUP_LAST_YEAR;
841
 
                if (comment) {
842
 
                        *comment = _comment;
843
 
                } else {
844
 
                        _g_free0 (_comment);
845
 
                }
846
 
                return result;
847
 
        }
848
 
        if (comment) {
849
 
                *comment = _comment;
850
 
        } else {
851
 
                _g_free0 (_comment);
852
 
        }
853
 
}
854
 
 
855
 
 
856
604
static void _g_object_unref0_ (gpointer var) {
857
605
        (var == NULL) ? NULL : (var = (g_object_unref (var), NULL));
858
606
}
864
612
}
865
613
 
866
614
 
867
 
static void unity_files_place_utils_list_dir_data_free (gpointer _data) {
868
 
        UnityFilesPlaceUtilsListDirData* data;
 
615
static void unity_files_lens_utils_list_dir_data_free (gpointer _data) {
 
616
        UnityFilesLensUtilsListDirData* data;
869
617
        data = _data;
870
618
        _g_object_unref0 (data->folder);
871
619
        __g_slist_free__g_object_unref0_0 (data->result);
872
 
        g_slice_free (UnityFilesPlaceUtilsListDirData, data);
 
620
        g_slice_free (UnityFilesLensUtilsListDirData, data);
873
621
}
874
622
 
875
623
 
876
 
void unity_files_place_utils_list_dir (GFile* folder, GAsyncReadyCallback _callback_, gpointer _user_data_) {
877
 
        UnityFilesPlaceUtilsListDirData* _data_;
878
 
        _data_ = g_slice_new0 (UnityFilesPlaceUtilsListDirData);
879
 
        _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, unity_files_place_utils_list_dir);
880
 
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, unity_files_place_utils_list_dir_data_free);
 
624
void unity_files_lens_utils_list_dir (GFile* folder, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
625
        UnityFilesLensUtilsListDirData* _data_;
 
626
        _data_ = g_slice_new0 (UnityFilesLensUtilsListDirData);
 
627
        _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, unity_files_lens_utils_list_dir);
 
628
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, unity_files_lens_utils_list_dir_data_free);
881
629
        _data_->folder = _g_object_ref0 (folder);
882
 
        unity_files_place_utils_list_dir_co (_data_);
 
630
        unity_files_lens_utils_list_dir_co (_data_);
883
631
}
884
632
 
885
633
 
886
 
GSList* unity_files_place_utils_list_dir_finish (GAsyncResult* _res_, GError** error) {
 
634
GSList* unity_files_lens_utils_list_dir_finish (GAsyncResult* _res_, GError** error) {
887
635
        GSList* result;
888
 
        UnityFilesPlaceUtilsListDirData* _data_;
 
636
        UnityFilesLensUtilsListDirData* _data_;
889
637
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
890
638
                return NULL;
891
639
        }
901
649
     * and return a list of FileInfos filled with the attributes specified
902
650
     * by Utils.all_attribs
903
651
     */
904
 
static void unity_files_place_utils_list_dir_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
905
 
        UnityFilesPlaceUtilsListDirData* data;
 
652
static void unity_files_lens_utils_list_dir_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
653
        UnityFilesLensUtilsListDirData* data;
906
654
        data = _user_data_;
907
655
        data->_source_object_ = source_object;
908
656
        data->_res_ = _res_;
909
 
        unity_files_place_utils_list_dir_co (data);
 
657
        unity_files_lens_utils_list_dir_co (data);
910
658
}
911
659
 
912
660
 
940
688
}
941
689
 
942
690
 
943
 
static gboolean unity_files_place_utils_list_dir_co (UnityFilesPlaceUtilsListDirData* data) {
 
691
static gboolean unity_files_lens_utils_list_dir_co (UnityFilesLensUtilsListDirData* data) {
944
692
        switch (data->_state_) {
945
693
                case 0:
946
694
                goto _state_0;
954
702
        _state_0:
955
703
        data->_result_ = NULL;
956
704
        data->_state_ = 1;
957
 
        g_file_enumerate_children_async (data->folder, UNITY_FILES_PLACE_UTILS_all_attribs, 0, G_PRIORITY_DEFAULT, NULL, unity_files_place_utils_list_dir_ready, data);
 
705
        g_file_enumerate_children_async (data->folder, UNITY_FILES_LENS_UTILS_all_attribs, 0, G_PRIORITY_DEFAULT, NULL, unity_files_lens_utils_list_dir_ready, data);
958
706
        return FALSE;
959
707
        _state_1:
960
708
        data->_tmp0_ = NULL;
974
722
        }
975
723
        while (TRUE) {
976
724
                data->_state_ = 2;
977
 
                g_file_enumerator_next_files_async (data->e, 10, G_PRIORITY_DEFAULT, NULL, unity_files_place_utils_list_dir_ready, data);
 
725
                g_file_enumerator_next_files_async (data->e, 10, G_PRIORITY_DEFAULT, NULL, unity_files_lens_utils_list_dir_ready, data);
978
726
                return FALSE;
979
727
                _state_2:
980
728
                data->_tmp1_ = NULL;
1052
800
}
1053
801
 
1054
802
 
1055
 
void unity_files_place_utils_apply_uri_filter (GeeSet* valid_uris, DeeResultSet* filter_set) {
 
803
void unity_files_lens_utils_apply_uri_filter (GeeSet* valid_uris, DeeResultSet* filter_set) {
1056
804
        DeeModel* _tmp0_ = NULL;
1057
805
        DeeModel* _tmp1_;
1058
806
        DeeModel* model;
1080
828
                        if (!(row != NULL)) {
1081
829
                                break;
1082
830
                        }
1083
 
                        _tmp4_ = dee_model_get_string (model, row, (guint) UNITY_FILES_PLACE_RESULTS_COLUMN_URI);
 
831
                        _tmp4_ = dee_model_get_string (model, row, (guint) UNITY_FILES_LENS_RESULTS_COLUMN_URI);
1084
832
                        _tmp5_ = g_strdup (_tmp4_);
1085
833
                        _g_free0 (uri);
1086
834
                        uri = _tmp5_;
1093
841
                _g_object_unref0 (_row_it);
1094
842
        }
1095
843
        if (n_removed > 0) {
1096
 
                g_debug ("utils.vala:325: Removed %u rows from result set", n_removed);
 
844
                g_debug ("utils.vala:326: Removed %u rows from result set", n_removed);
1097
845
        }
1098
846
        _g_free0 (uri);
1099
847
        _g_object_unref0 (model);
1100
848
}
1101
849
 
1102
850
 
1103
 
gboolean unity_files_place_utils_check_is_filter_search (UnityPlaceSearch* new_search, UnityPlaceSearch* old_search) {
 
851
gboolean unity_files_lens_utils_check_is_filter_search (UnityLensSearch* new_search, UnityLensSearch* old_search) {
1104
852
        gboolean result = FALSE;
1105
853
        gboolean is_filter_search;
1106
854
        g_return_val_if_fail (new_search != NULL, FALSE);
1107
855
        is_filter_search = FALSE;
1108
856
        if (old_search != NULL) {
1109
 
                gchar* _tmp0_ = NULL;
 
857
                const gchar* _tmp0_ = NULL;
 
858
                gchar* _tmp1_;
1110
859
                gchar* previous_search_string;
1111
 
                gboolean _tmp1_ = FALSE;
1112
 
                _tmp0_ = unity_place_search_get_search_string (old_search);
1113
 
                previous_search_string = _tmp0_;
 
860
                gboolean _tmp2_ = FALSE;
 
861
                _tmp0_ = unity_lens_search_get_search_string (old_search);
 
862
                _tmp1_ = g_strdup (_tmp0_);
 
863
                previous_search_string = _tmp1_;
1114
864
                if (previous_search_string != NULL) {
1115
 
                        _tmp1_ = g_strcmp0 (previous_search_string, "") != 0;
 
865
                        _tmp2_ = g_strcmp0 (previous_search_string, "") != 0;
1116
866
                } else {
1117
 
                        _tmp1_ = FALSE;
 
867
                        _tmp2_ = FALSE;
1118
868
                }
1119
 
                if (_tmp1_) {
1120
 
                        gchar* _tmp2_ = NULL;
1121
 
                        gchar* _tmp3_;
 
869
                if (_tmp2_) {
 
870
                        const gchar* _tmp3_ = NULL;
1122
871
                        gboolean _tmp4_;
1123
 
                        _tmp2_ = unity_place_search_get_search_string (new_search);
1124
 
                        _tmp3_ = _tmp2_;
 
872
                        _tmp3_ = unity_lens_search_get_search_string (new_search);
1125
873
                        _tmp4_ = g_str_has_prefix (_tmp3_, previous_search_string);
1126
874
                        is_filter_search = _tmp4_;
1127
 
                        _g_free0 (_tmp3_);
1128
875
                }
1129
876
                _g_free0 (previous_search_string);
1130
877
        }
1133
880
}
1134
881
 
1135
882
 
1136
 
GeeSet* unity_files_place_utils_get_uri_set (ZeitgeistResultSet* results) {
 
883
GeeSet* unity_files_lens_utils_get_uri_set (ZeitgeistResultSet* results) {
1137
884
        GeeSet* result = NULL;
1138
885
        GeeHashSet* _tmp0_ = NULL;
1139
886
        GeeSet* uris;
1198
945
}
1199
946
 
1200
947
 
1201
 
gboolean unity_files_place_utils_search_has_really_changed (UnityPlaceSearch* old_search, UnityPlaceSearch* new_search) {
 
948
gboolean unity_files_lens_utils_search_has_really_changed (UnityLensSearch* old_search, UnityLensSearch* new_search) {
1202
949
        gboolean result = FALSE;
1203
950
        gboolean _tmp0_ = FALSE;
1204
951
        gchar* s1 = NULL;
1213
960
                return result;
1214
961
        }
1215
962
        if (old_search == NULL) {
1216
 
                gchar* _tmp1_ = NULL;
1217
 
                gboolean _tmp2_ = FALSE;
1218
 
                _tmp1_ = unity_place_search_get_search_string (new_search);
 
963
                const gchar* _tmp1_ = NULL;
 
964
                gchar* _tmp2_;
 
965
                gboolean _tmp3_ = FALSE;
 
966
                _tmp1_ = unity_lens_search_get_search_string (new_search);
 
967
                _tmp2_ = g_strdup (_tmp1_);
1219
968
                _g_free0 (s1);
1220
 
                s1 = _tmp1_;
 
969
                s1 = _tmp2_;
1221
970
                if (s1 == NULL) {
1222
 
                        _tmp2_ = TRUE;
 
971
                        _tmp3_ = TRUE;
1223
972
                } else {
1224
 
                        gchar* _tmp3_ = NULL;
1225
 
                        gchar* _tmp4_;
1226
 
                        _tmp3_ = string_strip (s1);
1227
 
                        _tmp4_ = _tmp3_;
1228
 
                        _tmp2_ = g_strcmp0 (_tmp4_, "") == 0;
1229
 
                        _g_free0 (_tmp4_);
 
973
                        gchar* _tmp4_ = NULL;
 
974
                        gchar* _tmp5_;
 
975
                        _tmp4_ = string_strip (s1);
 
976
                        _tmp5_ = _tmp4_;
 
977
                        _tmp3_ = g_strcmp0 (_tmp5_, "") == 0;
 
978
                        _g_free0 (_tmp5_);
1230
979
                }
1231
 
                if (_tmp2_) {
 
980
                if (_tmp3_) {
1232
981
                        result = FALSE;
1233
982
                        _g_free0 (s2);
1234
983
                        _g_free0 (s1);
1241
990
                }
1242
991
        } else {
1243
992
                if (new_search == NULL) {
1244
 
                        gchar* _tmp5_ = NULL;
1245
 
                        gboolean _tmp6_ = FALSE;
1246
 
                        _tmp5_ = unity_place_search_get_search_string (old_search);
 
993
                        const gchar* _tmp6_ = NULL;
 
994
                        gchar* _tmp7_;
 
995
                        gboolean _tmp8_ = FALSE;
 
996
                        _tmp6_ = unity_lens_search_get_search_string (old_search);
 
997
                        _tmp7_ = g_strdup (_tmp6_);
1247
998
                        _g_free0 (s2);
1248
 
                        s2 = _tmp5_;
 
999
                        s2 = _tmp7_;
1249
1000
                        if (s2 == NULL) {
1250
 
                                _tmp6_ = TRUE;
 
1001
                                _tmp8_ = TRUE;
1251
1002
                        } else {
1252
 
                                gchar* _tmp7_ = NULL;
1253
 
                                gchar* _tmp8_;
1254
 
                                _tmp7_ = string_strip (s2);
1255
 
                                _tmp8_ = _tmp7_;
1256
 
                                _tmp6_ = g_strcmp0 (_tmp8_, "") == 0;
1257
 
                                _g_free0 (_tmp8_);
 
1003
                                gchar* _tmp9_ = NULL;
 
1004
                                gchar* _tmp10_;
 
1005
                                _tmp9_ = string_strip (s2);
 
1006
                                _tmp10_ = _tmp9_;
 
1007
                                _tmp8_ = g_strcmp0 (_tmp10_, "") == 0;
 
1008
                                _g_free0 (_tmp10_);
1258
1009
                        }
1259
 
                        if (_tmp6_) {
 
1010
                        if (_tmp8_) {
1260
1011
                                result = FALSE;
1261
1012
                                _g_free0 (s2);
1262
1013
                                _g_free0 (s1);
1268
1019
                                return result;
1269
1020
                        }
1270
1021
                } else {
1271
 
                        gchar* _tmp9_ = NULL;
1272
 
                        gchar* _tmp10_ = NULL;
1273
 
                        _tmp9_ = unity_place_search_get_search_string (new_search);
 
1022
                        const gchar* _tmp11_ = NULL;
 
1023
                        gchar* _tmp12_;
 
1024
                        const gchar* _tmp13_ = NULL;
 
1025
                        gchar* _tmp14_;
 
1026
                        _tmp11_ = unity_lens_search_get_search_string (new_search);
 
1027
                        _tmp12_ = g_strdup (_tmp11_);
1274
1028
                        _g_free0 (s1);
1275
 
                        s1 = _tmp9_;
1276
 
                        _tmp10_ = unity_place_search_get_search_string (old_search);
 
1029
                        s1 = _tmp12_;
 
1030
                        _tmp13_ = unity_lens_search_get_search_string (old_search);
 
1031
                        _tmp14_ = g_strdup (_tmp13_);
1277
1032
                        _g_free0 (s2);
1278
 
                        s2 = _tmp10_;
 
1033
                        s2 = _tmp14_;
1279
1034
                        if (s1 == NULL) {
1280
 
                                gboolean _tmp11_ = FALSE;
 
1035
                                gboolean _tmp15_ = FALSE;
1281
1036
                                if (s2 == NULL) {
1282
 
                                        _tmp11_ = TRUE;
 
1037
                                        _tmp15_ = TRUE;
1283
1038
                                } else {
1284
 
                                        gchar* _tmp12_ = NULL;
1285
 
                                        gchar* _tmp13_;
1286
 
                                        _tmp12_ = string_strip (s2);
1287
 
                                        _tmp13_ = _tmp12_;
1288
 
                                        _tmp11_ = g_strcmp0 (_tmp13_, "") == 0;
1289
 
                                        _g_free0 (_tmp13_);
 
1039
                                        gchar* _tmp16_ = NULL;
 
1040
                                        gchar* _tmp17_;
 
1041
                                        _tmp16_ = string_strip (s2);
 
1042
                                        _tmp17_ = _tmp16_;
 
1043
                                        _tmp15_ = g_strcmp0 (_tmp17_, "") == 0;
 
1044
                                        _g_free0 (_tmp17_);
1290
1045
                                }
1291
 
                                if (_tmp11_) {
 
1046
                                if (_tmp15_) {
1292
1047
                                        result = FALSE;
1293
1048
                                        _g_free0 (s2);
1294
1049
                                        _g_free0 (s1);
1301
1056
                                }
1302
1057
                        } else {
1303
1058
                                if (s2 == NULL) {
1304
 
                                        gboolean _tmp14_ = FALSE;
 
1059
                                        gboolean _tmp18_ = FALSE;
1305
1060
                                        if (s1 == NULL) {
1306
 
                                                _tmp14_ = TRUE;
 
1061
                                                _tmp18_ = TRUE;
1307
1062
                                        } else {
1308
 
                                                gchar* _tmp15_ = NULL;
1309
 
                                                gchar* _tmp16_;
1310
 
                                                _tmp15_ = string_strip (s1);
1311
 
                                                _tmp16_ = _tmp15_;
1312
 
                                                _tmp14_ = g_strcmp0 (_tmp16_, "") == 0;
1313
 
                                                _g_free0 (_tmp16_);
 
1063
                                                gchar* _tmp19_ = NULL;
 
1064
                                                gchar* _tmp20_;
 
1065
                                                _tmp19_ = string_strip (s1);
 
1066
                                                _tmp20_ = _tmp19_;
 
1067
                                                _tmp18_ = g_strcmp0 (_tmp20_, "") == 0;
 
1068
                                                _g_free0 (_tmp20_);
1314
1069
                                        }
1315
 
                                        if (_tmp14_) {
 
1070
                                        if (_tmp18_) {
1316
1071
                                                result = FALSE;
1317
1072
                                                _g_free0 (s2);
1318
1073
                                                _g_free0 (s1);
1324
1079
                                                return result;
1325
1080
                                        }
1326
1081
                                } else {
1327
 
                                        gchar* _tmp17_ = NULL;
1328
 
                                        gchar* _tmp18_;
1329
 
                                        gchar* _tmp19_ = NULL;
1330
 
                                        gchar* _tmp20_;
1331
 
                                        gboolean _tmp21_;
1332
 
                                        _tmp17_ = string_strip (s1);
1333
 
                                        _tmp18_ = _tmp17_;
1334
 
                                        _tmp19_ = string_strip (s2);
1335
 
                                        _tmp20_ = _tmp19_;
1336
 
                                        _tmp21_ = g_strcmp0 (_tmp18_, _tmp20_) != 0;
1337
 
                                        _g_free0 (_tmp20_);
1338
 
                                        _g_free0 (_tmp18_);
1339
 
                                        result = _tmp21_;
 
1082
                                        gchar* _tmp21_ = NULL;
 
1083
                                        gchar* _tmp22_;
 
1084
                                        gchar* _tmp23_ = NULL;
 
1085
                                        gchar* _tmp24_;
 
1086
                                        gboolean _tmp25_;
 
1087
                                        _tmp21_ = string_strip (s1);
 
1088
                                        _tmp22_ = _tmp21_;
 
1089
                                        _tmp23_ = string_strip (s2);
 
1090
                                        _tmp24_ = _tmp23_;
 
1091
                                        _tmp25_ = g_strcmp0 (_tmp22_, _tmp24_) != 0;
 
1092
                                        _g_free0 (_tmp24_);
 
1093
                                        _g_free0 (_tmp22_);
 
1094
                                        result = _tmp25_;
1340
1095
                                        _g_free0 (s2);
1341
1096
                                        _g_free0 (s1);
1342
1097
                                        return result;
1349
1104
}
1350
1105
 
1351
1106
 
1352
 
gchar* unity_files_place_utils_normalize_string (const gchar* input) {
 
1107
gchar* unity_files_lens_utils_normalize_string (const gchar* input) {
1353
1108
        gchar* result = NULL;
1354
1109
        gchar* _tmp0_ = NULL;
1355
1110
        gchar* _tmp1_;