The Tor Browser / file revision

widget/qt/nsPrintSettingsQt.cpp@b8a032363ba2

widget/qt/nsPrintSettingsQt.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Thu, 22 Jan 2015 13:21:57 +0100
branch
TOR_BUG_9701
changeset 15
b8a032363ba2
permissions
-rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-

     2  *

     3  * This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 

     7 #include <QPrinter>

     8 #include <QDebug>

     9 #include "nsPrintSettingsQt.h"

    10 #include "nsIFile.h"

    11 #include "nsCRTGlue.h"

    12 

    13 NS_IMPL_ISUPPORTS_INHERITED(nsPrintSettingsQt,

    14                             nsPrintSettings,

    15                             nsPrintSettingsQt)

    16 

    17 nsPrintSettingsQt::nsPrintSettingsQt():

    18     mQPrinter(new QPrinter())

    19 {

    20 }

    21 

    22 nsPrintSettingsQt::~nsPrintSettingsQt()

    23 {

    24     //smart pointer should take care of cleanup

    25 }

    26 

    27 nsPrintSettingsQt::nsPrintSettingsQt(const nsPrintSettingsQt& aPS):

    28     mQPrinter(aPS.mQPrinter)

    29 {

    30 }

    31 

    32 nsPrintSettingsQt& 

    33 nsPrintSettingsQt::operator=(const nsPrintSettingsQt& rhs)

    34 {

    35     if (this == &rhs) {

    36         return *this;

    37     }

    38 

    39     nsPrintSettings::operator=(rhs);

    40     mQPrinter = rhs.mQPrinter;

    41     return *this;

    42 }

    43 

    44 nsresult 

    45 nsPrintSettingsQt::_Clone(nsIPrintSettings** _retval)

    46 {

    47     NS_ENSURE_ARG_POINTER(_retval);

    48 

    49     nsPrintSettingsQt* newSettings = new nsPrintSettingsQt(*this);

    50     *_retval = newSettings;

    51     NS_ADDREF(*_retval);

    52     return NS_OK;

    53 }

    54 

    55 NS_IMETHODIMP

    56 nsPrintSettingsQt::_Assign(nsIPrintSettings* aPS)

    57 {

    58     nsPrintSettingsQt* printSettingsQt = static_cast<nsPrintSettingsQt*>(aPS);

    59     if (!printSettingsQt)

    60         return NS_ERROR_UNEXPECTED;

    61     *this = *printSettingsQt;

    62     return NS_OK;

    63 }

    64 

    65 NS_IMETHODIMP

    66 nsPrintSettingsQt::GetPrintRange(int16_t* aPrintRange)

    67 {

    68     NS_ENSURE_ARG_POINTER(aPrintRange);

    69 

    70     QPrinter::PrintRange range = mQPrinter->printRange();

    71     if (range == QPrinter::PageRange) {

    72         *aPrintRange = kRangeSpecifiedPageRange;

    73     } else if (range == QPrinter::Selection) {

    74         *aPrintRange = kRangeSelection;

    75     } else {

    76         *aPrintRange = kRangeAllPages;

    77     }

    78 

    79     return NS_OK;

    80 }

    81 

    82 NS_IMETHODIMP 

    83 nsPrintSettingsQt::SetPrintRange(int16_t aPrintRange)

    84 {

    85     if (aPrintRange == kRangeSelection) {

    86         mQPrinter->setPrintRange(QPrinter::Selection);

    87     } else if (aPrintRange == kRangeSpecifiedPageRange) {

    88         mQPrinter->setPrintRange(QPrinter::PageRange);

    89     } else {

    90         mQPrinter->setPrintRange(QPrinter::AllPages);

    91     }

    92     return NS_OK;

    93 }

    94 

    95 NS_IMETHODIMP

    96 nsPrintSettingsQt::GetStartPageRange(int32_t* aStartPageRange)

    97 {

    98     NS_ENSURE_ARG_POINTER(aStartPageRange);

    99     int32_t start = mQPrinter->fromPage();

   100     *aStartPageRange = start;

   101     return NS_OK;

   102 }

   103 

   104 NS_IMETHODIMP

   105 nsPrintSettingsQt::SetStartPageRange(int32_t aStartPageRange)

   106 {

   107     int32_t endRange = mQPrinter->toPage();

   108     mQPrinter->setFromTo(aStartPageRange, endRange);

   109     return NS_OK;

   110 }

   111 

   112 NS_IMETHODIMP

   113 nsPrintSettingsQt::GetEndPageRange(int32_t* aEndPageRange)

   114 {

   115     NS_ENSURE_ARG_POINTER(aEndPageRange);

   116     int32_t end = mQPrinter->toPage();

   117     *aEndPageRange = end;

   118     return NS_OK;

   119 }

   120 

   121 NS_IMETHODIMP

   122 nsPrintSettingsQt::SetEndPageRange(int32_t aEndPageRange)

   123 {

   124     int32_t startRange = mQPrinter->fromPage();

   125     mQPrinter->setFromTo(startRange, aEndPageRange);

   126     return NS_OK;

   127 }

   128 

   129 NS_IMETHODIMP

   130 nsPrintSettingsQt::GetPrintReversed(bool* aPrintReversed)

   131 {

   132     NS_ENSURE_ARG_POINTER(aPrintReversed);

   133     if (mQPrinter->pageOrder() == QPrinter::LastPageFirst) {

   134         *aPrintReversed = true;

   135     } else {

   136         *aPrintReversed = false;

   137     }

   138     return NS_OK;

   139 }

   140 

   141 NS_IMETHODIMP

   142 nsPrintSettingsQt::SetPrintReversed(bool aPrintReversed)

   143 {

   144     if (aPrintReversed) {

   145         mQPrinter->setPageOrder(QPrinter::LastPageFirst);

   146     } else {

   147         mQPrinter->setPageOrder(QPrinter::FirstPageFirst);

   148     }

   149     return NS_OK;

   150 }

   151 

   152 NS_IMETHODIMP

   153 nsPrintSettingsQt::GetPrintInColor(bool* aPrintInColor)

   154 {

   155     NS_ENSURE_ARG_POINTER(aPrintInColor);

   156     if (mQPrinter->colorMode() == QPrinter::Color) {

   157         *aPrintInColor = true;

   158     } else {

   159         *aPrintInColor = false;

   160     }

   161     return NS_OK;

   162 }

   163 NS_IMETHODIMP

   164 nsPrintSettingsQt::SetPrintInColor(bool aPrintInColor)

   165 {

   166     if (aPrintInColor) {

   167         mQPrinter->setColorMode(QPrinter::Color);

   168     } else {

   169         mQPrinter->setColorMode(QPrinter::GrayScale);

   170     }

   171     return NS_OK;

   172 }

   173 

   174 NS_IMETHODIMP

   175 nsPrintSettingsQt::GetOrientation(int32_t* aOrientation)

   176 {

   177     NS_ENSURE_ARG_POINTER(aOrientation);

   178     QPrinter::Orientation orientation = mQPrinter->orientation();

   179     if (orientation == QPrinter::Landscape) {

   180         *aOrientation = kLandscapeOrientation;

   181     } else {

   182         *aOrientation = kPortraitOrientation;

   183     }

   184     return NS_OK;

   185 }

   186 

   187 NS_IMETHODIMP

   188 nsPrintSettingsQt::SetOrientation(int32_t aOrientation)

   189 {

   190     if (aOrientation == kLandscapeOrientation) {

   191         mQPrinter->setOrientation(QPrinter::Landscape);

   192     } else {

   193         mQPrinter->setOrientation(QPrinter::Portrait);

   194     }

   195     return NS_OK;

   196 }

   197 

   198 NS_IMETHODIMP

   199 nsPrintSettingsQt::GetToFileName(char16_t** aToFileName)

   200 {

   201     NS_ENSURE_ARG_POINTER(aToFileName);

   202     QString filename;

   203     filename = mQPrinter->outputFileName();

   204     *aToFileName = ToNewUnicode(

   205             nsDependentString((char16_t*)filename.data()));

   206     return NS_OK;

   207 }

   208 

   209 NS_IMETHODIMP

   210 nsPrintSettingsQt::SetToFileName(const char16_t* aToFileName)

   211 {

   212     nsCOMPtr<nsIFile> file;

   213     nsresult rv = NS_NewLocalFile(nsDependentString(aToFileName), true,

   214                                 getter_AddRefs(file));

   215     NS_ENSURE_SUCCESS(rv, rv);

   216 

   217     QString filename((const QChar*)aToFileName, NS_strlen(aToFileName));

   218     mQPrinter->setOutputFileName(filename);

   219 

   220     return NS_OK;

   221 }

   222 

   223 NS_IMETHODIMP

   224 nsPrintSettingsQt::GetPrinterName(char16_t** aPrinter)

   225 {

   226     NS_ENSURE_ARG_POINTER(aPrinter);

   227     *aPrinter = ToNewUnicode(nsDependentString(

   228                 (const char16_t*)mQPrinter->printerName().constData()));

   229     return NS_OK;

   230 }

   231 

   232 NS_IMETHODIMP

   233 nsPrintSettingsQt::SetPrinterName(const char16_t* aPrinter)

   234 {

   235     QString printername((const QChar*)aPrinter, NS_strlen(aPrinter));

   236     mQPrinter->setPrinterName(printername);

   237     return NS_OK;

   238 }

   239 

   240 NS_IMETHODIMP

   241 nsPrintSettingsQt::GetNumCopies(int32_t* aNumCopies)

   242 {

   243     NS_ENSURE_ARG_POINTER(aNumCopies);

   244     *aNumCopies = mQPrinter->numCopies();

   245     return NS_OK;

   246 }

   247 

   248 NS_IMETHODIMP

   249 nsPrintSettingsQt::SetNumCopies(int32_t aNumCopies)

   250 {

   251     mQPrinter->setNumCopies(aNumCopies);

   252     return NS_OK;

   253 }

   254 

   255 NS_IMETHODIMP

   256 nsPrintSettingsQt::GetScaling(double* aScaling)

   257 {

   258     NS_ENSURE_ARG_POINTER(aScaling);

   259     qDebug()<<Q_FUNC_INFO;

   260     qDebug()<<"Scaling not implemented in Qt port";

   261     *aScaling = 1.0; //FIXME

   262     return NS_ERROR_NOT_IMPLEMENTED;

   263 }

   264 

   265 NS_IMETHODIMP

   266 nsPrintSettingsQt::SetScaling(double aScaling)

   267 {

   268     qDebug()<<Q_FUNC_INFO;

   269     qDebug()<<"Scaling not implemented in Qt port"; //FIXME

   270     return NS_ERROR_NOT_IMPLEMENTED;

   271 }

   272 

   273 static const char* const indexToPaperName[] =

   274 { "A4", "B5", "Letter", "Legal", "Executive",

   275   "A0", "A1", "A2", "A3", "A5", "A6", "A7", "A8", "A9",

   276   "B0", "B1", "B10", "B2", "B3", "B4", "B6", "B7", "B8", "B9",

   277   "C5E", "Comm10E", "DLE", "Folio", "Ledger", "Tabloid"

   278 };

   279 

   280 static const QPrinter::PageSize indexToQtPaperEnum[] =

   281 {

   282     QPrinter::A4, QPrinter::B5, QPrinter::Letter, QPrinter::Legal,

   283     QPrinter::Executive, QPrinter::A0, QPrinter::A1, QPrinter::A2, QPrinter::A3,

   284     QPrinter::A5, QPrinter::A6, QPrinter::A7, QPrinter::A8, QPrinter::A9,

   285     QPrinter::B0, QPrinter::B1, QPrinter::B10, QPrinter::B2, QPrinter::B3,

   286     QPrinter::B4, QPrinter::B6, QPrinter::B7, QPrinter::B8, QPrinter::B9,

   287     QPrinter::C5E, QPrinter::Comm10E, QPrinter::DLE, QPrinter::Folio,

   288     QPrinter::Ledger, QPrinter::Tabloid

   289 };

   290 

   291 NS_IMETHODIMP

   292 nsPrintSettingsQt::GetPaperName(char16_t** aPaperName)

   293 {

   294     PR_STATIC_ASSERT(sizeof(indexToPaperName)/

   295         sizeof(char*) == QPrinter::NPageSize);

   296     PR_STATIC_ASSERT(sizeof(indexToQtPaperEnum)/

   297         sizeof(QPrinter::PageSize) == QPrinter::NPageSize);

   298 

   299     QPrinter::PaperSize size = mQPrinter->paperSize();

   300     QString name(indexToPaperName[size]);

   301     *aPaperName = ToNewUnicode(nsDependentString

   302         ((const char16_t*)name.constData()));

   303     return NS_OK;

   304 }

   305 

   306 NS_IMETHODIMP

   307 nsPrintSettingsQt::SetPaperName(const char16_t* aPaperName)

   308 {

   309     QString ref((QChar*)aPaperName, NS_strlen(aPaperName));

   310     for (uint32_t i = 0; i < QPrinter::NPageSize; i++)

   311     {

   312         if (ref == QString(indexToPaperName[i])) {

   313             mQPrinter->setPageSize(indexToQtPaperEnum[i]);

   314             return NS_OK;

   315         }

   316     }

   317     return NS_ERROR_FAILURE;

   318 }

   319 

   320 QPrinter::Unit GetQtUnit(int16_t aGeckoUnit)

   321 {

   322     if (aGeckoUnit == nsIPrintSettings::kPaperSizeMillimeters) {

   323         return QPrinter::Millimeter;

   324     } else {

   325         return QPrinter::Inch;

   326     }

   327 }

   328 

   329 #define SETUNWRITEABLEMARGIN\

   330     mQPrinter->setPageMargins(\

   331             NS_TWIPS_TO_INCHES(mUnwriteableMargin.left),\

   332             NS_TWIPS_TO_INCHES(mUnwriteableMargin.top),\

   333             NS_TWIPS_TO_INCHES(mUnwriteableMargin.right),\

   334             NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom),\

   335             QPrinter::Inch);

   336 

   337 NS_IMETHODIMP

   338 nsPrintSettingsQt::SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin)

   339 {

   340     nsPrintSettings::SetUnwriteableMarginInTwips(aUnwriteableMargin);

   341     SETUNWRITEABLEMARGIN

   342     return NS_OK;

   343 }

   344 

   345 NS_IMETHODIMP

   346 nsPrintSettingsQt::SetUnwriteableMarginTop(double aUnwriteableMarginTop)

   347 {

   348     nsPrintSettings::SetUnwriteableMarginTop(aUnwriteableMarginTop);

   349     SETUNWRITEABLEMARGIN

   350     return NS_OK;

   351 }

   352 

   353 NS_IMETHODIMP

   354 nsPrintSettingsQt::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft)

   355 {

   356     nsPrintSettings::SetUnwriteableMarginLeft(aUnwriteableMarginLeft);

   357     SETUNWRITEABLEMARGIN

   358     return NS_OK;

   359 }

   360 

   361 NS_IMETHODIMP

   362 nsPrintSettingsQt::SetUnwriteableMarginBottom(double aUnwriteableMarginBottom)

   363 {

   364     nsPrintSettings::SetUnwriteableMarginBottom(aUnwriteableMarginBottom);

   365     SETUNWRITEABLEMARGIN

   366     return NS_OK;

   367 }

   368 

   369 NS_IMETHODIMP

   370 nsPrintSettingsQt::SetUnwriteableMarginRight(double aUnwriteableMarginRight)

   371 {

   372     nsPrintSettings::SetUnwriteableMarginRight(aUnwriteableMarginRight);

   373     SETUNWRITEABLEMARGIN

   374     return NS_OK;

   375 }

   376 

   377 NS_IMETHODIMP

   378 nsPrintSettingsQt::GetPaperWidth(double* aPaperWidth)

   379 {

   380     NS_ENSURE_ARG_POINTER(aPaperWidth);

   381     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));

   382     *aPaperWidth = papersize.width();

   383     return NS_OK;

   384 }

   385 

   386 NS_IMETHODIMP

   387 nsPrintSettingsQt::SetPaperWidth(double aPaperWidth)

   388 {

   389     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));

   390     papersize.setWidth(aPaperWidth);

   391     mQPrinter->setPaperSize(papersize, GetQtUnit(mPaperSizeUnit));

   392     return NS_OK;

   393 }

   394 

   395 NS_IMETHODIMP

   396 nsPrintSettingsQt::GetPaperHeight(double* aPaperHeight)

   397 {

   398     NS_ENSURE_ARG_POINTER(aPaperHeight);

   399     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));

   400     *aPaperHeight = papersize.height();

   401     return NS_OK;

   402 }

   403 

   404 NS_IMETHODIMP

   405 nsPrintSettingsQt::SetPaperHeight(double aPaperHeight)

   406 {

   407     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));

   408     papersize.setHeight(aPaperHeight);

   409     mQPrinter->setPaperSize(papersize, GetQtUnit(mPaperSizeUnit));

   410     return NS_OK;

   411 }

   412 

   413 NS_IMETHODIMP

   414 nsPrintSettingsQt::SetPaperSizeUnit(int16_t aPaperSizeUnit)

   415 {

   416     mPaperSizeUnit = aPaperSizeUnit;

   417     return NS_OK;

   418 }

   419 

   420 NS_IMETHODIMP

   421 nsPrintSettingsQt::GetEffectivePageSize(double* aWidth, double* aHeight)

   422 {

   423     QSizeF papersize = mQPrinter->paperSize(QPrinter::Inch);

   424     if (mQPrinter->orientation() == QPrinter::Landscape) {

   425         *aWidth  = NS_INCHES_TO_INT_TWIPS(papersize.height());

   426         *aHeight = NS_INCHES_TO_INT_TWIPS(papersize.width());

   427     } else {

   428         *aWidth  = NS_INCHES_TO_INT_TWIPS(papersize.width());

   429         *aHeight = NS_INCHES_TO_INT_TWIPS(papersize.height());

   430     }

   431     return NS_OK;

   432 }

   433

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial