jean
/
Learning_GTK4_tree
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Learning_GTK4_tree/modules/printbackends/gtkprintbackendcpdb.c

1693 lines
61 KiB
C
Raw Permalink Normal View History

initial
2023-12-12 11:36:42 +01:00
/* GTK - The GIMP Toolkit
* gtkprintbackendcpdb.h: Default implementation of GtkPrintBackend
* for the Common Print Dialog Backends (CPDB)
* Copyright (C) 2022, 2023 TinyTrebuchet <tinytrebuchet@protonmail.com>
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <cpdb/frontend.h>
#include <gtk/gtkprivate.h>
#include "gtkprintbackendcpdb.h"
#include "gtkprintbackendutils.h"
#include <cairo.h>
#include <cairo-pdf.h>
#include <glib/gi18n-lib.h>
#include <gtkprintercpdb.h>
#define GTK_PRINT_BACKEND_CPDB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_BACKEND_CPDB, GtkPrintBackendCpdbClass))
#define GTK_IS_PRINT_BACKEND_CPDB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_BACKEND_CPDB))
#define GTK_PRINT_BACKEND_CPDB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_BACKEND_CPDB, GtkPrintBackendCpdbClass))
/*
* Multiplier for converting points to mm
*/
#define points_multiplier 2.83464567
#define _CPDB_MAX_CHUNK_SIZE 8192
static void gtk_print_backend_cpdb_finalize (GObject *object);
static void cpdb_request_printer_list (GtkPrintBackend *backend);
static void cpdb_printer_request_details (GtkPrinter *printer);
static void cpdb_acquire_details_cb (cpdb_printer_obj_t *cpdb_printer_obj,
int success,
gpointer user_data);
static GtkPrintCapabilities cpdb_printer_get_capabilities (GtkPrinter *printer);
static GtkPrinterOptionSet *cpdb_printer_get_options (GtkPrinter *printer,
GtkPrintSettings *settings,
GtkPageSetup *page_setup,
GtkPrintCapabilities capabilities);
static GtkPageSetup *cpdb_get_gtk_page_setup (cpdb_printer_obj_t *printer_obj,
const char *media);
static GList *cpdb_printer_list_papers (GtkPrinter *printer);
static GtkPageSetup *cpdb_printer_get_default_page_size (GtkPrinter *printer);
static gboolean cpdb_printer_get_hard_margins (GtkPrinter *printer,
double *top,
double *bottom,
double *left,
double *right);
static gboolean cpdb_printer_get_hard_margins_for_paper_size (GtkPrinter *printer,
GtkPaperSize *paper_size,
double *top,
double *bottom,
double *left,
double *right);
static void cpdb_printer_get_settings_from_options (GtkPrinter *printer,
GtkPrinterOptionSet *options,
GtkPrintSettings *settings);
static void cpdb_printer_prepare_for_print (GtkPrinter *printer,
GtkPrintJob *print_job,
GtkPrintSettings *settings,
GtkPageSetup *page_setup);
static void cpdb_print_cb (GtkPrintBackendCpdb *cpdb_backend,
GError *error,
gpointer user_data);
static gboolean cpdb_write (GIOChannel *source,
GIOCondition con,
gpointer user_data);
static void cpdb_print_stream (GtkPrintBackend *backend,
GtkPrintJob *job,
GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
GDestroyNotify dnotify);
static void gtk_printer_cpdb_configure_page_setup (GtkPrinter *printer,
GtkPageSetup *page_setup,
GtkPrintSettings *settings);
static void gtk_printer_cpdb_configure_settings (const char *key,
const char *value,
gpointer user_data);
static cairo_surface_t *cpdb_printer_create_cairo_surface (GtkPrinter *printer,
GtkPrintSettings *settings,
double width,
double height,
GIOChannel *cache_io);
static void cpdb_fill_gtk_option (GtkPrinterOption *gtk_option,
cpdb_option_t *cpdb_option,
cpdb_printer_obj_t *printer_obj);
static void printer_updates_callback (cpdb_frontend_obj_t *frontend_obj,
cpdb_printer_obj_t *printer_obj,
cpdb_printer_update_t change);
static void add_option_to_settings (GtkPrinterOption *option,
gpointer user_data);
static void cpdb_printer_add_hash_table (gpointer key,
gpointer value,
gpointer user_data);
static void cpdb_add_gtk_printer (GtkPrintBackend *backend,
cpdb_printer_obj_t *printer_obj);
static void cpdb_remove_gtk_printer (GtkPrintBackend *backend,
cpdb_printer_obj_t *printer_obj);
static void set_state_message (GtkPrinter *printer);
static char *cpdb_option_translation (cpdb_printer_obj_t *printer_obj,
const char *option_name);
static char *cpdb_choice_translation (cpdb_printer_obj_t *printer_obj,
const char *option_name,
const char *choice_name);
static void initialize (void);
static gchar *get_gtk_group (cpdb_printer_obj_t *printer_obj,
const char *group_name);
/*
* List of locales for text translation
*/
static const gchar* const* locales = NULL;
/*
* Mark the options which have already been displayed in other tabs,
* and exclude them from the "Advanced" tab, while getting printer options
*/
static GHashTable *already_used_options = NULL;
struct _GtkPrintBackendCpdbClass
{
GtkPrintBackendClass parent_class;
};
struct _GtkPrintBackendCpdb
{
GtkPrintBackend parent_instance;
cpdb_frontend_obj_t *frontend_obj;
};
typedef struct {
GtkPrintBackend *backend;
GtkPrintJobCompleteFunc callback;
GtkPrintJob *job;
char *path;
GIOStream *target_io_stream;
gpointer user_data;
GDestroyNotify dnotify;
} _PrintStreamData;
G_DEFINE_DYNAMIC_TYPE (GtkPrintBackendCpdb, gtk_print_backend_cpdb, GTK_TYPE_PRINT_BACKEND)
/*
* GtkPrintBackend object for currently opened print dialog
*/
static GtkPrintBackend *gtk_print_backend = NULL;
G_MODULE_EXPORT
void
g_io_module_load (GIOModule *module)
{
g_type_module_use (G_TYPE_MODULE (module));
gtk_print_backend_cpdb_register_type (G_TYPE_MODULE (module));
gtk_printer_cpdb_register_type (G_TYPE_MODULE (module));
g_io_extension_point_implement (GTK_PRINT_BACKEND_EXTENSION_POINT_NAME,
GTK_TYPE_PRINT_BACKEND_CPDB,
"cpdb",
10);
}
G_MODULE_EXPORT
void
g_io_module_unload (GIOModule *module)
{
}
G_MODULE_EXPORT
char **
g_io_module_query (void)
{
char *eps[] = {
(char *)GTK_PRINT_BACKEND_EXTENSION_POINT_NAME,
NULL
};
return g_strdupv (eps);
}
/*
* GtkPrintBackendCpdb
*/
/*
* gtk_print_backend_cpdb_new:
*
* Creates a new #GtkPrintBackendCpdb object. #GtkPrintBackendCpdb
* implements the #GtkPrintBackend interface with direct access to
* the filesystem using Unix/Linux API calls
*
* Returns: the new #GtkPrintBackendCpdb object
*/
GtkPrintBackend *
gtk_print_backend_cpdb_new (void)
{
GTK_DEBUG (PRINTING, "CPDB Backend: Creating a new CPDB print backend object");
return g_object_new (GTK_TYPE_PRINT_BACKEND_CPDB, NULL);
}
static void
gtk_print_backend_cpdb_class_init (GtkPrintBackendCpdbClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_CLASS (klass);
gobject_class->finalize = gtk_print_backend_cpdb_finalize;
backend_class->request_printer_list = cpdb_request_printer_list;
backend_class->printer_request_details = cpdb_printer_request_details;
backend_class->printer_get_capabilities = cpdb_printer_get_capabilities;
backend_class->printer_get_options = cpdb_printer_get_options;
backend_class->printer_list_papers = cpdb_printer_list_papers;
backend_class->printer_get_default_page_size = cpdb_printer_get_default_page_size;
backend_class->printer_get_hard_margins = cpdb_printer_get_hard_margins;
backend_class->printer_get_hard_margins_for_paper_size = cpdb_printer_get_hard_margins_for_paper_size;
backend_class->printer_get_settings_from_options = cpdb_printer_get_settings_from_options;
backend_class->printer_prepare_for_print = cpdb_printer_prepare_for_print;
backend_class->printer_create_cairo_surface = cpdb_printer_create_cairo_surface;
backend_class->print_stream = cpdb_print_stream;
}
static void
gtk_print_backend_cpdb_class_finalize (GtkPrintBackendCpdbClass *class)
{
}
static void
gtk_print_backend_cpdb_init (GtkPrintBackendCpdb *backend_cpdb)
{
char *tmp, *instance_name;
initialize ();
/*
* Initialize the FrontendObj with a random instance name to
* prevent conflicts with print dialogs opened from other programs
*/
tmp = random_string (4);
instance_name = g_strdup_printf ("Gtk_%s", tmp);
GTK_DEBUG (PRINTING, "Creating frontendObj for CPDB backend: %s", instance_name);
backend_cpdb->frontend_obj = cpdbGetNewFrontendObj (instance_name,
(cpdb_printer_callback) printer_updates_callback);
cpdbIgnoreLastSavedSettings (backend_cpdb->frontend_obj);
gtk_print_backend = GTK_PRINT_BACKEND (backend_cpdb);
g_free (tmp);
g_free (instance_name);
}
static void
gtk_print_backend_cpdb_finalize (GObject *object)
{
GtkPrintBackendCpdb *backend_cpdb;
GObjectClass *backend_parent_class;
GTK_DEBUG (PRINTING, "Finalizing CPDB backend object");
backend_cpdb = GTK_PRINT_BACKEND_CPDB (object);
backend_parent_class = G_OBJECT_CLASS (gtk_print_backend_cpdb_parent_class);
cpdbDeleteFrontendObj (backend_cpdb->frontend_obj);
gtk_print_backend = NULL;
backend_parent_class->finalize (object);
}
/*
* This function is responsible for displaying the printer
* list obtained from CPDB backend on the print dialog.
*/
static void
cpdb_request_printer_list (GtkPrintBackend *backend)
{
GtkPrintBackendCpdb *backend_cpdb = GTK_PRINT_BACKEND_CPDB (backend);
cpdbConnectToDBus (backend_cpdb->frontend_obj);
g_hash_table_foreach (backend_cpdb->frontend_obj->printer,
cpdb_printer_add_hash_table,
backend);
gtk_print_backend_set_list_done (backend);
}
/*
* This function is responsible for making a printer acquire all
* the details and supported options list, which need not be queried
* until the user clicks on the printer in the printer list in the dialog.
* The print dialog runs this function asynchronously and displays
* "Getting printer attributes..." as the printer status meanwhile.
* This function is needed as some printers (like temporary CUPS queue)
* can take a couple of seconds to materialize and acquire all the details,
* and it's important the dialog doesn't block during that time.
*/
static void
cpdb_printer_request_details (GtkPrinter *printer)
{
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
cpdbAcquireDetails (printer_obj, cpdb_acquire_details_cb, printer);
}
static void
cpdb_acquire_details_cb (cpdb_printer_obj_t *printer_obj,
int success,
gpointer user_data)
{
GtkPrinter *printer = GTK_PRINTER (user_data);
GtkPrintBackend *backend = gtk_printer_get_backend (printer);
gboolean accepting_jobs, paused, status_changed;
if (success == 0)
{
GTK_DEBUG (PRINTING, "Error acquiring printer details");
g_signal_emit_by_name (printer, "details-acquired", FALSE);
return;
}
accepting_jobs = cpdbIsAcceptingJobs (printer_obj);
paused = g_strcmp0 (cpdbGetState (printer_obj), "stopped") == 0;
status_changed = paused ^ gtk_printer_is_paused (printer);
gtk_printer_set_is_accepting_jobs (printer, accepting_jobs);
gtk_printer_set_is_paused (printer, paused);
set_state_message (printer);
gtk_printer_set_has_details (printer, TRUE);
g_signal_emit_by_name (printer, "details-acquired", TRUE);
if (status_changed)
g_signal_emit_by_name (backend, "printer-status-changed", printer);
}
/*
* This function is responsible for specifying which features the
* print dialog should offer for the given printer.
*/
static GtkPrintCapabilities
cpdb_printer_get_capabilities (GtkPrinter *printer)
{
GtkPrintCapabilities capabilities = 0;
cpdb_option_t *cpdb_option;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_PAGE_SET);
if (cpdb_option != NULL && cpdb_option->num_supported >= 3)
capabilities |= GTK_PRINT_CAPABILITY_PAGE_SET;
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_COPIES);
if (cpdb_option != NULL &&
g_strcmp0 (cpdb_option->supported_values[0], "1") != 0 &&
g_strcmp0 (cpdb_option->supported_values[0], "1-1") != 0)
capabilities |= GTK_PRINT_CAPABILITY_COPIES;
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_COLLATE);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
capabilities |= GTK_PRINT_CAPABILITY_COLLATE;
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_PAGE_DELIVERY);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
capabilities |= GTK_PRINT_CAPABILITY_REVERSE;
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_PRINT_SCALING);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
capabilities |= GTK_PRINT_CAPABILITY_SCALE;
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_NUMBER_UP);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
capabilities |= GTK_PRINT_CAPABILITY_NUMBER_UP;
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_NUMBER_UP_LAYOUT);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
capabilities |= GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT;
return capabilities;
}
/*
* This function is responsible for getting all the options
* that the printer supports and display them into the
* GUI template of GTK+ print dialog box.
* The backend should obtain whatever options it supports,
* from either its print server or PPDs.
*/
static GtkPrinterOptionSet *
cpdb_printer_get_options (GtkPrinter *printer,
GtkPrintSettings *settings,
GtkPageSetup *page_setup,
GtkPrintCapabilities capabilities)
{
char *option_name;
char *display_name;
gpointer key, value;
GHashTableIter iter;
GtkPrinterCpdb *printer_cpdb;
cpdb_printer_obj_t *printer_obj;
cpdb_option_t *cpdb_option;
GtkPrinterOption *gtk_option;
GtkPrinterOptionSet *gtk_option_set;
gtk_option_set = gtk_printer_option_set_new ();
printer_cpdb = GTK_PRINTER_CPDB (printer);
printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
/** Page-Setup **/
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_NUMBER_UP);
if ((capabilities & GTK_PRINT_CAPABILITY_NUMBER_UP) && cpdb_option != NULL)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-n-up",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_NUMBER_UP_LAYOUT);
if ((capabilities & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT) && cpdb_option != NULL)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-n-up-layout",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_SIDES);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-duplex",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_MEDIA_SOURCE);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-paper-source",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_MEDIA_TYPE);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-paper-type",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_OUTPUT_BIN);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-output-tray",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
/** Jobs **/
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_JOB_PRIORITY);
if (cpdb_option != NULL)
{
/* job-priority is represented as a number from 1-100 */
const char *prio[] = {"100", "80", "50", "30"};
const char *prio_display[] = {N_("Urgent"), N_("High"), N_("Medium"), N_("Low")};
for (int i = 0; i < G_N_ELEMENTS(prio_display); i++)
prio_display[i] = _(prio_display[i]);
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-job-prio",
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
gtk_printer_option_choices_from_array (gtk_option,
G_N_ELEMENTS (prio),
prio, prio_display);
gtk_printer_option_set (gtk_option, "50");
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_JOB_SHEETS);
if (cpdb_option != NULL && cpdb_option->num_supported > 1)
{
gtk_option = gtk_printer_option_new ("gtk-cover-before",
C_("printer option", "Before"),
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
gtk_option = gtk_printer_option_new ("gtk-cover-after",
C_("printer option", "After"),
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
cpdb_option = cpdbGetOption (printer_obj, CPDB_OPTION_BILLING_INFO);
if (cpdb_option != NULL)
{
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new ("gtk-billing-info",
display_name,
GTK_PRINTER_OPTION_TYPE_STRING);
gtk_printer_option_set (gtk_option, "");
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
const char *print_at[] = {"now", "at", "on-hold"};
gtk_option = gtk_printer_option_new ("gtk-print-time",
_("Print at"),
GTK_PRINTER_OPTION_TYPE_PICKONE);
gtk_printer_option_choices_from_array (gtk_option,
G_N_ELEMENTS (print_at),
print_at, print_at);
gtk_printer_option_set (gtk_option, "now");
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
gtk_option = gtk_printer_option_new ("gtk-print-time-text",
_("Print at time"),
GTK_PRINTER_OPTION_TYPE_STRING);
gtk_printer_option_set (gtk_option, "");
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
/** Other options **/
g_hash_table_iter_init (&iter, printer_obj->options->table);
while (g_hash_table_iter_next (&iter, &key, &value))
{
option_name = (char *) key;
if (g_hash_table_contains (already_used_options, option_name))
continue;
cpdb_option = (cpdb_option_t *) value;
if (cpdb_option->num_supported <= 1)
continue;
display_name = cpdb_option_translation (printer_obj,
cpdb_option->option_name);
gtk_option = gtk_printer_option_new (cpdb_option->option_name,
display_name,
GTK_PRINTER_OPTION_TYPE_PICKONE);
cpdb_fill_gtk_option (gtk_option, cpdb_option, printer_obj);
gtk_option->group = get_gtk_group (printer_obj,
cpdb_option->group_name);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
/*
* Check if borderles printing is supported
*/
gboolean borderless = TRUE;
const char *attrs[] = {CPDB_OPTION_MARGIN_TOP, CPDB_OPTION_MARGIN_BOTTOM,
CPDB_OPTION_MARGIN_LEFT, CPDB_OPTION_MARGIN_RIGHT};
for (int i = 0; i < 4; i++)
{
cpdb_option = cpdbGetOption (printer_obj, (gchar *) attrs[i]);
gboolean found = FALSE;
if (cpdb_option != NULL)
{
for (int j = 0; j < cpdb_option->num_supported; j++)
{
if (g_strcmp0 (cpdb_option->supported_values[j], "0") == 0)
{
found = TRUE;
break;
}
}
}
if (!found)
{
borderless = FALSE;
break;
}
}
if (borderless)
{
gtk_option = gtk_printer_option_new ("borderless",
C_("print option", "Borderless"),
GTK_PRINTER_OPTION_TYPE_BOOLEAN);
gtk_option->group = get_gtk_group (printer_obj, CPDB_GROUP_MEDIA);
gtk_printer_option_set_add (gtk_option_set, gtk_option);
g_object_unref (gtk_option);
}
return gtk_option_set;
}
/*
* Helper function to create GtkPageSetup from given "media" size
*/
static GtkPageSetup *
cpdb_get_gtk_page_setup (cpdb_printer_obj_t *printer_obj,
const char *media)
{
char *display_name;
int width, height, num_margins, ok;
cpdb_margin_t *margins;
GtkPaperSize *paper_size;
GtkPageSetup *page_setup;
page_setup = gtk_page_setup_new ();
display_name = cpdb_choice_translation (printer_obj,
CPDB_OPTION_MEDIA,
media);
ok = cpdbGetMediaSize (printer_obj,
media,
&width,
&height);
if (ok == 1)
{
paper_size = gtk_paper_size_new_custom (media,
display_name,
width / 100.0,
height / 100.0,
GTK_UNIT_MM);
gtk_page_setup_set_paper_size (page_setup, paper_size);
gtk_paper_size_free (paper_size);
}
num_margins = cpdbGetMediaMargins (printer_obj,
media,
&margins);
if (num_margins > 0)
{
gtk_page_setup_set_left_margin (page_setup,
margins[0].left / 100.0,
GTK_UNIT_MM);
gtk_page_setup_set_right_margin (page_setup,
margins[0].right / 100.0,
GTK_UNIT_MM);
gtk_page_setup_set_top_margin (page_setup,
margins[0].top / 100.0,
GTK_UNIT_MM);
gtk_page_setup_set_bottom_margin (page_setup,
margins[0].bottom / 100.0,
GTK_UNIT_MM);
}
return page_setup;
}
/*
* This function is responsible for listing all the page sizes supported by a printer
*/
static GList *
cpdb_printer_list_papers (GtkPrinter *printer)
{
cpdb_option_t *media;
GList *result = NULL;
GtkPageSetup *page_setup;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
media = cpdbGetOption (printer_obj, CPDB_OPTION_MEDIA);
if (media == NULL)
return NULL;
for (int i = 0; i < media->num_supported; i++)
{
if (g_str_has_prefix (media->supported_values[i], "custom_min") ||
g_str_has_prefix (media->supported_values[i], "custom_max"))
continue;
page_setup = cpdb_get_gtk_page_setup (printer_obj,
media->supported_values[i]);
result = g_list_prepend (result, page_setup);
}
result = g_list_reverse (result);
return result;
}
/*
* This function is responsible for getting the default page size for a printer
*/
static GtkPageSetup *
cpdb_printer_get_default_page_size (GtkPrinter *printer)
{
char *default_media;
GtkPageSetup *page_setup = NULL;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
default_media = cpdbGetDefault (printer_obj, CPDB_OPTION_MEDIA);
if (default_media != NULL)
{
page_setup = cpdb_get_gtk_page_setup (printer_obj, default_media);
}
return page_setup;
}
/*
* This function is responsible for getting the
* default page size margins supported by a printer
*/
static gboolean
cpdb_printer_get_hard_margins (GtkPrinter *printer,
double *top,
double *bottom,
double *left,
double *right)
{
char *left_margin, *right_margin, *top_margin, *bottom_margin;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
top_margin = cpdbGetDefault (printer_obj, CPDB_OPTION_MARGIN_TOP);
left_margin = cpdbGetDefault (printer_obj, CPDB_OPTION_MARGIN_LEFT);
right_margin = cpdbGetDefault (printer_obj, CPDB_OPTION_MARGIN_RIGHT);
bottom_margin = cpdbGetDefault (printer_obj, CPDB_OPTION_MARGIN_BOTTOM);
if (top_margin != NULL &&
left_margin != NULL &&
right_margin != NULL &&
bottom_margin != NULL)
{
*top = g_ascii_strtod (top_margin, NULL) * points_multiplier / 100.0;
*left = g_ascii_strtod (left_margin, NULL) * points_multiplier / 100.0;
*right = g_ascii_strtod (right_margin, NULL) * points_multiplier / 100.0;
*bottom = g_ascii_strtod (bottom_margin, NULL) * points_multiplier / 100.0;
return TRUE;
}
return FALSE;
}
/*
* This function is responsible for getting the
* default page size margins for give paper size
*/
static gboolean
cpdb_printer_get_hard_margins_for_paper_size (GtkPrinter *printer,
GtkPaperSize *paper_size,
double *top,
double *bottom,
double *left,
double *right)
{
int num_margins;
const char *media;
cpdb_margin_t *margins;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
media = gtk_paper_size_get_name (paper_size);
if (media != NULL)
{
num_margins = cpdbGetMediaMargins (printer_obj, media, &margins);
if (num_margins > 0)
{
*top = margins[0].top * points_multiplier / 100.0;
*left = margins[0].left * points_multiplier / 100.0;
*right = margins[0].right * points_multiplier / 100.0;
*bottom = margins[0].bottom * points_multiplier / 100.0;
return TRUE;
}
}
return FALSE;
}
/*
* @user_data: GtkPrintSettings
*/
static void
add_option_to_settings (GtkPrinterOption *option,
gpointer user_data)
{
GtkPrintSettings *settings = (GtkPrintSettings *) user_data;
gtk_print_settings_set (settings, option->name, option->value);
}
/*
* This method is invoked when the print button on the print dialog is pressed.
* It's responsible for gathering all the settings from the print dialog that the
* user may have selected before pressing the print button.
*/
static void
cpdb_printer_get_settings_from_options (GtkPrinter *printer,
GtkPrinterOptionSet *options,
GtkPrintSettings *settings)
{
char *value;
GtkPrinterOption *option, *cover_before, *cover_after;
option = gtk_printer_option_set_lookup (options, "gtk-n-up");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_NUMBER_UP,
option->value);
}
option = gtk_printer_option_set_lookup (options, "gtk-n-up-layout");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_NUMBER_UP_LAYOUT,
option->value);
}
option = gtk_printer_option_set_lookup (options, "gtk-duplex");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_SIDES,
option->value);
}
option = gtk_printer_option_set_lookup (options, "gtk-paper-source");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_MEDIA_SOURCE,
option->value);
}
option = gtk_printer_option_set_lookup (options, "gtk-paper-type");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_MEDIA_TYPE,
option->value);
}
option = gtk_printer_option_set_lookup (options, "gtk-output-tray");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_OUTPUT_BIN,
option->value);
}
option = gtk_printer_option_set_lookup (options, "gtk-job-prio");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_JOB_PRIORITY,
option->value);
}
cover_before = gtk_printer_option_set_lookup (options, "gtk-cover-before");
cover_after = gtk_printer_option_set_lookup (options, "gtk-cover-after");
if (cover_before != NULL && cover_after != NULL)
{
value = g_strdup_printf ("%s,%s",
cover_before->value,
cover_after->value);
gtk_print_settings_set (settings,
CPDB_OPTION_JOB_SHEETS,
value);
g_free (value);
}
option = gtk_printer_option_set_lookup (options, "gtk-billing-info");
if (option != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_BILLING_INFO,
option->value);
}
char *print_at = NULL;
option = gtk_printer_option_set_lookup (options, "gtk-print-time");
if (option != NULL)
print_at = g_strdup (option->value);
char *print_at_time = NULL;
option = gtk_printer_option_set_lookup (options, "gtk-print-time-text");
if (option != NULL)
print_at_time = g_strdup (option->value);
if (print_at != NULL && print_at_time != NULL)
{
if (g_strcmp0 (print_at, "at") == 0)
{
char *utc_time = NULL;
utc_time = localtime_to_utctime (print_at_time);
if (utc_time != NULL)
{
gtk_print_settings_set (settings,
CPDB_OPTION_JOB_HOLD_UNTIL,
utc_time);
g_free (utc_time);
}
else
gtk_print_settings_set (settings,
CPDB_OPTION_JOB_HOLD_UNTIL,
print_at_time);
}
else if (g_strcmp0 (print_at, "on-hold") == 0)
gtk_print_settings_set (settings,
CPDB_OPTION_JOB_HOLD_UNTIL,
CPDB_JOB_HOLD_INDEFINITE);
}
if (print_at != NULL)
g_free (print_at);
if (print_at_time != NULL)
g_free (print_at_time);
gtk_printer_option_set_foreach (options, add_option_to_settings, settings);
}
static cairo_status_t
_cairo_write (void *closure,
const unsigned char *data,
unsigned int length)
{
GIOChannel *io = (GIOChannel *)closure;
gsize written;
GError *error;
error = NULL;
GTK_DEBUG (PRINTING, "CPDB Backend: Writing %i byte chunk to temp file", length);
while (length > 0)
{
g_io_channel_write_chars (io, (const char *)data, length, &written, &error);
if (error != NULL)
{
GTK_DEBUG (PRINTING, "CPDB Backend: Error writing to temp file, %s", error->message);
g_error_free (error);
return CAIRO_STATUS_WRITE_ERROR;
}
GTK_DEBUG (PRINTING, "CPDB Backend: Wrote %" G_GSIZE_FORMAT " bytes to temp file\n", written);
data += written;
length -= written;
}
return CAIRO_STATUS_SUCCESS;
}
/*
* called after prepare_for_print ()
*/
static cairo_surface_t *
cpdb_printer_create_cairo_surface (GtkPrinter *printer,
GtkPrintSettings *settings,
double width,
double height,
GIOChannel *cache_io)
{
cairo_surface_t *surface;
surface = cairo_pdf_surface_create_for_stream (_cairo_write, cache_io, width, height);
cairo_surface_set_fallback_resolution (surface,
2.0 * gtk_print_settings_get_printer_lpi (settings),
2.0 * gtk_print_settings_get_printer_lpi (settings));
return surface;
}
static void
gtk_printer_cpdb_configure_settings (const char *key,
const char *value,
gpointer user_data)
{
const char *option_name, *option_value;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (user_data);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
option_name = key;
option_value = value;
if (g_str_has_prefix (option_name, "gtk") ||
g_strcmp0 (option_value, "") == 0)
{
return;
}
cpdbAddSettingToPrinter (printer_obj, option_name, option_value);
}
static void
gtk_printer_cpdb_configure_page_setup (GtkPrinter *printer,
GtkPageSetup *page_setup,
GtkPrintSettings *settings)
{
char *value, *orientation, *default_orientation;
const char *borderless;
double width, height, left, top, right, bottom;
GtkPageOrientation page_orientation;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM) * 100.0;
height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM) * 100.0;
left = gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM) * 100.0;
right = gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM) * 100.0;
top = gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM) * 100.0;
bottom = gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM) * 100.0;
borderless = gtk_print_settings_get (settings, "borderless");
if (g_ascii_strcasecmp (borderless, "True") == 0)
left = right = top = bottom = 0;
value = g_strdup_printf ("{media-size={x-dimension=%.0f y-dimension=%.0f} "
"media-bottom-margin=%.0f "
"media-left-margin=%.0f "
"media-right-margin=%.0f "
"media-top-margin=%.0f}",
width, height, bottom, left, right, top);
gtk_print_settings_set (settings, CPDB_OPTION_MEDIA_COL, value);
g_free (value);
page_orientation = gtk_page_setup_get_orientation (page_setup);
default_orientation = cpdbGetDefault (printer_obj, CPDB_OPTION_ORIENTATION);
switch (page_orientation)
{
case GTK_PAGE_ORIENTATION_PORTRAIT:
orientation = g_strdup_printf (CPDB_ORIENTATION_PORTRAIT);
break;
case GTK_PAGE_ORIENTATION_LANDSCAPE:
orientation = g_strdup_printf (CPDB_ORIENTATION_LANDSCAPE);
break;
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
orientation = g_strdup_printf (CPDB_ORIENTATION_RLANDSCAPE);
break;
case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
orientation = g_strdup_printf (CPDB_ORIENTATION_RPORTRAIT);
break;
default:
orientation = default_orientation;
}
gtk_print_settings_set (settings, CPDB_OPTION_ORIENTATION, orientation);
g_free (orientation);
}
static void
cpdb_printer_prepare_for_print (GtkPrinter *printer,
GtkPrintJob *print_job,
GtkPrintSettings *settings,
GtkPageSetup *page_setup)
{
int n_ranges;
double scale;
GtkPrintPages pages;
GtkPageRange *ranges;
GtkPageSet page_set;
GtkPrintCapabilities capabilities;
capabilities = cpdb_printer_get_capabilities (printer);
pages = gtk_print_settings_get_print_pages (settings);
gtk_print_job_set_pages (print_job, pages);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_PRINT_PAGES);
if (pages == GTK_PRINT_PAGES_RANGES)
ranges = gtk_print_settings_get_page_ranges (settings, &n_ranges);
else
{
ranges = NULL;
n_ranges = 0;
}
gtk_print_job_set_page_ranges (print_job, ranges, n_ranges);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
scale = gtk_print_settings_get_scale (settings);
if (scale != 100.0)
gtk_print_job_set_scale (print_job, scale / 100.0);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_SCALE);
if (capabilities & GTK_PRINT_CAPABILITY_COLLATE)
{
if (gtk_print_settings_get_collate (settings))
gtk_print_settings_set (settings,
CPDB_OPTION_COLLATE,
CPDB_COLLATE_ENABLED);
}
gtk_print_job_set_collate (print_job, FALSE);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_COLLATE);
if (capabilities & GTK_PRINT_CAPABILITY_REVERSE)
{
if (gtk_print_settings_get_reverse (settings))
gtk_print_settings_set (settings,
CPDB_OPTION_PAGE_DELIVERY,
CPDB_PAGE_DELIVERY_REVERSE);
}
gtk_print_job_set_reverse (print_job, FALSE);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_REVERSE);
if (capabilities & GTK_PRINT_CAPABILITY_COPIES)
{
int copies = gtk_print_settings_get_n_copies (settings);
if (copies > 1)
{
char *value = g_strdup_printf ("%d", copies);
gtk_print_settings_set (settings, CPDB_OPTION_COPIES, value);
g_free (value);
}
}
gtk_print_job_set_num_copies (print_job, 1);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_N_COPIES);
page_set = gtk_print_settings_get_page_set (settings);
switch (page_set)
{
case GTK_PAGE_SET_EVEN :
gtk_print_settings_set (settings,
CPDB_OPTION_PAGE_SET,
CPDB_PAGE_SET_EVEN);
break;
case GTK_PAGE_SET_ODD :
gtk_print_settings_set (settings,
CPDB_OPTION_PAGE_SET,
CPDB_PAGE_SET_ODD);
break;
case GTK_PAGE_SET_ALL :
default :
gtk_print_settings_set (settings,
CPDB_OPTION_PAGE_SET,
CPDB_PAGE_SET_ALL);
}
gtk_print_job_set_page_set (print_job, GTK_PAGE_SET_ALL);
gtk_print_settings_unset (settings, GTK_PRINT_SETTINGS_PAGE_SET);
gtk_print_settings_unset (settings, "printer");
gtk_printer_cpdb_configure_page_setup (printer, page_setup, settings);
gtk_print_settings_unset (settings, "borderless");
gtk_print_settings_foreach (settings,
gtk_printer_cpdb_configure_settings,
printer);
}
static void
cpdb_print_cb (GtkPrintBackendCpdb *backend_cpdb,
GError *error,
gpointer user_data)
{;
GtkPrinterCpdb *printer_cpdb;
cpdb_printer_obj_t *printer_obj;
_PrintStreamData *ps = (_PrintStreamData *) user_data;
if (ps->target_io_stream != NULL)
g_io_stream_close (G_IO_STREAM (ps->target_io_stream), NULL, NULL);
if (ps->callback)
ps->callback (ps->job, ps->user_data, error);
if (ps->dnotify)
ps->dnotify (ps->user_data);
gtk_print_job_set_status (ps->job,
error ? GTK_PRINT_STATUS_FINISHED_ABORTED
: GTK_PRINT_STATUS_FINISHED);
if (!error)
{
printer_cpdb = GTK_PRINTER_CPDB (gtk_print_job_get_printer (ps->job));
printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
GTK_DEBUG (PRINTING, "CPDB Backend: Sending file to CPDB for printing - %s\n", ps->path);
cpdbPrintFile (printer_obj, ps->path);
g_free (ps->path);
}
if (ps->job)
g_object_unref (ps->job);
g_free (ps);
}
static gboolean
cpdb_write (GIOChannel *source,
GIOCondition con,
gpointer user_data)
{
char buf[_CPDB_MAX_CHUNK_SIZE];
gsize bytes_read;
GError *error;
GIOStatus status;
GOutputStream *out_stream;
_PrintStreamData *ps = (_PrintStreamData *) user_data;
error = NULL;
status = g_io_channel_read_chars (source,
buf,
_CPDB_MAX_CHUNK_SIZE,
&bytes_read,
&error);
if (status != G_IO_STATUS_ERROR)
{
gsize bytes_written;
out_stream = g_io_stream_get_output_stream (ps->target_io_stream);
g_output_stream_write_all (out_stream,
buf,
bytes_read,
&bytes_written,
NULL,
&error);
}
if (error != NULL || status == G_IO_STATUS_EOF)
{
cpdb_print_cb (GTK_PRINT_BACKEND_CPDB (ps->backend),
error,
user_data);
if (error != NULL)
{
GTK_DEBUG (PRINTING, "CPDB Backend: Error writing to file - %s\n", error->message);
g_error_free (error);
}
return FALSE;
}
GTK_DEBUG (PRINTING, "CPDB Backend: Writing %" G_GSIZE_FORMAT " byte chunk to cpdb pipe\n", bytes_read);
return TRUE;
}
static void
cpdb_print_stream (GtkPrintBackend *backend,
GtkPrintJob *job,
GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
GDestroyNotify dnotify)
{
GError *error;
GFile *file;
_PrintStreamData *ps;
GFileIOStream *iostream;
ps = g_new0 (_PrintStreamData, 1);
ps->callback = callback;
ps->user_data = user_data;
ps->dnotify = dnotify;
ps->job = g_object_ref (job);
ps->backend = backend;
error = NULL;
file = g_file_new_tmp (NULL, &iostream, &error);
if (file == NULL)
goto error;
ps->path = g_file_get_path (file);
ps->target_io_stream = G_IO_STREAM (iostream);
g_object_unref (file);
error:
if (error != NULL)
{
GTK_DEBUG (PRINTING, "Error: %s\n", error->message);
cpdb_print_cb (GTK_PRINT_BACKEND_CPDB (backend), error, ps);
g_error_free (error);
return;
}
g_io_add_watch (data_io,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP,
(GIOFunc) cpdb_write,
ps);
}
/*
* Reflect changes in printers to the GTK print dialog.
*/
static void
printer_updates_callback (cpdb_frontend_obj_t *frontend_obj,
cpdb_printer_obj_t *printer_obj,
cpdb_printer_update_t change)
{
GtkPrinter *printer;
if (gtk_print_backend == NULL)
return;
switch (change)
{
case CPDB_CHANGE_PRINTER_ADDED:
cpdb_add_gtk_printer (gtk_print_backend, printer_obj);
break;
case CPDB_CHANGE_PRINTER_REMOVED:
cpdb_remove_gtk_printer (gtk_print_backend, printer_obj);
cpdbDeletePrinterObj (printer_obj);
break;
case CPDB_CHANGE_PRINTER_STATE_CHANGED:
printer = gtk_print_backend_find_printer (gtk_print_backend, printer_obj->name);
set_state_message (printer);
g_signal_emit_by_name (gtk_print_backend, "printer-status-changed", printer);
break;
default:
break;
}
}
/*
* @key: printer name
* @value: cpdb_printer_obj_t
* @user_data: GtkPrintBackend
*/
static void
cpdb_printer_add_hash_table (gpointer key,
gpointer value,
gpointer user_data)
{
cpdb_add_gtk_printer (user_data, value);
}
/*
* Adds given printer to given GtkPrintBackend
*/
static void
cpdb_add_gtk_printer (GtkPrintBackend *backend,
cpdb_printer_obj_t *printer_obj)
{
GtkPrinter *printer;
GtkPrinterCpdb *printer_cpdb;
cpdb_printer_obj_t *default_printer;
GtkPrintBackendCpdb *backend_cpdb = GTK_PRINT_BACKEND_CPDB (backend);
/*
* Ignore printers from FILE backend,
* since we are using "Print To File" GTK print backend.
*/
if (g_strcmp0 (printer_obj->backend_name, "FILE") == 0)
return;
printer_cpdb = g_object_new (GTK_TYPE_PRINTER_CPDB,
"name", printer_obj->name,
"backend", backend,
NULL);
gtk_printer_cpdb_set_printer_obj (printer_cpdb, printer_obj);
printer = GTK_PRINTER (printer_cpdb);
gtk_printer_set_icon_name (printer, "printer");
gtk_printer_set_location (printer, printer_obj->location);
gtk_printer_set_description (printer, printer_obj->info);
gtk_printer_set_accepts_pdf (printer, TRUE);
gtk_printer_set_accepts_ps (printer, TRUE);
gtk_printer_set_is_active (printer, TRUE);
gtk_printer_set_has_details (printer, FALSE);
default_printer = cpdbGetDefaultPrinter (backend_cpdb->frontend_obj);
if (default_printer == printer_obj)
gtk_printer_set_is_default (printer, TRUE);
/*
* If printer state is not available, wait till cpdbAcquireDetails ()
* is called when the printer is clicked on in the print dialog
*/
if (g_strcmp0 (printer_obj->state, "NA") == 0)
{
gtk_printer_set_is_accepting_jobs (printer, TRUE);
gtk_printer_set_is_paused (printer, FALSE);
gtk_printer_set_state_message (printer, "");
}
else
{
gtk_printer_set_is_accepting_jobs (printer,
cpdbIsAcceptingJobs (printer_obj));
gtk_printer_set_is_paused (printer,
g_strcmp0 (cpdbGetState (printer_obj),
CPDB_STATE_STOPPED) == 0);
set_state_message (printer);
}
gtk_print_backend_add_printer (backend, printer);
if (gtk_print_backend_printer_list_is_done (backend))
{
g_signal_emit_by_name (backend, "printer-added", printer);
g_signal_emit_by_name (backend, "printer-list-changed");
}
g_object_unref (printer);
}
/*
* Removes given printer from given GtkPrintBackend
*/
static void
cpdb_remove_gtk_printer (GtkPrintBackend *backend,
cpdb_printer_obj_t *printer_obj)
{
GtkPrinter *printer = gtk_print_backend_find_printer (backend, printer_obj->name);
gtk_print_backend_remove_printer (backend, printer);
g_signal_emit_by_name (backend, "printer-removed", printer);
g_signal_emit_by_name (backend, "printer-list-changed");
}
/*
* Sets printer status
*/
static void
set_state_message (GtkPrinter *printer)
{
gboolean stopped, accepting_jobs;
GtkPrinterCpdb *printer_cpdb = GTK_PRINTER_CPDB (printer);
cpdb_printer_obj_t *printer_obj = gtk_printer_cpdb_get_printer_obj (printer_cpdb);
stopped = g_strcmp0 (cpdbGetState (printer_obj), CPDB_STATE_STOPPED) == 0;
accepting_jobs = cpdbIsAcceptingJobs (printer_obj);
if (stopped && !accepting_jobs)
/* Translators: this is a printer status. */
gtk_printer_set_state_message (printer, _("Paused; Rejecting Jobs"));
else if (stopped && accepting_jobs)
/* Translators: this is a printer status. */
gtk_printer_set_state_message (printer, _("Paused"));
else if (!accepting_jobs)
/* Translators: this is a printer status. */
gtk_printer_set_state_message (printer, _("Rejecting Jobs"));
else
gtk_printer_set_state_message (printer, "");
}
/*
* Fills option choices & sets default in gtk_option from cpdb_option
*/
static void
cpdb_fill_gtk_option (GtkPrinterOption *gtk_option,
cpdb_option_t *cpdb_option,
cpdb_printer_obj_t *printer_obj)
{
char *display_val;
char **default_val;
gtk_printer_option_allocate_choices (gtk_option, cpdb_option->num_supported);
for (int i = 0; i < cpdb_option->num_supported; i++)
{
gtk_option->choices[i] = g_strdup (cpdb_option->supported_values[i]);
display_val = cpdb_choice_translation (printer_obj,
cpdb_option->option_name,
cpdb_option->supported_values[i]);
gtk_option->choices_display[i] = g_strdup (display_val);
}
if (g_strcmp0 (cpdb_option->default_value, "NA") != 0)
{
if (g_strcmp0 (cpdb_option->option_name, CPDB_OPTION_JOB_SHEETS) == 0)
{
default_val = g_strsplit (cpdb_option->default_value, ",", 2);
if (g_strcmp0 (gtk_option->name, "gtk-cover-before") == 0)
gtk_printer_option_set (gtk_option, default_val[0]);
else if (g_strcmp0 (gtk_option->name, "gtk-cover-after") == 0)
gtk_printer_option_set (gtk_option, default_val[1]);
}
else
{
gtk_printer_option_set (gtk_option, g_strdup (cpdb_option->default_value));
}
}
}
/*
* Wrapper for getting translation of an option name
*/
static char *
cpdb_option_translation (cpdb_printer_obj_t *printer_obj,
const char *option_name)
{
int i;
char *translation = NULL;
for (i = 0; locales[i] != NULL; i++)
{
translation = cpdbGetOptionTranslation (printer_obj,
option_name,
locales[i]);
if (translation != NULL)
break;
}
return translation;
}
/*
* Wrapper for getting translation of a choice name
*/
static char *
cpdb_choice_translation (cpdb_printer_obj_t *printer_obj,
const char *option_name,
const char *choice_name)
{
int i;
char *translation = NULL;
for (i = 0; locales[i] != NULL; i++)
{
translation = cpdbGetChoiceTranslation (printer_obj,
option_name,
choice_name,
locales[i]);
if (translation != NULL)
break;
}
return translation;
}
/*
* Wrapper for getting translation of a group name
*/
static char *
cpdb_group_translation (cpdb_printer_obj_t *printer_obj,
const char *group_name)
{
int i;
char *translation = NULL;
for (i = 0; locales[i] != NULL; i++)
{
translation = cpdbGetGroupTranslation (printer_obj,
group_name,
locales[i]);
if (translation != NULL)
break;
}
return translation;
}
/*
* Convert CPDB groups explicitly supported by GTK print dialog
*/
static gchar *
get_gtk_group (cpdb_printer_obj_t *printer_obj,
const char *group_name)
{
if (g_strcmp0 (group_name, CPDB_GROUP_COLOR) == 0)
return g_strdup ("ColorPage");
if (g_strcmp0 (group_name, CPDB_GROUP_QUALITY) == 0)
return g_strdup ("ImageQualityPage");
if (g_strcmp0 (group_name, CPDB_GROUP_FINISHINGS) == 0)
return g_strdup ("FinishingPage");
return cpdb_group_translation (printer_obj, group_name);
}
/*
* Do initial setup
*/
static void
initialize (void)
{
cpdbInit ();
if (locales == NULL)
locales = g_get_language_names ();
if (already_used_options == NULL)
{
already_used_options = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_COPIES);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_PAGE_RANGES);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_ORIENTATION);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_PAGE_DELIVERY);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_COLLATE);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_NUMBER_UP);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_NUMBER_UP_LAYOUT);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_PAGE_SET);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MEDIA);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MARGIN_TOP);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MARGIN_BOTTOM);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MARGIN_LEFT);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MARGIN_RIGHT);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_SIDES);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MEDIA_SOURCE);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_MEDIA_TYPE);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_OUTPUT_BIN);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_JOB_PRIORITY);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_JOB_SHEETS);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_JOB_HOLD_UNTIL);
g_hash_table_add (already_used_options, (gpointer) CPDB_OPTION_BILLING_INFO);
g_hash_table_add (already_used_options, (gpointer) "borderless");
}
}