]> git.sur5r.net Git - glabels/blob - libglabels/lgl-xml-template.c
Updated POTFILES.in
[glabels] / libglabels / lgl-xml-template.c
1 /*
2  *  lgl-xml-template.c
3  *  Copyright (C) 2001-2010  Jim Evins <evins@snaught.com>.
4  *
5  *  This file is part of libglabels.
6  *
7  *  libglabels is free software: you can redistribute it and/or modify
8  *  it under the terms of the GNU Lesser General Public License as published by
9  *  the Free Software Foundation, either version 3 of the License, or
10  *  (at your option) any later version.
11  *
12  *  libglabels 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
15  *  GNU Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public License
18  *  along with libglabels.  If not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include "lgl-xml-template.h"
24
25 #include <glib/gi18n.h>
26 #include <glib.h>
27 #include <string.h>
28 #include <libintl.h>
29
30 #include "libglabels-private.h"
31
32 #include "lgl-db.h"
33 #include "lgl-xml.h"
34
35 /*===========================================*/
36 /* Private types                             */
37 /*===========================================*/
38
39 /*===========================================*/
40 /* Private globals                           */
41 /*===========================================*/
42
43 /*===========================================*/
44 /* Local function prototypes                 */
45 /*===========================================*/
46 static void  xml_parse_meta_node            (xmlNodePtr              label_node,
47                                              lglTemplate            *template);
48 static void  xml_parse_label_rectangle_node (xmlNodePtr              label_node,
49                                              lglTemplate            *template);
50 static void  xml_parse_label_ellipse_node   (xmlNodePtr              label_node,
51                                              lglTemplate            *template);
52 static void  xml_parse_label_round_node     (xmlNodePtr              label_node,
53                                              lglTemplate            *template);
54 static void  xml_parse_label_cd_node        (xmlNodePtr              label_node,
55                                              lglTemplate            *template);
56 static void  xml_parse_layout_node          (xmlNodePtr              layout_node,
57                                              lglTemplateFrame       *frame);
58 static void  xml_parse_markup_margin_node   (xmlNodePtr              markup_node,
59                                              lglTemplateFrame       *frame);
60 static void  xml_parse_markup_line_node     (xmlNodePtr              markup_node,
61                                              lglTemplateFrame       *frame);
62 static void  xml_parse_markup_circle_node   (xmlNodePtr              markup_node,
63                                              lglTemplateFrame       *frame);
64 static void  xml_parse_markup_rect_node     (xmlNodePtr              markup_node,
65                                              lglTemplateFrame       *frame);
66 static void  xml_parse_markup_ellipse_node  (xmlNodePtr              markup_node,
67                                              lglTemplateFrame       *frame);
68 static void  xml_parse_alias_node           (xmlNodePtr              alias_node,
69                                              lglTemplate            *template);
70
71 static void  xml_create_meta_node           (const gchar                  *attr,
72                                              const gchar                  *value,
73                                              xmlNodePtr                    root,
74                                              const xmlNsPtr                ns);
75 static void  xml_create_label_node          (const lglTemplateFrame       *frame,
76                                              xmlNodePtr                    root,
77                                              const xmlNsPtr                ns);
78 static void  xml_create_layout_node         (const lglTemplateLayout      *layout,
79                                              xmlNodePtr                    root,
80                                              const xmlNsPtr                ns);
81 static void  xml_create_markup_margin_node  (const lglTemplateMarkup      *margin,
82                                              xmlNodePtr                    root,
83                                              const xmlNsPtr                ns);
84 static void  xml_create_markup_line_node    (const lglTemplateMarkup      *line,
85                                              xmlNodePtr                    root,
86                                              const xmlNsPtr                ns);
87 static void  xml_create_markup_circle_node  (const lglTemplateMarkup      *circle,
88                                              xmlNodePtr                    root,
89                                              const xmlNsPtr                ns);
90 static void  xml_create_markup_rect_node    (const lglTemplateMarkup      *circle,
91                                              xmlNodePtr                    root,
92                                              const xmlNsPtr                ns);
93 static void  xml_create_markup_ellipse_node (const lglTemplateMarkup      *circle,
94                                              xmlNodePtr                    root,
95                                              const xmlNsPtr                ns);
96
97
98 /**
99  * lgl_xml_template_read_templates_from_file:
100  * @utf8_filename:       Filename of papers file (name encoded as UTF-8)
101  *
102  * Read glabels templates from template file.
103  *
104  */
105 void
106 lgl_xml_template_read_templates_from_file (const gchar *utf8_filename)
107 {
108         gchar      *filename;
109         xmlDocPtr   templates_doc;
110
111         LIBXML_TEST_VERSION;
112
113         filename = g_filename_from_utf8 (utf8_filename, -1, NULL, NULL, NULL);
114         if (!filename)
115         {
116                 g_message ("Utf8 filename conversion error");
117                 return;
118         }
119
120         templates_doc = xmlParseFile (filename);
121         if (!templates_doc)
122         {
123                 g_message ("\"%s\" is not a glabels template file (not XML)",
124                       filename);
125                 return;
126         }
127
128         lgl_xml_template_parse_templates_doc (templates_doc);
129
130         g_free (filename);
131         xmlFreeDoc (templates_doc);
132 }
133
134
135 /**
136  * lgl_xml_template_parse_templates_doc:
137  * @templates_doc:  libxml #xmlDocPtr tree, representing template file.
138  *
139  * Read glabels templates from a libxml #xmlDocPtr tree.
140  *
141  */
142 void
143 lgl_xml_template_parse_templates_doc (const xmlDocPtr templates_doc)
144 {
145         
146         xmlNodePtr   root, node;
147         lglTemplate *template;
148
149         LIBXML_TEST_VERSION;
150
151         root = xmlDocGetRootElement (templates_doc);
152         if (!root || !root->name)
153         {
154                 g_message ("\"%s\" is not a glabels template file (no root node)",
155                            templates_doc->URL);
156                 return;
157         }
158         if (!lgl_xml_is_node (root, "Glabels-templates"))
159         {
160                 g_message ("\"%s\" is not a glabels template file (wrong root node)",
161                       templates_doc->URL);
162                 return;
163         }
164
165         for (node = root->xmlChildrenNode; node != NULL; node = node->next)
166         {
167
168                 if (lgl_xml_is_node (node, "Template"))
169                 {
170                         template = lgl_xml_template_parse_template_node (node);
171                         if (template)
172                         {
173                                 _lgl_db_register_template_internal (template);
174                                 lgl_template_free (template);
175                         }
176                 }
177                 else
178                 {
179                         if ( !xmlNodeIsText(node) )
180                         {
181                                 if (!lgl_xml_is_node (node,"comment"))
182                                 {
183                                         g_message ("bad node =  \"%s\"",node->name);
184                                 }
185                         }
186                 }
187         }
188 }
189
190
191 /**
192  * lgl_xml_template_parse_template_node:
193  * @template_node:  libxml #xmlNodePtr template node from a #xmlDocPtr tree.
194  *
195  * Read a single glabels template from a libxml #xmlNodePtr node.
196  *
197  * Returns: a pointer to a newly created #lglTemplate structure.
198  *
199  */
200 lglTemplate *
201 lgl_xml_template_parse_template_node (const xmlNodePtr template_node)
202 {
203         gchar                 *brand;
204         gchar                 *part;
205         gchar                 *name;
206         gchar                 *equiv_part;
207         gchar                 *description;
208         gchar                 *paper_id;
209         gdouble                page_width, page_height;
210         lglPaper              *paper = NULL;
211         lglTemplate           *template;
212         xmlNodePtr             node;
213         gchar                **v;
214         lglTemplateFrame      *frame;
215
216
217         brand = lgl_xml_get_prop_string (template_node, "brand", NULL);
218         part  = lgl_xml_get_prop_string (template_node, "part", NULL);
219         if (!brand || !part)
220         {
221                 name = lgl_xml_get_prop_string (template_node, "name", NULL);
222                 if (name)
223                 {
224                         v = g_strsplit (name, " ", 2);
225                         brand = g_strdup (v[0]);
226                         part  = g_strchug (g_strdup (v[1]));
227                         g_free (name);
228                         g_strfreev (v);
229                         
230                 }
231                 else
232                 {
233                         g_message ("Missing name or brand/part attributes.");
234                 }
235         }
236
237
238         equiv_part = lgl_xml_get_prop_string (template_node, "equiv", NULL);
239
240
241         description = lgl_xml_get_prop_i18n_string (template_node, "description", NULL);
242         paper_id = lgl_xml_get_prop_string (template_node, "size", NULL);
243
244         if (lgl_db_is_paper_id_other (paper_id))
245         {
246
247                 page_width = lgl_xml_get_prop_length (template_node, "width", 0);
248                 page_height = lgl_xml_get_prop_length (template_node, "height", 0);
249
250         }
251         else
252         {
253                 paper = lgl_db_lookup_paper_from_id (paper_id);
254                 if (paper == NULL)
255                 {
256                         /* This should always be an id, but just in case a name
257                            slips by! */
258                         g_message ("Unknown page size id \"%s\", trying as name",
259                                    paper_id);
260                         paper = lgl_db_lookup_paper_from_name (paper_id);
261                         g_free (paper_id);
262                         paper_id = g_strdup (paper->id);
263                 }
264                 if (paper != NULL)
265                 {
266                         page_width  = paper->width;
267                         page_height = paper->height;
268                 }
269                 else
270                 {
271                         page_width  = 612;
272                         page_height = 792;
273                         g_message ("Unknown page size id or name \"%s\"",
274                                    paper_id);
275                 }
276                 lgl_paper_free (paper);
277                 paper = NULL;
278         }
279
280
281         if (!equiv_part)
282         {
283                 template = lgl_template_new (brand, part, description,
284                                              paper_id, page_width, page_height);
285         }
286         else
287         {
288                 template = lgl_template_new_from_equiv (brand, part, equiv_part);
289
290                 if (!template)
291                 {
292                         g_message ("Forward references not supported.");
293                         return NULL;
294                 }
295         }
296
297
298         for (node = template_node->xmlChildrenNode; node != NULL; node = node->next)
299         {
300                 if (lgl_xml_is_node (node, "Meta"))
301                 {
302                         xml_parse_meta_node (node, template);
303                 }
304                 else if (lgl_xml_is_node (node, "Label-rectangle"))
305                 {
306                         xml_parse_label_rectangle_node (node, template);
307                 }
308                 else if (lgl_xml_is_node (node, "Label-ellipse"))
309                 {
310                         xml_parse_label_ellipse_node (node, template);
311                 }
312                 else if (lgl_xml_is_node (node, "Label-round"))
313                 {
314                         xml_parse_label_round_node (node, template);
315                 }
316                 else if (lgl_xml_is_node (node, "Label-cd"))
317                 {
318                         xml_parse_label_cd_node (node, template);
319                 }
320                 else if (lgl_xml_is_node (node, "Alias"))
321                 {
322                         xml_parse_alias_node (node, template);
323                 }
324                 else
325                 {
326                         if (!xmlNodeIsText (node))
327                         {
328                                 if (!lgl_xml_is_node (node,"comment"))
329                                 {
330                                         g_message ("bad node =  \"%s\"",node->name);
331                                 }
332                         }
333                 }
334         }
335
336         g_free (brand);
337         g_free (part);
338         g_free (equiv_part);
339         g_free (description);
340         g_free (paper_id);
341
342         /*
343          * Create a default full-page frame, if a known frame type was not found.
344          */
345         if ( template->frames == NULL )
346         {
347                 g_message ("%s %s: missing valid frame node", template->brand, template->part);
348                 frame = lgl_template_frame_rect_new ("0", page_width, page_height, 0, 0, 0);
349                 lgl_template_frame_add_layout (frame, lgl_template_layout_new (1, 1, 0, 0, 0, 0));
350                 lgl_template_add_frame (template, frame);
351         }
352
353         /*
354          * Create a default 1x1 layout, if layout is missing.
355          */
356         frame = (lglTemplateFrame *)template->frames->data;
357         if ( frame->all.layouts == NULL )
358         {
359                 g_message ("%s %s: missing layout node", template->brand, template->part);
360                 lgl_template_frame_add_layout (frame, lgl_template_layout_new (1, 1, 0, 0, 0, 0));
361         }
362
363         return template;
364 }
365
366 /*--------------------------------------------------------------------------*/
367 /* PRIVATE.  Parse XML Template->Meta Node.                                 */
368 /*--------------------------------------------------------------------------*/
369 static void
370 xml_parse_meta_node (xmlNodePtr   meta_node,
371                      lglTemplate *template)
372 {
373         gchar               *product_url;
374         gchar               *category;
375
376         product_url = lgl_xml_get_prop_string (meta_node, "product_url", NULL);
377         if ( product_url != NULL )
378         {
379                 g_free (template->product_url);
380                 template->product_url = product_url;
381         }
382
383         category = lgl_xml_get_prop_string (meta_node, "category", NULL);
384         if ( category != NULL )
385         {
386                 lgl_template_add_category (template, category);
387                 g_free (category);
388         }
389 }
390
391
392 /*--------------------------------------------------------------------------*/
393 /* PRIVATE.  Parse XML Template->Label-rectangle Node.                      */
394 /*--------------------------------------------------------------------------*/
395 static void
396 xml_parse_label_rectangle_node (xmlNodePtr   label_node,
397                                 lglTemplate *template)
398 {
399         gchar               *id;
400         gchar               *tmp;
401         gdouble              x_waste, y_waste;
402         gdouble              w, h, r;
403         lglTemplateFrame    *frame;
404         xmlNodePtr           node;
405
406         id      = lgl_xml_get_prop_string (label_node, "id", NULL);
407
408         if ((tmp = lgl_xml_get_prop_string (label_node, "waste", NULL)))
409         {
410                 /* Handle single "waste" property. */
411                 x_waste = y_waste = lgl_xml_get_prop_length (label_node, "waste", 0);
412                 g_free (tmp);
413         }
414         else
415         {
416                 x_waste = lgl_xml_get_prop_length (label_node, "x_waste", 0);
417                 y_waste = lgl_xml_get_prop_length (label_node, "y_waste", 0);
418         }
419
420         w       = lgl_xml_get_prop_length (label_node, "width", 0);
421         h       = lgl_xml_get_prop_length (label_node, "height", 0);
422         r       = lgl_xml_get_prop_length (label_node, "round", 0);
423
424         frame = lgl_template_frame_rect_new ((gchar *)id, w, h, r, x_waste, y_waste);
425         lgl_template_add_frame (template, frame);
426
427         for (node = label_node->xmlChildrenNode; node != NULL; node = node->next)
428         {
429                 if (lgl_xml_is_node (node, "Layout"))
430                 {
431                         xml_parse_layout_node (node, frame);
432                 }
433                 else if (lgl_xml_is_node (node, "Markup-margin"))
434                 {
435                         xml_parse_markup_margin_node (node, frame);
436                 }
437                 else if (lgl_xml_is_node (node, "Markup-line"))
438                 {
439                         xml_parse_markup_line_node (node, frame);
440                 }
441                 else if (lgl_xml_is_node (node, "Markup-circle"))
442                 {
443                         xml_parse_markup_circle_node (node, frame);
444                 }
445                 else if (lgl_xml_is_node (node, "Markup-rect"))
446                 {
447                         xml_parse_markup_rect_node (node, frame);
448                 }
449                 else if (lgl_xml_is_node (node, "Markup-ellipse"))
450                 {
451                         xml_parse_markup_ellipse_node (node, frame);
452                 }
453                 else if (!xmlNodeIsText (node))
454                 {
455                         if (!lgl_xml_is_node (node, "comment"))
456                         {
457                                 g_message ("bad node =  \"%s\"",node->name);
458                         }
459                 }
460         }
461
462         g_free (id);
463 }
464
465
466 /*--------------------------------------------------------------------------*/
467 /* PRIVATE.  Parse XML Template->Label-ellipse Node.                        */
468 /*--------------------------------------------------------------------------*/
469 static void
470 xml_parse_label_ellipse_node (xmlNodePtr   label_node,
471                               lglTemplate *template)
472 {
473         gchar               *id;
474         gdouble              waste;
475         gdouble              w, h;
476         lglTemplateFrame    *frame;
477         xmlNodePtr           node;
478
479         id      = lgl_xml_get_prop_string (label_node, "id", NULL);
480
481         w       = lgl_xml_get_prop_length (label_node, "width", 0);
482         h       = lgl_xml_get_prop_length (label_node, "height", 0);
483         waste   = lgl_xml_get_prop_length (label_node, "waste", 0);
484
485         frame = lgl_template_frame_ellipse_new ((gchar *)id, w, h, waste);
486         lgl_template_add_frame (template, frame);
487
488         for (node = label_node->xmlChildrenNode; node != NULL; node = node->next)
489         {
490                 if (lgl_xml_is_node (node, "Layout"))
491                 {
492                         xml_parse_layout_node (node, frame);
493                 }
494                 else if (lgl_xml_is_node (node, "Markup-margin"))
495                 {
496                         xml_parse_markup_margin_node (node, frame);
497                 }
498                 else if (lgl_xml_is_node (node, "Markup-line"))
499                 {
500                         xml_parse_markup_line_node (node, frame);
501                 }
502                 else if (lgl_xml_is_node (node, "Markup-circle"))
503                 {
504                         xml_parse_markup_circle_node (node, frame);
505                 }
506                 else if (lgl_xml_is_node (node, "Markup-rect"))
507                 {
508                         xml_parse_markup_rect_node (node, frame);
509                 }
510                 else if (lgl_xml_is_node (node, "Markup-ellipse"))
511                 {
512                         xml_parse_markup_ellipse_node (node, frame);
513                 }
514                 else if (!xmlNodeIsText (node))
515                 {
516                         if (!lgl_xml_is_node (node, "comment"))
517                         {
518                                 g_message ("bad node =  \"%s\"",node->name);
519                         }
520                 }
521         }
522
523         g_free (id);
524 }
525
526
527 /*--------------------------------------------------------------------------*/
528 /* PRIVATE.  Parse XML Template->Label-round Node.                          */
529 /*--------------------------------------------------------------------------*/
530 static void
531 xml_parse_label_round_node (xmlNodePtr   label_node,
532                             lglTemplate *template)
533 {
534         gchar               *id;
535         gdouble              waste;
536         gdouble              r;
537         lglTemplateFrame    *frame;
538         xmlNodePtr           node;
539
540         id    = lgl_xml_get_prop_string (label_node, "id", NULL);
541         waste = lgl_xml_get_prop_length (label_node, "waste", 0);
542         r     = lgl_xml_get_prop_length (label_node, "radius", 0);
543
544         frame = lgl_template_frame_round_new ((gchar *)id, r, waste);
545         lgl_template_add_frame (template, frame);
546
547         for (node = label_node->xmlChildrenNode; node != NULL; node = node->next)
548         {
549                 if (lgl_xml_is_node (node, "Layout"))
550                 {
551                         xml_parse_layout_node (node, frame);
552                 }
553                 else if (lgl_xml_is_node (node, "Markup-margin"))
554                 {
555                         xml_parse_markup_margin_node (node, frame);
556                 }
557                 else if (lgl_xml_is_node (node, "Markup-line"))
558                 {
559                         xml_parse_markup_line_node (node, frame);
560                 }
561                 else if (lgl_xml_is_node (node, "Markup-circle"))
562                 {
563                         xml_parse_markup_circle_node (node, frame);
564                 }
565                 else if (lgl_xml_is_node (node, "Markup-rect"))
566                 {
567                         xml_parse_markup_rect_node (node, frame);
568                 }
569                 else if (lgl_xml_is_node (node, "Markup-ellipse"))
570                 {
571                         xml_parse_markup_ellipse_node (node, frame);
572                 }
573                 else if (!xmlNodeIsText (node))
574                 {
575                         if (!lgl_xml_is_node (node, "comment"))
576                         {
577                                 g_message ("bad node =  \"%s\"",node->name);
578                         }
579                 }
580         }
581
582         g_free (id);
583 }
584
585 /*--------------------------------------------------------------------------*/
586 /* PRIVATE.  Parse XML Template->Label-cd Node.                             */
587 /*--------------------------------------------------------------------------*/
588 static void
589 xml_parse_label_cd_node (xmlNodePtr   label_node,
590                          lglTemplate *template)
591 {
592         gchar               *id;
593         gdouble              waste;
594         gdouble              r1, r2, w, h;
595         lglTemplateFrame    *frame;
596         xmlNodePtr           node;
597
598         id    = lgl_xml_get_prop_string (label_node, "id", NULL);
599         waste = lgl_xml_get_prop_length (label_node, "waste", 0);
600         r1    = lgl_xml_get_prop_length (label_node, "radius", 0);
601         r2    = lgl_xml_get_prop_length (label_node, "hole", 0);
602         w     = lgl_xml_get_prop_length (label_node, "width", 0);
603         h     = lgl_xml_get_prop_length (label_node, "height", 0);
604
605         frame = lgl_template_frame_cd_new ((gchar *)id, r1, r2, w, h, waste);
606         lgl_template_add_frame (template, frame);
607
608         for (node = label_node->xmlChildrenNode; node != NULL; node = node->next)
609         {
610                 if (lgl_xml_is_node (node, "Layout"))
611                 {
612                         xml_parse_layout_node (node, frame);
613                 }
614                 else if (lgl_xml_is_node (node, "Markup-margin"))
615                 {
616                         xml_parse_markup_margin_node (node, frame);
617                 }
618                 else if (lgl_xml_is_node (node, "Markup-line"))
619                 {
620                         xml_parse_markup_line_node (node, frame);
621                 }
622                 else if (lgl_xml_is_node (node, "Markup-circle"))
623                 {
624                         xml_parse_markup_circle_node (node, frame);
625                 }
626                 else if (lgl_xml_is_node (node, "Markup-rect"))
627                 {
628                         xml_parse_markup_rect_node (node, frame);
629                 }
630                 else if (lgl_xml_is_node (node, "Markup-ellipse"))
631                 {
632                         xml_parse_markup_ellipse_node (node, frame);
633                 }
634                 else if (!xmlNodeIsText (node))
635                 {
636                         if (!lgl_xml_is_node (node, "comment"))
637                         {
638                                 g_message ("bad node =  \"%s\"",node->name);
639                         }
640                 }
641         }
642
643         g_free (id);
644 }
645
646 /*--------------------------------------------------------------------------*/
647 /* PRIVATE.  Parse XML Template->Label->Layout Node.                        */
648 /*--------------------------------------------------------------------------*/
649 static void
650 xml_parse_layout_node (xmlNodePtr          layout_node,
651                        lglTemplateFrame   *frame)
652 {
653         gint        nx, ny;
654         gdouble     x0, y0, dx, dy;
655         xmlNodePtr  node;
656
657         nx = lgl_xml_get_prop_int (layout_node, "nx", 1);
658         ny = lgl_xml_get_prop_int (layout_node, "ny", 1);
659
660         x0 = lgl_xml_get_prop_length (layout_node, "x0", 0);
661         y0 = lgl_xml_get_prop_length (layout_node, "y0", 0);
662
663         dx = lgl_xml_get_prop_length (layout_node, "dx", 0);
664         dy = lgl_xml_get_prop_length (layout_node, "dy", 0);
665
666         lgl_template_frame_add_layout (frame, lgl_template_layout_new (nx, ny, x0, y0, dx, dy));
667
668         for (node = layout_node->xmlChildrenNode; node != NULL; node = node->next)
669         {
670                 if (!xmlNodeIsText (node))
671                 {
672                         if (!lgl_xml_is_node (node, "comment"))
673                         {
674                                 g_message ("bad node =  \"%s\"",node->name);
675                         }
676                 }
677         }
678
679 }
680
681 /*--------------------------------------------------------------------------*/
682 /* PRIVATE.  Parse XML Template->Label->Markup-margin Node.                 */
683 /*--------------------------------------------------------------------------*/
684 static void
685 xml_parse_markup_margin_node (xmlNodePtr          markup_node,
686                               lglTemplateFrame   *frame)
687 {
688         gdouble     size;
689         xmlNodePtr  node;
690
691         size = lgl_xml_get_prop_length (markup_node, "size", 0);
692
693         lgl_template_frame_add_markup (frame, lgl_template_markup_margin_new (size));
694
695         for (node = markup_node->xmlChildrenNode; node != NULL; node = node->next)
696         {
697                 if (!xmlNodeIsText (node))
698                 {
699                         if (!lgl_xml_is_node (node, "comment"))
700                         {
701                                 g_message ("bad node =  \"%s\"",node->name);
702                         }
703                 }
704         }
705
706 }
707
708 /*--------------------------------------------------------------------------*/
709 /* PRIVATE.  Parse XML Template->Label->Markup-line Node.                   */
710 /*--------------------------------------------------------------------------*/
711 static void
712 xml_parse_markup_line_node (xmlNodePtr          markup_node,
713                             lglTemplateFrame   *frame)
714 {
715         gdouble     x1, y1, x2, y2;
716         xmlNodePtr  node;
717
718         x1 = lgl_xml_get_prop_length (markup_node, "x1", 0);
719         y1 = lgl_xml_get_prop_length (markup_node, "y1", 0);
720         x2 = lgl_xml_get_prop_length (markup_node, "x2", 0);
721         y2 = lgl_xml_get_prop_length (markup_node, "y2", 0);
722
723         lgl_template_frame_add_markup (frame, lgl_template_markup_line_new (x1, y1, x2, y2));
724
725         for (node = markup_node->xmlChildrenNode; node != NULL; node = node->next)
726         {
727                 if (!xmlNodeIsText (node))
728                 {
729                         if (!lgl_xml_is_node (node, "comment"))
730                         {
731                                 g_message ("bad node =  \"%s\"",node->name);
732                         }
733                 }
734         }
735
736 }
737
738 /*--------------------------------------------------------------------------*/
739 /* PRIVATE.  Parse XML Template->Label->Markup-circle Node.                 */
740 /*--------------------------------------------------------------------------*/
741 static void
742 xml_parse_markup_circle_node (xmlNodePtr          markup_node,
743                               lglTemplateFrame   *frame)
744 {
745         gdouble     x0, y0, r;
746         xmlNodePtr  node;
747
748         x0 = lgl_xml_get_prop_length (markup_node, "x0", 0);
749         y0 = lgl_xml_get_prop_length (markup_node, "y0", 0);
750         r  = lgl_xml_get_prop_length (markup_node, "radius", 0);
751
752         lgl_template_frame_add_markup (frame, lgl_template_markup_circle_new (x0, y0, r));
753
754         for (node = markup_node->xmlChildrenNode; node != NULL; node = node->next)
755         {
756                 if (!xmlNodeIsText (node))
757                 {
758                         if (!lgl_xml_is_node (node, "comment"))
759                         {
760                                 g_message ("bad node =  \"%s\"",node->name);
761                         }
762                 }
763         }
764
765 }
766
767
768 /*--------------------------------------------------------------------------*/
769 /* PRIVATE.  Parse XML Template->Label->Markup-rect Node.                   */
770 /*--------------------------------------------------------------------------*/
771 static void
772 xml_parse_markup_rect_node (xmlNodePtr          markup_node,
773                             lglTemplateFrame   *frame)
774 {
775         gdouble     x1, y1, w, h, r;
776         xmlNodePtr  node;
777
778         x1 = lgl_xml_get_prop_length (markup_node, "x1", 0);
779         y1 = lgl_xml_get_prop_length (markup_node, "y1", 0);
780         w  = lgl_xml_get_prop_length (markup_node, "w", 0);
781         h  = lgl_xml_get_prop_length (markup_node, "h", 0);
782         r  = lgl_xml_get_prop_length (markup_node, "r", 0);
783
784         lgl_template_frame_add_markup (frame, lgl_template_markup_rect_new (x1, y1, w, h, r));
785
786         for (node = markup_node->xmlChildrenNode; node != NULL; node = node->next)
787         {
788                 if (!xmlNodeIsText (node))
789                 {
790                         if (!lgl_xml_is_node (node, "comment"))
791                         {
792                                 g_message ("bad node =  \"%s\"",node->name);
793                         }
794                 }
795         }
796
797 }
798
799
800 /*--------------------------------------------------------------------------*/
801 /* PRIVATE.  Parse XML Template->Label->Markup-ellipse Node.                */
802 /*--------------------------------------------------------------------------*/
803 static void
804 xml_parse_markup_ellipse_node (xmlNodePtr          markup_node,
805                                lglTemplateFrame   *frame)
806 {
807         gdouble     x1, y1, w, h;
808         xmlNodePtr  node;
809
810         x1 = lgl_xml_get_prop_length (markup_node, "x1", 0);
811         y1 = lgl_xml_get_prop_length (markup_node, "y1", 0);
812         w  = lgl_xml_get_prop_length (markup_node, "w", 0);
813         h  = lgl_xml_get_prop_length (markup_node, "h", 0);
814
815         lgl_template_frame_add_markup (frame, lgl_template_markup_ellipse_new (x1, y1, w, h));
816
817         for (node = markup_node->xmlChildrenNode; node != NULL; node = node->next)
818         {
819                 if (!xmlNodeIsText (node))
820                 {
821                         if (!lgl_xml_is_node (node, "comment"))
822                         {
823                                 g_message ("bad node =  \"%s\"",node->name);
824                         }
825                 }
826         }
827
828 }
829
830
831 /*--------------------------------------------------------------------------*/
832 /* PRIVATE.  Parse deprecated XML Template->Alias Node.                     */
833 /*--------------------------------------------------------------------------*/
834 static void
835 xml_parse_alias_node (xmlNodePtr   alias_node,
836                       lglTemplate *template)
837 {
838         g_message ("Skipping deprecated \"Alias\" node.");
839 }
840
841
842 /**
843  * lgl_xml_template_write_templates_to_file:
844  * @templates:      List of #lglTemplate structures
845  * @utf8_filename:  Filename of templates file (name encoded as UTF-8)
846  *
847  * Write a list of #lglTemplate structures to a glabels XML template file.
848  *
849  * Returns: the number of bytes written or -1 in case of failure
850  *
851  */
852 gint
853 lgl_xml_template_write_templates_to_file (GList       *templates,
854                                           const gchar *utf8_filename)
855 {
856         xmlDocPtr    doc;
857         xmlNsPtr     ns;
858         gint         bytes_written;
859         GList       *p;
860         lglTemplate *template;
861         gchar       *filename;
862
863         doc = xmlNewDoc ((xmlChar *)"1.0");
864         doc->xmlRootNode = xmlNewDocNode (doc, NULL, (xmlChar *)"Glabels-templates", NULL);
865
866         ns = xmlNewNs (doc->xmlRootNode, (xmlChar *)LGL_XML_NAME_SPACE, NULL);
867         xmlSetNs (doc->xmlRootNode, ns);
868
869         for (p=templates; p!=NULL; p=p->next)
870         {
871                 template = (lglTemplate *)p->data;
872                 lgl_xml_template_create_template_node (template, doc->xmlRootNode, ns);
873         }
874
875         filename = g_filename_from_utf8 (utf8_filename, -1, NULL, NULL, NULL);
876         if (!filename)
877         {
878                 g_message ("Utf8 conversion error.");
879                 return -1;
880         }
881         else
882         {
883                 xmlSetDocCompressMode (doc, 0);
884                 bytes_written = xmlSaveFormatFile (filename, doc, TRUE);
885                 xmlFreeDoc (doc);
886                 g_free (filename);
887                 return bytes_written;
888         }
889
890 }
891
892
893 /**
894  * lgl_xml_template_write_template_to_file:
895  * @template:       #lglTemplate structure to be written
896  * @utf8_filename:  Filename of templates file (name encoded as UTF-8)
897  *
898  * Write a single #lglTemplate structures to a glabels XML template file.
899  *
900  * Returns: the number of bytes written or -1 in case of failure
901  *
902  */
903 gint
904 lgl_xml_template_write_template_to_file (const lglTemplate  *template,
905                                          const gchar        *utf8_filename)
906 {
907         GList     *templates = NULL;
908         gint       bytes_written;
909
910         templates = g_list_append (templates, (gpointer)template);
911
912         bytes_written = lgl_xml_template_write_templates_to_file (templates, utf8_filename);
913
914         g_list_free (templates);
915
916         return bytes_written;
917 }
918
919
920 /**
921  * lgl_xml_template_create_template_node:
922  * @template:       #lglTemplate structure to be written
923  * @root:           parent node to receive new child node
924  * @ns:             a libxml #xmlNsPtr
925  *
926  * Add a single #lglTemplate child node to given #xmlNodePtr.
927  *
928  */
929 void
930 lgl_xml_template_create_template_node (const lglTemplate *template,
931                                        xmlNodePtr         root,
932                                        const xmlNsPtr     ns)
933 {
934         xmlNodePtr          node;
935         GList              *p;
936         lglTemplateFrame   *frame;
937
938         node = xmlNewChild (root, ns, (xmlChar *)"Template", NULL);
939
940         lgl_xml_set_prop_string (node, "brand", template->brand);
941         lgl_xml_set_prop_string (node, "part", template->part);
942
943         lgl_xml_set_prop_string (node, "size", template->paper_id);
944         if (xmlStrEqual ((xmlChar *)template->paper_id, (xmlChar *)"Other"))
945         {
946
947                 lgl_xml_set_prop_length (node, "width", template->page_width);
948                 lgl_xml_set_prop_length (node, "height", template->page_height);
949
950         }
951
952         lgl_xml_set_prop_string (node, "description", template->description);
953
954         xml_create_meta_node ("product_url", template->product_url, node, ns );
955         for ( p=template->category_ids; p != NULL; p=p->next )
956         {
957                 xml_create_meta_node ( "category", p->data, node, ns );
958         }
959         for ( p=template->frames; p != NULL; p=p->next )
960         {
961                 frame = (lglTemplateFrame *)p->data;
962                 xml_create_label_node (frame, node, ns);
963         }
964
965 }
966
967 /*--------------------------------------------------------------------------*/
968 /* PRIVATE.  Add XML Template->Meta Node with category.                     */
969 /*--------------------------------------------------------------------------*/
970 static void
971 xml_create_meta_node (const gchar      *attr,
972                       const gchar      *value,
973                       xmlNodePtr        root,
974                       const xmlNsPtr    ns)
975 {
976         xmlNodePtr node;
977
978         if ( value != NULL )
979         {
980                 node = xmlNewChild (root, ns, (xmlChar *)"Meta", NULL);
981                 lgl_xml_set_prop_string (node, attr, value);
982         }
983
984 }
985
986 /*--------------------------------------------------------------------------*/
987 /* PRIVATE.  Add XML Template->Label Node.                                  */
988 /*--------------------------------------------------------------------------*/
989 static void
990 xml_create_label_node (const lglTemplateFrame  *frame,
991                        xmlNodePtr               root,
992                        const xmlNsPtr           ns)
993 {
994         xmlNodePtr        node;
995         GList            *p;
996         lglTemplateMarkup *markup;
997         lglTemplateLayout *layout;
998
999         switch (frame->shape)
1000         {
1001
1002         case LGL_TEMPLATE_FRAME_SHAPE_RECT:
1003                 node = xmlNewChild(root, ns, (xmlChar *)"Label-rectangle", NULL);
1004                 lgl_xml_set_prop_string (node, "id",      frame->all.id);
1005                 lgl_xml_set_prop_length (node, "width",   frame->rect.w);
1006                 lgl_xml_set_prop_length (node, "height",  frame->rect.h);
1007                 lgl_xml_set_prop_length (node, "round",   frame->rect.r);
1008                 lgl_xml_set_prop_length (node, "x_waste", frame->rect.x_waste);
1009                 lgl_xml_set_prop_length (node, "y_waste", frame->rect.y_waste);
1010                 break;
1011
1012         case LGL_TEMPLATE_FRAME_SHAPE_ELLIPSE:
1013                 node = xmlNewChild(root, ns, (xmlChar *)"Label-ellipse", NULL);
1014                 lgl_xml_set_prop_string (node, "id",     frame->all.id);
1015                 lgl_xml_set_prop_length (node, "width",  frame->ellipse.w);
1016                 lgl_xml_set_prop_length (node, "height", frame->ellipse.h);
1017                 lgl_xml_set_prop_length (node, "waste",  frame->ellipse.waste);
1018                 break;
1019
1020         case LGL_TEMPLATE_FRAME_SHAPE_ROUND:
1021                 node = xmlNewChild(root, ns, (xmlChar *)"Label-round", NULL);
1022                 lgl_xml_set_prop_string (node, "id",      frame->all.id);
1023                 lgl_xml_set_prop_length (node, "radius",  frame->round.r);
1024                 lgl_xml_set_prop_length (node, "waste",   frame->round.waste);
1025                 break;
1026
1027         case LGL_TEMPLATE_FRAME_SHAPE_CD:
1028                 node = xmlNewChild(root, ns, (xmlChar *)"Label-cd", NULL);
1029                 lgl_xml_set_prop_string (node, "id",     frame->all.id);
1030                 lgl_xml_set_prop_length (node, "radius", frame->cd.r1);
1031                 lgl_xml_set_prop_length (node, "hole",   frame->cd.r2);
1032                 if (frame->cd.w != 0.0)
1033                 {
1034                         lgl_xml_set_prop_length (node, "width",  frame->cd.w);
1035                 }
1036                 if (frame->cd.h != 0.0)
1037                 {
1038                         lgl_xml_set_prop_length (node, "height", frame->cd.h);
1039                 }
1040                 lgl_xml_set_prop_length (node, "waste",  frame->cd.waste);
1041                 break;
1042
1043         default:
1044                 g_message ("Unknown label style");
1045                 return;
1046                 break;
1047
1048         }
1049
1050         for ( p=frame->all.markups; p != NULL; p=p->next )
1051         {
1052                 markup = (lglTemplateMarkup *)p->data;
1053                 switch (markup->type)
1054                 {
1055                 case LGL_TEMPLATE_MARKUP_MARGIN:
1056                         xml_create_markup_margin_node (markup, node, ns);
1057                         break;
1058                 case LGL_TEMPLATE_MARKUP_LINE:
1059                         xml_create_markup_line_node (markup, node, ns);
1060                         break;
1061                 case LGL_TEMPLATE_MARKUP_CIRCLE:
1062                         xml_create_markup_circle_node (markup, node, ns);
1063                         break;
1064                 case LGL_TEMPLATE_MARKUP_RECT:
1065                         xml_create_markup_rect_node (markup, node, ns);
1066                         break;
1067                 case LGL_TEMPLATE_MARKUP_ELLIPSE:
1068                         xml_create_markup_ellipse_node (markup, node, ns);
1069                         break;
1070                 default:
1071                         g_message ("Unknown markup type");
1072                         break;
1073                 }
1074         }
1075
1076         for ( p=frame->all.layouts; p != NULL; p=p->next )
1077         {
1078                 layout = (lglTemplateLayout *)p->data;
1079                 xml_create_layout_node (layout, node, ns);
1080         }
1081
1082 }
1083
1084 /*--------------------------------------------------------------------------*/
1085 /* PRIVATE.  Add XML Template->Label->Layout Node.                          */
1086 /*--------------------------------------------------------------------------*/
1087 static void
1088 xml_create_layout_node (const lglTemplateLayout *layout,
1089                         xmlNodePtr               root,
1090                         const xmlNsPtr           ns)
1091 {
1092         xmlNodePtr  node;
1093
1094         node = xmlNewChild(root, ns, (xmlChar *)"Layout", NULL);
1095         lgl_xml_set_prop_int (node, "nx", layout->nx);
1096         lgl_xml_set_prop_int (node, "ny", layout->ny);
1097         lgl_xml_set_prop_length (node, "x0", layout->x0);
1098         lgl_xml_set_prop_length (node, "y0", layout->y0);
1099         lgl_xml_set_prop_length (node, "dx", layout->dx);
1100         lgl_xml_set_prop_length (node, "dy", layout->dy);
1101
1102 }
1103
1104 /*--------------------------------------------------------------------------*/
1105 /* PRIVATE.  Add XML Template->Label->Markup-margin Node.                   */
1106 /*--------------------------------------------------------------------------*/
1107 static void
1108 xml_create_markup_margin_node (const lglTemplateMarkup  *markup,
1109                                xmlNodePtr                root,
1110                                const xmlNsPtr            ns)
1111 {
1112         xmlNodePtr  node;
1113
1114         node = xmlNewChild(root, ns, (xmlChar *)"Markup-margin", NULL);
1115
1116         lgl_xml_set_prop_length (node, "size", markup->margin.size);
1117
1118 }
1119
1120 /*--------------------------------------------------------------------------*/
1121 /* PRIVATE.  Add XML Template->Label->Markup-line Node.                     */
1122 /*--------------------------------------------------------------------------*/
1123 static void
1124 xml_create_markup_line_node (const lglTemplateMarkup *markup,
1125                              xmlNodePtr               root,
1126                              const xmlNsPtr           ns)
1127 {
1128         xmlNodePtr  node;
1129
1130         node = xmlNewChild(root, ns, (xmlChar *)"Markup-line", NULL);
1131
1132         lgl_xml_set_prop_length (node, "x1", markup->line.x1);
1133         lgl_xml_set_prop_length (node, "y1", markup->line.y1);
1134         lgl_xml_set_prop_length (node, "x2", markup->line.x2);
1135         lgl_xml_set_prop_length (node, "y2", markup->line.y2);
1136
1137 }
1138
1139 /*--------------------------------------------------------------------------*/
1140 /* PRIVATE.  Add XML Template->Label->Markup-circle Node.                   */
1141 /*--------------------------------------------------------------------------*/
1142 static void
1143 xml_create_markup_circle_node (const lglTemplateMarkup *markup,
1144                                xmlNodePtr               root,
1145                                const xmlNsPtr           ns)
1146 {
1147         xmlNodePtr  node;
1148
1149         node = xmlNewChild(root, ns, (xmlChar *)"Markup-circle", NULL);
1150
1151         lgl_xml_set_prop_length (node, "x0",     markup->circle.x0);
1152         lgl_xml_set_prop_length (node, "y0",     markup->circle.y0);
1153         lgl_xml_set_prop_length (node, "radius", markup->circle.r);
1154
1155 }
1156
1157
1158 /*--------------------------------------------------------------------------*/
1159 /* PRIVATE.  Add XML Template->Label->Markup-rect Node.                     */
1160 /*--------------------------------------------------------------------------*/
1161 static void
1162 xml_create_markup_rect_node (const lglTemplateMarkup *markup,
1163                              xmlNodePtr               root,
1164                              const xmlNsPtr           ns)
1165 {
1166         xmlNodePtr  node;
1167
1168         node = xmlNewChild(root, ns, (xmlChar *)"Markup-rect", NULL);
1169
1170         lgl_xml_set_prop_length (node, "x1", markup->rect.x1);
1171         lgl_xml_set_prop_length (node, "y1", markup->rect.y1);
1172         lgl_xml_set_prop_length (node, "w",  markup->rect.w);
1173         lgl_xml_set_prop_length (node, "h",  markup->rect.h);
1174         lgl_xml_set_prop_length (node, "r",  markup->rect.r);
1175
1176 }
1177
1178
1179 /*--------------------------------------------------------------------------*/
1180 /* PRIVATE.  Add XML Template->Label->Markup-ellipse Node.                  */
1181 /*--------------------------------------------------------------------------*/
1182 static void
1183 xml_create_markup_ellipse_node (const lglTemplateMarkup *markup,
1184                                 xmlNodePtr               root,
1185                                 const xmlNsPtr           ns)
1186 {
1187         xmlNodePtr  node;
1188
1189         node = xmlNewChild(root, ns, (xmlChar *)"Markup-ellipse", NULL);
1190
1191         lgl_xml_set_prop_length (node, "x1", markup->ellipse.x1);
1192         lgl_xml_set_prop_length (node, "y1", markup->ellipse.y1);
1193         lgl_xml_set_prop_length (node, "w",  markup->ellipse.w);
1194         lgl_xml_set_prop_length (node, "h",  markup->ellipse.h);
1195
1196 }
1197
1198
1199
1200 /*
1201  * Local Variables:       -- emacs
1202  * mode: C                -- emacs
1203  * c-basic-offset: 8      -- emacs
1204  * tab-width: 8           -- emacs
1205  * indent-tabs-mode: nil  -- emacs
1206  * End:                   -- emacs
1207  */