gtkprintbackend.c 24.3 KB
Newer Older
Cody Russell's avatar
Cody Russell committed
1
/* GTK - The GIMP Toolkit
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 * gtkprintbackend.h: Abstract printer backend interfaces
 * Copyright (C) 2003, Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include "config.h"
#include <string.h>

#include <gmodule.h>

#include "gtkintl.h"
#include "gtkmodules.h"
28
#include "gtkmarshalers.h"
29 30 31
#include "gtkprivate.h"
#include "gtkprintbackend.h"

Alexander Larsson's avatar
Alexander Larsson committed
32

33 34 35 36 37 38 39 40 41
static void gtk_print_backend_dispose      (GObject      *object);
static void gtk_print_backend_set_property (GObject      *object,
                                            guint         prop_id,
                                            const GValue *value,
                                            GParamSpec   *pspec);
static void gtk_print_backend_get_property (GObject      *object,
                                            guint         prop_id,
                                            GValue       *value,
                                            GParamSpec   *pspec);
Alexander Larsson's avatar
Alexander Larsson committed
42 43 44 45 46 47

struct _GtkPrintBackendPrivate
{
  GHashTable *printers;
  guint printer_list_requested : 1;
  guint printer_list_done : 1;
48
  GtkPrintBackendStatus status;
49 50
  char **auth_info_required;
  char **auth_info;
Alexander Larsson's avatar
Alexander Larsson committed
51 52 53 54 55 56 57 58
};

enum {
  PRINTER_LIST_CHANGED,
  PRINTER_LIST_DONE,
  PRINTER_ADDED,
  PRINTER_REMOVED,
  PRINTER_STATUS_CHANGED,
59
  REQUEST_PASSWORD,
Alexander Larsson's avatar
Alexander Larsson committed
60 61 62 63 64
  LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = { 0 };

65 66 67 68 69 70
enum 
{ 
  PROP_ZERO,
  PROP_STATUS
};

Alexander Larsson's avatar
Alexander Larsson committed
71
static GObjectClass *backend_parent_class;
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106

GQuark
gtk_print_backend_error_quark (void)
{
  static GQuark quark = 0;
  if (quark == 0)
    quark = g_quark_from_static_string ("gtk-print-backend-error-quark");
  return quark;
}

/*****************************************
 *     GtkPrintBackendModule modules     *
 *****************************************/

typedef struct _GtkPrintBackendModule GtkPrintBackendModule;
typedef struct _GtkPrintBackendModuleClass GtkPrintBackendModuleClass;

struct _GtkPrintBackendModule
{
  GTypeModule parent_instance;
  
  GModule *library;

  void             (*init)     (GTypeModule    *module);
  void             (*exit)     (void);
  GtkPrintBackend* (*create)   (void);

  gchar *path;
};

struct _GtkPrintBackendModuleClass
{
  GTypeModuleClass parent_class;
};

Matthias Clasen's avatar
Matthias Clasen committed
107
G_DEFINE_TYPE (GtkPrintBackendModule, _gtk_print_backend_module, G_TYPE_TYPE_MODULE)
108 109 110 111 112 113 114 115 116 117 118 119 120 121
#define GTK_TYPE_PRINT_BACKEND_MODULE      (_gtk_print_backend_module_get_type ())
#define GTK_PRINT_BACKEND_MODULE(module)   (G_TYPE_CHECK_INSTANCE_CAST ((module), GTK_TYPE_PRINT_BACKEND_MODULE, GtkPrintBackendModule))

static GSList *loaded_backends;

static gboolean
gtk_print_backend_module_load (GTypeModule *module)
{
  GtkPrintBackendModule *pb_module = GTK_PRINT_BACKEND_MODULE (module); 
  gpointer initp, exitp, createp;
 
  pb_module->library = g_module_open (pb_module->path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
  if (!pb_module->library)
    {
122
      g_warning ("%s", g_module_error());
123 124 125 126 127 128 129 130 131 132 133
      return FALSE;
    }
  
  /* extract symbols from the lib */
  if (!g_module_symbol (pb_module->library, "pb_module_init",
			&initp) ||
      !g_module_symbol (pb_module->library, "pb_module_exit", 
			&exitp) ||
      !g_module_symbol (pb_module->library, "pb_module_create", 
			&createp))
    {
134
      g_warning ("%s", g_module_error());
135 136 137 138 139 140 141 142 143
      g_module_close (pb_module->library);
      
      return FALSE;
    }

  pb_module->init = initp;
  pb_module->exit = exitp;
  pb_module->create = createp;

Johan Dahlin's avatar
Johan Dahlin committed
144
  /* call the printbackend's init function to let it */
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
  /* setup anything it needs to set up. */
  pb_module->init (module);

  return TRUE;
}

static void
gtk_print_backend_module_unload (GTypeModule *module)
{
  GtkPrintBackendModule *pb_module = GTK_PRINT_BACKEND_MODULE (module);
  
  pb_module->exit();

  g_module_close (pb_module->library);
  pb_module->library = NULL;

  pb_module->init = NULL;
  pb_module->exit = NULL;
  pb_module->create = NULL;
}

/* This only will ever be called if an error occurs during
 * initialization
 */
static void
gtk_print_backend_module_finalize (GObject *object)
{
  GtkPrintBackendModule *module = GTK_PRINT_BACKEND_MODULE (object);

  g_free (module->path);

  G_OBJECT_CLASS (_gtk_print_backend_module_parent_class)->finalize (object);
}

static void
_gtk_print_backend_module_class_init (GtkPrintBackendModuleClass *class)
{
  GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (class);
  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
Alexander Larsson's avatar
Alexander Larsson committed
184

185 186 187 188 189 190
  module_class->load = gtk_print_backend_module_load;
  module_class->unload = gtk_print_backend_module_unload;

  gobject_class->finalize = gtk_print_backend_module_finalize;
}

191 192 193 194 195 196 197
static void 
gtk_print_backend_set_property (GObject      *object,
                                guint         prop_id,
                                const GValue *value,
                                GParamSpec   *pspec)
{
  GtkPrintBackend *backend = GTK_PRINT_BACKEND (object);
198
  GtkPrintBackendPrivate *priv = backend->priv;
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217

  switch (prop_id)
    {
    case PROP_STATUS:
      priv->status = g_value_get_int (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void 
gtk_print_backend_get_property (GObject    *object,
                                guint       prop_id,
                                GValue     *value,
                                GParamSpec *pspec)
{
  GtkPrintBackend *backend = GTK_PRINT_BACKEND (object);
218
  GtkPrintBackendPrivate *priv = backend->priv;
219 220 221 222 223 224 225 226 227 228 229 230

  switch (prop_id)
    {
    case PROP_STATUS:
      g_value_set_int (value, priv->status);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
static void
_gtk_print_backend_module_init (GtkPrintBackendModule *pb_module)
{
}

static GtkPrintBackend *
_gtk_print_backend_module_create (GtkPrintBackendModule *pb_module)
{
  GtkPrintBackend *pb;
  
  if (g_type_module_use (G_TYPE_MODULE (pb_module)))
    {
      pb = pb_module->create ();
      g_type_module_unuse (G_TYPE_MODULE (pb_module));
      return pb;
    }
  return NULL;
}

250
static GtkPrintBackend *
Matthias Clasen's avatar
Matthias Clasen committed
251
_gtk_print_backend_create (const gchar *backend_name)
252 253
{
  GSList *l;
Matthias Clasen's avatar
Matthias Clasen committed
254 255
  gchar *module_path;
  gchar *full_name;
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
  GtkPrintBackendModule *pb_module;
  GtkPrintBackend *pb;

  for (l = loaded_backends; l != NULL; l = l->next)
    {
      pb_module = l->data;
      
      if (strcmp (G_TYPE_MODULE (pb_module)->name, backend_name) == 0)
	return _gtk_print_backend_module_create (pb_module);
    }

  pb = NULL;
  if (g_module_supported ())
    {
      full_name = g_strconcat ("printbackend-", backend_name, NULL);
      module_path = _gtk_find_module (full_name, "printbackends");
      g_free (full_name);

      if (module_path)
	{
	  pb_module = g_object_new (GTK_TYPE_PRINT_BACKEND_MODULE, NULL);

	  g_type_module_set_name (G_TYPE_MODULE (pb_module), backend_name);
	  pb_module->path = g_strdup (module_path);

	  loaded_backends = g_slist_prepend (loaded_backends,
		   		             pb_module);

	  pb = _gtk_print_backend_module_create (pb_module);
285 286

	  /* Increase use-count so that we don't unload print backends.
Matthias Clasen's avatar
Matthias Clasen committed
287 288 289
	   * There is a problem with module unloading in the cups module,
	   * see cups_dispatch_watch_finalize for details. 
	   */
290
	  g_type_module_use (G_TYPE_MODULE (pb_module));
291 292 293 294 295 296 297 298
	}
      
      g_free (module_path);
    }

  return pb;
}

299 300 301 302 303
/**
 * gtk_printer_backend_load_modules:
 *
 * Return value: (element-type GtkPrintBackend) (transfer container):
 */
304
GList *
Matthias Clasen's avatar
Matthias Clasen committed
305
gtk_print_backend_load_modules (void)
306 307 308 309 310 311 312 313 314 315 316
{
  GList *result;
  GtkPrintBackend *backend;
  gchar *setting;
  gchar **backends;
  gint i;
  GtkSettings *settings;

  result = NULL;

  settings = gtk_settings_get_default ();
317 318 319 320
  if (settings)
    g_object_get (settings, "gtk-print-backends", &setting, NULL);
  else
    setting = g_strdup (GTK_PRINT_BACKENDS);
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342

  backends = g_strsplit (setting, ",", -1);

  for (i = 0; backends[i]; i++)
    {
      g_strchug (backends[i]);
      g_strchomp (backends[i]);
      backend = _gtk_print_backend_create (backends[i]);
      
      if (backend)
        result = g_list_append (result, backend);
    }

  g_strfreev (backends);
  g_free (setting);

  return result;
}

/*****************************************
 *             GtkPrintBackend           *
 *****************************************/
Alexander Larsson's avatar
Alexander Larsson committed
343

Matthias Clasen's avatar
Matthias Clasen committed
344
G_DEFINE_TYPE (GtkPrintBackend, gtk_print_backend, G_TYPE_OBJECT)
Alexander Larsson's avatar
Alexander Larsson committed
345

346 347 348
static void                 fallback_printer_request_details       (GtkPrinter          *printer);
static gboolean             fallback_printer_mark_conflicts        (GtkPrinter          *printer,
								    GtkPrinterOptionSet *options);
349 350 351 352 353
static gboolean             fallback_printer_get_hard_margins      (GtkPrinter          *printer,
                                                                    gdouble             *top,
                                                                    gdouble             *bottom,
                                                                    gdouble             *left,
                                                                    gdouble             *right);
354 355 356
static GList *              fallback_printer_list_papers           (GtkPrinter          *printer);
static GtkPageSetup *       fallback_printer_get_default_page_size (GtkPrinter          *printer);
static GtkPrintCapabilities fallback_printer_get_capabilities      (GtkPrinter          *printer);
357
static void                 request_password                       (GtkPrintBackend     *backend,
358 359 360 361
                                                                    gpointer             auth_info_required,
                                                                    gpointer             auth_info_default,
                                                                    gpointer             auth_info_display,
                                                                    gpointer             auth_info_visible,
362
                                                                    const gchar         *prompt);
363
  
Alexander Larsson's avatar
Alexander Larsson committed
364 365
static void
gtk_print_backend_class_init (GtkPrintBackendClass *class)
366
{
Alexander Larsson's avatar
Alexander Larsson committed
367 368
  GObjectClass *object_class;
  object_class = (GObjectClass *) class;
369

Alexander Larsson's avatar
Alexander Larsson committed
370 371 372
  backend_parent_class = g_type_class_peek_parent (class);
  
  object_class->dispose = gtk_print_backend_dispose;
373 374
  object_class->set_property = gtk_print_backend_set_property;
  object_class->get_property = gtk_print_backend_get_property;
Alexander Larsson's avatar
Alexander Larsson committed
375

376 377 378 379
  class->printer_request_details = fallback_printer_request_details;
  class->printer_mark_conflicts = fallback_printer_mark_conflicts;
  class->printer_get_hard_margins = fallback_printer_get_hard_margins;
  class->printer_list_papers = fallback_printer_list_papers;
380
  class->printer_get_default_page_size = fallback_printer_get_default_page_size;
381
  class->printer_get_capabilities = fallback_printer_get_capabilities;
382
  class->request_password = request_password;
383
  
384 385 386 387 388 389 390 391 392 393
  g_object_class_install_property (object_class, 
                                   PROP_STATUS,
                                   g_param_spec_int ("status",
                                                     "Status",
                                                     "The status of the print backend",
                                                     GTK_PRINT_BACKEND_STATUS_UNKNOWN,
                                                     GTK_PRINT_BACKEND_STATUS_UNAVAILABLE,
                                                     GTK_PRINT_BACKEND_STATUS_UNKNOWN,
                                                     GTK_PARAM_READWRITE)); 

Alexander Larsson's avatar
Alexander Larsson committed
394 395 396
  g_type_class_add_private (class, sizeof (GtkPrintBackendPrivate));
  
  signals[PRINTER_LIST_CHANGED] =
Matthias Clasen's avatar
Matthias Clasen committed
397
    g_signal_new (I_("printer-list-changed"),
Alexander Larsson's avatar
Alexander Larsson committed
398 399 400 401 402 403 404
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkPrintBackendClass, printer_list_changed),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
  signals[PRINTER_LIST_DONE] =
Matthias Clasen's avatar
Matthias Clasen committed
405
    g_signal_new (I_("printer-list-done"),
Alexander Larsson's avatar
Alexander Larsson committed
406 407 408 409 410 411 412
		    G_TYPE_FROM_CLASS (class),
		    G_SIGNAL_RUN_LAST,
		    G_STRUCT_OFFSET (GtkPrintBackendClass, printer_list_done),
		    NULL, NULL,
		    g_cclosure_marshal_VOID__VOID,
		    G_TYPE_NONE, 0);
  signals[PRINTER_ADDED] =
Matthias Clasen's avatar
Matthias Clasen committed
413
    g_signal_new (I_("printer-added"),
Alexander Larsson's avatar
Alexander Larsson committed
414 415 416 417 418 419 420
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkPrintBackendClass, printer_added),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GTK_TYPE_PRINTER);
  signals[PRINTER_REMOVED] =
Matthias Clasen's avatar
Matthias Clasen committed
421
    g_signal_new (I_("printer-removed"),
Alexander Larsson's avatar
Alexander Larsson committed
422 423 424 425 426 427 428
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkPrintBackendClass, printer_removed),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GTK_TYPE_PRINTER);
  signals[PRINTER_STATUS_CHANGED] =
Matthias Clasen's avatar
Matthias Clasen committed
429
    g_signal_new (I_("printer-status-changed"),
Alexander Larsson's avatar
Alexander Larsson committed
430 431 432 433 434 435
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkPrintBackendClass, printer_status_changed),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GTK_TYPE_PRINTER);
436 437 438 439 440 441
  signals[REQUEST_PASSWORD] =
    g_signal_new (I_("request-password"),
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkPrintBackendClass, request_password),
		  NULL, NULL,
442 443
		  _gtk_marshal_VOID__POINTER_POINTER_POINTER_POINTER_STRING,
		  G_TYPE_NONE, 5, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_STRING);
Alexander Larsson's avatar
Alexander Larsson committed
444 445 446 447 448 449 450
}

static void
gtk_print_backend_init (GtkPrintBackend *backend)
{
  GtkPrintBackendPrivate *priv;

451 452 453
  priv = backend->priv = G_TYPE_INSTANCE_GET_PRIVATE (backend,
                                                      GTK_TYPE_PRINT_BACKEND,
                                                      GtkPrintBackendPrivate);
Alexander Larsson's avatar
Alexander Larsson committed
454 455 456 457

  priv->printers = g_hash_table_new_full (g_str_hash, g_str_equal, 
					  (GDestroyNotify) g_free,
					  (GDestroyNotify) g_object_unref);
458 459
  priv->auth_info_required = NULL;
  priv->auth_info = NULL;
Alexander Larsson's avatar
Alexander Larsson committed
460 461 462 463 464 465 466 467 468 469 470 471
}

static void
gtk_print_backend_dispose (GObject *object)
{
  GtkPrintBackend *backend;
  GtkPrintBackendPrivate *priv;

  backend = GTK_PRINT_BACKEND (object);
  priv = backend->priv;

  /* We unref the printers in dispose, not in finalize so that
Matthias Clasen's avatar
Matthias Clasen committed
472 473
   * we can break refcount cycles with gtk_print_backend_destroy 
   */
Alexander Larsson's avatar
Alexander Larsson committed
474
  if (priv->printers)
475
    {
Alexander Larsson's avatar
Alexander Larsson committed
476 477
      g_hash_table_destroy (priv->printers);
      priv->printers = NULL;
478 479
    }

Alexander Larsson's avatar
Alexander Larsson committed
480
  backend_parent_class->dispose (object);
481 482
}

Alexander Larsson's avatar
Alexander Larsson committed
483

484 485 486 487 488 489
static void
fallback_printer_request_details (GtkPrinter *printer)
{
}

static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
490
fallback_printer_mark_conflicts (GtkPrinter          *printer,
491 492 493 494 495
				 GtkPrinterOptionSet *options)
{
  return FALSE;
}

496
static gboolean
497
fallback_printer_get_hard_margins (GtkPrinter *printer,
Matthias Clasen's avatar
Matthias Clasen committed
498 499 500 501
				   gdouble    *top,
				   gdouble    *bottom,
				   gdouble    *left,
				   gdouble    *right)
502
{
503
  return FALSE;
504 505 506 507 508 509 510 511
}

static GList *
fallback_printer_list_papers (GtkPrinter *printer)
{
  return NULL;
}

512 513 514 515 516 517
static GtkPageSetup *
fallback_printer_get_default_page_size (GtkPrinter *printer)
{
  return NULL;
}

518 519 520 521 522 523 524
static GtkPrintCapabilities
fallback_printer_get_capabilities (GtkPrinter *printer)
{
  return 0;
}


525
static void
Matthias Clasen's avatar
Matthias Clasen committed
526 527 528
printer_hash_to_sorted_active_list (const gchar  *key,
                                    gpointer      value,
                                    GList       **out_list)
529
{
Alexander Larsson's avatar
Alexander Larsson committed
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
  GtkPrinter *printer;

  printer = GTK_PRINTER (value);

  if (gtk_printer_get_name (printer) == NULL)
    return;

  if (!gtk_printer_is_active (printer))
    return;

  *out_list = g_list_insert_sorted (*out_list, value, (GCompareFunc) gtk_printer_compare);
}


void
gtk_print_backend_add_printer (GtkPrintBackend *backend,
Matthias Clasen's avatar
Matthias Clasen committed
546
			       GtkPrinter      *printer)
Alexander Larsson's avatar
Alexander Larsson committed
547 548
{
  GtkPrintBackendPrivate *priv;
549
  
Alexander Larsson's avatar
Alexander Larsson committed
550
  g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));
551

Alexander Larsson's avatar
Alexander Larsson committed
552
  priv = backend->priv;
553

Alexander Larsson's avatar
Alexander Larsson committed
554 555 556 557 558 559 560 561 562 563
  if (!priv->printers)
    return;
  
  g_hash_table_insert (priv->printers,
		       g_strdup (gtk_printer_get_name (printer)), 
		       g_object_ref (printer));
}

void
gtk_print_backend_remove_printer (GtkPrintBackend *backend,
Matthias Clasen's avatar
Matthias Clasen committed
564
				  GtkPrinter      *printer)
Alexander Larsson's avatar
Alexander Larsson committed
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
{
  GtkPrintBackendPrivate *priv;
  
  g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));
  priv = backend->priv;

  if (!priv->printers)
    return;
  
  g_hash_table_remove (priv->printers,
		       gtk_printer_get_name (printer));
}

void
gtk_print_backend_set_list_done (GtkPrintBackend *backend)
{
  if (!backend->priv->printer_list_done)
    {
      backend->priv->printer_list_done = TRUE;
      g_signal_emit (backend, signals[PRINTER_LIST_DONE], 0);
585 586 587
    }
}

Alexander Larsson's avatar
Alexander Larsson committed
588

589 590 591
/**
 * gtk_print_backend_get_printer_list:
 *
592 593
 * Returns the current list of printers.
 *
594
 * Return value: (element-type GtkPrinter) (transfer container):
595 596
 *   A list of #GtkPrinter objects. The list should be freed
 *   with g_list_free().
597
 */
598
GList *
Alexander Larsson's avatar
Alexander Larsson committed
599
gtk_print_backend_get_printer_list (GtkPrintBackend *backend)
600
{
Alexander Larsson's avatar
Alexander Larsson committed
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
  GtkPrintBackendPrivate *priv;
  GList *result;
  
  g_return_val_if_fail (GTK_IS_PRINT_BACKEND (backend), NULL);

  priv = backend->priv;

  result = NULL;
  if (priv->printers != NULL)
    g_hash_table_foreach (priv->printers,
                          (GHFunc) printer_hash_to_sorted_active_list,
                          &result);

  if (!priv->printer_list_requested && priv->printers != NULL)
    {
      if (GTK_PRINT_BACKEND_GET_CLASS (backend)->request_printer_list)
	GTK_PRINT_BACKEND_GET_CLASS (backend)->request_printer_list (backend);
      priv->printer_list_requested = TRUE;
    }
620

Matthias Clasen's avatar
Matthias Clasen committed
621
  return result;
Alexander Larsson's avatar
Alexander Larsson committed
622
}
623

Alexander Larsson's avatar
Alexander Larsson committed
624 625 626 627
gboolean
gtk_print_backend_printer_list_is_done (GtkPrintBackend *print_backend)
{
  g_return_val_if_fail (GTK_IS_PRINT_BACKEND (print_backend), TRUE);
628

Alexander Larsson's avatar
Alexander Larsson committed
629
  return print_backend->priv->printer_list_done;
630 631 632
}

GtkPrinter *
Alexander Larsson's avatar
Alexander Larsson committed
633
gtk_print_backend_find_printer (GtkPrintBackend *backend,
Matthias Clasen's avatar
Matthias Clasen committed
634
                                const gchar     *printer_name)
635
{
Alexander Larsson's avatar
Alexander Larsson committed
636 637 638 639 640 641
  GtkPrintBackendPrivate *priv;
  GtkPrinter *printer;
  
  g_return_val_if_fail (GTK_IS_PRINT_BACKEND (backend), NULL);

  priv = backend->priv;
642

Alexander Larsson's avatar
Alexander Larsson committed
643 644 645 646
  if (priv->printers)
    printer = g_hash_table_lookup (priv->printers, printer_name);
  else
    printer = NULL;
647

Alexander Larsson's avatar
Alexander Larsson committed
648
  return printer;  
649 650 651
}

void
Matthias Clasen's avatar
Matthias Clasen committed
652 653
gtk_print_backend_print_stream (GtkPrintBackend        *backend,
                                GtkPrintJob            *job,
654
                                GIOChannel             *data_io,
655
                                GtkPrintJobCompleteFunc callback,
Matthias Clasen's avatar
Matthias Clasen committed
656
                                gpointer                user_data,
657
				GDestroyNotify          dnotify)
658
{
Alexander Larsson's avatar
Alexander Larsson committed
659 660 661 662
  g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));

  GTK_PRINT_BACKEND_GET_CLASS (backend)->print_stream (backend,
						       job,
663
						       data_io,
Alexander Larsson's avatar
Alexander Larsson committed
664 665
						       callback,
						       user_data,
666
						       dnotify);
Alexander Larsson's avatar
Alexander Larsson committed
667 668
}

669
void 
670 671 672
gtk_print_backend_set_password (GtkPrintBackend  *backend,
                                gchar           **auth_info_required,
                                gchar           **auth_info)
673 674 675 676
{
  g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));

  if (GTK_PRINT_BACKEND_GET_CLASS (backend)->set_password)
677
    GTK_PRINT_BACKEND_GET_CLASS (backend)->set_password (backend, auth_info_required, auth_info);
678 679 680
}

static void
681 682
store_entry (GtkEntry  *entry,
             gpointer   user_data)
683
{
684
  gchar **data = (gchar **) user_data;
685

686
  if (*data != NULL)
687
    {
688 689
      memset (*data, 0, strlen (*data));
      g_free (*data);
690 691
    }

692
  *data = g_strdup (gtk_entry_get_text (entry));
693 694 695 696 697 698 699 700
}

static void
password_dialog_response (GtkWidget       *dialog,
                          gint             response_id,
                          GtkPrintBackend *backend)
{
  GtkPrintBackendPrivate *priv = backend->priv;
701
  gint i;
702 703

  if (response_id == GTK_RESPONSE_OK)
704
    gtk_print_backend_set_password (backend, priv->auth_info_required, priv->auth_info);
705
  else
706
    gtk_print_backend_set_password (backend, priv->auth_info_required, NULL);
707

708 709 710 711 712 713 714 715 716
  for (i = 0; i < g_strv_length (priv->auth_info_required); i++)
    if (priv->auth_info[i] != NULL)
      {
        memset (priv->auth_info[i], 0, strlen (priv->auth_info[i]));
        g_free (priv->auth_info[i]);
        priv->auth_info[i] = NULL;
      }
  g_free (priv->auth_info);
  priv->auth_info = NULL;
717

718
  g_strfreev (priv->auth_info_required);
719 720 721 722 723 724 725

  gtk_widget_destroy (dialog);

  g_object_unref (backend);
}

static void
726 727 728 729 730 731
request_password (GtkPrintBackend  *backend,
                  gpointer          auth_info_required,
                  gpointer          auth_info_default,
                  gpointer          auth_info_display,
                  gpointer          auth_info_visible,
                  const gchar      *prompt)
732 733
{
  GtkPrintBackendPrivate *priv = backend->priv;
734 735
  GtkWidget *dialog, *box, *main_box, *label, *icon, *vbox, *entry;
  GtkWidget *focus = NULL;
736
  GtkWidget *content_area;
737
  gchar     *markup;
738 739 740 741 742 743 744 745 746 747
  gint       length;
  gint       i;
  gchar    **ai_required = (gchar **) auth_info_required;
  gchar    **ai_default = (gchar **) auth_info_default;
  gchar    **ai_display = (gchar **) auth_info_display;
  gboolean  *ai_visible = (gboolean *) auth_info_visible;

  priv->auth_info_required = g_strdupv (ai_required);
  length = g_strv_length (ai_required);
  priv->auth_info = g_new0 (gchar *, length);
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777

  dialog = gtk_dialog_new_with_buttons ( _("Authentication"), NULL, GTK_DIALOG_MODAL, 
                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                         GTK_STOCK_OK, GTK_RESPONSE_OK,
                                         NULL);

  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  main_box = gtk_hbox_new (FALSE, 0);

  /* Left */
  icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
  gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);
  gtk_misc_set_padding (GTK_MISC (icon), 6, 6);


  /* Right */
  vbox = gtk_vbox_new (FALSE, 0);
  gtk_widget_set_size_request (GTK_WIDGET (vbox), 320, -1);

  /* Right - 1. */
  label = gtk_label_new (NULL);
  markup = g_markup_printf_escaped ("<span weight=\"bold\" size=\"large\">%s</span>", prompt);
  gtk_label_set_markup (GTK_LABEL (label), markup);
  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
  gtk_widget_set_size_request (GTK_WIDGET (label), 320, -1);
  g_free (markup);


  /* Packing */
778 779
  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
  gtk_box_pack_start (GTK_BOX (content_area), main_box, TRUE, FALSE, 0);
780 781 782 783 784

  gtk_box_pack_start (GTK_BOX (main_box), icon, FALSE, FALSE, 6);
  gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 6);

  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 6);
785 786 787 788 789 790 791 792 793 794 795
  
  /* Right - 2. */
  for (i = 0; i < length; i++)
    {
      priv->auth_info[i] = g_strdup (ai_default[i]);
      if (ai_display[i] != NULL)
        {
          box = gtk_hbox_new (TRUE, 0);

          label = gtk_label_new (ai_display[i]);
          gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
796

797 798
          entry = gtk_entry_new ();
          focus = entry;
799

800 801
          if (ai_default[i] != NULL)
            gtk_entry_set_text (GTK_ENTRY (entry), ai_default[i]);
802

803 804
          gtk_entry_set_visibility (GTK_ENTRY (entry), ai_visible[i]);
          gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
805

806
          gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, TRUE, 6);
807

808 809
          gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box), entry, TRUE, TRUE, 0);
810

811 812 813 814
          g_signal_connect (entry, "changed",
                            G_CALLBACK (store_entry), &(priv->auth_info[i]));
        }
    }
815

816 817 818 819 820
  if (focus != NULL)
    {
      gtk_widget_grab_focus (focus);
      focus = NULL;
    }
821 822 823 824 825 826 827 828

  g_object_ref (backend);
  g_signal_connect (G_OBJECT (dialog), "response",
                    G_CALLBACK (password_dialog_response), backend);

  gtk_widget_show_all (dialog);
}

Alexander Larsson's avatar
Alexander Larsson committed
829 830 831 832
void
gtk_print_backend_destroy (GtkPrintBackend *print_backend)
{
  /* The lifecycle of print backends and printers are tied, such that
Matthias Clasen's avatar
Matthias Clasen committed
833 834 835 836 837
   * the backend owns the printers, but the printers also ref the backend.
   * This is so that if the app has a reference to a printer its backend
   * will be around. However, this results in a cycle, which we break
   * with this call, which causes the print backend to release its printers.
   */
Alexander Larsson's avatar
Alexander Larsson committed
838
  g_object_run_dispose (G_OBJECT (print_backend));
839
}