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; }