git.sur5r.net Git - glabels/blob - glabels2/libglabels/paper.c

   1 /*
   2  *  (LIBGLABELS) Template library for GLABELS
   3  *
   4  *  paper.c:  paper module
   5  *
   6  *  Copyright (C) 2003, 2004  Jim Evins <evins@snaught.com>.
   7  *
   8  *  This file is part of the LIBGLABELS library.
   9  *
  10  *  This library is free software; you can redistribute it and/or
  11  *  modify it under the terms of the GNU Library General Public
  12  *  License as published by the Free Software Foundation; either
  13  *  version 2 of the License, or (at your option) any later version.
  14  *
  15  *  This library is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  *  Library General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU Library General Public
  21  *  License along with this library; if not, write to the Free
  22  *  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  23  *  MA 02111-1307, USA
  24  */
  25
  26 #include "libglabels-private.h"
  27
  28 #include <string.h>
  29
  30 #include "paper.h"
  31 #include "xml-paper.h"
  32
  33 /*===========================================*/
  34 /* Private types                             */
  35 /*===========================================*/
  36
  37 /*===========================================*/
  38 /* Private globals                           */
  39 /*===========================================*/
  40
  41 static GList *papers = NULL;
  42
  43 /*===========================================*/
  44 /* Local function prototypes                 */
  45 /*===========================================*/
  46
  47 static GList *read_papers (void);
  48 static GList *read_paper_files_from_dir (GList       *papers,
  49                                          const gchar *dirname);
  50
  51 \f
  52 /*****************************************************************************/
  53 /* Initialize module.                                                        */
  54 /*****************************************************************************/
  55 void
  56 gl_paper_init (void)
  57 {
  58         glPaper *other;
  59
  60         if (papers) {
  61                 return; /* Already initialized. */
  62         }
  63
  64         papers = read_papers ();
  65
  66         /* Create and append an "Other" entry. */
  67         other = gl_paper_new ("Other", _("Other"), 0.0, 0.0);
  68         papers = g_list_append (papers, other);
  69 }
  70
  71 /*****************************************************************************/
  72 /* Create a new paper structure.                                             */
  73 /*****************************************************************************/
  74 glPaper *
  75 gl_paper_new (gchar             *id,
  76               gchar             *name,
  77               gdouble            width,
  78               gdouble            height)
  79 {
  80         glPaper *paper;
  81
  82         paper         = g_new0 (glPaper,1);
  83         paper->id     = g_strdup (id);
  84         paper->name   = g_strdup (name);
  85         paper->width  = width;
  86         paper->height = height;
  87
  88         return paper;
  89 }
  90
  91 /*****************************************************************************/
  92 /* Copy a paper.                                                          */
  93 /*****************************************************************************/
  94 glPaper *gl_paper_dup (const glPaper *orig_paper)
  95 {
  96         glPaper       *paper;
  97
  98         g_return_val_if_fail (orig_paper, NULL);
  99
 100         paper = g_new0 (glPaper,1);
 101
 102         paper->id     = g_strdup (orig_paper->id);
 103         paper->name   = g_strdup (orig_paper->name);
 104         paper->width  = orig_paper->width;
 105         paper->height = orig_paper->height;
 106
 107         return paper;
 108 }
 109
 110 /*****************************************************************************/
 111 /* Free up a paper.                                                       */
 112 /*****************************************************************************/
 113 void gl_paper_free (glPaper *paper)
 114 {
 115
 116         if ( paper != NULL ) {
 117
 118                 g_free (paper->id);
 119                 paper->name = NULL;
 120
 121                 g_free (paper->name);
 122                 paper->name = NULL;
 123
 124                 g_free (paper);
 125         }
 126
 127 }
 128
 129 /*****************************************************************************/
 130 /* Get a list of known page size ids                                         */
 131 /*****************************************************************************/
 132 GList *
 133 gl_paper_get_id_list (void)
 134 {
 135         GList           *ids = NULL;
 136         GList           *p;
 137         glPaper         *paper;
 138
 139         if (!papers) {
 140                 gl_paper_init ();
 141         }
 142
 143         for ( p=papers; p != NULL; p=p->next ) {
 144                 paper = (glPaper *)p->data;
 145                 ids = g_list_append (ids, g_strdup (paper->id));
 146         }
 147
 148         return ids;
 149 }
 150
 151 /*****************************************************************************/
 152 /* Free a list of page size ids.                                             */
 153 /*****************************************************************************/
 154 void
 155 gl_paper_free_id_list (GList *ids)
 156 {
 157         GList *p;
 158
 159         for (p = ids; p != NULL; p = p->next) {
 160                 g_free (p->data);
 161                 p->data = NULL;
 162         }
 163
 164         g_list_free (ids);
 165 }
 166
 167 /*****************************************************************************/
 168 /* Get a list of known page size names                                       */
 169 /*****************************************************************************/
 170 GList *
 171 gl_paper_get_name_list (void)
 172 {
 173         GList           *names = NULL;
 174         GList           *p;
 175         glPaper         *paper;
 176
 177         if (!papers) {
 178                 gl_paper_init ();
 179         }
 180
 181         for ( p=papers; p != NULL; p=p->next ) {
 182                 paper = (glPaper *)p->data;
 183                 names = g_list_append (names, g_strdup (paper->name));
 184         }
 185
 186         return names;
 187 }
 188
 189 /*****************************************************************************/
 190 /* Free a list of page size names.                                           */
 191 /*****************************************************************************/
 192 void
 193 gl_paper_free_name_list (GList *names)
 194 {
 195         GList *p;
 196
 197         for (p = names; p != NULL; p = p->next) {
 198                 g_free (p->data);
 199                 p->data = NULL;
 200         }
 201
 202         g_list_free (names);
 203 }
 204
 205 /*****************************************************************************/
 206 /* Is page size id known?                                                    */
 207 /*****************************************************************************/
 208 gboolean
 209 gl_paper_is_id_known (const gchar *id)
 210 {
 211         GList       *p;
 212         glPaper     *paper;
 213
 214         if (!papers) {
 215                 gl_paper_init ();
 216         }
 217
 218         if (id == NULL) {
 219                 return FALSE;
 220         }
 221
 222         for (p = papers; p != NULL; p = p->next) {
 223                 paper = (glPaper *) p->data;
 224                 if (g_strcasecmp (paper->id, id) == 0) {
 225                         return TRUE;
 226                 }
 227         }
 228
 229         return FALSE;
 230 }
 231
 232 /*****************************************************************************/
 233 /* Is page size id "Other?"                                                  */
 234 /*****************************************************************************/
 235 gboolean
 236 gl_paper_is_id_other (const gchar *id)
 237 {
 238         if (id == NULL) {
 239                 return FALSE;
 240         }
 241
 242         return (g_strcasecmp (id, "Other") == 0);
 243 }
 244
 245 /*****************************************************************************/
 246 /* Return a paper structure from id.                                         */
 247 /*****************************************************************************/
 248 glPaper *
 249 gl_paper_from_id (const gchar *id)
 250 {
 251         GList       *p;
 252         glPaper     *paper;
 253
 254         if (!papers) {
 255                 gl_paper_init ();
 256         }
 257
 258         if (id == NULL) {
 259                 /* If no id, return first paper as a default */
 260                 return gl_paper_dup ((glPaper *) papers->data);
 261         }
 262
 263         for (p = papers; p != NULL; p = p->next) {
 264                 paper = (glPaper *) p->data;
 265                 if (g_strcasecmp (paper->id, id) == 0) {
 266                         return gl_paper_dup (paper);
 267                 }
 268         }
 269
 270         return NULL;
 271 }
 272
 273 /*****************************************************************************/
 274 /* Return a paper structure from name.                                       */
 275 /*****************************************************************************/
 276 glPaper *
 277 gl_paper_from_name (const gchar *name)
 278 {
 279         GList       *p;
 280         glPaper     *paper;
 281
 282         if (!papers) {
 283                 gl_paper_init ();
 284         }
 285
 286         if (name == NULL) {
 287                 /* If no name, return first paper as a default */
 288                 return gl_paper_dup ((glPaper *) papers->data);
 289         }
 290
 291         for (p = papers; p != NULL; p = p->next) {
 292                 paper = (glPaper *) p->data;
 293                 if (g_strcasecmp (paper->name, name) == 0) {
 294                         return gl_paper_dup (paper);
 295                 }
 296         }
 297
 298         return NULL;
 299 }
 300
 301 /*****************************************************************************/
 302 /* Lookup paper id from name.                                                */
 303 /*****************************************************************************/
 304 gchar *
 305 gl_paper_lookup_id_from_name (const gchar       *name)
 306 {
 307         glPaper *paper = NULL;
 308         gchar   *id = NULL;
 309
 310         g_return_val_if_fail (name, NULL);
 311
 312         paper = gl_paper_from_name (name);
 313         if ( paper != NULL ) {
 314                 id = g_strdup (paper->id);
 315                 gl_paper_free (paper);
 316                 paper = NULL;
 317         }
 318
 319         return id;
 320 }
 321
 322 /*****************************************************************************/
 323 /* Lookup paper name from id.                                                */
 324 /*****************************************************************************/
 325 gchar *
 326 gl_paper_lookup_name_from_id (const gchar       *id)
 327 {
 328         glPaper *paper = NULL;
 329         gchar   *name = NULL;
 330
 331         g_return_val_if_fail (id, NULL);
 332
 333         paper = gl_paper_from_id (id);
 334         if ( paper != NULL ) {
 335                 name = g_strdup (paper->name);
 336                 gl_paper_free (paper);
 337                 paper = NULL;
 338         }
 339
 340         return name;
 341 }
 342
 343 /*--------------------------------------------------------------------------*/
 344 /* PRIVATE.  Read papers from various  files.                            */
 345 /*--------------------------------------------------------------------------*/
 346 static GList *
 347 read_papers (void)
 348 {
 349         gchar *data_dir;
 350         GList *papers = NULL;
 351
 352         data_dir = GL_SYSTEM_DATA_DIR;
 353         papers = read_paper_files_from_dir (papers, data_dir);
 354         g_free (data_dir);
 355
 356         data_dir = GL_USER_DATA_DIR;
 357         papers = read_paper_files_from_dir (papers, data_dir);
 358         g_free (data_dir);
 359
 360         if (papers == NULL) {
 361                 g_warning (_("No paper files found!"));
 362         }
 363
 364         return papers;
 365 }
 366
 367 /*--------------------------------------------------------------------------*/
 368 /* PRIVATE.  Read all paper files from given directory.  Append to list. */
 369 /*--------------------------------------------------------------------------*/
 370 static GList *
 371 read_paper_files_from_dir (GList       *papers,
 372                            const gchar *dirname)
 373 {
 374         GDir        *dp;
 375         const gchar *filename, *extension;
 376         gchar       *full_filename = NULL;
 377         GError      *gerror = NULL;
 378         GList       *new_papers = NULL;
 379
 380         if (dirname == NULL) {
 381                 return papers;
 382         }
 383
 384         if (!g_file_test (dirname, G_FILE_TEST_EXISTS)) {
 385                 return papers;
 386         }
 387
 388         dp = g_dir_open (dirname, 0, &gerror);
 389         if (gerror != NULL) {
 390                 g_warning ("cannot open data directory: %s", gerror->message );
 391                 return papers;
 392         }
 393
 394         while ((filename = g_dir_read_name (dp)) != NULL) {
 395
 396                 extension = strrchr (filename, '.');
 397
 398                 if (extension != NULL) {
 399
 400                         if ( (g_strcasecmp (extension, ".paper") == 0)
 401                              || (g_strcasecmp (filename, "paper-sizes.xml") == 0) ) {
 402
 403                                 full_filename =
 404                                     g_build_filename (dirname, filename, NULL);
 405                                 new_papers =
 406                                     gl_xml_paper_read_papers_from_file (full_filename);
 407                                 g_free (full_filename);
 408
 409                                 papers = g_list_concat (papers, new_papers);
 410                                 new_papers = NULL;
 411
 412                         }
 413
 414                 }
 415
 416         }
 417
 418         g_dir_close (dp);
 419
 420         return papers;
 421 }
 422
 423 /*****************************************************************************/
 424 /* Print known papers (for debugging purposes)                               */
 425 /*****************************************************************************/
 426 void
 427 gl_paper_print_known_papers (void)
 428 {
 429         GList       *p;
 430         glPaper     *paper;
 431
 432         if (!papers) {
 433                 gl_paper_init ();
 434         }
 435
 436         g_print ("%s():\n", __FUNCTION__);
 437         for (p = papers; p != NULL; p = p->next) {
 438                 paper = (glPaper *) p->data;
 439
 440                 g_print ("PAPER id=\"%s\", name=\"%s\", width=%gpts, height=%gpts\n",
 441                          paper->id, paper->name, paper->width, paper->height);
 442
 443         }
 444         g_print ("\n");
 445
 446 }
 447
 448