1693 lines
61 KiB
C
1693 lines
61 KiB
C
/* 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");
|
|
}
|
|
}
|