GtkPageSetup * xviewer_print_get_page_setup (void) { GtkPageSetup *page_setup; GKeyFile *key_file; GError *error = NULL; key_file = xviewer_print_get_key_file (); if (key_file && g_key_file_has_group (key_file, XVIEWER_PAGE_SETUP_GROUP)) { page_setup = gtk_page_setup_new_from_key_file (key_file, XVIEWER_PAGE_SETUP_GROUP, &error); } else { page_setup = gtk_page_setup_new (); } if (error) { page_setup = gtk_page_setup_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 page_setup; }
/** * vik_print_preview_new: * @page: page setup * @drawable_id: the drawable to print * * Creates a new #VikPrintPreview widget. * * Return value: the new #VikPrintPreview widget. **/ GtkWidget * vik_print_preview_new (GtkPageSetup *page, GdkDrawable *drawable) { VikPrintPreview *preview; gfloat ratio; preview = g_object_new (VIK_TYPE_PRINT_PREVIEW, NULL); preview->drawable = drawable; if (page != NULL) preview->page = gtk_page_setup_copy (page); else preview->page = gtk_page_setup_new (); ratio = (gtk_page_setup_get_paper_width (preview->page, GTK_UNIT_POINTS) / gtk_page_setup_get_paper_height (preview->page, GTK_UNIT_POINTS)); gtk_aspect_frame_set (GTK_ASPECT_FRAME (preview), 0.5, 0.5, ratio, FALSE); gtk_widget_set_size_request (preview->area, DRAWING_AREA_SIZE, DRAWING_AREA_SIZE); return GTK_WIDGET (preview); }
static GtkPrintOperation *create_print_operation(GtkTextView *text_view) { GtkPrintOperation *op; static GtkPageSetup *page_setup = NULL; op = gtk_print_operation_new(); if (settings) gtk_print_operation_set_print_settings(op, settings); if (!page_setup) { page_setup = gtk_page_setup_new(); gtk_page_setup_set_top_margin(page_setup, 25.0, GTK_UNIT_MM); gtk_page_setup_set_bottom_margin(page_setup, 20.0, GTK_UNIT_MM); gtk_page_setup_set_left_margin(page_setup, 20.0, GTK_UNIT_MM); gtk_page_setup_set_right_margin(page_setup, 20.0, GTK_UNIT_MM); } gtk_print_operation_set_default_page_setup(op, page_setup); g_signal_connect(op, "begin-print", G_CALLBACK(cb_begin_print), text_view); g_signal_connect(op, "draw-page", G_CALLBACK(cb_draw_page), NULL); g_signal_connect(op, "end-print", G_CALLBACK(cb_end_print), NULL); return op; }
static void load_page_setup (GeditApp *app) { GeditAppPrivate *priv; gchar *filename; GError *error = NULL; priv = gedit_app_get_instance_private (app); g_return_if_fail (priv->page_setup == NULL); filename = get_page_setup_file (); priv->page_setup = gtk_page_setup_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->page_setup == NULL) { priv->page_setup = gtk_page_setup_new (); } }
/** * ephy_embed_shell_get_page_setup: * * Return value: (transfer none): **/ GtkPageSetup * ephy_embed_shell_get_page_setup (EphyEmbedShell *shell) { EphyEmbedShellPrivate *priv = ephy_embed_shell_get_instance_private (shell); g_return_val_if_fail (EPHY_IS_EMBED_SHELL (shell), NULL); if (priv->page_setup == NULL) { GError *error = NULL; char *path; path = g_build_filename (ephy_dot_dir (), PAGE_SETUP_FILENAME, NULL); priv->page_setup = gtk_page_setup_new_from_file (path, &error); g_free (path); if (error) g_error_free (error); /* If that still didn't work, create a new, empty one */ if (priv->page_setup == NULL) priv->page_setup = gtk_page_setup_new (); } return priv->page_setup; }
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; }
static void call_prepare_print (GtkPrintOperation *op, PortalData *portal) { GtkPrintOperationPrivate *priv = op->priv; GVariant *settings; GVariant *setup; GVariantBuilder opt_builder; GVariant *options; char *parent_window_str = NULL; g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT); options = g_variant_builder_end (&opt_builder); if (priv->print_settings) settings = gtk_print_settings_to_gvariant (priv->print_settings); else { GVariantBuilder builder; g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); settings = g_variant_builder_end (&builder); } if (priv->default_page_setup) setup = gtk_page_setup_to_gvariant (priv->default_page_setup); else { GtkPageSetup *page_setup = gtk_page_setup_new (); setup = gtk_page_setup_to_gvariant (page_setup); g_object_unref (page_setup); } if (portal->parent != NULL && gtk_widget_is_visible (GTK_WIDGET (portal->parent))) { GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (portal->parent)); #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_WINDOW (window)) parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window)); #endif } g_dbus_proxy_call (portal->proxy, "PreparePrint", g_variant_new ("(ss@a{sv}@a{sv}@a{sv})", parent_window_str ? parent_window_str : "", _("Print"), /* title */ settings, setup, options), G_DBUS_CALL_FLAGS_NONE, -1, NULL, prepare_print_called, portal); g_free (parent_window_str); }
CefSize ClientPrintHandlerGtk::GetPdfPaperSize(int device_units_per_inch) { GtkPageSetup* page_setup = gtk_page_setup_new(); float width = gtk_page_setup_get_paper_width(page_setup, GTK_UNIT_INCH); float height = gtk_page_setup_get_paper_height(page_setup, GTK_UNIT_INCH); g_object_unref(page_setup); return CefSize(width * device_units_per_inch, height * device_units_per_inch); }
static GtkPageSetup * load_page_setup (GKeyFile *key_file) { GtkPageSetup *page_setup; page_setup = gtk_page_setup_new (); if (g_key_file_has_group (key_file, PAGE_SETUP_GROUP_NAME)) gtk_page_setup_load_key_file ( page_setup, key_file, PAGE_SETUP_GROUP_NAME, NULL); return page_setup; }
bool decode(ArgumentDecoder* decoder, GRefPtr<GtkPageSetup>& pageSetup) { GOwnPtr<GKeyFile> keyFile; if (!decodeGKeyFile(decoder, keyFile)) return false; pageSetup = adoptGRef(gtk_page_setup_new()); if (!keyFile) return true; if (!gtk_page_setup_load_key_file(pageSetup.get(), keyFile.get(), "Page Setup", 0)) pageSetup = 0; return pageSetup; }
static GObject * xviewer_print_create_custom_widget (GtkPrintOperation *operation, gpointer user_data) { GtkPageSetup *page_setup; XviewerPrintData *data; xviewer_debug (DEBUG_PRINTING); data = (XviewerPrintData *)user_data; page_setup = gtk_print_operation_get_default_page_setup (operation); if (page_setup == NULL) page_setup = gtk_page_setup_new (); return G_OBJECT (xviewer_print_image_setup_new (data->image, page_setup)); }
static void photos_print_operation_constructed (GObject *object) { PhotosPrintOperation *self = PHOTOS_PRINT_OPERATION (object); GeglRectangle bbox; GtkPageSetup *page_setup; gchar *name; G_OBJECT_CLASS (photos_print_operation_parent_class)->constructed (object); page_setup = gtk_page_setup_new (); gtk_print_operation_set_default_page_setup (GTK_PRINT_OPERATION (self), page_setup); bbox = gegl_node_get_bounding_box (self->node); if (bbox.height >= bbox.width) gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_PORTRAIT); else gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_LANDSCAPE); g_object_unref (page_setup); name = g_strdup (photos_base_item_get_name (self->item)); if (name == NULL || name[0] == '\0') { GFile *file; const gchar *uri; gchar *basename; uri = photos_base_item_get_uri (self->item); file = g_file_new_for_uri (uri); basename = g_file_get_basename (file); if (g_utf8_validate (basename, -1, NULL)) name = g_strdup (basename); else name = g_filename_to_utf8 (basename, -1, NULL, NULL, NULL); g_free (basename); g_object_unref (file); } gtk_print_operation_set_job_name (GTK_PRINT_OPERATION (self), name); g_free (name); }
void calendar_begin_print (GtkPrintOperation *operation, GtkPrintContext *context, gpointer user_data) { GUI *appGUI = (GUI *) user_data; GtkPageSetup *setup; if (config.cal_print_page_orientation == LANDSCAPE) { setup = gtk_page_setup_new (); gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_LANDSCAPE); gtk_print_operation_set_default_page_setup (operation, setup); g_object_unref (setup); } appGUI->print_lines_per_page = 1; appGUI->print_nlines = 1; appGUI->print_npages = 1; gtk_print_operation_set_n_pages (operation, appGUI->print_npages); }
GtkPrintOperation * biorhythm_print_operation_new (BiorhythmChart *chart) { GtkPrintOperation *print; GtkPageSetup *page_setup; print = gtk_print_operation_new (); gtk_print_operation_set_n_pages (print, 1); gtk_print_operation_set_job_name (print, "Print Biorhythm"); gtk_print_operation_set_embed_page_setup (print, FALSE); page_setup = gtk_page_setup_new (); gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_LANDSCAPE); gtk_print_operation_set_default_page_setup (print, page_setup); g_signal_connect (print, "draw_page", G_CALLBACK (biorhythm_print_draw_page), chart); return print; }
/** --------------------------------------------------- */ 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(); }
/*! \brief Create a default page setup for a schematic page. * \par Function Description * Creates and returns a new #GtkPageSetup for \a page, taking into * account the requested \a paper_size_name. If \a paper_size_name is * NULL, the system default paper size is used. The \a orientation may * be LANDSCAPE, PORTRAIT or AUTOLAYOUT. If \a AUTOLAYOUT is chosen, * the page orientation that best fits the page contents is chosen. * * \param toplevel A #TOPLEVEL structure. * \param page The #PAGE to generate a page setup for. * \param paper_size_name The name of the paper size to use. * \param orientation The paper orientation to use. * * \returns A newly-created page setup. */ static GtkPageSetup * x_print_default_page_setup (TOPLEVEL *toplevel, PAGE *page) { GtkPageSetup *setup = gtk_page_setup_new (); GtkPaperSize *papersize; int status, wx_min, wy_min, wx_max, wy_max; EdaConfig *cfg; gchar *paper, *orientation; /* Get configuration values */ cfg = eda_config_get_context_for_path (s_page_get_filename (page)); paper = eda_config_get_string (cfg, CFG_GROUP_PRINTING, CFG_KEY_PRINTING_PAPER, NULL); orientation = eda_config_get_string (cfg, CFG_GROUP_PRINTING, CFG_KEY_PRINTING_ORIENTATION, NULL); /* If the paper size is valid, set it up with default margins. */ papersize = gtk_paper_size_new (paper); if (papersize != NULL) { gtk_page_setup_set_paper_size_and_default_margins (setup, papersize); } if (g_strcmp0 (orientation, "landscape") == 0) { gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_LANDSCAPE); } else if (g_strcmp0 (orientation, "portrait") == 0) { gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_PORTRAIT); } else if (orientation == NULL || g_strcmp0 (orientation, "auto") == 0) { /* Automatically choose the orientation that fits best */ status = world_get_object_glist_bounds (toplevel, s_page_objects (page), &wx_min, &wy_min, &wx_max, &wy_max); if (!status || (wx_max - wx_min) > (wy_max - wy_min)) { /* Default to landscape */ gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_LANDSCAPE); } else { gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_PORTRAIT); } } g_free (paper); g_free (orientation); return setup; }
GtkPrintOperation * create_print_operation (DiagramData *data, const char *name) { PrintData *print_data; GtkPrintOperation *operation; GtkPageSetup * setup; int num_pages; /* gets deleted in end_print */ print_data = g_new0 (PrintData, 1); print_data->data = g_object_ref (data); print_data->renderer = g_object_new (DIA_TYPE_CAIRO_RENDERER, NULL); operation = gtk_print_operation_new (); gtk_print_operation_set_job_name (operation, name); setup = gtk_print_operation_get_default_page_setup (operation); if (!setup) setup = gtk_page_setup_new (); _dia_to_gtk_page_setup (print_data->data, setup); gtk_print_operation_set_default_page_setup (operation, setup); g_object_unref (setup); /* similar logic draw_page() but we need to set the total pages in advance */ if (data->paper.fitto) { num_pages = data->paper.fitwidth * data->paper.fitheight; } else { int nx = ceil((data->extents.right - data->extents.left) / data->paper.width); int ny = ceil((data->extents.bottom - data->extents.top) / data->paper.height); num_pages = nx * ny; } gtk_print_operation_set_n_pages (operation, num_pages); gtk_print_operation_set_unit (operation, GTK_UNIT_MM); g_signal_connect (operation, "draw_page", G_CALLBACK (draw_page), print_data); g_signal_connect (operation, "begin_print", G_CALLBACK (begin_print), print_data); g_signal_connect (operation, "end_print", G_CALLBACK (end_print), print_data); return operation; }
Print::Print(SPDocument *doc, SPItem *base) : _doc (doc), _base (base) { g_assert (_doc); g_assert (_base); _printop = gtk_print_operation_new (); // set up dialog title, based on document name gchar *jobname = _doc->name ? _doc->name : _("SVG Document"); Glib::ustring title = _("Print"); title += " "; title += jobname; gtk_print_operation_set_job_name (_printop, title.c_str()); // set up paper size to match the document size gtk_print_operation_set_unit (_printop, GTK_UNIT_POINTS); GtkPageSetup *page_setup = gtk_page_setup_new(); gdouble doc_width = sp_document_width(_doc) * PT_PER_PX; gdouble doc_height = sp_document_height(_doc) * PT_PER_PX; GtkPaperSize *paper_size = gtk_paper_size_new_custom("custom", "custom", doc_width, doc_height, GTK_UNIT_POINTS); gtk_page_setup_set_paper_size (page_setup, paper_size); #ifndef WIN32 gtk_print_operation_set_default_page_setup (_printop, page_setup); #endif gtk_print_operation_set_use_full_page (_printop, TRUE); // set up signals _workaround._doc = _doc; _workaround._base = _base; _workaround._tab = &_tab; g_signal_connect (_printop, "create-custom-widget", G_CALLBACK (create_custom_widget), _tab.gobj()); g_signal_connect (_printop, "begin-print", G_CALLBACK (begin_print), NULL); g_signal_connect (_printop, "draw-page", G_CALLBACK (draw_page), &_workaround); // build custom preferences tab gtk_print_operation_set_custom_tab_label (_printop, _("Rendering")); }
void ephy_embed_shell_set_page_setup (EphyEmbedShell *shell, GtkPageSetup *page_setup) { EphyEmbedShellPrivate *priv = ephy_embed_shell_get_instance_private (shell); char *path; g_return_if_fail (EPHY_IS_EMBED_SHELL (shell)); if (page_setup != NULL) g_object_ref (page_setup); else page_setup = gtk_page_setup_new (); if (priv->page_setup != NULL) g_object_unref (priv->page_setup); priv->page_setup = page_setup; path = g_build_filename (ephy_dot_dir (), PAGE_SETUP_FILENAME, NULL); gtk_page_setup_to_file (page_setup, path, NULL); g_free (path); }
JNIEXPORT jlong JNICALL Java_org_gnome_gtk_GtkPageSetup_gtk_1page_1setup_1new ( JNIEnv* env, jclass cls ) { GtkPageSetup* result; jlong _result; // call function result = gtk_page_setup_new(); // translate return value to JNI type _result = (jlong) result; // cleanup return value if (result != NULL) { bindings_java_memory_cleanup((GObject*)result, TRUE); } // and finally return _result; }
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); }
GtkWidget * print_page_layout_gui (PrintData *data, const gchar *help_id) { GtkWidget *main_hbox; GtkWidget *main_vbox; GtkWidget *button; GtkWidget *frame; GtkPageSetup *setup; GtkSizeGroup *label_group; GtkSizeGroup *entry_group; memset (&info, 0, sizeof (PrintSizeInfo)); info.data = data; info.image_width = gimp_drawable_width (data->drawable_id); info.image_height = gimp_drawable_height (data->drawable_id); setup = gtk_print_operation_get_default_page_setup (data->operation); if (! setup) { setup = gtk_page_setup_new (); gtk_print_operation_set_default_page_setup (data->operation, setup); } /* main hbox */ main_hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); /* main vbox */ main_vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_hbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); entry_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* size entry area for the image's print size */ frame = print_size_frame (data, label_group, entry_group); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* offset entry area for the image's offset position */ frame = print_offset_frame (data, label_group, entry_group); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); g_object_unref (label_group); g_object_unref (entry_group); button = gtk_check_button_new_with_mnemonic (_("Ignore Page _Margins")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), data->use_full_page); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (print_size_info_use_full_page_toggled), NULL); gtk_widget_show (button); /* preview */ frame = gimp_frame_new (_("Preview")); gtk_box_pack_start (GTK_BOX (main_hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); info.preview = print_preview_new (setup, data->drawable_id); print_preview_set_use_full_page (PRINT_PREVIEW (info.preview), data->use_full_page); gtk_container_add (GTK_CONTAINER (frame), info.preview); gtk_widget_show (info.preview); g_signal_connect (info.preview, "offsets-changed", G_CALLBACK (print_size_info_preview_offset_changed), NULL); print_size_info_set_page_setup (&info); g_signal_connect_object (data->operation, "notify::default-page-setup", G_CALLBACK (print_page_setup_notify), main_hbox, 0); gimp_help_connect (main_hbox, gimp_standard_help_func, help_id, NULL); return main_hbox; }
GtkPrintOperation * xviewer_print_operation_new (XviewerImage *image, GtkPrintSettings *print_settings, GtkPageSetup *page_setup) { GtkPrintOperation *print; XviewerPrintData *data; gint width, height; xviewer_debug (DEBUG_PRINTING); print = gtk_print_operation_new (); data = g_slice_new0 (XviewerPrintData); data->left_margin = 0; data->top_margin = 0; data->scale_factor = 100; data->image = g_object_ref (image); data->unit = GTK_UNIT_INCH; xviewer_image_get_size (image, &width, &height); if (page_setup == NULL) page_setup = gtk_page_setup_new (); if (height >= width) { gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_PORTRAIT); } else { gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_LANDSCAPE); } gtk_print_operation_set_print_settings (print, print_settings); gtk_print_operation_set_default_page_setup (print, page_setup); gtk_print_operation_set_n_pages (print, 1); gtk_print_operation_set_job_name (print, xviewer_image_get_caption (image)); gtk_print_operation_set_embed_page_setup (print, TRUE); g_signal_connect (print, "draw_page", G_CALLBACK (xviewer_print_draw_page), data); g_signal_connect (print, "create-custom-widget", G_CALLBACK (xviewer_print_create_custom_widget), data); g_signal_connect (print, "custom-widget-apply", G_CALLBACK (xviewer_print_custom_widget_apply), data); g_signal_connect (print, "end-print", G_CALLBACK (xviewer_print_end_print), data); g_signal_connect (print, "update-custom-widget", G_CALLBACK (xviewer_print_image_setup_update), data); gtk_print_operation_set_custom_tab_label (print, _("Image Settings")); return print; }
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); } }
void ClientPrintHandlerGtk::OnPrintSettings( CefRefPtr<CefPrintSettings> settings, bool get_defaults) { if (get_defaults) { DCHECK(!page_setup_); DCHECK(!printer_); // |gtk_settings_| is a new copy. gtk_settings_ = gtk_print_settings_copy(GetLastUsedSettings()->settings()); page_setup_ = gtk_page_setup_new(); } else { if (!gtk_settings_) { gtk_settings_ = gtk_print_settings_copy(GetLastUsedSettings()->settings()); } GtkPrinterList* printer_list = new GtkPrinterList; printer_ = printer_list->GetPrinterWithName(settings->GetDeviceName()); if (printer_) { g_object_ref(printer_); gtk_print_settings_set_printer(gtk_settings_, gtk_printer_get_name(printer_)); if (!page_setup_) { page_setup_ = gtk_printer_get_default_page_size(printer_); } } gtk_print_settings_set_n_copies(gtk_settings_, settings->GetCopies()); gtk_print_settings_set_collate(gtk_settings_, settings->WillCollate()); std::string color_value; std::string color_setting_name; GetColorModelForMode(settings->GetColorModel(), &color_setting_name, &color_value); gtk_print_settings_set(gtk_settings_, color_setting_name.c_str(), color_value.c_str()); if (settings->GetDuplexMode() != DUPLEX_MODE_UNKNOWN) { const char* cups_duplex_mode = NULL; switch (settings->GetDuplexMode()) { case DUPLEX_MODE_LONG_EDGE: cups_duplex_mode = kDuplexNoTumble; break; case DUPLEX_MODE_SHORT_EDGE: cups_duplex_mode = kDuplexTumble; break; case DUPLEX_MODE_SIMPLEX: cups_duplex_mode = kDuplexNone; break; default: // UNKNOWN_DUPLEX_MODE NOTREACHED(); break; } gtk_print_settings_set(gtk_settings_, kCUPSDuplex, cups_duplex_mode); } if (!page_setup_) page_setup_ = gtk_page_setup_new(); gtk_print_settings_set_orientation( gtk_settings_, settings->IsLandscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE : GTK_PAGE_ORIENTATION_PORTRAIT); delete printer_list; } InitPrintSettings(gtk_settings_, page_setup_, settings); }
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; }
static GtkWidget *create_custom_widget_cb(GtkPrintOperation *operation, PrintData *data) { GtkWidget *layout; GtkWidget *main_hbox; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *button; GtkWidget *label; GtkPageSetup *setup; CustomWidgetInfo *info = g_malloc0(sizeof(CustomWidgetInfo)); g_signal_connect_swapped (data->operation, _("done"), G_CALLBACK (custom_widgets_cleanup), info); info->data = data; setup = gtk_print_operation_get_default_page_setup (data->operation); if (! setup) { setup = gtk_page_setup_new (); gtk_print_operation_set_default_page_setup (data->operation, setup); } layout = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (layout), 12); /* main hbox */ main_hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (layout), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* main vbox */ main_vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_hbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /* Page Size */ button = gtk_button_new_with_mnemonic (_("_Adjust Page Size " "and Orientation")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (page_setup_cb), info); gtk_widget_show (button); /* Center */ GtkWidget *combo; const PrintCenterName *center; hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("C_enter:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = vik_combo_box_text_new (); for (center = center_modes; center->name; center++) { vik_combo_box_text_append (combo, _(center->name)); } gtk_combo_box_set_active(GTK_COMBO_BOX(combo), VIK_PRINT_CENTER_BOTH); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); g_signal_connect(combo, "changed", G_CALLBACK(center_changed_cb), info); info->center_combo = combo; /* ignore page margins */ button = gtk_check_button_new_with_mnemonic (_("Ignore Page _Margins")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), data->use_full_page); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (full_page_toggled_cb), info); gtk_widget_show (button); /* scale */ vbox = gtk_vbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Image S_ize:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); info->scale_label = label; gtk_box_pack_start (GTK_BOX (hbox), info->scale_label, TRUE, TRUE, 0); gtk_widget_show (info->scale_label); info->scale = gtk_hscale_new_with_range(1, 100, 1); gtk_box_pack_start (GTK_BOX (vbox), info->scale, TRUE, TRUE, 0); gtk_scale_set_draw_value(GTK_SCALE(info->scale), FALSE); gtk_widget_show (info->scale); gtk_label_set_mnemonic_widget (GTK_LABEL (label), info->scale); g_signal_connect(info->scale, "change_value", G_CALLBACK(scale_change_value_cb), info); info->preview = vik_print_preview_new (setup, GDK_DRAWABLE(vik_viewport_get_pixmap(data->vvp))); vik_print_preview_set_use_full_page (VIK_PRINT_PREVIEW(info->preview), data->use_full_page); gtk_box_pack_start (GTK_BOX (main_hbox), info->preview, TRUE, TRUE, 0); gtk_widget_show (info->preview); g_signal_connect (info->preview, "offsets-changed", G_CALLBACK (preview_offsets_changed_cb), info); update_page_setup (info); gdouble offset_x_max, offset_y_max; get_max_offsets (info, &offset_x_max, &offset_y_max); vik_print_preview_set_image_offsets_max (VIK_PRINT_PREVIEW (info->preview), offset_x_max, offset_y_max); set_scale_value(info); return layout; }
static VALUE rg_initialize(VALUE self) { G_INITIALIZE(self, gtk_page_setup_new()); return Qnil; }