widget/src/cocoa/nsPrintSettingsX.mm

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Conrad Carlen <ccarlen@netscape.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsPrintSettingsX.h"
  40 #include "nsObjCExceptions.h"
  41 #include "nsIPrintSessionX.h"
  42
  43 #include "nsIPrefService.h"
  44 #include "nsIPrefBranch.h"
  45 #include "nsServiceManagerUtils.h"
  46
  47 #include "plbase64.h"
  48 #include "prmem.h"
  49 #include "prnetdb.h"
  50
  51
  52 // This struct should be represented identically on all architectures, and
  53 // there shouldn't be any padding before the data field.
  54 struct FrozenHandle {
  55   PRUint32 size;
  56   char data[0];
  57 };
  58
  59
  60 #define PRINTING_PREF_BRANCH            "print."
  61 #define MAC_OS_X_PAGE_SETUP_PREFNAME    "macosx.pagesetup-2"
  62
  63
  64 // Utility class stack-based handle ownership
  65 class StHandleOwner
  66 {
  67 public:
  68   StHandleOwner(Handle inHandle)
  69     : mHandle(inHandle)
  70   {
  71   }
  72
  73   ~StHandleOwner()
  74   {
  75     NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
  76
  77     if (mHandle)
  78       ::DisposeHandle(mHandle);
  79
  80     NS_OBJC_END_TRY_ABORT_BLOCK;
  81   }
  82
  83   Handle GetHandle() { return mHandle; }
  84
  85   void   ClearHandle(Boolean disposeIt = false)
  86   {
  87     NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
  88
  89     if (disposeIt)
  90       ::DisposeHandle(mHandle);
  91
  92     mHandle = nsnull;
  93
  94     NS_OBJC_END_TRY_ABORT_BLOCK;
  95   }
  96
  97 protected:
  98   Handle mHandle;
  99 };
 100
 101
 102 //      Utility class for saving, locking, and restoring handle state.
 103 //  Ok with null handle.
 104 class StHandleLocker
 105 {
 106 public:
 107   StHandleLocker(Handle theHandle)
 108     :   mHandle(theHandle)
 109   {
 110     NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 111
 112     if (mHandle) {
 113       mOldHandleState = ::HGetState(mHandle);
 114       ::HLock(mHandle);
 115     }
 116
 117     NS_OBJC_END_TRY_ABORT_BLOCK;
 118   }
 119
 120   ~StHandleLocker()
 121   {
 122     NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 123
 124     if (mHandle)
 125       ::HSetState(mHandle, mOldHandleState);
 126
 127     NS_OBJC_END_TRY_ABORT_BLOCK;
 128   }
 129
 130 protected:
 131   Handle mHandle;
 132   SInt8 mOldHandleState;
 133 };
 134
 135
 136 NS_IMPL_ISUPPORTS_INHERITED1(nsPrintSettingsX, nsPrintSettings, nsIPrintSettingsX)
 137
 138 nsPrintSettingsX::nsPrintSettingsX() :
 139   mPageFormat(kPMNoPageFormat),
 140   mPrintSettings(kPMNoPrintSettings)
 141 {
 142 }
 143
 144
 145 nsPrintSettingsX::nsPrintSettingsX(const nsPrintSettingsX& src) :
 146   mPageFormat(kPMNoPageFormat),
 147   mPrintSettings(kPMNoPrintSettings)
 148 {
 149   *this = src;
 150 }
 151
 152
 153 nsPrintSettingsX::~nsPrintSettingsX()
 154 {
 155   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 156
 157   if (mPageFormat != kPMNoPageFormat) {
 158     ::PMRelease(mPageFormat);
 159     mPageFormat = kPMNoPageFormat;
 160   }
 161   if (mPrintSettings != kPMNoPrintSettings) {
 162     ::PMRelease(mPrintSettings);
 163     mPrintSettings = kPMNoPrintSettings;
 164   }
 165
 166   NS_OBJC_END_TRY_ABORT_BLOCK;
 167 }
 168
 169
 170 nsPrintSettingsX& nsPrintSettingsX::operator=(const nsPrintSettingsX& rhs)
 171 {
 172   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
 173
 174   if (this == &rhs) {
 175     return *this;
 176   }
 177
 178   nsPrintSettings::operator=(rhs);
 179
 180   OSStatus status;
 181
 182   if (mPageFormat != kPMNoPageFormat) {
 183     ::PMRelease(mPageFormat);
 184     mPageFormat = kPMNoPageFormat;
 185   }
 186   if (rhs.mPageFormat != kPMNoPageFormat) {
 187     PMPageFormat pageFormat;
 188     status = ::PMCreatePageFormat(&pageFormat);
 189     if (status == noErr) {
 190       status = ::PMCopyPageFormat(rhs.mPageFormat, pageFormat);
 191       if (status == noErr) {
 192         mPageFormat = pageFormat;
 193         // NOTE: No need to re-initialize mUnwriteableMargin here (even
 194         // though mPageFormat is changing). It'll be copied correctly by
 195         // nsPrintSettings::operator=.
 196       } else {
 197         ::PMRelease(pageFormat);
 198       }
 199     }
 200   }
 201
 202   if (mPrintSettings != kPMNoPrintSettings) {
 203     ::PMRelease(mPrintSettings);
 204     mPrintSettings = kPMNoPrintSettings;
 205   }
 206   if (rhs.mPrintSettings != kPMNoPrintSettings) {
 207     PMPrintSettings    printSettings;
 208     status = ::PMCreatePrintSettings(&printSettings);
 209     if (status == noErr) {
 210       status = ::PMCopyPrintSettings(rhs.mPrintSettings, printSettings);
 211       if (status == noErr)
 212         mPrintSettings = printSettings;
 213       else
 214         ::PMRelease(printSettings);
 215     }
 216   }
 217
 218   return *this;
 219
 220   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(*this);
 221 }
 222
 223
 224 nsresult nsPrintSettingsX::Init()
 225 {
 226   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 227
 228   OSStatus status;
 229
 230   PMPrintSession printSession = NULL;
 231   status = ::PMCreateSession(&printSession);
 232
 233   if (status == noErr) {
 234     // First, create a default page format
 235     status = CreateDefaultPageFormat(printSession, mPageFormat);
 236     InitUnwriteableMargin();
 237
 238     // Then, if no error, create the default print settings
 239     if (status == noErr) {
 240       status = CreateDefaultPrintSettings(printSession, mPrintSettings);
 241     }
 242     OSStatus tempStatus = ::PMRelease(printSession);
 243     if (status == noErr)
 244       status = tempStatus;
 245   }
 246   return (status == noErr) ? NS_OK : NS_ERROR_FAILURE;
 247
 248   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 249 }
 250
 251
 252 // Should be called whenever mPageFormat changes.
 253 NS_IMETHODIMP nsPrintSettingsX::InitUnwriteableMargin()
 254 {
 255   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 256
 257   if (mPageFormat == kPMNoPageFormat)
 258     return NS_OK;
 259
 260   PMPaper paper;
 261   PMPaperMargins paperMargin;
 262   ::PMGetPageFormatPaper(mPageFormat, &paper);
 263   ::PMPaperGetMargins(paper, &paperMargin);
 264   mUnwriteableMargin.top    = NS_POINTS_TO_TWIPS(paperMargin.top);
 265   mUnwriteableMargin.left   = NS_POINTS_TO_TWIPS(paperMargin.left);
 266   mUnwriteableMargin.bottom = NS_POINTS_TO_TWIPS(paperMargin.bottom);
 267   mUnwriteableMargin.right  = NS_POINTS_TO_TWIPS(paperMargin.right);
 268
 269   return NS_OK;
 270
 271   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 272 }
 273
 274
 275 NS_IMETHODIMP nsPrintSettingsX::GetNativePrintSession(PMPrintSession *aNativePrintSession)
 276 {
 277    NS_ENSURE_ARG_POINTER(aNativePrintSession);
 278    *aNativePrintSession = nsnull;
 279
 280    nsCOMPtr<nsIPrintSession> printSession;
 281    GetPrintSession(getter_AddRefs(printSession));
 282    if (!printSession)
 283     return NS_ERROR_FAILURE;
 284    nsCOMPtr<nsIPrintSessionX> printSessionX(do_QueryInterface(printSession));
 285    if (!printSession)
 286     return NS_ERROR_FAILURE;
 287
 288    return printSessionX->GetNativeSession(aNativePrintSession);
 289 }
 290
 291
 292 NS_IMETHODIMP nsPrintSettingsX::GetPMPageFormat(PMPageFormat *aPMPageFormat)
 293 {
 294   NS_ENSURE_ARG_POINTER(aPMPageFormat);
 295   *aPMPageFormat = kPMNoPageFormat;
 296   NS_ENSURE_STATE(mPageFormat != kPMNoPageFormat);
 297
 298   *aPMPageFormat = mPageFormat;
 299   OSStatus status = noErr;
 300
 301   return (status == noErr) ? NS_OK : NS_ERROR_FAILURE;
 302 }
 303
 304
 305 NS_IMETHODIMP nsPrintSettingsX::SetPMPageFormat(PMPageFormat aPMPageFormat)
 306 {
 307   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 308
 309   NS_ENSURE_ARG(aPMPageFormat);
 310
 311   OSStatus status = ::PMRetain(aPMPageFormat);
 312   if (status == noErr) {
 313     if (mPageFormat)
 314       status = ::PMRelease(mPageFormat);
 315     mPageFormat = aPMPageFormat;
 316     InitUnwriteableMargin();
 317   }
 318   return (status == noErr) ? NS_OK : NS_ERROR_FAILURE;
 319
 320   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 321 }
 322
 323
 324 NS_IMETHODIMP nsPrintSettingsX::GetPMPrintSettings(PMPrintSettings *aPMPrintSettings)
 325 {
 326   NS_ENSURE_ARG_POINTER(aPMPrintSettings);
 327   *aPMPrintSettings = kPMNoPrintSettings;
 328   NS_ENSURE_STATE(mPrintSettings != kPMNoPrintSettings);
 329
 330   *aPMPrintSettings = mPrintSettings;
 331
 332   return NS_OK;
 333 }
 334
 335
 336 NS_IMETHODIMP nsPrintSettingsX::SetPMPrintSettings(PMPrintSettings aPMPrintSettings)
 337 {
 338   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 339
 340   NS_ENSURE_ARG(aPMPrintSettings);
 341
 342   OSStatus status = ::PMRetain(aPMPrintSettings);
 343   if (status == noErr) {
 344     if (mPrintSettings)
 345       status = ::PMRelease(mPrintSettings);
 346     mPrintSettings = aPMPrintSettings;
 347   }
 348   return (status == noErr) ? NS_OK : NS_ERROR_FAILURE;
 349
 350   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 351 }
 352
 353
 354 NS_IMETHODIMP nsPrintSettingsX::ReadPageFormatFromPrefs()
 355 {
 356   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 357
 358   nsresult rv;
 359   nsCOMPtr<nsIPrefService> prefService(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
 360   if (NS_FAILED(rv))
 361     return rv;
 362   nsCOMPtr<nsIPrefBranch> prefBranch;
 363   rv = prefService->GetBranch(PRINTING_PREF_BRANCH, getter_AddRefs(prefBranch));
 364   if (NS_FAILED(rv))
 365     return rv;
 366
 367   nsXPIDLCString  encodedData;
 368   rv = prefBranch->GetCharPref(MAC_OS_X_PAGE_SETUP_PREFNAME, getter_Copies(encodedData));
 369   if (NS_FAILED(rv))
 370     return rv;
 371
 372   // decode the base64
 373   PRInt32 encodedDataLen = encodedData.Length();
 374   FrozenHandle* frozenHandle =
 375    (FrozenHandle*)::PL_Base64Decode(encodedData.get(), encodedDataLen, nsnull);
 376   if (!frozenHandle)
 377     return NS_ERROR_FAILURE;
 378
 379   PRUint32 handleSize = PR_ntohl(frozenHandle->size);
 380
 381   // Ensure that the length reported in the frozen handle agrees with the
 382   // amount of decoded data.  At most 3 bytes of data map to 4 bytes when
 383   // base64-encoded.
 384   PRUint32 maximumDataSize = (encodedDataLen * 3) / 4 - sizeof(FrozenHandle);
 385   PRUint32 minimumDataSize = maximumDataSize - 2;
 386   if (handleSize > maximumDataSize || handleSize < minimumDataSize) {
 387     free(frozenHandle);
 388     return NS_ERROR_FAILURE;
 389   }
 390
 391   Handle    decodedDataHandle = nsnull;
 392   OSErr err = ::PtrToHand(frozenHandle->data, &decodedDataHandle, handleSize);
 393   free(frozenHandle);
 394   if (err != noErr)
 395     return NS_ERROR_OUT_OF_MEMORY;
 396
 397   StHandleOwner   handleOwner(decodedDataHandle);
 398
 399   OSStatus      status;
 400   PMPageFormat  newPageFormat = kPMNoPageFormat;
 401
 402   status = ::PMCreatePageFormat(&newPageFormat);
 403   if (status == noErr) {
 404     status = ::PMUnflattenPageFormat(decodedDataHandle, &newPageFormat);
 405     if (status == noErr) {
 406       if (mPageFormat)
 407         status = ::PMRelease(mPageFormat);
 408       mPageFormat = newPageFormat; // PMCreatePageFormat returned it with a refcnt of 1
 409       InitUnwriteableMargin();
 410     }
 411   }
 412   return (status == noErr) ? NS_OK : NS_ERROR_FAILURE;
 413
 414   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 415 }
 416
 417
 418 NS_IMETHODIMP nsPrintSettingsX::WritePageFormatToPrefs()
 419 {
 420   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 421
 422   if (mPageFormat == kPMNoPageFormat)
 423     return NS_ERROR_NOT_INITIALIZED;
 424
 425   nsresult rv;
 426   nsCOMPtr<nsIPrefService> prefService(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
 427   if (NS_FAILED(rv))
 428     return rv;
 429   nsCOMPtr<nsIPrefBranch> prefBranch;
 430   rv = prefService->GetBranch(PRINTING_PREF_BRANCH, getter_AddRefs(prefBranch));
 431   if (NS_FAILED(rv))
 432     return rv;
 433
 434   Handle    pageFormatHandle = nsnull;
 435   OSStatus  err = ::PMFlattenPageFormat(mPageFormat, &pageFormatHandle);
 436   if (err != noErr)
 437     return NS_ERROR_FAILURE;
 438
 439   StHandleOwner   handleOwner(pageFormatHandle);
 440   StHandleLocker  handleLocker(pageFormatHandle);
 441
 442   // Save the handle in a struct that identifies the data length and
 443   // the data itself, and wrap it all up in base64.  The length must be
 444   // included because PL_DecodeBase64 doesn't return the size of the
 445   // decoded data, and the handle will need to be reconstructed later with
 446   // the correct size.
 447   PRUint32 dataSize = ::GetHandleSize(pageFormatHandle);
 448   PRUint32 frozenDataSize = sizeof(FrozenHandle) + dataSize;
 449   FrozenHandle* frozenHandle = (FrozenHandle*)malloc(frozenDataSize);
 450   if (!frozenHandle)
 451     return NS_ERROR_OUT_OF_MEMORY;
 452
 453   frozenHandle->size = PR_htonl(dataSize);
 454   memcpy(&frozenHandle->data, *pageFormatHandle, dataSize);
 455
 456   nsXPIDLCString  encodedData;
 457   encodedData.Adopt(::PL_Base64Encode((char*)frozenHandle, frozenDataSize,
 458                     nsnull));
 459   free(frozenHandle);
 460   if (!encodedData.get())
 461     return NS_ERROR_OUT_OF_MEMORY;
 462
 463   return prefBranch->SetCharPref(MAC_OS_X_PAGE_SETUP_PREFNAME, encodedData);
 464
 465   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 466 }
 467
 468
 469 nsresult nsPrintSettingsX::_Clone(nsIPrintSettings **_retval)
 470 {
 471   NS_ENSURE_ARG_POINTER(_retval);
 472   *_retval = nsnull;
 473
 474   nsPrintSettingsX *newSettings = new nsPrintSettingsX(*this);
 475   if (!newSettings)
 476     return NS_ERROR_FAILURE;
 477   *_retval = newSettings;
 478   NS_ADDREF(*_retval);
 479   return NS_OK;
 480 }
 481
 482
 483 NS_IMETHODIMP nsPrintSettingsX::_Assign(nsIPrintSettings *aPS)
 484 {
 485   nsPrintSettingsX *printSettingsX = static_cast<nsPrintSettingsX*>(aPS);
 486   if (!printSettingsX)
 487     return NS_ERROR_UNEXPECTED;
 488   *this = *printSettingsX;
 489   return NS_OK;
 490 }
 491
 492
 493 OSStatus nsPrintSettingsX::CreateDefaultPageFormat(PMPrintSession aSession, PMPageFormat& outFormat)
 494 {
 495   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
 496
 497   OSStatus status;
 498   PMPageFormat pageFormat;
 499
 500   outFormat = kPMNoPageFormat;
 501   status = ::PMCreatePageFormat(&pageFormat);
 502   if (status == noErr && pageFormat != kPMNoPageFormat) {
 503     status = ::PMSessionDefaultPageFormat(aSession, pageFormat);
 504     if (status == noErr) {
 505       outFormat = pageFormat;
 506       return NS_OK;
 507     }
 508   }
 509   return status;
 510
 511   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(noErr);
 512 }
 513
 514
 515 OSStatus nsPrintSettingsX::CreateDefaultPrintSettings(PMPrintSession aSession, PMPrintSettings& outSettings)
 516 {
 517   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
 518
 519   OSStatus status;
 520   PMPrintSettings printSettings;
 521
 522   outSettings = kPMNoPrintSettings;
 523   status = ::PMCreatePrintSettings(&printSettings);
 524   if (status == noErr && printSettings != kPMNoPrintSettings) {
 525     status = ::PMSessionDefaultPrintSettings(aSession, printSettings);
 526     if (status == noErr) {
 527       outSettings = printSettings;
 528       return noErr;
 529     }
 530   }
 531   return status;
 532
 533   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(noErr);
 534 }