2006-02-07 01:12:58 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2006-02-07 01:12:56 +00:00
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
2006-02-07 01:12:08 +00:00
|
|
|
*
|
2006-02-07 01:12:56 +00:00
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.1 (the "License"); you may not use this file except in
|
|
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/NPL/
|
2006-02-07 01:12:08 +00:00
|
|
|
*
|
2006-02-07 01:12:56 +00:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
2006-02-07 01:12:08 +00:00
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2006-02-07 01:12:56 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
2006-02-07 01:12:58 +00:00
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2000
|
2006-02-07 01:12:56 +00:00
|
|
|
* the Initial Developer. All Rights Reserved.
|
2006-02-07 01:12:08 +00:00
|
|
|
*
|
2006-02-07 01:12:56 +00:00
|
|
|
* Contributor(s):
|
2006-02-07 01:13:09 +00:00
|
|
|
* Jessica Blanco <jblanco@us.ibm.com>
|
2006-02-07 01:12:56 +00:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2006-02-07 01:12:08 +00:00
|
|
|
|
|
|
|
#include "nsPrintOptionsImpl.h"
|
2006-02-07 01:12:18 +00:00
|
|
|
#include "nsCoord.h"
|
|
|
|
#include "nsUnitConversion.h"
|
2006-02-07 01:13:00 +00:00
|
|
|
#include "nsReadableUtils.h"
|
2006-02-07 01:13:12 +00:00
|
|
|
#include "nsPrintSettingsImpl.h"
|
2006-02-07 01:12:08 +00:00
|
|
|
|
2006-02-07 01:13:25 +00:00
|
|
|
#include "nsIDOMWindow.h"
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsIDialogParamBlock.h"
|
2006-02-07 01:14:10 +00:00
|
|
|
#include "nsXPCOM.h"
|
2006-02-07 01:13:25 +00:00
|
|
|
#include "nsISupportsPrimitives.h"
|
|
|
|
#include "nsIWindowWatcher.h"
|
|
|
|
#include "nsIDOMWindowInternal.h"
|
|
|
|
#include "nsVoidArray.h"
|
|
|
|
#include "nsSupportsArray.h"
|
2006-02-07 01:14:28 +00:00
|
|
|
#include "prprf.h"
|
2006-02-07 01:13:25 +00:00
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
// For Prefs
|
2006-02-07 01:14:24 +00:00
|
|
|
#include "nsIPrefBranch.h"
|
|
|
|
#include "nsIPrefService.h"
|
2006-02-07 01:12:18 +00:00
|
|
|
#include "nsIServiceManager.h"
|
2006-02-07 01:12:08 +00:00
|
|
|
|
2006-02-07 01:13:09 +00:00
|
|
|
#include "nsISimpleEnumerator.h"
|
|
|
|
#include "nsISupportsPrimitives.h"
|
|
|
|
#include "nsGfxCIID.h"
|
|
|
|
|
|
|
|
static NS_DEFINE_IID(kCPrinterEnumerator, NS_PRINTER_ENUMERATOR_CID);
|
|
|
|
|
2006-02-07 01:13:56 +00:00
|
|
|
NS_IMPL_ISUPPORTS2(nsPrintOptions, nsIPrintOptions, nsIPrintSettingsService)
|
2006-02-07 01:12:08 +00:00
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
// Pref Constants
|
2006-02-07 01:13:37 +00:00
|
|
|
const char kMarginTop[] = "print_margin_top";
|
|
|
|
const char kMarginLeft[] = "print_margin_left";
|
|
|
|
const char kMarginBottom[] = "print_margin_bottom";
|
|
|
|
const char kMarginRight[] = "print_margin_right";
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:12:20 +00:00
|
|
|
// Prefs for Print Options
|
2006-02-07 01:13:37 +00:00
|
|
|
const char kPrintEvenPages[] = "print_evenpages";
|
|
|
|
const char kPrintOddPages[] = "print_oddpages";
|
|
|
|
const char kPrintHeaderStrLeft[] = "print_headerleft";
|
|
|
|
const char kPrintHeaderStrCenter[] = "print_headercenter";
|
|
|
|
const char kPrintHeaderStrRight[] = "print_headerright";
|
|
|
|
const char kPrintFooterStrLeft[] = "print_footerleft";
|
|
|
|
const char kPrintFooterStrCenter[] = "print_footercenter";
|
|
|
|
const char kPrintFooterStrRight[] = "print_footerright";
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:12:20 +00:00
|
|
|
// Additional Prefs
|
2006-02-07 01:13:37 +00:00
|
|
|
const char kPrintPaperSize[] = "print_paper_size"; // this has been deprecated
|
|
|
|
|
|
|
|
const char kPrintReversed[] = "print_reversed";
|
|
|
|
const char kPrintInColor[] = "print_in_color";
|
|
|
|
const char kPrintPaperName[] = "print_paper_name";
|
2006-02-07 01:14:39 +00:00
|
|
|
const char kPrintPlexName[] = "print_plex_name";
|
2006-02-07 01:13:37 +00:00
|
|
|
const char kPrintPaperSizeType[] = "print_paper_size_type";
|
|
|
|
const char kPrintPaperData[] = "print_paper_data";
|
|
|
|
const char kPrintPaperSizeUnit[] = "print_paper_size_unit";
|
|
|
|
const char kPrintPaperWidth[] = "print_paper_width";
|
|
|
|
const char kPrintPaperHeight[] = "print_paper_height";
|
|
|
|
const char kPrintOrientation[] = "print_orientation";
|
|
|
|
const char kPrintCommand[] = "print_command";
|
|
|
|
const char kPrinterName[] = "print_printer";
|
|
|
|
const char kPrintToFile[] = "print_to_file";
|
|
|
|
const char kPrintToFileName[] = "print_to_filename";
|
|
|
|
const char kPrintPageDelay[] = "print_pagedelay";
|
|
|
|
const char kPrintBGColors[] = "print_bgcolor";
|
|
|
|
const char kPrintBGImages[] = "print_bgimages";
|
|
|
|
|
|
|
|
const char kJustLeft[] = "left";
|
|
|
|
const char kJustCenter[] = "center";
|
|
|
|
const char kJustRight[] = "right";
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:13:38 +00:00
|
|
|
static NS_DEFINE_IID(kPrinterEnumeratorCID, NS_PRINTER_ENUMERATOR_CID);
|
|
|
|
|
2006-02-07 01:13:01 +00:00
|
|
|
nsFont* nsPrintOptions::sDefaultFont = nsnull;
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:12:08 +00:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 6/21/00 dwc
|
|
|
|
*/
|
2006-02-07 01:14:22 +00:00
|
|
|
nsPrintOptions::nsPrintOptions()
|
2006-02-07 01:12:08 +00:00
|
|
|
{
|
|
|
|
/* member initializers and constructor code */
|
2006-02-07 01:13:01 +00:00
|
|
|
if (sDefaultFont == nsnull) {
|
|
|
|
sDefaultFont = new nsFont("Times", NS_FONT_STYLE_NORMAL,NS_FONT_VARIANT_NORMAL,
|
2006-02-07 01:12:58 +00:00
|
|
|
NS_FONT_WEIGHT_NORMAL,0,NSIntPointsToTwips(10));
|
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIPrefService> prefService = do_GetService(NS_PREFSERVICE_CONTRACTID);
|
|
|
|
if (prefService) {
|
|
|
|
prefService->GetBranch("print.", getter_AddRefs(mPrefBranch));
|
|
|
|
}
|
2006-02-07 01:12:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 6/21/00 dwc
|
|
|
|
*/
|
|
|
|
nsPrintOptions::~nsPrintOptions()
|
|
|
|
{
|
2006-02-07 01:13:01 +00:00
|
|
|
if (sDefaultFont != nsnull) {
|
|
|
|
delete sDefaultFont;
|
|
|
|
sDefaultFont = nsnull;
|
2006-02-07 01:12:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:09 +00:00
|
|
|
|
2006-02-07 01:13:12 +00:00
|
|
|
//**************************************************************
|
|
|
|
//** PageList Enumerator
|
|
|
|
//**************************************************************
|
2006-02-07 01:13:09 +00:00
|
|
|
class
|
|
|
|
nsPrinterListEnumerator : public nsISimpleEnumerator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsPrinterListEnumerator();
|
|
|
|
virtual ~nsPrinterListEnumerator();
|
|
|
|
|
|
|
|
//nsISupports interface
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
//nsISimpleEnumerator interface
|
|
|
|
NS_DECL_NSISIMPLEENUMERATOR
|
|
|
|
|
2006-02-07 01:13:21 +00:00
|
|
|
NS_IMETHOD Init();
|
2006-02-07 01:13:09 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
PRUnichar **mPrinters;
|
|
|
|
PRUint32 mCount;
|
|
|
|
PRUint32 mIndex;
|
|
|
|
};
|
|
|
|
|
|
|
|
nsPrinterListEnumerator::nsPrinterListEnumerator() :
|
|
|
|
mPrinters(nsnull), mCount(0), mIndex(0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPrinterListEnumerator::~nsPrinterListEnumerator()
|
|
|
|
{
|
|
|
|
if (mPrinters) {
|
|
|
|
PRUint32 i;
|
|
|
|
for (i = 0; i < mCount; i++ ) {
|
|
|
|
nsMemory::Free(mPrinters[i]);
|
|
|
|
}
|
|
|
|
nsMemory::Free(mPrinters);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_ISUPPORTS1(nsPrinterListEnumerator, nsISimpleEnumerator)
|
|
|
|
|
2006-02-07 01:13:21 +00:00
|
|
|
NS_IMETHODIMP nsPrinterListEnumerator::Init()
|
2006-02-07 01:13:09 +00:00
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrinterEnumerator> printerEnumerator;
|
|
|
|
|
|
|
|
printerEnumerator = do_CreateInstance(kCPrinterEnumerator, &rv);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
2006-02-07 01:13:21 +00:00
|
|
|
return printerEnumerator->EnumeratePrinters(&mCount, &mPrinters);
|
2006-02-07 01:13:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPrinterListEnumerator::HasMoreElements(PRBool *result)
|
|
|
|
{
|
|
|
|
*result = (mIndex < mCount);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPrinterListEnumerator::GetNext(nsISupports **aPrinter)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrinter);
|
|
|
|
*aPrinter = nsnull;
|
|
|
|
if (mIndex >= mCount) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUnichar *printerName = mPrinters[mIndex++];
|
2006-02-07 01:14:06 +00:00
|
|
|
nsCOMPtr<nsISupportsString> printerNameWrapper;
|
2006-02-07 01:13:09 +00:00
|
|
|
nsresult rv;
|
|
|
|
|
2006-02-07 01:14:06 +00:00
|
|
|
rv = nsComponentManager::CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, nsnull,
|
|
|
|
NS_GET_IID(nsISupportsString), getter_AddRefs(printerNameWrapper));
|
2006-02-07 01:13:09 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_TRUE(printerNameWrapper, NS_ERROR_OUT_OF_MEMORY);
|
2006-02-07 01:14:09 +00:00
|
|
|
printerNameWrapper->SetData(nsDependentString(printerName));
|
2006-02-07 01:13:09 +00:00
|
|
|
*aPrinter = NS_STATIC_CAST(nsISupports*, printerNameWrapper);
|
|
|
|
NS_ADDREF(*aPrinter);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 1/12/01 rods
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2006-02-07 01:12:20 +00:00
|
|
|
nsPrintOptions::SetFontNamePointSize(nsString& aFontName, PRInt32 aPointSize)
|
2006-02-07 01:12:18 +00:00
|
|
|
{
|
2006-02-07 01:14:37 +00:00
|
|
|
if (sDefaultFont != nsnull && !aFontName.IsEmpty() && aPointSize > 0) {
|
2006-02-07 01:13:01 +00:00
|
|
|
sDefaultFont->name = aFontName;
|
|
|
|
sDefaultFont->size = NSIntPointsToTwips(aPointSize);
|
2006-02-07 01:12:18 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 1/12/01 rods
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2006-02-07 01:12:20 +00:00
|
|
|
nsPrintOptions::SetDefaultFont(nsFont &aFont)
|
2006-02-07 01:12:18 +00:00
|
|
|
{
|
2006-02-07 01:13:01 +00:00
|
|
|
if (sDefaultFont != nsnull) {
|
|
|
|
delete sDefaultFont;
|
2006-02-07 01:12:20 +00:00
|
|
|
}
|
2006-02-07 01:13:01 +00:00
|
|
|
sDefaultFont = new nsFont(aFont);
|
2006-02-07 01:12:18 +00:00
|
|
|
return NS_OK;
|
2006-02-07 01:12:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
2006-02-07 01:12:18 +00:00
|
|
|
* @update 1/12/01 rods
|
2006-02-07 01:12:08 +00:00
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2006-02-07 01:12:20 +00:00
|
|
|
nsPrintOptions::GetDefaultFont(nsFont &aFont)
|
2006-02-07 01:12:08 +00:00
|
|
|
{
|
2006-02-07 01:13:01 +00:00
|
|
|
aFont = *sDefaultFont;
|
2006-02-07 01:12:08 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 6/21/00 dwc
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
2006-02-07 01:13:25 +00:00
|
|
|
nsPrintOptions::ShowPrintSetupDialog(nsIPrintSettings *aPS)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPS, "Can't have a null PrintSettings!");
|
|
|
|
if (aPS == nsnull) return NS_OK;
|
|
|
|
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// create a nsISupportsArray of the parameters
|
|
|
|
// being passed to the window
|
|
|
|
nsCOMPtr<nsISupportsArray> array;
|
|
|
|
NS_NewISupportsArray(getter_AddRefs(array));
|
|
|
|
if (!array) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports> psSupports(do_QueryInterface(aPS));
|
|
|
|
NS_ASSERTION(psSupports, "PrintSettings must be a supports");
|
|
|
|
array->AppendElement(psSupports);
|
|
|
|
|
2006-02-07 01:14:08 +00:00
|
|
|
nsCOMPtr<nsIDialogParamBlock> ioParamBlock(do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID));
|
2006-02-07 01:13:25 +00:00
|
|
|
if (ioParamBlock) {
|
|
|
|
ioParamBlock->SetInt(0, 0);
|
|
|
|
nsCOMPtr<nsISupports> blkSupps(do_QueryInterface(ioParamBlock));
|
|
|
|
NS_ASSERTION(blkSupps, "IOBlk must be a supports");
|
|
|
|
|
|
|
|
array->AppendElement(blkSupps);
|
|
|
|
nsCOMPtr<nsISupports> arguments(do_QueryInterface(array));
|
|
|
|
NS_ASSERTION(array, "array must be a supports");
|
|
|
|
|
2006-02-07 01:14:07 +00:00
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
|
2006-02-07 01:13:25 +00:00
|
|
|
if (wwatch) {
|
|
|
|
nsCOMPtr<nsIDOMWindow> active;
|
|
|
|
wwatch->GetActiveWindow(getter_AddRefs(active)); nsCOMPtr<nsIDOMWindowInternal> parent = do_QueryInterface(active);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMWindow> newWindow;
|
2006-02-07 01:14:40 +00:00
|
|
|
rv = wwatch->OpenWindow(parent, "chrome://global/content/printPageSetup.xul",
|
2006-02-07 01:13:25 +00:00
|
|
|
"_blank", "chrome,modal,centerscreen", array,
|
|
|
|
getter_AddRefs(newWindow));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
|
2006-02-07 01:12:08 +00:00
|
|
|
}
|
2006-02-07 01:12:18 +00:00
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
2006-02-07 01:13:37 +00:00
|
|
|
* Helper function - Creates the "prefix" for the pref
|
|
|
|
* It is either "print."
|
|
|
|
* or "print.printer_<print name>."
|
2006-02-07 01:12:18 +00:00
|
|
|
*/
|
2006-02-07 01:13:37 +00:00
|
|
|
const char* nsPrintOptions::GetPrefName(const char * aPrefName,
|
|
|
|
const nsString& aPrinterName)
|
2006-02-07 01:12:18 +00:00
|
|
|
{
|
2006-02-07 01:13:37 +00:00
|
|
|
if (!aPrefName || !*aPrefName) {
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ERROR("Must have a valid pref name!");
|
2006-02-07 01:13:37 +00:00
|
|
|
return aPrefName;
|
2006-02-07 01:12:20 +00:00
|
|
|
}
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:14:35 +00:00
|
|
|
mPrefName.Truncate(); /* mPrefName = ""; */
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
if (aPrinterName.Length()) {
|
2006-02-07 01:14:35 +00:00
|
|
|
mPrefName.Append("printer_");
|
2006-02-07 01:14:25 +00:00
|
|
|
mPrefName.AppendWithConversion(aPrinterName);
|
2006-02-07 01:14:35 +00:00
|
|
|
mPrefName.Append(".");
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:25 +00:00
|
|
|
mPrefName += aPrefName;
|
2006-02-07 01:12:20 +00:00
|
|
|
|
2006-02-07 01:14:25 +00:00
|
|
|
return mPrefName.get();
|
2006-02-07 01:12:18 +00:00
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Testing of read/write prefs
|
|
|
|
// This define controls debug output
|
|
|
|
#ifdef DEBUG_rods_X
|
|
|
|
static void WriteDebugStr(const char* aArg1, const char* aArg2, const PRUnichar* aStr)
|
2006-02-07 01:13:36 +00:00
|
|
|
{
|
2006-02-07 01:13:37 +00:00
|
|
|
nsString str(aStr);
|
|
|
|
PRUnichar s = '&';
|
|
|
|
PRUnichar r = '_';
|
|
|
|
str.ReplaceChar(s, r);
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
printf("%s %s = %s \n", aArg1, aArg2, ToNewUTF8String(str));
|
2006-02-07 01:13:36 +00:00
|
|
|
}
|
2006-02-07 01:13:37 +00:00
|
|
|
const char* kWriteStr = "Write Pref:";
|
|
|
|
const char* kReadStr = "Read Pref:";
|
|
|
|
#define DUMP_STR(_a1, _a2, _a3) WriteDebugStr((_a1), GetPrefName((_a2), aPrefName), (_a3));
|
|
|
|
#define DUMP_BOOL(_a1, _a2, _a3) printf("%s %s = %s \n", (_a1), GetPrefName((_a2), aPrefName), (_a3)?"T":"F");
|
|
|
|
#define DUMP_INT(_a1, _a2, _a3) printf("%s %s = %d \n", (_a1), GetPrefName((_a2), aPrefName), (_a3));
|
|
|
|
#define DUMP_DBL(_a1, _a2, _a3) printf("%s %s = %10.5f \n", (_a1), GetPrefName((_a2), aPrefName), (_a3));
|
|
|
|
#else
|
|
|
|
#define DUMP_STR(_a1, _a2, _a3)
|
|
|
|
#define DUMP_BOOL(_a1, _a2, _a3)
|
|
|
|
#define DUMP_INT(_a1, _a2, _a3)
|
|
|
|
#define DUMP_DBL(_a1, _a2, _a3)
|
|
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* This will read in the generic prefs (not specific to a printer)
|
|
|
|
* or it will it can read the prefs in using the printer name to qualify
|
|
|
|
* It is either "print.attr_name"
|
|
|
|
* or "print.printer_HPLasr5.attr_name"
|
|
|
|
*
|
|
|
|
*/
|
2006-02-07 01:13:36 +00:00
|
|
|
nsresult
|
2006-02-07 01:13:37 +00:00
|
|
|
nsPrintOptions::ReadPrefs(nsIPrintSettings* aPS, const nsString& aPrefName, PRUint32 aFlags)
|
2006-02-07 01:13:36 +00:00
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveMargins) {
|
|
|
|
nscoord halfInch = NS_INCHES_TO_TWIPS(0.5);
|
|
|
|
nsMargin margin;
|
|
|
|
margin.SizeTo(halfInch, halfInch, halfInch, halfInch);
|
|
|
|
ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrefName), margin.top);
|
|
|
|
DUMP_INT(kReadStr, kMarginTop, margin.top);
|
|
|
|
ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrefName), margin.left);
|
|
|
|
DUMP_INT(kReadStr, kMarginLeft, margin.left);
|
|
|
|
ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrefName), margin.bottom);
|
|
|
|
DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
|
|
|
|
ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrefName), margin.right);
|
|
|
|
DUMP_INT(kReadStr, kMarginRight, margin.right);
|
|
|
|
aPS->SetMarginInTwips(margin);
|
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
PRBool b;
|
|
|
|
nsString str;
|
|
|
|
PRInt32 iVal;
|
|
|
|
double dbl;
|
|
|
|
|
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintEvenPages, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintEvenPages, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintOddPages, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintOddPages, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintHeaderStrLeft, aPrefName), str))) {
|
|
|
|
aPS->SetHeaderStrLeft(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintHeaderStrCenter, aPrefName), str))) {
|
|
|
|
aPS->SetHeaderStrCenter(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintHeaderStrRight, aPrefName), str))) {
|
|
|
|
aPS->SetHeaderStrRight(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintFooterStrLeft, aPrefName), str))) {
|
|
|
|
aPS->SetFooterStrLeft(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintFooterStrCenter, aPrefName), str))) {
|
|
|
|
aPS->SetFooterStrCenter(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:36 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintFooterStrRight, aPrefName), str))) {
|
|
|
|
aPS->SetFooterStrRight(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:12:32 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintBGColors, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintBGColors(b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintBGColors, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:12:32 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintBGImages, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintBGImages(b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintBGImages, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:01 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(kPrintPaperSize, aPrefName), &iVal))) { // this has been deprecated
|
|
|
|
aPS->SetPaperSize(iVal);
|
|
|
|
DUMP_INT(kReadStr, kPrintPaperSize, iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:12:32 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveReversed) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintReversed, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintReversed(b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintReversed, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveInColor) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintInColor, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintInColor(b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintInColor, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperName) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintPaperName, aPrefName), str))) {
|
|
|
|
aPS->SetPaperName(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintPaperName, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:35 +00:00
|
|
|
|
2006-02-07 01:14:39 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePlexName) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintPlexName, aPrefName), str))) {
|
|
|
|
aPS->SetPlexName(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintPlexName, str.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperSizeUnit) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(kPrintPaperSizeUnit, aPrefName), &iVal))) {
|
|
|
|
aPS->SetPaperSizeUnit(iVal);
|
|
|
|
DUMP_INT(kReadStr, kPrintPaperSizeUnit, iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperSizeType) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(kPrintPaperSizeType, aPrefName), &iVal))) {
|
|
|
|
aPS->SetPaperSizeType(iVal);
|
|
|
|
DUMP_INT(kReadStr, kPrintPaperSizeType, iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperData) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(kPrintPaperData, aPrefName), &iVal))) {
|
|
|
|
aPS->SetPaperData(iVal);
|
|
|
|
DUMP_INT(kReadStr, kPrintPaperData, iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperWidth) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefDouble(GetPrefName(kPrintPaperWidth, aPrefName), dbl))) {
|
|
|
|
aPS->SetPaperWidth(dbl);
|
|
|
|
DUMP_DBL(kReadStr, kPrintPaperWidth, dbl);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:37 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperHeight) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefDouble(GetPrefName(kPrintPaperHeight, aPrefName), dbl))) {
|
|
|
|
aPS->SetPaperHeight(dbl);
|
|
|
|
DUMP_DBL(kReadStr, kPrintPaperHeight, dbl);
|
2006-02-07 01:13:35 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(kPrintOrientation, aPrefName), &iVal))) {
|
|
|
|
aPS->SetOrientation(iVal);
|
|
|
|
DUMP_INT(kReadStr, kPrintOrientation, iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintCommand, aPrefName), str))) {
|
|
|
|
aPS->SetPrintCommand(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintCommand, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePrinterName) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrinterName, aPrefName), str))) {
|
|
|
|
aPS->SetPrinterName(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrinterName, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetBoolPref(GetPrefName(kPrintToFile, aPrefName), &b))) {
|
|
|
|
aPS->SetPrintToFile(b);
|
|
|
|
DUMP_BOOL(kReadStr, kPrintToFile, b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
|
|
|
|
if (NS_SUCCEEDED(ReadPrefString(GetPrefName(kPrintToFileName, aPrefName), str))) {
|
|
|
|
aPS->SetToFileName(str.get());
|
|
|
|
DUMP_STR(kReadStr, kPrintToFileName, str.get());
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(kPrintPageDelay, aPrefName), &iVal))) {
|
|
|
|
aPS->SetPrintPageDelay(iVal);
|
|
|
|
DUMP_INT(kReadStr, kPrintPageDelay, iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
// Not Reading In:
|
|
|
|
// Scaling
|
|
|
|
// ShrinkToFit
|
|
|
|
// Number of Copies
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
return NS_OK;
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 1/12/01 rods
|
|
|
|
*/
|
|
|
|
nsresult
|
|
|
|
nsPrintOptions::WritePrefs(nsIPrintSettings *aPS, const nsString& aPrefName, PRUint32 aFlags)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPS);
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
|
|
|
|
|
|
|
nsMargin margin;
|
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveMargins) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
|
|
|
|
WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrefName), margin.top);
|
|
|
|
DUMP_INT(kWriteStr, kMarginTop, margin.top);
|
|
|
|
WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrefName), margin.left);
|
|
|
|
DUMP_INT(kWriteStr, kMarginLeft, margin.top);
|
|
|
|
WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrefName), margin.bottom);
|
|
|
|
DUMP_INT(kWriteStr, kMarginBottom, margin.top);
|
|
|
|
WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrefName), margin.right);
|
|
|
|
DUMP_INT(kWriteStr, kMarginRight, margin.top);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
PRBool b;
|
|
|
|
PRUnichar* uStr;
|
|
|
|
PRInt32 iVal;
|
|
|
|
PRInt16 iVal16;
|
|
|
|
double dbl;
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages, &b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintEvenPages, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages, &b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintOddPages, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintOddPages, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintHeaderStrLeft, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintHeaderStrCenter, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetHeaderStrRight(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintHeaderStrRight, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetFooterStrLeft(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintFooterStrLeft, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetFooterStrCenter(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintFooterStrCenter, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetFooterStrRight(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintFooterStrRight, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintBGColors, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintBGColors, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintBGImages, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintBGImages, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperSize(&iVal))) {
|
|
|
|
DUMP_INT(kWriteStr, kPrintPaperSize, iVal);
|
|
|
|
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSize, aPrefName), iVal); // this has been deprecated
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveReversed) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintReversed, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintReversed, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:10 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveInColor) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintInColor, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintInColor, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperName) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperName(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintPaperName, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintPaperName, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:39 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePlexName) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPlexName(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintPlexName, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintPlexName, aPrefName));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperSizeUnit) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperSizeUnit(&iVal16))) {
|
|
|
|
DUMP_INT(kWriteStr, kPrintPaperSizeUnit, iVal16);
|
|
|
|
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSizeUnit, aPrefName), PRInt32(iVal16));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperSizeType) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperSizeType(&iVal16))) {
|
|
|
|
DUMP_INT(kWriteStr, kPrintPaperSizeType, iVal16);
|
|
|
|
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSizeType, aPrefName), PRInt32(iVal16));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperData) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
|
|
|
|
DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
|
|
|
|
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperData, aPrefName), PRInt32(iVal16));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperWidth) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperWidth(&dbl))) {
|
|
|
|
DUMP_DBL(kWriteStr, kPrintPaperWidth, dbl);
|
|
|
|
WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrefName), dbl);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePaperHeight) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPaperHeight(&dbl))) {
|
|
|
|
DUMP_DBL(kWriteStr, kPrintPaperHeight, dbl);
|
|
|
|
WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrefName), dbl);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
|
|
|
|
DUMP_INT(kWriteStr, kPrintOrientation, iVal);
|
|
|
|
mPrefBranch->SetIntPref(GetPrefName(kPrintOrientation, aPrefName), iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintCommand(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintCommand, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintCommand, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePrinterName) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrinterName(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrinterName, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrinterName, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
|
|
|
|
DUMP_BOOL(kWriteStr, kPrintToFile, b);
|
|
|
|
mPrefBranch->SetBoolPref(GetPrefName(kPrintToFile, aPrefName), b);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetToFileName(&uStr))) {
|
|
|
|
DUMP_STR(kWriteStr, kPrintToFileName, uStr);
|
|
|
|
WritePrefString(uStr, GetPrefName(kPrintToFileName, aPrefName));
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
|
|
|
|
if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
|
|
|
|
DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
|
|
|
|
mPrefBranch->SetIntPref(GetPrefName(kPrintPageDelay, aPrefName), iVal);
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
// Not Writing Out:
|
|
|
|
// Scaling
|
|
|
|
// ShrinkToFit
|
|
|
|
// Number of Copies
|
|
|
|
|
|
|
|
return NS_OK;
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
/* create and return a new |nsPrinterListEnumerator| */
|
|
|
|
NS_IMETHODIMP nsPrintOptions::AvailablePrinters(nsISimpleEnumerator **aPrinterEnumerator)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrinterEnumerator);
|
|
|
|
*aPrinterEnumerator = nsnull;
|
2006-02-07 01:13:35 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
nsCOMPtr<nsPrinterListEnumerator> printerListEnum = new nsPrinterListEnumerator();
|
|
|
|
NS_ENSURE_TRUE(printerListEnum.get(), NS_ERROR_OUT_OF_MEMORY);
|
2006-02-07 01:13:35 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
nsresult rv = printerListEnum->Init();
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
*aPrinterEnumerator = NS_STATIC_CAST(nsISimpleEnumerator*, printerListEnum);
|
|
|
|
NS_ADDREF(*aPrinterEnumerator);
|
|
|
|
}
|
2006-02-07 01:14:34 +00:00
|
|
|
return rv;
|
2006-02-07 01:13:36 +00:00
|
|
|
}
|
2006-02-07 01:13:35 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
NS_IMETHODIMP nsPrintOptions::DisplayJobProperties( const PRUnichar *aPrinter, nsIPrintSettings* aPrintSettings, PRBool *aDisplayed)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG(aPrinter);
|
|
|
|
*aDisplayed = PR_FALSE;
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrinterEnumerator> propDlg;
|
|
|
|
|
|
|
|
propDlg = do_CreateInstance(kCPrinterEnumerator, &rv);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
if (NS_FAILED(propDlg->DisplayPropertiesDlg((PRUnichar*)aPrinter, aPrintSettings)))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
*aDisplayed = PR_TRUE;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2006-02-07 01:13:05 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
/* [noscript] voidPtr GetNativeData (in short aDataType); */
|
|
|
|
NS_IMETHODIMP nsPrintOptions::GetNativeData(PRInt16 aDataType, void * *_retval)
|
2006-02-07 01:13:36 +00:00
|
|
|
{
|
2006-02-07 01:13:37 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(_retval);
|
|
|
|
*_retval = nsnull;
|
|
|
|
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
2006-02-07 01:13:12 +00:00
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:05 +00:00
|
|
|
nsresult nsPrintOptions::_CreatePrintSettings(nsIPrintSettings **_retval)
|
2006-02-07 01:13:12 +00:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsPrintSettings* printSettings = new nsPrintSettings(); // does not initially ref count
|
|
|
|
NS_ASSERTION(printSettings, "Can't be NULL!");
|
|
|
|
|
|
|
|
rv = printSettings->QueryInterface(NS_GET_IID(nsIPrintSettings), (void**)_retval); // ref counts
|
|
|
|
if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
InitPrintSettingsFromPrefs(*_retval, PR_FALSE, nsIPrintSettings::kInitSaveAll); // ignore return value
|
2006-02-07 01:13:12 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:05 +00:00
|
|
|
/* nsIPrintSettings CreatePrintSettings (); */
|
|
|
|
NS_IMETHODIMP nsPrintOptions::CreatePrintSettings(nsIPrintSettings **_retval)
|
|
|
|
{
|
|
|
|
return _CreatePrintSettings(_retval);
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:56 +00:00
|
|
|
//-----------------------------------------------------
|
|
|
|
//-----------------------------------------------------
|
|
|
|
//-- nsIPrintSettingsService
|
|
|
|
//-----------------------------------------------------
|
|
|
|
//-----------------------------------------------------
|
2006-02-07 01:13:23 +00:00
|
|
|
/* readonly attribute nsIPrintSettings globalPrintSettings; */
|
|
|
|
NS_IMETHODIMP nsPrintOptions::GetGlobalPrintSettings(nsIPrintSettings * *aGlobalPrintSettings)
|
|
|
|
{
|
|
|
|
if (!mGlobalPrintSettings) {
|
|
|
|
CreatePrintSettings(getter_AddRefs(mGlobalPrintSettings));
|
|
|
|
NS_ASSERTION(mGlobalPrintSettings, "Can't be NULL!");
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this still NULL, we have some very big problems going on
|
|
|
|
if (!mGlobalPrintSettings) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aGlobalPrintSettings = mGlobalPrintSettings.get();
|
|
|
|
NS_ADDREF(*aGlobalPrintSettings);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:56 +00:00
|
|
|
/* readonly attribute nsIPrintSettings newPrintSettings; */
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintOptions::GetNewPrintSettings(nsIPrintSettings * *aNewPrintSettings)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNewPrintSettings);
|
2006-02-07 01:14:20 +00:00
|
|
|
return CreatePrintSettings(aNewPrintSettings);
|
2006-02-07 01:13:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintOptions::GetDefaultPrinterName(PRUnichar * *aDefaultPrinterName)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDefaultPrinterName);
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrinterEnumerator> prtEnum = do_GetService(kPrinterEnumeratorCID, &rv);
|
|
|
|
if (prtEnum) {
|
|
|
|
rv = prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintOptions::InitPrintSettingsFromPrinter(const PRUnichar *aPrinterName, nsIPrintSettings *aPrintSettings)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPrintSettings);
|
2006-02-07 01:14:20 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aPrinterName);
|
2006-02-07 01:13:56 +00:00
|
|
|
|
2006-02-07 01:14:23 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
nsXPIDLString printerName;
|
|
|
|
aPrintSettings->GetPrinterName(getter_Copies(printerName));
|
|
|
|
if (!printerName.Equals(aPrinterName)) {
|
|
|
|
NS_WARNING("Printer names should match!");
|
2006-02-07 01:13:56 +00:00
|
|
|
}
|
2006-02-07 01:14:23 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
PRBool isInitialized;
|
|
|
|
aPrintSettings->GetIsInitializedFromPrinter(&isInitialized);
|
|
|
|
if (!isInitialized) {
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIPrinterEnumerator> prtEnum = do_GetService(kPrinterEnumeratorCID, &rv);
|
|
|
|
if (prtEnum) {
|
|
|
|
rv = prtEnum->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
aPrintSettings->SetIsInitializedFromPrinter(PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
2006-02-07 01:13:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Helper function - Returns either the name or sets the length to zero
|
|
|
|
*/
|
|
|
|
static void GetAdjustedPrinterName(nsIPrintSettings* aPS, PRBool aUsePNP, nsString& aPrinterName)
|
|
|
|
{
|
|
|
|
aPrinterName.SetLength(0);
|
|
|
|
|
2006-02-07 01:14:23 +00:00
|
|
|
// Get the Printer Name from the PrintSettings
|
2006-02-07 01:13:56 +00:00
|
|
|
// to use as a prefix for Pref Names
|
|
|
|
PRUnichar* prtName = nsnull;
|
|
|
|
if (aUsePNP && NS_SUCCEEDED(aPS->GetPrinterName(&prtName))) {
|
|
|
|
if (prtName && !*prtName) {
|
|
|
|
nsMemory::Free(prtName);
|
|
|
|
prtName = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prtName) {
|
|
|
|
aPrinterName = prtName;
|
|
|
|
PRUnichar uc = '_';
|
|
|
|
const char* replaceStr = " \n\r";
|
|
|
|
for (PRInt32 i=0;i<(PRInt32)strlen(replaceStr);i++) {
|
|
|
|
PRUnichar uChar = replaceStr[i];
|
|
|
|
aPrinterName.ReplaceChar(uChar, uc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:00 +00:00
|
|
|
/* PRInt32 getPrinterPrefInt (in nsIPrintSettings aPrintSettings, in wstring aPrefName); */
|
|
|
|
NS_IMETHODIMP nsPrintOptions::GetPrinterPrefInt(nsIPrintSettings *aPrintSettings, const PRUnichar *aPrefName, PRInt32 *_retval)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
|
|
|
|
2006-02-07 01:14:00 +00:00
|
|
|
nsString prtName;
|
|
|
|
// Get the Printer Name from the PtinerSettings
|
|
|
|
// to use as a prefix for Pref Names
|
|
|
|
GetAdjustedPrinterName(aPrintSettings, PR_TRUE, prtName);
|
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
PRInt32 iVal;
|
|
|
|
if (NS_SUCCEEDED(mPrefBranch->GetIntPref(GetPrefName(NS_LossyConvertUCS2toASCII(aPrefName).get(), prtName), &iVal))) {
|
|
|
|
*_retval = iVal;
|
|
|
|
return NS_OK;
|
2006-02-07 01:14:00 +00:00
|
|
|
}
|
2006-02-07 01:14:24 +00:00
|
|
|
|
2006-02-07 01:14:00 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:56 +00:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* See documentation in nsPrintOptionsImpl.h
|
|
|
|
* @update 1/12/01 rods
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPrintOptions::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS, PRBool aUsePNP, PRUint32 aFlags)
|
|
|
|
{
|
2006-02-07 01:14:23 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aPS);
|
2006-02-07 01:13:56 +00:00
|
|
|
|
2006-02-07 01:14:23 +00:00
|
|
|
PRBool isInitialized;
|
|
|
|
aPS->GetIsInitializedFromPrefs(&isInitialized);
|
|
|
|
if (!isInitialized) {
|
|
|
|
nsString prtName;
|
|
|
|
// read any non printer specific prefs
|
|
|
|
// with empty printer name
|
|
|
|
nsresult rv = ReadPrefs(aPS, prtName, aFlags);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// Get the Printer Name from the PrintSettings
|
|
|
|
// to use as a prefix for Pref Names
|
|
|
|
GetAdjustedPrinterName(aPS, aUsePNP, prtName);
|
|
|
|
if (prtName.Length()) {
|
|
|
|
// Now read any printer specific prefs
|
|
|
|
rv = ReadPrefs(aPS, prtName, aFlags);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
aPS->SetIsInitializedFromPrefs(PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
2006-02-07 01:13:56 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** ---------------------------------------------------
|
|
|
|
* This will asve into prefs most all the PrintSettings either generically (not specified printer)
|
|
|
|
* or to a specific printer.
|
|
|
|
*/
|
|
|
|
nsresult
|
|
|
|
nsPrintOptions::SavePrintSettingsToPrefs(nsIPrintSettings *aPS, PRBool aUsePrinterNamePrefix, PRUint32 aFlags)
|
|
|
|
{
|
|
|
|
nsString prtName;
|
|
|
|
// Get the Printer Name from the PtinerSettings
|
|
|
|
// to use as a prefix for Pref Names
|
|
|
|
GetAdjustedPrinterName(aPS, aUsePrinterNamePrefix, prtName);
|
|
|
|
|
|
|
|
// Now write any printer specific prefs
|
|
|
|
return WritePrefs(aPS, prtName, aFlags);
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:12 +00:00
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
//-----------------------------------------------------
|
|
|
|
//-- Protected Methods
|
|
|
|
//-----------------------------------------------------
|
2006-02-07 01:12:20 +00:00
|
|
|
//---------------------------------------------------
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult nsPrintOptions::ReadPrefString(const char * aPrefId,
|
2006-02-07 01:12:20 +00:00
|
|
|
nsString& aString)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
2006-02-07 01:12:20 +00:00
|
|
|
char * str = nsnull;
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult rv = mPrefBranch->GetCharPref(aPrefId, &str);
|
2006-02-07 01:12:20 +00:00
|
|
|
if (NS_SUCCEEDED(rv) && str) {
|
2006-02-07 01:14:41 +00:00
|
|
|
CopyUTF8toUTF16(str, aString);
|
2006-02-07 01:12:20 +00:00
|
|
|
nsMemory::Free(str);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
/** ---------------------------------------------------
|
|
|
|
* Write PRUnichar* to Prefs and deletes the contents of the string
|
|
|
|
*/
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult nsPrintOptions::WritePrefString(PRUnichar*& aStr, const char* aPrefId)
|
2006-02-07 01:13:37 +00:00
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
2006-02-07 01:13:37 +00:00
|
|
|
if (!aStr) return NS_ERROR_FAILURE;
|
|
|
|
|
2006-02-07 01:14:41 +00:00
|
|
|
nsresult rv = mPrefBranch->SetCharPref(aPrefId,
|
|
|
|
NS_ConvertUTF16toUTF8(aStr).get());
|
|
|
|
nsMemory::Free(aStr);
|
|
|
|
aStr = nsnull;
|
2006-02-07 01:13:37 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult nsPrintOptions::WritePrefString(const char * aPrefId,
|
2006-02-07 01:12:20 +00:00
|
|
|
nsString& aString)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
2006-02-07 01:12:20 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aPrefId);
|
|
|
|
|
2006-02-07 01:14:41 +00:00
|
|
|
return mPrefBranch->SetCharPref(aPrefId,
|
|
|
|
NS_ConvertUTF16toUTF8(aString).get());
|
2006-02-07 01:12:20 +00:00
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult nsPrintOptions::ReadPrefDouble(const char * aPrefId,
|
2006-02-07 01:13:12 +00:00
|
|
|
double& aVal)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
2006-02-07 01:13:12 +00:00
|
|
|
char * str = nsnull;
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult rv = mPrefBranch->GetCharPref(aPrefId, &str);
|
2006-02-07 01:13:12 +00:00
|
|
|
if (NS_SUCCEEDED(rv) && str) {
|
2006-02-07 01:13:37 +00:00
|
|
|
float f;
|
2006-02-07 01:14:28 +00:00
|
|
|
PR_sscanf(str, "%f", &f);
|
2006-02-07 01:13:37 +00:00
|
|
|
aVal = double(f);
|
2006-02-07 01:13:12 +00:00
|
|
|
nsMemory::Free(str);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult nsPrintOptions::WritePrefDouble(const char * aPrefId,
|
2006-02-07 01:13:12 +00:00
|
|
|
double aVal)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
NS_ENSURE_STATE(mPrefBranch);
|
2006-02-07 01:13:12 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aPrefId);
|
|
|
|
|
|
|
|
char str[64];
|
|
|
|
sprintf(str, "%6.2f", aVal);
|
2006-02-07 01:14:24 +00:00
|
|
|
return mPrefBranch->SetCharPref(aPrefId, str);
|
2006-02-07 01:13:12 +00:00
|
|
|
}
|
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
//---------------------------------------------------
|
2006-02-07 01:14:24 +00:00
|
|
|
void nsPrintOptions::ReadInchesToTwipsPref(const char * aPrefId,
|
2006-02-07 01:12:18 +00:00
|
|
|
nscoord& aTwips)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
if (!mPrefBranch) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
char * str = nsnull;
|
2006-02-07 01:14:24 +00:00
|
|
|
nsresult rv = mPrefBranch->GetCharPref(aPrefId, &str);
|
2006-02-07 01:12:18 +00:00
|
|
|
if (NS_SUCCEEDED(rv) && str) {
|
|
|
|
nsAutoString justStr;
|
|
|
|
justStr.AssignWithConversion(str);
|
|
|
|
PRInt32 errCode;
|
|
|
|
float inches = justStr.ToFloat(&errCode);
|
|
|
|
if (NS_SUCCEEDED(errCode)) {
|
|
|
|
aTwips = NS_INCHES_TO_TWIPS(inches);
|
|
|
|
} else {
|
|
|
|
aTwips = 0;
|
|
|
|
}
|
|
|
|
nsMemory::Free(str);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------
|
2006-02-07 01:14:24 +00:00
|
|
|
void nsPrintOptions::WriteInchesFromTwipsPref(const char * aPrefId,
|
2006-02-07 01:12:18 +00:00
|
|
|
nscoord aTwips)
|
|
|
|
{
|
2006-02-07 01:14:24 +00:00
|
|
|
if (!mPrefBranch) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:12:18 +00:00
|
|
|
double inches = NS_TWIPS_TO_INCHES(aTwips);
|
|
|
|
nsAutoString inchesStr;
|
|
|
|
inchesStr.AppendFloat(inches);
|
2006-02-07 01:13:00 +00:00
|
|
|
char * str = ToNewCString(inchesStr);
|
2006-02-07 01:12:18 +00:00
|
|
|
if (str) {
|
2006-02-07 01:14:24 +00:00
|
|
|
mPrefBranch->SetCharPref(aPrefId, str);
|
2006-02-07 01:12:18 +00:00
|
|
|
} else {
|
2006-02-07 01:14:24 +00:00
|
|
|
mPrefBranch->SetCharPref(aPrefId, "0.5");
|
2006-02-07 01:12:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
//---------------------------------------------------
|
2006-02-07 01:14:24 +00:00
|
|
|
void nsPrintOptions::ReadJustification(const char * aPrefId,
|
2006-02-07 01:12:20 +00:00
|
|
|
PRInt16& aJust,
|
|
|
|
PRInt16 aInitValue)
|
2006-02-07 01:12:18 +00:00
|
|
|
{
|
|
|
|
aJust = aInitValue;
|
2006-02-07 01:12:20 +00:00
|
|
|
nsAutoString justStr;
|
2006-02-07 01:14:24 +00:00
|
|
|
if (NS_SUCCEEDED(ReadPrefString(aPrefId, justStr))) {
|
2006-02-07 01:13:37 +00:00
|
|
|
if (justStr.EqualsWithConversion(kJustRight)) {
|
|
|
|
aJust = nsIPrintSettings::kJustRight;
|
2006-02-07 01:12:18 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
} else if (justStr.EqualsWithConversion(kJustCenter)) {
|
|
|
|
aJust = nsIPrintSettings::kJustCenter;
|
2006-02-07 01:12:18 +00:00
|
|
|
|
|
|
|
} else {
|
2006-02-07 01:13:37 +00:00
|
|
|
aJust = nsIPrintSettings::kJustLeft;
|
2006-02-07 01:12:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------
|
2006-02-07 01:14:24 +00:00
|
|
|
void nsPrintOptions::WriteJustification(const char * aPrefId,
|
2006-02-07 01:12:20 +00:00
|
|
|
PRInt16 aJust)
|
2006-02-07 01:12:18 +00:00
|
|
|
{
|
|
|
|
switch (aJust) {
|
2006-02-07 01:13:37 +00:00
|
|
|
case nsIPrintSettings::kJustLeft:
|
2006-02-07 01:14:24 +00:00
|
|
|
mPrefBranch->SetCharPref(aPrefId, kJustLeft);
|
2006-02-07 01:12:18 +00:00
|
|
|
break;
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
case nsIPrintSettings::kJustCenter:
|
2006-02-07 01:14:24 +00:00
|
|
|
mPrefBranch->SetCharPref(aPrefId, kJustCenter);
|
2006-02-07 01:12:18 +00:00
|
|
|
break;
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
case nsIPrintSettings::kJustRight:
|
2006-02-07 01:14:24 +00:00
|
|
|
mPrefBranch->SetCharPref(aPrefId, kJustRight);
|
2006-02-07 01:12:18 +00:00
|
|
|
break;
|
|
|
|
} //switch
|
|
|
|
}
|
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Testing of read/write prefs
|
|
|
|
// This define turns on the testing module below
|
|
|
|
// so at start up it writes and reads the prefs.
|
|
|
|
#ifdef DEBUG_rods_X
|
|
|
|
class Tester {
|
|
|
|
public:
|
|
|
|
Tester();
|
|
|
|
};
|
|
|
|
Tester::Tester()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPrintSettings> ps;
|
|
|
|
nsresult rv;
|
2006-02-07 01:13:58 +00:00
|
|
|
nsCOMPtr<nsIPrintOptions> printService = do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
|
2006-02-07 01:13:37 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = printService->CreatePrintSettings(getter_AddRefs(ps));
|
|
|
|
}
|
2006-02-07 01:12:20 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
if (ps) {
|
|
|
|
ps->SetPrintOptions(nsIPrintSettings::kPrintOddPages, PR_TRUE);
|
|
|
|
ps->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, PR_FALSE);
|
|
|
|
ps->SetMarginTop(1.0);
|
|
|
|
ps->SetMarginLeft(1.0);
|
|
|
|
ps->SetMarginBottom(1.0);
|
|
|
|
ps->SetMarginRight(1.0);
|
|
|
|
ps->SetScaling(0.5);
|
|
|
|
ps->SetPrintBGColors(PR_TRUE);
|
|
|
|
ps->SetPrintBGImages(PR_TRUE);
|
|
|
|
ps->SetPrintRange(15);
|
|
|
|
ps->SetHeaderStrLeft(NS_ConvertUTF8toUCS2("Left").get());
|
|
|
|
ps->SetHeaderStrCenter(NS_ConvertUTF8toUCS2("Center").get());
|
|
|
|
ps->SetHeaderStrRight(NS_ConvertUTF8toUCS2("Right").get());
|
|
|
|
ps->SetFooterStrLeft(NS_ConvertUTF8toUCS2("Left").get());
|
|
|
|
ps->SetFooterStrCenter(NS_ConvertUTF8toUCS2("Center").get());
|
|
|
|
ps->SetFooterStrRight(NS_ConvertUTF8toUCS2("Right").get());
|
|
|
|
ps->SetPaperName(NS_ConvertUTF8toUCS2("Paper Name").get());
|
2006-02-07 01:14:39 +00:00
|
|
|
ps->SetPlexName(NS_ConvertUTF8toUCS2("Plex Name").get());
|
2006-02-07 01:13:37 +00:00
|
|
|
ps->SetPaperSizeType(10);
|
|
|
|
ps->SetPaperData(1);
|
|
|
|
ps->SetPaperWidth(100.0);
|
|
|
|
ps->SetPaperHeight(50.0);
|
|
|
|
ps->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
|
|
|
|
ps->SetPrintReversed(PR_TRUE);
|
|
|
|
ps->SetPrintInColor(PR_TRUE);
|
|
|
|
ps->SetPaperSize(5);
|
|
|
|
ps->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
|
|
|
|
ps->SetPrintCommand(NS_ConvertUTF8toUCS2("Command").get());
|
|
|
|
ps->SetNumCopies(2);
|
|
|
|
ps->SetPrinterName(NS_ConvertUTF8toUCS2("Printer Name").get());
|
|
|
|
ps->SetPrintToFile(PR_TRUE);
|
|
|
|
ps->SetToFileName(NS_ConvertUTF8toUCS2("File Name").get());
|
|
|
|
ps->SetPrintPageDelay(1000);
|
|
|
|
|
|
|
|
struct SettingsType {
|
|
|
|
const char* mName;
|
|
|
|
PRUint32 mFlag;
|
|
|
|
};
|
|
|
|
SettingsType gSettings[] = {
|
|
|
|
{"OddEven", nsIPrintSettings::kInitSaveOddEvenPages},
|
|
|
|
{kPrintHeaderStrLeft, nsIPrintSettings::kInitSaveHeaderLeft},
|
|
|
|
{kPrintHeaderStrCenter, nsIPrintSettings::kInitSaveHeaderCenter},
|
|
|
|
{kPrintHeaderStrRight, nsIPrintSettings::kInitSaveHeaderRight},
|
|
|
|
{kPrintFooterStrLeft, nsIPrintSettings::kInitSaveFooterLeft},
|
|
|
|
{kPrintFooterStrCenter, nsIPrintSettings::kInitSaveFooterCenter},
|
|
|
|
{kPrintFooterStrRight, nsIPrintSettings::kInitSaveFooterRight},
|
|
|
|
{kPrintBGColors, nsIPrintSettings::kInitSaveBGColors},
|
|
|
|
{kPrintBGImages, nsIPrintSettings::kInitSaveBGImages},
|
|
|
|
{kPrintPaperSize, nsIPrintSettings::kInitSavePaperSize},
|
|
|
|
{kPrintPaperName, nsIPrintSettings::kInitSavePaperName},
|
2006-02-07 01:14:39 +00:00
|
|
|
{kPrintPlexName, nsIPrintSettings::kInitSavePlexName},
|
2006-02-07 01:13:37 +00:00
|
|
|
{kPrintPaperSizeUnit, nsIPrintSettings::kInitSavePaperSizeUnit},
|
|
|
|
{kPrintPaperSizeType, nsIPrintSettings::kInitSavePaperSizeType},
|
|
|
|
{kPrintPaperData, nsIPrintSettings::kInitSavePaperData},
|
|
|
|
{kPrintPaperWidth, nsIPrintSettings::kInitSavePaperWidth},
|
|
|
|
{kPrintPaperHeight, nsIPrintSettings::kInitSavePaperHeight},
|
|
|
|
{kPrintReversed, nsIPrintSettings::kInitSaveReversed},
|
|
|
|
{kPrintInColor, nsIPrintSettings::kInitSaveInColor},
|
|
|
|
{kPrintOrientation, nsIPrintSettings::kInitSaveOrientation},
|
|
|
|
{kPrintCommand, nsIPrintSettings::kInitSavePrintCommand},
|
|
|
|
{kPrinterName, nsIPrintSettings::kInitSavePrinterName},
|
|
|
|
{kPrintToFile, nsIPrintSettings::kInitSavePrintToFile},
|
|
|
|
{kPrintToFileName, nsIPrintSettings::kInitSaveToFileName},
|
|
|
|
{kPrintPageDelay, nsIPrintSettings::kInitSavePageDelay},
|
|
|
|
{"Margins", nsIPrintSettings::kInitSaveMargins},
|
|
|
|
{"All", nsIPrintSettings::kInitSaveAll},
|
|
|
|
{nsnull, 0}};
|
|
|
|
|
|
|
|
nsString prefix; prefix.AssignWithConversion("Printer Name");
|
|
|
|
PRInt32 i = 0;
|
|
|
|
while (gSettings[i].mName != nsnull) {
|
|
|
|
printf("------------------------------------------------\n");
|
|
|
|
printf("%d) %s -> 0x%X\n", i, gSettings[i].mName, gSettings[i].mFlag);
|
|
|
|
printService->SavePrintSettingsToPrefs(ps, PR_TRUE, gSettings[i].mFlag);
|
|
|
|
printService->InitPrintSettingsFromPrefs(ps, PR_TRUE, gSettings[i].mFlag);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
2006-02-07 01:12:20 +00:00
|
|
|
|
2006-02-07 01:13:37 +00:00
|
|
|
}
|
|
|
|
Tester gTester;
|
|
|
|
#endif
|