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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include <glib/gi18n-lib.h>
  22
  23 #ifdef HAVE_COLORD
  24 #include <colord.h>
  25 #endif
  26
  27 #include "gtkintl.h"
  28 #include "gtkprintercups.h"
  29
  30 enum {
  31   PROP_0,
  32   PROP_PROFILE_TITLE
  33 };
  34
  35 static void gtk_printer_cups_init       (GtkPrinterCups      *printer);
  36 static void gtk_printer_cups_class_init (GtkPrinterCupsClass *class);
  37 static void gtk_printer_cups_finalize   (GObject             *object);
  38
  39 static GtkPrinterClass *gtk_printer_cups_parent_class;
  40 static GType gtk_printer_cups_type = 0;
  41
  42 static void gtk_printer_cups_set_property (GObject      *object,
  43                                            guint         prop_id,
  44                                            const GValue *value,
  45                                            GParamSpec   *pspec);
  46 static void gtk_printer_cups_get_property (GObject      *object,
  47                                            guint         prop_id,
  48                                            GValue       *value,
  49                                            GParamSpec   *pspec);
  50
  51 void
  52 gtk_printer_cups_register_type (GTypeModule *module)
  53 {
  54   const GTypeInfo object_info =
  55   {
  56     sizeof (GtkPrinterCupsClass),
  57     (GBaseInitFunc) NULL,
  58     (GBaseFinalizeFunc) NULL,
  59     (GClassInitFunc) gtk_printer_cups_class_init,
  60     NULL,           /* class_finalize */
  61     NULL,           /* class_data */
  62     sizeof (GtkPrinterCups),
  63     0,              /* n_preallocs */
  64     (GInstanceInitFunc) gtk_printer_cups_init,
  65   };
  66
  67  gtk_printer_cups_type = g_type_module_register_type (module,
  68                                                       GTK_TYPE_PRINTER,
  69                                                       "GtkPrinterCups",
  70                                                       &object_info, 0);
  71 }
  72
  73 GType
  74 gtk_printer_cups_get_type (void)
  75 {
  76   return gtk_printer_cups_type;
  77 }
  78
  79 static void
  80 gtk_printer_cups_class_init (GtkPrinterCupsClass *class)
  81 {
  82   GObjectClass *object_class = (GObjectClass *) class;
  83
  84   object_class->finalize = gtk_printer_cups_finalize;
  85   object_class->set_property = gtk_printer_cups_set_property;
  86   object_class->get_property = gtk_printer_cups_get_property;
  87
  88   gtk_printer_cups_parent_class = g_type_class_peek_parent (class);
  89
  90   g_object_class_install_property (G_OBJECT_CLASS (class),
  91                                    PROP_PROFILE_TITLE,
  92                                    g_param_spec_string ("profile-title",
  93                                                         P_("Color Profile Title"),
  94                                                         P_("The title of the color profile to use"),
  95                                                         "",
  96                                                         G_PARAM_READABLE));
  97 }
  98
  99 static void
 100 gtk_printer_cups_init (GtkPrinterCups *printer)
 101 {
 102   printer->device_uri = NULL;
 103   printer->printer_uri = NULL;
 104   printer->state = 0;
 105   printer->hostname = NULL;
 106   printer->port = 0;
 107   printer->ppd_name = NULL;
 108   printer->ppd_file = NULL;
 109   printer->default_cover_before = NULL;
 110   printer->default_cover_after = NULL;
 111   printer->remote = FALSE;
 112   printer->get_remote_ppd_poll = 0;
 113   printer->get_remote_ppd_attempts = 0;
 114   printer->remote_cups_connection_test = NULL;
 115   printer->auth_info_required = NULL;
 116 }
 117
 118 static void
 119 gtk_printer_cups_finalize (GObject *object)
 120 {
 121   GtkPrinterCups *printer;
 122
 123   g_return_if_fail (object != NULL);
 124
 125   printer = GTK_PRINTER_CUPS (object);
 126
 127   g_free (printer->device_uri);
 128   g_free (printer->printer_uri);
 129   g_free (printer->hostname);
 130   g_free (printer->ppd_name);
 131   g_free (printer->default_cover_before);
 132   g_free (printer->default_cover_after);
 133   g_strfreev (printer->auth_info_required);
 134
 135 #ifdef HAVE_COLORD
 136   g_cancellable_cancel (printer->colord_cancellable);
 137   g_object_unref (printer->colord_cancellable);
 138   g_free (printer->colord_title);
 139   g_free (printer->colord_qualifier);
 140   if (printer->colord_client)
 141     g_object_unref (printer->colord_client);
 142   if (printer->colord_device)
 143     g_object_unref (printer->colord_device);
 144   if (printer->colord_profile)
 145     g_object_unref (printer->colord_profile);
 146 #endif
 147
 148   if (printer->ppd_file)
 149     ppdClose (printer->ppd_file);
 150
 151   if (printer->get_remote_ppd_poll > 0)
 152     g_source_remove (printer->get_remote_ppd_poll);
 153   printer->get_remote_ppd_attempts = 0;
 154
 155   gtk_cups_connection_test_free (printer->remote_cups_connection_test);
 156
 157   G_OBJECT_CLASS (gtk_printer_cups_parent_class)->finalize (object);
 158 }
 159
 160 static void
 161 gtk_printer_cups_set_property (GObject         *object,
 162                                guint            prop_id,
 163                                const GValue    *value,
 164                                GParamSpec      *pspec)
 165 {
 166   switch (prop_id)
 167     {
 168     default:
 169       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 170       break;
 171     }
 172 }
 173
 174 static void
 175 gtk_printer_cups_get_property (GObject    *object,
 176                                guint       prop_id,
 177                                GValue     *value,
 178                                GParamSpec *pspec)
 179 {
 180 #ifdef HAVE_COLORD
 181   GtkPrinterCups *printer = GTK_PRINTER_CUPS (object);
 182 #endif
 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] = option->value;
 348   else
 349     format[2] = "*";
 350
 351   /* get profile for the device given the qualifier */
 352   qualifier = g_strdup_printf ("%s.%s.%s,%s.%s.*,%s.*.*",
 353                                format[0], format[1], format[2],
 354                                format[0], format[1],
 355                                format[0]);
 356
 357   /* only requery colord if the option that was changed would give
 358    * us a different profile result */
 359   if (g_strcmp0 (qualifier, printer->colord_qualifier) == 0)
 360     goto out;
 361
 362   qualifiers = g_strsplit (qualifier, ",", -1);
 363   cd_device_get_profile_for_qualifiers (printer->colord_device,
 364                                         (const gchar **) qualifiers,
 365                                         printer->colord_cancellable,
 366                                         colord_client_device_get_profile_for_qualifiers_cb,
 367                                         printer);
 368
 369   /* save for the future */
 370   g_free (printer->colord_qualifier);
 371   printer->colord_qualifier = g_strdup (qualifier);
 372
 373   /* update the UI */
 374   colord_update_ui_from_settings (printer);
 375 out:
 376   g_free (qualifier);
 377   g_strfreev (qualifiers);
 378 }
 379
 380 static void
 381 colord_client_device_connect_cb (GObject *source_object,
 382                                  GAsyncResult *res,
 383                                  gpointer user_data)
 384 {
 385   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 386   gboolean ret;
 387   GError *error = NULL;
 388
 389   /* get details about the device */
 390   ret = cd_device_connect_finish (CD_DEVICE (source_object), res, &error);
 391   if (!ret)
 392     {
 393       g_warning ("failed to get properties from the colord device: %s",
 394                  error->message);
 395       g_error_free (error);
 396       goto out;
 397     }
 398 out:
 399   /* update the UI */
 400   colord_update_ui_from_settings (printer);
 401 }
 402
 403 static void
 404 colord_client_find_device_cb (GObject *source_object,
 405                               GAsyncResult *res,
 406                               gpointer user_data)
 407 {
 408   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 409   GError *error = NULL;
 410
 411   /* get the new device */
 412   printer->colord_device = cd_client_find_device_finish (printer->colord_client,
 413                                                res,
 414                                                &error);
 415   if (printer->colord_device == NULL)
 416     {
 417       g_warning ("failed to get find a colord device: %s",
 418                  error->message);
 419       g_error_free (error);
 420       goto out;
 421     }
 422
 423   /* get details about the device */
 424   g_cancellable_reset (printer->colord_cancellable);
 425   cd_device_connect (printer->colord_device,
 426                      printer->colord_cancellable,
 427                      colord_client_device_connect_cb,
 428                      printer);
 429 out:
 430   /* update the UI */
 431   colord_update_ui_from_settings (printer);
 432 }
 433
 434 static void
 435 colord_update_device (GtkPrinterCups *printer)
 436 {
 437   gchar *colord_device_id = NULL;
 438
 439   /* not yet connected to the daemon */
 440   if (!cd_client_get_connected (printer->colord_client))
 441     goto out;
 442
 443   /* not yet assigned a printer */
 444   if (printer->ppd_file == NULL)
 445     goto out;
 446
 447   /* old cached profile no longer valid */
 448   if (printer->colord_profile)
 449     {
 450       g_object_unref (printer->colord_profile);
 451       printer->colord_profile = NULL;
 452     }
 453
 454   /* old cached device no longer valid */
 455   if (printer->colord_device)
 456     {
 457       g_object_unref (printer->colord_device);
 458       printer->colord_device = NULL;
 459     }
 460
 461   /* generate a known ID */
 462   colord_device_id = g_strdup_printf ("cups-%s", gtk_printer_get_name (GTK_PRINTER (printer)));
 463
 464   g_cancellable_reset (printer->colord_cancellable);
 465   cd_client_find_device (printer->colord_client,
 466                          colord_device_id,
 467                          printer->colord_cancellable,
 468                          colord_client_find_device_cb,
 469                          printer);
 470 out:
 471   g_free (colord_device_id);
 472
 473   /* update the UI */
 474   colord_update_ui_from_settings (printer);
 475 }
 476
 477 static void
 478 colord_client_connect_cb (GObject *source_object,
 479                           GAsyncResult *res,
 480                           gpointer user_data)
 481 {
 482   gboolean ret;
 483   GError *error = NULL;
 484   GtkPrinterCups *printer = GTK_PRINTER_CUPS (user_data);
 485
 486   ret = cd_client_connect_finish (CD_CLIENT (source_object),
 487                                   res, &error);
 488   if (!ret)
 489     {
 490       g_warning ("failed to contact colord: %s", error->message);
 491       g_error_free (error);
 492     }
 493
 494   /* refresh the device */
 495   colord_update_device (printer);
 496 }
 497 #endif
 498
 499 /**
 500  * gtk_printer_cups_new:
 501  *
 502  * Creates a new #GtkPrinterCups.
 503  *
 504  * Return value: a new #GtkPrinterCups
 505  *
 506  * Since: 2.10
 507  **/
 508 GtkPrinterCups *
 509 gtk_printer_cups_new (const char      *name,
 510                       GtkPrintBackend *backend,
 511                       gpointer         colord_client)
 512 {
 513   GObject *result;
 514   gboolean accepts_pdf;
 515   GtkPrinterCups *printer;
 516
 517 #if (CUPS_VERSION_MAJOR == 1 && CUPS_VERSION_MINOR >= 2) || CUPS_VERSION_MAJOR > 1
 518   accepts_pdf = TRUE;
 519 #else
 520   accepts_pdf = FALSE;
 521 #endif
 522
 523   result = g_object_new (GTK_TYPE_PRINTER_CUPS,
 524                          "name", name,
 525                          "backend", backend,
 526                          "is-virtual", FALSE,
 527                          "accepts-pdf", accepts_pdf,
 528                          NULL);
 529   printer = GTK_PRINTER_CUPS (result);
 530
 531 #ifdef HAVE_COLORD
 532   /* connect to colord */
 533   if (colord_client != NULL)
 534     {
 535       printer->colord_cancellable = g_cancellable_new ();
 536       printer->colord_client = g_object_ref (CD_CLIENT (colord_client));
 537       cd_client_connect (printer->colord_client,
 538                          printer->colord_cancellable,
 539                          colord_client_connect_cb,
 540                          printer);
 541     }
 542 #endif
 543   return printer;
 544 }
 545
 546 ppd_file_t *
 547 gtk_printer_cups_get_ppd (GtkPrinterCups *printer)
 548 {
 549   return printer->ppd_file;
 550 }
 551
 552 const gchar *
 553 gtk_printer_cups_get_ppd_name (GtkPrinterCups  *printer)
 554 {
 555   const gchar *result;
 556
 557   result = printer->ppd_name;
 558
 559   if (result == NULL)
 560     result = gtk_printer_get_name (GTK_PRINTER (printer));
 561
 562   return result;
 563 }