Pileus Git - ~andy/gtk/blob - modules/printbackends/cups/gtkprintercups.c

   1 /* GtkPrinterCupsCups
   2  * Copyright (C) 2006 John (J5) Palmieri  <johnp@redhat.com>
   3  * Copyright (C) 2011 Richard Hughes <rhughes@redhat.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #include <glib/gi18n-lib.h>
  24
  25 #ifdef HAVE_COLORD
  26 #include <colord.h>
  27 #endif
  28
  29 #include "gtkintl.h"
  30 #include "gtkprintercups.h"
  31
  32 enum {
  33   PROP_0,
  34   PROP_PROFILE_TITLE
  35 };
  36
  37 static void gtk_printer_cups_init       (GtkPrinterCups      *printer);
  38 static void gtk_printer_cups_class_init (GtkPrinterCupsClass *class);
  39 static void gtk_printer_cups_finalize   (GObject             *object);
  40
  41 static GtkPrinterClass *gtk_printer_cups_parent_class;
  42 static GType gtk_printer_cups_type = 0;
  43
  44 static void gtk_printer_cups_set_property (GObject      *object,
  45                                            guint         prop_id,
  46                                            const GValue *value,
  47                                            GParamSpec   *pspec);
  48 static void gtk_printer_cups_get_property (GObject      *object,
  49                                            guint         prop_id,
  50                                            GValue       *value,
  51                                            GParamSpec   *pspec);
  52
  53 void
  54 gtk_printer_cups_register_type (GTypeModule *module)
  55 {
  56   const GTypeInfo object_info =
  57   {
  58     sizeof (GtkPrinterCupsClass),
  59     (GBaseInitFunc) NULL,
  60     (GBaseFinalizeFunc) NULL,
  61     (GClassInitFunc) gtk_printer_cups_class_init,
  62     NULL,           /* class_finalize */
  63     NULL,           /* class_data */
  64     sizeof (GtkPrinterCups),
  65     0,              /* n_preallocs */
  66     (GInstanceInitFunc) gtk_printer_cups_init,
  67   };
  68
  69  gtk_printer_cups_type = g_type_module_register_type (module,
  70                                                       GTK_TYPE_PRINTER,
  71                                                       "GtkPrinterCups",
  72                                                       &object_info, 0);
  73 }
  74
  75 GType
  76 gtk_printer_cups_get_type (void)
  77 {
  78   return gtk_printer_cups_type;
  79 }
  80
  81 static void
  82 gtk_printer_cups_class_init (GtkPrinterCupsClass *class)
  83 {
  84   GObjectClass *object_class = (GObjectClass *) class;
  85
  86   object_class->finalize = gtk_printer_cups_finalize;
  87   object_class->set_property = gtk_printer_cups_set_property;
  88   object_class->get_property = gtk_printer_cups_get_property;
  89
  90   gtk_printer_cups_parent_class = g_type_class_peek_parent (class);
  91
  92   g_object_class_install_property (G_OBJECT_CLASS (class),
  93                                    PROP_PROFILE_TITLE,
  94                                    g_param_spec_string ("profile-title",
  95                                                         P_("Color Profile Title"),
  96                                                         P_("The title of the color profile to use"),
  97                                                         "",
  98                                                         G_PARAM_READABLE));
  99 }
 100
 101 static void
 102 gtk_printer_cups_init (GtkPrinterCups *printer)
 103 {
 104   printer->device_uri = NULL;
 105   printer->printer_uri = NULL;
 106   printer->state = 0;
 107   printer->hostname = NULL;
 108   printer->port = 0;
 109   printer->ppd_name = NULL;
 110   printer->ppd_file = NULL;
 111   printer->default_cover_before = NULL;
 112   printer->default_cover_after = NULL;
 113   printer->remote = FALSE;
 114   printer->get_remote_ppd_poll = 0;
 115   printer->get_remote_ppd_attempts = 0;
 116   printer->remote_cups_connection_test = NULL;
 117   printer->auth_info_required = NULL;
 118 }
 119
 120 static void
 121 gtk_printer_cups_finalize (GObject *object)
 122 {
 123   GtkPrinterCups *printer;
 124
 125   g_return_if_fail (object != NULL);
 126
 127   printer = GTK_PRINTER_CUPS (object);
 128
 129   g_free (printer->device_uri);
 130   g_free (printer->printer_uri);
 131   g_free (printer->hostname);
 132   g_free (printer->ppd_name);
 133   g_free (printer->default_cover_before);
 134   g_free (printer->default_cover_after);
 135   g_strfreev (printer->auth_info_required);
 136
 137 #ifdef HAVE_COLORD
 138   g_cancellable_cancel (printer->colord_cancellable);
 139   g_object_unref (printer->colord_cancellable);
 140   g_free (printer->colord_title);
 141   g_free (printer->colord_qualifier);
 142   if (printer->colord_client)
 143     g_object_unref (printer->colord_client);
 144   if (printer->colord_device)
 145     g_object_unref (printer->colord_device);
 146   if (printer->colord_profile)
 147     g_object_unref (printer->colord_profile);
 148 #endif
 149
 150   if (printer->ppd_file)
 151     ppdClose (printer->ppd_file);
 152
 153   if (printer->get_remote_ppd_poll > 0)
 154     g_source_remove (printer->get_remote_ppd_poll);
 155   printer->get_remote_ppd_attempts = 0;
 156
 157   gtk_cups_connection_test_free (printer->remote_cups_connection_test);
 158
 159   G_OBJECT_CLASS (gtk_printer_cups_parent_class)->finalize (object);
 160 }
 161
 162 static void
 163 gtk_printer_cups_set_property (GObject         *object,
 164                                guint            prop_id,
 165                                const GValue    *value,
 166                                GParamSpec      *pspec)
 167 {
 168   switch (prop_id)
 169     {
 170     default:
 171       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 172       break;
 173     }
 174 }
 175
 176 static void
 177 gtk_printer_cups_get_property (GObject    *object,
 178                                guint       prop_id,
 179                                GValue     *value,
 180                                GParamSpec *pspec)
 181 {
 182   GtkPrinterCups *printer = GTK_PRINTER_CUPS (object);
 183
 184   switch (prop_id)
 185     {
 186     case PROP_PROFILE_TITLE:
 187 #ifdef HAVE_COLORD
 188       if (printer->colord_title)
 189         g_value_set_string (value, printer->colord_title);
 190       else
 191         g_value_set_static_string (value, "");
 192 #else
 193       g_value_set_static_string (value, NULL);
 194 #endif
 195       break;
 196     default:
 197       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 198       break;
 199     }
 200 }
 201
 202 #ifdef HAVE_COLORD
 203
 204 static void
 205 colord_update_ui_from_settings (GtkPrinterCups *printer)
 206 {
 207   const gchar *title = NULL;
 208
 209   /* not yet connected to colord */
 210   if (printer->colord_client == NULL)
 211     goto out;
 212   if (!cd_client_get_connected (printer->colord_client))
 213     goto out;
 214
 215   /* failed to get a colord device for the printer */
 216   if (printer->colord_device == NULL)
 217     {
 218       /* TRANSLATORS: when we're running an old CUPS, and
 219        * it hasn't registered the device with colord */
 220       title = _("Color management unavailable");
 221       goto out;
 222     }
 223
 224   /* when colord prevents us from connecting (should not happen) */
 225   if (!cd_device_get_connected (printer->colord_device))
 226     goto out;
 227
 228   /* failed to get a colord device for the printer */
 229   if (printer->colord_profile == NULL)
 230     {
 231       /* TRANSLATORS: when there is no color profile available */
 232       title = _("No profile available");
 233       goto out;
 234     }
 235
 236   /* when colord prevents us from connecting (should not happen) */
 237   if (!cd_profile_get_connected (printer->colord_profile))
 238     goto out;
 239   title = cd_profile_get_title (printer->colord_profile);
 240   if (title == NULL)
 241     {
 242       /* TRANSLATORS: when the color profile has no title */
 243       title = _("Unspecified profile");
 244       goto out;
 245     }
 246
 247 out:
 248   /* SUCCESS! */
 249   if (g_strcmp0 (title, printer->colord_title) != 0)
 250     {
 251       g_free (printer->colord_title);
 252       printer->colord_title = g_strdup (title);
 253       g_object_notify (G_OBJECT (printer), "profile-title");
 254     }
 255   return;
 256 }
 257
 258 static void
 259 colord_client_profile_connect_cb (GObject *source_object,
 260                                   GAsyncResult *res,
 261                                   gpointer user_data)
 262 {
 263   gboolean ret;
 264   GError *error = NULL;
 265   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 266
 267   ret = cd_profile_connect_finish (CD_PROFILE (source_object),
 268                                    res,
 269                                    &error);
 270   if (!ret)
 271     {
 272       g_warning ("failed to get properties from the profile: %s",
 273                  error->message);
 274       g_error_free (error);
 275     }
 276
 277   /* update the UI */
 278   colord_update_ui_from_settings (printer);
 279 }
 280
 281 static void
 282 colord_client_device_get_profile_for_qualifiers_cb (GObject *source_object,
 283                                                     GAsyncResult *res,
 284                                                     gpointer user_data)
 285 {
 286   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 287   GError *error = NULL;
 288
 289   printer->colord_profile = cd_device_get_profile_for_qualifiers_finish (printer->colord_device,
 290                                                                          res,
 291                                                                          &error);
 292   if (printer->colord_profile == NULL)
 293     {
 294       /* not having a profile for a qualifier is not a warning */
 295       g_debug ("no profile for device %s: %s",
 296                cd_device_get_id (printer->colord_device),
 297                error->message);
 298       g_error_free (error);
 299       goto out;
 300     }
 301
 302   /* get details about the profile */
 303   cd_profile_connect (printer->colord_profile,
 304                       printer->colord_cancellable,
 305                       colord_client_profile_connect_cb,
 306                       printer);
 307 out:
 308   /* update the UI */
 309   colord_update_ui_from_settings (printer);
 310 }
 311
 312 void
 313 gtk_printer_cups_update_settings (GtkPrinterCups *printer,
 314                                   GtkPrintSettings *settings,
 315                                   GtkPrinterOptionSet *set)
 316 {
 317   gchar *qualifier = NULL;
 318   gchar **qualifiers = NULL;
 319   GtkPrinterOption *option;
 320   const gchar *format[3];
 321
 322   /* nothing set yet */
 323   if (printer->colord_device == NULL)
 324     goto out;
 325   if (!cd_device_get_connected (printer->colord_device))
 326     goto out;
 327
 328   /* cupsICCQualifier1 */
 329   option = gtk_printer_option_set_lookup (set, "cups-ColorSpace");
 330   if (option == NULL)
 331     option = gtk_printer_option_set_lookup (set, "cups-ColorModel");
 332   if (option != NULL)
 333     format[0] = option->value;
 334   else
 335     format[0] = "*";
 336
 337   /* cupsICCQualifier2 */
 338   option = gtk_printer_option_set_lookup (set, "cups-OutputMode");
 339   if (option != NULL)
 340     format[1] = option->value;
 341   else
 342     format[1] = "*";
 343
 344   /* cupsICCQualifier3 */
 345   option = gtk_printer_option_set_lookup (set, "cups-Resolution");
 346   if (option != NULL)
 347     format[2] = "*";
 348
 349   /* get profile for the device given the qualifier */
 350   qualifier = g_strdup_printf ("%s.%s.%s,%s.%s.*,%s.*.*",
 351                                format[0], format[1], format[2],
 352                                format[0], format[1],
 353                                format[0]);
 354
 355   /* only requery colord if the option that was changed would give
 356    * us a different profile result */
 357   if (g_strcmp0 (qualifier, printer->colord_qualifier) == 0)
 358     goto out;
 359
 360   qualifiers = g_strsplit (qualifier, ",", -1);
 361   cd_device_get_profile_for_qualifiers (printer->colord_device,
 362                                         (const gchar **) qualifiers,
 363                                         printer->colord_cancellable,
 364                                         colord_client_device_get_profile_for_qualifiers_cb,
 365                                         printer);
 366
 367   /* save for the future */
 368   g_free (printer->colord_qualifier);
 369   printer->colord_qualifier = g_strdup (qualifier);
 370
 371   /* update the UI */
 372   colord_update_ui_from_settings (printer);
 373 out:
 374   g_free (qualifier);
 375   g_strfreev (qualifiers);
 376 }
 377
 378 static void
 379 colord_client_device_connect_cb (GObject *source_object,
 380                                  GAsyncResult *res,
 381                                  gpointer user_data)
 382 {
 383   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 384   gboolean ret;
 385   GError *error = NULL;
 386
 387   /* get details about the device */
 388   ret = cd_device_connect_finish (CD_DEVICE (source_object), res, &error);
 389   if (!ret)
 390     {
 391       g_warning ("failed to get properties from the colord device: %s",
 392                  error->message);
 393       g_error_free (error);
 394       goto out;
 395     }
 396 out:
 397   /* update the UI */
 398   colord_update_ui_from_settings (printer);
 399 }
 400
 401 static void
 402 colord_client_find_device_cb (GObject *source_object,
 403                               GAsyncResult *res,
 404                               gpointer user_data)
 405 {
 406   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 407   GError *error = NULL;
 408
 409   /* get the new device */
 410   printer->colord_device = cd_client_find_device_finish (printer->colord_client,
 411                                                res,
 412                                                &error);
 413   if (printer->colord_device == NULL)
 414     {
 415       g_warning ("failed to get find a colord device: %s",
 416                  error->message);
 417       g_error_free (error);
 418       goto out;
 419     }
 420
 421   /* get details about the device */
 422   g_cancellable_reset (printer->colord_cancellable);
 423   cd_device_connect (printer->colord_device,
 424                      printer->colord_cancellable,
 425                      colord_client_device_connect_cb,
 426                      printer);
 427 out:
 428   /* update the UI */
 429   colord_update_ui_from_settings (printer);
 430 }
 431
 432 static void
 433 colord_update_device (GtkPrinterCups *printer)
 434 {
 435   gchar *colord_device_id = NULL;
 436
 437   /* not yet connected to the daemon */
 438   if (!cd_client_get_connected (printer->colord_client))
 439     goto out;
 440
 441   /* not yet assigned a printer */
 442   if (printer->ppd_file == NULL)
 443     goto out;
 444
 445   /* old cached profile no longer valid */
 446   if (printer->colord_profile)
 447     {
 448       g_object_unref (printer->colord_profile);
 449       printer->colord_profile = NULL;
 450     }
 451
 452   /* old cached device no longer valid */
 453   if (printer->colord_device)
 454     {
 455       g_object_unref (printer->colord_device);
 456       printer->colord_device = NULL;
 457     }
 458
 459   /* generate a known ID */
 460   colord_device_id = g_strdup_printf ("cups-%s", gtk_printer_get_name (GTK_PRINTER (printer)));
 461
 462   g_cancellable_reset (printer->colord_cancellable);
 463   cd_client_find_device (printer->colord_client,
 464                          colord_device_id,
 465                          printer->colord_cancellable,
 466                          colord_client_find_device_cb,
 467                          printer);
 468 out:
 469   g_free (colord_device_id);
 470
 471   /* update the UI */
 472   colord_update_ui_from_settings (printer);
 473 }
 474
 475 static void
 476 colord_client_connect_cb (GObject *source_object,
 477                           GAsyncResult *res,
 478                           gpointer user_data)
 479 {
 480   gboolean ret;
 481   GError *error = NULL;
 482   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 483
 484   ret = cd_client_connect_finish (CD_CLIENT (source_object),
 485                                   res, &error);
 486   if (!ret)
 487     {
 488       g_warning ("failed to contact colord: %s", error->message);
 489       g_error_free (error);
 490     }
 491
 492   /* refresh the device */
 493   colord_update_device (printer);
 494 }
 495 #endif
 496
 497 /**
 498  * gtk_printer_cups_new:
 499  *
 500  * Creates a new #GtkPrinterCups.
 501  *
 502  * Return value: a new #GtkPrinterCups
 503  *
 504  * Since: 2.10
 505  **/
 506 GtkPrinterCups *
 507 gtk_printer_cups_new (const char      *name,
 508                       GtkPrintBackend *backend,
 509                       gpointer         colord_client)
 510 {
 511   GObject *result;
 512   gboolean accepts_pdf;
 513   GtkPrinterCups *printer;
 514
 515 #if (CUPS_VERSION_MAJOR == 1 && CUPS_VERSION_MINOR >= 2) || CUPS_VERSION_MAJOR > 1
 516   accepts_pdf = TRUE;
 517 #else
 518   accepts_pdf = FALSE;
 519 #endif
 520
 521   result = g_object_new (GTK_TYPE_PRINTER_CUPS,
 522                          "name", name,
 523                          "backend", backend,
 524                          "is-virtual", FALSE,
 525                          "accepts-pdf", accepts_pdf,
 526                          NULL);
 527   printer = GTK_PRINTER_CUPS (result);
 528
 529 #ifdef HAVE_COLORD
 530   /* connect to colord */
 531   if (colord_client != NULL)
 532     {
 533       printer->colord_cancellable = g_cancellable_new ();
 534       printer->colord_client = g_object_ref (CD_CLIENT (colord_client));
 535       cd_client_connect (printer->colord_client,
 536                          printer->colord_cancellable,
 537                          colord_client_connect_cb,
 538                          printer);
 539     }
 540 #endif
 541   return printer;
 542 }
 543
 544 ppd_file_t *
 545 gtk_printer_cups_get_ppd (GtkPrinterCups *printer)
 546 {
 547   return printer->ppd_file;
 548 }
 549
 550 const gchar *
 551 gtk_printer_cups_get_ppd_name (GtkPrinterCups  *printer)
 552 {
 553   const gchar *result;
 554
 555   result = printer->ppd_name;
 556
 557   if (result == NULL)
 558     result = gtk_printer_get_name (GTK_PRINTER (printer));
 559
 560   return result;
 561 }