← Back to branch summary

~ubuntu-branches/ubuntu/lucid/nautilus-actions/lucid

« back to all changes in this revision

Viewing changes to libnautilus-actions/nautilus-actions-config-schema-reader.c

  • Committer: Bazaar Package Importer
  • Author(s): Christine Spang
  • Date: 2006-05-02 21:15:03 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060502211503-ygoa8zap193bi9gq
Tags: 1.2-1
* New upstream release.
  - Add support for filtering using mimetypes of selected files
  - Add support for choice about case sensitiveness of file patterns
  - New Tango style icons
  - Grammar and spelling errors fixed
  - Fix segfault when defining an action with an empty file pattern
  - Fix a crash when selecting a cdrom drive with Nautilus 2.14
  - Added Bengali translation; others updated
  - Other minor bugfixes
* Bumped standards version to 2.7.0.0; no change.
* Added debian/watch

Show diffs side-by-side

added added

removed removed

Lines of Context:
libnautilus-actions/nautilus-actions-config-schema-reader.c
39
39
        ACTION_PATH_TYPE,
40
40
        ACTION_PARAMS_TYPE,
41
41
        ACTION_BASENAMES_TYPE,
 
42
        ACTION_MATCHCASE_TYPE,
 
43
        ACTION_MIMETYPES_TYPE,
42
44
        ACTION_ISFILE_TYPE,
43
45
        ACTION_ISDIR_TYPE,
44
46
        ACTION_MULTIPLE_TYPE,
67
69
        
68
70
        for (iter = config_node->children; iter; iter = iter->next)
69
71
        {
70
 
                xmlChar *text;
71
 
 
72
72
                if (!retv && iter->type == XML_ELEMENT_NODE &&
73
73
                                g_ascii_strncasecmp ((gchar*)iter->name, 
74
74
                                                                NA_GCONF_XML_SCHEMA_DFT,
75
75
                                                                strlen (NA_GCONF_XML_SCHEMA_DFT)) == 0)
76
76
                {
77
 
                        *value = xmlNodeGetContent (iter);
 
77
                        *value = (char*)xmlNodeGetContent (iter);
78
78
                        retv = TRUE;
79
79
                }
80
80
        }
93
93
        *type = ACTION_NONE_TYPE;
94
94
        for (iter = config_node->children; iter; iter = iter->next)
95
95
        {
96
 
                xmlChar *text;
 
96
                char *text;
97
97
 
98
98
                if (!is_key_ok && iter->type == XML_ELEMENT_NODE &&
99
99
                                g_ascii_strncasecmp ((gchar*)iter->name, 
100
100
                                                                NA_GCONF_XML_SCHEMA_APPLYTO,
101
101
                                                                strlen (NA_GCONF_XML_SCHEMA_APPLYTO)) == 0)
102
102
                {
103
 
                        text = xmlNodeGetContent (iter);
 
103
                        text = (char*)xmlNodeGetContent (iter);
104
104
 
105
105
                        if (get_uuid)
106
106
                        {
131
131
                        {
132
132
                                *type = ACTION_BASENAMES_TYPE;
133
133
                        }
 
134
                        else if (g_str_has_suffix (text, ACTION_MATCHCASE_ENTRY))
 
135
                        {
 
136
                                *type = ACTION_MATCHCASE_TYPE;
 
137
                        }
 
138
                        else if (g_str_has_suffix (text, ACTION_MIMETYPES_ENTRY))
 
139
                        {
 
140
                                *type = ACTION_MIMETYPES_TYPE;
 
141
                        }
134
142
                        else if (g_str_has_suffix (text, ACTION_ISFILE_ENTRY))
135
143
                        {
136
144
                                *type = ACTION_ISFILE_TYPE;
163
171
                                                                NA_GCONF_XML_SCHEMA_DFT,
164
172
                                                                strlen (NA_GCONF_XML_SCHEMA_DFT)) == 0)
165
173
                {
166
 
                        *value = xmlNodeGetContent (iter);
 
174
                        *value = (char*)xmlNodeGetContent (iter);
167
175
                        is_default_value_ok = TRUE;
168
176
                }
169
177
                else if (!is_default_value_ok && iter->type == XML_ELEMENT_NODE &&
187
195
static GSList* schema_string_to_gslist (const gchar* str_list_value)
188
196
{
189
197
        GSList* list = NULL;
190
 
        gchar* ptr = str_list_value;
191
 
        gchar* start = NULL;
 
198
        const gchar* ptr = str_list_value;
 
199
        const gchar* start = NULL;
192
200
        gchar* str_list = NULL;
193
201
        gchar** str_list_splited = NULL;
194
 
        gboolean found = FALSE;
195
202
        int i;
196
203
        
197
204
        //--> First remove the brackets []
253
260
        gboolean is_path_ok = FALSE;
254
261
        gboolean is_params_ok = FALSE;
255
262
        gboolean is_basenames_ok = FALSE;
 
263
        gboolean is_matchcase_ok = FALSE;
 
264
        gboolean is_mimetypes_ok = FALSE;
256
265
        gboolean is_isfile_ok = FALSE;
257
266
        gboolean is_isdir_ok = FALSE;
258
267
        gboolean is_multiple_ok = FALSE;
310
319
                                                g_slist_foreach (list, (GFunc)g_free, NULL);
311
320
                                                g_slist_free (list);
312
321
                                                break;
 
322
                                        case ACTION_MATCHCASE_TYPE:
 
323
                                                is_matchcase_ok = TRUE;
 
324
                                                nautilus_actions_config_action_set_match_case (action, schema_string_to_bool (value));
 
325
                                                break;
 
326
                                        case ACTION_MIMETYPES_TYPE:
 
327
                                                is_mimetypes_ok = TRUE;
 
328
                                                list = schema_string_to_gslist (value);
 
329
                                                nautilus_actions_config_action_set_mimetypes (action, list);
 
330
                                                g_slist_foreach (list, (GFunc)g_free, NULL);
 
331
                                                g_slist_free (list);
 
332
                                                break;
313
333
                                        case ACTION_ISFILE_TYPE:
314
334
                                                is_isfile_ok = TRUE;
315
335
                                                nautilus_actions_config_action_set_is_file (action, schema_string_to_bool (value));
335
355
                                                {
336
356
                                                        g_free (action->version);
337
357
                                                }
338
 
                                                action->version = g_strdup (NAUTILUS_ACTIONS_CONFIG_VERSION);
 
358
                                                action->version = g_strdup (value);
339
359
                                                break;
340
360
                                        default:
341
361
                                                break;
346
366
                }
347
367
        }
348
368
                
349
 
        if (is_version_ok && is_schemes_ok && is_multiple_ok && 
350
 
                                is_isdir_ok && is_isfile_ok && is_basenames_ok && 
351
 
                                is_params_ok && is_path_ok && is_icon_ok && 
352
 
                                is_tooltip_ok && is_label_ok)
 
369
        if (is_version_ok)
353
370
        {
354
 
                retv = TRUE;
 
371
                if (g_ascii_strcasecmp (action->version, "1.0") == 0 && 
 
372
                                is_schemes_ok && is_multiple_ok && 
 
373
                                is_isdir_ok && is_isfile_ok && is_basenames_ok && 
 
374
                                is_params_ok && is_path_ok && is_icon_ok && 
 
375
                                is_tooltip_ok && is_label_ok)
 
376
                {
 
377
 
 
378
                        retv = TRUE;
 
379
                }
 
380
                else if (g_ascii_strcasecmp (action->version, NAUTILUS_ACTIONS_CONFIG_VERSION) == 0 && 
 
381
                                is_schemes_ok && is_multiple_ok && 
 
382
                                is_matchcase_ok && is_mimetypes_ok &&
 
383
                                is_isdir_ok && is_isfile_ok && is_basenames_ok && 
 
384
                                is_params_ok && is_path_ok && is_icon_ok && 
 
385
                                is_tooltip_ok && is_label_ok)
 
386
                {
 
387
                        retv = TRUE;
 
388
                }
355
389
        }       
356
390
 
 
391
        /*
 
392
        g_warning ("schemes : %d, multiple : %d, match_case : %d, mimetypes : %d, isdir : %d, isfile : %d, basenames : %d, param : %d, path : %d, icon : %d, tooltip : %d, label : %d, TRUE: %d, version: %s",
 
393
                                is_schemes_ok ,  is_multiple_ok ,  
 
394
                                is_matchcase_ok ,  is_mimetypes_ok , 
 
395
                                is_isdir_ok ,  is_isfile_ok ,  is_basenames_ok ,  
 
396
                                is_params_ok ,  is_path_ok ,  is_icon_ok ,  
 
397
                                is_tooltip_ok ,  is_label_ok, TRUE, action->version);
 
398
        */
357
399
        return retv;
358
400
}
359
401
 
380
422
                                                                                                NA_GCONF_XML_SCHEMA_LIST, 
381
423
                                                                                                strlen (NA_GCONF_XML_SCHEMA_LIST)) == 0)
382
424
                                {
383
 
                                        action = nautilus_actions_config_action_new ();
 
425
                                        action = nautilus_actions_config_action_new_default ();
384
426
                                        if (action->uuid != NULL)
385
427
                                        {
386
428
                                                g_free (action->uuid);