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;
}
/** ---------------------------------------------------
*/
void
nsPrintSettingsGTK::SetGtkPrintSettings(GtkPrintSettings *aPrintSettings)
{
if (mPrintSettings)
g_object_unref(mPrintSettings);
mPrintSettings = (GtkPrintSettings*) g_object_ref(aPrintSettings);
GtkPaperSize* newPaperSize = gtk_print_settings_get_paper_size(aPrintSettings);
if (newPaperSize) {
gtk_paper_size_free(mPaperSize);
mPaperSize = moz_gtk_paper_size_copy_to_new_custom(newPaperSize);
}
SaveNewPageSize();
}
void XAP_UnixDialog_Print::releasePrinterGraphicsContext(GR_Graphics * pGraphics)
{
UT_UNUSED(pGraphics);
UT_ASSERT(pGraphics == m_pPrintGraphics);
DELETEP(m_pPrintGraphics);
if(m_pPageSetup)
g_object_unref(m_pPageSetup);
m_pPageSetup = NULL;
if(m_pGtkPageSize)
gtk_paper_size_free (m_pGtkPageSize);
m_pGtkPageSize= NULL;
if(m_pPO)
g_object_unref(m_pPO);
m_pPO= NULL;
}
/** -------------------------------------------------------
* 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;
}
/** ---------------------------------------------------
*/
nsPrintSettingsGTK::~nsPrintSettingsGTK()
{
if (mPageSetup) {
g_object_unref(mPageSetup);
mPageSetup = nullptr;
}
if (mPrintSettings) {
g_object_unref(mPrintSettings);
mPrintSettings = nullptr;
}
if (mGTKPrinter) {
g_object_unref(mGTKPrinter);
mGTKPrinter = nullptr;
}
gtk_paper_size_free(mPaperSize);
}
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);
}
}
FormatDialog::~FormatDialog()
{
XOJ_CHECK_TYPE(FormatDialog);
for (GList* l = this->list; l != NULL; l = l->next)
{
if (l->data)
{
GtkPaperSize* s = (GtkPaperSize*) l->data;
gtk_paper_size_free(s);
}
}
g_list_free(this->list);
this->list = NULL;
XOJ_RELEASE_TYPE(FormatDialog);
}
/** ---------------------------------------------------
*/
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();
}
/** ---------------------------------------------------
*/
void
nsPrintSettingsGTK::SetGtkPageSetup(GtkPageSetup *aPageSetup)
{
if (mPageSetup)
g_object_unref(mPageSetup);
mPageSetup = (GtkPageSetup*) g_object_ref(aPageSetup);
InitUnwriteableMargin();
// We make a custom copy of the GtkPaperSize so it can be mutable. If a
// GtkPaperSize wasn't made as custom, its properties are immutable.
GtkPaperSize* newPaperSize = gtk_page_setup_get_paper_size(aPageSetup);
if (newPaperSize) { // Yes, this can be null
gtk_paper_size_free(mPaperSize);
mPaperSize = moz_gtk_paper_size_copy_to_new_custom(newPaperSize);
}
// If newPaperSize was not null, we must update our twin too (GtkPrintSettings).
// If newPaperSize was null, we must set this object to use mPaperSize.
SaveNewPageSize();
}
static void
export_command_line (int argc, char * const *argv)
{
int c;
gchar *str;
/* Parse command-line arguments */
while ((c = getopt_long (argc, argv, export_short_options,
export_long_options, NULL)) != -1) {
switch (c) {
case 0:
/* This is a long-form-only flag option, and has already been
* dealt with by getopt_long(). */
break;
case 2: /* --no-color */
settings.color = FALSE;
break;
case 'a':
str = export_command_line__utf8_check (optarg, "-a,--align");
if (!export_parse_align (str)) {
fprintf (stderr, bad_arg_msg, optarg, "-a,--align");
fprintf (stderr, see_help_msg);
exit (1);
}
g_free (str);
break;
case 'c':
settings.color = TRUE;
break;
case 'd':
settings.dpi = strtod (optarg, NULL);
if (settings.dpi <= 0) {
fprintf (stderr, bad_arg_msg, optarg, "-d,--dpi");
fprintf (stderr, see_help_msg);
exit (1);
}
break;
case 'f':
g_free (settings.format);
settings.format = export_command_line__utf8_check (optarg, "-f,--format");
break;
case 'F':
str = export_command_line__utf8_check (optarg, "-F,--font");
g_free (settings.font);
settings.font = str;
break;
case 'h':
export_usage ();
break;
case 'k':
str = export_command_line__utf8_check (optarg, "-k,--scale");
if (!export_parse_scale (str)) {
fprintf (stderr, bad_arg_msg, optarg, "-k,--scale");
fprintf (stderr, see_help_msg);
exit (1);
}
g_free (str);
/* Since a specific scale was provided, ditch the paper size
* setting */
if (settings.paper != NULL) {
gtk_paper_size_free (settings.paper);
settings.paper = NULL;
}
break;
case 'l':
if (!export_parse_layout (optarg)) {
fprintf (stderr, bad_arg_msg,
optarg, "-l,--layout");
fprintf (stderr, see_help_msg);
exit (1);
}
break;
case 'm':
str = export_command_line__utf8_check (optarg, "-m,--margins");
if (!export_parse_margins (str)) {
fprintf (stderr, bad_arg_msg, optarg, "-m,--margins");
fprintf (stderr, see_help_msg);
exit (1);
}
g_free (str);
break;
case 'o':
settings.outfile = optarg;
break;
case 'p':
str = export_command_line__utf8_check (optarg, "-p,--paper");
if (!export_parse_paper (str)) {
fprintf (stderr, bad_arg_msg, optarg, "-p,--paper");
fprintf (stderr, see_help_msg);
exit (1);
}
g_free (str);
break;
case 's':
str = export_command_line__utf8_check (optarg, "-s,--size");
if (!export_parse_size (str)) {
fprintf (stderr, bad_arg_msg, optarg, "-s,--size");
fprintf (stderr, see_help_msg);
exit (1);
}
g_free (str);
/* Since a specific size was provided, ditch the paper size
* setting */
if (settings.paper != NULL) {
gtk_paper_size_free (settings.paper);
settings.paper = NULL;
}
break;
case '?':
/* getopt_long already printed an error message */
fprintf (stderr, see_help_msg);
exit (1);
break;
default:
g_assert_not_reached ();
}
}
/* Check that some schematic files to print were provided */
if (argc <= optind) {
fprintf (stderr,
_("ERROR: You must specify at least one input filename.\n"));
fprintf (stderr, see_help_msg);
exit (1);
}
settings.infilec = argc - optind;
settings.infilev = &argv[optind];
if (settings.outfile == NULL) {
fprintf (stderr,
_("ERROR: You must specify an output filename.\n"));
fprintf (stderr, see_help_msg);
exit (1);
}
}
/* Initialise settings from config store. */
static void
export_config (void)
{
EdaConfig *cfg = eda_config_get_context_for_file (NULL);
gchar *str;
gdouble *lst;
gdouble dval;
gdouble bval;
gsize n;
GError *err = NULL;
/* Parse orientation */
str = eda_config_get_string (cfg, "export", "layout", NULL);
export_parse_layout (str); /* Don't care if it works */
g_free (str);
/* Parse paper size */
str = eda_config_get_string (cfg, "export", "paper", NULL);
export_parse_paper (str);
g_free (str);
/* Parse specific size setting -- always in points */
if (eda_config_has_key (cfg, "export", "size", NULL)) {
lst = eda_config_get_double_list (cfg, "export", "size", &n, NULL);
if (lst != NULL) {
if (n >= 2) {
memcpy (settings.size, lst, 2*sizeof(gdouble));
}
g_free (lst);
}
/* Since a specific size was provided, ditch the paper size
* setting */
if (settings.paper != NULL) {
gtk_paper_size_free (settings.paper);
settings.paper = NULL;
}
}
/* Parse margins -- always in points */
lst = eda_config_get_double_list (cfg, "export", "margins", &n, NULL);
if (lst != NULL) {
if (n >= 4) { /* In the config file all four sides must be specified */
memcpy (settings.margins, lst, 4*sizeof(gdouble));
}
g_free (lst);
}
/* Parse alignment */
lst = eda_config_get_double_list (cfg, "export", "align", &n, NULL);
if (lst != NULL) {
if (n >= 2) { /* Both halign and valign must be specified */
memcpy (settings.align, lst, 2*sizeof(gdouble));
}
g_free (lst);
}
/* Parse dpi */
dval = eda_config_get_double (cfg, "export", "dpi", &err);
if (err == NULL) {
settings.dpi = dval;
} else {
g_clear_error (&err);
}
bval = eda_config_get_boolean (cfg, "export", "monochrome", &err);
if (err == NULL) {
settings.color = !bval;
} else {
g_clear_error (&err);
}
str = eda_config_get_string (cfg, "export", "font", NULL);
if (str != NULL) {
g_free (settings.font);
settings.font = str;
}
}
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
}
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 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);
*/
}
