widget/qt/nsPrintSettingsQt.cpp

   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     QPrinter::PaperSize size = mQPrinter->paperSize();
 295     QString name(indexToPaperName[size]);
 296     *aPaperName = ToNewUnicode(nsDependentString((const char16_t*)name.constData()));
 297     return NS_OK;
 298 }
 299
 300 NS_IMETHODIMP
 301 nsPrintSettingsQt::SetPaperName(const char16_t* aPaperName)
 302 {
 303     QString ref((QChar*)aPaperName, NS_strlen(aPaperName));
 304     for (uint32_t i = 0; i < sizeof(indexToPaperName)/sizeof(char*); i++)
 305     {
 306         if (ref == QString(indexToPaperName[i])) {
 307             mQPrinter->setPageSize(indexToQtPaperEnum[i]);
 308             return NS_OK;
 309         }
 310     }
 311     return NS_ERROR_FAILURE;
 312 }
 313
 314 QPrinter::Unit GetQtUnit(int16_t aGeckoUnit)
 315 {
 316     if (aGeckoUnit == nsIPrintSettings::kPaperSizeMillimeters) {
 317         return QPrinter::Millimeter;
 318     } else {
 319         return QPrinter::Inch;
 320     }
 321 }
 322
 323 #define SETUNWRITEABLEMARGIN\
 324     mQPrinter->setPageMargins(\
 325             NS_TWIPS_TO_INCHES(mUnwriteableMargin.left),\
 326             NS_TWIPS_TO_INCHES(mUnwriteableMargin.top),\
 327             NS_TWIPS_TO_INCHES(mUnwriteableMargin.right),\
 328             NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom),\
 329             QPrinter::Inch);
 330
 331 NS_IMETHODIMP
 332 nsPrintSettingsQt::SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin)
 333 {
 334     nsPrintSettings::SetUnwriteableMarginInTwips(aUnwriteableMargin);
 335     SETUNWRITEABLEMARGIN
 336     return NS_OK;
 337 }
 338
 339 NS_IMETHODIMP
 340 nsPrintSettingsQt::SetUnwriteableMarginTop(double aUnwriteableMarginTop)
 341 {
 342     nsPrintSettings::SetUnwriteableMarginTop(aUnwriteableMarginTop);
 343     SETUNWRITEABLEMARGIN
 344     return NS_OK;
 345 }
 346
 347 NS_IMETHODIMP
 348 nsPrintSettingsQt::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft)
 349 {
 350     nsPrintSettings::SetUnwriteableMarginLeft(aUnwriteableMarginLeft);
 351     SETUNWRITEABLEMARGIN
 352     return NS_OK;
 353 }
 354
 355 NS_IMETHODIMP
 356 nsPrintSettingsQt::SetUnwriteableMarginBottom(double aUnwriteableMarginBottom)
 357 {
 358     nsPrintSettings::SetUnwriteableMarginBottom(aUnwriteableMarginBottom);
 359     SETUNWRITEABLEMARGIN
 360     return NS_OK;
 361 }
 362
 363 NS_IMETHODIMP
 364 nsPrintSettingsQt::SetUnwriteableMarginRight(double aUnwriteableMarginRight)
 365 {
 366     nsPrintSettings::SetUnwriteableMarginRight(aUnwriteableMarginRight);
 367     SETUNWRITEABLEMARGIN
 368     return NS_OK;
 369 }
 370
 371 NS_IMETHODIMP
 372 nsPrintSettingsQt::GetPaperWidth(double* aPaperWidth)
 373 {
 374     NS_ENSURE_ARG_POINTER(aPaperWidth);
 375     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));
 376     *aPaperWidth = papersize.width();
 377     return NS_OK;
 378 }
 379
 380 NS_IMETHODIMP
 381 nsPrintSettingsQt::SetPaperWidth(double aPaperWidth)
 382 {
 383     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));
 384     papersize.setWidth(aPaperWidth);
 385     mQPrinter->setPaperSize(papersize, GetQtUnit(mPaperSizeUnit));
 386     return NS_OK;
 387 }
 388
 389 NS_IMETHODIMP
 390 nsPrintSettingsQt::GetPaperHeight(double* aPaperHeight)
 391 {
 392     NS_ENSURE_ARG_POINTER(aPaperHeight);
 393     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));
 394     *aPaperHeight = papersize.height();
 395     return NS_OK;
 396 }
 397
 398 NS_IMETHODIMP
 399 nsPrintSettingsQt::SetPaperHeight(double aPaperHeight)
 400 {
 401     QSizeF papersize = mQPrinter->paperSize(GetQtUnit(mPaperSizeUnit));
 402     papersize.setHeight(aPaperHeight);
 403     mQPrinter->setPaperSize(papersize, GetQtUnit(mPaperSizeUnit));
 404     return NS_OK;
 405 }
 406
 407 NS_IMETHODIMP
 408 nsPrintSettingsQt::SetPaperSizeUnit(int16_t aPaperSizeUnit)
 409 {
 410     mPaperSizeUnit = aPaperSizeUnit;
 411     return NS_OK;
 412 }
 413
 414 NS_IMETHODIMP
 415 nsPrintSettingsQt::GetEffectivePageSize(double* aWidth, double* aHeight)
 416 {
 417     QSizeF papersize = mQPrinter->paperSize(QPrinter::Inch);
 418     if (mQPrinter->orientation() == QPrinter::Landscape) {
 419         *aWidth  = NS_INCHES_TO_INT_TWIPS(papersize.height());
 420         *aHeight = NS_INCHES_TO_INT_TWIPS(papersize.width());
 421     } else {
 422         *aWidth  = NS_INCHES_TO_INT_TWIPS(papersize.width());
 423         *aHeight = NS_INCHES_TO_INT_TWIPS(papersize.height());
 424     }
 425     return NS_OK;
 426 }
 427