int main (int argc, char **argv) { GtkPrintOperation *print; TestPrintFileOperation *print_file; gtk_init (&argc, &argv); /* Test some random drawing, with per-page paper settings */ print = gtk_print_operation_new (); gtk_print_operation_set_n_pages (print, 2); gtk_print_operation_set_unit (print, GTK_UNIT_MM); gtk_print_operation_set_export_filename (print, "test.pdf"); g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL); g_signal_connect (print, "request_page_setup", G_CALLBACK (request_page_setup), NULL); gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_EXPORT, NULL, NULL); /* Test subclassing of GtkPrintOperation */ print_file = test_print_file_operation_new ("testprint.c"); test_print_file_operation_set_font_size (print_file, 12.0); gtk_print_operation_set_export_filename (GTK_PRINT_OPERATION (print_file), "test2.pdf"); gtk_print_operation_run (GTK_PRINT_OPERATION (print_file), GTK_PRINT_OPERATION_ACTION_EXPORT, NULL, NULL); return 0; }
void XAP_UnixDialog_Print::PrintDirectly(XAP_Frame * pFrame, const char * szFilename, const char * szPrinter) { m_pFrame = pFrame; setupPrint(); if(szFilename) { gtk_print_operation_set_export_filename(m_pPO, szFilename); gtk_print_operation_run (m_pPO,GTK_PRINT_OPERATION_ACTION_EXPORT, NULL,NULL); } else { GtkPrintSettings * pSettings = gtk_print_operation_get_print_settings(m_pPO); if(szPrinter) { gtk_print_settings_set_printer(pSettings, szPrinter); } else { gtk_print_settings_set_printer(pSettings, GTK_PRINT_SETTINGS_PRINTER); } gtk_print_operation_set_print_settings(m_pPO,pSettings); gtk_print_operation_run (m_pPO,GTK_PRINT_OPERATION_ACTION_PRINT, NULL,NULL); } cleanup(); }
void create_gtkprint_session(GtkTextView *text_view, const gchar *title) { GtkPrintOperation *op; GtkPrintOperationResult res; GError *err = NULL; page_title = title; op = create_print_operation(text_view); res = gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(text_view))), &err); switch (res) { case GTK_PRINT_OPERATION_RESULT_ERROR: create_error_dialog(text_view, err->message); g_error_free(err); case GTK_PRINT_OPERATION_RESULT_APPLY: if (settings) g_object_unref(settings); settings = g_object_ref(gtk_print_operation_get_print_settings(op)); default: break; } g_object_unref(op); }
void gl_ui_cmd_file_print (GtkAction *action, glWindow *window) { glPrintOpDialog *op; GtkPrintOperationResult result; gl_debug (DEBUG_COMMANDS, "START"); g_return_if_fail (action && GTK_IS_ACTION(action)); g_return_if_fail (window && GL_IS_WINDOW(window)); op = gl_print_op_dialog_new (GL_VIEW(window->view)->label); if (window->print_settings) { gl_print_op_set_settings (GL_PRINT_OP (op), window->print_settings); } result = gtk_print_operation_run (GTK_PRINT_OPERATION (op), GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (window), NULL); if ( result == GTK_PRINT_OPERATION_RESULT_APPLY ) { gl_print_op_free_settings (window->print_settings); window->print_settings = gl_print_op_get_settings (GL_PRINT_OP (op)); } gl_debug (DEBUG_COMMANDS, "END"); }
void gui_editor_print (GUIEditor *editor) { editor->print_operation = gtk_print_operation_new (); #ifdef G_OS_WIN32 gtk_print_operation_set_unit (editor->print_operation, GTK_UNIT_POINTS); #endif GtkPrintOperationResult res; GError *error; GtkWidget *error_dialog; g_signal_connect (editor->print_operation, "begin-print", G_CALLBACK (gui_editor_begin_print), editor); g_signal_connect (editor->print_operation, "draw-page", G_CALLBACK (gui_editor_draw_page), editor); gtk_print_operation_set_show_progress (editor->print_operation, TRUE); res = gtk_print_operation_run (editor->print_operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, NULL, &error); if (res == GTK_PRINT_OPERATION_RESULT_ERROR ) { error_dialog = gtk_message_dialog_new (GTK_WINDOW (editor->scroll), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error printing file:\n%s", error->message); gtk_widget_show (error_dialog); g_error_free (error); } g_object_unref (editor->print_operation); }
static void photos_base_item_print_load (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object); GtkWindow *toplevel = GTK_WINDOW (user_data); GeglNode *node; GtkPrintOperation *print_op; node = photos_base_item_load_finish (self, res, NULL); if (node == NULL) goto out; print_op = photos_print_operation_new (self, node); g_signal_connect_data (print_op, "done", G_CALLBACK (photos_base_item_print_operation_done), g_object_ref (self), (GClosureNotify) g_object_unref, G_CONNECT_SWAPPED); /* It is self managing. */ photos_print_notification_new (print_op); gtk_print_operation_run (print_op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, toplevel, NULL); out: g_clear_object (&node); g_object_unref (toplevel); }
static void ide_editor_view_actions_print (GSimpleAction *action, GVariant *param, gpointer user_data) { IdeEditorView *self = user_data; GtkWidget *toplevel; g_autoptr(IdeEditorPrintOperation) operation; GtkPrintOperationResult result; g_assert (IDE_IS_EDITOR_VIEW (self)); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self)); operation = ide_editor_print_operation_new (self->frame1->source_view); /* keep a ref until "done" is emitted */ g_object_ref (operation); g_signal_connect_after (operation, "done", G_CALLBACK (print_done), g_object_ref (self)); result = gtk_print_operation_run (GTK_PRINT_OPERATION (operation), GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (toplevel), NULL); handle_print_result (self, GTK_PRINT_OPERATION (operation), result); }
static void get_view_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { GtkPrintOperation *operation = user_data; EBookClient *book_client = E_BOOK_CLIENT (source_object); EBookClientView *client_view = NULL; EContactPrintContext *ctxt; GError *error = NULL; e_book_client_get_view_finish (book_client, result, &client_view, &error); ctxt = g_object_get_data (G_OBJECT (operation), "contact-print-ctx"); g_return_if_fail (ctxt != NULL); if (error != NULL) { g_warning ( "%s: Failed to get view: %s", G_STRFUNC, error->message); g_error_free (error); gtk_print_operation_run (operation, ctxt->action, NULL, NULL); g_object_unref (operation); } else { g_signal_connect ( client_view, "objects-added", G_CALLBACK (contacts_added), ctxt); g_signal_connect ( client_view, "complete", G_CALLBACK (view_complete), operation); e_book_client_view_start (client_view, &error); if (error != NULL) { g_warning ( "%s: Failed to start view: %s", G_STRFUNC, error->message); g_error_free (error); gtk_print_operation_run (operation, ctxt->action, NULL, NULL); g_object_unref (operation); } } }
static void printing_print_gtk(GeanyDocument *doc) { GtkPrintOperation *op; GtkPrintOperationResult res = GTK_PRINT_OPERATION_RESULT_ERROR; GError *error = NULL; DocInfo *dinfo; PrintWidgets *widgets; /** TODO check for monospace font, detect the widest character in the font and * use it at font_width */ widgets = g_new0(PrintWidgets, 1); dinfo = g_new0(DocInfo, 1); /* all other fields are initialised in begin_print() */ dinfo->doc = doc; op = gtk_print_operation_new(); gtk_print_operation_set_unit(op, GTK_UNIT_POINTS); gtk_print_operation_set_show_progress(op, TRUE); #if GTK_CHECK_VERSION(2, 18, 0) gtk_print_operation_set_embed_page_setup(op, TRUE); #endif g_signal_connect(op, "begin-print", G_CALLBACK(begin_print), dinfo); g_signal_connect(op, "end-print", G_CALLBACK(end_print), dinfo); g_signal_connect(op, "draw-page", G_CALLBACK(draw_page), dinfo); g_signal_connect(op, "status-changed", G_CALLBACK(status_changed), doc->file_name); g_signal_connect(op, "create-custom-widget", G_CALLBACK(create_custom_widget), widgets); g_signal_connect(op, "custom-widget-apply", G_CALLBACK(custom_widget_apply), widgets); if (settings != NULL) gtk_print_operation_set_print_settings(op, settings); if (page_setup != NULL) gtk_print_operation_set_default_page_setup(op, page_setup); res = gtk_print_operation_run( op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(main_widgets.window), &error); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (settings != NULL) g_object_unref(settings); settings = g_object_ref(gtk_print_operation_get_print_settings(op)); /* status message is printed in the status-changed handler */ } else if (res == GTK_PRINT_OPERATION_RESULT_ERROR) { dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Printing of %s failed (%s)."), doc->file_name, error->message); g_error_free(error); } g_object_unref(op); g_free(dinfo); g_free(widgets); }
void calendar_print_start_cb (GtkWidget *widget, gpointer user_data) { GUI *appGUI = (GUI *) user_data; GtkPrintOperation *print; GtkPrintOperationResult result; GError *error = NULL; gchar buffer[BUFFER_SIZE]; g_strlcpy (config.cal_print_month_name_font, gtk_entry_get_text (GTK_ENTRY (appGUI->cal->print_month_name_font_entry)), MAXFONTNAME); g_strlcpy (config.cal_print_day_name_font, gtk_entry_get_text (GTK_ENTRY (appGUI->cal->print_day_name_font_entry)), MAXFONTNAME); g_strlcpy (config.cal_print_day_num_font, gtk_entry_get_text (GTK_ENTRY (appGUI->cal->print_day_num_font_entry)), MAXFONTNAME); g_strlcpy (config.cal_print_event_font, gtk_entry_get_text (GTK_ENTRY (appGUI->cal->print_event_font_entry)), MAXFONTNAME); config.cal_print_event_length = gtk_spin_button_get_value (GTK_SPIN_BUTTON (appGUI->cal->print_event_length_spinbutton)); config.cal_print_padding = gtk_spin_button_get_value (GTK_SPIN_BUTTON (appGUI->cal->print_padding_spinbutton)); config.cal_print_page_orientation = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_portrait_radiobutton)) ? PORTRAIT : LANDSCAPE; config.cal_print_tasks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_tasks_checkbutton)); config.cal_print_birthdays = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_birthdays_checkbutton)); config.cal_print_namedays = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_namedays_checkbutton)); config.cal_print_day_notes = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_day_notes_checkbutton)); config.cal_print_ical = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_ical_checkbutton)); gtk_widget_destroy (appGUI->cal->window_print_options); print = gtk_print_operation_new (); appGUI->print_lines_per_page = 0; appGUI->print_nlines = 0; appGUI->print_npages = 0; g_signal_connect (print, "begin_print", G_CALLBACK (calendar_begin_print), appGUI); g_signal_connect (print, "draw_page", G_CALLBACK (calendar_draw_page), appGUI); result = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (appGUI->main_window), &error); if (result == GTK_PRINT_OPERATION_RESULT_ERROR) { g_snprintf (buffer, BUFFER_SIZE, "%s: %s", _("Error printing"), error->message); utl_gui_create_dialog (GTK_MESSAGE_ERROR, buffer, GTK_WINDOW (appGUI->main_window)); g_error_free (error); } g_object_unref (print); }
void x_print (GschemToplevel *w_current) { static GtkPrintSettings *settings = NULL; GtkPageSetup *setup; GtkPrintOperation *print; GtkPrintOperationResult res; GError *err = NULL; int num_pages = 1; /* Create the print operation and set it up */ print = GTK_PRINT_OPERATION (g_object_new (GTK_TYPE_PRINT_OPERATION, "n-pages", num_pages, "use-full-page", FALSE, "unit", GTK_UNIT_POINTS, NULL)); if (settings != NULL) { gtk_print_operation_set_print_settings (print, settings); } setup = x_print_default_page_setup (w_current->toplevel, w_current->toplevel->page_current); gtk_print_operation_set_default_page_setup (print, setup); g_signal_connect (print, "draw_page", G_CALLBACK (draw_page__print_operation), w_current); res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (w_current->main_window), &err); if (res == GTK_PRINT_OPERATION_RESULT_ERROR) { /* If printing failed due to an error, show an error dialog */ GtkWidget *error_dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Error printing file:\n%1$s"), err->message); g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (error_dialog); g_error_free (err); } else if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { /* We're supposed to store the print settings, so do that */ if (settings != NULL) { g_object_unref (settings); } settings = GTK_PRINT_SETTINGS (g_object_ref (gtk_print_operation_get_print_settings (print))); } /* Clean up */ g_object_unref (print); }
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; }
void a_print(VikWindow *vw, VikViewport *vvp) { /* TODO: make print_settings non-static when saving_settings_to_file is * implemented. Keep it static for now to retain settings for each * viking session */ static GtkPrintSettings *print_settings = NULL; GtkPrintOperation *print_oper; GtkPrintOperationResult res; PrintData data; print_oper = gtk_print_operation_new (); data.num_pages = 1; data.vw = vw; data.vvp = vvp; data.offset_x = 0; data.offset_y = 0; data.center = VIK_PRINT_CENTER_BOTH; data.use_full_page = FALSE; data.operation = print_oper; data.xmpp = vik_viewport_get_xmpp(vvp); data.ympp = vik_viewport_get_ympp(vvp); data.width = vik_viewport_get_width(vvp); data.height = vik_viewport_get_height(vvp); data.xres = data.yres = 230; /* FIXME */ if (print_settings != NULL) gtk_print_operation_set_print_settings (print_oper, print_settings); g_signal_connect (print_oper, "begin_print", G_CALLBACK (begin_print), &data); g_signal_connect (print_oper, "draw_page", G_CALLBACK (draw_page), &data); g_signal_connect (print_oper, "end-print", G_CALLBACK (end_print), &data); g_signal_connect (print_oper, "create-custom-widget", G_CALLBACK (create_custom_widget_cb), &data); gtk_print_operation_set_custom_tab_label (print_oper, _("Image Settings")); res = gtk_print_operation_run (print_oper, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (vw), NULL); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (print_settings != NULL) g_object_unref (print_settings); print_settings = g_object_ref (gtk_print_operation_get_print_settings (print_oper)); } g_object_unref (print_oper); }
void print(zathura_t* zathura) { g_return_if_fail(zathura != NULL); g_return_if_fail(zathura->document != NULL); GtkPrintOperation* print_operation = gtk_print_operation_new(); /* print operation settings */ gtk_print_operation_set_job_name(print_operation, zathura_document_get_path(zathura->document)); gtk_print_operation_set_allow_async(print_operation, TRUE); gtk_print_operation_set_n_pages(print_operation, zathura_document_get_number_of_pages(zathura->document)); gtk_print_operation_set_current_page(print_operation, zathura_document_get_current_page_number(zathura->document)); gtk_print_operation_set_use_full_page(print_operation, TRUE); if (zathura->print.settings != NULL) { gtk_print_operation_set_print_settings(print_operation, zathura->print.settings); } if (zathura->print.page_setup != NULL) { gtk_print_operation_set_default_page_setup(print_operation, zathura->print.page_setup); } gtk_print_operation_set_embed_page_setup(print_operation, TRUE); /* print operation signals */ g_signal_connect(print_operation, "draw-page", G_CALLBACK(cb_print_draw_page), zathura); g_signal_connect(print_operation, "end-print", G_CALLBACK(cb_print_end), zathura); g_signal_connect(print_operation, "request-page-setup", G_CALLBACK(cb_print_request_page_setup), zathura); /* print */ GError* error = NULL; GtkPrintOperationResult result = gtk_print_operation_run(print_operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(zathura->ui.session->gtk.window), &error); if (result == GTK_PRINT_OPERATION_RESULT_ERROR) { girara_notify(zathura->ui.session, GIRARA_ERROR, _("Printing failed: %s"), error->message); g_error_free(error); } else if (result == GTK_PRINT_OPERATION_RESULT_APPLY) { g_clear_object(&zathura->print.settings); g_clear_object(&zathura->print.page_setup); /* save previous settings */ zathura->print.settings = g_object_ref(gtk_print_operation_get_print_settings(print_operation)); zathura->print.page_setup = g_object_ref(gtk_print_operation_get_default_page_setup(print_operation)); } g_object_unref(print_operation); }
static void draw_page(GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data) { cairo_t *cr; PangoLayout *layout; double w, h; struct graphics_context gc = { .printer = 1 }; cr = gtk_print_context_get_cairo_context(context); gc.cr = cr; layout=gtk_print_context_create_pango_layout(context); w = gtk_print_context_get_width(context); h = gtk_print_context_get_height(context); /* Do the profile on the top half of the page.. */ plot(&gc, w, h/2, current_dive); pango_cairo_show_layout(cr,layout); g_object_unref(layout); } static void begin_print(GtkPrintOperation *operation, gpointer user_data) { } static GtkPrintSettings *settings = NULL; void do_print(void) { GtkPrintOperation *print; GtkPrintOperationResult res; print = gtk_print_operation_new(); if (settings != NULL) gtk_print_operation_set_print_settings(print, settings); gtk_print_operation_set_n_pages(print, 1); g_signal_connect(print, "begin_print", G_CALLBACK(begin_print), NULL); g_signal_connect(print, "draw_page", G_CALLBACK(draw_page), NULL); res = gtk_print_operation_run(print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(main_window), NULL); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (settings != NULL) g_object_unref(settings); settings = g_object_ref(gtk_print_operation_get_print_settings(print)); } g_object_unref(print); }
void cairo_print_callback (DiagramData *data, const gchar *filename, guint flags, /* further additions */ void *user_data) { GtkPrintOperation *op = create_print_operation (data, filename ? filename : "diagram"); GtkPrintOperationResult res; GError *error = NULL; res = gtk_print_operation_run (op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, NULL, &error); if (GTK_PRINT_OPERATION_RESULT_ERROR == res) { message_error (error->message); g_error_free (error); } }
void e_contact_print (EBookClient *book_client, EBookQuery *query, const GSList *contact_list, GtkPrintOperationAction action) { GtkPrintOperation *operation; EContactPrintContext *ctxt; ctxt = g_new0 (EContactPrintContext, 1); ctxt->action = action; ctxt->contact_list = e_client_util_copy_object_slist (NULL, contact_list); ctxt->style = g_new0 (EContactPrintStyle, 1); ctxt->page_nr = 0; ctxt->pages = 0; operation = e_print_operation_new (); gtk_print_operation_set_n_pages (operation, 1); g_object_set_data_full ( G_OBJECT (operation), "contact-print-ctx", ctxt, g_free); g_signal_connect ( operation, "begin-print", G_CALLBACK (contact_begin_print), ctxt); g_signal_connect ( operation, "draw_page", G_CALLBACK (contact_draw_page), ctxt); g_signal_connect ( operation, "end-print", G_CALLBACK (contact_end_print), ctxt); if (book_client) { gchar *query_str = e_book_query_to_string (query); e_book_client_get_view ( book_client, query_str, NULL, get_view_ready_cb, operation); g_free (query_str); } else { gtk_print_operation_run (operation, action, NULL, NULL); g_object_unref (operation); } }
static void print_pixbuf (GObject * ignored, gpointer user_data) { GtkPrintOperation *print; GtkPrintOperationResult res; ViewerCbInfo *info = (ViewerCbInfo *) user_data; print = gtk_print_operation_new (); g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), info); g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), info); res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (info->window), NULL); g_object_unref (print); }
void create_gtkprint_preview_session(GtkTextView *text_view, const gchar *title) { GtkPrintOperation *op; GtkPrintOperationResult res; GError *err = NULL; page_title = title; op = create_print_operation(text_view); res = gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PREVIEW, GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(text_view))), &err); if (res == GTK_PRINT_OPERATION_RESULT_ERROR) { create_error_dialog(text_view, err->message); g_error_free(err); } g_object_unref(op); }
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; }
/* File->Print... */ void action_print(GtkAction *action, I7Document *document) { GError *error = NULL; I7App *theapp = i7_app_get(); GtkPrintOperation *print = gtk_print_operation_new(); GtkPrintSettings *settings = i7_app_get_print_settings(theapp); if(settings) gtk_print_operation_set_print_settings(print, settings); g_signal_connect(print, "begin-print", G_CALLBACK(on_begin_print), document); GtkPrintOperationResult result = gtk_print_operation_run(print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(document), &error); if(result == GTK_PRINT_OPERATION_RESULT_APPLY) i7_app_set_print_settings(theapp, g_object_ref(gtk_print_operation_get_print_settings(print))); else if(result == GTK_PRINT_OPERATION_RESULT_ERROR) /* TRANSLATORS: File->Print... */ error_dialog(GTK_WINDOW(document), error, _("There was an error printing: ")); g_object_unref(print); }
void XAP_UnixDialog_Print::runModal(XAP_Frame * pFrame) { m_pFrame = pFrame; setupPrint(); gtk_print_operation_set_show_progress(m_pPO, TRUE); XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(m_pFrame->getFrameImpl()); // Get the GtkWindow of the parent frame GtkWidget * parent = pUnixFrameImpl->getTopLevelWindow(); GtkWindow * pPWindow = GTK_WINDOW(parent); // const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet(); // const gchar * szDialogName = einterpret_cast<const gchar *>(pSS->getValue(XAP_STRING_ID_DLG_UP_PrintTitle); gtk_print_operation_run (m_pPO, (m_bIsPreview)? GTK_PRINT_OPERATION_ACTION_PREVIEW: GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, pPWindow, NULL); cleanup(); }
static VALUE po_run(int argc, VALUE *argv, VALUE self) { VALUE action, parent, rb_result; GtkPrintOperationResult result; GError *error = NULL; rb_scan_args(argc, argv, "11", &action, &parent); result = gtk_print_operation_run(_SELF(self), RVAL2GENUM(action, GTK_TYPE_PRINT_OPERATION_ACTION), RVAL2GOBJ(parent), &error); rb_result = GENUM2RVAL(result, GTK_TYPE_PRINT_OPERATION_RESULT); if (rb_block_given_p()) { return rb_yield(rb_result); } else { if (result == GTK_PRINT_OPERATION_RESULT_ERROR) RAISE_GERROR(error); return rb_result; } }
static void print_or_preview (GSimpleAction *action, GtkPrintOperationAction print_action) { GtkPrintOperation *print; PrintData *print_data; print_data = g_new0 (PrintData, 1); print_data->text = get_text (); print_data->font = g_strdup ("Sans 12"); print = gtk_print_operation_new (); gtk_print_operation_set_track_print_status (print, TRUE); if (settings != NULL) gtk_print_operation_set_print_settings (print, settings); if (page_setup != NULL) gtk_print_operation_set_default_page_setup (print, page_setup); g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), print_data); g_signal_connect (print, "end-print", G_CALLBACK (end_print), print_data); g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), print_data); g_signal_connect (print, "create_custom_widget", G_CALLBACK (create_custom_widget), print_data); g_signal_connect (print, "custom_widget_apply", G_CALLBACK (custom_widget_apply), print_data); g_signal_connect (print, "preview", G_CALLBACK (preview_cb), print_data); g_signal_connect (print, "done", G_CALLBACK (print_done), print_data); gtk_print_operation_set_export_filename (print, "test.pdf"); #if 0 gtk_print_operation_set_allow_async (print, TRUE); #endif gtk_print_operation_run (print, print_action, GTK_WINDOW (main_window), NULL); g_object_unref (print); }
static void view_complete (EBookClientView *client_view, const GError *error, GtkPrintOperation *operation) { EContactPrintContext *ctxt; g_return_if_fail (operation != NULL); ctxt = g_object_get_data (G_OBJECT (operation), "contact-print-ctx"); g_return_if_fail (ctxt != NULL); e_book_client_view_stop (client_view, NULL); g_signal_handlers_disconnect_by_func ( client_view, G_CALLBACK (contacts_added), ctxt); g_signal_handlers_disconnect_by_func ( client_view, G_CALLBACK (view_complete), operation); g_object_unref (client_view); gtk_print_operation_run (operation, ctxt->action, NULL, NULL); g_object_unref (operation); }
//! //! @brief Sets up a print operation for the current results //! //! The function checks the results of the results text buffer, and then attempts //! to set up a print operation. If a section of the search results are highlighted //! only those results are printed. //! void gw_print (const GtkPrintOperationAction ACTION, GwSearchWindow *window) { //Declarations GwPrintData *data; GtkPrintOperation *operation; GtkPrintOperationResult res; //Initializations data = gw_printdata_new (window); operation = gtk_print_operation_new (); //Force at least some minimal margins on the pages that print gtk_print_operation_set_default_page_setup (operation, NULL); gtk_print_operation_set_use_full_page (operation, FALSE); gtk_print_operation_set_unit (operation, GTK_UNIT_MM); if (_settings != NULL) gtk_print_operation_set_print_settings (operation, _settings); g_signal_connect (operation, "begin_print", G_CALLBACK (_begin_print), data); g_signal_connect (operation, "draw_page", G_CALLBACK (_draw_page), data); g_signal_connect (operation, "paginate", G_CALLBACK (_paginate), data); g_signal_connect (operation, "done", G_CALLBACK (_done), data); res = gtk_print_operation_run (operation, ACTION, NULL, NULL); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (_settings != NULL) g_object_unref (_settings); _settings = g_object_ref (gtk_print_operation_get_print_settings (operation)); } //Cleanup gw_printdata_free (data); g_object_unref (operation); }
gint yad_print_run (void) { GtkWidget *dlg; GtkWidget *box, *img, *lbl; gchar *uri, *job_name = NULL; GtkPrintCapabilities pcap; GtkPrintOperationAction act = GTK_PRINT_OPERATION_ACTION_PRINT; gint resp, ret = 0; GError *err = NULL; /* check if file is exists */ if (options.common_data.uri && options.common_data.uri[0]) { if (!g_file_test (options.common_data.uri, G_FILE_TEST_EXISTS)) { g_printerr (_("File %s not found.\n"), options.common_data.uri); return 1; } } else { g_printerr (_("Filename is not specified.\n")); return 1; } /* create print dialog */ dlg = gtk_print_unix_dialog_new (options.data.dialog_title, NULL); gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL); gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (dlg), TRUE); pcap = GTK_PRINT_CAPABILITY_PAGE_SET | GTK_PRINT_CAPABILITY_COPIES | GTK_PRINT_CAPABILITY_COLLATE | GTK_PRINT_CAPABILITY_REVERSE | GTK_PRINT_CAPABILITY_NUMBER_UP | GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT; if (options.common_data.preview && options.print_data.type != YAD_PRINT_RAW) pcap |= GTK_PRINT_CAPABILITY_PREVIEW; gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dlg), pcap); if (!settings.print_settings) settings.print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dlg)); uri = g_build_filename (g_get_current_dir (), "yad.pdf", NULL); gtk_print_settings_set (settings.print_settings, "output-uri", g_filename_to_uri (uri, NULL, NULL)); g_free (uri); gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dlg), settings.print_settings); if (settings.page_setup) gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dlg), settings.page_setup); /* set window behavior */ gtk_widget_set_name (dlg, "yad-dialog-window"); if (options.data.sticky) gtk_window_stick (GTK_WINDOW (dlg)); gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed); gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop); gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated); gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar); gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar); /* set window size and position */ if (!options.data.geometry) { gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height); if (options.data.center) gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER); else if (options.data.mouse) gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE); } else { /* parse geometry, if given. must be after showing widget */ gtk_widget_realize (dlg); gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry); } /* create yad's top box */ if (options.data.dialog_text || options.data.dialog_image) { #if !GTK_CHECK_VERSION(3,0,0) box = gtk_hbox_new (FALSE, 0); #else box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #endif if (options.data.dialog_image) { GdkPixbuf *pb = NULL; pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON); img = gtk_image_new_from_pixbuf (pb); if (pb) g_object_unref (pb); gtk_widget_set_name (img, "yad-dialog-image"); gtk_box_pack_start (GTK_BOX (box), img, FALSE, FALSE, 2); } if (options.data.dialog_text) { gchar *buf = g_strcompress (options.data.dialog_text); lbl = gtk_label_new (NULL); if (!options.data.no_markup) gtk_label_set_markup (GTK_LABEL (lbl), buf); else gtk_label_set_text (GTK_LABEL (lbl), buf); gtk_widget_set_name (lbl, "yad-dialog-label"); gtk_label_set_selectable (GTK_LABEL (lbl), options.data.selectable_labels); gtk_misc_set_alignment (GTK_MISC (lbl), options.data.text_align, 0.5); if (options.data.geometry || options.data.width != -1) gtk_label_set_line_wrap (GTK_LABEL (lbl), TRUE); gtk_box_pack_start (GTK_BOX (box), lbl, TRUE, TRUE, 2); g_signal_connect (G_OBJECT (lbl), "size-allocate", G_CALLBACK (size_allocate_cb), NULL); g_free (buf); } /* add tob box to dialog */ gtk_widget_show_all (box); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), box, TRUE, TRUE, 5); gtk_box_reorder_child (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), box, 0); } do { resp = gtk_dialog_run (GTK_DIALOG (dlg)); switch (resp) { case GTK_RESPONSE_APPLY: /* ask for preview */ act = GTK_PRINT_OPERATION_ACTION_PREVIEW; case GTK_RESPONSE_OK: /* run print */ settings.print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dlg)); settings.page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dlg)); job_name = g_strdup_printf ("yad-%s-%d", g_path_get_basename (options.common_data.uri), getpid ()); if (options.print_data.type != YAD_PRINT_RAW) { /* print text or image */ GtkPrintOperation *op = gtk_print_operation_new (); gtk_print_operation_set_unit (op, GTK_UNIT_POINTS); gtk_print_operation_set_print_settings (op, settings.print_settings); gtk_print_operation_set_default_page_setup (op, settings.page_setup); gtk_print_operation_set_job_name (op, job_name); switch (options.print_data.type) { case YAD_PRINT_TEXT: g_signal_connect (G_OBJECT (op), "begin-print", G_CALLBACK (begin_print_text), NULL); g_signal_connect (G_OBJECT (op), "draw-page", G_CALLBACK (draw_page_text), NULL); break; case YAD_PRINT_IMAGE: gtk_print_operation_set_n_pages (op, 1); g_signal_connect (G_OBJECT (op), "draw-page", G_CALLBACK (draw_page_image), NULL); break; default:; } if (gtk_print_operation_run (op, act, NULL, &err) == GTK_PRINT_OPERATION_RESULT_ERROR) { g_printerr (_("Printing failed: %s\n"), err->message); ret = 1; } } else { /* print raw ps or pdf data */ GtkPrinter *prnt; GtkPrintJob *job; prnt = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dlg)); if (g_str_has_suffix (options.common_data.uri, ".ps")) { if (!gtk_printer_accepts_ps (prnt)) { g_printerr (_("Printer doesn't support ps format.\n")); ret = 1; } } else if (g_str_has_suffix (options.common_data.uri, ".pdf")) { if (!gtk_printer_accepts_pdf (prnt)) { g_printerr (_("Printer doesn't support pdf format.\n")); ret = 1; } } else { g_printerr (_("This file type is not supported for raw printing.\n")); ret = 1; } if (ret == 1) break; job = gtk_print_job_new (job_name, prnt, settings.print_settings, settings.page_setup); if (gtk_print_job_set_source_file (job, options.common_data.uri, &err)) { gtk_print_job_send (job, (GtkPrintJobCompleteFunc) raw_print_done, &ret, NULL); gtk_main (); } else { g_printerr (_("Load source file failed: %s\n"), err->message); ret = 1; } } break; default: ret = 1; break; } } while (resp == GTK_RESPONSE_APPLY); gtk_widget_destroy (dlg); write_settings (); return ret; }
void gdict_show_print_dialog (GtkWindow *parent, GdictDefbox *defbox) { GtkPrintOperation *operation; GdictPrintData *data; gchar *print_font; gchar *word; GError *error; g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent)); g_return_if_fail (GDICT_IS_DEFBOX (defbox)); g_object_get (defbox, "word", &word, NULL); if (!word) { g_warning ("Print should be disabled."); return; } data = g_new0 (GdictPrintData, 1); data->defbox = defbox; data->word = word; operation = gtk_print_operation_new (); print_font = get_print_font (); data->font_desc = pango_font_description_from_string (print_font); data->font_size = pango_font_description_get_size (data->font_desc) / PANGO_SCALE; g_free (print_font); g_signal_connect (operation, "begin-print", G_CALLBACK (begin_print), data); g_signal_connect (operation, "draw-page", G_CALLBACK (draw_page), data); g_signal_connect (operation, "end-print", G_CALLBACK (end_print), data); error = NULL; gtk_print_operation_run (operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, parent, &error); g_object_unref (operation); if (error) { GtkWidget *dialog; dialog = gtk_message_dialog_new (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Unable to display the preview: %s"), error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); } }
static GimpPDBStatusType print_image (gint32 image_ID, gboolean interactive, GError **error) { GtkPrintOperation *operation; GtkPrintOperationResult result; gchar *temp_proc; gint32 layer; PrintData data; /* create a print layer from the projection */ layer = gimp_layer_new_from_visible (image_ID, image_ID, PRINT_PROC_NAME); operation = gtk_print_operation_new (); gtk_print_operation_set_n_pages (operation, 1); print_operation_set_name (operation, image_ID); print_page_setup_load (operation, image_ID); /* fill in the PrintData struct */ data.image_id = image_ID; data.drawable_id = layer; data.unit = gimp_get_default_unit (); data.image_unit = gimp_image_get_unit (image_ID); data.offset_x = 0; data.offset_y = 0; data.center = CENTER_BOTH; data.use_full_page = FALSE; data.operation = operation; gimp_image_get_resolution (image_ID, &data.xres, &data.yres); print_settings_load (&data); gtk_print_operation_set_unit (operation, GTK_UNIT_PIXEL); g_signal_connect (operation, "begin-print", G_CALLBACK (begin_print), &data); g_signal_connect (operation, "draw-page", G_CALLBACK (draw_page), &data); g_signal_connect (operation, "end-print", G_CALLBACK (end_print), &image_ID); print_operation = operation; temp_proc = print_temp_proc_install (image_ID); gimp_extension_enable (); if (interactive) { gimp_ui_init (PLUG_IN_BINARY, FALSE); g_signal_connect_swapped (operation, "end-print", G_CALLBACK (print_settings_save), &data); g_signal_connect (operation, "create-custom-widget", G_CALLBACK (create_custom_widget), &data); gtk_print_operation_set_custom_tab_label (operation, _("Image Settings")); result = gtk_print_operation_run (operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, NULL, error); } else { result = gtk_print_operation_run (operation, GTK_PRINT_OPERATION_ACTION_PRINT, NULL, error); } gimp_uninstall_temp_proc (temp_proc); g_free (temp_proc); print_operation = NULL; g_object_unref (operation); if (gimp_drawable_is_valid (layer)) gimp_drawable_delete (layer); switch (result) { case GTK_PRINT_OPERATION_RESULT_APPLY: case GTK_PRINT_OPERATION_RESULT_IN_PROGRESS: return GIMP_PDB_SUCCESS; case GTK_PRINT_OPERATION_RESULT_CANCEL: return GIMP_PDB_CANCEL; case GTK_PRINT_OPERATION_RESULT_ERROR: return GIMP_PDB_EXECUTION_ERROR; } return GIMP_PDB_EXECUTION_ERROR; }
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; }