← Back to branch summary

~ubuntu-branches/debian/stretch/glade/stretch

« back to all changes in this revision

Viewing changes to gladeui/glade-xml-utils.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson, Emilio Pozuelo Monfort, Andreas Henriksson
  • Date: 2014-05-23 13:00:17 UTC
  • mfrom: (1.3.2)
  • Revision ID: package-import@ubuntu.com-20140523130017-7sp231ghdz55szde
Tags: 3.18.3-1
[ Emilio Pozuelo Monfort ]
* debian/rules:
  + Pass -c4 to dpkg-gensymbols so we know when new symbols are added.
* debian/libgladeui-2-6.symbols:
  + Add missing symbols.

[ Andreas Henriksson ]
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gladeui/glade-xml-utils.c
63
63
 
64
64
 
65
65
static gchar *
66
 
claim_string (xmlChar * string)
 
66
claim_string (xmlChar *string)
67
67
{
68
68
  gchar *ret;
69
69
  ret = g_strdup (CAST_BAD (string));
80
80
 * Sets the property @name in @node_in to @val
81
81
 */
82
82
void
83
 
glade_xml_set_value (GladeXmlNode * node_in, const gchar * name,
84
 
                     const gchar * val)
 
83
glade_xml_set_value (GladeXmlNode *node_in, const gchar *name, const gchar *val)
85
84
{
86
85
  xmlNodePtr node = (xmlNodePtr) node_in;
87
86
  xmlChar *ret;
104
103
 * Returns: A newly allocated string
105
104
 */
106
105
gchar *
107
 
glade_xml_get_content (GladeXmlNode * node_in)
 
106
glade_xml_get_content (GladeXmlNode *node_in)
108
107
{
109
108
  xmlNodePtr node = (xmlNodePtr) node_in;
110
109
  xmlChar *val = xmlNodeGetContent (node);
120
119
 * Sets the content of @node to @content.
121
120
 */
122
121
void
123
 
glade_xml_set_content (GladeXmlNode * node_in, const gchar * content)
 
122
glade_xml_set_content (GladeXmlNode *node_in, const gchar *content)
124
123
{
125
124
  xmlNodePtr node = (xmlNodePtr) node_in;
126
125
  xmlChar *content_encoded;
142
141
 *
143
142
 */
144
143
static gchar *
145
 
glade_xml_get_value (xmlNodePtr node, const gchar * name)
 
144
glade_xml_get_value (xmlNodePtr node, const gchar *name)
146
145
{
147
146
  xmlNodePtr child;
148
147
  gchar *ret = NULL;
162
161
 * Returns: %TRUE if @node_in's name is equal to @name, %FALSE otherwise
163
162
 */
164
163
gboolean
165
 
glade_xml_node_verify_silent (GladeXmlNode * node_in, const gchar * name)
 
164
glade_xml_node_verify_silent (GladeXmlNode *node_in, const gchar *name)
166
165
{
167
166
  xmlNodePtr node = (xmlNodePtr) node_in;
168
167
 
184
183
 * Returns: %TRUE if @node_in's name is equal to @name, %FALSE otherwise
185
184
 */
186
185
gboolean
187
 
glade_xml_node_verify (GladeXmlNode * node_in, const gchar * name)
 
186
glade_xml_node_verify (GladeXmlNode *node_in, const gchar *name)
188
187
{
189
188
  xmlNodePtr node = (xmlNodePtr) node_in;
190
189
 
210
209
 * Returns: %TRUE if the node is found, %FALSE otherwise
211
210
 */
212
211
gboolean
213
 
glade_xml_get_value_int (GladeXmlNode * node_in, const gchar * name, gint * val)
 
212
glade_xml_get_value_int (GladeXmlNode *node_in, const gchar *name, gint *val)
214
213
{
215
214
  xmlNodePtr node = (xmlNodePtr) node_in;
216
215
  gchar *value, *endptr = NULL;
245
244
 * Returns:
246
245
 **/
247
246
gboolean
248
 
glade_xml_get_value_int_required (GladeXmlNode * node, const gchar * name,
249
 
                                  gint * val)
 
247
glade_xml_get_value_int_required (GladeXmlNode *node,
 
248
                                  const gchar  *name,
 
249
                                  gint         *val)
250
250
{
251
251
  gboolean ret;
252
252
 
264
264
 * the content of a child.
265
265
 */
266
266
gchar *
267
 
glade_xml_get_value_string (GladeXmlNode * node_in, const gchar * name)
 
267
glade_xml_get_value_string (GladeXmlNode *node_in, const gchar *name)
268
268
{
269
269
  xmlNodePtr node = (xmlNodePtr) node_in;
270
270
  return glade_xml_get_value (node, name);
271
271
}
272
272
 
273
273
static gchar *
274
 
glade_xml_get_property (xmlNodePtr node, const gchar * name)
 
274
glade_xml_get_property (xmlNodePtr node, const gchar *name)
275
275
{
276
276
  xmlChar *val;
277
277
 
284
284
}
285
285
 
286
286
static void
287
 
glade_xml_set_property (xmlNodePtr node, const gchar * name,
288
 
                        const gchar * value)
 
287
glade_xml_set_property (xmlNodePtr   node,
 
288
                        const gchar *name,
 
289
                        const gchar *value)
289
290
{
290
291
  if (value)
291
292
    xmlSetProp (node, BAD_CAST (name), BAD_CAST (value));
302
303
 * the content of a child.
303
304
 */
304
305
gboolean
305
 
glade_xml_get_boolean (GladeXmlNode * node_in, const gchar * name,
306
 
                       gboolean _default)
 
306
glade_xml_get_boolean (GladeXmlNode *node_in,
 
307
                       const gchar  *name,
 
308
                       gboolean      _default)
307
309
{
308
310
  xmlNodePtr node = (xmlNodePtr) node_in;
309
311
  gchar *value;
338
340
 * the content of a child.
339
341
 */
340
342
gboolean
341
 
glade_xml_get_property_boolean (GladeXmlNode * node_in,
342
 
                                const gchar * name, gboolean _default)
 
343
glade_xml_get_property_boolean (GladeXmlNode *node_in,
 
344
                                const gchar  *name,
 
345
                                gboolean      _default)
343
346
{
344
347
  xmlNodePtr node = (xmlNodePtr) node_in;
345
348
  gchar *value;
370
373
}
371
374
 
372
375
gdouble
373
 
glade_xml_get_property_double (GladeXmlNode * node_in,
374
 
                               const gchar * name, gdouble _default)
 
376
glade_xml_get_property_double (GladeXmlNode *node_in,
 
377
                               const gchar  *name,
 
378
                               gdouble       _default)
375
379
{
376
380
  xmlNodePtr node = (xmlNodePtr) node_in;
377
381
  gdouble retval;
397
401
}
398
402
 
399
403
gint
400
 
glade_xml_get_property_int (GladeXmlNode * node_in,
401
 
                            const gchar * name, gint _default)
 
404
glade_xml_get_property_int (GladeXmlNode *node_in,
 
405
                            const gchar  *name,
 
406
                            gint          _default)
402
407
{
403
408
  xmlNodePtr node = (xmlNodePtr) node_in;
404
409
  gint retval;
415
420
}
416
421
 
417
422
void
418
 
glade_xml_node_set_property_boolean (GladeXmlNode * node_in,
419
 
                                     const gchar * name, gboolean value)
 
423
glade_xml_node_set_property_boolean (GladeXmlNode *node_in,
 
424
                                     const gchar  *name,
 
425
                                     gboolean      value)
420
426
{
421
427
  xmlNodePtr node = (xmlNodePtr) node_in;
422
428
 
434
440
#undef GLADE_TAG_FALSE3
435
441
 
436
442
gchar *
437
 
glade_xml_get_value_string_required (GladeXmlNode * node_in,
438
 
                                     const gchar * name, const gchar * xtra)
 
443
glade_xml_get_value_string_required (GladeXmlNode *node_in,
 
444
                                     const gchar  *name,
 
445
                                     const gchar  *xtra)
439
446
{
440
447
  xmlNodePtr node = (xmlNodePtr) node_in;
441
448
  gchar *value = glade_xml_get_value (node, name);
454
461
}
455
462
 
456
463
gchar *
457
 
glade_xml_get_property_string (GladeXmlNode * node_in, const gchar * name)
 
464
glade_xml_get_property_string (GladeXmlNode *node_in, const gchar *name)
458
465
{
459
466
  xmlNodePtr node = (xmlNodePtr) node_in;
460
467
 
462
469
}
463
470
 
464
471
void
465
 
glade_xml_node_set_property_string (GladeXmlNode * node_in,
466
 
                                    const gchar * name, const gchar * string)
 
472
glade_xml_node_set_property_string (GladeXmlNode *node_in,
 
473
                                    const gchar  *name,
 
474
                                    const gchar  *string)
467
475
{
468
476
  xmlNodePtr node = (xmlNodePtr) node_in;
469
477
 
471
479
}
472
480
 
473
481
gchar *
474
 
glade_xml_get_property_string_required (GladeXmlNode * node_in,
475
 
                                        const gchar * name, const gchar * xtra)
 
482
glade_xml_get_property_string_required (GladeXmlNode *node_in,
 
483
                                        const gchar  *name,
 
484
                                        const gchar  *xtra)
476
485
{
477
486
  xmlNodePtr node = (xmlNodePtr) node_in;
478
487
  gchar *value = glade_xml_get_property_string (node_in, name);
490
499
}
491
500
 
492
501
gboolean
493
 
glade_xml_get_property_version (GladeXmlNode * node_in,
494
 
                                const gchar * name,
495
 
                                guint16 * major, guint16 * minor)
 
502
glade_xml_get_property_version (GladeXmlNode *node_in,
 
503
                                const gchar  *name,
 
504
                                guint16      *major,
 
505
                                guint16      * minor)
496
506
{
497
507
  xmlNodePtr node = (xmlNodePtr) node_in;
498
508
  gchar *value = glade_xml_get_property_string (node_in, name);
522
532
}
523
533
 
524
534
GList *
525
 
glade_xml_get_property_targetable_versions (GladeXmlNode * node_in,
526
 
                                            const gchar * name)
 
535
glade_xml_get_property_targetable_versions (GladeXmlNode *node_in,
 
536
                                            const gchar  *name)
527
537
{
528
538
  GladeTargetableVersion *version;
529
539
  GList *targetable = NULL;
571
581
 * Search a child by name,
572
582
 */
573
583
GladeXmlNode *
574
 
glade_xml_search_child (GladeXmlNode * node_in, const gchar * name)
 
584
glade_xml_search_child (GladeXmlNode *node_in, const gchar *name)
575
585
{
576
586
  xmlNodePtr node;
577
587
  xmlNodePtr child;
601
611
 * Return Value: 
602
612
 **/
603
613
GladeXmlNode *
604
 
glade_xml_search_child_required (GladeXmlNode * node, const gchar * name)
 
614
glade_xml_search_child_required (GladeXmlNode *node, const gchar *name)
605
615
{
606
616
  GladeXmlNode *child;
607
617
 
617
627
/* --------------------------- Parse Context ----------------------------*/
618
628
 
619
629
static GladeXmlContext *
620
 
glade_xml_context_new_real (GladeXmlDoc * doc, gboolean freedoc, xmlNsPtr ns)
 
630
glade_xml_context_new_real (GladeXmlDoc *doc, gboolean freedoc, xmlNsPtr ns)
621
631
{
622
632
  GladeXmlContext *context = g_new0 (GladeXmlContext, 1);
623
633
 
629
639
}
630
640
 
631
641
GladeXmlContext *
632
 
glade_xml_context_new (GladeXmlDoc * doc, const gchar * name_space)
 
642
glade_xml_context_new (GladeXmlDoc *doc, const gchar *name_space)
633
643
{
634
644
  /* We are not using the namespace now */
635
645
  return glade_xml_context_new_real (doc, TRUE, NULL);
645
655
}
646
656
 
647
657
GladeXmlContext *
648
 
glade_xml_context_new_from_path (const gchar * full_path,
649
 
                                 const gchar * nspace, const gchar * root_name)
 
658
glade_xml_context_new_from_path (const gchar *full_path,
 
659
                                 const gchar *nspace,
 
660
                                 const gchar *root_name)
650
661
{
651
662
  GladeXmlContext *context;
652
663
  xmlDocPtr doc;
703
714
 * Similar to glade_xml_context_destroy but it also frees the document set in the context
704
715
 **/
705
716
void
706
 
glade_xml_context_free (GladeXmlContext * context)
 
717
glade_xml_context_free (GladeXmlContext *context)
707
718
{
708
719
  g_return_if_fail (context != NULL);
709
720
  if (context->doc)
714
725
}
715
726
 
716
727
void
717
 
glade_xml_node_append_child (GladeXmlNode * node_in, GladeXmlNode * child_in)
 
728
glade_xml_node_append_child (GladeXmlNode *node_in,
 
729
                             GladeXmlNode *child_in)
718
730
{
719
731
  xmlNodePtr node = (xmlNodePtr) node_in;
720
732
  xmlNodePtr child = (xmlNodePtr) child_in;
737
749
 
738
750
 
739
751
GladeXmlNode *
740
 
glade_xml_node_new (GladeXmlContext * context, const gchar * name)
 
752
glade_xml_node_new (GladeXmlContext *context, const gchar *name)
741
753
{
742
754
  g_return_val_if_fail (context != NULL, NULL);
743
755
  g_return_val_if_fail (name != NULL, NULL);
747
759
}
748
760
 
749
761
GladeXmlNode *
750
 
glade_xml_node_new_comment (GladeXmlContext * context, const gchar * comment)
 
762
glade_xml_node_new_comment (GladeXmlContext *context, const gchar *comment)
751
763
{
752
764
  g_return_val_if_fail (context != NULL, NULL);
753
765
  g_return_val_if_fail (comment != NULL, NULL);
769
781
}
770
782
 
771
783
void
772
 
glade_xml_node_delete (GladeXmlNode * node)
 
784
glade_xml_node_delete (GladeXmlNode *node)
773
785
{
774
786
  xmlFreeNode ((xmlNodePtr) node);
775
787
}
776
788
 
777
789
GladeXmlDoc *
778
 
glade_xml_context_get_doc (GladeXmlContext * context)
 
790
glade_xml_context_get_doc (GladeXmlContext *context)
779
791
{
780
792
  return context->doc;
781
793
}
782
794
 
783
795
gchar *
784
 
glade_xml_dump_from_context (GladeXmlContext * context)
 
796
glade_xml_dump_from_context (GladeXmlContext *context)
785
797
{
786
798
  GladeXmlDoc *doc;
787
799
  xmlChar *string = NULL;
797
809
}
798
810
 
799
811
gboolean
800
 
glade_xml_node_is_comment (GladeXmlNode * node_in)
 
812
glade_xml_node_is_comment (GladeXmlNode *node_in)
801
813
{
802
814
  xmlNodePtr node = (xmlNodePtr) node_in;
803
815
  return (node) ? node->type == XML_COMMENT_NODE : FALSE;
824
836
}
825
837
 
826
838
GladeXmlNode *
827
 
glade_xml_node_get_parent (GladeXmlNode * node_in)
 
839
glade_xml_node_get_parent (GladeXmlNode *node_in)
828
840
{
829
841
  xmlNodePtr node = (xmlNodePtr) node_in;
830
842
 
833
845
 
834
846
 
835
847
GladeXmlNode *
836
 
glade_xml_node_get_children_with_comments (GladeXmlNode * node_in)
 
848
glade_xml_node_get_children_with_comments (GladeXmlNode *node_in)
837
849
{
838
850
  xmlNodePtr node = (xmlNodePtr) node_in;
839
851
 
841
853
}
842
854
 
843
855
GladeXmlNode *
844
 
glade_xml_node_next (GladeXmlNode * node_in)
 
856
glade_xml_node_next (GladeXmlNode *node_in)
845
857
{
846
858
  xmlNodePtr node = (xmlNodePtr) node_in;
847
859
 
853
865
}
854
866
 
855
867
GladeXmlNode *
856
 
glade_xml_node_next_with_comments (GladeXmlNode * node_in)
 
868
glade_xml_node_next_with_comments (GladeXmlNode *node_in)
857
869
{
858
870
  xmlNodePtr node = (xmlNodePtr) node_in;
859
871
 
861
873
}
862
874
 
863
875
GladeXmlNode *
864
 
glade_xml_node_prev_with_comments (GladeXmlNode * node_in)
 
876
glade_xml_node_prev_with_comments (GladeXmlNode *node_in)
865
877
{
866
878
  xmlNodePtr node = (xmlNodePtr) node_in;
867
879
 
869
881
}
870
882
 
871
883
const gchar *
872
 
glade_xml_node_get_name (GladeXmlNode * node_in)
 
884
glade_xml_node_get_name (GladeXmlNode *node_in)
873
885
{
874
886
  xmlNodePtr node = (xmlNodePtr) node_in;
875
887
 
885
897
}
886
898
 
887
899
void
888
 
glade_xml_doc_set_root (GladeXmlDoc * doc_in, GladeXmlNode * node_in)
 
900
glade_xml_doc_set_root (GladeXmlDoc *doc_in, GladeXmlNode *node_in)
889
901
{
890
902
  xmlNodePtr node = (xmlNodePtr) node_in;
891
903
  xmlDocPtr doc = (xmlDocPtr) doc_in;
894
906
}
895
907
 
896
908
gint
897
 
glade_xml_doc_save (GladeXmlDoc * doc_in, const gchar * full_path)
 
909
glade_xml_doc_save (GladeXmlDoc *doc_in, const gchar *full_path)
898
910
{
899
911
  xmlDocPtr doc = (xmlDocPtr) doc_in;
900
912
 
903
915
}
904
916
 
905
917
void
906
 
glade_xml_doc_free (GladeXmlDoc * doc_in)
 
918
glade_xml_doc_free (GladeXmlDoc *doc_in)
907
919
{
908
920
  xmlDocPtr doc = (xmlDocPtr) doc_in;
909
921
 
917
929
 * Returns: the #GladeXmlNode that is the document root of @doc
918
930
 */
919
931
GladeXmlNode *
920
 
glade_xml_doc_get_root (GladeXmlDoc * doc)
 
932
glade_xml_doc_get_root (GladeXmlDoc *doc)
921
933
{
922
934
  xmlNodePtr node;
923
935
 
927
939
}
928
940
 
929
941
gboolean
930
 
glade_xml_load_sym_from_node (GladeXmlNode * node_in,
931
 
                              GModule * module,
932
 
                              gchar * tagname, gpointer * sym_location)
 
942
glade_xml_load_sym_from_node (GladeXmlNode *node_in,
 
943
                              GModule      *module,
 
944
                              gchar        *tagname,
 
945
                              gpointer     *sym_location)
933
946
{
934
947
  static GModule *self = NULL;
935
948
  gboolean retval = FALSE;