2001-09-28 20:14:13 +00:00
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version : NPL 1.1 / GPL 2.0 / LGPL 2.1
2001-03-22 23:34:41 +00:00
*
2001-09-28 20:14:13 +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/
2001-03-22 23:34:41 +00:00
*
2001-09-28 20:14:13 +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 .
2001-03-22 23:34:41 +00:00
*
* The Original Code is Mozilla Communicator client code .
*
2001-09-28 20:14:13 +00:00
* The Initial Developer of the Original Code is
* Netscape Communications Corporation .
* Portions created by the Initial Developer are Copyright ( C ) 1998
* the Initial Developer . All Rights Reserved .
2001-03-22 23:34:41 +00:00
*
* Contributor ( s ) :
* Alec Flett < alecf @ netscape . com >
* Brian Nesse < bnesse @ netscape . com >
2001-09-28 20:14:13 +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 * * * * * */
2001-03-22 23:34:41 +00:00
# include "nsPrefBranch.h"
# include "nsILocalFile.h"
# include "nsIObserverService.h"
# include "nsISupportsPrimitives.h"
2002-04-09 14:18:39 +00:00
# include "nsIDirectoryService.h"
2001-03-22 23:34:41 +00:00
# include "nsString.h"
2001-09-29 08:28:41 +00:00
# include "nsReadableUtils.h"
2001-03-22 23:34:41 +00:00
# include "nsXPIDLString.h"
2001-09-06 19:30:47 +00:00
# include "nsScriptSecurityManager.h"
2001-04-20 06:45:56 +00:00
# include "nsIStringBundle.h"
2001-09-06 19:30:47 +00:00
# include "prefapi.h"
2001-04-24 20:32:16 +00:00
# include "prmem.h"
2001-12-04 01:52:44 +00:00
# include "pldhash.h"
2001-03-22 23:34:41 +00:00
# include "nsIFileSpec.h" // this should be removed eventually
# include "prefapi_private_data.h"
// Definitions
struct EnumerateData {
2001-04-11 23:07:03 +00:00
const char * parent ;
nsVoidArray * pref_list ;
} ;
struct PrefCallbackData {
nsIPrefBranch * pBranch ;
2001-10-22 20:54:48 +00:00
nsISupports * pObserver ;
PRBool bIsWeakRef ;
2001-03-22 23:34:41 +00:00
} ;
2001-04-11 23:07:03 +00:00
static NS_DEFINE_CID ( kSecurityManagerCID , NS_SCRIPTSECURITYMANAGER_CID ) ;
2001-03-22 23:34:41 +00:00
// Prototypes
2001-11-30 18:42:41 +00:00
extern PrefResult pref_UnlockPref ( const char * key ) ;
2001-12-04 01:52:44 +00:00
PR_STATIC_CALLBACK ( PLDHashOperator )
pref_enumChild ( PLDHashTable * table , PLDHashEntryHdr * heh ,
PRUint32 i , void * arg ) ;
2001-03-22 23:34:41 +00:00
static int PR_CALLBACK NotifyObserver ( const char * newpref , void * data ) ;
// this needs to be removed!
static nsresult _convertRes ( int res )
//---------------------------------------------------------------------------
{
switch ( res ) {
case PREF_OUT_OF_MEMORY :
return NS_ERROR_OUT_OF_MEMORY ;
case PREF_NOT_INITIALIZED :
return NS_ERROR_NOT_INITIALIZED ;
case PREF_BAD_PARAMETER :
return NS_ERROR_INVALID_ARG ;
case PREF_TYPE_CHANGE_ERR :
case PREF_ERROR :
case PREF_BAD_LOCKFILE :
case PREF_DEFAULT_VALUE_NOT_INITIALIZED :
return NS_ERROR_UNEXPECTED ;
case PREF_VALUECHANGED :
2001-10-08 19:52:17 +00:00
return NS_OK ;
2001-03-22 23:34:41 +00:00
}
NS_ASSERTION ( ( res > = PREF_DEFAULT_VALUE_NOT_INITIALIZED ) & & ( res < = PREF_PROFILE_UPGRADE ) , " you added a new error code to prefapi.h and didn't update _convertRes " ) ;
return NS_OK ;
}
2001-03-29 00:48:30 +00:00
/*
* Constructor / Destructor
*/
2001-03-22 23:34:41 +00:00
nsPrefBranch : : nsPrefBranch ( const char * aPrefRoot , PRBool aDefaultBranch )
: mObservers ( nsnull )
{
NS_INIT_ISUPPORTS ( ) ;
mPrefRoot = aPrefRoot ;
mPrefRootLength = mPrefRoot . Length ( ) ;
mIsDefault = aDefaultBranch ;
2001-10-22 20:54:48 +00:00
nsCOMPtr < nsIObserverService > observerService =
2001-12-06 19:49:38 +00:00
do_GetService ( " @mozilla.org/observer-service;1 " ) ;
2001-10-22 20:54:48 +00:00
if ( observerService ) {
+ + mRefCnt ; // Our refcnt must be > 0 when we call this, or we'll get deleted!
2001-10-30 22:57:44 +00:00
// add weak so we don't have to clean up at shutdown
2001-10-22 20:54:48 +00:00
observerService - > AddObserver ( this , NS_XPCOM_SHUTDOWN_OBSERVER_ID , PR_TRUE ) ;
- - mRefCnt ;
}
2001-03-22 23:34:41 +00:00
}
nsPrefBranch : : ~ nsPrefBranch ( )
{
2001-10-22 20:54:48 +00:00
freeObserverList ( ) ;
2001-03-22 23:34:41 +00:00
}
2001-03-29 00:48:30 +00:00
/*
* nsISupports Implementation
*/
NS_IMPL_THREADSAFE_ADDREF ( nsPrefBranch )
NS_IMPL_THREADSAFE_RELEASE ( nsPrefBranch )
NS_INTERFACE_MAP_BEGIN ( nsPrefBranch )
2001-04-11 23:07:03 +00:00
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS ( nsISupports , nsIPrefBranch )
NS_INTERFACE_MAP_ENTRY ( nsIPrefBranch )
NS_INTERFACE_MAP_ENTRY ( nsIPrefBranchInternal )
NS_INTERFACE_MAP_ENTRY ( nsISecurityPref )
2001-10-22 20:54:48 +00:00
NS_INTERFACE_MAP_ENTRY ( nsIObserver )
2001-06-19 01:40:19 +00:00
NS_INTERFACE_MAP_ENTRY ( nsISupportsWeakReference )
2001-03-29 00:48:30 +00:00
NS_INTERFACE_MAP_END
/*
* nsIPrefBranch Implementation
*/
2001-03-22 23:34:41 +00:00
NS_IMETHODIMP nsPrefBranch : : GetRoot ( char * * aRoot )
{
NS_ENSURE_ARG_POINTER ( aRoot ) ;
mPrefRoot . Truncate ( mPrefRootLength ) ;
2001-09-29 08:28:41 +00:00
* aRoot = ToNewCString ( mPrefRoot ) ;
2001-03-22 23:34:41 +00:00
return NS_OK ;
}
NS_IMETHODIMP nsPrefBranch : : GetPrefType ( const char * aPrefName , PRInt32 * _retval )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
nsresult rv ;
rv = getValidatedPrefName ( aPrefName , & pref ) ;
if ( NS_FAILED ( rv ) )
return rv ;
* _retval = PREF_GetPrefType ( pref ) ;
2001-03-22 23:34:41 +00:00
return NS_OK ;
}
NS_IMETHODIMP nsPrefBranch : : GetBoolPref ( const char * aPrefName , PRBool * _retval )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( PREF_GetBoolPref ( pref , _retval , mIsDefault ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : SetBoolPref ( const char * aPrefName , PRInt32 aValue )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
if ( PR_FALSE = = mIsDefault ) {
rv = _convertRes ( PREF_SetBoolPref ( pref , aValue ) ) ;
} else {
rv = _convertRes ( PREF_SetDefaultBoolPref ( pref , aValue ) ) ;
}
2001-03-22 23:34:41 +00:00
}
2001-03-29 00:48:30 +00:00
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : GetCharPref ( const char * aPrefName , char * * _retval )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( PREF_CopyCharPref ( pref , _retval , mIsDefault ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : SetCharPref ( const char * aPrefName , const char * aValue )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
NS_ENSURE_ARG_POINTER ( aValue ) ;
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
if ( PR_FALSE = = mIsDefault ) {
rv = _convertRes ( PREF_SetCharPref ( pref , aValue ) ) ;
} else {
rv = _convertRes ( PREF_SetDefaultCharPref ( pref , aValue ) ) ;
}
2001-03-22 23:34:41 +00:00
}
2001-03-29 00:48:30 +00:00
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : GetIntPref ( const char * aPrefName , PRInt32 * _retval )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( PREF_GetIntPref ( pref , _retval , mIsDefault ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : SetIntPref ( const char * aPrefName , PRInt32 aValue )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
if ( PR_FALSE = = mIsDefault ) {
rv = _convertRes ( PREF_SetIntPref ( pref , aValue ) ) ;
} else {
rv = _convertRes ( PREF_SetDefaultIntPref ( pref , aValue ) ) ;
}
2001-03-22 23:34:41 +00:00
}
2001-03-29 00:48:30 +00:00
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : GetComplexValue ( const char * aPrefName , const nsIID & aType , void * * _retval )
{
nsresult rv ;
nsXPIDLCString utf8String ;
2001-04-24 20:32:16 +00:00
// we have to do this one first because it's different than all the rest
if ( aType . Equals ( NS_GET_IID ( nsIPrefLocalizedString ) ) ) {
nsCOMPtr < nsIPrefLocalizedString > theString ( do_CreateInstance ( NS_PREFLOCALIZEDSTRING_CONTRACTID , & rv ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-04-24 20:32:16 +00:00
PRBool bNeedDefault = PR_FALSE ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
if ( NS_FAILED ( rv ) )
return rv ;
2001-04-24 20:32:16 +00:00
if ( mIsDefault ) {
bNeedDefault = PR_TRUE ;
} else {
// if there is no user (or locked) value
if ( ! PREF_HasUserPref ( pref ) & & ! PREF_PrefIsLocked ( pref ) ) {
bNeedDefault = PR_TRUE ;
}
}
// if we need to fetch the default value, do that instead, otherwise use the
// value we pulled in at the top of this function
if ( bNeedDefault ) {
nsXPIDLString utf16String ;
rv = GetDefaultFromPropertiesFile ( pref , getter_Copies ( utf16String ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
rv = theString - > SetData ( utf16String . get ( ) ) ;
}
} else {
rv = GetCharPref ( aPrefName , getter_Copies ( utf8String ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
2001-05-07 07:51:24 +00:00
rv = theString - > SetData ( NS_ConvertUTF8toUCS2 ( utf8String ) . get ( ) ) ;
2001-04-24 20:32:16 +00:00
}
}
if ( NS_SUCCEEDED ( rv ) ) {
nsIPrefLocalizedString * temp = theString ;
NS_ADDREF ( temp ) ;
* _retval = ( void * ) temp ;
}
}
return rv ;
2001-03-29 00:48:30 +00:00
}
2001-04-24 20:32:16 +00:00
// if we can't get the pref, there's no point in being here
rv = GetCharPref ( aPrefName , getter_Copies ( utf8String ) ) ;
2001-03-22 23:34:41 +00:00
if ( NS_FAILED ( rv ) ) {
return rv ;
}
if ( aType . Equals ( NS_GET_IID ( nsILocalFile ) ) ) {
nsCOMPtr < nsILocalFile > file ( do_CreateInstance ( NS_LOCAL_FILE_CONTRACTID , & rv ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
rv = file - > SetPersistentDescriptor ( utf8String ) ;
if ( NS_SUCCEEDED ( rv ) ) {
nsILocalFile * temp = file ;
NS_ADDREF ( temp ) ;
* _retval = ( void * ) temp ;
return NS_OK ;
}
}
return rv ;
}
2002-04-09 14:18:39 +00:00
if ( aType . Equals ( NS_GET_IID ( nsIRelativeFilePref ) ) ) {
nsACString : : const_iterator keyBegin , strEnd ;
utf8String . BeginReading ( keyBegin ) ;
utf8String . EndReading ( strEnd ) ;
// The pref has the format: [fromKey]a/b/c
if ( * keyBegin + + ! = ' [ ' )
return NS_ERROR_FAILURE ;
nsACString : : const_iterator keyEnd ( keyBegin ) ;
if ( ! FindCharInReadable ( ' ] ' , keyEnd , strEnd ) )
return NS_ERROR_FAILURE ;
nsCAutoString key ( Substring ( keyBegin , keyEnd ) ) ;
nsCOMPtr < nsILocalFile > fromFile ;
nsCOMPtr < nsIProperties > directoryService ( do_GetService ( NS_DIRECTORY_SERVICE_CONTRACTID , & rv ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
rv = directoryService - > Get ( key . get ( ) , NS_GET_IID ( nsILocalFile ) , getter_AddRefs ( fromFile ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
nsCOMPtr < nsILocalFile > theFile ;
2002-04-27 05:33:09 +00:00
rv = NS_NewLocalFile ( nsCString ( ) , PR_TRUE , getter_AddRefs ( theFile ) ) ;
2002-04-09 14:18:39 +00:00
if ( NS_FAILED ( rv ) )
return rv ;
rv = theFile - > SetRelativeDescriptor ( fromFile , Substring ( + + keyEnd , strEnd ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
nsCOMPtr < nsIRelativeFilePref > relativePref ;
rv = NS_NewRelativeFilePref ( theFile , key , getter_AddRefs ( relativePref ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
* _retval = relativePref ;
NS_ADDREF ( NS_STATIC_CAST ( nsIRelativeFilePref * , * _retval ) ) ;
return NS_OK ;
}
2001-03-22 23:34:41 +00:00
if ( aType . Equals ( NS_GET_IID ( nsISupportsWString ) ) ) {
nsCOMPtr < nsISupportsWString > theString ( do_CreateInstance ( NS_SUPPORTS_WSTRING_CONTRACTID , & rv ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
2001-05-07 07:51:24 +00:00
rv = theString - > SetData ( NS_ConvertUTF8toUCS2 ( utf8String ) . get ( ) ) ;
2001-03-22 23:34:41 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
nsISupportsWString * temp = theString ;
NS_ADDREF ( temp ) ;
* _retval = ( void * ) temp ;
return NS_OK ;
}
}
return rv ;
}
2001-12-23 23:23:41 +00:00
// This is deprecated and you should not be using it
2001-03-22 23:34:41 +00:00
if ( aType . Equals ( NS_GET_IID ( nsIFileSpec ) ) ) {
nsCOMPtr < nsIFileSpec > file ( do_CreateInstance ( NS_FILESPEC_CONTRACTID , & rv ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
nsIFileSpec * temp = file ;
PRBool valid ;
file - > SetPersistentDescriptorString ( utf8String ) ; // only returns NS_OK
file - > IsValid ( & valid ) ;
if ( ! valid ) {
/* if the string wasn't a valid persistent descriptor, it might be a valid native path */
file - > SetNativePath ( utf8String ) ;
}
NS_ADDREF ( temp ) ;
* _retval = ( void * ) temp ;
return NS_OK ;
}
return rv ;
}
NS_WARNING ( " nsPrefBranch::GetComplexValue - Unsupported interface type " ) ;
return NS_NOINTERFACE ;
}
NS_IMETHODIMP nsPrefBranch : : SetComplexValue ( const char * aPrefName , const nsIID & aType , nsISupports * aValue )
{
2001-09-06 19:30:47 +00:00
nsresult rv = NS_NOINTERFACE ;
2001-03-29 00:48:30 +00:00
2001-03-22 23:34:41 +00:00
if ( aType . Equals ( NS_GET_IID ( nsILocalFile ) ) ) {
nsCOMPtr < nsILocalFile > file = do_QueryInterface ( aValue ) ;
2002-04-27 05:33:09 +00:00
nsCAutoString descriptorString ;
2001-03-22 23:34:41 +00:00
2002-04-27 05:33:09 +00:00
rv = file - > GetPersistentDescriptor ( descriptorString ) ;
2001-03-22 23:34:41 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
2002-04-27 05:33:09 +00:00
rv = SetCharPref ( aPrefName , descriptorString . get ( ) ) ;
2001-03-22 23:34:41 +00:00
}
return rv ;
}
2002-04-09 14:18:39 +00:00
if ( aType . Equals ( NS_GET_IID ( nsIRelativeFilePref ) ) ) {
nsCOMPtr < nsIRelativeFilePref > relFilePref = do_QueryInterface ( aValue ) ;
if ( ! relFilePref )
return NS_NOINTERFACE ;
nsCOMPtr < nsILocalFile > file ;
relFilePref - > GetFile ( getter_AddRefs ( file ) ) ;
if ( ! file )
return NS_ERROR_FAILURE ;
nsCAutoString relativeToKey ;
( void ) relFilePref - > GetRelativeToKey ( relativeToKey ) ;
nsCOMPtr < nsILocalFile > relativeToFile ;
nsCOMPtr < nsIProperties > directoryService ( do_GetService ( NS_DIRECTORY_SERVICE_CONTRACTID , & rv ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
rv = directoryService - > Get ( relativeToKey . get ( ) , NS_GET_IID ( nsILocalFile ) , getter_AddRefs ( relativeToFile ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
nsCAutoString relDescriptor ;
rv = file - > GetRelativeDescriptor ( relativeToFile , relDescriptor ) ;
if ( NS_FAILED ( rv ) )
return rv ;
nsCAutoString descriptorString ;
descriptorString . Append ( ' [ ' ) ;
descriptorString . Append ( relativeToKey ) ;
descriptorString . Append ( ' ] ' ) ;
descriptorString . Append ( relDescriptor ) ;
return SetCharPref ( aPrefName , descriptorString . get ( ) ) ;
}
2001-03-22 23:34:41 +00:00
if ( aType . Equals ( NS_GET_IID ( nsISupportsWString ) ) ) {
nsCOMPtr < nsISupportsWString > theString = do_QueryInterface ( aValue ) ;
if ( theString ) {
nsXPIDLString wideString ;
rv = theString - > GetData ( getter_Copies ( wideString ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
2001-04-24 20:32:16 +00:00
rv = SetCharPref ( aPrefName , NS_ConvertUCS2toUTF8 ( wideString ) . get ( ) ) ;
2001-03-22 23:34:41 +00:00
}
}
return rv ;
}
if ( aType . Equals ( NS_GET_IID ( nsIPrefLocalizedString ) ) ) {
nsCOMPtr < nsIPrefLocalizedString > theString = do_QueryInterface ( aValue ) ;
if ( theString ) {
nsXPIDLString wideString ;
rv = theString - > GetData ( getter_Copies ( wideString ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
2001-04-24 20:32:16 +00:00
rv = SetCharPref ( aPrefName , NS_ConvertUCS2toUTF8 ( wideString ) . get ( ) ) ;
2001-03-22 23:34:41 +00:00
}
}
return rv ;
}
2001-12-23 23:23:41 +00:00
// This is deprecated and you should not be using it
2001-03-22 23:34:41 +00:00
if ( aType . Equals ( NS_GET_IID ( nsIFileSpec ) ) ) {
nsCOMPtr < nsIFileSpec > file = do_QueryInterface ( aValue ) ;
nsXPIDLCString descriptorString ;
rv = file - > GetPersistentDescriptorString ( getter_Copies ( descriptorString ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
2001-04-24 20:32:16 +00:00
rv = SetCharPref ( aPrefName , descriptorString ) ;
2001-03-22 23:34:41 +00:00
}
return rv ;
}
NS_WARNING ( " nsPrefBranch::SetComplexValue - Unsupported interface type " ) ;
return NS_NOINTERFACE ;
}
NS_IMETHODIMP nsPrefBranch : : ClearUserPref ( const char * aPrefName )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( PREF_ClearUserPref ( pref ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
2001-06-08 20:31:34 +00:00
NS_IMETHODIMP nsPrefBranch : : PrefHasUserValue ( const char * aPrefName , PRBool * _retval )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-06-08 20:31:34 +00:00
nsresult rv ;
NS_ENSURE_ARG_POINTER ( _retval ) ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-06-08 20:31:34 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
* _retval = PREF_HasUserPref ( pref ) ;
}
return rv ;
}
2001-03-22 23:34:41 +00:00
NS_IMETHODIMP nsPrefBranch : : LockPref ( const char * aPrefName )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( PREF_LockPref ( pref ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : PrefIsLocked ( const char * aPrefName , PRBool * _retval )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-03-22 23:34:41 +00:00
NS_ENSURE_ARG_POINTER ( _retval ) ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
* _retval = PREF_PrefIsLocked ( pref ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : UnlockPref ( const char * aPrefName )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
2001-03-29 00:48:30 +00:00
nsresult rv ;
2001-09-06 19:30:47 +00:00
rv = getValidatedPrefName ( aPrefName , & pref ) ;
2001-03-29 00:48:30 +00:00
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( pref_UnlockPref ( pref ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
2001-03-29 00:48:30 +00:00
/* void resetBranch (in string startingAt); */
NS_IMETHODIMP nsPrefBranch : : ResetBranch ( const char * aStartingAt )
2001-03-22 23:34:41 +00:00
{
2001-03-29 00:48:30 +00:00
return NS_ERROR_NOT_IMPLEMENTED ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : DeleteBranch ( const char * aStartingAt )
{
2001-09-06 19:30:47 +00:00
const char * pref ;
nsresult rv ;
rv = getValidatedPrefName ( aStartingAt , & pref ) ;
if ( NS_SUCCEEDED ( rv ) ) {
rv = _convertRes ( PREF_DeleteBranch ( pref ) ) ;
}
return rv ;
2001-03-22 23:34:41 +00:00
}
NS_IMETHODIMP nsPrefBranch : : GetChildList ( const char * aStartingAt , PRUint32 * aCount , char * * * aChildArray )
{
char * * outArray ;
char * theElement ;
PRInt32 numPrefs ;
PRInt32 dwIndex ;
EnumerateData ed ;
nsAutoVoidArray prefArray ;
2001-09-06 19:30:47 +00:00
NS_ENSURE_ARG_POINTER ( aStartingAt ) ;
2001-03-22 23:34:41 +00:00
NS_ENSURE_ARG_POINTER ( aCount ) ;
NS_ENSURE_ARG_POINTER ( aChildArray ) ;
// this will contain a list of all the pref name strings
// allocate on the stack for speed
ed . parent = getPrefName ( aStartingAt ) ;
ed . pref_list = & prefArray ;
2002-01-05 00:09:53 +00:00
PL_DHashTableEnumerate ( & gHashTable , pref_enumChild , & ed ) ;
2001-03-22 23:34:41 +00:00
// now that we've built up the list, run the callback on
// all the matching elements
numPrefs = prefArray . Count ( ) ;
2001-06-26 21:14:12 +00:00
if ( numPrefs ) {
outArray = ( char * * ) nsMemory : : Alloc ( numPrefs * sizeof ( char * ) ) ;
if ( ! outArray )
return NS_ERROR_OUT_OF_MEMORY ;
2001-03-22 23:34:41 +00:00
2001-06-26 21:14:12 +00:00
for ( dwIndex = 0 ; dwIndex < numPrefs ; + + dwIndex ) {
2001-07-05 17:51:27 +00:00
// we need to lop off mPrefRoot in case the user is planning to pass this
// back to us because if they do we are going to add mPrefRoot again.
theElement = ( ( char * ) prefArray . ElementAt ( dwIndex ) ) + mPrefRootLength ;
2001-06-26 21:14:12 +00:00
outArray [ dwIndex ] = ( char * ) nsMemory : : Clone ( theElement , strlen ( theElement ) + 1 ) ;
2001-03-22 23:34:41 +00:00
2001-06-26 21:14:12 +00:00
if ( ! outArray [ dwIndex ] ) {
// we ran out of memory... this is annoying
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY ( dwIndex , outArray ) ;
return NS_ERROR_OUT_OF_MEMORY ;
}
2001-03-22 23:34:41 +00:00
}
2001-06-26 21:14:12 +00:00
* aChildArray = outArray ;
} else {
* aChildArray = nsnull ;
} /* endif */
2001-03-22 23:34:41 +00:00
* aCount = numPrefs ;
2001-06-26 21:14:12 +00:00
2001-03-22 23:34:41 +00:00
return NS_OK ;
}
2001-10-08 19:52:17 +00:00
/*
* nsIPrefBranchInternal methods
*/
2001-10-22 20:54:48 +00:00
NS_IMETHODIMP nsPrefBranch : : AddObserver ( const char * aDomain , nsIObserver * aObserver , PRBool aHoldWeak )
2001-03-22 23:34:41 +00:00
{
2001-12-06 19:49:38 +00:00
PrefCallbackData * pCallback ;
const char * pref ;
2001-04-11 23:07:03 +00:00
2001-03-22 23:34:41 +00:00
NS_ENSURE_ARG_POINTER ( aDomain ) ;
NS_ENSURE_ARG_POINTER ( aObserver ) ;
if ( ! mObservers ) {
2001-04-11 23:07:03 +00:00
mObservers = new nsAutoVoidArray ( ) ;
if ( nsnull = = mObservers )
return NS_ERROR_OUT_OF_MEMORY ;
2001-03-22 23:34:41 +00:00
}
2001-04-11 23:07:03 +00:00
pCallback = ( PrefCallbackData * ) nsMemory : : Alloc ( sizeof ( PrefCallbackData ) ) ;
if ( nsnull = = pCallback )
return NS_ERROR_OUT_OF_MEMORY ;
pCallback - > pBranch = NS_STATIC_CAST ( nsIPrefBranch * , this ) ;
2001-10-22 20:54:48 +00:00
pCallback - > bIsWeakRef = aHoldWeak ;
// hold a weak reference to the observer if so requested
nsCOMPtr < nsISupports > observerRef ;
if ( aHoldWeak ) {
nsCOMPtr < nsISupportsWeakReference > weakRefFactory = do_QueryInterface ( aObserver ) ;
if ( ! weakRefFactory ) {
// the caller didn't give us a object that supports weak reference... tell them
nsMemory : : Free ( pCallback ) ;
return NS_ERROR_INVALID_ARG ;
}
observerRef = do_GetWeakReference ( weakRefFactory ) ;
} else {
observerRef = aObserver ;
}
pCallback - > pObserver = observerRef ;
NS_ADDREF ( pCallback - > pObserver ) ;
2001-04-24 20:32:16 +00:00
2001-04-11 23:07:03 +00:00
mObservers - > AppendElement ( pCallback ) ;
mObserverDomains . AppendCString ( nsCString ( aDomain ) ) ;
2001-03-22 23:34:41 +00:00
2001-12-06 19:49:38 +00:00
// We must pass a fully qualified preference name to the callback
pref = getPrefName ( aDomain ) ; // aDomain == nsnull only possible failure, trapped above
PREF_RegisterCallback ( pref , NotifyObserver , pCallback ) ;
2001-03-22 23:34:41 +00:00
return NS_OK ;
}
NS_IMETHODIMP nsPrefBranch : : RemoveObserver ( const char * aDomain , nsIObserver * aObserver )
{
2001-12-06 19:49:38 +00:00
const char * pref ;
2001-04-11 23:07:03 +00:00
PrefCallbackData * pCallback ;
PRInt32 count ;
PRInt32 i ;
2001-03-22 23:34:41 +00:00
nsresult rv ;
2001-10-22 20:54:48 +00:00
nsCAutoString domain ;
2001-03-22 23:34:41 +00:00
NS_ENSURE_ARG_POINTER ( aDomain ) ;
NS_ENSURE_ARG_POINTER ( aObserver ) ;
if ( ! mObservers )
return NS_OK ;
// need to find the index of observer, so we can remove it from the domain list too
2001-04-11 23:07:03 +00:00
count = mObservers - > Count ( ) ;
if ( count = = 0 )
2001-03-22 23:34:41 +00:00
return NS_OK ;
for ( i = 0 ; i < count ; i + + ) {
2001-04-11 23:07:03 +00:00
pCallback = ( PrefCallbackData * ) mObservers - > ElementAt ( i ) ;
2001-10-22 20:54:48 +00:00
if ( pCallback ) {
nsCOMPtr < nsISupports > observerRef ;
if ( pCallback - > bIsWeakRef ) {
nsCOMPtr < nsISupportsWeakReference > weakRefFactory = do_QueryInterface ( aObserver ) ;
if ( weakRefFactory )
observerRef = do_GetWeakReference ( aObserver ) ;
}
if ( ! observerRef )
observerRef = aObserver ;
if ( pCallback - > pObserver = = observerRef ) {
mObserverDomains . CStringAt ( i , domain ) ;
2002-05-01 22:12:01 +00:00
if ( domain . Equals ( aDomain ) ) {
// We must pass a fully qualified preference name to remove the callback
pref = getPrefName ( aDomain ) ; // aDomain == nsnull only possible failure, trapped above
rv = _convertRes ( PREF_UnregisterCallback ( pref , NotifyObserver , pCallback ) ) ;
if ( NS_SUCCEEDED ( rv ) ) {
NS_RELEASE ( pCallback - > pObserver ) ;
nsMemory : : Free ( pCallback ) ;
mObservers - > RemoveElementAt ( i ) ;
mObserverDomains . RemoveCStringAt ( i ) ;
}
return rv ;
}
2001-10-22 20:54:48 +00:00
}
2001-03-22 23:34:41 +00:00
}
}
2002-05-01 22:12:01 +00:00
return NS_OK ;
2001-03-22 23:34:41 +00:00
}
2001-10-22 20:54:48 +00:00
NS_IMETHODIMP nsPrefBranch : : Observe ( nsISupports * aSubject , const char * aTopic , const PRUnichar * someData )
{
// watch for xpcom shutdown and free our observers to eliminate any cyclic references
if ( ! nsCRT : : strcmp ( aTopic , NS_XPCOM_SHUTDOWN_OBSERVER_ID ) ) {
freeObserverList ( ) ;
}
return NS_OK ;
}
2001-03-22 23:34:41 +00:00
static int PR_CALLBACK NotifyObserver ( const char * newpref , void * data )
{
2001-04-11 23:07:03 +00:00
PrefCallbackData * pData = ( PrefCallbackData * ) data ;
2001-12-06 19:49:38 +00:00
nsPrefBranch * prefBranch = NS_STATIC_CAST ( nsPrefBranch * , pData - > pBranch ) ;
// remove any root this string may contain so as to not confuse the observer
// by passing them something other than what they passed us as a topic
PRUint32 len = prefBranch - > GetRootLength ( ) ;
nsCAutoString suffix ( newpref + len ) ;
2001-04-11 23:07:03 +00:00
2001-10-22 20:54:48 +00:00
nsCOMPtr < nsIObserver > observer ;
if ( pData - > bIsWeakRef ) {
nsIWeakReference * weakRef = NS_STATIC_CAST ( nsIWeakReference * , pData - > pObserver ) ;
observer = do_QueryReferent ( weakRef ) ;
if ( ! observer ) {
// this weak referenced observer went away, remove them from the list
nsCOMPtr < nsIPrefBranchInternal > pbi = do_QueryInterface ( pData - > pBranch ) ;
if ( pbi ) {
observer = NS_STATIC_CAST ( nsIObserver * , pData - > pObserver ) ;
pbi - > RemoveObserver ( newpref , observer ) ;
}
return 0 ;
}
} else
observer = NS_STATIC_CAST ( nsIObserver * , pData - > pObserver ) ;
2001-04-11 23:07:03 +00:00
2001-10-22 20:54:48 +00:00
observer - > Observe ( pData - > pBranch , NS_PREFBRANCH_PREFCHANGE_TOPIC_ID ,
2001-12-06 19:49:38 +00:00
NS_ConvertASCIItoUCS2 ( suffix ) . get ( ) ) ;
2001-10-22 20:54:48 +00:00
return 0 ;
2001-03-22 23:34:41 +00:00
}
2001-10-22 20:54:48 +00:00
void nsPrefBranch : : freeObserverList ( void )
{
2001-12-06 19:49:38 +00:00
const char * pref ;
2001-10-22 20:54:48 +00:00
PrefCallbackData * pCallback ;
if ( mObservers ) {
// unregister the observers
PRInt32 count ;
count = mObservers - > Count ( ) ;
if ( count > 0 ) {
PRInt32 i ;
nsCAutoString domain ;
for ( i = 0 ; i < count ; i + + ) {
pCallback = ( PrefCallbackData * ) mObservers - > ElementAt ( i ) ;
if ( pCallback ) {
mObserverDomains . CStringAt ( i , domain ) ;
2001-12-06 19:49:38 +00:00
// We must pass a fully qualified preference name to remove the callback
pref = getPrefName ( domain . get ( ) ) ; // can't fail because domain must be valid
PREF_UnregisterCallback ( pref , NotifyObserver , pCallback ) ;
2001-10-22 20:54:48 +00:00
NS_RELEASE ( pCallback - > pObserver ) ;
nsMemory : : Free ( pCallback ) ;
}
}
// now empty the observer arrays in bulk
mObservers - > Clear ( ) ;
mObserverDomains . Clear ( ) ;
}
delete mObservers ;
mObservers = 0 ;
}
}
2001-04-12 23:28:43 +00:00
nsresult nsPrefBranch : : GetDefaultFromPropertiesFile ( const char * aPrefName , PRUnichar * * return_buf )
{
nsresult rv ;
// the default value contains a URL to a .properties file
nsXPIDLCString propertyFileURL ;
rv = _convertRes ( PREF_CopyCharPref ( aPrefName , getter_Copies ( propertyFileURL ) , PR_TRUE ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
nsCOMPtr < nsIStringBundleService > bundleService =
2001-10-08 19:52:17 +00:00
do_GetService ( NS_STRINGBUNDLE_CONTRACTID , & rv ) ;
2001-04-12 23:28:43 +00:00
if ( NS_FAILED ( rv ) )
return rv ;
nsCOMPtr < nsIStringBundle > bundle ;
2001-04-27 21:30:24 +00:00
rv = bundleService - > CreateBundle ( propertyFileURL ,
2001-04-12 23:28:43 +00:00
getter_AddRefs ( bundle ) ) ;
if ( NS_FAILED ( rv ) )
return rv ;
// string names are in unicdoe
nsAutoString stringId ;
stringId . AssignWithConversion ( aPrefName ) ;
2001-06-30 11:02:25 +00:00
return bundle - > GetStringFromName ( stringId . get ( ) , return_buf ) ;
2001-04-12 23:28:43 +00:00
}
2001-03-22 23:34:41 +00:00
const char * nsPrefBranch : : getPrefName ( const char * aPrefName )
{
// for speed, avoid strcpy if we can:
if ( mPrefRoot . IsEmpty ( ) )
return aPrefName ;
// isn't there a better way to do this? this is really kind of gross.
mPrefRoot . Truncate ( mPrefRootLength ) ;
// only append if anything to append
2001-09-06 19:30:47 +00:00
if ( ( nsnull ! = aPrefName ) & & ( * aPrefName ! = ' \0 ' ) )
2001-03-22 23:34:41 +00:00
mPrefRoot . Append ( aPrefName ) ;
return mPrefRoot . get ( ) ;
}
2001-09-06 19:30:47 +00:00
nsresult nsPrefBranch : : getValidatedPrefName ( const char * aPrefName , const char * * _retval )
2001-03-22 23:34:41 +00:00
{
2001-09-06 19:30:47 +00:00
static const char capabilityPrefix [ ] = " capability. " ;
const char * fullPref ;
NS_ENSURE_ARG_POINTER ( aPrefName ) ;
// for speed, avoid strcpy if we can:
if ( mPrefRoot . IsEmpty ( ) ) {
fullPref = aPrefName ;
} else {
// isn't there a better way to do this? this is really kind of gross.
mPrefRoot . Truncate ( mPrefRootLength ) ;
// only append if anything to append
if ( ( nsnull ! = aPrefName ) & & ( * aPrefName ! = ' \0 ' ) )
mPrefRoot . Append ( aPrefName ) ;
fullPref = mPrefRoot . get ( ) ;
2001-04-11 23:07:03 +00:00
}
2001-03-22 23:34:41 +00:00
2001-09-06 19:30:47 +00:00
// now that we have the pref, check it against the ScriptSecurityManager
if ( ( fullPref [ 0 ] = = ' c ' ) & &
PL_strncmp ( fullPref , capabilityPrefix , sizeof ( capabilityPrefix ) - 1 ) = = 0 )
2001-04-11 23:07:03 +00:00
{
nsresult rv ;
2001-07-25 07:54:28 +00:00
nsCOMPtr < nsIScriptSecurityManager > secMan =
do_GetService ( kSecurityManagerCID , & rv ) ;
2001-04-11 23:07:03 +00:00
PRBool enabled ;
2001-09-06 19:30:47 +00:00
if ( NS_FAILED ( rv ) )
return NS_ERROR_FAILURE ;
2001-04-11 23:07:03 +00:00
rv = secMan - > IsCapabilityEnabled ( " CapabilityPreferencesAccess " , & enabled ) ;
if ( NS_FAILED ( rv ) | | ! enabled )
return NS_ERROR_FAILURE ;
}
2001-09-06 19:30:47 +00:00
* _retval = fullPref ;
2001-04-11 23:07:03 +00:00
return NS_OK ;
}
2001-03-22 23:34:41 +00:00
2001-12-04 01:52:44 +00:00
PR_STATIC_CALLBACK ( PLDHashOperator )
pref_enumChild ( PLDHashTable * table , PLDHashEntryHdr * heh ,
PRUint32 i , void * arg )
2001-09-06 19:30:47 +00:00
{
2001-12-04 01:52:44 +00:00
PrefHashEntry * he = NS_STATIC_CAST ( PrefHashEntry * , heh ) ;
EnumerateData * d = NS_REINTERPRET_CAST ( EnumerateData * , arg ) ;
if ( PL_strncmp ( he - > key , d - > parent , PL_strlen ( d - > parent ) ) = = 0 ) {
d - > pref_list - > AppendElement ( ( void * ) he - > key ) ;
2001-09-06 19:30:47 +00:00
}
2001-12-04 01:52:44 +00:00
return PL_DHASH_NEXT ;
2001-09-06 19:30:47 +00:00
}
2001-03-22 23:34:41 +00:00
2001-04-11 23:07:03 +00:00
/*
2001-10-08 19:52:17 +00:00
* nsISecurityPref methods
*
2001-04-11 23:07:03 +00:00
* Pref access without security check - these are here
* to support nsScriptSecurityManager .
* These functions are part of nsISecurityPref , not nsIPref .
* * * PLEASE * * do not call these functions from elsewhere
*/
NS_IMETHODIMP nsPrefBranch : : SecurityGetBoolPref ( const char * pref , PRBool * return_val )
{
return _convertRes ( PREF_GetBoolPref ( getPrefName ( pref ) , return_val , PR_FALSE ) ) ;
}
2001-03-22 23:34:41 +00:00
2001-04-11 23:07:03 +00:00
NS_IMETHODIMP nsPrefBranch : : SecuritySetBoolPref ( const char * pref , PRBool value )
{
return _convertRes ( PREF_SetBoolPref ( getPrefName ( pref ) , value ) ) ;
}
2001-03-22 23:34:41 +00:00
2001-04-11 23:07:03 +00:00
NS_IMETHODIMP nsPrefBranch : : SecurityGetCharPref ( const char * pref , char * * return_buf )
{
return _convertRes ( PREF_CopyCharPref ( getPrefName ( pref ) , return_buf , PR_FALSE ) ) ;
}
NS_IMETHODIMP nsPrefBranch : : SecuritySetCharPref ( const char * pref , const char * value )
{
return _convertRes ( PREF_SetCharPref ( getPrefName ( pref ) , value ) ) ;
}
NS_IMETHODIMP nsPrefBranch : : SecurityGetIntPref ( const char * pref , PRInt32 * return_val )
{
return _convertRes ( PREF_GetIntPref ( getPrefName ( pref ) , return_val , PR_FALSE ) ) ;
}
NS_IMETHODIMP nsPrefBranch : : SecuritySetIntPref ( const char * pref , PRInt32 value )
{
return _convertRes ( PREF_SetIntPref ( getPrefName ( pref ) , value ) ) ;
}
NS_IMETHODIMP nsPrefBranch : : SecurityClearUserPref ( const char * pref_name )
{
return _convertRes ( PREF_ClearUserPref ( getPrefName ( pref_name ) ) ) ;
2001-03-22 23:34:41 +00:00
}
2002-04-09 14:18:39 +00:00
//----------------------------------------------------------------------------
// nsPrefLocalizedString
//----------------------------------------------------------------------------
2001-03-22 23:34:41 +00:00
nsPrefLocalizedString : : nsPrefLocalizedString ( )
2001-04-03 20:11:54 +00:00
: mUnicodeString ( nsnull )
2001-03-22 23:34:41 +00:00
{
nsresult rv ;
NS_INIT_REFCNT ( ) ;
mUnicodeString = do_CreateInstance ( NS_SUPPORTS_WSTRING_CONTRACTID , & rv ) ;
}
nsPrefLocalizedString : : ~ nsPrefLocalizedString ( )
{
}
2001-04-03 20:11:54 +00:00
/*
* nsISupports Implementation
*/
NS_IMPL_THREADSAFE_ADDREF ( nsPrefLocalizedString )
NS_IMPL_THREADSAFE_RELEASE ( nsPrefLocalizedString )
NS_INTERFACE_MAP_BEGIN ( nsPrefLocalizedString )
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS ( nsISupports , nsIPrefLocalizedString )
NS_INTERFACE_MAP_ENTRY ( nsIPrefLocalizedString )
NS_INTERFACE_MAP_ENTRY ( nsISupportsWString )
NS_INTERFACE_MAP_END
nsresult nsPrefLocalizedString : : Init ( )
{
nsresult rv ;
mUnicodeString = do_CreateInstance ( NS_SUPPORTS_WSTRING_CONTRACTID , & rv ) ;
return rv ;
}
2002-04-09 14:18:39 +00:00
//----------------------------------------------------------------------------
// nsRelativeFilePref
//----------------------------------------------------------------------------
NS_IMPL_THREADSAFE_ISUPPORTS1 ( nsRelativeFilePref , nsIRelativeFilePref ) ;
nsRelativeFilePref : : nsRelativeFilePref ( )
{
NS_INIT_ISUPPORTS ( ) ;
}
nsRelativeFilePref : : ~ nsRelativeFilePref ( )
{
}
NS_IMETHODIMP nsRelativeFilePref : : GetFile ( nsILocalFile * * aFile )
{
NS_ENSURE_ARG_POINTER ( aFile ) ;
* aFile = mFile ;
NS_IF_ADDREF ( * aFile ) ;
return * aFile ? NS_OK : NS_ERROR_NULL_POINTER ;
}
NS_IMETHODIMP nsRelativeFilePref : : SetFile ( nsILocalFile * aFile )
{
mFile = aFile ;
return NS_OK ;
}
NS_IMETHODIMP nsRelativeFilePref : : GetRelativeToKey ( nsACString & aRelativeToKey )
{
aRelativeToKey . Assign ( mRelativeToKey ) ;
return NS_OK ;
}
NS_IMETHODIMP nsRelativeFilePref : : SetRelativeToKey ( const nsACString & aRelativeToKey )
{
mRelativeToKey . Assign ( aRelativeToKey ) ;
return NS_OK ;
}