GtkPrintSettings *
xviewer_print_get_print_settings (void)
{
GtkPrintSettings *print_settings;
GError *error = NULL;
GKeyFile *key_file;
key_file = xviewer_print_get_key_file ();
if (key_file && g_key_file_has_group (key_file, XVIEWER_PRINT_SETTINGS_GROUP)) {
print_settings = gtk_print_settings_new_from_key_file (key_file, XVIEWER_PRINT_SETTINGS_GROUP, &error);
} else {
print_settings = gtk_print_settings_new ();
}
if (error) {
print_settings = gtk_print_settings_new ();
g_warning ("Error loading print settings file: %s", error->message);
g_error_free (error);
}
if (key_file)
g_key_file_free (key_file);
return print_settings;
}
static void page_setup_cb (GtkWidget *widget, CustomWidgetInfo *info)
{
PrintData *data = info->data;
GtkPrintOperation *operation = data->operation;
GtkPrintSettings *settings;
GtkPageSetup *page_setup;
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (widget);
#if GTK_CHECK_VERSION (2,18,0)
if (! gtk_widget_is_toplevel (toplevel))
#else
if (! GTK_WIDGET_TOPLEVEL (toplevel))
#endif
toplevel = NULL;
settings = gtk_print_operation_get_print_settings (operation);
if (! settings)
settings = gtk_print_settings_new ();
page_setup = gtk_print_operation_get_default_page_setup (operation);
page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (toplevel),
page_setup, settings);
gtk_print_operation_set_default_page_setup (operation, page_setup);
vik_print_preview_set_page_setup (VIK_PRINT_PREVIEW (info->preview),
page_setup);
update_page_setup (info);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg1, arg2;
GtkPrintSettings* settings = NULL;
GError *error = NULL;
rb_scan_args(argc, argv, "02", &arg1, &arg2);
if (NIL_P(arg1)){
settings = gtk_print_settings_new();
} else if (NIL_P(arg2)){
settings = gtk_print_settings_new_from_file(RVAL2CSTR(arg1), &error);
if (!settings) {
RAISE_GERROR(error);
}
} else {
settings = gtk_print_settings_new_from_key_file((GKeyFile*)RVAL2BOXED(arg1, G_TYPE_KEY_FILE),
RVAL2CSTR(arg2),
&error);
if (!settings) {
RAISE_GERROR(error);
}
}
G_INITIALIZE(self, settings);
return Qnil;
}
static void
load_print_settings (GeditApp *app)
{
GeditAppPrivate *priv;
gchar *filename;
GError *error = NULL;
priv = gedit_app_get_instance_private (app);
g_return_if_fail (priv->print_settings == NULL);
filename = get_print_settings_file ();
priv->print_settings = gtk_print_settings_new_from_file (filename, &error);
if (error)
{
/* Ignore file not found error */
if (error->domain != G_FILE_ERROR ||
error->code != G_FILE_ERROR_NOENT)
{
g_warning ("%s", error->message);
}
g_error_free (error);
}
g_free (filename);
/* fall back to default settings */
if (priv->print_settings == NULL)
{
priv->print_settings = gtk_print_settings_new ();
}
}
/**
* ephy_embed_shell_get_print_settings:
* @shell: the #EphyEmbedShell
*
* Gets the global #GtkPrintSettings object.
*
* Returns: (transfer none): a #GtkPrintSettings object
**/
GtkPrintSettings *
ephy_embed_shell_get_print_settings (EphyEmbedShell *shell)
{
EphyEmbedShellPrivate *priv = ephy_embed_shell_get_instance_private (shell);
g_return_val_if_fail (EPHY_IS_EMBED_SHELL (shell), NULL);
if (priv->print_settings == NULL) {
GError *error = NULL;
char *path;
path = g_build_filename (ephy_dot_dir (), PRINT_SETTINGS_FILENAME, NULL);
priv->print_settings = gtk_print_settings_new_from_file (path, &error);
g_free (path);
/* Note: the gtk print settings file format is the same as our
* legacy one, so no need to migrate here.
*/
if (priv->print_settings == NULL)
priv->print_settings = gtk_print_settings_new ();
}
return priv->print_settings;
}
static GtkPrintOperationResult
_do_print(EDITOR * e, GtkPrintOperationAction action)
{
GtkPrintOperation *operation;
GtkPrintSettings *psettings;
GtkPageSetup *setup;
GtkPrintOperationResult result;
GError *error = NULL;
operation = gtk_print_operation_new();
psettings = gtk_print_settings_new();
psettings = gtk_print_operation_get_print_settings(operation);
setup = gtk_page_setup_new();
gtk_page_setup_set_top_margin(setup, 30, GTK_UNIT_PIXEL);
gtk_page_setup_set_left_margin(setup, 50, GTK_UNIT_PIXEL);
#ifdef WIN32
gtk_print_operation_set_unit(operation, GTK_UNIT_POINTS);
#endif
gtk_print_operation_set_default_page_setup(operation, setup);
result = gtk_html_print_operation_run(GTK_HTML(e->html_widget), operation, action, GTK_WINDOW(e->window), (GtkHTMLPrintCalcHeight) _calc_header_height, /* GtkHTMLPrintCalcHeight calc_header_height */
(GtkHTMLPrintCalcHeight) _calc_footer_height, /* GtkHTMLPrintCalcHeight calc_footer_height */
(GtkHTMLPrintDrawFunc) _draw_header, /* GtkHTMLPrintDrawFunc draw_header */
(GtkHTMLPrintDrawFunc) _draw_footer, /* GtkHTMLPrintDrawFunc draw_footer */
e, /* gpointer user_data */
&error);
g_object_unref(operation);
handle_error(&error);
return result;
}
GtkWidget *
do_printing (GtkWidget *do_widget)
{
GtkPrintOperation *operation;
GtkPrintSettings *settings;
PrintData *data;
GError *error = NULL;
operation = gtk_print_operation_new ();
data = g_new0 (PrintData, 1);
data->resourcename = g_strdup ("/sources/printing.c");
data->font_size = 12.0;
g_signal_connect (G_OBJECT (operation), "begin-print",
G_CALLBACK (begin_print), data);
g_signal_connect (G_OBJECT (operation), "draw-page",
G_CALLBACK (draw_page), data);
g_signal_connect (G_OBJECT (operation), "end-print",
G_CALLBACK (end_print), data);
gtk_print_operation_set_use_full_page (operation, FALSE);
gtk_print_operation_set_unit (operation, GTK_UNIT_POINTS);
gtk_print_operation_set_embed_page_setup (operation, TRUE);
settings = gtk_print_settings_new ();
gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BASENAME, "gtk-demo");
gtk_print_operation_set_print_settings (operation, settings);
gtk_print_operation_run (operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (do_widget), &error);
g_object_unref (operation);
g_object_unref (settings);
if (error)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (do_widget),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
}
return NULL;
}
/* File->Page Setup... */
void
action_page_setup(GtkAction *action, I7Document *document)
{
I7App *theapp = i7_app_get();
GtkPrintSettings *settings = i7_app_get_print_settings(theapp);
if(!settings)
settings = gtk_print_settings_new();
GtkPageSetup *new_page_setup = gtk_print_run_page_setup_dialog(GTK_WINDOW(document), i7_app_get_page_setup(theapp), settings);
i7_app_set_page_setup(theapp, new_page_setup);
}
bool decode(ArgumentDecoder* decoder, GRefPtr<GtkPrintSettings>& printSettings)
{
GOwnPtr<GKeyFile> keyFile;
if (!decodeGKeyFile(decoder, keyFile))
return false;
printSettings = adoptGRef(gtk_print_settings_new());
if (!keyFile)
return true;
if (!gtk_print_settings_load_key_file(printSettings.get(), keyFile.get(), "Print Settings", 0))
printSettings = 0;
return printSettings;
}
void printing_page_setup_gtk(void)
{
GtkPageSetup *new_page_setup;
if (settings == NULL)
settings = gtk_print_settings_new();
new_page_setup = gtk_print_run_page_setup_dialog(
GTK_WINDOW(main_widgets.window), page_setup, settings);
if (page_setup != NULL)
g_object_unref(page_setup);
page_setup = new_page_setup;
}
void
print_page_setup_dialog (GtkPrintOperation *operation)
{
GtkPrintSettings *settings;
GtkPageSetup *setup;
g_return_if_fail (GTK_IS_PRINT_OPERATION (operation));
setup = gtk_print_operation_get_default_page_setup (operation);
settings = gtk_print_settings_new ();
setup = gtk_print_run_page_setup_dialog (NULL, setup, settings);
g_object_unref (settings);
gtk_print_operation_set_default_page_setup (operation, setup);
}
int
main (int argc, char **argv)
{
GtkApplication *app;
GError *error = NULL;
gtk_init (NULL, NULL);
settings = gtk_print_settings_new_from_file ("print-settings.ini", &error);
if (error) {
g_print ("Failed to load print settings: %s\n", error->message);
g_clear_error (&error);
settings = gtk_print_settings_new ();
}
g_assert (settings != NULL);
page_setup = gtk_page_setup_new_from_file ("page-setup.ini", &error);
if (error) {
g_print ("Failed to load page setup: %s\n", error->message);
g_clear_error (&error);
}
app = gtk_application_new ("org.gtk.PrintEditor", 0);
g_action_map_add_action_entries (G_ACTION_MAP (app),
app_entries, G_N_ELEMENTS (app_entries),
app);
g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
g_signal_connect (app, "command-line", G_CALLBACK (command_line), NULL);
g_application_run (G_APPLICATION (app), argc, argv);
if (!gtk_print_settings_to_file (settings, "print-settings.ini", &error)) {
g_print ("Failed to save print settings: %s\n", error->message);
g_clear_error (&error);
}
if (page_setup &&
!gtk_page_setup_to_file (page_setup, "page-setup.ini", &error)) {
g_print ("Failed to save page setup: %s\n", error->message);
g_clear_error (&error);
}
return 0;
}
static void
photos_print_operation_init (PhotosPrintOperation *self)
{
GtkPrintSettings *settings;
self->unit = GTK_UNIT_INCH;
self->left_margin = 0.0;
self->top_margin = 0.0;
self->scale_factor = 100.0;
settings = gtk_print_settings_new ();
gtk_print_operation_set_print_settings (GTK_PRINT_OPERATION (self), settings);
g_object_unref (settings);
gtk_print_operation_set_custom_tab_label (GTK_PRINT_OPERATION (self), _("Image Settings"));
gtk_print_operation_set_embed_page_setup (GTK_PRINT_OPERATION (self), TRUE);
gtk_print_operation_set_n_pages (GTK_PRINT_OPERATION (self), 1);
}
int
main (int argc, char **argv)
{
GtkPrintOperation *print;
GtkPrintSettings *settings;
settings = gtk_print_settings_new ();
/* gtk_print_settings_set_printer (settings, "printer"); */
print = gtk_print_operation_new ();
gtk_print_operation_set_print_settings (print, settings);
gtk_print_operation_set_n_pages (print, 1);
gtk_print_operation_set_unit (print, GTK_UNIT_MM);
g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT, NULL, NULL);
return 0;
}
static GtkPrintSettings *
load_settings (GKeyFile *key_file)
{
GtkPrintSettings *settings;
GError *error = NULL;
settings = gtk_print_settings_new ();
if (g_key_file_has_group (key_file, PRINT_SETTINGS_GROUP_NAME))
gtk_print_settings_load_key_file (
settings, key_file, PRINT_SETTINGS_GROUP_NAME, &error);
if (error != NULL) {
g_warning ("%s", error->message);
g_error_free (error);
}
return settings;
}
/** ---------------------------------------------------
*/
nsPrintSettingsGTK::nsPrintSettingsGTK() :
mPageSetup(nullptr),
mPrintSettings(nullptr),
mGTKPrinter(nullptr),
mPrintSelectionOnly(false)
{
// The aim here is to set up the objects enough that silent printing works well.
// These will be replaced anyway if the print dialog is used.
mPrintSettings = gtk_print_settings_new();
mPageSetup = gtk_page_setup_new();
InitUnwriteableMargin();
SetOutputFormat(nsIPrintSettings::kOutputFormatNative);
GtkPaperSize* defaultPaperSize = gtk_paper_size_new(nullptr);
mPaperSize = moz_gtk_paper_size_copy_to_new_custom(defaultPaperSize);
gtk_paper_size_free(defaultPaperSize);
SaveNewPageSize();
}
int
main (int argc, char **argv)
{
GError *error = NULL;
g_set_application_name ("Print editor");
gtk_init (&argc, &argv);
settings = gtk_print_settings_new_from_file ("print-settings.ini", &error);
if (error) {
g_print ("Failed to load print settings: %s\n", error->message);
g_clear_error (&error);
settings = gtk_print_settings_new ();
}
g_assert (settings != NULL);
page_setup = gtk_page_setup_new_from_file ("page-setup.ini", &error);
if (error) {
g_print ("Failed to load page setup: %s\n", error->message);
g_clear_error (&error);
}
create_window ();
if (argc == 2)
load_file (argv[1]);
gtk_main ();
if (!gtk_print_settings_to_file (settings, "print-settings.ini", &error)) {
g_print ("Failed to save print settings: %s\n", error->message);
g_clear_error (&error);
}
if (page_setup &&
!gtk_page_setup_to_file (page_setup, "page-setup.ini", &error)) {
g_print ("Failed to save page setup: %s\n", error->message);
g_clear_error (&error);
}
return 0;
}
/**
* ephy_embed_shell_set_print_settings:
* @shell: the #EphyEmbedShell
* @settings: the new #GtkPrintSettings object
*
* Sets the global #GtkPrintSettings object.
*
**/
void
ephy_embed_shell_set_print_settings (EphyEmbedShell *shell,
GtkPrintSettings *settings)
{
EphyEmbedShellPrivate *priv = ephy_embed_shell_get_instance_private (shell);
char *path;
g_return_if_fail (EPHY_IS_EMBED_SHELL (shell));
if (settings != NULL)
g_object_ref (settings);
if (priv->print_settings != NULL)
g_object_unref (priv->print_settings);
priv->print_settings = settings ? settings : gtk_print_settings_new ();
path = g_build_filename (ephy_dot_dir (), PRINT_SETTINGS_FILENAME, NULL);
gtk_print_settings_to_file (settings, path, NULL);
g_free (path);
}
static void
load_print_settings (GeditApp *app)
{
GeditAppPrivate *priv;
gchar *filename;
GError *error = NULL;
priv = gedit_app_get_instance_private (app);
g_return_if_fail (priv->print_settings == NULL);
filename = get_print_settings_file ();
priv->print_settings = gtk_print_settings_new_from_file (filename, &error);
if (error != NULL)
{
/* - Ignore file not found error.
* - Ignore empty file error, i.e. group not found. This happens
* when we click on cancel in the print dialog, when using the
* printing for the first time in gedit.
*/
if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT) &&
!g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND))
{
g_warning ("Load print settings error: %s", error->message);
}
g_error_free (error);
}
g_free (filename);
/* fall back to default settings */
if (priv->print_settings == NULL)
{
priv->print_settings = gtk_print_settings_new ();
}
}
static gboolean
print_settings_load_from_key_file (PrintData *data,
GKeyFile *key_file)
{
GtkPrintOperation *operation = data->operation;
GtkPrintSettings *settings;
gchar **keys;
gsize n_keys;
gint i;
settings = gtk_print_operation_get_print_settings (operation);
if (! settings)
settings = gtk_print_settings_new ();
keys = g_key_file_get_keys (key_file, PRINT_SETTINGS_NAME, &n_keys, NULL);
if (! keys)
return FALSE;
for (i = 0; i < n_keys; i++)
{
gchar *value;
value = g_key_file_get_value (key_file,
PRINT_SETTINGS_NAME, keys[i], NULL);
if (value)
{
gtk_print_settings_set (settings, keys[i], value);
g_free (value);
}
}
g_strfreev (keys);
if (g_key_file_has_key (key_file, "image-setup", "unit", NULL))
{
data->unit = g_key_file_get_integer (key_file, "image-setup",
"unit", NULL);
}
if (g_key_file_has_key (key_file, "image-setup", "x-resolution", NULL) &&
g_key_file_has_key (key_file, "image-setup", "y-resolution", NULL))
{
data->xres = g_key_file_get_double (key_file, "image-setup",
"x-resolution", NULL);
data->yres = g_key_file_get_double (key_file, "image-setup",
"y-resolution", NULL);
}
if (g_key_file_has_key (key_file, "image-setup", "x-offset", NULL) &&
g_key_file_has_key (key_file, "image-setup", "y-offset", NULL))
{
data->offset_x = g_key_file_get_double (key_file, "image-setup",
"x-offset", NULL);
data->offset_y = g_key_file_get_double (key_file, "image-setup",
"y-offset", NULL);
}
if (g_key_file_has_key (key_file, "image-setup", "center-mode", NULL))
{
data->center = g_key_file_get_integer (key_file, "image-setup",
"center-mode", NULL);
}
if (g_key_file_has_key (key_file, "image-setup", "use-full-page", NULL))
{
data->use_full_page = g_key_file_get_boolean (key_file, "image-setup",
"use-full-page", NULL);
}
if (g_key_file_has_key (key_file, "image-setup", "crop-marks", NULL))
{
data->draw_crop_marks = g_key_file_get_boolean (key_file, "image-setup",
"crop-marks", NULL);
}
gtk_print_operation_set_print_settings (operation, settings);
return TRUE;
}
static gboolean
mail_printer_print_timeout_cb (GTask *task)
{
AsyncContext *async_context;
gpointer source_object;
const gchar *export_filename;
GtkPrintSettings *print_settings = NULL;
WebKitPrintOperation *print_operation = NULL;
WebKitPrintOperationResponse response;
/* FIXME WK2
gulong draw_page_handler_id;
gulong create_custom_widget_handler_id;
gulong custom_widget_apply_handler_id;*/
async_context = g_task_get_task_data (task);
g_return_val_if_fail (async_context != NULL, G_SOURCE_REMOVE);
source_object = g_task_get_source_object (task);
g_return_val_if_fail (E_IS_MAIL_PRINTER (source_object), G_SOURCE_REMOVE);
print_settings = gtk_print_settings_new ();
export_filename = e_mail_printer_get_export_filename (E_MAIL_PRINTER (source_object));
gtk_print_settings_set (
print_settings,
GTK_PRINT_SETTINGS_OUTPUT_BASENAME,
export_filename);
print_operation = webkit_print_operation_new (async_context->web_view);
webkit_print_operation_set_print_settings (print_operation, print_settings);
g_signal_connect_data (
print_operation, "failed",
G_CALLBACK (mail_printer_print_failed_cb),
g_object_ref (task),
(GClosureNotify) g_object_unref, 0);
g_signal_connect_data (
print_operation, "finished",
G_CALLBACK (mail_printer_print_finished_cb),
g_object_ref (task),
(GClosureNotify) g_object_unref, 0);
/* FIXME WK2
create_custom_widget_handler_id = g_signal_connect (
print_operation, "create-custom-widget",
G_CALLBACK (mail_printer_create_custom_widget_cb),
async_context);
custom_widget_apply_handler_id = g_signal_connect (
print_operation, "custom-widget-apply",
G_CALLBACK (mail_printer_custom_widget_apply_cb),
async_context); */
/* FIXME WK2 - this will be hard to add back to WK2 API.. There is a CSS draft
* that can be used to add a page numbers, but it is not in WebKit yet.
* http://www.w3.org/TR/css3-page/
draw_page_handler_id = g_signal_connect (
print_operation, "draw-page",
G_CALLBACK (mail_printer_draw_footer_cb),
async_context->cancellable); */
response = webkit_print_operation_run_dialog (print_operation, NULL);
/* FIXME WK2
g_signal_handler_disconnect (
print_operation, create_custom_widget_handler_id);
g_signal_handler_disconnect (
print_operation, custom_widget_apply_handler_id);
g_signal_handler_disconnect (
print_operation, draw_page_handler_id); */
g_clear_object (&print_operation);
g_clear_object (&print_settings);
if (response == WEBKIT_PRINT_OPERATION_RESPONSE_CANCEL) {
async_context->print_result = GTK_PRINT_OPERATION_RESULT_CANCEL;
g_task_return_boolean (task, TRUE);
}
return G_SOURCE_REMOVE;
}
void
CmOutputPrinter(int select_file, int show_dialog)
{
GtkPrintOperation *print;
GtkPrintOperationResult res;
char buf[MESSAGE_BUF_SIZE];
struct objlist *graobj, *g2wobj;
int id, g2wid, g2woid, opt;
N_VALUE *g2winst;
GError *error;
struct print_obj pobj;
GtkPaperSize *paper_size;
GtkPageSetup *page_setup;
if (Menulock || Globallock)
return;
if (select_file && ! SetFileHidden())
return;
FileAutoScale();
AdjustAxis();
graobj = chkobject("gra");
if (graobj == NULL)
return;
g2wobj = chkobject("gra2gtkprint");
if (g2wobj == NULL)
return;
g2wid = newobj(g2wobj);
if (g2wid < 0)
return;
putobj(g2wobj, "use_opacity", g2wid, &Menulocal.use_opacity);
g2winst = chkobjinst(g2wobj, g2wid);
_getobj(g2wobj, "oid", g2winst, &g2woid);
id = newobj(graobj);
init_graobj(graobj, id, "gra2gtkprint", g2woid);
print = gtk_print_operation_new();
gtk_print_operation_set_n_pages(print, 1);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_print_operation_set_has_selection(print, FALSE);
gtk_print_operation_set_support_selection(print, FALSE);
gtk_print_operation_set_embed_page_setup(print, FALSE);
#endif
gtk_print_operation_set_use_full_page(print, TRUE);
if (PrintSettings == NULL)
PrintSettings = gtk_print_settings_new();
if (Menulocal.PaperId == PAPER_ID_CUSTOM) {
paper_size = gtk_paper_size_new_custom(Menulocal.PaperName,
Menulocal.PaperName,
Menulocal.PaperWidth / 100.0,
Menulocal.PaperHeight / 100.0,
GTK_UNIT_MM);
} else {
paper_size = gtk_paper_size_new(Menulocal.PaperName);
}
page_setup = gtk_page_setup_new();
gtk_page_setup_set_paper_size(page_setup, paper_size);
if (Menulocal.PaperLandscape) {
gtk_page_setup_set_orientation(page_setup, GTK_PAGE_ORIENTATION_LANDSCAPE);
} else {
gtk_page_setup_set_orientation(page_setup, GTK_PAGE_ORIENTATION_PORTRAIT);
}
gtk_print_operation_set_default_page_setup(print, page_setup);
gtk_print_operation_set_print_settings(print, PrintSettings);
pobj.graobj = graobj;
pobj.id = id;
pobj.g2wobj = g2wobj;
pobj.g2winst = g2winst;
g_signal_connect(print, "draw_page", G_CALLBACK(draw_page), &pobj);
switch (show_dialog) {
case PRINT_SHOW_DIALOG_NONE:
opt = GTK_PRINT_OPERATION_ACTION_PRINT;
break;
case PRINT_SHOW_DIALOG_PREVIEW:
opt = GTK_PRINT_OPERATION_ACTION_PREVIEW;
break;
case PRINT_SHOW_DIALOG_DIALOG:
opt = GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG;
break;
default:
opt = GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG;
}
res = gtk_print_operation_run(print, opt, GTK_WINDOW(TopLevel), &error);
if (res == GTK_PRINT_OPERATION_RESULT_ERROR) {
snprintf(buf, sizeof(buf), _("Printing error: %s"), error->message);
message_box(NULL, buf, _("Print"), RESPONS_ERROR);
g_error_free(error);
} else if (res == GTK_PRINT_OPERATION_RESULT_APPLY) {
if (PrintSettings)
g_object_unref(PrintSettings);
PrintSettings = g_object_ref(gtk_print_operation_get_print_settings(print));
}
g_object_unref(print);
delobj(graobj, id);
delobj(g2wobj, g2wid);
if (select_file && NgraphApp.FileWin.data.data) {
FileWinUpdate(NgraphApp.FileWin.data.data, TRUE);
}
}
/**
* Prints the current page.
*
* If printing on WIN32, in order to prevent the font from being tiny, (see bug #591177),
* A GtkPrintOperation object needs to be created so that the unit can be set, and then
* webkit_web_frame_print_full() needs to be called to use that GtkPrintOperation. On
* other platforms (specifically linux - not sure about MacOSX), the version of webkit may
* not contain the function webkit_web_frame_print_full(), so webkit_web_frame_print() is
* called instead (the font size problem doesn't show up on linux).
*
* @param self HTML renderer object
*/
static void
impl_webkit_print( GncHtml* self, const gchar* jobname, gboolean export_pdf )
{
#if !HAVE(WEBKIT_WEB_FRAME_PRINT_FULL)
extern void webkit_web_frame_print( WebKitWebFrame * frame );
#endif
gchar *export_filename = NULL;
GncHtmlWebkitPrivate* priv;
WebKitWebFrame* frame;
#if HAVE(WEBKIT_WEB_FRAME_PRINT_FULL)
GtkPrintOperation* op = gtk_print_operation_new();
GError* error = NULL;
GtkPrintSettings *print_settings;
#endif
priv = GNC_HTML_WEBKIT_GET_PRIVATE(self);
frame = webkit_web_view_get_main_frame( priv->web_view );
#if HAVE(WEBKIT_WEB_FRAME_PRINT_FULL)
gnc_print_operation_init( op, jobname );
print_settings = gtk_print_operation_get_print_settings (op);
if (!print_settings)
{
print_settings = gtk_print_settings_new();
gtk_print_operation_set_print_settings(op, print_settings);
}
#ifdef G_OS_WIN32
gtk_print_operation_set_unit( op, GTK_UNIT_POINTS );
#endif
// Make sure to generate a full export filename
if (g_str_has_suffix(jobname, ".pdf"))
{
export_filename = g_strdup(jobname);
}
else
{
export_filename = g_strconcat(jobname, ".pdf", NULL);
}
// Two different modes of operation. Either export to PDF, or run the
// normal print dialog
if (export_pdf)
{
GtkWidget *dialog;
gint result;
gchar *export_dirname = NULL;
gchar* basename;
// Before we save the PDF file, we always as the user for the export
// file name. We will store the chosen directory in the gtk print settings
// as well.
dialog = gtk_file_chooser_dialog_new (_("Export to PDF File"),
NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
// Does the jobname look like a valid full file path?
basename = g_path_get_basename(jobname);
if (strcmp(basename, jobname) != 0)
{
gchar *tmp_basename;
gchar *tmp_dirname = g_path_get_dirname(jobname);
if (g_file_test(tmp_dirname, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
{
// Yes, the jobname starts with a directory name that actually
// exists. Hence we use this as output directory.
export_dirname = tmp_dirname;
tmp_dirname = NULL;
// As the prefix part of the "jobname" is the directory path, we
// need to extract the suffix part for the filename.
tmp_basename = g_path_get_basename(export_filename);
g_free(export_filename);
export_filename = tmp_basename;
}
g_free(tmp_dirname);
}
g_free(basename);
// Set the output file name from the given jobname
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(dialog), export_filename);
// Do we have a stored output directory?
if (!export_dirname && gtk_print_settings_has_key(print_settings, GNC_GTK_PRINT_SETTINGS_EXPORT_DIR))
{
const char* tmp_dirname = gtk_print_settings_get(print_settings,
GNC_GTK_PRINT_SETTINGS_EXPORT_DIR);
// Only use the directory subsequently if it exists.
if (g_file_test(tmp_dirname, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
{
export_dirname = g_strdup(tmp_dirname);
}
}
// If we have an already existing directory, propose it now.
if (export_dirname)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), export_dirname);
}
g_free(export_dirname);
result = gtk_dialog_run (GTK_DIALOG (dialog));
// Weird. In gtk_dialog_run, the gtk code will run a fstat() on the
// proposed new output filename, which of course fails with "file not
// found" as this file doesn't exist. It will still show a warning output
// in the trace file, though.
if (result == GTK_RESPONSE_ACCEPT)
{
// The user pressed "Ok", so use the file name for the actual file output.
gchar *dirname;
char *tmp = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
g_free(export_filename);
export_filename = tmp;
// Store the directory part of the file for later
dirname = g_path_get_dirname(export_filename);
if (g_file_test(dirname, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
{
gtk_print_settings_set(print_settings, GNC_GTK_PRINT_SETTINGS_EXPORT_DIR, dirname);
}
g_free(dirname);
}
gtk_widget_destroy (dialog);
if (result != GTK_RESPONSE_ACCEPT)
{
// User pressed cancel - no saving of the PDF file here.
g_free(export_filename);
g_object_unref( op );
return;
}
// This function expects the full filename including (absolute?) path
gtk_print_operation_set_export_filename(op, export_filename);
// Run the "Export to PDF" print operation
webkit_web_frame_print_full( frame, op, GTK_PRINT_OPERATION_ACTION_EXPORT, &error );
}
else
{
// Also store this export file name as output URI in the settings
if (gtk_print_settings_has_key(print_settings, GTK_PRINT_SETTINGS_OUTPUT_URI))
{
// Get the previous output URI, extract the directory part, and
// append the current filename.
const gchar *olduri = gtk_print_settings_get(print_settings, GTK_PRINT_SETTINGS_OUTPUT_URI);
gchar *dirname = g_path_get_dirname(olduri);
gchar *newuri = (g_strcmp0(dirname, ".") == 0)
? g_strdup(export_filename)
: g_build_filename(dirname, export_filename, NULL);
//g_warning("olduri=%s newuri=%s", olduri, newuri);
// This function expects the full filename including protocol, path, and name
gtk_print_settings_set(print_settings, GTK_PRINT_SETTINGS_OUTPUT_URI, newuri);
g_free(newuri);
g_free(dirname);
}
else
{
// No stored output URI from the print settings, so just set our export filename
gtk_print_settings_set(print_settings, GTK_PRINT_SETTINGS_OUTPUT_URI, export_filename);
}
// Run the normal printing dialog
webkit_web_frame_print_full( frame, op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, &error );
}
if ( error != NULL )
{
GtkWidget* window = gtk_widget_get_toplevel( GTK_WIDGET(priv->web_view) );
GtkWidget* dialog = gtk_message_dialog_new( gtk_widget_is_toplevel(window) ? GTK_WINDOW(window) : NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", error->message );
g_error_free( error );
g_signal_connect( dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);
gtk_widget_show( dialog );
}
// Remember to save the printing settings after this print job
gnc_print_operation_save_print_settings(op);
g_object_unref( op );
g_free(export_filename);
#else
webkit_web_frame_print( frame );
#endif
}
GtkWidget *
do_printing (GtkWidget *do_widget)
{
GtkPrintOperation *operation;
GtkPrintSettings *settings;
PrintData *data;
gchar *uri, *ext;
const gchar *dir;
GError *error = NULL;
operation = gtk_print_operation_new ();
data = g_new0 (PrintData, 1);
data->filename = demo_find_file ("printing.c", NULL);
data->font_size = 12.0;
g_signal_connect (G_OBJECT (operation), "begin-print",
G_CALLBACK (begin_print), data);
g_signal_connect (G_OBJECT (operation), "draw-page",
G_CALLBACK (draw_page), data);
g_signal_connect (G_OBJECT (operation), "end-print",
G_CALLBACK (end_print), data);
gtk_print_operation_set_use_full_page (operation, FALSE);
gtk_print_operation_set_unit (operation, GTK_UNIT_POINTS);
gtk_print_operation_set_embed_page_setup (operation, TRUE);
settings = gtk_print_settings_new ();
dir = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
if (dir == NULL)
dir = g_get_home_dir ();
if (g_strcmp0 (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT), "ps") == 0)
ext = ".ps";
else if (g_strcmp0 (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT), "svg") == 0)
ext = ".svg";
else
ext = ".pdf";
uri = g_strconcat ("file://", dir, "/", "gtk-demo", ext, NULL);
gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_URI, uri);
gtk_print_operation_set_print_settings (operation, settings);
gtk_print_operation_run (operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (do_widget), &error);
g_object_unref (operation);
g_object_unref (settings);
g_free (uri);
if (error)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (do_widget),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
}
return NULL;
}
static VALUE
ps_initialize(VALUE self)
{
G_INITIALIZE(self, gtk_print_settings_new());
return Qnil;
}
void XAP_UnixDialog_Print::setupPrint()
{
double blockMrgnLeft, blockMrgnRight, mrgnTop, mrgnBottom, mrgnLeft, mrgnRight = 0.;
double width, height;
bool portrait;
m_pView = static_cast<FV_View*>(m_pFrame->getCurrentView());
m_pPO = gtk_print_operation_new();
//
// Set filename if it's not present already
//
std::string sURI = m_pView->getDocument()->getPrintFilename();
if(sURI.empty())
{
const std::string & filename = m_pView->getDocument()->getFilename();
if(!filename.empty()) {
sURI = filename;
UT_addOrReplacePathSuffix(sURI, ".pdf");
}
}
if(!sURI.empty()) {
GtkPrintSettings * pSettings = gtk_print_settings_new();
gtk_print_settings_set(pSettings,
GTK_PRINT_SETTINGS_OUTPUT_URI,
sURI.c_str() );
gtk_print_operation_set_print_settings(m_pPO,pSettings);
g_object_unref(pSettings);
}
s_getPageMargins(m_pView, blockMrgnLeft, blockMrgnRight, mrgnLeft, mrgnRight, mrgnTop, mrgnBottom);
portrait = m_pView->getPageSize().isPortrait();
width = m_pView->getPageSize().Width (DIM_MM);
height = m_pView->getPageSize().Height (DIM_MM);
m_pPageSetup = gtk_page_setup_new();
const char * pszName = m_pView->getPageSize().getPredefinedName();
bool isPredefined = false;
const char * pszGtkName = NULL;
if(pszName == NULL)
{
}
else if(g_ascii_strcasecmp(pszName,"Custom") == 0)
{
}
else if(g_ascii_strcasecmp(pszName,"A0") == 0)
{
isPredefined = true;
pszGtkName = "iso_a0";
}
else if(g_ascii_strcasecmp(pszName,"A1") == 0)
{
isPredefined = true;
pszGtkName = "iso_a1";
}
else if(g_ascii_strcasecmp(pszName,"A2") == 0)
{
isPredefined = true;
pszGtkName = "iso_a2";
}
else if(g_ascii_strcasecmp(pszName,"A3") == 0)
{
isPredefined = true;
pszGtkName = "iso_a3";
}
else if(g_ascii_strcasecmp(pszName,"A4") == 0)
{
isPredefined = true;
pszGtkName = "iso_a4";
}
else if(g_ascii_strcasecmp(pszName,"A5") == 0)
{
isPredefined = true;
pszGtkName = "iso_a5";
}
else if(g_ascii_strcasecmp(pszName,"A6") == 0)
{
isPredefined = true;
pszGtkName = "iso_a6";
}
else if(g_ascii_strcasecmp(pszName,"A7") == 0)
{
isPredefined = true;
pszGtkName = "iso_a7";
}
else if(g_ascii_strcasecmp(pszName,"A8") == 0)
{
isPredefined = true;
pszGtkName = "iso_a8";
}
else if(g_ascii_strcasecmp(pszName,"A9") == 0)
{
isPredefined = true;
pszGtkName = "iso_a9";
}
else if(g_ascii_strcasecmp(pszName,"B0") == 0)
{
isPredefined = true;
pszGtkName = "iso_b0";
}
else if(g_ascii_strcasecmp(pszName,"B1") == 0)
{
isPredefined = true;
pszGtkName = "iso_b1";
}
else if(g_ascii_strcasecmp(pszName,"B2") == 0)
{
isPredefined = true;
pszGtkName = "iso_b2";
}
else if(g_ascii_strcasecmp(pszName,"B3") == 0)
{
isPredefined = true;
pszGtkName = "iso_b3";
}
else if(g_ascii_strcasecmp(pszName,"B4") == 0)
{
isPredefined = true;
pszGtkName = "iso_b4";
}
else if(g_ascii_strcasecmp(pszName,"B4") == 0)
{
isPredefined = true;
pszGtkName = "iso_b4";
}
else if(g_ascii_strcasecmp(pszName,"B5") == 0)
{
isPredefined = true;
pszGtkName = "iso_b5";
}
else if(g_ascii_strcasecmp(pszName,"B6") == 0)
{
isPredefined = true;
pszGtkName = "iso_b6";
}
else if(g_ascii_strcasecmp(pszName,"B7") == 0)
{
isPredefined = true;
pszGtkName = "iso_b7";
}
else if(g_ascii_strcasecmp(pszName,"Legal") == 0)
{
isPredefined = true;
pszGtkName = "na_legal";
}
else if(g_ascii_strcasecmp(pszName,"Letter") == 0)
{
isPredefined = true;
pszGtkName = "na_letter";
}
if(isPredefined)
{
m_pGtkPageSize = gtk_paper_size_new(static_cast<const gchar *>(pszGtkName));
}
else
{
/*
* Width() and Height() will return the paper size as shown in the UI.
* Gtk wants the real paper size, however, and will swap the two
* itself when we specify the orientation.
*/
m_pGtkPageSize = gtk_paper_size_new_custom("custom",
"custom",
portrait ? width : height,
portrait ? height : width,
GTK_UNIT_MM);
}
//
// Set the Page Size
//
gtk_page_setup_set_paper_size(m_pPageSetup,m_pGtkPageSize);
//
// Set the margins
//
gtk_page_setup_set_top_margin(m_pPageSetup,mrgnTop,GTK_UNIT_INCH);
gtk_page_setup_set_bottom_margin(m_pPageSetup,mrgnBottom,GTK_UNIT_INCH);
gtk_page_setup_set_left_margin(m_pPageSetup,mrgnLeft,GTK_UNIT_INCH);
gtk_page_setup_set_right_margin(m_pPageSetup,mrgnRight,GTK_UNIT_INCH);
//
// Set orientation
//
if( portrait)
gtk_page_setup_set_orientation(m_pPageSetup,GTK_PAGE_ORIENTATION_PORTRAIT);
else
gtk_page_setup_set_orientation(m_pPageSetup,GTK_PAGE_ORIENTATION_LANDSCAPE);
gtk_print_operation_set_default_page_setup(m_pPO,m_pPageSetup);
gtk_print_operation_set_use_full_page (m_pPO, true);
m_pDL = m_pView->getLayout();
m_iCurrentPage = m_pDL->findPage(m_pView->getCurrentPage());
m_iNumberPages = (gint) m_pDL->countPages();
gtk_print_operation_set_current_page(m_pPO,m_iCurrentPage);
g_signal_connect (m_pPO, "begin_print", G_CALLBACK (s_Begin_Print), this);
g_signal_connect (m_pPO, "draw_page", G_CALLBACK (s_Print_Page), this);
}
int PrintText(const char *name, gchar *text)
{
GKeyFile *conf = GetConf();
GtkPrintOperation *prt;
const gchar *font;
GtkPageSetup *page_setup = NULL;
GtkPrintSettings *print_settings = NULL;
if(!text)
return -EINVAL;
prt = gtk_print_operation_new();
if(!prt)
return -1;
// Set job parameters
g_object_set_data_full(G_OBJECT(prt),"3270Text",g_strsplit(g_strchomp(text),"\n",-1),(void (*)(gpointer)) g_strfreev);
// Set print
font = GetString("Print","Font","");
if(!*font)
font = GetString("Terminal","Font","Courier");
g_object_set_data_full(G_OBJECT(prt),"3270FontName",g_strdup(font),g_free);
// Configure print operation
gtk_print_operation_set_job_name(prt,name);
gtk_print_operation_set_allow_async(prt,0);
gtk_print_operation_set_show_progress(prt,1);
gtk_print_operation_set_custom_tab_label(prt,_( "Font" ));
g_signal_connect(prt, "begin-print", G_CALLBACK(begin_print), 0);
g_signal_connect(prt, "draw-page", G_CALLBACK(draw_page), 0);
#ifdef HAVE_PRINT_FONT_DIALOG
g_signal_connect(prt, "create-custom-widget", G_CALLBACK(create_custom_widget), 0);
g_signal_connect(prt, "custom-widget-apply", G_CALLBACK(custom_widget_apply), 0);
#endif
g_signal_connect(prt, "done", G_CALLBACK(print_done), 0);
if(conf)
{
#if GTK_CHECK_VERSION(2,12,0)
gchar *ptr = g_key_file_get_string(conf,"Print Settings","output-uri",NULL);
if(ptr)
{
gchar *uri = NULL;
switch(*(ptr++))
{
case '$':
if(g_str_has_prefix(ptr,"home/"))
uri = g_strdup_printf("file:///%s/%s",g_get_home_dir(),ptr+5);
#if GTK_CHECK_VERSION(2,14,0)
else if(g_str_has_prefix(ptr,"documents/"))
uri = g_strdup_printf("file:///%s/%s",g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS),ptr+10);
else if(g_str_has_prefix(ptr,"desktop/"))
uri = g_strdup_printf("file:///%s/%s",g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP),ptr+8);
#endif
break;
case '~':
uri = g_strdup_printf("file:///%s/%s",g_get_home_dir(),ptr);
break;
}
if(uri)
{
g_key_file_set_string(conf,"Print Settings","output-uri",uri);
g_free(uri);
}
}
print_settings = gtk_print_settings_new_from_key_file(conf,NULL,NULL);
page_setup = gtk_page_setup_new_from_key_file(conf,NULL,NULL);
if(!page_setup)
page_setup = gtk_page_setup_new();
#else // GTK_CHECK_VERSION(2,12,0)
print_settings = gtk_print_settings_new();
if(print_settings)
{
gchar **list;
int f;
list = g_key_file_get_keys(conf,"PrintSettings",NULL,NULL);
if(list)
{
for(f=0;list[f];f++)
gtk_print_settings_set(print_settings,list[f],g_key_file_get_string(conf,"PrintSettings",list[f],NULL));
g_strfreev(list);
}
}
page_setup = gtk_page_setup_new();
#endif
}
else
{
page_setup = gtk_page_setup_new();
gtk_print_operation_set_print_settings(prt,gtk_print_settings_new());
}
Trace("page_setup: %p print_settings: %p",page_setup,print_settings);
gtk_print_operation_set_print_settings(prt,print_settings);
gtk_print_operation_set_default_page_setup(prt,page_setup);
// Run Print dialog
gtk_print_operation_run(prt,GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,GTK_WINDOW(topwindow),NULL);
g_object_unref(prt);
return 0;
}
