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