diff options
Diffstat (limited to 'WebKit/win/WebPreferences.cpp')
| -rw-r--r-- | WebKit/win/WebPreferences.cpp | 1132 |
1 files changed, 1132 insertions, 0 deletions
diff --git a/WebKit/win/WebPreferences.cpp b/WebKit/win/WebPreferences.cpp new file mode 100644 index 0000000..689efc0 --- /dev/null +++ b/WebKit/win/WebPreferences.cpp @@ -0,0 +1,1132 @@ +/* + * 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 "WebKit.h" +#include "WebKitDLL.h" +#include "WebPreferences.h" +#include "WebKit.h" + +#include "WebNotificationCenter.h" +#include "WebPreferenceKeysPrivate.h" + +#pragma warning( push, 0 ) +#include <WebCore/CString.h> +#include <WebCore/FileSystem.h> +#include <WebCore/Font.h> +#include <WebCore/PlatformString.h> +#include <WebCore/StringHash.h> +#include "WebLocalizableStrings.h" +#pragma warning( pop ) + +#include <CoreFoundation/CoreFoundation.h> +#include <CoreGraphics/CoreGraphics.h> +#include <shlobj.h> +#include <shfolder.h> +#include <tchar.h> +#include <WebKitSystemInterface/WebKitSystemInterface.h> +#include <wtf/HashMap.h> +#include <wtf/OwnArrayPtr.h> + +using namespace WebCore; + +static const String& oldPreferencesPath() +{ + static String path = pathByAppendingComponent(roamingUserSpecificStorageDirectory(), "WebKitPreferences.plist"); + return path; +} + +template<typename NumberType> struct CFNumberTraits { static const unsigned Type; }; +template<> struct CFNumberTraits<int> { static const unsigned Type = kCFNumberSInt32Type; }; +template<> struct CFNumberTraits<LONGLONG> { static const unsigned Type = kCFNumberLongLongType; }; +template<> struct CFNumberTraits<float> { static const unsigned Type = kCFNumberFloat32Type; }; + +template<typename NumberType> +static NumberType numberValueForPreferencesValue(CFPropertyListRef value) +{ + if (!value) + return 0; + + CFTypeID cfType = CFGetTypeID(value); + if (cfType == CFStringGetTypeID()) + return static_cast<NumberType>(CFStringGetIntValue(static_cast<CFStringRef>(value))); + else if (cfType == CFBooleanGetTypeID()) { + Boolean boolVal = CFBooleanGetValue(static_cast<CFBooleanRef>(value)); + return boolVal ? 1 : 0; + } else if (cfType == CFNumberGetTypeID()) { + NumberType val = 0; + CFNumberGetValue(static_cast<CFNumberRef>(value), CFNumberTraits<NumberType>::Type, &val); + return val; + } + + return 0; +} + +template<typename NumberType> +static RetainPtr<CFNumberRef> cfNumber(NumberType value) +{ + return RetainPtr<CFNumberRef>(AdoptCF, CFNumberCreate(0, CFNumberTraits<NumberType>::Type, &value)); +} + +static bool booleanValueForPreferencesValue(CFPropertyListRef value) +{ + return numberValueForPreferencesValue<int>(value); +} + +// WebPreferences ---------------------------------------------------------------- + +static CFDictionaryRef defaultSettings; + +static HashMap<WebCore::String, WebPreferences*> webPreferencesInstances; + +WebPreferences* WebPreferences::sharedStandardPreferences() +{ + static WebPreferences* standardPreferences; + if (!standardPreferences) { + standardPreferences = WebPreferences::createInstance(); + standardPreferences->setAutosaves(TRUE); + standardPreferences->load(); + } + + return standardPreferences; +} + +WebPreferences::WebPreferences() + : m_refCount(0) + , m_autoSaves(0) + , m_automaticallyDetectsCacheModel(true) + , m_numWebViews(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<IWebPreferences*>(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 (defaultSettings) + return; + + CFMutableDictionaryRef defaults = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + + 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()); + + 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<CFStringRef> 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(WebKitFontSmoothingTypePreferenceKey), 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); + + RetainPtr<CFStringRef> cacheModelRef(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), WebCacheModelDocumentViewer)); + CFDictionaryAddValue(defaults, CFSTR(WebKitCacheModelPreferenceKey), cacheModelRef.get()); + + CFDictionaryAddValue(defaults, CFSTR(WebKitAuthorAndUserStylesEnabledPreferenceKey), kCFBooleanTrue); + + defaultSettings = defaults; +} + +RetainPtr<CFPropertyListRef> WebPreferences::valueForKey(CFStringRef key) +{ + RetainPtr<CFPropertyListRef> value = CFDictionaryGetValue(m_privatePrefs.get(), key); + if (value) + return value; + + value.adoptCF(CFPreferencesCopyAppValue(key, kCFPreferencesCurrentApplication)); + if (value) + return value; + + return CFDictionaryGetValue(defaultSettings, key); +} + +void WebPreferences::setValueForKey(CFStringRef key, CFPropertyListRef value) +{ + CFDictionarySetValue(m_privatePrefs.get(), key, value); + if (m_autoSaves) { + CFPreferencesSetAppValue(key, value, kCFPreferencesCurrentApplication); + save(); + } +} + +BSTR WebPreferences::stringValueForKey(CFStringRef key) +{ + RetainPtr<CFPropertyListRef> value = valueForKey(key); + + if (!value || (CFGetTypeID(value.get()) != CFStringGetTypeID())) + return 0; + + CFStringRef str = static_cast<CFStringRef>(value.get()); + + 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) +{ + return numberValueForPreferencesValue<int>(valueForKey(key).get()); +} + +BOOL WebPreferences::boolValueForKey(CFStringRef key) +{ + return booleanValueForPreferencesValue(valueForKey(key).get()); +} + +float WebPreferences::floatValueForKey(CFStringRef key) +{ + return numberValueForPreferencesValue<float>(valueForKey(key).get()); +} + +LONGLONG WebPreferences::longlongValueForKey(CFStringRef key) +{ + return numberValueForPreferencesValue<LONGLONG>(valueForKey(key).get()); +} + +void WebPreferences::setStringValue(CFStringRef key, LPCTSTR value) +{ + BSTR val = stringValueForKey(key); + if (val && !_tcscmp(val, value)) + return; + SysFreeString(val); + + RetainPtr<CFStringRef> valueRef(AdoptCF, + CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(value), (CFIndex)_tcslen(value), kCFAllocatorMalloc)); + setValueForKey(key, valueRef.get()); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setIntegerValue(CFStringRef key, int value) +{ + if (integerValueForKey(key) == value) + return; + + setValueForKey(key, cfNumber(value).get()); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setBoolValue(CFStringRef key, BOOL value) +{ + if (boolValueForKey(key) == value) + return; + + setValueForKey(key, value ? kCFBooleanTrue : kCFBooleanFalse); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setLongLongValue(CFStringRef key, LONGLONG value) +{ + if (longlongValueForKey(key) == value) + return; + + setValueForKey(key, cfNumber(value).get()); + + postPreferencesChangesNotification(); +} + +BSTR WebPreferences::webPreferencesChangedNotification() +{ + static BSTR webPreferencesChangedNotification = SysAllocString(WebPreferencesChangedNotification); + return webPreferencesChangedNotification; +} + +BSTR WebPreferences::webPreferencesRemovedNotification() +{ + static BSTR webPreferencesRemovedNotification = SysAllocString(WebPreferencesRemovedNotification); + return webPreferencesRemovedNotification; +} + +void WebPreferences::save() +{ + CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication); +} + +void WebPreferences::load() +{ + initializeDefaultSettings(); + + m_privatePrefs.adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); + + migrateWebKitPreferencesToCFPreferences(); +} + +void WebPreferences::migrateWebKitPreferencesToCFPreferences() +{ + CFStringRef didMigrateKey = CFSTR(WebKitDidMigrateWebKitPreferencesToCFPreferencesPreferenceKey); + if (boolValueForKey(didMigrateKey)) + return; + bool oldValue = m_autoSaves; + m_autoSaves = true; + setBoolValue(didMigrateKey, TRUE); + m_autoSaves = oldValue; + + CString path = oldPreferencesPath().utf8(); + + RetainPtr<CFURLRef> urlRef(AdoptCF, CFURLCreateFromFileSystemRepresentation(0, reinterpret_cast<const UInt8*>(path.data()), path.length(), false)); + if (!urlRef) + return; + + RetainPtr<CFReadStreamRef> stream(AdoptCF, CFReadStreamCreateWithFile(0, urlRef.get())); + if (!stream) + return; + + if (!CFReadStreamOpen(stream.get())) + return; + + CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0; + RetainPtr<CFPropertyListRef> plist(AdoptCF, CFPropertyListCreateFromStream(0, stream.get(), 0, kCFPropertyListMutableContainersAndLeaves, &format, 0)); + CFReadStreamClose(stream.get()); + + if (!plist || CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) + return; + + copyWebKitPreferencesToCFPreferences(static_cast<CFDictionaryRef>(plist.get())); + + deleteFile(oldPreferencesPath()); +} + +void WebPreferences::copyWebKitPreferencesToCFPreferences(CFDictionaryRef dict) +{ + ASSERT_ARG(dict, dict); + + int count = CFDictionaryGetCount(dict); + if (count <= 0) + return; + + CFStringRef didRemoveDefaultsKey = CFSTR(WebKitDidMigrateDefaultSettingsFromSafari3BetaPreferenceKey); + bool omitDefaults = !booleanValueForPreferencesValue(CFDictionaryGetValue(dict, didRemoveDefaultsKey)); + + OwnArrayPtr<CFTypeRef> keys(new CFTypeRef[count]); + OwnArrayPtr<CFTypeRef> values(new CFTypeRef[count]); + CFDictionaryGetKeysAndValues(dict, keys.get(), values.get()); + + for (int i = 0; i < count; ++i) { + if (!keys[i] || !values[i] || CFGetTypeID(keys[i]) != CFStringGetTypeID()) + continue; + + if (omitDefaults) { + CFTypeRef defaultValue = CFDictionaryGetValue(defaultSettings, keys[i]); + if (defaultValue && CFEqual(defaultValue, values[i])) + continue; + } + + setValueForKey(static_cast<CFStringRef>(keys[i]), values[i]); + } +} + +// IUnknown ------------------------------------------------------------------- + +HRESULT STDMETHODCALLTYPE WebPreferences::QueryInterface(REFIID riid, void** ppvObject) +{ + *ppvObject = 0; + if (IsEqualGUID(riid, IID_IUnknown)) + *ppvObject = static_cast<IWebPreferences*>(this); + else if (IsEqualGUID(riid, IID_IWebPreferences)) + *ppvObject = static_cast<IWebPreferences*>(this); + else if (IsEqualGUID(riid, IID_IWebPreferencesPrivate)) + *ppvObject = static_cast<IWebPreferencesPrivate*>(this); + else if (IsEqualGUID(riid, CLSID_WebPreferences)) + *ppvObject = 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); + } + + this->postPreferencesChangesNotification(); + + 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::unused1() +{ + ASSERT_NOT_REACHED(); + return E_FAIL; +} + +HRESULT WebPreferences::unused2() +{ + ASSERT_NOT_REACHED(); + return E_FAIL; +} + +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(WebKitFontSmoothingTypePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFontSmoothing( + /* [in] */ FontSmoothingType smoothingType) +{ + setIntegerValue(CFSTR(WebKitFontSmoothingTypePreferenceKey), smoothingType); + if (smoothingType == FontSmoothingTypeWindows) + smoothingType = FontSmoothingTypeStandard; + 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::cacheModel(WebCacheModel* cacheModel) +{ + if (!cacheModel) + return E_POINTER; + + *cacheModel = (WebCacheModel)integerValueForKey(CFSTR(WebKitCacheModelPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setCacheModel(WebCacheModel cacheModel) +{ + setIntegerValue(CFSTR(WebKitCacheModelPreferenceKey), cacheModel); + 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)); +} + +HRESULT WebPreferences::setAutomaticallyDetectsCacheModel(BOOL automaticallyDetectsCacheModel) +{ + m_automaticallyDetectsCacheModel = !!automaticallyDetectsCacheModel; + return S_OK; +} + +HRESULT WebPreferences::automaticallyDetectsCacheModel(BOOL* automaticallyDetectsCacheModel) +{ + if (!automaticallyDetectsCacheModel) + return E_POINTER; + + *automaticallyDetectsCacheModel = m_automaticallyDetectsCacheModel; + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAuthorAndUserStylesEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitAuthorAndUserStylesEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::authorAndUserStylesEnabled(BOOL* enabled) +{ + if (!enabled) + return E_POINTER; + + *enabled = boolValueForKey(CFSTR(WebKitAuthorAndUserStylesEnabledPreferenceKey)); + return S_OK; +} + +void WebPreferences::willAddToWebView() +{ + ++m_numWebViews; +} + +void WebPreferences::didRemoveFromWebView() +{ + ASSERT(m_numWebViews); + if (--m_numWebViews == 0) { + IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal(); + nc->postNotificationName(webPreferencesRemovedNotification(), static_cast<IWebPreferences*>(this), 0); + } +} |