static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
GtkPaperSize *size;
if (argc <= 1) {
VALUE name;
rb_scan_args(argc, argv, "01", &name);
size = gtk_paper_size_new(RVAL2CSTR_ACCEPT_NIL(name));
} else if (argc == 4) {
size = gtk_paper_size_new_from_ppd(RVAL2CSTR(argv[0]),
RVAL2CSTR(argv[1]),
NUM2DBL(argv[2]),
NUM2DBL(argv[3]));
} else if (argc == 5) {
size = gtk_paper_size_new_custom(RVAL2CSTR(argv[0]),
RVAL2CSTR(argv[1]),
NUM2DBL(argv[2]),
NUM2DBL(argv[3]),
RVAL2UNIT(argv[4]));
} else {
rb_raise(rb_eArgError,
"wrong number of arguments (%d for 0, 1, 4 or 5)", argc);
}
G_INITIALIZE(self, size);
return Qnil;
}
NS_IMETHODIMP
nsPrintSettingsGTK::SetPaperName(const char16_t * aPaperName)
{
NS_ConvertUTF16toUTF8 gtkPaperName(aPaperName);
// Convert these Goanna names to GTK names
if (gtkPaperName.EqualsIgnoreCase("letter"))
gtkPaperName.AssignLiteral(GTK_PAPER_NAME_LETTER);
else if (gtkPaperName.EqualsIgnoreCase("legal"))
gtkPaperName.AssignLiteral(GTK_PAPER_NAME_LEGAL);
// Try to get the display name from the name so our paper size fits in the Page Setup dialog.
GtkPaperSize* paperSize = gtk_paper_size_new(gtkPaperName.get());
char* displayName = strdup(gtk_paper_size_get_display_name(paperSize));
gtk_paper_size_free(paperSize);
paperSize = gtk_paper_size_new_custom(gtkPaperName.get(), displayName,
gtk_paper_size_get_width(mPaperSize, GTK_UNIT_INCH),
gtk_paper_size_get_height(mPaperSize, GTK_UNIT_INCH),
GTK_UNIT_INCH);
free(displayName);
gtk_paper_size_free(mPaperSize);
mPaperSize = paperSize;
SaveNewPageSize();
return NS_OK;
}
/* Parse the --paper option. Clears any size setting. */
static gboolean
export_parse_paper (const gchar *paper)
{
GtkPaperSize *paper_size = gtk_paper_size_new (paper);
if (paper_size == NULL) return FALSE;
if (settings.paper != NULL) gtk_paper_size_free (settings.paper);
settings.paper = paper_size;
/* Must reset size setting to invalid or it will override paper
* setting */
settings.size[0] = settings.size[1] = -1;
return TRUE;
}
/** -------------------------------------------------------
* Initialize the nsDeviceContextSpecGTK
* @update dc 2/15/98
* @update syd 3/2/99
*/
NS_IMETHODIMP nsDeviceContextSpecGTK::Init(nsIWidget *aWidget,
nsIPrintSettings* aPS,
PRBool aIsPrintPreview)
{
DO_PR_DEBUG_LOG(("nsDeviceContextSpecGTK::Init(aPS=%p)\n", aPS));
if (gtk_major_version < 2 ||
(gtk_major_version == 2 && gtk_minor_version < 10))
return NS_ERROR_NOT_AVAILABLE; // I'm so sorry bz
mPrintSettings = aPS;
mIsPPreview = aIsPrintPreview;
// This is only set by embedders
PRBool toFile;
aPS->GetPrintToFile(&toFile);
mToPrinter = !toFile && !aIsPrintPreview;
nsCOMPtr<nsPrintSettingsGTK> printSettingsGTK(do_QueryInterface(aPS));
if (!printSettingsGTK)
return NS_ERROR_NO_INTERFACE;
mGtkPrinter = printSettingsGTK->GetGtkPrinter();
mGtkPrintSettings = printSettingsGTK->GetGtkPrintSettings();
mGtkPageSetup = printSettingsGTK->GetGtkPageSetup();
// This is a horrible workaround for some printer driver bugs that treat custom page sizes different
// to standard ones. If our paper object matches one of a standard one, use a standard paper size
// object instead. See bug 414314 for more info.
GtkPaperSize* geckosHackishPaperSize = gtk_page_setup_get_paper_size(mGtkPageSetup);
GtkPaperSize* standardGtkPaperSize = gtk_paper_size_new(gtk_paper_size_get_name(geckosHackishPaperSize));
mGtkPageSetup = gtk_page_setup_copy(mGtkPageSetup);
mGtkPrintSettings = gtk_print_settings_copy(mGtkPrintSettings);
GtkPaperSize* properPaperSize;
if (gtk_paper_size_is_equal(geckosHackishPaperSize, standardGtkPaperSize)) {
properPaperSize = standardGtkPaperSize;
} else {
properPaperSize = geckosHackishPaperSize;
gtk_paper_size_free(standardGtkPaperSize);
}
gtk_print_settings_set_paper_size(mGtkPrintSettings, properPaperSize);
gtk_page_setup_set_paper_size_and_default_margins(mGtkPageSetup, properPaperSize);
return NS_OK;
}
static void
request_page_setup (GtkPrintOperation *operation,
GtkPrintContext *context,
int page_nr,
GtkPageSetup *setup)
{
/* Make the second page landscape mode a5 */
if (page_nr == 1)
{
GtkPaperSize *a5_size = gtk_paper_size_new ("iso_a5");
gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_LANDSCAPE);
gtk_page_setup_set_paper_size (setup, a5_size);
gtk_paper_size_free (a5_size);
}
}
/** ---------------------------------------------------
*/
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;
}
static void
update_format_examples (GtkDialog *chooser)
{
CcFormatChooserPrivate *priv = GET_PRIVATE (chooser);
gchar *locale;
GDateTime *dt;
gchar *s;
const gchar *fmt;
GtkPaperSize *paper;
locale = g_strdup (setlocale (LC_TIME, NULL));
setlocale (LC_TIME, priv->region);
dt = g_date_time_new_now_local ();
display_date (priv->full_date, dt, "%A %e %B %Y");
display_date (priv->medium_date, dt, "%e %b %Y");
display_date (priv->short_date, dt, "%x");
display_date (priv->time, dt, "%X");
setlocale (LC_TIME, locale);
g_free (locale);
locale = g_strdup (setlocale (LC_NUMERIC, NULL));
setlocale (LC_NUMERIC, priv->region);
s = g_strdup_printf ("%'.2f", 123456789.00);
gtk_label_set_text (GTK_LABEL (priv->number), s);
g_free (s);
setlocale (LC_NUMERIC, locale);
g_free (locale);
#if 0
locale = g_strdup (setlocale (LC_MONETARY, NULL));
setlocale (LC_MONETARY, priv->region);
num_info = localeconv ();
if (num_info != NULL)
gtk_label_set_text (GTK_LABEL (priv->currency), num_info->currency_symbol);
setlocale (LC_MONETARY, locale);
g_free (locale);
#endif
#ifdef LC_MEASUREMENT
locale = g_strdup (setlocale (LC_MEASUREMENT, NULL));
setlocale (LC_MEASUREMENT, priv->region);
fmt = nl_langinfo (_NL_MEASUREMENT_MEASUREMENT);
if (fmt && *fmt == 2)
gtk_label_set_text (GTK_LABEL (priv->measurement), C_("measurement format", "Imperial"));
else
gtk_label_set_text (GTK_LABEL (priv->measurement), C_("measurement format", "Metric"));
setlocale (LC_MEASUREMENT, locale);
g_free (locale);
#endif
#ifdef LC_PAPER
locale = g_strdup (setlocale (LC_PAPER, NULL));
setlocale (LC_PAPER, priv->region);
paper = gtk_paper_size_new (gtk_paper_size_get_default ());
gtk_label_set_text (GTK_LABEL (priv->paper), gtk_paper_size_get_display_name (paper));
gtk_paper_size_free (paper);
setlocale (LC_PAPER, locale);
g_free (locale);
#endif
}
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);
}
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);
}
}
static void papersize(PdfPrintContext *ppc)
{
//GList *list, *item;
const gchar *name;
GtkPaperSize *ps;
DB( g_print("[papersize]\n") );
name = gtk_paper_size_get_default();
DB( g_print("- def paper is %s\n", name) );
ps = gtk_paper_size_new(name);
/*GtkPageSetup *new_page_setup;
if (settings == NULL)
settings = gtk_print_settings_new ();
new_page_setup = gtk_print_run_page_setup_dialog (NULL,
page_setup, settings);
if (page_setup)
g_object_unref (page_setup);
page_setup = new_page_setup;
*/
//#if MYDEBUG == 1
gdouble w, h, mt, mb, ml, mr;
w = gtk_paper_size_get_width(ps, GTK_UNIT_MM);
h = gtk_paper_size_get_height(ps, GTK_UNIT_MM);
mt = gtk_paper_size_get_default_top_margin(ps, GTK_UNIT_MM);
mr = gtk_paper_size_get_default_right_margin(ps, GTK_UNIT_MM);
mb = gtk_paper_size_get_default_bottom_margin(ps, GTK_UNIT_MM);
ml = gtk_paper_size_get_default_left_margin(ps, GTK_UNIT_MM);
DB( g_print("- name: %s\n", gtk_paper_size_get_display_name(ps)) );
DB( g_print("- w: %f (%f)\n- h: %f (%f)\n", w, w/PANGO_SCALE, h, h/PANGO_SCALE) );
DB( g_print("- margin: %f %f %f %f\n", mt, mr, mb, ml) );
ppc->w = w * 2.83;
ppc->h = h * 2.83;
ppc->mt = mt * 2.83;
ppc->mr = mr * 2.83;
ppc->mb = mb * 2.83;
ppc->ml = ml * 2.83;
//#endif
gtk_paper_size_free(ps);
/* list all paper size */
/*
list = gtk_paper_size_get_paper_sizes (FALSE);
item = g_list_first(list);
while(item != NULL)
{
ps = item->data;
if(ps != NULL)
{
g_print("- name: %s\n", gtk_paper_size_get_display_name(ps));
gtk_paper_size_free(ps);
}
item = g_list_next(item);
}
g_list_free (list);
*/
}
