LCOV - code coverage report
Current view: directory - widget/xpwidgets - nsPrintOptionsImpl.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 439 0 0.0 %
Date: 2012-06-02 Functions: 31 0 0.0 %

       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) 2000
      20                 :  * the Initial Developer. All Rights Reserved.
      21                 :  *
      22                 :  * Contributor(s):
      23                 :  *   Jessica Blanco <jblanco@us.ibm.com>
      24                 :  *   Bastiaan Jacques <b.jacques@planet.nl>
      25                 :  *
      26                 :  * Alternatively, the contents of this file may be used under the terms of
      27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
      28                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      30                 :  * of those above. If you wish to allow use of your version of this file only
      31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      32                 :  * use your version of this file under the terms of the MPL, indicate your
      33                 :  * decision by deleting the provisions above and replace them with the notice
      34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      35                 :  * the provisions above, a recipient may use your version of this file under
      36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      37                 :  *
      38                 :  * ***** END LICENSE BLOCK ***** */
      39                 : 
      40                 : #include "nsPrintOptionsImpl.h"
      41                 : #include "nsReadableUtils.h"
      42                 : #include "nsPrintSettingsImpl.h"
      43                 : 
      44                 : #include "nsIDOMWindow.h"
      45                 : #include "nsIServiceManager.h"
      46                 : #include "nsIDialogParamBlock.h"
      47                 : #include "nsXPCOM.h"
      48                 : #include "nsISupportsPrimitives.h"
      49                 : #include "nsIWindowWatcher.h"
      50                 : #include "nsISupportsArray.h"
      51                 : #include "prprf.h"
      52                 : 
      53                 : #include "nsIStringEnumerator.h"
      54                 : #include "nsISupportsPrimitives.h"
      55                 : #include "stdlib.h"
      56                 : #include "nsAutoPtr.h"
      57                 : #include "mozilla/Preferences.h"
      58                 : #include "nsPrintfCString.h"
      59                 : 
      60                 : using namespace mozilla;
      61                 : 
      62               0 : NS_IMPL_ISUPPORTS2(nsPrintOptions, nsIPrintOptions, nsIPrintSettingsService)
      63                 : 
      64                 : // Pref Constants
      65                 : static const char kMarginTop[]       = "print_margin_top";
      66                 : static const char kMarginLeft[]      = "print_margin_left";
      67                 : static const char kMarginBottom[]    = "print_margin_bottom";
      68                 : static const char kMarginRight[]     = "print_margin_right";
      69                 : static const char kEdgeTop[]         = "print_edge_top";
      70                 : static const char kEdgeLeft[]        = "print_edge_left";
      71                 : static const char kEdgeBottom[]      = "print_edge_bottom";
      72                 : static const char kEdgeRight[]       = "print_edge_right";
      73                 : static const char kUnwriteableMarginTop[]    = "print_unwriteable_margin_top";
      74                 : static const char kUnwriteableMarginLeft[]   = "print_unwriteable_margin_left";
      75                 : static const char kUnwriteableMarginBottom[] = "print_unwriteable_margin_bottom";
      76                 : static const char kUnwriteableMarginRight[]  = "print_unwriteable_margin_right";
      77                 : 
      78                 : // Prefs for Print Options
      79                 : static const char kPrintEvenPages[]       = "print_evenpages";
      80                 : static const char kPrintOddPages[]        = "print_oddpages";
      81                 : static const char kPrintHeaderStrLeft[]   = "print_headerleft";
      82                 : static const char kPrintHeaderStrCenter[] = "print_headercenter";
      83                 : static const char kPrintHeaderStrRight[]  = "print_headerright";
      84                 : static const char kPrintFooterStrLeft[]   = "print_footerleft";
      85                 : static const char kPrintFooterStrCenter[] = "print_footercenter";
      86                 : static const char kPrintFooterStrRight[]  = "print_footerright";
      87                 : 
      88                 : // Additional Prefs
      89                 : static const char kPrintReversed[]      = "print_reversed";
      90                 : static const char kPrintInColor[]       = "print_in_color";
      91                 : static const char kPrintPaperName[]     = "print_paper_name";
      92                 : static const char kPrintPlexName[]      = "print_plex_name";
      93                 : static const char kPrintPaperSizeType[] = "print_paper_size_type";
      94                 : static const char kPrintPaperData[]     = "print_paper_data";
      95                 : static const char kPrintPaperSizeUnit[] = "print_paper_size_unit";
      96                 : static const char kPrintPaperWidth[]    = "print_paper_width";
      97                 : static const char kPrintPaperHeight[]   = "print_paper_height";
      98                 : static const char kPrintColorspace[]    = "print_colorspace";
      99                 : static const char kPrintResolutionName[]= "print_resolution_name";
     100                 : static const char kPrintDownloadFonts[] = "print_downloadfonts";
     101                 : static const char kPrintOrientation[]   = "print_orientation";
     102                 : static const char kPrintCommand[]       = "print_command";
     103                 : static const char kPrinterName[]        = "print_printer";
     104                 : static const char kPrintToFile[]        = "print_to_file";
     105                 : static const char kPrintToFileName[]    = "print_to_filename";
     106                 : static const char kPrintPageDelay[]     = "print_page_delay";
     107                 : static const char kPrintBGColors[]      = "print_bgcolor";
     108                 : static const char kPrintBGImages[]      = "print_bgimages";
     109                 : static const char kPrintShrinkToFit[]   = "print_shrink_to_fit";
     110                 : static const char kPrintScaling[]       = "print_scaling";
     111                 : 
     112                 : static const char kJustLeft[]   = "left";
     113                 : static const char kJustCenter[] = "center";
     114                 : static const char kJustRight[]  = "right";
     115                 : 
     116                 : #define NS_PRINTER_ENUMERATOR_CONTRACTID "@mozilla.org/gfx/printerenumerator;1"
     117                 : 
     118               0 : nsPrintOptions::nsPrintOptions()
     119                 : {
     120               0 : }
     121                 : 
     122               0 : nsPrintOptions::~nsPrintOptions()
     123                 : {
     124               0 : }
     125                 : 
     126                 : nsresult
     127               0 : nsPrintOptions::Init()
     128                 : {
     129               0 :   return NS_OK;
     130                 : }
     131                 : 
     132                 : NS_IMETHODIMP
     133               0 : nsPrintOptions::ShowPrintSetupDialog(nsIPrintSettings *aPS)
     134                 : {
     135               0 :   NS_ENSURE_ARG_POINTER(aPS);
     136                 :   nsresult rv;
     137                 : 
     138                 :   // create a nsISupportsArray of the parameters
     139                 :   // being passed to the window
     140               0 :   nsCOMPtr<nsISupportsArray> array;
     141               0 :   rv = NS_NewISupportsArray(getter_AddRefs(array));
     142               0 :   NS_ENSURE_SUCCESS(rv, rv);
     143                 : 
     144               0 :   nsCOMPtr<nsISupports> psSupports = do_QueryInterface(aPS);
     145               0 :   NS_ASSERTION(psSupports, "PrintSettings must be a supports");
     146               0 :   array->AppendElement(psSupports);
     147                 : 
     148                 :   nsCOMPtr<nsIDialogParamBlock> ioParamBlock =
     149               0 :       do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID, &rv);
     150               0 :   NS_ENSURE_SUCCESS(rv, rv);
     151                 : 
     152               0 :   ioParamBlock->SetInt(0, 0);
     153                 : 
     154               0 :   nsCOMPtr<nsISupports> blkSupps = do_QueryInterface(ioParamBlock);
     155               0 :   NS_ASSERTION(blkSupps, "IOBlk must be a supports");
     156               0 :   array->AppendElement(blkSupps);
     157                 : 
     158                 :   nsCOMPtr<nsIWindowWatcher> wwatch =
     159               0 :       do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
     160               0 :   NS_ENSURE_SUCCESS(rv, rv);
     161                 : 
     162               0 :   nsCOMPtr<nsIDOMWindow> parent;
     163               0 :   wwatch->GetActiveWindow(getter_AddRefs(parent));
     164                 :   // null |parent| is non-fatal
     165                 : 
     166               0 :   nsCOMPtr<nsIDOMWindow> newWindow;
     167                 : 
     168               0 :   return wwatch->OpenWindow(parent,
     169                 :                             "chrome://global/content/printPageSetup.xul",
     170                 :                             "_blank","chrome,modal,centerscreen", array,
     171               0 :                             getter_AddRefs(newWindow));
     172                 : }
     173                 : 
     174                 : /** ---------------------------------------------------
     175                 :  *  Helper function - Creates the "prefix" for the pref
     176                 :  *  It is either "print."
     177                 :  *  or "print.printer_<print name>."
     178                 :  */
     179                 : const char*
     180               0 : nsPrintOptions::GetPrefName(const char * aPrefName,
     181                 :                             const nsAString& aPrinterName)
     182                 : {
     183               0 :   if (!aPrefName || !*aPrefName) {
     184               0 :     NS_ERROR("Must have a valid pref name!");
     185               0 :     return aPrefName;
     186                 :   }
     187                 : 
     188               0 :   mPrefName.Truncate(); /* mPrefName = ""; */
     189                 : 
     190               0 :   if (aPrinterName.Length()) {
     191               0 :     mPrefName.Append("printer_");
     192               0 :     AppendUTF16toUTF8(aPrinterName, mPrefName);
     193               0 :     mPrefName.Append(".");
     194                 :   }
     195               0 :   mPrefName += aPrefName;
     196                 : 
     197               0 :   return mPrefName.get();
     198                 : }
     199                 : 
     200                 : //----------------------------------------------------------------------
     201                 : // Testing of read/write prefs
     202                 : // This define controls debug output
     203                 : #ifdef DEBUG_rods_X
     204                 : static void WriteDebugStr(const char* aArg1, const char* aArg2,
     205                 :                           const PRUnichar* aStr)
     206                 : {
     207                 :   nsString str(aStr);
     208                 :   PRUnichar s = '&';
     209                 :   PRUnichar r = '_';
     210                 :   str.ReplaceChar(s, r);
     211                 : 
     212                 :   printf("%s %s = %s \n", aArg1, aArg2, ToNewUTF8String(str));
     213                 : }
     214                 : const char* kWriteStr = "Write Pref:";
     215                 : const char* kReadStr  = "Read Pref:";
     216                 : #define DUMP_STR(_a1, _a2, _a3)  WriteDebugStr((_a1), GetPrefName((_a2), \
     217                 : aPrefName), (_a3));
     218                 : #define DUMP_BOOL(_a1, _a2, _a3) printf("%s %s = %s \n", (_a1), \
     219                 : GetPrefName((_a2), aPrefName), (_a3)?"T":"F");
     220                 : #define DUMP_INT(_a1, _a2, _a3)  printf("%s %s = %d \n", (_a1), \
     221                 : GetPrefName((_a2), aPrefName), (_a3));
     222                 : #define DUMP_DBL(_a1, _a2, _a3)  printf("%s %s = %10.5f \n", (_a1), \
     223                 : GetPrefName((_a2), aPrefName), (_a3));
     224                 : #else
     225                 : #define DUMP_STR(_a1, _a2, _a3)
     226                 : #define DUMP_BOOL(_a1, _a2, _a3)
     227                 : #define DUMP_INT(_a1, _a2, _a3)
     228                 : #define DUMP_DBL(_a1, _a2, _a3)
     229                 : #endif /* DEBUG_rods_X */
     230                 : //----------------------------------------------------------------------
     231                 : 
     232                 : /**
     233                 :  *  This will either read in the generic prefs (not specific to a printer)
     234                 :  *  or read the prefs in using the printer name to qualify.
     235                 :  *  It is either "print.attr_name" or "print.printer_HPLasr5.attr_name"
     236                 :  */
     237                 : nsresult 
     238               0 : nsPrintOptions::ReadPrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName,
     239                 :                           PRUint32 aFlags)
     240                 : {
     241               0 :   NS_ENSURE_ARG_POINTER(aPS);
     242                 : 
     243               0 :   if (aFlags & nsIPrintSettings::kInitSaveMargins) {
     244               0 :     PRInt32 halfInch = NS_INCHES_TO_INT_TWIPS(0.5);
     245               0 :     nsIntMargin margin(halfInch, halfInch, halfInch, halfInch);
     246                 :     ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top,
     247               0 :                           kMarginTop);
     248                 :     DUMP_INT(kReadStr, kMarginTop, margin.top);
     249                 :     ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), margin.left,
     250               0 :                           kMarginLeft);
     251                 :     DUMP_INT(kReadStr, kMarginLeft, margin.left);
     252                 :     ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
     253               0 :                           margin.bottom, kMarginBottom);
     254                 :     DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
     255                 :     ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), margin.right,
     256               0 :                           kMarginRight);
     257                 :     DUMP_INT(kReadStr, kMarginRight, margin.right);
     258               0 :     aPS->SetMarginInTwips(margin);
     259                 :   }
     260                 : 
     261               0 :   if (aFlags & nsIPrintSettings::kInitSaveEdges) {
     262               0 :     nsIntMargin margin(0,0,0,0);
     263                 :     ReadInchesIntToTwipsPref(GetPrefName(kEdgeTop, aPrinterName), margin.top,
     264               0 :                              kEdgeTop);
     265                 :     DUMP_INT(kReadStr, kEdgeTop, margin.top);
     266                 :     ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), margin.left,
     267               0 :                              kEdgeLeft);
     268                 :     DUMP_INT(kReadStr, kEdgeLeft, margin.left);
     269                 :     ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
     270               0 :                              margin.bottom, kEdgeBottom);
     271                 :     DUMP_INT(kReadStr, kEdgeBottom, margin.bottom);
     272                 :     ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName), margin.right,
     273               0 :                              kEdgeRight);
     274                 :     DUMP_INT(kReadStr, kEdgeRight, margin.right);
     275               0 :     aPS->SetEdgeInTwips(margin);
     276                 :   }
     277                 : 
     278               0 :   if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
     279               0 :     nsIntMargin margin;
     280                 :     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName), margin.top,
     281               0 :                              kUnwriteableMarginTop);
     282                 :     DUMP_INT(kReadStr, kUnwriteableMarginTop, margin.top);
     283                 :     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName), margin.left,
     284               0 :                              kUnwriteableMarginLeft);
     285                 :     DUMP_INT(kReadStr, kUnwriteableMarginLeft, margin.left);
     286                 :     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
     287               0 :                              margin.bottom, kUnwriteableMarginBottom);
     288                 :     DUMP_INT(kReadStr, kUnwriteableMarginBottom, margin.bottom);
     289                 :     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName), margin.right,
     290               0 :                              kUnwriteableMarginRight);
     291                 :     DUMP_INT(kReadStr, kUnwriteableMarginRight, margin.right);
     292               0 :     aPS->SetUnwriteableMarginInTwips(margin);
     293                 :   }
     294                 : 
     295                 :   bool     b;
     296               0 :   nsAutoString str;
     297                 :   PRInt32  iVal;
     298                 :   double   dbl;
     299                 : 
     300                 : #define GETBOOLPREF(_prefname, _retval)                 \
     301                 :   NS_SUCCEEDED(                                         \
     302                 :     Preferences::GetBool(                               \
     303                 :       GetPrefName(_prefname, aPrinterName), _retval     \
     304                 :     )                                                   \
     305                 :   )
     306                 : 
     307                 : #define GETSTRPREF(_prefname, _retval)                  \
     308                 :   NS_SUCCEEDED(                                         \
     309                 :     Preferences::GetString(                             \
     310                 :       GetPrefName(_prefname, aPrinterName), _retval     \
     311                 :     )                                                   \
     312                 :   )
     313                 : 
     314                 : #define GETINTPREF(_prefname, _retval)                  \
     315                 :   NS_SUCCEEDED(                                         \
     316                 :     Preferences::GetInt(                                \
     317                 :       GetPrefName(_prefname, aPrinterName), _retval     \
     318                 :     )                                                   \
     319                 :   )
     320                 : 
     321                 : #define GETDBLPREF(_prefname, _retval)                  \
     322                 :   NS_SUCCEEDED(                                         \
     323                 :     ReadPrefDouble(                                     \
     324                 :       GetPrefName(_prefname, aPrinterName), _retval     \
     325                 :     )                                                   \
     326                 :   )
     327                 : 
     328                 :   // Paper size prefs are read as a group
     329               0 :   if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
     330                 :     PRInt32 sizeUnit, sizeType;
     331                 :     double width, height;
     332                 : 
     333               0 :     bool success = GETINTPREF(kPrintPaperSizeUnit, &sizeUnit)
     334               0 :                   && GETINTPREF(kPrintPaperSizeType, &sizeType)
     335               0 :                   && GETDBLPREF(kPrintPaperWidth, width)
     336               0 :                   && GETDBLPREF(kPrintPaperHeight, height)
     337               0 :                   && GETSTRPREF(kPrintPaperName, &str);
     338                 : 
     339                 :     // Bug 315687: Sanity check paper size to avoid paper size values in
     340                 :     // mm when the size unit flag is inches. The value 100 is arbitrary
     341                 :     // and can be changed.
     342               0 :     if (success) {
     343                 :       success = (sizeUnit != nsIPrintSettings::kPaperSizeInches)
     344                 :              || (width < 100.0)
     345               0 :              || (height < 100.0);
     346                 :     }
     347                 : 
     348               0 :     if (success) {
     349               0 :       aPS->SetPaperSizeUnit(sizeUnit);
     350                 :       DUMP_INT(kReadStr, kPrintPaperSizeUnit, sizeUnit);
     351               0 :       aPS->SetPaperSizeType(sizeType);
     352                 :       DUMP_INT(kReadStr, kPrintPaperSizeType, sizeType);
     353               0 :       aPS->SetPaperWidth(width);
     354                 :       DUMP_DBL(kReadStr, kPrintPaperWidth, width);
     355               0 :       aPS->SetPaperHeight(height);
     356                 :       DUMP_DBL(kReadStr, kPrintPaperHeight, height);
     357               0 :       aPS->SetPaperName(str.get());
     358                 :       DUMP_STR(kReadStr, kPrintPaperName, str.get());
     359                 :     }
     360                 :   }
     361                 : 
     362               0 :   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
     363               0 :   if (GETBOOLPREF(kPrintEvenPages, &b)) {
     364               0 :     aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
     365                 :     DUMP_BOOL(kReadStr, kPrintEvenPages, b);
     366                 :   }
     367                 :   }
     368                 : 
     369               0 :   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
     370               0 :     if (GETBOOLPREF(kPrintOddPages, &b)) {
     371               0 :       aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
     372                 :       DUMP_BOOL(kReadStr, kPrintOddPages, b);
     373                 :     }
     374                 :   }
     375                 : 
     376               0 :   if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
     377               0 :     if (GETSTRPREF(kPrintHeaderStrLeft, &str)) {
     378               0 :       aPS->SetHeaderStrLeft(str.get());
     379                 :       DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
     380                 :     }
     381                 :   }
     382                 : 
     383               0 :   if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
     384               0 :     if (GETSTRPREF(kPrintHeaderStrCenter, &str)) {
     385               0 :       aPS->SetHeaderStrCenter(str.get());
     386                 :       DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
     387                 :     }
     388                 :   }
     389                 : 
     390               0 :   if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
     391               0 :     if (GETSTRPREF(kPrintHeaderStrRight, &str)) {
     392               0 :       aPS->SetHeaderStrRight(str.get());
     393                 :       DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
     394                 :     }
     395                 :   }
     396                 : 
     397               0 :   if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
     398               0 :     if (GETSTRPREF(kPrintFooterStrLeft, &str)) {
     399               0 :       aPS->SetFooterStrLeft(str.get());
     400                 :       DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
     401                 :     }
     402                 :   }
     403                 : 
     404               0 :   if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
     405               0 :     if (GETSTRPREF(kPrintFooterStrCenter, &str)) {
     406               0 :       aPS->SetFooterStrCenter(str.get());
     407                 :       DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
     408                 :     }
     409                 :   }
     410                 : 
     411               0 :   if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
     412               0 :     if (GETSTRPREF(kPrintFooterStrRight, &str)) {
     413               0 :       aPS->SetFooterStrRight(str.get());
     414                 :       DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
     415                 :     }
     416                 :   }
     417                 : 
     418               0 :   if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
     419               0 :     if (GETBOOLPREF(kPrintBGColors, &b)) {
     420               0 :       aPS->SetPrintBGColors(b);
     421                 :       DUMP_BOOL(kReadStr, kPrintBGColors, b);
     422                 :     }
     423                 :   }
     424                 : 
     425               0 :   if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
     426               0 :     if (GETBOOLPREF(kPrintBGImages, &b)) {
     427               0 :       aPS->SetPrintBGImages(b);
     428                 :       DUMP_BOOL(kReadStr, kPrintBGImages, b);
     429                 :     }
     430                 :   }
     431                 : 
     432               0 :   if (aFlags & nsIPrintSettings::kInitSaveReversed) {
     433               0 :     if (GETBOOLPREF(kPrintReversed, &b)) {
     434               0 :       aPS->SetPrintReversed(b);
     435                 :       DUMP_BOOL(kReadStr, kPrintReversed, b);
     436                 :     }
     437                 :   }
     438                 : 
     439               0 :   if (aFlags & nsIPrintSettings::kInitSaveInColor) {
     440               0 :     if (GETBOOLPREF(kPrintInColor, &b)) {
     441               0 :       aPS->SetPrintInColor(b);
     442                 :       DUMP_BOOL(kReadStr, kPrintInColor, b);
     443                 :     }
     444                 :   }
     445                 : 
     446               0 :   if (aFlags & nsIPrintSettings::kInitSavePlexName) {
     447               0 :     if (GETSTRPREF(kPrintPlexName, &str)) {
     448               0 :       aPS->SetPlexName(str.get());
     449                 :       DUMP_STR(kReadStr, kPrintPlexName, str.get());
     450                 :     }
     451                 :   }
     452                 : 
     453               0 :   if (aFlags & nsIPrintSettings::kInitSavePaperData) {
     454               0 :     if (GETINTPREF(kPrintPaperData, &iVal)) {
     455               0 :       aPS->SetPaperData(iVal);
     456                 :       DUMP_INT(kReadStr, kPrintPaperData, iVal);
     457                 :     }
     458                 :   }
     459                 : 
     460               0 :   if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
     461               0 :     if (GETSTRPREF(kPrintColorspace, &str)) {
     462               0 :       aPS->SetColorspace(str.get());
     463                 :       DUMP_STR(kReadStr, kPrintColorspace, str.get());
     464                 :     }
     465                 :   }
     466                 : 
     467               0 :   if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
     468               0 :     if (GETSTRPREF(kPrintResolutionName, &str)) {
     469               0 :       aPS->SetResolutionName(str.get());
     470                 :       DUMP_STR(kReadStr, kPrintResolutionName, str.get());
     471                 :     }
     472                 :   }
     473                 : 
     474               0 :   if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
     475               0 :     if (GETBOOLPREF(kPrintDownloadFonts, &b)) {
     476               0 :       aPS->SetDownloadFonts(b);
     477                 :       DUMP_BOOL(kReadStr, kPrintDownloadFonts, b);
     478                 :     }
     479                 :   }
     480                 : 
     481               0 :   if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
     482               0 :     if (GETINTPREF(kPrintOrientation, &iVal)) {
     483               0 :       aPS->SetOrientation(iVal);
     484                 :       DUMP_INT(kReadStr, kPrintOrientation, iVal);
     485                 :     }
     486                 :   }
     487                 : 
     488               0 :   if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
     489               0 :     if (GETSTRPREF(kPrintCommand, &str)) {
     490               0 :       aPS->SetPrintCommand(str.get());
     491                 :       DUMP_STR(kReadStr, kPrintCommand, str.get());
     492                 :     }
     493                 :   }
     494                 : 
     495               0 :   if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
     496               0 :     if (GETBOOLPREF(kPrintToFile, &b)) {
     497               0 :       aPS->SetPrintToFile(b);
     498                 :       DUMP_BOOL(kReadStr, kPrintToFile, b);
     499                 :     }
     500                 :   }
     501                 : 
     502               0 :   if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
     503               0 :     if (GETSTRPREF(kPrintToFileName, &str)) {
     504               0 :       aPS->SetToFileName(str.get());
     505                 :       DUMP_STR(kReadStr, kPrintToFileName, str.get());
     506                 :     }
     507                 :   }
     508                 : 
     509               0 :   if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
     510               0 :     if (GETINTPREF(kPrintPageDelay, &iVal)) {
     511               0 :       aPS->SetPrintPageDelay(iVal);
     512                 :       DUMP_INT(kReadStr, kPrintPageDelay, iVal);
     513                 :     }
     514                 :   }
     515                 : 
     516               0 :   if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
     517               0 :     if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
     518               0 :       aPS->SetShrinkToFit(b);
     519                 :       DUMP_BOOL(kReadStr, kPrintShrinkToFit, b);
     520                 :     }
     521                 :   }
     522                 : 
     523               0 :   if (aFlags & nsIPrintSettings::kInitSaveScaling) {
     524               0 :     if (GETDBLPREF(kPrintScaling, dbl)) {
     525               0 :       aPS->SetScaling(dbl);
     526                 :       DUMP_DBL(kReadStr, kPrintScaling, dbl);
     527                 :     }
     528                 :   }
     529                 : 
     530                 :   // Not Reading In:
     531                 :   //   Number of Copies
     532                 : 
     533               0 :   return NS_OK;
     534                 : }
     535                 : 
     536                 : /** ---------------------------------------------------
     537                 :  *  See documentation in nsPrintOptionsImpl.h
     538                 :  *  @update 1/12/01 rods
     539                 :  */
     540                 : nsresult 
     541               0 : nsPrintOptions::WritePrefs(nsIPrintSettings *aPS, const nsAString& aPrinterName,
     542                 :                            PRUint32 aFlags)
     543                 : {
     544               0 :   NS_ENSURE_ARG_POINTER(aPS);
     545                 : 
     546               0 :   nsIntMargin margin;
     547               0 :   if (aFlags & nsIPrintSettings::kInitSaveMargins) {
     548               0 :     if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
     549                 :       WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName),
     550               0 :                                margin.top);
     551                 :       DUMP_INT(kWriteStr, kMarginTop, margin.top);
     552                 :       WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
     553               0 :                                margin.left);
     554                 :       DUMP_INT(kWriteStr, kMarginLeft, margin.top);
     555                 :       WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
     556               0 :                                margin.bottom);
     557                 :       DUMP_INT(kWriteStr, kMarginBottom, margin.top);
     558                 :       WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
     559               0 :                                margin.right);
     560                 :       DUMP_INT(kWriteStr, kMarginRight, margin.top);
     561                 :     }
     562                 :   }
     563                 : 
     564               0 :   nsIntMargin edge;
     565               0 :   if (aFlags & nsIPrintSettings::kInitSaveEdges) {
     566               0 :     if (NS_SUCCEEDED(aPS->GetEdgeInTwips(edge))) {
     567                 :       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName),
     568               0 :                                   edge.top);
     569                 :       DUMP_INT(kWriteStr, kEdgeTop, edge.top);
     570                 :       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
     571               0 :                                   edge.left);
     572                 :       DUMP_INT(kWriteStr, kEdgeLeft, edge.top);
     573                 :       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
     574               0 :                                   edge.bottom);
     575                 :       DUMP_INT(kWriteStr, kEdgeBottom, edge.top);
     576                 :       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
     577               0 :                                   edge.right);
     578                 :       DUMP_INT(kWriteStr, kEdgeRight, edge.top);
     579                 :     }
     580                 :   }
     581                 : 
     582               0 :   nsIntMargin unwriteableMargin;
     583               0 :   if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
     584               0 :     if (NS_SUCCEEDED(aPS->GetUnwriteableMarginInTwips(unwriteableMargin))) {
     585                 :       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName),
     586               0 :                                   unwriteableMargin.top);
     587                 :       DUMP_INT(kWriteStr, kUnwriteableMarginTop, unwriteableMargin.top);
     588                 :       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName),
     589               0 :                                   unwriteableMargin.left);
     590                 :       DUMP_INT(kWriteStr, kUnwriteableMarginLeft, unwriteableMargin.top);
     591                 :       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
     592               0 :                                   unwriteableMargin.bottom);
     593                 :       DUMP_INT(kWriteStr, kUnwriteableMarginBottom, unwriteableMargin.top);
     594                 :       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName),
     595               0 :                                   unwriteableMargin.right);
     596                 :       DUMP_INT(kWriteStr, kUnwriteableMarginRight, unwriteableMargin.top);
     597                 :     }
     598                 :   }
     599                 : 
     600                 :   // Paper size prefs are saved as a group
     601               0 :   if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
     602                 :     PRInt16 sizeUnit, sizeType;
     603                 :     double width, height;
     604                 :     PRUnichar *name;
     605                 :  
     606               0 :     if (
     607               0 :       NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
     608               0 :       NS_SUCCEEDED(aPS->GetPaperSizeType(&sizeType)) &&
     609               0 :       NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
     610               0 :       NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
     611               0 :       NS_SUCCEEDED(aPS->GetPaperName(&name))
     612                 :     ) {
     613                 :       DUMP_INT(kWriteStr, kPrintPaperSizeUnit, sizeUnit);
     614                 :       Preferences::SetInt(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
     615               0 :                           PRInt32(sizeUnit));
     616                 :       DUMP_INT(kWriteStr, kPrintPaperSizeType, sizeType);
     617                 :       Preferences::SetInt(GetPrefName(kPrintPaperSizeType, aPrinterName),
     618               0 :                           PRInt32(sizeType));
     619                 :       DUMP_DBL(kWriteStr, kPrintPaperWidth, width);
     620               0 :       WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
     621                 :       DUMP_DBL(kWriteStr, kPrintPaperHeight, height);
     622               0 :       WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
     623                 :       DUMP_STR(kWriteStr, kPrintPaperName, name);
     624               0 :       Preferences::SetString(GetPrefName(kPrintPaperName, aPrinterName), name);
     625                 :     }
     626                 :   }
     627                 : 
     628                 :   bool       b;
     629                 :   PRUnichar* uStr;
     630                 :   PRInt32    iVal;
     631                 :   PRInt16    iVal16;
     632                 :   double     dbl;
     633                 : 
     634               0 :   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
     635               0 :     if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages,
     636                 :                                           &b))) {
     637                 :           DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
     638               0 :           Preferences::SetBool(GetPrefName(kPrintEvenPages, aPrinterName), b);
     639                 :         }
     640                 :   }
     641                 : 
     642               0 :   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
     643               0 :     if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages,
     644                 :                                           &b))) {
     645                 :           DUMP_BOOL(kWriteStr, kPrintOddPages, b);
     646               0 :           Preferences::SetBool(GetPrefName(kPrintOddPages, aPrinterName), b);
     647                 :         }
     648                 :   }
     649                 : 
     650               0 :   if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
     651               0 :     if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(&uStr))) {
     652                 :       DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr);
     653                 :       Preferences::SetString(GetPrefName(kPrintHeaderStrLeft, aPrinterName),
     654               0 :                              uStr);
     655                 :     }
     656                 :   }
     657                 : 
     658               0 :   if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
     659               0 :     if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(&uStr))) {
     660                 :       DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr);
     661                 :       Preferences::SetString(GetPrefName(kPrintHeaderStrCenter, aPrinterName),
     662               0 :                              uStr);
     663                 :     }
     664                 :   }
     665                 : 
     666               0 :   if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
     667               0 :     if (NS_SUCCEEDED(aPS->GetHeaderStrRight(&uStr))) {
     668                 :       DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr);
     669                 :       Preferences::SetString(GetPrefName(kPrintHeaderStrRight, aPrinterName),
     670               0 :                              uStr);
     671                 :     }
     672                 :   }
     673                 : 
     674               0 :   if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
     675               0 :     if (NS_SUCCEEDED(aPS->GetFooterStrLeft(&uStr))) {
     676                 :       DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr);
     677                 :       Preferences::SetString(GetPrefName(kPrintFooterStrLeft, aPrinterName),
     678               0 :                              uStr);
     679                 :     }
     680                 :   }
     681                 : 
     682               0 :   if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
     683               0 :     if (NS_SUCCEEDED(aPS->GetFooterStrCenter(&uStr))) {
     684                 :       DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr);
     685                 :       Preferences::SetString(GetPrefName(kPrintFooterStrCenter, aPrinterName),
     686               0 :                              uStr);
     687                 :     }
     688                 :   }
     689                 : 
     690               0 :   if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
     691               0 :     if (NS_SUCCEEDED(aPS->GetFooterStrRight(&uStr))) {
     692                 :       DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr);
     693                 :       Preferences::SetString(GetPrefName(kPrintFooterStrRight, aPrinterName),
     694               0 :                              uStr);
     695                 :     }
     696                 :   }
     697                 : 
     698               0 :   if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
     699               0 :     if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
     700                 :       DUMP_BOOL(kWriteStr, kPrintBGColors, b);
     701               0 :       Preferences::SetBool(GetPrefName(kPrintBGColors, aPrinterName), b);
     702                 :     }
     703                 :   }
     704                 : 
     705               0 :   if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
     706               0 :     if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
     707                 :       DUMP_BOOL(kWriteStr, kPrintBGImages, b);
     708               0 :       Preferences::SetBool(GetPrefName(kPrintBGImages, aPrinterName), b);
     709                 :     }
     710                 :   }
     711                 : 
     712               0 :   if (aFlags & nsIPrintSettings::kInitSaveReversed) {
     713               0 :     if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
     714                 :       DUMP_BOOL(kWriteStr, kPrintReversed, b);
     715               0 :       Preferences::SetBool(GetPrefName(kPrintReversed, aPrinterName), b);
     716                 :     }
     717                 :   }
     718                 : 
     719               0 :   if (aFlags & nsIPrintSettings::kInitSaveInColor) {
     720               0 :     if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
     721                 :       DUMP_BOOL(kWriteStr, kPrintInColor, b);
     722               0 :       Preferences::SetBool(GetPrefName(kPrintInColor, aPrinterName), b);
     723                 :     }
     724                 :   }
     725                 : 
     726               0 :   if (aFlags & nsIPrintSettings::kInitSavePlexName) {
     727               0 :     if (NS_SUCCEEDED(aPS->GetPlexName(&uStr))) {
     728                 :       DUMP_STR(kWriteStr, kPrintPlexName, uStr);
     729               0 :       Preferences::SetString(GetPrefName(kPrintPlexName, aPrinterName), uStr);
     730                 :     }
     731                 :   }
     732                 : 
     733               0 :   if (aFlags & nsIPrintSettings::kInitSavePaperData) {
     734               0 :     if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
     735                 :       DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
     736                 :       Preferences::SetInt(GetPrefName(kPrintPaperData, aPrinterName),
     737               0 :                           PRInt32(iVal16));
     738                 :     }
     739                 :   }
     740                 : 
     741               0 :   if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
     742               0 :     if (NS_SUCCEEDED(aPS->GetColorspace(&uStr))) {
     743                 :       DUMP_STR(kWriteStr, kPrintColorspace, uStr);
     744               0 :       Preferences::SetString(GetPrefName(kPrintColorspace, aPrinterName), uStr);
     745                 :     }
     746                 :   }
     747                 : 
     748               0 :   if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
     749               0 :     if (NS_SUCCEEDED(aPS->GetResolutionName(&uStr))) {
     750                 :       DUMP_STR(kWriteStr, kPrintResolutionName, uStr);
     751                 :       Preferences::SetString(GetPrefName(kPrintResolutionName, aPrinterName),
     752               0 :                              uStr);
     753                 :     }
     754                 :   }
     755                 : 
     756               0 :   if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
     757               0 :     if (NS_SUCCEEDED(aPS->GetDownloadFonts(&b))) {
     758                 :       DUMP_BOOL(kWriteStr, kPrintDownloadFonts, b);
     759               0 :       Preferences::SetBool(GetPrefName(kPrintDownloadFonts, aPrinterName), b);
     760                 :     }
     761                 :   }
     762                 : 
     763               0 :   if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
     764               0 :     if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
     765                 :       DUMP_INT(kWriteStr, kPrintOrientation, iVal);
     766               0 :       Preferences::SetInt(GetPrefName(kPrintOrientation, aPrinterName), iVal);
     767                 :     }
     768                 :   }
     769                 : 
     770               0 :   if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
     771               0 :     if (NS_SUCCEEDED(aPS->GetPrintCommand(&uStr))) {
     772                 :       DUMP_STR(kWriteStr, kPrintCommand, uStr);
     773               0 :       Preferences::SetString(GetPrefName(kPrintCommand, aPrinterName), uStr);
     774                 :     }
     775                 :   }
     776                 : 
     777                 :   // Only the general version of this pref is saved
     778               0 :   if ((aFlags & nsIPrintSettings::kInitSavePrinterName)
     779               0 :       && aPrinterName.IsEmpty()) {
     780               0 :     if (NS_SUCCEEDED(aPS->GetPrinterName(&uStr))) {
     781                 :       DUMP_STR(kWriteStr, kPrinterName, uStr);
     782               0 :       Preferences::SetString(kPrinterName, uStr);
     783                 :     }
     784                 :   }
     785                 : 
     786               0 :   if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
     787               0 :     if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
     788                 :       DUMP_BOOL(kWriteStr, kPrintToFile, b);
     789               0 :       Preferences::SetBool(GetPrefName(kPrintToFile, aPrinterName), b);
     790                 :     }
     791                 :   }
     792                 : 
     793               0 :   if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
     794               0 :     if (NS_SUCCEEDED(aPS->GetToFileName(&uStr))) {
     795                 :       DUMP_STR(kWriteStr, kPrintToFileName, uStr);
     796               0 :       Preferences::SetString(GetPrefName(kPrintToFileName, aPrinterName), uStr);
     797                 :     }
     798                 :   }
     799                 : 
     800               0 :   if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
     801               0 :     if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
     802                 :       DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
     803               0 :       Preferences::SetInt(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
     804                 :     }
     805                 :   }
     806                 : 
     807               0 :   if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
     808               0 :     if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
     809                 :       DUMP_BOOL(kWriteStr, kPrintShrinkToFit, b);
     810               0 :       Preferences::SetBool(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
     811                 :     }
     812                 :   }
     813                 : 
     814               0 :   if (aFlags & nsIPrintSettings::kInitSaveScaling) {
     815               0 :     if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
     816                 :       DUMP_DBL(kWriteStr, kPrintScaling, dbl);
     817               0 :       WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
     818                 :     }
     819                 :   }
     820                 : 
     821                 :   // Not Writing Out:
     822                 :   //   Number of Copies
     823                 : 
     824               0 :   return NS_OK;
     825                 : }
     826                 : 
     827                 : NS_IMETHODIMP
     828               0 : nsPrintOptions::DisplayJobProperties(const PRUnichar *aPrinter,
     829                 :                                      nsIPrintSettings* aPrintSettings,
     830                 :                                      bool *aDisplayed)
     831                 : {
     832               0 :   NS_ENSURE_ARG_POINTER(aPrinter);
     833               0 :   *aDisplayed = false;
     834                 : 
     835                 :   nsresult rv;
     836                 :   nsCOMPtr<nsIPrinterEnumerator> propDlg =
     837               0 :            do_CreateInstance(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
     838               0 :   NS_ENSURE_SUCCESS(rv, rv);
     839                 : 
     840               0 :   NS_ENSURE_ARG_POINTER(aPrintSettings);
     841               0 :   rv = propDlg->DisplayPropertiesDlg(aPrinter, aPrintSettings);
     842               0 :   NS_ENSURE_SUCCESS(rv, rv);
     843                 : 
     844               0 :   *aDisplayed = true;
     845                 : 
     846               0 :   return rv;
     847                 : }
     848                 : 
     849               0 : NS_IMETHODIMP nsPrintOptions::GetNativeData(PRInt16 aDataType, void * *_retval)
     850                 : {
     851               0 :   return NS_ERROR_NOT_IMPLEMENTED;
     852                 : }
     853                 : 
     854               0 : nsresult nsPrintOptions::_CreatePrintSettings(nsIPrintSettings **_retval)
     855                 : {
     856                 :   // does not initially ref count
     857               0 :   nsPrintSettings * printSettings = new nsPrintSettings();
     858               0 :   NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
     859                 : 
     860               0 :   NS_ADDREF(*_retval = printSettings); // ref count
     861                 : 
     862               0 :   nsXPIDLString printerName;
     863               0 :   nsresult rv = GetDefaultPrinterName(getter_Copies(printerName));
     864               0 :   NS_ENSURE_SUCCESS(rv, rv);
     865               0 :   (*_retval)->SetPrinterName(printerName.get());
     866                 : 
     867                 :   (void)InitPrintSettingsFromPrefs(*_retval, false,
     868               0 :                                    nsIPrintSettings::kInitSaveAll);
     869                 : 
     870               0 :   return NS_OK;
     871                 : }
     872                 : 
     873               0 : NS_IMETHODIMP nsPrintOptions::CreatePrintSettings(nsIPrintSettings **_retval)
     874                 : {
     875               0 :   return _CreatePrintSettings(_retval);
     876                 : }
     877                 : 
     878                 : NS_IMETHODIMP
     879               0 : nsPrintOptions::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
     880                 : {
     881                 :   nsresult rv;
     882                 : 
     883               0 :   rv = CreatePrintSettings(getter_AddRefs(mGlobalPrintSettings));
     884               0 :   NS_ENSURE_SUCCESS(rv, rv);
     885                 : 
     886               0 :   NS_ADDREF(*aGlobalPrintSettings = mGlobalPrintSettings.get());
     887                 : 
     888               0 :   return rv;
     889                 : }
     890                 : 
     891                 : NS_IMETHODIMP
     892               0 : nsPrintOptions::GetNewPrintSettings(nsIPrintSettings * *aNewPrintSettings)
     893                 : {
     894               0 :   return CreatePrintSettings(aNewPrintSettings);
     895                 : }
     896                 : 
     897                 : NS_IMETHODIMP
     898               0 : nsPrintOptions::GetDefaultPrinterName(PRUnichar * *aDefaultPrinterName)
     899                 : {
     900                 :   nsresult rv;
     901                 :   nsCOMPtr<nsIPrinterEnumerator> prtEnum =
     902               0 :            do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
     903               0 :   NS_ENSURE_SUCCESS(rv, rv);
     904                 : 
     905                 :   // Look up the printer from the last print job
     906               0 :   nsAutoString lastPrinterName;
     907               0 :   Preferences::GetString(kPrinterName, &lastPrinterName);
     908               0 :   if (!lastPrinterName.IsEmpty()) {
     909                 :     // Verify it's still a valid printer
     910               0 :     nsCOMPtr<nsIStringEnumerator> printers;
     911               0 :     rv = prtEnum->GetPrinterNameList(getter_AddRefs(printers));
     912               0 :     if (NS_SUCCEEDED(rv)) {
     913               0 :       bool isValid = false;
     914                 :       bool hasMore;
     915               0 :       while (NS_SUCCEEDED(printers->HasMore(&hasMore)) && hasMore) {
     916               0 :         nsAutoString printer;
     917               0 :         if (NS_SUCCEEDED(printers->GetNext(printer)) && lastPrinterName.Equals(printer)) {
     918               0 :           isValid = true;
     919                 :           break;
     920                 :         }
     921                 :       }
     922               0 :       if (isValid) {
     923               0 :         *aDefaultPrinterName = ToNewUnicode(lastPrinterName);
     924               0 :         return NS_OK;
     925                 :       }
     926                 :     }
     927                 :   }
     928                 : 
     929                 :   // There is no last printer preference, or it doesn't name a valid printer.
     930                 :   // Return the default from the printer enumeration.
     931               0 :   return prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
     932                 : }
     933                 : 
     934                 : NS_IMETHODIMP
     935               0 : nsPrintOptions::InitPrintSettingsFromPrinter(const PRUnichar *aPrinterName,
     936                 :                                              nsIPrintSettings *aPrintSettings)
     937                 : {
     938               0 :   NS_ENSURE_ARG_POINTER(aPrintSettings);
     939               0 :   NS_ENSURE_ARG_POINTER(aPrinterName);
     940                 : 
     941                 : #ifdef NS_DEBUG
     942               0 :   nsXPIDLString printerName;
     943               0 :   aPrintSettings->GetPrinterName(getter_Copies(printerName));
     944               0 :   if (!printerName.Equals(aPrinterName)) {
     945               0 :     NS_WARNING("Printer names should match!");
     946                 :   }
     947                 : #endif
     948                 : 
     949                 :   bool isInitialized;
     950               0 :   aPrintSettings->GetIsInitializedFromPrinter(&isInitialized);
     951               0 :   if (isInitialized)
     952               0 :     return NS_OK;
     953                 : 
     954                 :   nsresult rv;
     955                 :   nsCOMPtr<nsIPrinterEnumerator> prtEnum =
     956               0 :            do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
     957               0 :   NS_ENSURE_SUCCESS(rv, rv);
     958                 : 
     959               0 :   rv = prtEnum->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
     960               0 :   NS_ENSURE_SUCCESS(rv, rv);
     961                 : 
     962               0 :   aPrintSettings->SetIsInitializedFromPrinter(true);
     963               0 :   return rv;
     964                 : }
     965                 : 
     966                 : /** ---------------------------------------------------
     967                 :  *  Helper function - Returns either the name or sets the length to zero
     968                 :  */
     969                 : static nsresult 
     970               0 : GetAdjustedPrinterName(nsIPrintSettings* aPS, bool aUsePNP,
     971                 :                        nsAString& aPrinterName)
     972                 : {
     973               0 :   NS_ENSURE_ARG_POINTER(aPS);
     974                 : 
     975               0 :   aPrinterName.Truncate();
     976               0 :   if (!aUsePNP)
     977               0 :     return NS_OK;
     978                 : 
     979                 :   // Get the Printer Name from the PrintSettings 
     980                 :   // to use as a prefix for Pref Names
     981               0 :   PRUnichar* prtName = nsnull;
     982                 : 
     983               0 :   nsresult rv = aPS->GetPrinterName(&prtName);
     984               0 :   NS_ENSURE_SUCCESS(rv, rv);
     985                 : 
     986               0 :   aPrinterName = nsDependentString(prtName);
     987                 : 
     988                 :   // Convert any whitespaces, carriage returns or newlines to _
     989                 :   // The below algorithm is supposedly faster than using iterators
     990               0 :   NS_NAMED_LITERAL_STRING(replSubstr, "_");
     991               0 :   const char* replaceStr = " \n\r";
     992                 : 
     993                 :   PRInt32 x;
     994               0 :   for (x=0; x < (PRInt32)strlen(replaceStr); x++) {
     995               0 :     PRUnichar uChar = replaceStr[x];
     996                 : 
     997               0 :     PRInt32 i = 0;
     998               0 :     while ((i = aPrinterName.FindChar(uChar, i)) != kNotFound) {
     999               0 :       aPrinterName.Replace(i, 1, replSubstr);
    1000               0 :       i++;
    1001                 :     }
    1002                 :   }
    1003               0 :   return NS_OK;
    1004                 : }
    1005                 : 
    1006                 : NS_IMETHODIMP
    1007               0 : nsPrintOptions::GetPrinterPrefInt(nsIPrintSettings *aPrintSettings,
    1008                 :                                   const PRUnichar *aPrefName, PRInt32 *_retval)
    1009                 : {
    1010               0 :   NS_ENSURE_ARG_POINTER(aPrintSettings);
    1011               0 :   NS_ENSURE_ARG_POINTER(aPrefName);
    1012                 : 
    1013               0 :   nsAutoString prtName;
    1014                 :   // Get the Printer Name from the PrintSettings
    1015                 :   // to use as a prefix for Pref Names
    1016               0 :   GetAdjustedPrinterName(aPrintSettings, true, prtName);
    1017                 : 
    1018                 :   const char* prefName =
    1019               0 :     GetPrefName(NS_LossyConvertUTF16toASCII(aPrefName).get(), prtName);
    1020                 : 
    1021               0 :   NS_ENSURE_TRUE(prefName, NS_ERROR_FAILURE);
    1022                 : 
    1023                 :   PRInt32 iVal;
    1024               0 :   nsresult rv = Preferences::GetInt(prefName, &iVal);
    1025               0 :   NS_ENSURE_SUCCESS(rv, rv);
    1026                 : 
    1027               0 :   *_retval = iVal;
    1028               0 :   return rv;
    1029                 : }
    1030                 : 
    1031                 : NS_IMETHODIMP 
    1032               0 : nsPrintOptions::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS,
    1033                 :                                            bool aUsePNP, PRUint32 aFlags)
    1034                 : {
    1035               0 :   NS_ENSURE_ARG_POINTER(aPS);
    1036                 : 
    1037                 :   bool isInitialized;
    1038               0 :   aPS->GetIsInitializedFromPrefs(&isInitialized);
    1039                 : 
    1040               0 :   if (isInitialized)
    1041               0 :     return NS_OK;
    1042                 : 
    1043               0 :   nsAutoString prtName;
    1044                 :   // read any non printer specific prefs
    1045                 :   // with empty printer name
    1046               0 :   nsresult rv = ReadPrefs(aPS, prtName, aFlags);
    1047               0 :   NS_ENSURE_SUCCESS(rv, rv);
    1048                 : 
    1049                 :   // Get the Printer Name from the PrintSettings
    1050                 :   // to use as a prefix for Pref Names
    1051               0 :   rv = GetAdjustedPrinterName(aPS, aUsePNP, prtName);
    1052               0 :   NS_ENSURE_SUCCESS(rv, rv);
    1053                 : 
    1054               0 :   if (prtName.IsEmpty()) {
    1055               0 :     NS_WARNING("Caller should supply a printer name.");
    1056               0 :     return NS_OK;
    1057                 :   }
    1058                 : 
    1059                 :   // Now read any printer specific prefs
    1060               0 :   rv = ReadPrefs(aPS, prtName, aFlags);
    1061               0 :   if (NS_SUCCEEDED(rv))
    1062               0 :     aPS->SetIsInitializedFromPrefs(true);
    1063                 : 
    1064               0 :   return NS_OK;
    1065                 : }
    1066                 : 
    1067                 : /**
    1068                 :  *  Save all of the printer settings; if we can find a printer name, save
    1069                 :  *  printer-specific preferences. Otherwise, save generic ones.
    1070                 :  */
    1071                 : nsresult
    1072               0 : nsPrintOptions::SavePrintSettingsToPrefs(nsIPrintSettings *aPS,
    1073                 :                                          bool aUsePrinterNamePrefix,
    1074                 :                                          PRUint32 aFlags)
    1075                 : {
    1076               0 :   NS_ENSURE_ARG_POINTER(aPS);
    1077               0 :   nsAutoString prtName;
    1078                 : 
    1079                 :   // Get the printer name from the PrinterSettings for an optional prefix.
    1080               0 :   nsresult rv = GetAdjustedPrinterName(aPS, aUsePrinterNamePrefix, prtName);
    1081               0 :   NS_ENSURE_SUCCESS(rv, rv);
    1082                 : 
    1083                 :   // Write the prefs, with or without a printer name prefix.
    1084               0 :   return WritePrefs(aPS, prtName, aFlags);
    1085                 : }
    1086                 : 
    1087                 : 
    1088                 : //-----------------------------------------------------
    1089                 : //-- Protected Methods --------------------------------
    1090                 : //-----------------------------------------------------
    1091                 : nsresult
    1092               0 : nsPrintOptions::ReadPrefDouble(const char * aPrefId, double& aVal)
    1093                 : {
    1094               0 :   NS_ENSURE_ARG_POINTER(aPrefId);
    1095                 : 
    1096               0 :   nsCAutoString str;
    1097               0 :   nsresult rv = Preferences::GetCString(aPrefId, &str);
    1098               0 :   if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
    1099               0 :     aVal = atof(str.get());
    1100                 :   }
    1101               0 :   return rv;
    1102                 : }
    1103                 : 
    1104                 : nsresult
    1105               0 : nsPrintOptions::WritePrefDouble(const char * aPrefId, double aVal)
    1106                 : {
    1107               0 :   NS_ENSURE_ARG_POINTER(aPrefId);
    1108                 : 
    1109               0 :   nsPrintfCString str("%6.2f", aVal);
    1110               0 :   NS_ENSURE_TRUE(!str.IsEmpty(), NS_ERROR_FAILURE);
    1111                 : 
    1112               0 :   return Preferences::SetCString(aPrefId, str);
    1113                 : }
    1114                 : 
    1115                 : void
    1116               0 : nsPrintOptions::ReadInchesToTwipsPref(const char * aPrefId, PRInt32& aTwips,
    1117                 :                                       const char * aMarginPref)
    1118                 : {
    1119               0 :   nsAutoString str;
    1120               0 :   nsresult rv = Preferences::GetString(aPrefId, &str);
    1121               0 :   if (NS_FAILED(rv) || str.IsEmpty()) {
    1122               0 :     rv = Preferences::GetString(aMarginPref, &str);
    1123                 :   }
    1124               0 :   if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
    1125                 :     PRInt32 errCode;
    1126               0 :     float inches = str.ToFloat(&errCode);
    1127               0 :     if (NS_SUCCEEDED(errCode)) {
    1128               0 :       aTwips = NS_INCHES_TO_INT_TWIPS(inches);
    1129                 :     } else {
    1130               0 :       aTwips = 0;
    1131                 :     }
    1132                 :   }
    1133               0 : }
    1134                 : 
    1135                 : void
    1136               0 : nsPrintOptions::WriteInchesFromTwipsPref(const char * aPrefId, PRInt32 aTwips)
    1137                 : {
    1138               0 :   double inches = NS_TWIPS_TO_INCHES(aTwips);
    1139               0 :   nsCAutoString inchesStr;
    1140               0 :   inchesStr.AppendFloat(inches);
    1141                 : 
    1142               0 :   Preferences::SetCString(aPrefId, inchesStr);
    1143               0 : }
    1144                 : 
    1145                 : void
    1146               0 : nsPrintOptions::ReadInchesIntToTwipsPref(const char * aPrefId, PRInt32& aTwips,
    1147                 :                                          const char * aMarginPref)
    1148                 : {
    1149                 :   PRInt32 value;
    1150               0 :   nsresult rv = Preferences::GetInt(aPrefId, &value);
    1151               0 :   if (NS_FAILED(rv)) {
    1152               0 :     rv = Preferences::GetInt(aMarginPref, &value);
    1153                 :   }
    1154               0 :   if (NS_SUCCEEDED(rv)) {
    1155               0 :     aTwips = NS_INCHES_TO_INT_TWIPS(float(value)/100.0f);
    1156                 :   } else {
    1157               0 :     aTwips = 0;
    1158                 :   }
    1159               0 : }
    1160                 : 
    1161                 : void
    1162               0 : nsPrintOptions::WriteInchesIntFromTwipsPref(const char * aPrefId, PRInt32 aTwips)
    1163                 : {
    1164                 :   Preferences::SetInt(aPrefId,
    1165               0 :                       PRInt32(NS_TWIPS_TO_INCHES(aTwips) * 100.0f + 0.5f));
    1166               0 : }
    1167                 : 
    1168                 : void
    1169               0 : nsPrintOptions::ReadJustification(const char * aPrefId, PRInt16& aJust,
    1170                 :                                   PRInt16 aInitValue)
    1171                 : {
    1172               0 :   aJust = aInitValue;
    1173               0 :   nsAutoString justStr;
    1174               0 :   if (NS_SUCCEEDED(Preferences::GetString(aPrefId, &justStr))) {
    1175               0 :     if (justStr.EqualsASCII(kJustRight)) {
    1176               0 :       aJust = nsIPrintSettings::kJustRight;
    1177               0 :     } else if (justStr.EqualsASCII(kJustCenter)) {
    1178               0 :       aJust = nsIPrintSettings::kJustCenter;
    1179                 :     } else {
    1180               0 :       aJust = nsIPrintSettings::kJustLeft;
    1181                 :     }
    1182                 :   }
    1183               0 : }
    1184                 : 
    1185                 : //---------------------------------------------------
    1186                 : void
    1187               0 : nsPrintOptions::WriteJustification(const char * aPrefId, PRInt16 aJust)
    1188                 : {
    1189               0 :   switch (aJust) {
    1190                 :     case nsIPrintSettings::kJustLeft:
    1191               0 :       Preferences::SetCString(aPrefId, kJustLeft);
    1192               0 :       break;
    1193                 : 
    1194                 :     case nsIPrintSettings::kJustCenter:
    1195               0 :       Preferences::SetCString(aPrefId, kJustCenter);
    1196               0 :       break;
    1197                 : 
    1198                 :     case nsIPrintSettings::kJustRight:
    1199               0 :       Preferences::SetCString(aPrefId, kJustRight);
    1200               0 :       break;
    1201                 :   } //switch
    1202               0 : }
    1203                 : 
    1204                 : //----------------------------------------------------------------------
    1205                 : // Testing of read/write prefs
    1206                 : // This define turns on the testing module below
    1207                 : // so at start up it writes and reads the prefs.
    1208                 : #ifdef DEBUG_rods_X
    1209                 : class Tester {
    1210                 :   public:
    1211                 :     Tester();
    1212                 : };
    1213                 : Tester::Tester()
    1214                 : {
    1215                 :   nsCOMPtr<nsIPrintSettings> ps;
    1216                 :   nsresult rv;
    1217                 :   nsCOMPtr<nsIPrintOptions> printService =
    1218                 :       do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
    1219                 :   if (NS_SUCCEEDED(rv)) {
    1220                 :     rv = printService->CreatePrintSettings(getter_AddRefs(ps));
    1221                 :   }
    1222                 : 
    1223                 :   if (ps) {
    1224                 :     ps->SetPrintOptions(nsIPrintSettings::kPrintOddPages,  true);
    1225                 :     ps->SetPrintOptions(nsIPrintSettings::kPrintEvenPages,  false);
    1226                 :     ps->SetMarginTop(1.0);
    1227                 :     ps->SetMarginLeft(1.0);
    1228                 :     ps->SetMarginBottom(1.0);
    1229                 :     ps->SetMarginRight(1.0);
    1230                 :     ps->SetScaling(0.5);
    1231                 :     ps->SetPrintBGColors(true);
    1232                 :     ps->SetPrintBGImages(true);
    1233                 :     ps->SetPrintRange(15);
    1234                 :     ps->SetHeaderStrLeft(NS_ConvertUTF8toUTF16("Left").get());
    1235                 :     ps->SetHeaderStrCenter(NS_ConvertUTF8toUTF16("Center").get());
    1236                 :     ps->SetHeaderStrRight(NS_ConvertUTF8toUTF16("Right").get());
    1237                 :     ps->SetFooterStrLeft(NS_ConvertUTF8toUTF16("Left").get());
    1238                 :     ps->SetFooterStrCenter(NS_ConvertUTF8toUTF16("Center").get());
    1239                 :     ps->SetFooterStrRight(NS_ConvertUTF8toUTF16("Right").get());
    1240                 :     ps->SetPaperName(NS_ConvertUTF8toUTF16("Paper Name").get());
    1241                 :     ps->SetPlexName(NS_ConvertUTF8toUTF16("Plex Name").get());
    1242                 :     ps->SetPaperSizeType(10);
    1243                 :     ps->SetPaperData(1);
    1244                 :     ps->SetPaperWidth(100.0);
    1245                 :     ps->SetPaperHeight(50.0);
    1246                 :     ps->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
    1247                 :     ps->SetPrintReversed(true);
    1248                 :     ps->SetPrintInColor(true);
    1249                 :     ps->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
    1250                 :     ps->SetPrintCommand(NS_ConvertUTF8toUTF16("Command").get());
    1251                 :     ps->SetNumCopies(2);
    1252                 :     ps->SetPrinterName(NS_ConvertUTF8toUTF16("Printer Name").get());
    1253                 :     ps->SetPrintToFile(true);
    1254                 :     ps->SetToFileName(NS_ConvertUTF8toUTF16("File Name").get());
    1255                 :     ps->SetPrintPageDelay(1000);
    1256                 :     ps->SetShrinkToFit(true);
    1257                 : 
    1258                 :     struct SettingsType {
    1259                 :       const char* mName;
    1260                 :       PRUint32    mFlag;
    1261                 :     };
    1262                 :     SettingsType gSettings[] = {
    1263                 :       {"OddEven", nsIPrintSettings::kInitSaveOddEvenPages},
    1264                 :       {kPrintHeaderStrLeft, nsIPrintSettings::kInitSaveHeaderLeft},
    1265                 :       {kPrintHeaderStrCenter, nsIPrintSettings::kInitSaveHeaderCenter},
    1266                 :       {kPrintHeaderStrRight, nsIPrintSettings::kInitSaveHeaderRight},
    1267                 :       {kPrintFooterStrLeft, nsIPrintSettings::kInitSaveFooterLeft},
    1268                 :       {kPrintFooterStrCenter, nsIPrintSettings::kInitSaveFooterCenter},
    1269                 :       {kPrintFooterStrRight, nsIPrintSettings::kInitSaveFooterRight},
    1270                 :       {kPrintBGColors, nsIPrintSettings::kInitSaveBGColors},
    1271                 :       {kPrintBGImages, nsIPrintSettings::kInitSaveBGImages},
    1272                 :       {kPrintShrinkToFit, nsIPrintSettings::kInitSaveShrinkToFit},
    1273                 :       {kPrintPaperSize, nsIPrintSettings::kInitSavePaperSize},
    1274                 :       {kPrintPlexName, nsIPrintSettings::kInitSavePlexName},
    1275                 :       {kPrintPaperData, nsIPrintSettings::kInitSavePaperData},
    1276                 :       {kPrintReversed, nsIPrintSettings::kInitSaveReversed},
    1277                 :       {kPrintInColor, nsIPrintSettings::kInitSaveInColor},
    1278                 :       {kPrintColorspace, nsIPrintSettings::kInitSaveColorspace},
    1279                 :       {kPrintResolutionName, nsIPrintSettings::kInitSaveResolutionName},
    1280                 :       {kPrintDownloadFonts, nsIPrintSettings::kInitSaveDownloadFonts},
    1281                 :       {kPrintOrientation, nsIPrintSettings::kInitSaveOrientation},
    1282                 :       {kPrintCommand, nsIPrintSettings::kInitSavePrintCommand},
    1283                 :       {kPrinterName, nsIPrintSettings::kInitSavePrinterName},
    1284                 :       {kPrintToFile, nsIPrintSettings::kInitSavePrintToFile},
    1285                 :       {kPrintToFileName, nsIPrintSettings::kInitSaveToFileName},
    1286                 :       {kPrintPageDelay, nsIPrintSettings::kInitSavePageDelay},
    1287                 :       {"Margins", nsIPrintSettings::kInitSaveMargins},
    1288                 :       {"All", nsIPrintSettings::kInitSaveAll},
    1289                 :       {nsnull, 0}};
    1290                 : 
    1291                 :       nsString prefix; prefix.AssignLiteral("Printer Name");
    1292                 :       PRInt32 i = 0;
    1293                 :       while (gSettings[i].mName != nsnull) {
    1294                 :         printf("------------------------------------------------\n");
    1295                 :         printf("%d) %s -> 0x%X\n", i, gSettings[i].mName, gSettings[i].mFlag);
    1296                 :         printService->SavePrintSettingsToPrefs(ps, true, gSettings[i].mFlag);
    1297                 :         printService->InitPrintSettingsFromPrefs(ps, true,
    1298                 :                                                  gSettings[i].mFlag);
    1299                 :         i++;
    1300                 :       }
    1301                 :   }
    1302                 : 
    1303                 : }
    1304                 : Tester gTester;
    1305                 : #endif

Generated by: LCOV version 1.7