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;
}
static void
preview_got_page_size (GtkPrintOperationPreview *preview,
GtkPrintContext *context,
GtkPageSetup *page_setup,
gpointer data)
{
PreviewOp *pop = data;
GtkPaperSize *paper_size;
double w, h;
cairo_t *cr;
gdouble dpi_x, dpi_y;
paper_size = gtk_page_setup_get_paper_size (page_setup);
w = gtk_paper_size_get_width (paper_size, GTK_UNIT_INCH);
h = gtk_paper_size_get_height (paper_size, GTK_UNIT_INCH);
cr = gdk_cairo_create (pop->area->window);
dpi_x = pop->area->allocation.width/w;
dpi_y = pop->area->allocation.height/h;
if (fabs (dpi_x - pop->dpi_x) > 0.001 ||
fabs (dpi_y - pop->dpi_y) > 0.001)
{
gtk_print_context_set_cairo_context (context, cr, dpi_x, dpi_y);
pop->dpi_x = dpi_x;
pop->dpi_y = dpi_y;
}
pango_cairo_update_layout (cr, pop->data->layout);
cairo_destroy (cr);
}
/* attribute double paperWidth; */
NS_IMETHODIMP
nsPrintSettingsGTK::GetPaperWidth(double *aPaperWidth)
{
NS_ENSURE_ARG_POINTER(aPaperWidth);
*aPaperWidth = gtk_paper_size_get_width(mPaperSize, GetGTKUnit(mPaperSizeUnit));
return NS_OK;
}
NS_IMETHODIMP
nsPrintSettingsGTK::SetPaperHeight(double aPaperHeight)
{
gtk_paper_size_set_size(mPaperSize,
gtk_paper_size_get_width(mPaperSize, GetGTKUnit(mPaperSizeUnit)),
aPaperHeight,
GetGTKUnit(mPaperSizeUnit));
SaveNewPageSize();
return NS_OK;
}
static
GtkPaperSize* moz_gtk_paper_size_copy_to_new_custom(GtkPaperSize* oldPaperSize)
{
// We make a "custom-ified" copy of the paper size so it can be changed later.
return gtk_paper_size_new_custom(gtk_paper_size_get_name(oldPaperSize),
gtk_paper_size_get_display_name(oldPaperSize),
gtk_paper_size_get_width(oldPaperSize, GTK_UNIT_INCH),
gtk_paper_size_get_height(oldPaperSize, GTK_UNIT_INCH),
GTK_UNIT_INCH);
}
static void
unix_start_page (GtkPrintOperation *op,
GtkPrintContext *print_context,
GtkPageSetup *page_setup)
{
GtkPrintOperationUnix *op_unix;
GtkPaperSize *paper_size;
cairo_surface_type_t type;
gdouble w, h;
op_unix = op->priv->platform_data;
paper_size = gtk_page_setup_get_paper_size (page_setup);
w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
type = cairo_surface_get_type (op_unix->surface);
if ((op->priv->manual_number_up < 2) ||
(op->priv->page_position % op->priv->manual_number_up == 0))
{
if (type == CAIRO_SURFACE_TYPE_PS)
{
cairo_ps_surface_set_size (op_unix->surface, w, h);
cairo_ps_surface_dsc_begin_page_setup (op_unix->surface);
switch (gtk_page_setup_get_orientation (page_setup))
{
case GTK_PAGE_ORIENTATION_PORTRAIT:
case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
cairo_ps_surface_dsc_comment (op_unix->surface, "%%PageOrientation: Portrait");
break;
case GTK_PAGE_ORIENTATION_LANDSCAPE:
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
cairo_ps_surface_dsc_comment (op_unix->surface, "%%PageOrientation: Landscape");
break;
}
}
else if (type == CAIRO_SURFACE_TYPE_PDF)
{
if (!op->priv->manual_orientation)
{
w = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
h = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
}
cairo_pdf_surface_set_size (op_unix->surface, w, h);
}
}
}
NS_IMETHODIMP
nsPrintSettingsGTK::SetPaperSizeUnit(int16_t aPaperSizeUnit)
{
// Convert units internally. e.g. they might have set the values while we're still in mm but
// they change to inch just afterwards, expecting that their sizes are in inches.
gtk_paper_size_set_size(mPaperSize,
gtk_paper_size_get_width(mPaperSize, GetGTKUnit(mPaperSizeUnit)),
gtk_paper_size_get_height(mPaperSize, GetGTKUnit(mPaperSizeUnit)),
GetGTKUnit(aPaperSizeUnit));
SaveNewPageSize();
mPaperSizeUnit = aPaperSizeUnit;
return NS_OK;
}
static cairo_surface_t *
create_preview_surface_platform (GtkPaperSize *paper_size,
gdouble *dpi_x,
gdouble *dpi_y)
{
gdouble width, height;
width = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
height = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
*dpi_x = *dpi_y = PRINTER_DPI;
return cairo_pdf_surface_create_for_stream (dummy_write_func, NULL,
width, height);
}
NS_IMETHODIMP
nsPrintSettingsGTK::GetEffectivePageSize(double *aWidth, double *aHeight)
{
*aWidth = NS_INCHES_TO_INT_TWIPS(gtk_paper_size_get_width(mPaperSize, GTK_UNIT_INCH));
*aHeight = NS_INCHES_TO_INT_TWIPS(gtk_paper_size_get_height(mPaperSize, GTK_UNIT_INCH));
GtkPageOrientation gtkOrient = gtk_page_setup_get_orientation(mPageSetup);
if (gtkOrient == GTK_PAGE_ORIENTATION_LANDSCAPE ||
gtkOrient == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE) {
double temp = *aWidth;
*aWidth = *aHeight;
*aHeight = temp;
}
return NS_OK;
}
void FormatDialog::cbFormatChangedCb(GtkComboBox* widget, FormatDialog* dlg)
{
XOJ_CHECK_TYPE_OBJ(dlg, FormatDialog);
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter(widget, &iter))
{
GtkTreeModel* model = gtk_combo_box_get_model(widget);
GValue value = { 0 };
gtk_tree_model_get_value(model, &iter, 1, &value);
if (G_VALUE_HOLDS_POINTER(&value))
{
GtkPaperSize* s = (GtkPaperSize*) g_value_get_pointer(&value);
if (s == NULL)
{
return;
}
double width = gtk_paper_size_get_width(s, GTK_UNIT_POINTS) / dlg->scale;
double height = gtk_paper_size_get_height(s, GTK_UNIT_POINTS) / dlg->scale;
if (dlg->orientation == ORIENTATION_LANDSCAPE)
{
double tmp = width;
width = height;
height = tmp;
}
else
{
dlg->setOrientation(ORIENTATION_PORTRAIT);
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dlg->get("spinWidth")), width);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dlg->get("spinHeight")), height);
}
}
}
void FormatDialog::spinValueChangedCb(GtkSpinButton* spinbutton, FormatDialog* dlg)
{
XOJ_CHECK_TYPE_OBJ(dlg, FormatDialog);
double width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(dlg->get("spinWidth"))) * dlg->scale;
double height = gtk_spin_button_get_value(GTK_SPIN_BUTTON(dlg->get("spinHeight"))) * dlg->scale;
if (width < height)
{
dlg->setOrientation(ORIENTATION_PORTRAIT);
}
else if (width > height)
{
dlg->setOrientation(ORIENTATION_LANDSCAPE);
}
else
{
dlg->setOrientation(ORIENTATION_NOT_DEFINED);
}
int i = 0;
for (GList* l = dlg->list; l != NULL; l = l->next)
{
GtkPaperSize* s = (GtkPaperSize*) l->data;
double w = gtk_paper_size_get_width(s, GTK_UNIT_POINTS);
double h = gtk_paper_size_get_height(s, GTK_UNIT_POINTS);
if (((int) (w - width) == 0 && (int) (h - height) == 0) || ((int) (h - width) == 0 && (int) (w - height) == 0))
{
gtk_combo_box_set_active(GTK_COMBO_BOX(dlg->get("cbTemplate")), i);
return;
}
i++;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(dlg->get("cbTemplate")), i);
}
static void
unix_start_page (GtkPrintOperation *op,
GtkPrintContext *print_context,
GtkPageSetup *page_setup)
{
GtkPrintOperationUnix *op_unix;
GtkPaperSize *paper_size;
cairo_surface_type_t type;
gdouble w, h;
op_unix = op->priv->platform_data;
paper_size = gtk_page_setup_get_paper_size (page_setup);
w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
type = cairo_surface_get_type (op_unix->surface);
if (type == CAIRO_SURFACE_TYPE_PS)
cairo_ps_surface_set_size (op_unix->surface, w, h);
else if (type == CAIRO_SURFACE_TYPE_PDF)
cairo_pdf_surface_set_size (op_unix->surface, w, h);
}
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);
*/
}
FormatDialog::FormatDialog(GladeSearchpath* gladeSearchPath, Settings* settings, double width, double heigth) :
GladeGui(gladeSearchPath, "pagesize.glade", "pagesizeDialog")
{
XOJ_INIT_TYPE(FormatDialog);
this->orientation = ORIENTATION_NOT_DEFINED;
this->selectedScale = 0;
this->settings = settings;
SElement& format = settings->getCustomElement("format");
string unit;
if (format.getString("unit", unit))
{
for (int i = 0; i < XOJ_UNIT_COUNT; i++)
{
if (unit == XOJ_UNITS[i].name)
{
this->selectedScale = i;
break;
}
}
}
this->scale = XOJ_UNITS[this->selectedScale].scale;
this->origHeight = heigth;
this->origWidth = width;
this->width = -1;
this->height = -1;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(get("spinWidth")), this->origWidth / this->scale);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(get("spinHeight")), this->origHeight / this->scale);
GtkWidget* cbUnit = get("cbUnit");
GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(cbUnit), GTK_TREE_MODEL(store));
g_object_unref(store);
GtkCellRenderer* cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbUnit), cell, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cbUnit), cell, "text", 0, NULL);
for (int i = 0; i < XOJ_UNIT_COUNT; i++)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(cbUnit), XOJ_UNITS[i].name);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(cbUnit), this->selectedScale);
GtkWidget* cbTemplate = get("cbTemplate");
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_combo_box_set_model(GTK_COMBO_BOX(cbTemplate), GTK_TREE_MODEL(store));
g_object_unref(store);
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbTemplate), cell, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cbTemplate), cell, "text", 0, NULL);
int selectedFormat = -1;
string formatlist = settings->getVisiblePageFormats();
if (heigth < width)
{
double tmp = width;
width = heigth;
heigth = tmp;
}
this->list = gtk_paper_size_get_paper_sizes(false);
int i = 0;
GList* next = NULL;
for (GList* l = list; l != NULL; l = next)
{
GtkPaperSize* s = (GtkPaperSize*) l->data;
next = l->next;
double w = gtk_paper_size_get_width(s, GTK_UNIT_POINTS);
double h = gtk_paper_size_get_height(s, GTK_UNIT_POINTS);
bool visible = false;
if (((int) (w - width) * 10) == 0 && ((int) (h - heigth) * 10) == 0)
{
selectedFormat = i;
visible = true;
}
if (formatlist.find(gtk_paper_size_get_name(s)) != string::npos)
{
visible = true;
}
if (visible)
{
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, gtk_paper_size_get_display_name(s), -1);
gtk_list_store_set(store, &iter, 1, s, -1);
i++;
}
else
{
gtk_paper_size_free(s);
this->list = g_list_delete_link(this->list, l);
}
}
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, _C("Custom"), -1);
gtk_list_store_set(store, &iter, 1, NULL, -1);
// not found, select custom format
if (selectedFormat == -1)
{
selectedFormat = i;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(cbTemplate), selectedFormat);
spinValueChangedCb(NULL, this);
g_signal_connect(get("btLandscape"), "toggled", G_CALLBACK(landscapeSelectedCb), this);
g_signal_connect(get("btPortrait"), "toggled", G_CALLBACK(portraitSelectedCb), this);
g_signal_connect(cbTemplate, "changed", G_CALLBACK(cbFormatChangedCb), this);
g_signal_connect(cbUnit, "changed", G_CALLBACK(cbUnitChanged), this);
g_signal_connect(get("spinWidth"), "value-changed", G_CALLBACK(spinValueChangedCb), this);
g_signal_connect(get("spinHeight"), "value-changed", G_CALLBACK(spinValueChangedCb), this);
}
/* static */ nsresult
GeckoPrintService::TranslateSettings (GtkPrintSettings *aGtkSettings,
GtkPageSetup *aPageSetup,
GtkPrinter *aPrinter,
const nsACString &aSourceFile,
PRInt16 aPrintFrames,
PRBool aIsForPrinting,
nsIPrintSettings *aSettings)
{
NS_ENSURE_ARG (aGtkSettings);
NS_ENSURE_ARG (aPageSetup);
GtkPrintCapabilities capabilities = GtkPrintCapabilities (0);
if (aIsForPrinting) {
NS_ENSURE_TRUE (aPrinter, NS_ERROR_FAILURE);
capabilities = gtk_printer_get_capabilities (aPrinter);
}
/* Initialisation */
aSettings->SetIsInitializedFromPrinter (PR_FALSE); /* FIXME: PR_TRUE? */
aSettings->SetIsInitializedFromPrefs (PR_FALSE); /* FIXME: PR_TRUE? */
aSettings->SetPrintSilent (PR_FALSE);
aSettings->SetShowPrintProgress (PR_TRUE);
/* We always print PS to a file and then hand that off to gtk-print */
aSettings->SetPrinterName (LITERAL ("PostScript/default"));
if (aIsForPrinting) {
aSettings->SetPrintToFile (PR_TRUE);
nsString sourceFile;
NS_CStringToUTF16 (aSourceFile,
NS_CSTRING_ENCODING_NATIVE_FILESYSTEM,
sourceFile);
aSettings->SetToFileName (sourceFile.get ());
} else {
/* Otherwise mozilla will create the file nevertheless and
* fail since we haven't set a name!
*/
aSettings->SetPrintToFile (PR_FALSE);
}
/* This is the time between printing each page, in ms.
* It 'gives the user more time to press cancel' !
* We don't want any of this nonsense, so set this to a low value,
* just enough to update the print dialogue.
*/
aSettings->SetPrintPageDelay (50);
if (aIsForPrinting) {
#ifdef HAVE_NSIPRINTSETTINGS_SETOUTPUTFORMAT
NS_ENSURE_TRUE (aPrinter, NS_ERROR_FAILURE);
const char *format = gtk_print_settings_get (aGtkSettings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
if (!format)
format = "ps";
if (strcmp (format, "pdf") == 0 &&
gtk_printer_accepts_pdf (aPrinter)) {
aSettings->SetOutputFormat (nsIPrintSettings::kOutputFormatPDF);
} else if (strcmp (format, "ps") == 0 &&
gtk_printer_accepts_ps (aPrinter)) {
aSettings->SetOutputFormat (nsIPrintSettings::kOutputFormatPS);
} else {
g_warning ("Output format '%s' specified, but printer '%s' does not support it!",
format, gtk_printer_get_name (aPrinter));
return NS_ERROR_FAILURE;
}
#endif
int n_copies = gtk_print_settings_get_n_copies (aGtkSettings);
if (n_copies <= 0)
return NS_ERROR_FAILURE;
if (capabilities & GTK_PRINT_CAPABILITY_COPIES) {
aSettings->SetNumCopies (1);
} else {
/* We have to copy them ourself */
aSettings->SetNumCopies (n_copies);
gtk_print_settings_set_n_copies (aGtkSettings, 1);
}
gboolean reverse = gtk_print_settings_get_reverse (aGtkSettings);
if (capabilities & GTK_PRINT_CAPABILITY_REVERSE) {
aSettings->SetPrintReversed (PR_FALSE);
} else {
aSettings->SetPrintReversed (reverse);
gtk_print_settings_set_reverse (aGtkSettings, FALSE);
}
GtkPageSet pageSet = gtk_print_settings_get_page_set (aGtkSettings);
aSettings->SetPrintOptions (nsIPrintSettings::kPrintEvenPages,
pageSet != GTK_PAGE_SET_ODD);
aSettings->SetPrintOptions (nsIPrintSettings::kPrintEvenPages,
pageSet != GTK_PAGE_SET_EVEN);
GtkPrintPages printPages = gtk_print_settings_get_print_pages (aGtkSettings);
switch (printPages) {
case GTK_PRINT_PAGES_RANGES: {
int numRanges = 0;
GtkPageRange *pageRanges = gtk_print_settings_get_page_ranges (aGtkSettings, &numRanges);
if (numRanges > 0) {
/* FIXME: We can only support one range, ignore more ranges or raise error? */
aSettings->SetPrintRange (nsIPrintSettings::kRangeSpecifiedPageRange);
/* Gecko page numbers start at 1, while gtk page numbers start at 0 */
aSettings->SetStartPageRange (pageRanges[0].start + 1);
aSettings->SetEndPageRange (pageRanges[0].end + 1);
g_free (pageRanges);
break;
}
/* Fall-through to PAGES_ALL */
}
case GTK_PRINT_PAGES_CURRENT:
/* not supported, fall through */
case GTK_PRINT_PAGES_ALL:
aSettings->SetPrintRange (nsIPrintSettings::kRangeAllPages);
break;
/* FIXME: we need some custom ranges here, "Selection" and "Focused Frame" */
}
} else {
aSettings->SetPrintOptions (nsIPrintSettings::kPrintEvenPages, PR_TRUE);
aSettings->SetPrintOptions (nsIPrintSettings::kPrintEvenPages, PR_TRUE);
aSettings->SetPrintReversed (PR_FALSE);
aSettings->SetPrintRange (nsIPrintSettings::kRangeAllPages);
}
/* And clear those in the settings, so the printer doesn't try to apply them too */
gtk_print_settings_set_print_pages (aGtkSettings, GTK_PRINT_PAGES_ALL);
gtk_print_settings_set_page_ranges (aGtkSettings, NULL, 0);
gtk_print_settings_set_page_set (aGtkSettings, GTK_PAGE_SET_ALL);
/* We must use the page setup here instead of the print settings, see gtk bug #485685 */
switch (gtk_page_setup_get_orientation (aPageSetup)) {
case GTK_PAGE_ORIENTATION_PORTRAIT:
case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT: /* not supported */
aSettings->SetOrientation (nsIPrintSettings::kPortraitOrientation);
break;
case GTK_PAGE_ORIENTATION_LANDSCAPE:
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE: /* not supported */
aSettings->SetOrientation (nsIPrintSettings::kLandscapeOrientation);
break;
}
aSettings->SetPrintInColor (gtk_print_settings_get_use_color (aGtkSettings));
aSettings->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
#ifdef HAVE_NSIPRINTSETTINGS_SETPAPERSIZE
aSettings->SetPaperSize (nsIPrintSettings::kPaperSizeDefined);
#endif
GtkPaperSize *paperSize = gtk_page_setup_get_paper_size (aPageSetup);
if (!paperSize) {
return NS_ERROR_FAILURE;
}
aSettings->SetPaperSizeType (nsIPrintSettings::kPaperSizeDefined);
aSettings->SetPaperWidth (gtk_paper_size_get_width (paperSize, GTK_UNIT_MM));
aSettings->SetPaperHeight (gtk_paper_size_get_height (paperSize, GTK_UNIT_MM));
#ifdef HAVE_NSIPRINTSETTINGS_SETPAPERNAME
aSettings->SetPaperName (NS_ConvertUTF8toUTF16 (gtk_paper_size_get_name (paperSize)).get ());
#else
{
/* Mozilla bug https://bugzilla.mozilla.org/show_bug.cgi?id=307404
* means that we cannot actually use any paper sizes except mozilla's
* builtin list, and we must refer to them *by name*!
*/
static const struct {
const char gtkPaperName[13];
const char mozPaperName[10];
} paperTable [] = {
{ GTK_PAPER_NAME_A5, "A5" },
{ GTK_PAPER_NAME_A4, "A4" },
{ GTK_PAPER_NAME_A3, "A3" },
{ GTK_PAPER_NAME_LETTER, "Letter" },
{ GTK_PAPER_NAME_LEGAL, "Legal" },
{ GTK_PAPER_NAME_EXECUTIVE, "Executive" },
};
const char *paperName = gtk_paper_size_get_name (paperSize);
PRUint32 i;
for (i = 0; i < G_N_ELEMENTS (paperTable); i++) {
if (g_ascii_strcasecmp (paperTable[i].gtkPaperName, paperName) == 0) {
paperName = paperTable[i].mozPaperName;
break;
}
}
if (i == G_N_ELEMENTS (paperTable)) {
/* Not in table, fall back to A4 */
g_warning ("Unknown paper name '%s', falling back to A4", gtk_paper_size_get_name (paperSize));
paperName = paperTable[1].mozPaperName;
}
aSettings->SetPaperName (NS_ConvertUTF8toUTF16 (paperName).get ());
}
#endif /* !HAVE_NSIPRINTSETTINGS_SETPAPERNAME */
/* Sucky mozilla wants margins in inch! */
aSettings->SetMarginTop (gtk_page_setup_get_top_margin (aPageSetup, GTK_UNIT_INCH));
aSettings->SetMarginBottom (gtk_page_setup_get_bottom_margin (aPageSetup, GTK_UNIT_INCH));
aSettings->SetMarginLeft (gtk_page_setup_get_left_margin (aPageSetup, GTK_UNIT_INCH));
aSettings->SetMarginRight (gtk_page_setup_get_right_margin (aPageSetup, GTK_UNIT_INCH));
aSettings->SetHeaderStrLeft (eel_gconf_get_boolean (CONF_PRINT_PAGE_TITLE) ? LITERAL ("&T") : LITERAL (""));
aSettings->SetHeaderStrCenter (LITERAL (""));
aSettings->SetHeaderStrRight (eel_gconf_get_boolean (CONF_PRINT_PAGE_URL) ? LITERAL ("&U") : LITERAL (""));
aSettings->SetFooterStrLeft (eel_gconf_get_boolean (CONF_PRINT_PAGE_NUMBERS) ? LITERAL ("&PT") : LITERAL (""));
aSettings->SetFooterStrCenter (LITERAL (""));
aSettings->SetFooterStrRight (eel_gconf_get_boolean (CONF_PRINT_DATE) ? LITERAL ("&D") : LITERAL (""));
aSettings->SetPrintFrameType (aPrintFrames);
aSettings->SetPrintFrameTypeUsage (nsIPrintSettings::kUseSettingWhenPossible);
/* FIXME: only if GTK_PRINT_CAPABILITY_SCALE is not set? */
aSettings->SetScaling (gtk_print_settings_get_scale (aGtkSettings) / 100.0);
gtk_print_settings_set_scale (aGtkSettings, 1.0);
aSettings->SetShrinkToFit (PR_FALSE); /* FIXME setting */
aSettings->SetPrintBGColors (eel_gconf_get_boolean (CONF_PRINT_BG_COLORS) != FALSE);
aSettings->SetPrintBGImages (eel_gconf_get_boolean (CONF_PRINT_BG_IMAGES) != FALSE);
/* aSettings->SetPlexName (LITERAL ("default")); */
/* aSettings->SetColorspace (LITERAL ("default")); */
/* aSettings->SetResolutionName (LITERAL ("default")); */
/* aSettings->SetDownloadFonts (PR_TRUE); */
/* Unset those setting that we can handle, so they don't get applied
* again for the print job.
*/
/* gtk_print_settings_set_collate (aGtkSettings, FALSE); not yet */
/* FIXME: Unset the orientation for the print job? */
/* gtk_page_setup_set_orientation (aPageSetup, GTK_PAGE_ORIENTATION_PORTRAIT); */
/* FIXME: unset output format -> "ps" ? */
return NS_OK;
}
/* Calculates a page layout. If page is NULL, uses the first page
* (this is convenient for single-page rendering). The required size
* of the page is returned in extents, and the cairo transformation
* matrix needed to fit the drawing into the page is returned in mtx.
* Takes into account all of the margin/orientation/paper settings,
* and the size of the drawing itself. */
static void
export_layout_page (PAGE *page, cairo_rectangle_t *extents, cairo_matrix_t *mtx)
{
cairo_rectangle_t drawable;
int wx_min, wy_min, wx_max, wy_max, w_width, w_height;
gboolean landscape = FALSE;
gdouble m[4]; /* Calculated margins */
gdouble s; /* Calculated scale */
gdouble slack[2]; /* Calculated alignment slack */
if (page == NULL) {
const GList *pages = geda_list_get_glist (toplevel->pages);
g_assert (pages != NULL && pages->data != NULL);
page = (PAGE *) pages->data;
}
/* Set the margins. If none were provided by the user, get them
* from the paper size (if a paper size is being used) or just use a
* sensible default. */
if (settings.margins[0] >= 0) {
memcpy (m, settings.margins, 4*sizeof(gdouble));
} else if (settings.paper != NULL) {
m[0] = gtk_paper_size_get_default_top_margin (settings.paper, GTK_UNIT_POINTS);
m[1] = gtk_paper_size_get_default_left_margin (settings.paper, GTK_UNIT_POINTS);
m[2] = gtk_paper_size_get_default_bottom_margin (settings.paper, GTK_UNIT_POINTS);
m[3] = gtk_paper_size_get_default_right_margin (settings.paper, GTK_UNIT_POINTS);
} else {
m[0] = DEFAULT_MARGIN;
m[1] = DEFAULT_MARGIN;
m[2] = DEFAULT_MARGIN;
m[3] = DEFAULT_MARGIN;
}
/* Now calculate extents of objects within page */
world_get_object_glist_bounds (toplevel, s_page_objects (page),
&wx_min, &wy_min, &wx_max, &wy_max);
w_width = wx_max - wx_min;
w_height = wy_max - wy_min;
/* If a size was specified, use it. Otherwise, use paper size, if
* provided. Fall back to just using the size of the drawing. */
extents->x = extents->y = 0;
if (settings.size[0] >= 0) {
/* get extents from size */
extents->width = settings.size[0];
extents->height = settings.size[1];
} else if (settings.paper != NULL) {
/* get extents from paper */
gdouble p_width, p_height;
/* Select orientation */
switch (settings.layout) {
case ORIENTATION_LANDSCAPE:
landscape = TRUE;
break;
case ORIENTATION_PORTRAIT:
landscape = FALSE;
break;
case ORIENTATION_AUTO:
default:
landscape = (w_width > w_height);
break;
}
p_width = gtk_paper_size_get_width (settings.paper, GTK_UNIT_POINTS);
p_height = gtk_paper_size_get_height (settings.paper, GTK_UNIT_POINTS);
if (landscape) {
extents->width = p_height;
extents->height = p_width;
} else {
extents->width = p_width;
extents->height = p_height;
}
} else {
/* get extents from drawing */
extents->width = w_width * settings.scale; /* in points */
extents->height = w_height * settings.scale; /* in points */
/* If the extents were obtained from the drawing, grow the extents
* rather than shrinking the drawable area. This ensures that the
* overall aspect ratio of the image remains correct. */
extents->width += m[1] + m[3];
extents->height += m[0] + m[2];
}
drawable.x = m[1];
drawable.y = m[0];
drawable.width = extents->width - m[1] - m[3];
drawable.height = extents->height - m[0] - m[2];
/* Calculate optimum scale */
s = fmin (drawable.width / w_width, drawable.height / w_height);
/* Calculate alignment slack */
slack[0] = fmin (1, fmax (0, settings.align[0])) * (drawable.width - w_width * s);
slack[1] = fmin (1, fmax (0, settings.align[1])) * (drawable.height - w_height * s);
/* Finally, create and set a cairo transformation matrix that
* centres the drawing into the drawable area. */
cairo_matrix_init (mtx, s, 0, 0, -s,
- wx_min * s + drawable.x + slack[0],
(wy_min + w_height) * s + drawable.y + slack[1]);
}
static VALUE
rg_get_width(VALUE self, VALUE unit)
{
return rb_float_new(gtk_paper_size_get_width(_SELF(self), RVAL2UNIT(unit)));
}
