mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-02 10:00:54 +00:00
740 lines
22 KiB
C++
740 lines
22 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsPrintSettingsGTK.h"
|
|
#include "nsIFile.h"
|
|
#include "nsNetUtil.h"
|
|
#include <stdlib.h>
|
|
|
|
static
|
|
gboolean ref_printer(GtkPrinter *aPrinter, gpointer aData)
|
|
{
|
|
((nsPrintSettingsGTK*) aData)->SetGtkPrinter(aPrinter);
|
|
return TRUE;
|
|
}
|
|
|
|
static
|
|
gboolean printer_enumerator(GtkPrinter *aPrinter, gpointer aData)
|
|
{
|
|
if (gtk_printer_is_default(aPrinter))
|
|
return ref_printer(aPrinter, aData);
|
|
|
|
return FALSE; // Keep 'em coming...
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED1(nsPrintSettingsGTK,
|
|
nsPrintSettings,
|
|
nsPrintSettingsGTK)
|
|
|
|
/** ---------------------------------------------------
|
|
*/
|
|
nsPrintSettingsGTK::nsPrintSettingsGTK() :
|
|
mPageSetup(NULL),
|
|
mPrintSettings(NULL),
|
|
mGTKPrinter(NULL),
|
|
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(NULL);
|
|
mPaperSize = moz_gtk_paper_size_copy_to_new_custom(defaultPaperSize);
|
|
gtk_paper_size_free(defaultPaperSize);
|
|
SaveNewPageSize();
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
*/
|
|
nsPrintSettingsGTK::~nsPrintSettingsGTK()
|
|
{
|
|
if (mPageSetup) {
|
|
g_object_unref(mPageSetup);
|
|
mPageSetup = NULL;
|
|
}
|
|
if (mPrintSettings) {
|
|
g_object_unref(mPrintSettings);
|
|
mPrintSettings = NULL;
|
|
}
|
|
if (mGTKPrinter) {
|
|
g_object_unref(mGTKPrinter);
|
|
mGTKPrinter = NULL;
|
|
}
|
|
gtk_paper_size_free(mPaperSize);
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
*/
|
|
nsPrintSettingsGTK::nsPrintSettingsGTK(const nsPrintSettingsGTK& aPS) :
|
|
mPageSetup(NULL),
|
|
mPrintSettings(NULL),
|
|
mGTKPrinter(NULL),
|
|
mPrintSelectionOnly(false)
|
|
{
|
|
*this = aPS;
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
*/
|
|
nsPrintSettingsGTK& nsPrintSettingsGTK::operator=(const nsPrintSettingsGTK& rhs)
|
|
{
|
|
if (this == &rhs) {
|
|
return *this;
|
|
}
|
|
|
|
nsPrintSettings::operator=(rhs);
|
|
|
|
if (mPageSetup)
|
|
g_object_unref(mPageSetup);
|
|
mPageSetup = gtk_page_setup_copy(rhs.mPageSetup);
|
|
// NOTE: No need to re-initialize mUnwriteableMargin here (even
|
|
// though mPageSetup is changing). It'll be copied correctly by
|
|
// nsPrintSettings::operator=.
|
|
|
|
if (mPrintSettings)
|
|
g_object_unref(mPrintSettings);
|
|
mPrintSettings = gtk_print_settings_copy(rhs.mPrintSettings);
|
|
|
|
if (mGTKPrinter)
|
|
g_object_unref(mGTKPrinter);
|
|
mGTKPrinter = (GtkPrinter*) g_object_ref(rhs.mGTKPrinter);
|
|
|
|
mPrintSelectionOnly = rhs.mPrintSelectionOnly;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/** -------------------------------------------
|
|
*/
|
|
nsresult nsPrintSettingsGTK::_Clone(nsIPrintSettings **_retval)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(_retval);
|
|
*_retval = nullptr;
|
|
|
|
nsPrintSettingsGTK *newSettings = new nsPrintSettingsGTK(*this);
|
|
if (!newSettings)
|
|
return NS_ERROR_FAILURE;
|
|
*_retval = newSettings;
|
|
NS_ADDREF(*_retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
/** -------------------------------------------
|
|
*/
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::_Assign(nsIPrintSettings *aPS)
|
|
{
|
|
nsPrintSettingsGTK *printSettingsGTK = static_cast<nsPrintSettingsGTK*>(aPS);
|
|
if (!printSettingsGTK)
|
|
return NS_ERROR_UNEXPECTED;
|
|
*this = *printSettingsGTK;
|
|
return NS_OK;
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
*/
|
|
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();
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
*/
|
|
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
|
|
nsPrintSettingsGTK::SetGtkPrinter(GtkPrinter *aPrinter)
|
|
{
|
|
if (mGTKPrinter)
|
|
g_object_unref(mGTKPrinter);
|
|
|
|
mGTKPrinter = (GtkPrinter*) g_object_ref(aPrinter);
|
|
}
|
|
|
|
/**
|
|
* Reimplementation of nsPrintSettings functions so that we get the values
|
|
* from the GTK objects rather than our own variables.
|
|
*/
|
|
|
|
/* attribute long printRange; */
|
|
NS_IMETHODIMP nsPrintSettingsGTK::GetPrintRange(int16_t *aPrintRange)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aPrintRange);
|
|
if (mPrintSelectionOnly) {
|
|
*aPrintRange = kRangeSelection;
|
|
return NS_OK;
|
|
}
|
|
|
|
GtkPrintPages gtkRange = gtk_print_settings_get_print_pages(mPrintSettings);
|
|
if (gtkRange == GTK_PRINT_PAGES_RANGES)
|
|
*aPrintRange = kRangeSpecifiedPageRange;
|
|
else
|
|
*aPrintRange = kRangeAllPages;
|
|
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP nsPrintSettingsGTK::SetPrintRange(int16_t aPrintRange)
|
|
{
|
|
if (aPrintRange == kRangeSelection) {
|
|
mPrintSelectionOnly = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
mPrintSelectionOnly = false;
|
|
if (aPrintRange == kRangeSpecifiedPageRange)
|
|
gtk_print_settings_set_print_pages(mPrintSettings, GTK_PRINT_PAGES_RANGES);
|
|
else
|
|
gtk_print_settings_set_print_pages(mPrintSettings, GTK_PRINT_PAGES_ALL);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute long startPageRange; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetStartPageRange(int32_t *aStartPageRange)
|
|
{
|
|
gint ctRanges;
|
|
GtkPageRange* lstRanges = gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
|
|
|
|
// Make sure we got a range.
|
|
if (ctRanges < 1) {
|
|
*aStartPageRange = 1;
|
|
} else {
|
|
// GTK supports multiple page ranges; gecko only supports 1. So find
|
|
// the lowest start page.
|
|
int32_t start(lstRanges[0].start);
|
|
for (gint ii = 1; ii < ctRanges; ii++) {
|
|
start = NS_MIN(lstRanges[ii].start, start);
|
|
}
|
|
*aStartPageRange = start + 1;
|
|
}
|
|
|
|
g_free(lstRanges);
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetStartPageRange(int32_t aStartPageRange)
|
|
{
|
|
int32_t endRange;
|
|
GetEndPageRange(&endRange);
|
|
|
|
GtkPageRange gtkRange;
|
|
gtkRange.start = aStartPageRange - 1;
|
|
gtkRange.end = endRange - 1;
|
|
|
|
gtk_print_settings_set_page_ranges(mPrintSettings, >kRange, 1);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute long endPageRange; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetEndPageRange(int32_t *aEndPageRange)
|
|
{
|
|
gint ctRanges;
|
|
GtkPageRange* lstRanges = gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
|
|
|
|
if (ctRanges < 1) {
|
|
*aEndPageRange = 1;
|
|
} else {
|
|
int32_t end(lstRanges[0].end);
|
|
for (gint ii = 1; ii < ctRanges; ii++) {
|
|
end = NS_MAX(lstRanges[ii].end, end);
|
|
}
|
|
*aEndPageRange = end + 1;
|
|
}
|
|
|
|
g_free(lstRanges);
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetEndPageRange(int32_t aEndPageRange)
|
|
{
|
|
int32_t startRange;
|
|
GetStartPageRange(&startRange);
|
|
|
|
GtkPageRange gtkRange;
|
|
gtkRange.start = startRange - 1;
|
|
gtkRange.end = aEndPageRange - 1;
|
|
|
|
gtk_print_settings_set_page_ranges(mPrintSettings, >kRange, 1);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute boolean printReversed; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetPrintReversed(bool *aPrintReversed)
|
|
{
|
|
*aPrintReversed = gtk_print_settings_get_reverse(mPrintSettings);
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetPrintReversed(bool aPrintReversed)
|
|
{
|
|
gtk_print_settings_set_reverse(mPrintSettings, aPrintReversed);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute boolean printInColor; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetPrintInColor(bool *aPrintInColor)
|
|
{
|
|
*aPrintInColor = gtk_print_settings_get_use_color(mPrintSettings);
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetPrintInColor(bool aPrintInColor)
|
|
{
|
|
gtk_print_settings_set_use_color(mPrintSettings, aPrintInColor);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute short orientation; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetOrientation(int32_t *aOrientation)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aOrientation);
|
|
|
|
GtkPageOrientation gtkOrient = gtk_page_setup_get_orientation(mPageSetup);
|
|
switch (gtkOrient) {
|
|
case GTK_PAGE_ORIENTATION_LANDSCAPE:
|
|
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
|
|
*aOrientation = kLandscapeOrientation;
|
|
break;
|
|
|
|
case GTK_PAGE_ORIENTATION_PORTRAIT:
|
|
case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
|
|
default:
|
|
*aOrientation = kPortraitOrientation;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetOrientation(int32_t aOrientation)
|
|
{
|
|
GtkPageOrientation gtkOrient;
|
|
if (aOrientation == kLandscapeOrientation)
|
|
gtkOrient = GTK_PAGE_ORIENTATION_LANDSCAPE;
|
|
else
|
|
gtkOrient = GTK_PAGE_ORIENTATION_PORTRAIT;
|
|
|
|
gtk_print_settings_set_orientation(mPrintSettings, gtkOrient);
|
|
gtk_page_setup_set_orientation(mPageSetup, gtkOrient);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute wstring toFileName; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetToFileName(PRUnichar * *aToFileName)
|
|
{
|
|
// Get the gtk output filename
|
|
const char* gtk_output_uri = gtk_print_settings_get(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI);
|
|
if (!gtk_output_uri) {
|
|
*aToFileName = ToNewUnicode(mToFileName);
|
|
return NS_OK;
|
|
}
|
|
|
|
// Convert to an nsIFile
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = NS_GetFileFromURLSpec(nsDependentCString(gtk_output_uri),
|
|
getter_AddRefs(file));
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
// Extract the path
|
|
nsAutoString path;
|
|
rv = file->GetPath(path);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
*aToFileName = ToNewUnicode(path);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetToFileName(const PRUnichar * aToFileName)
|
|
{
|
|
if (aToFileName[0] == 0) {
|
|
mToFileName.SetLength(0);
|
|
gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI, NULL);
|
|
return NS_OK;
|
|
}
|
|
|
|
if (StringEndsWith(nsDependentString(aToFileName), NS_LITERAL_STRING(".ps"))) {
|
|
gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT, "ps");
|
|
} else {
|
|
gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT, "pdf");
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = NS_NewLocalFile(nsDependentString(aToFileName), true,
|
|
getter_AddRefs(file));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Convert the nsIFile to a URL
|
|
nsAutoCString url;
|
|
rv = NS_GetURLSpecFromFile(file, url);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI, url.get());
|
|
mToFileName = aToFileName;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetPrinterName(PRUnichar * *aPrinter)
|
|
{
|
|
const char* gtkPrintName = gtk_print_settings_get_printer(mPrintSettings);
|
|
if (!gtkPrintName) {
|
|
if (GTK_IS_PRINTER(mGTKPrinter)) {
|
|
gtkPrintName = gtk_printer_get_name(mGTKPrinter);
|
|
} else {
|
|
// This mimics what nsPrintSettingsImpl does when we try to Get before we Set
|
|
nsXPIDLString nullPrintName;
|
|
*aPrinter = ToNewUnicode(nullPrintName);
|
|
return NS_OK;
|
|
}
|
|
}
|
|
*aPrinter = ToNewUnicode(nsDependentCString(gtkPrintName));
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetPrinterName(const PRUnichar * aPrinter)
|
|
{
|
|
NS_ConvertUTF16toUTF8 gtkPrinter(aPrinter);
|
|
|
|
if (StringBeginsWith(gtkPrinter, NS_LITERAL_CSTRING("CUPS/"))) {
|
|
// Strip off "CUPS/"; GTK might recognize the rest
|
|
gtkPrinter.Cut(0, strlen("CUPS/"));
|
|
}
|
|
|
|
// Give mPrintSettings the passed-in printer name if either...
|
|
// - it has no printer name stored yet
|
|
// - it has an existing printer name that's different from
|
|
// the name passed to this function.
|
|
const char* oldPrinterName = gtk_print_settings_get_printer(mPrintSettings);
|
|
if (!oldPrinterName || !gtkPrinter.Equals(oldPrinterName)) {
|
|
mIsInitedFromPrinter = false;
|
|
mIsInitedFromPrefs = false;
|
|
gtk_print_settings_set_printer(mPrintSettings, gtkPrinter.get());
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute long numCopies; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetNumCopies(int32_t *aNumCopies)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aNumCopies);
|
|
*aNumCopies = gtk_print_settings_get_n_copies(mPrintSettings);
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetNumCopies(int32_t aNumCopies)
|
|
{
|
|
gtk_print_settings_set_n_copies(mPrintSettings, aNumCopies);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute double scaling; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetScaling(double *aScaling)
|
|
{
|
|
*aScaling = gtk_print_settings_get_scale(mPrintSettings) / 100.0;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetScaling(double aScaling)
|
|
{
|
|
gtk_print_settings_set_scale(mPrintSettings, aScaling * 100.0);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute wstring paperName; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetPaperName(PRUnichar * *aPaperName)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aPaperName);
|
|
*aPaperName = ToNewUnicode(NS_ConvertUTF8toUTF16(gtk_paper_size_get_name(mPaperSize)));
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetPaperName(const PRUnichar * aPaperName)
|
|
{
|
|
NS_ConvertUTF16toUTF8 gtkPaperName(aPaperName);
|
|
|
|
// Convert these Gecko 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;
|
|
}
|
|
|
|
GtkUnit
|
|
nsPrintSettingsGTK::GetGTKUnit(int16_t aGeckoUnit)
|
|
{
|
|
if (aGeckoUnit == kPaperSizeMillimeters)
|
|
return GTK_UNIT_MM;
|
|
else
|
|
return GTK_UNIT_INCH;
|
|
}
|
|
|
|
void
|
|
nsPrintSettingsGTK::SaveNewPageSize()
|
|
{
|
|
gtk_print_settings_set_paper_size(mPrintSettings, mPaperSize);
|
|
gtk_page_setup_set_paper_size(mPageSetup, mPaperSize);
|
|
}
|
|
|
|
void
|
|
nsPrintSettingsGTK::InitUnwriteableMargin()
|
|
{
|
|
mUnwriteableMargin.SizeTo(
|
|
NS_INCHES_TO_INT_TWIPS(gtk_page_setup_get_left_margin(mPageSetup, GTK_UNIT_INCH)),
|
|
NS_INCHES_TO_INT_TWIPS(gtk_page_setup_get_top_margin(mPageSetup, GTK_UNIT_INCH)),
|
|
NS_INCHES_TO_INT_TWIPS(gtk_page_setup_get_right_margin(mPageSetup, GTK_UNIT_INCH)),
|
|
NS_INCHES_TO_INT_TWIPS(gtk_page_setup_get_bottom_margin(mPageSetup, GTK_UNIT_INCH))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* NOTE: Need a custom set of SetUnwriteableMargin functions, because
|
|
* whenever we change mUnwriteableMargin, we must pass the change
|
|
* down to our GTKPageSetup object. (This is needed in order for us
|
|
* to give the correct default values in nsPrintDialogGTK.)
|
|
*
|
|
* It's important that the following functions pass
|
|
* mUnwriteableMargin values rather than aUnwriteableMargin values
|
|
* to gtk_page_setup_set_[blank]_margin, because the two may not be
|
|
* the same. (Specifically, negative values of aUnwriteableMargin
|
|
* are ignored by the nsPrintSettings::SetUnwriteableMargin functions.)
|
|
*/
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin)
|
|
{
|
|
nsPrintSettings::SetUnwriteableMarginInTwips(aUnwriteableMargin);
|
|
gtk_page_setup_set_top_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.top), GTK_UNIT_INCH);
|
|
gtk_page_setup_set_left_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.left), GTK_UNIT_INCH);
|
|
gtk_page_setup_set_bottom_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom), GTK_UNIT_INCH);
|
|
gtk_page_setup_set_right_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.right), GTK_UNIT_INCH);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute double unwriteableMarginTop; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetUnwriteableMarginTop(double aUnwriteableMarginTop)
|
|
{
|
|
nsPrintSettings::SetUnwriteableMarginTop(aUnwriteableMarginTop);
|
|
gtk_page_setup_set_top_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.top), GTK_UNIT_INCH);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute double unwriteableMarginLeft; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft)
|
|
{
|
|
nsPrintSettings::SetUnwriteableMarginLeft(aUnwriteableMarginLeft);
|
|
gtk_page_setup_set_left_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.left), GTK_UNIT_INCH);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute double unwriteableMarginBottom; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetUnwriteableMarginBottom(double aUnwriteableMarginBottom)
|
|
{
|
|
nsPrintSettings::SetUnwriteableMarginBottom(aUnwriteableMarginBottom);
|
|
gtk_page_setup_set_bottom_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom), GTK_UNIT_INCH);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute double unwriteableMarginRight; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetUnwriteableMarginRight(double aUnwriteableMarginRight)
|
|
{
|
|
nsPrintSettings::SetUnwriteableMarginRight(aUnwriteableMarginRight);
|
|
gtk_page_setup_set_right_margin(mPageSetup,
|
|
NS_TWIPS_TO_INCHES(mUnwriteableMargin.right), GTK_UNIT_INCH);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* 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::SetPaperWidth(double aPaperWidth)
|
|
{
|
|
gtk_paper_size_set_size(mPaperSize,
|
|
aPaperWidth,
|
|
gtk_paper_size_get_height(mPaperSize, GetGTKUnit(mPaperSizeUnit)),
|
|
GetGTKUnit(mPaperSizeUnit));
|
|
SaveNewPageSize();
|
|
return NS_OK;
|
|
}
|
|
|
|
/* attribute double paperHeight; */
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetPaperHeight(double *aPaperHeight)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aPaperHeight);
|
|
*aPaperHeight = gtk_paper_size_get_height(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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::SetupSilentPrinting()
|
|
{
|
|
// We have to get a printer here, rather than when the print settings are constructed.
|
|
// This is because when we request sync, GTK makes us wait in the *event loop* while waiting
|
|
// for the enumeration to finish. We must do this when event loop runs are expected.
|
|
gtk_enumerate_printers(printer_enumerator, this, NULL, TRUE);
|
|
|
|
// XXX If no default printer set, get the first one.
|
|
if (!GTK_IS_PRINTER(mGTKPrinter))
|
|
gtk_enumerate_printers(ref_printer, this, NULL, TRUE);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPrintSettingsGTK::GetPageRanges(nsTArray<int32_t> &aPages)
|
|
{
|
|
gint ctRanges;
|
|
GtkPageRange* lstRanges = gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
|
|
|
|
aPages.Clear();
|
|
|
|
if (ctRanges > 1) {
|
|
for (gint i = 0; i < ctRanges; i++) {
|
|
aPages.AppendElement(lstRanges[i].start+1);
|
|
aPages.AppendElement(lstRanges[i].end+1);
|
|
}
|
|
}
|
|
|
|
g_free(lstRanges);
|
|
return NS_OK;
|
|
}
|
|
|