lib/ephy-print-utils.c

   1 /*
   2  *  Copyright © 2006 Christian Persch
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2, or (at your option)
   7  *  any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *  $Id: ephy-print-utils.c 6952 2007-03-11 19:42:02Z chpe $
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24
  25 #include <glib.h>
  26 #include <gtk/gtktypebuiltins.h>
  27
  28 #include "ephy-debug.h"
  29 #include "ephy-string.h"
  30
  31 #include "ephy-print-utils.h"
  32
  33 #define PRINT_SETTINGS_GROUP    "Print Settings"
  34 #define PAGE_SETUP_GROUP        "Page Setup"
  35 #define PAPER_SIZE_GROUP        "Paper Size"
  36
  37 #define ERROR_QUARK             (g_quark_from_static_string ("ephy-print-utils-error"))
  38
  39 /**
  40  * ephy_print_utils_settings_new_from_file:
  41  * @file_name: the filename to read the settings from
  42  * @error:
  43  *
  44  * Reads the print settings from @filename. Returns a new #GtkPrintSettings
  45  * object with the restored settings, or %NULL if an error occurred.
  46  *
  47  * Return value: the restored #GtkPrintSettings
  48  *
  49  * Since: 2.10
  50  */
  51 GtkPrintSettings *
  52 ephy_print_utils_settings_new_from_file (const gchar *file_name,
  53                                          GError     **error)
  54 {
  55   GtkPrintSettings *settings;
  56   GKeyFile *key_file;
  57
  58   g_return_val_if_fail (file_name != NULL, NULL);
  59
  60   key_file = g_key_file_new ();
  61   if (!g_key_file_load_from_file (key_file, file_name, 0, error))
  62     {
  63       g_key_file_free (key_file);
  64       return NULL;
  65     }
  66
  67   settings = ephy_print_utils_settings_new_from_key_file (key_file, error);
  68   g_key_file_free (key_file);
  69
  70   return settings;
  71 }
  72
  73 /**
  74  * ephy_print_utils_settings_new_from_key_file:
  75  * @key_file: the #GKeyFile to retrieve the settings from
  76  * @error:
  77  *
  78  * Reads the print settings from @key_file. Returns a new #GtkPrintSettings
  79  * object with the restored settings, or %NULL if an error occurred.
  80  *
  81  * Return value: the restored #GtkPrintSettings
  82  *
  83  * Since: 2.10
  84  */
  85 GtkPrintSettings *
  86 ephy_print_utils_settings_new_from_key_file (GKeyFile *key_file,
  87                                              GError  **error)
  88 {
  89   GtkPrintSettings *settings;
  90   gchar **keys;
  91   gsize n_keys, i;
  92   GError *err = NULL;
  93
  94   g_return_val_if_fail (key_file != NULL, NULL);
  95
  96   keys = g_key_file_get_keys (key_file,
  97                               PRINT_SETTINGS_GROUP,
  98                               &n_keys,
  99                               &err);
 100   if (err != NULL)
 101     {
 102       g_propagate_error (error, err);
 103       return NULL;
 104     }
 105
 106   settings = gtk_print_settings_new ();
 107
 108   for (i = 0 ; i < n_keys; ++i)
 109     {
 110       gchar *value;
 111
 112       value = g_key_file_get_string (key_file,
 113                                      PRINT_SETTINGS_GROUP,
 114                                      keys[i],
 115                                      NULL);
 116       if (!value)
 117         continue;
 118
 119       gtk_print_settings_set (settings, keys[i], value);
 120       g_free (value);
 121     }
 122
 123   g_strfreev (keys);
 124
 125   return settings;
 126 }
 127
 128 /**
 129  * ephy_print_utils_settings_to_file:
 130  * @settings: a #GtkPrintSettings
 131  * @file_name: the file to save to
 132  * @error:
 133  *
 134  * This function saves the print settings from @settings to @file_name.
 135  *
 136  * Return value: %TRUE on success
 137  *
 138  * Since: 2.10
 139  */
 140 gboolean
 141 ephy_print_utils_settings_to_file (GtkPrintSettings     *settings,
 142                                    const char           *file_name,
 143                                    GError              **error)
 144 {
 145   GKeyFile *keyfile;
 146   gboolean retval;
 147   char *data = NULL;
 148   gsize len;
 149   GError *err = NULL;
 150
 151   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
 152   g_return_val_if_fail (file_name != NULL, FALSE);
 153
 154   keyfile = g_key_file_new ();
 155   retval = ephy_print_utils_settings_to_key_file (settings, keyfile, &err);
 156   if (!retval) goto out;
 157
 158   data = g_key_file_to_data (keyfile, &len, &err);
 159   if (!data) goto out;
 160
 161   retval = g_file_set_contents (file_name, data, len, &err);
 162
 163 out:
 164   if (err != NULL)
 165     g_propagate_error (error, err);
 166
 167   g_key_file_free (keyfile);
 168   g_free (data);
 169
 170   return retval;
 171 }
 172
 173 static void
 174 add_value_to_keyfile (const gchar *key,
 175                       const gchar *value,
 176                       GKeyFile *keyfile)
 177 {
 178   g_key_file_set_string (keyfile, PRINT_SETTINGS_GROUP, key, value);
 179 }
 180
 181 /**
 182  * ephy_print_utils_settings_to_key_file:
 183  * @settings: a #GtkPrintSettings
 184  * @key_file: the #GKeyFile to save the print settings to
 185  * @error:
 186  *
 187  * This function adds the print settings from @settings to @key_file.
 188  *
 189  * Return value: %TRUE on success
 190  *
 191  * Since: 2.10
 192  */
 193 gboolean
 194 ephy_print_utils_settings_to_key_file (GtkPrintSettings  *settings,
 195                                        GKeyFile          *key_file,
 196                                        GError           **error)
 197 {
 198   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
 199   g_return_val_if_fail (key_file != NULL, FALSE);
 200
 201   gtk_print_settings_foreach (settings,
 202                               (GtkPrintSettingsFunc) add_value_to_keyfile,
 203                               key_file);
 204
 205   return TRUE;
 206 }
 207
 208 /**
 209  * ephy_print_utils_page_setup_new_from_file:
 210  * @file_name: the filename to read the page_setup from
 211  * @error:
 212  *
 213  * Reads the print page_setup from @filename. Returns a new #GtkPageSetup
 214  * object with the restored page_setup, or %NULL if an error occurred.
 215  *
 216  * Return value: the restored #GtkPageSetup
 217  *
 218  * Since: 2.10
 219  */
 220 GtkPageSetup *
 221 ephy_print_utils_page_setup_new_from_file (const gchar *file_name,
 222                                            GError     **error)
 223 {
 224   GtkPageSetup *page_setup;
 225   GKeyFile *key_file;
 226
 227   g_return_val_if_fail (file_name != NULL, NULL);
 228
 229   key_file = g_key_file_new ();
 230   if (!g_key_file_load_from_file (key_file, file_name, 0, error))
 231     {
 232       g_key_file_free (key_file);
 233       return NULL;
 234     }
 235
 236   page_setup = ephy_print_utils_page_setup_new_from_key_file (key_file, error);
 237   g_key_file_free (key_file);
 238
 239   return page_setup;
 240 }
 241
 242 /**
 243  * ephy_print_utils_page_setup_new_from_key_file:
 244  * @key_file: the #GKeyFile to retrieve the page_setup from
 245  * @error:
 246  *
 247  * Reads the print page_setup from @key_file. Returns a new #GtkPageSetup
 248  * object with the restored page_setup, or %NULL if an error occurred.
 249  *
 250  * Return value: the restored #GtkPageSetup
 251  *
 252  * Since: 2.10
 253  */
 254 GtkPageSetup *
 255 ephy_print_utils_page_setup_new_from_key_file (GKeyFile *key_file,
 256                                                GError  **error)
 257 {
 258   GtkPageSetup *page_setup = NULL;
 259   GtkPaperSize *paper_size = NULL;
 260   gdouble width, height, top, bottom, left, right;
 261   char *name = NULL, *ppd_name = NULL, *display_name = NULL, *orientation = NULL;
 262   gboolean retval = TRUE;
 263   GError *err = NULL;
 264
 265   g_return_val_if_fail (key_file != NULL, NULL);
 266
 267   if (!g_key_file_has_group (key_file, PAGE_SETUP_GROUP) ||
 268       !g_key_file_has_group (key_file, PAPER_SIZE_GROUP)) {
 269     g_set_error (error, ERROR_QUARK, 0, "Not a valid epiphany page setup file");
 270     retval = FALSE;
 271     goto out;
 272   }
 273
 274 #define GET_DOUBLE(kf, group, name, v) \
 275 v = g_key_file_get_double (kf, group, name, &err); \
 276 if (err != NULL) {\
 277   g_propagate_error (error, err);\
 278   retval = FALSE;\
 279   goto out;\
 280 }
 281
 282   GET_DOUBLE (key_file, PAPER_SIZE_GROUP, "Width", width);
 283   GET_DOUBLE (key_file, PAPER_SIZE_GROUP, "Height", height);
 284   GET_DOUBLE (key_file, PAGE_SETUP_GROUP, "MarginTop", top);
 285   GET_DOUBLE (key_file, PAGE_SETUP_GROUP, "MarginBottom", bottom);
 286   GET_DOUBLE (key_file, PAGE_SETUP_GROUP, "MarginLeft", left);
 287   GET_DOUBLE (key_file, PAGE_SETUP_GROUP, "MarginRight", right);
 288
 289 #undef GET_DOUBLE
 290
 291   name = g_key_file_get_string (key_file, PAPER_SIZE_GROUP,
 292                                 "Name", NULL);
 293   ppd_name = g_key_file_get_string (key_file, PAPER_SIZE_GROUP,
 294                                     "PPDName", NULL);
 295   display_name = g_key_file_get_string (key_file, PAPER_SIZE_GROUP,
 296                                         "DisplayName", NULL);
 297   orientation = g_key_file_get_string (key_file, PAGE_SETUP_GROUP,
 298                                        "Orientation", NULL);
 299
 300   if ((ppd_name == NULL && name == NULL) || orientation == NULL)
 301     {
 302       g_set_error (error, ERROR_QUARK, 0, "Not a valid epiphany page setup file");
 303       retval = FALSE;
 304       goto out;
 305     }
 306
 307   if (ppd_name != NULL) {
 308     paper_size = gtk_paper_size_new_from_ppd (ppd_name, display_name,
 309                                               width, height);
 310   } else {
 311     paper_size = gtk_paper_size_new_custom (name, display_name,
 312                                             width, height, GTK_UNIT_MM);
 313   }
 314   g_assert (paper_size != NULL);
 315
 316   page_setup = gtk_page_setup_new ();
 317   gtk_page_setup_set_paper_size (page_setup, paper_size);
 318   gtk_paper_size_free (paper_size);
 319
 320   gtk_page_setup_set_top_margin (page_setup, top, GTK_UNIT_MM);
 321   gtk_page_setup_set_bottom_margin (page_setup, bottom, GTK_UNIT_MM);
 322   gtk_page_setup_set_left_margin (page_setup, left, GTK_UNIT_MM);
 323   gtk_page_setup_set_right_margin (page_setup, right, GTK_UNIT_MM);
 324
 325   gtk_page_setup_set_orientation (page_setup,
 326                                   ephy_string_enum_from_string (GTK_TYPE_PAGE_ORIENTATION,
 327                                                                 orientation));
 328 out:
 329   g_free (ppd_name);
 330   g_free (name);
 331   g_free (display_name);
 332   g_free (orientation);
 333
 334   return page_setup;
 335 }
 336
 337 /**
 338  * ephy_print_utils_page_setup_to_file:
 339  * @page_setup: a #GtkPageSetup
 340  * @file_name: the file to save to
 341  * @error:
 342  *
 343  * This function saves the print page_setup from @page_setup to @file_name.
 344  *
 345  * Return value: %TRUE on success
 346  *
 347  * Since: 2.10
 348  */
 349 gboolean
 350 ephy_print_utils_page_setup_to_file (GtkPageSetup     *page_setup,
 351                                      const char           *file_name,
 352                                      GError              **error)
 353 {
 354   GKeyFile *keyfile;
 355   gboolean retval;
 356   char *data = NULL;
 357   gsize len;
 358
 359   g_return_val_if_fail (GTK_IS_PAGE_SETUP (page_setup), FALSE);
 360   g_return_val_if_fail (file_name != NULL, FALSE);
 361
 362   keyfile = g_key_file_new ();
 363   retval = ephy_print_utils_page_setup_to_key_file (page_setup, keyfile, error);
 364   if (!retval) goto out;
 365
 366   data = g_key_file_to_data (keyfile, &len, error);
 367   if (!data) goto out;
 368
 369   retval = g_file_set_contents (file_name, data, len, error);
 370
 371 out:
 372   g_key_file_free (keyfile);
 373   g_free (data);
 374
 375   return retval;
 376 }
 377
 378 /**
 379  * ephy_print_utils_page_setup_to_key_file:
 380  * @page_setup: a #GtkPageSetup
 381  * @key_file: the #GKeyFile to save the print page_setup to
 382  * @error:
 383  *
 384  * This function adds the print page_setup from @page_setup to @key_file.
 385  *
 386  * Return value: %TRUE on success
 387  *
 388  * Since: 2.10
 389  */
 390 gboolean
 391 ephy_print_utils_page_setup_to_key_file (GtkPageSetup  *page_setup,
 392                                          GKeyFile          *key_file,
 393                                          GError           **error)
 394 {
 395   GtkPaperSize *paper_size;
 396   const char *name, *ppd_name, *display_name;
 397   char *orientation;
 398
 399   g_return_val_if_fail (GTK_IS_PAGE_SETUP (page_setup), FALSE);
 400   g_return_val_if_fail (key_file != NULL, FALSE);
 401
 402   paper_size = gtk_page_setup_get_paper_size (page_setup);
 403   g_assert (paper_size != NULL);
 404
 405   name = gtk_paper_size_get_name (paper_size);
 406   display_name = gtk_paper_size_get_display_name (paper_size);
 407   ppd_name = gtk_paper_size_get_ppd_name (paper_size);
 408
 409   if (ppd_name != NULL) {
 410     g_key_file_set_string (key_file, PAPER_SIZE_GROUP,
 411                            "PPDName", ppd_name);
 412   } else {
 413     g_key_file_set_string (key_file, PAPER_SIZE_GROUP,
 414                            "Name", name);
 415   }
 416
 417   if (display_name) {
 418     g_key_file_set_string (key_file, PAPER_SIZE_GROUP,
 419                            "DisplayName", display_name);
 420   }
 421
 422   g_key_file_set_double (key_file, PAPER_SIZE_GROUP,
 423                          "Width", gtk_paper_size_get_width (paper_size, GTK_UNIT_MM));
 424   g_key_file_set_double (key_file, PAPER_SIZE_GROUP,
 425                          "Height", gtk_paper_size_get_height (paper_size, GTK_UNIT_MM));
 426
 427   g_key_file_set_double (key_file, PAGE_SETUP_GROUP,
 428                          "MarginTop", gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM));
 429   g_key_file_set_double (key_file, PAGE_SETUP_GROUP,
 430                          "MarginBottom", gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM));
 431   g_key_file_set_double (key_file, PAGE_SETUP_GROUP,
 432                          "MarginLeft", gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM));
 433   g_key_file_set_double (key_file, PAGE_SETUP_GROUP,
 434                          "MarginRight", gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM));
 435
 436   orientation = ephy_string_enum_to_string (GTK_TYPE_PAGE_ORIENTATION,
 437                                             gtk_page_setup_get_orientation (page_setup));
 438   g_key_file_set_string (key_file, PAGE_SETUP_GROUP,
 439                          "Orientation", orientation);
 440   g_free (orientation);
 441
 442   return TRUE;
 443 }