diff -r 000000000000 -r dd21522fd290 webengine/osswebengine/WebKit/win/WebPreferences.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webengine/osswebengine/WebKit/win/WebPreferences.cpp Mon Mar 30 12:54:55 2009 +0300 @@ -0,0 +1,1180 @@ +/* + * Copyright (C) 2006, 2007 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebKitDLL.h" +#include "WebPreferences.h" + +#include "WebNotificationCenter.h" +#include "WebPreferenceKeysPrivate.h" + +#pragma warning( push, 0 ) +#include +#include +#include +#include "WebLocalizableStrings.h" +#pragma warning( pop ) + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +// {A20B5645-692D-4147-BF80-E8CD84BE82A1} +DEFINE_GUID(IID_WebPreferences, 0xa20b5645, 0x692d, 0x4147, 0xbf, 0x80, 0xe8, 0xcd, 0x84, 0xbe, 0x82, 0xa1); + +static unsigned long long WebSystemMainMemory() +{ + MEMORYSTATUSEX statex; + + statex.dwLength = sizeof(statex); + GlobalMemoryStatusEx(&statex); + return statex.ullTotalPhys; +} + +// WebPreferences ---------------------------------------------------------------- + +CFDictionaryRef WebPreferences::s_defaultSettings = 0; + +static HashMap webPreferencesInstances; + +WebPreferences* WebPreferences::sharedStandardPreferences() +{ + static WebPreferences* standardPreferences; + if (!standardPreferences) { + standardPreferences = WebPreferences::createInstance(); + standardPreferences->load(); + standardPreferences->setAutosaves(TRUE); + standardPreferences->postPreferencesChangesNotification(); + } + + return standardPreferences; +} + +WebPreferences::WebPreferences() +: m_refCount(0) +, m_autoSaves(0) +{ + gClassCount++; +} + +WebPreferences::~WebPreferences() +{ + gClassCount--; +} + +WebPreferences* WebPreferences::createInstance() +{ + WebPreferences* instance = new WebPreferences(); + instance->AddRef(); + return instance; +} + +HRESULT WebPreferences::postPreferencesChangesNotification() +{ + IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal(); + HRESULT hr = nc->postNotificationName(webPreferencesChangedNotification(), static_cast(this), 0); + if (FAILED(hr)) + return hr; + + return S_OK; +} + +WebPreferences* WebPreferences::getInstanceForIdentifier(BSTR identifier) +{ + if (!identifier) + return sharedStandardPreferences(); + + WebCore::String identifierString(identifier, SysStringLen(identifier)); + return webPreferencesInstances.get(identifierString); +} + +void WebPreferences::setInstance(WebPreferences* instance, BSTR identifier) +{ + if (!identifier || !instance) + return; + WebCore::String identifierString(identifier, SysStringLen(identifier)); + webPreferencesInstances.add(identifierString, instance); +} + +void WebPreferences::removeReferenceForIdentifier(BSTR identifier) +{ + if (!identifier || webPreferencesInstances.isEmpty()) + return; + + WebCore::String identifierString(identifier, SysStringLen(identifier)); + WebPreferences* webPreference = webPreferencesInstances.get(identifierString); + if (webPreference && webPreference->m_refCount == 1) + webPreferencesInstances.remove(identifierString); +} + +void WebPreferences::initializeDefaultSettings() +{ + if (s_defaultSettings) + return; + + CFMutableDictionaryRef defaults = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + + // As a fudge factor, use 1000 instead of 1024, in case the reported memory doesn't align exactly to a megabyte boundary. + unsigned long long memSize = WebSystemMainMemory() / 1024 / 1000; + + // Page cache size (in pages) + int pageCacheSize; + if (memSize >= 1024) + pageCacheSize = 10; + else if (memSize >= 512) + pageCacheSize = 5; + else if (memSize >= 384) + pageCacheSize = 4; + else if (memSize >= 256) + pageCacheSize = 3; + else if (memSize >= 128) + pageCacheSize = 2; + else if (memSize >= 64) + pageCacheSize = 1; + else + pageCacheSize = 0; + + // Object cache size (in bytes) + int objectCacheSize; + if (memSize >= 2048) + objectCacheSize = 128 * 1024 * 1024; + else if (memSize >= 1024) + objectCacheSize = 64 * 1024 * 1024; + else if (memSize >= 512) + objectCacheSize = 32 * 1024 * 1024; + else + objectCacheSize = 24 * 1024 * 1024; + + CFDictionaryAddValue(defaults, CFSTR(WebKitStandardFontPreferenceKey), CFSTR("Times New Roman")); + CFDictionaryAddValue(defaults, CFSTR(WebKitFixedFontPreferenceKey), CFSTR("Courier New")); + CFDictionaryAddValue(defaults, CFSTR(WebKitSerifFontPreferenceKey), CFSTR("Times New Roman")); + CFDictionaryAddValue(defaults, CFSTR(WebKitSansSerifFontPreferenceKey), CFSTR("Arial")); + CFDictionaryAddValue(defaults, CFSTR(WebKitCursiveFontPreferenceKey), CFSTR("Comic Sans MS")); + CFDictionaryAddValue(defaults, CFSTR(WebKitFantasyFontPreferenceKey), CFSTR("Comic Sans MS")); + CFDictionaryAddValue(defaults, CFSTR(WebKitMinimumFontSizePreferenceKey), CFSTR("1")); + CFDictionaryAddValue(defaults, CFSTR(WebKitMinimumLogicalFontSizePreferenceKey), CFSTR("9")); + CFDictionaryAddValue(defaults, CFSTR(WebKitDefaultFontSizePreferenceKey), CFSTR("16")); + CFDictionaryAddValue(defaults, CFSTR(WebKitDefaultFixedFontSizePreferenceKey), CFSTR("13")); + WebCore::String defaultDefaultEncoding(LPCTSTR_UI_STRING("ISO-8859-1", "The default, default character encoding")); + CFDictionaryAddValue(defaults, CFSTR(WebKitDefaultTextEncodingNamePreferenceKey), defaultDefaultEncoding.createCFString()); + + RetainPtr pageCacheSizeString(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), pageCacheSize)); + CFDictionaryAddValue(defaults, CFSTR(WebKitPageCacheSizePreferenceKey), pageCacheSizeString.get()); + + RetainPtr objectCacheSizeString(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), objectCacheSize)); + CFDictionaryAddValue(defaults, CFSTR(WebKitObjectCacheSizePreferenceKey), objectCacheSizeString.get()); + + CFDictionaryAddValue(defaults, CFSTR(WebKitUserStyleSheetEnabledPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitUserStyleSheetLocationPreferenceKey), CFSTR("")); + CFDictionaryAddValue(defaults, CFSTR(WebKitShouldPrintBackgroundsPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitTextAreasAreResizablePreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitJavaEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitJavaScriptEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitPluginsEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitAllowAnimatedImagesPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitAllowAnimatedImageLoopingPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitDisplayImagesKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitBackForwardCacheExpirationIntervalKey), CFSTR("1800")); + CFDictionaryAddValue(defaults, CFSTR(WebKitTabToLinksPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitPrivateBrowsingEnabledPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitRespectStandardStyleKeyEquivalentsPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitShowsURLsInToolTipsPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitPDFDisplayModePreferenceKey), CFSTR("1")); + CFDictionaryAddValue(defaults, CFSTR(WebKitPDFScaleFactorPreferenceKey), CFSTR("0")); + + RetainPtr linkBehaviorStringRef(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), WebKitEditableLinkDefaultBehavior)); + CFDictionaryAddValue(defaults, CFSTR(WebKitEditableLinkBehaviorPreferenceKey), linkBehaviorStringRef.get()); + + CFDictionaryAddValue(defaults, CFSTR(WebKitHistoryItemLimitKey), CFSTR("1000")); + CFDictionaryAddValue(defaults, CFSTR(WebKitHistoryAgeInDaysLimitKey), CFSTR("7")); + CFDictionaryAddValue(defaults, CFSTR(WebKitIconDatabaseLocationKey), CFSTR("")); + CFDictionaryAddValue(defaults, CFSTR(WebKitIconDatabaseEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitFontSmothingTypePreferenceKey), CFSTR("2")); + CFDictionaryAddValue(defaults, CFSTR(WebKitCookieStorageAcceptPolicyPreferenceKey), CFSTR("2")); + CFDictionaryAddValue(defaults, CFSTR(WebContinuousSpellCheckingEnabledPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebGrammarCheckingEnabledPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(AllowContinuousSpellCheckingPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitUsesPageCachePreferenceKey), kCFBooleanTrue); + + s_defaultSettings = defaults; +} + +const void* WebPreferences::valueForKey(CFStringRef key) +{ + const void* value = CFDictionaryGetValue(m_privatePrefs.get(), key); + if (!value) + value = CFDictionaryGetValue(s_defaultSettings, key); + + return value; +} + +BSTR WebPreferences::stringValueForKey(CFStringRef key) +{ + CFStringRef str = (CFStringRef)valueForKey(key); + + if (!str || (CFGetTypeID(str) != CFStringGetTypeID())) + return 0; + + CFIndex length = CFStringGetLength(str); + const UniChar* uniChars = CFStringGetCharactersPtr(str); + if (uniChars) + return SysAllocStringLen((LPCTSTR)uniChars, length); + + BSTR bstr = SysAllocStringLen(0, length); + if (!bstr) + return 0; + + if (!CFStringGetCString(str, (char*)bstr, (length+1)*sizeof(WCHAR), kCFStringEncodingUTF16)) { + SysFreeString(bstr); + return 0; + } + + bstr[length] = 0; + return bstr; +} + +int WebPreferences::integerValueForKey(CFStringRef key) +{ + CFTypeRef cfVal = (CFStringRef)valueForKey(key); + if (!cfVal) + return 0; + + CFTypeID cfType = CFGetTypeID(cfVal); + if (cfType == CFStringGetTypeID()) + return CFStringGetIntValue((CFStringRef)cfVal); + else if (cfType == CFBooleanGetTypeID()) { + Boolean boolVal = CFBooleanGetValue((CFBooleanRef)cfVal); + return (boolVal) ? 1 : 0; + } + else if (cfType == CFNumberGetTypeID()) { + int val = 0; + CFNumberGetValue((CFNumberRef)cfVal, kCFNumberSInt32Type, &val); + return val; + } + + return 0; +} + +BOOL WebPreferences::boolValueForKey(CFStringRef key) +{ + return (integerValueForKey(key) != 0); +} + +float WebPreferences::floatValueForKey(CFStringRef key) +{ + CFTypeRef cfVal = (CFStringRef)valueForKey(key); + if (!cfVal) + return 0.0; + + CFTypeID cfType = CFGetTypeID(cfVal); + if (cfType == CFStringGetTypeID()) + return (float)CFStringGetDoubleValue((CFStringRef)cfVal); + else if (cfType == CFBooleanGetTypeID()) { + Boolean boolVal = CFBooleanGetValue((CFBooleanRef)cfVal); + return (boolVal) ? 1.0f : 0.0f; + } + else if (cfType == CFNumberGetTypeID()) { + float val = 0.0; + CFNumberGetValue((CFNumberRef)cfVal, kCFNumberFloatType, &val); + return val; + } + + return 0.0; +} + +void WebPreferences::setStringValue(CFStringRef key, LPCTSTR value) +{ + BSTR val = stringValueForKey(key); + if (val && !_tcscmp(val, value)) + return; + SysFreeString(val); + + RetainPtr valueRef(AdoptCF, + CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(value), (CFIndex)_tcslen(value), kCFAllocatorMalloc)); + CFDictionarySetValue(m_privatePrefs.get(), key, valueRef.get()); + if (m_autoSaves) + save(); + + postPreferencesChangesNotification(); +} + +BSTR WebPreferences::webPreferencesChangedNotification() +{ + static BSTR webPreferencesChangedNotification = SysAllocString(WebPreferencesChangedNotification); + return webPreferencesChangedNotification; +} + +void WebPreferences::setIntegerValue(CFStringRef key, int value) +{ + if (integerValueForKey(key) == value) + return; + + RetainPtr valueRef(AdoptCF, CFNumberCreate(0, kCFNumberSInt32Type, &value)); + CFDictionarySetValue(m_privatePrefs.get(), key, valueRef.get()); + if (m_autoSaves) + save(); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setBoolValue(CFStringRef key, BOOL value) +{ + if (boolValueForKey(key) == value) + return; + + CFDictionarySetValue(m_privatePrefs.get(), key, value ? kCFBooleanTrue : kCFBooleanFalse); + if (m_autoSaves) + save(); + + postPreferencesChangesNotification(); +} + +void WebPreferences::save() +{ + TCHAR appDataPath[MAX_PATH]; + if (FAILED(preferencesPath(appDataPath, MAX_PATH))) + return; + + RetainPtr stream(AdoptCF, + CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault)); + if (!stream) + return; + + if (!CFWriteStreamOpen(stream.get())) + return; + + if (!CFPropertyListWriteToStream(m_privatePrefs.get(), stream.get(), kCFPropertyListXMLFormat_v1_0, 0)) { + CFWriteStreamClose(stream.get()); + return; + } + CFWriteStreamClose(stream.get()); + + RetainPtr dataRef(AdoptCF, + (CFDataRef)CFWriteStreamCopyProperty(stream.get(), kCFStreamPropertyDataWritten)); + if (!dataRef) + return; + + void* bytes = (void*)CFDataGetBytePtr(dataRef.get()); + size_t length = CFDataGetLength(dataRef.get()); + safeCreateFileWithData(appDataPath, bytes, length); +} + +void WebPreferences::load() +{ + initializeDefaultSettings(); + + TCHAR appDataPath[MAX_PATH]; + if (FAILED(preferencesPath(appDataPath, MAX_PATH))) + return; + + DWORD appDataPathLength = (DWORD) _tcslen(appDataPath)+1; + int result = WideCharToMultiByte(CP_UTF8, 0, appDataPath, appDataPathLength, 0, 0, 0, 0); + Vector utf8Path(result); + if (!WideCharToMultiByte(CP_UTF8, 0, appDataPath, appDataPathLength, (LPSTR)utf8Path.data(), result, 0, 0)) + return; + + RetainPtr urlRef(AdoptCF, CFURLCreateFromFileSystemRepresentation(0, utf8Path.data(), result-1, false)); + if (!urlRef) + return; + + RetainPtr stream(AdoptCF, CFReadStreamCreateWithFile(0, urlRef.get())); + if (!stream) + return; + + if (CFReadStreamOpen(stream.get())) { + CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0; + RetainPtr plist(AdoptCF, CFPropertyListCreateFromStream(0, stream.get(), 0, kCFPropertyListMutableContainersAndLeaves, &format, 0)); + CFReadStreamClose(stream.get()); + + if (CFGetTypeID(plist.get()) == CFDictionaryGetTypeID()) + m_privatePrefs.adoptCF(const_cast(reinterpret_cast(plist.releaseRef()))); + } + + if (!m_privatePrefs) + m_privatePrefs.adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); + + migrateDefaultSettingsFromSafari3Beta(); +} + +void WebPreferences::migrateDefaultSettingsFromSafari3Beta() +{ + // The "migration" happening here is a one-time removal of any default values + // that were stored in the user's preferences due to . + + ASSERT(s_defaultSettings); + if (!m_privatePrefs) + return; + + CFStringRef didMigrateKey = CFSTR(WebKitDidMigrateDefaultSettingsFromSafari3BetaPreferenceKey); + if (boolValueForKey(didMigrateKey)) + return; + + removeValuesMatchingDefaultSettings(); + + bool oldValue = m_autoSaves; + m_autoSaves = true; + setBoolValue(didMigrateKey, TRUE); + m_autoSaves = oldValue; +} + +void WebPreferences::removeValuesMatchingDefaultSettings() +{ + ASSERT(m_privatePrefs); + + int count = CFDictionaryGetCount(m_privatePrefs.get()); + if (count <= 0) + return; + + Vector keys(count); + Vector values(count); + CFDictionaryGetKeysAndValues(m_privatePrefs.get(), keys.data(), values.data()); + + for (int i = 0; i < count; ++i) { + if (!values[i]) + continue; + + CFTypeRef defaultValue = CFDictionaryGetValue(s_defaultSettings, keys[i]); + if (!defaultValue) + continue; + + if (CFEqual(values[i], defaultValue)) + CFDictionaryRemoveValue(m_privatePrefs.get(), keys[i]); + } +} + +HRESULT WebPreferences::preferencesPath(LPTSTR path, size_t cchPath) +{ + // get the path to the user's Application Data folder (Example: C:\Documents and Settings\{username}\Application Data\Apple Computer\WebKit) + HRESULT hr = SHGetFolderPath(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 0, path); + if (FAILED(hr)) + return hr; + + if (_tcscat_s(path, cchPath, TEXT("\\Apple Computer\\"))) + return E_FAIL; + + WebCore::String appName = "WebKit"; + CFBundleRef bundle = CFBundleGetMainBundle(); + if (bundle) { + CFStringRef bundleExecutable = (CFStringRef)CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleExecutableKey); + if (bundleExecutable) + appName = bundleExecutable; + } + if (_tcscat_s(path, cchPath, appName.charactersWithNullTermination())) + return E_FAIL; + + int err = SHCreateDirectoryEx(0, path, 0); + if (err != ERROR_SUCCESS && err != ERROR_ALREADY_EXISTS) + return E_FAIL; + + if (_tcscat_s(path, cchPath, TEXT("\\WebKitPreferences.plist"))) + return E_FAIL; + + return S_OK; +} + +HRESULT WebPreferences::safeCreateFileWithData(LPCTSTR path, void* data, size_t length) +{ + TCHAR tempDirPath[MAX_PATH]; + TCHAR tempPath[MAX_PATH]; + HANDLE tempFileHandle = INVALID_HANDLE_VALUE; + HRESULT hr = S_OK; + tempPath[0] = 0; + + // create a temporary file + if (!GetTempPath(sizeof(tempDirPath)/sizeof(tempDirPath[0]), tempDirPath)) { + hr = HRESULT_FROM_WIN32(GetLastError()); + goto exit; + } + if (!GetTempFileName(tempDirPath, TEXT("WEBKIT"), 0, tempPath)) + return HRESULT_FROM_WIN32(GetLastError()); + tempFileHandle = CreateFile(tempPath, GENERIC_READ|GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); + if (tempFileHandle == INVALID_HANDLE_VALUE) { + hr = HRESULT_FROM_WIN32(GetLastError()); + goto exit; + } + + // write the data to this temp file + DWORD written; + if (!WriteFile(tempFileHandle, data, (DWORD)length, &written, 0)) { + hr = HRESULT_FROM_WIN32(GetLastError()); + goto exit; + } + + // copy the temp file to the destination file + CloseHandle(tempFileHandle); + tempFileHandle = INVALID_HANDLE_VALUE; + if (!MoveFileEx(tempPath, path, MOVEFILE_REPLACE_EXISTING)) { + hr = HRESULT_FROM_WIN32(GetLastError()); + goto exit; + } + +exit: + if (tempFileHandle != INVALID_HANDLE_VALUE) + CloseHandle(tempFileHandle); + if (tempPath[0]) + DeleteFile(tempPath); + + return hr; +} + +// IUnknown ------------------------------------------------------------------- + +HRESULT STDMETHODCALLTYPE WebPreferences::QueryInterface(REFIID riid, void** ppvObject) +{ + *ppvObject = 0; + if (IsEqualGUID(riid, IID_IUnknown)) + *ppvObject = static_cast(this); + else if (IsEqualGUID(riid, IID_IWebPreferences)) + *ppvObject = static_cast(this); + else if (IsEqualGUID(riid, IID_IWebPreferencesPrivate)) + *ppvObject = static_cast(this); + else if (IsEqualGUID(riid, IID_WebPreferences)) + *ppvObject = static_cast(this); + else + return E_NOINTERFACE; + + AddRef(); + return S_OK; +} + +ULONG STDMETHODCALLTYPE WebPreferences::AddRef(void) +{ + return ++m_refCount; +} + +ULONG STDMETHODCALLTYPE WebPreferences::Release(void) +{ + ULONG newRef = --m_refCount; + if (!newRef) + delete(this); + + return newRef; +} + +// IWebPreferences ------------------------------------------------------------ + +HRESULT STDMETHODCALLTYPE WebPreferences::standardPreferences( + /* [retval][out] */ IWebPreferences** standardPreferences) +{ + if (!standardPreferences) + return E_POINTER; + *standardPreferences = sharedStandardPreferences(); + (*standardPreferences)->AddRef(); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::initWithIdentifier( + /* [in] */ BSTR anIdentifier, + /* [retval][out] */ IWebPreferences** preferences) +{ + WebPreferences *instance = getInstanceForIdentifier(anIdentifier); + if (instance) { + *preferences = instance; + instance->AddRef(); + return S_OK; + } + + load(); + + *preferences = this; + AddRef(); + + if (anIdentifier) { + m_identifier = anIdentifier; + setInstance(this, m_identifier); + } + + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::identifier( + /* [retval][out] */ BSTR* ident) +{ + if (!ident) + return E_POINTER; + *ident = m_identifier ? SysAllocString(m_identifier) : 0; + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::standardFontFamily( + /* [retval][out] */ BSTR* family) +{ + *family = stringValueForKey(CFSTR(WebKitStandardFontPreferenceKey)); + return (*family) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setStandardFontFamily( + /* [in] */ BSTR family) +{ + setStringValue(CFSTR(WebKitStandardFontPreferenceKey), family); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::fixedFontFamily( + /* [retval][out] */ BSTR* family) +{ + *family = stringValueForKey(CFSTR(WebKitFixedFontPreferenceKey)); + return (*family) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFixedFontFamily( + /* [in] */ BSTR family) +{ + setStringValue(CFSTR(WebKitFixedFontPreferenceKey), family); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::serifFontFamily( + /* [retval][out] */ BSTR* fontFamily) +{ + *fontFamily = stringValueForKey(CFSTR(WebKitSerifFontPreferenceKey)); + return (*fontFamily) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setSerifFontFamily( + /* [in] */ BSTR family) +{ + setStringValue(CFSTR(WebKitSerifFontPreferenceKey), family); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::sansSerifFontFamily( + /* [retval][out] */ BSTR* family) +{ + *family = stringValueForKey(CFSTR(WebKitSansSerifFontPreferenceKey)); + return (*family) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setSansSerifFontFamily( + /* [in] */ BSTR family) +{ + setStringValue(CFSTR(WebKitSansSerifFontPreferenceKey), family); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::cursiveFontFamily( + /* [retval][out] */ BSTR* family) +{ + *family = stringValueForKey(CFSTR(WebKitCursiveFontPreferenceKey)); + return (*family) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setCursiveFontFamily( + /* [in] */ BSTR family) +{ + setStringValue(CFSTR(WebKitCursiveFontPreferenceKey), family); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::fantasyFontFamily( + /* [retval][out] */ BSTR* family) +{ + *family = stringValueForKey(CFSTR(WebKitFantasyFontPreferenceKey)); + return (*family) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFantasyFontFamily( + /* [in] */ BSTR family) +{ + setStringValue(CFSTR(WebKitFantasyFontPreferenceKey), family); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::defaultFontSize( + /* [retval][out] */ int* fontSize) +{ + *fontSize = integerValueForKey(CFSTR(WebKitDefaultFontSizePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setDefaultFontSize( + /* [in] */ int fontSize) +{ + setIntegerValue(CFSTR(WebKitDefaultFontSizePreferenceKey), fontSize); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::defaultFixedFontSize( + /* [retval][out] */ int* fontSize) +{ + *fontSize = integerValueForKey(CFSTR(WebKitDefaultFixedFontSizePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setDefaultFixedFontSize( + /* [in] */ int fontSize) +{ + setIntegerValue(CFSTR(WebKitDefaultFixedFontSizePreferenceKey), fontSize); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::minimumFontSize( + /* [retval][out] */ int* fontSize) +{ + *fontSize = integerValueForKey(CFSTR(WebKitMinimumFontSizePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setMinimumFontSize( + /* [in] */ int fontSize) +{ + setIntegerValue(CFSTR(WebKitMinimumFontSizePreferenceKey), fontSize); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::minimumLogicalFontSize( + /* [retval][out] */ int* fontSize) +{ + *fontSize = integerValueForKey(CFSTR(WebKitMinimumLogicalFontSizePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setMinimumLogicalFontSize( + /* [in] */ int fontSize) +{ + setIntegerValue(CFSTR(WebKitMinimumLogicalFontSizePreferenceKey), fontSize); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::defaultTextEncodingName( + /* [retval][out] */ BSTR* name) +{ + *name = stringValueForKey(CFSTR(WebKitDefaultTextEncodingNamePreferenceKey)); + return (*name) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setDefaultTextEncodingName( + /* [in] */ BSTR name) +{ + setStringValue(CFSTR(WebKitDefaultTextEncodingNamePreferenceKey), name); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::userStyleSheetEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitUserStyleSheetEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setUserStyleSheetEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitUserStyleSheetEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::userStyleSheetLocation( + /* [retval][out] */ BSTR* location) +{ + *location = stringValueForKey(CFSTR(WebKitUserStyleSheetLocationPreferenceKey)); + return (*location) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setUserStyleSheetLocation( + /* [in] */ BSTR location) +{ + setStringValue(CFSTR(WebKitUserStyleSheetLocationPreferenceKey), location); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::isJavaEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitJavaEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setJavaEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitJavaEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::isJavaScriptEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitJavaScriptEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setJavaScriptEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitJavaScriptEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::javaScriptCanOpenWindowsAutomatically( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setJavaScriptCanOpenWindowsAutomatically( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::arePlugInsEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitPluginsEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setPlugInsEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitPluginsEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::allowsAnimatedImages( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitAllowAnimatedImagesPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAllowsAnimatedImages( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitAllowAnimatedImagesPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::allowAnimatedImageLooping( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitAllowAnimatedImageLoopingPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAllowAnimatedImageLooping( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitAllowAnimatedImageLoopingPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setLoadsImagesAutomatically( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitDisplayImagesKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::loadsImagesAutomatically( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitDisplayImagesKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAutosaves( + /* [in] */ BOOL enabled) +{ + m_autoSaves = !!enabled; + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::autosaves( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = m_autoSaves ? TRUE : FALSE; + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setShouldPrintBackgrounds( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitShouldPrintBackgroundsPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::shouldPrintBackgrounds( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitShouldPrintBackgroundsPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setPrivateBrowsingEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitPrivateBrowsingEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::privateBrowsingEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitPrivateBrowsingEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setTabsToLinks( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitTabToLinksPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::tabsToLinks( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitTabToLinksPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setUsesPageCache( + /* [in] */ BOOL usesPageCache) +{ + setBoolValue(CFSTR(WebKitUsesPageCachePreferenceKey), usesPageCache); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::usesPageCache( + /* [retval][out] */ BOOL* usesPageCache) +{ + *usesPageCache = boolValueForKey(CFSTR(WebKitUsesPageCachePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::textAreasAreResizable( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitTextAreasAreResizablePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setTextAreasAreResizable( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitTextAreasAreResizablePreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::historyItemLimit(int* limit) +{ + *limit = integerValueForKey(CFSTR(WebKitHistoryItemLimitKey)); + return S_OK; +} + +HRESULT WebPreferences::setHistoryItemLimit(int limit) +{ + setIntegerValue(CFSTR(WebKitHistoryItemLimitKey), limit); + return S_OK; +} + +HRESULT WebPreferences::historyAgeInDaysLimit(int* limit) +{ + *limit = integerValueForKey(CFSTR(WebKitHistoryAgeInDaysLimitKey)); + return S_OK; +} + +HRESULT WebPreferences::setHistoryAgeInDaysLimit(int limit) +{ + setIntegerValue(CFSTR(WebKitHistoryAgeInDaysLimitKey), limit); + return S_OK; +} + +HRESULT WebPreferences::pageCacheSize(unsigned int* limit) +{ + *limit = integerValueForKey(CFSTR(WebKitPageCacheSizePreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::objectCacheSize(unsigned int* limit) +{ + *limit = integerValueForKey(CFSTR(WebKitObjectCacheSizePreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::iconDatabaseLocation( + /* [out] */ BSTR* location) +{ + *location = stringValueForKey(CFSTR(WebKitIconDatabaseLocationKey)); + return (*location) ? S_OK : E_FAIL; +} + +HRESULT WebPreferences::setIconDatabaseLocation( + /* [in] */ BSTR location) +{ + setStringValue(CFSTR(WebKitIconDatabaseLocationKey), location); + return S_OK; +} + +HRESULT WebPreferences::iconDatabaseEnabled(BOOL* enabled)//location) +{ + *enabled = boolValueForKey(CFSTR(WebKitIconDatabaseEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setIconDatabaseEnabled(BOOL enabled )//location) +{ + setBoolValue(CFSTR(WebKitIconDatabaseEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::fontSmoothing( + /* [retval][out] */ FontSmoothingType* smoothingType) +{ + *smoothingType = (FontSmoothingType) integerValueForKey(CFSTR(WebKitFontSmothingTypePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFontSmoothing( + /* [in] */ FontSmoothingType smoothingType) +{ + setIntegerValue(CFSTR(WebKitFontSmothingTypePreferenceKey), smoothingType); + wkSetFontSmoothingLevel((int)smoothingType); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::editableLinkBehavior( + /* [out, retval] */ WebKitEditableLinkBehavior* editableLinkBehavior) +{ + WebKitEditableLinkBehavior value = (WebKitEditableLinkBehavior) integerValueForKey(CFSTR(WebKitEditableLinkBehaviorPreferenceKey)); + switch (value) { + case WebKitEditableLinkDefaultBehavior: + case WebKitEditableLinkAlwaysLive: + case WebKitEditableLinkOnlyLiveWithShiftKey: + case WebKitEditableLinkLiveWhenNotFocused: + case WebKitEditableLinkNeverLive: + *editableLinkBehavior = value; + break; + default: // ensure that a valid result is returned + *editableLinkBehavior = WebKitEditableLinkDefaultBehavior; + break; + } + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setEditableLinkBehavior( + /* [in] */ WebKitEditableLinkBehavior behavior) +{ + setIntegerValue(CFSTR(WebKitEditableLinkBehaviorPreferenceKey), behavior); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::cookieStorageAcceptPolicy( + /* [retval][out] */ WebKitCookieStorageAcceptPolicy *acceptPolicy ) +{ + if (!acceptPolicy) + return E_POINTER; + + *acceptPolicy = (WebKitCookieStorageAcceptPolicy)integerValueForKey(CFSTR(WebKitCookieStorageAcceptPolicyPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setCookieStorageAcceptPolicy( + /* [in] */ WebKitCookieStorageAcceptPolicy acceptPolicy) +{ + setIntegerValue(CFSTR(WebKitCookieStorageAcceptPolicyPreferenceKey), acceptPolicy); + return S_OK; +} + + +HRESULT WebPreferences::continuousSpellCheckingEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebContinuousSpellCheckingEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setContinuousSpellCheckingEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebContinuousSpellCheckingEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::grammarCheckingEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebGrammarCheckingEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setGrammarCheckingEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebGrammarCheckingEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::allowContinuousSpellChecking(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(AllowContinuousSpellCheckingPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setAllowContinuousSpellChecking(BOOL enabled) +{ + setBoolValue(CFSTR(AllowContinuousSpellCheckingPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::isDOMPasteAllowed(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitDOMPasteAllowedPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setDOMPasteAllowed(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitDOMPasteAllowedPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::setDeveloperExtrasEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitDeveloperExtrasEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::developerExtrasEnabled(BOOL* enabled) +{ + if (!enabled) + return E_POINTER; + + *enabled = boolValueForKey(CFSTR(WebKitDeveloperExtrasEnabledPreferenceKey)); + return S_OK; +} + +bool WebPreferences::developerExtrasDisabledByOverride() +{ + return !!boolValueForKey(CFSTR(DisableWebKitDeveloperExtrasPreferenceKey)); +}