Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 03:15:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Backout a422b9ff0a9e (bug 591780 part 1) for causing 8% Ts regression on multiple platforms; a=khuey

Browse Source
This commit is contained in:
Ed Morley 2011-09-06 14:32:26 +01:00
parent daf47bf09d
commit 01f15294eb
26 changed files with 162 additions and 919 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
browser/base/content/nsContextMenu.js
View File

@ -321,8 +321,10 @@ nsContextMenu.prototype = {
var onMisspelling = InlineSpellCheckerUI.overMisspelling;
this.showItem("spell-check-enabled", canSpell);
this.showItem("spell-separator", canSpell || this.onEditableArea);
document.getElementById("spell-check-enabled")
.setAttribute("checked", canSpell && InlineSpellCheckerUI.enabled);
if (canSpell) {
document.getElementById("spell-check-enabled")
.setAttribute("checked", InlineSpellCheckerUI.enabled);
}
this.showItem("spell-add-to-dictionary", onMisspelling);

14
editor/composer/src/nsEditorSpellCheck.cpp
View File

@ -650,14 +650,6 @@ nsEditorSpellCheck::SetCurrentDictionary(const nsAString& aDictionary)
return mSpellChecker->SetCurrentDictionary(aDictionary);
}
NS_IMETHODIMP
nsEditorSpellCheck::GetSpellChecker(nsISpellChecker **aSpellChecker)
{
*aSpellChecker = mSpellChecker;
NS_IF_ADDREF(*aSpellChecker);
return NS_OK;
}
NS_IMETHODIMP
nsEditorSpellCheck::UninitSpellChecker()
{
@ -826,7 +818,11 @@ nsEditorSpellCheck::UpdateCurrentDictionary()
if (NS_FAILED(rv) || currentDictionary.IsEmpty()) {
rv = SetCurrentDictionary(NS_LITERAL_STRING("en-US"));
if (NS_FAILED(rv)) {
mSpellChecker->CheckCurrentDictionary();
nsTArray<nsString> dictList;
rv = mSpellChecker->GetDictionaryList(&dictList);
if (NS_SUCCEEDED(rv) && dictList.Length() > 0) {
SetCurrentDictionary(dictList[0]);
}
}
}
}

11
editor/idl/nsIEditorSpellCheck.idl
View File

@ -40,20 +40,11 @@
interface nsIEditor;
interface nsITextServicesFilter;
%{C++
#include "nsISpellChecker.h"
%}
[ptr] native nsISpellChecker(nsISpellChecker);
[scriptable, uuid(334946c3-0e93-4aac-b662-e1b56f95d68b)]
[scriptable, uuid(af84da62-588f-409f-847d-feecc991bd93)]
interface nsIEditorSpellCheck : nsISupports
{
/**
* Get the spell checker used by this editor.
*/
[noscript] readonly attribute nsISpellChecker spellChecker;
/**
* Returns true if we can enable spellchecking. If there are no available
* dictionaries, this will return false.

1
editor/libeditor/base/Makefile.in
View File

@ -94,5 +94,4 @@ INCLUDES += \
-I$(topsrcdir)/content/base/src \
-I$(topsrcdir)/content/events/src \
-I$(topsrcdir)/layout/style \
-I$(topsrcdir)/extensions/spellcheck/src \
$(NULL)

63
editor/libeditor/base/nsEditor.cpp
View File

@ -24,7 +24,6 @@
* Daniel Glazman <glazman@netscape.com>
* Masayuki Nakano <masayuki@d-toybox.com>
* Mats Palmgren <matspal@gmail.com>
* Jesper Kristensen <mail@jesperkristensen.dk>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
@ -49,11 +48,6 @@
#include "nsFocusManager.h"
#include "nsUnicharUtils.h"
#include "nsReadableUtils.h"
#include "nsIObserverService.h"
#include "mozilla/Services.h"
#include "mozISpellCheckingEngine.h"
#include "nsIEditorSpellCheck.h"
#include "mozInlineSpellChecker.h"
#include "nsIDOMText.h"
#include "nsIDOMElement.h"
@ -213,7 +207,6 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsEditor)
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
NS_INTERFACE_MAP_ENTRY(nsIEditorIMESupport)
NS_INTERFACE_MAP_ENTRY(nsIEditor)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEditor)
NS_INTERFACE_MAP_END
@ -307,13 +300,6 @@ nsEditor::PostCreate()
// update the UI with our state
NotifyDocumentListeners(eDocumentCreated);
NotifyDocumentListeners(eDocumentStateChanged);
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->AddObserver(this,
SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION,
PR_FALSE);
}
}
// update nsTextStateManager and caret if we have focus
@ -426,12 +412,6 @@ nsEditor::PreDestroy(PRBool aDestroyingFrames)
if (mDidPreDestroy)
return NS_OK;
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->RemoveObserver(this,
SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION);
}
// Let spellchecker clean up its observers etc. It is important not to
// actually free the spellchecker here, since the spellchecker could have
// caused flush notifications, which could have gotten here if a textbox
@ -1303,13 +1283,6 @@ NS_IMETHODIMP nsEditor::GetInlineSpellChecker(PRBool autoCreate,
return autoCreate ? NS_ERROR_NOT_AVAILABLE : NS_OK;
}
// We don't want to show the spell checking UI if there are no spell check dictionaries available.
PRBool canSpell = mozInlineSpellChecker::CanEnableInlineSpellChecking();
if (!canSpell) {
*aInlineSpellChecker = nsnull;
return NS_ERROR_FAILURE;
}
nsresult rv;
if (!mInlineSpellChecker && autoCreate) {
mInlineSpellChecker = do_CreateInstance(MOZ_INLINESPELLCHECKER_CONTRACTID, &rv);
@ -1328,49 +1301,17 @@ NS_IMETHODIMP nsEditor::GetInlineSpellChecker(PRBool autoCreate,
return NS_OK;
}
NS_IMETHODIMP nsEditor::Observe(nsISupports* aSubj, const char *aTopic,
const PRUnichar *aData)
{
NS_ASSERTION(!strcmp(aTopic,
SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION),
"Unexpected observer topic");
// When mozInlineSpellChecker::CanEnableInlineSpellChecking changes
SyncRealTimeSpell();
// When nsIEditorSpellCheck::GetCurrentDictionary changes
if (mInlineSpellChecker) {
// if the current dictionary is no longer available, find another one
nsCOMPtr<nsIEditorSpellCheck> editorSpellCheck;
mInlineSpellChecker->GetSpellChecker(getter_AddRefs(editorSpellCheck));
if (editorSpellCheck) {
nsCOMPtr<nsISpellChecker> spellChecker;
editorSpellCheck->GetSpellChecker(getter_AddRefs(spellChecker));
spellChecker->CheckCurrentDictionary();
}
// update the inline spell checker to reflect the new current dictionary
mInlineSpellChecker->SpellCheckRange(nsnull); // causes recheck
}
return NS_OK;
}
NS_IMETHODIMP nsEditor::SyncRealTimeSpell()
{
NS_TIME_FUNCTION;
PRBool enable = GetDesiredSpellCheckState();
// Initializes mInlineSpellChecker
nsCOMPtr<nsIInlineSpellChecker> spellChecker;
GetInlineSpellChecker(enable, getter_AddRefs(spellChecker));
if (mInlineSpellChecker) {
// We might have a mInlineSpellChecker even if there are no dictionaries
// available since we don't destroy the mInlineSpellChecker when the last
// dictionariy is removed, but in that case spellChecker is null
mInlineSpellChecker->SetEnableRealTimeSpell(enable && spellChecker);
if (spellChecker) {
spellChecker->SetEnableRealTimeSpell(enable);
}
return NS_OK;

5
editor/libeditor/base/nsEditor.h
View File

@ -66,7 +66,6 @@
#include "nsStubMutationObserver.h"
#include "nsIViewManager.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIObserver.h"
class nsIDOMCharacterData;
class nsIDOMRange;
@ -101,7 +100,6 @@ class nsIDOMNSEvent;
class nsEditor : public nsIEditor,
public nsIEditorIMESupport,
public nsSupportsWeakReference,
public nsIObserver,
public nsIPhonetic
{
public:
@ -155,9 +153,6 @@ public:
/* ------------ nsIEditorIMESupport methods -------------- */
NS_DECL_NSIEDITORIMESUPPORT
/* ------------ nsIObserver methods -------------- */
NS_DECL_NSIOBSERVER
// nsIPhonetic
NS_DECL_NSIPHONETIC

12
editor/txtsvc/public/nsISpellChecker.h
View File

@ -44,9 +44,9 @@
#define NS_SPELLCHECKER_CONTRACTID "@mozilla.org/spellchecker;1"
#define NS_ISPELLCHECKER_IID \
{ /* 27bff957-b486-40ae-9f5d-af0cdd211868 */ \
0x27bff957, 0xb486, 0x40ae, \
{ 0x9f, 0x5d, 0xaf, 0x0c, 0xdd, 0x21, 0x18, 0x68 } }
{ /* E75AC48C-E948-452E-8DB3-30FEE29FE3D2 */ \
0xe75ac48c, 0xe948, 0x452e, \
{ 0x8d, 0xb3, 0x30, 0xfe, 0xe2, 0x9f, 0xe3, 0xd2 } }
class nsITextServicesDocument;
class nsString;
@ -146,12 +146,6 @@ public:
* empty string, spellchecker will be disabled.
*/
NS_IMETHOD SetCurrentDictionary(const nsAString &aDictionary) = 0;
/**
* Call this on any change in installed dictionaries to ensure that the spell
* checker is not using a current dictionary which is no longer available.
*/
NS_IMETHOD CheckCurrentDictionary() = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsISpellChecker, NS_ISPELLCHECKER_IID)

4
extensions/spellcheck/Makefile.in
View File

@ -44,8 +44,4 @@ include $(DEPTH)/config/autoconf.mk
MODULE = spellchecker
DIRS = idl locales hunspell src
ifdef ENABLE_TESTS
DIRS += tests
endif
include $(topsrcdir)/config/rules.mk

2
extensions/spellcheck/hunspell/src/Makefile.in
View File

@ -71,8 +71,6 @@ endif
include $(topsrcdir)/config/rules.mk
INCLUDES += -I$(topsrcdir)/extensions/spellcheck/src
ifdef MOZ_NATIVE_HUNSPELL
CXXFLAGS += $(MOZ_HUNSPELL_CFLAGS)
endif

94
extensions/spellcheck/hunspell/src/mozHunspell.cpp
View File

@ -41,7 +41,6 @@
* Harri Pitkanen
* Andras Timar
* Tor Lillqvist
* Jesper Kristensen (mail@jesperkristensen.dk)
*
* 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
@ -71,8 +70,6 @@
#include "nsUnicharUtilCIID.h"
#include "nsUnicharUtils.h"
#include "nsCRT.h"
#include "mozInlineSpellChecker.h"
#include "mozilla/Services.h"
#include <stdlib.h>
#include "nsIMemoryReporter.h"
@ -125,7 +122,8 @@ mozHunspell::Init()
LoadDictionaryList();
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
nsCOMPtr<nsIObserverService> obs =
do_GetService("@mozilla.org/observer-service;1");
if (obs) {
obs->AddObserver(this, "profile-do-change", PR_TRUE);
}
@ -149,6 +147,9 @@ NS_IMETHODIMP mozHunspell::GetDictionary(PRUnichar **aDictionary)
{
NS_ENSURE_ARG_POINTER(aDictionary);
if (mDictionary.IsEmpty())
return NS_ERROR_NOT_INITIALIZED;
*aDictionary = ToNewUnicode(mDictionary);
return *aDictionary ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
@ -160,6 +161,9 @@ NS_IMETHODIMP mozHunspell::SetDictionary(const PRUnichar *aDictionary)
{
NS_ENSURE_ARG_POINTER(aDictionary);
if (mDictionary.Equals(aDictionary))
return NS_OK;
nsIFile* affFile = mDictionaries.GetWeak(nsDependentString(aDictionary));
if (!affFile)
return NS_ERROR_FILE_NOT_FOUND;
@ -174,9 +178,6 @@ NS_IMETHODIMP mozHunspell::SetDictionary(const PRUnichar *aDictionary)
nsresult rv = affFile->GetNativePath(affFileName);
NS_ENSURE_SUCCESS(rv, rv);
if (mAffixFileName.Equals(affFileName.get()))
return NS_OK;
dictFileName = affFileName;
PRInt32 dotPos = dictFileName.RFindChar('.');
if (dotPos == -1)
@ -190,7 +191,6 @@ NS_IMETHODIMP mozHunspell::SetDictionary(const PRUnichar *aDictionary)
delete mHunspell;
mDictionary = aDictionary;
mAffixFileName = affFileName;
mHunspell = new Hunspell(affFileName.get(),
dictFileName.get());
@ -222,13 +222,6 @@ NS_IMETHODIMP mozHunspell::SetDictionary(const PRUnichar *aDictionary)
else
mLanguage = Substring(mDictionary, 0, pos);
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(nsnull,
SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION,
nsnull);
}
return NS_OK;
}
@ -340,14 +333,6 @@ NS_IMETHODIMP mozHunspell::GetDictionaryList(PRUnichar ***aDictionaries,
return NS_OK;
}
static PLDHashOperator
FindFirstString(const nsAString& aString, nsIFile* aFile, void* aClosure)
{
nsAString *dic = (nsAString*) aClosure;
dic->Assign(aString);
return PL_DHASH_STOP;
}
void
mozHunspell::LoadDictionaryList()
{
@ -360,7 +345,6 @@ mozHunspell::LoadDictionaryList()
if (!dirSvc)
return;
// find built in dictionaries
nsCOMPtr<nsIFile> dictDir;
rv = dirSvc->Get(DICTIONARY_SEARCH_DIRECTORY,
NS_GET_IID(nsIFile), getter_AddRefs(dictDir));
@ -388,7 +372,6 @@ mozHunspell::LoadDictionaryList()
}
}
// find dictionaries from extensions requiring restart
nsCOMPtr<nsISimpleEnumerator> dictDirs;
rv = dirSvc->Get(DICTIONARY_SEARCH_DIRECTORY_LIST,
NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(dictDirs));
@ -404,51 +387,6 @@ mozHunspell::LoadDictionaryList()
if (dictDir)
LoadDictionariesFromDir(dictDir);
}
// find dictionaries from restartless extensions
for (PRUint32 i = 0; i < mDynamicDirectories.Count(); i++) {
LoadDictionariesFromDir(mDynamicDirectories[i]);
}
// Now we have finished updating the list of dictionaries, update the current
// dictionary and any editors which may use it.
mozInlineSpellChecker::UpdateCanEnableInlineSpellChecking();
// If the current dictionary has gone, try to replace it with another
// dictionary of the same language
if (!mDictionary.IsEmpty()) {
rv = SetDictionary(mDictionary.get());
if (NS_SUCCEEDED(rv))
return;
}
// If we didn't find a dictionary equal to the current dictionary or we had
// no current dictionary, just pick an arbitrary dictionary.
nsAutoString firstDictionary;
mDictionaries.EnumerateRead(FindFirstString, &firstDictionary);
if (!firstDictionary.IsEmpty()) {
rv = SetDictionary(firstDictionary.get());
if (NS_SUCCEEDED(rv))
return;
}
// If there are no dictionaries, set no current dictionary
if (!mDictionary.IsEmpty()) {
delete mHunspell;
mHunspell = nsnull;
mDictionary.AssignLiteral("");
mAffixFileName.AssignLiteral("");
mLanguage.AssignLiteral("");
mDecoder = nsnull;
mEncoder = nsnull;
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(nsnull,
SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION,
nsnull);
}
}
}
NS_IMETHODIMP
@ -604,19 +542,3 @@ mozHunspell::Observe(nsISupports* aSubj, const char *aTopic,
return NS_OK;
}
/* void addDirectory(in nsIFile dir); */
NS_IMETHODIMP mozHunspell::AddDirectory(nsIFile *aDir)
{
mDynamicDirectories.AppendObject(aDir);
LoadDictionaryList();
return NS_OK;
}
/* void removeDirectory(in nsIFile dir); */
NS_IMETHODIMP mozHunspell::RemoveDirectory(nsIFile *aDir)
{
mDynamicDirectories.RemoveObject(aDir);
LoadDictionaryList();
return NS_OK;
}

6
extensions/spellcheck/hunspell/src/mozHunspell.h
View File

@ -41,7 +41,6 @@
* Harri Pitkanen
* Andras Timar
* Tor Lillqvist
* Jesper Kristensen (mail@jesperkristensen.dk)
*
* 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
@ -65,7 +64,6 @@
#include "mozIPersonalDictionary.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsCOMArray.h"
#include "nsIObserver.h"
#include "nsIUnicodeEncoder.h"
#include "nsIUnicodeDecoder.h"
@ -111,10 +109,6 @@ protected:
nsInterfaceHashtable<nsStringHashKey, nsIFile> mDictionaries;
nsString mDictionary;
nsString mLanguage;
nsCString mAffixFileName;
// dynamic dirs used to search for dictionaries
nsCOMArray<nsIFile> mDynamicDirectories;
Hunspell *mHunspell;

33
extensions/spellcheck/idl/mozISpellCheckingEngine.idl
View File

@ -20,7 +20,6 @@
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Jesper Kristensen <mail@jesperkristensen.dk>
*
* 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
@ -41,7 +40,7 @@
interface nsIFile;
interface mozIPersonalDictionary;
[scriptable, uuid(8ba643a4-7ddc-4662-b976-7ec123843f10)]
[scriptable, uuid(6eb307d6-3567-481a-971a-feb666b8ae72)]
/**
* This interface represents a SpellChecker.
@ -50,22 +49,11 @@ interface mozIPersonalDictionary;
interface mozISpellCheckingEngine : nsISupports {
/**
* The name of the current dictionary
*
* Whenever getDictionaryList is not empty, this attribute contains a value
* from that list. Whenever getDictionaryList is empty, this attribute
* contains the empty string. Setting this attribute to a value not in
* getDictionaryList will throw NS_ERROR_FILE_NOT_FOUND.
*
* The spellcheck engine will send a notification with
* "spellcheck-dictionary-update" as topic when this changes.
*/
attribute wstring dictionary;
/**
* The language this spellchecker is using when checking
*
* The spellcheck engine will send a notification with
* "spellcheck-dictionary-update" as topic when this changes.
*/
readonly attribute wstring language;
@ -101,17 +89,11 @@ interface mozISpellCheckingEngine : nsISupports {
/**
* check a word
*
* The spellcheck engine will send a notification with
* "spellcheck-dictionary-update" as topic when this changes.
*/
boolean check(in wstring word);
/**
* get a list of suggestions for a misspelled word
*
* The spellcheck engine will send a notification with
* "spellcheck-dictionary-update" as topic when this changes.
*/
void suggest(in wstring word,[array, size_is(count)] out wstring suggestions, out PRUint32 count);
@ -119,22 +101,9 @@ interface mozISpellCheckingEngine : nsISupports {
* Load dictionaries from the specified dir
*/
void loadDictionariesFromDir(in nsIFile dir);
/**
* Add dictionaries from a directory to the spell checker
*/
void addDirectory(in nsIFile dir);
/**
* Remove dictionaries from a directory from the spell checker
*/
void removeDirectory(in nsIFile dir);
};
%{C++
#define DICTIONARY_SEARCH_DIRECTORY "DictD"
#define DICTIONARY_SEARCH_DIRECTORY_LIST "DictDL"
#define SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION \
"spellcheck-dictionary-update"
%}

12
extensions/spellcheck/src/mozInlineSpellChecker.cpp
View File

@ -600,9 +600,9 @@ nsresult mozInlineSpellChecker::Cleanup(PRBool aDestroyingFrames)
// do that and caches the result so we don't have to keep allocating those
// objects if there are no dictionaries or spellchecking.
//
// Whenever dictionaries are added or removed at runtime, this value must be
// updated before an observer notification is sent out about the change, to
// avoid editors getting a wrong cached result.
// This caching will prevent adding dictionaries at runtime if we start out
// with no dictionaries! Installing dictionaries as extensions will require
// a restart anyway, so it shouldn't be a problem.
PRBool // static
mozInlineSpellChecker::CanEnableInlineSpellChecking()
@ -625,12 +625,6 @@ mozInlineSpellChecker::CanEnableInlineSpellChecking()
return (gCanEnableSpellChecking == SpellCheck_Available);
}
void // static
mozInlineSpellChecker::UpdateCanEnableInlineSpellChecking()
{
gCanEnableSpellChecking = SpellCheck_Uninitialized;
}
// mozInlineSpellChecker::RegisterEventListeners
//
// The inline spell checker listens to mouse events and keyboard navigation+ // events.

4
extensions/spellcheck/src/mozInlineSpellChecker.h
View File

@ -229,10 +229,8 @@ public:
NS_DECL_NSIDOMEVENTLISTENER
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(mozInlineSpellChecker, nsIDOMEventListener)
// returns true if there are any spell checking dictionaries available
// returns true if it looks likely that we can enable real-time spell checking
static PRBool CanEnableInlineSpellChecking();
// update the cached value whenever the list of available dictionaries changes
static void UpdateCanEnableInlineSpellChecking();
nsresult Blur(nsIDOMEvent* aEvent);
nsresult MouseClick(nsIDOMEvent* aMouseEvent);

212
extensions/spellcheck/src/mozSpellChecker.cpp
View File

@ -18,7 +18,6 @@
* the Initial Developer. All Rights Reserved.
*
* Contributor(s): David Einstein Deinst@world.std.com
* Jesper Kristensen <mail@jesperkristensen.dk>
*
* 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
@ -78,6 +77,9 @@ mozSpellChecker::Init()
mPersonalDictionary = do_GetService("@mozilla.org/spellchecker/personaldictionary;1");
mSpellCheckingEngine = nsnull;
mCurrentEngineContractId = nsnull;
mDictionariesMap.Init();
InitSpellCheckDictionaryMap();
return NS_OK;
}
@ -305,45 +307,35 @@ mozSpellChecker::GetPersonalDictionary(nsTArray<nsString> *aWordList)
return NS_OK;
}
struct AppendNewStruct
{
nsTArray<nsString> *dictionaryList;
PRBool failed;
};
static PLDHashOperator
AppendNewString(const nsAString& aString, nsCString*, void* aClosure)
{
AppendNewStruct *ans = (AppendNewStruct*) aClosure;
if (!ans->dictionaryList->AppendElement(aString))
{
ans->failed = PR_TRUE;
return PL_DHASH_STOP;
}
return PL_DHASH_NEXT;
}
NS_IMETHODIMP
mozSpellChecker::GetDictionaryList(nsTArray<nsString> *aDictionaryList)
{
nsresult rv;
AppendNewStruct ans = {aDictionaryList, PR_FALSE};
// For catching duplicates
nsClassHashtable<nsStringHashKey, nsCString> dictionaries;
dictionaries.Init();
mDictionariesMap.EnumerateRead(AppendNewString, &ans);
nsCOMArray<mozISpellCheckingEngine> spellCheckingEngines;
rv = GetEngineList(&spellCheckingEngines);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 i = 0; i < spellCheckingEngines.Count(); i++) {
nsCOMPtr<mozISpellCheckingEngine> engine = spellCheckingEngines[i];
PRUint32 count = 0;
PRUnichar **words = NULL;
engine->GetDictionaryList(&words, &count);
for (PRUint32 k = 0; k < count; k++) {
nsAutoString dictName;
dictName.Assign(words[k]);
// Skip duplicate dictionaries. Only take the first one
// for each name.
if (dictionaries.Get(dictName, NULL))
continue;
dictionaries.Put(dictName, NULL);
if (!aDictionaryList->AppendElement(dictName)) {
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words);
return NS_ERROR_OUT_OF_MEMORY;
}
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words);
}
if (ans.failed)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
@ -364,87 +356,44 @@ mozSpellChecker::GetCurrentDictionary(nsAString &aDictionary)
NS_IMETHODIMP
mozSpellChecker::SetCurrentDictionary(const nsAString &aDictionary)
{
mSpellCheckingEngine = nsnull;
nsresult rv;
nsCString *contractId;
if (aDictionary.IsEmpty()) {
mCurrentEngineContractId = nsnull;
mSpellCheckingEngine = nsnull;
return NS_OK;
}
nsresult rv;
nsCOMArray<mozISpellCheckingEngine> spellCheckingEngines;
rv = GetEngineList(&spellCheckingEngines);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 i = 0; i < spellCheckingEngines.Count(); i++) {
nsCOMPtr<mozISpellCheckingEngine> engine = spellCheckingEngines[i];
rv = engine->SetDictionary(PromiseFlatString(aDictionary).get());
if (NS_SUCCEEDED(rv)) {
mSpellCheckingEngine = engine;
nsCOMPtr<mozIPersonalDictionary> personalDictionary = do_GetService("@mozilla.org/spellchecker/personaldictionary;1");
mSpellCheckingEngine->SetPersonalDictionary(personalDictionary.get());
return NS_OK;
}
if (!mDictionariesMap.Get(aDictionary, &contractId)){
NS_WARNING("Dictionary not found");
return NS_ERROR_NOT_AVAILABLE;
}
// We could not find any engine with the requested dictionary
return NS_ERROR_NOT_AVAILABLE;
}
if (!mCurrentEngineContractId || !mCurrentEngineContractId->Equals(*contractId)){
mSpellCheckingEngine = do_GetService(contractId->get(), &rv);
if (NS_FAILED(rv))
return rv;
NS_IMETHODIMP
mozSpellChecker::CheckCurrentDictionary()
{
// Check if the current engine has any dictionaries available. If not,
// the last dictionary has just been uninstalled, and we need to stop using
// the engine.
if (mSpellCheckingEngine) {
nsXPIDLString dictname;
mSpellCheckingEngine->GetDictionary(getter_Copies(dictname));
// We still have a dictionary, so keep using that.
if (!dictname.IsEmpty()) {
return NS_OK;
}
// Our current dictionary has gone, so we cannot use the engine anymore.
mSpellCheckingEngine = nsnull;
mCurrentEngineContractId = contractId;
}
// We have no current engine. Pick one.
nsresult rv;
nsCOMArray<mozISpellCheckingEngine> spellCheckingEngines;
rv = GetEngineList(&spellCheckingEngines);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 i = 0; i < spellCheckingEngines.Count(); i++) {
nsCOMPtr<mozISpellCheckingEngine> engine = spellCheckingEngines[i];
nsXPIDLString dictname;
engine->GetDictionary(getter_Copies(dictname));
if (!dictname.IsEmpty()) {
mSpellCheckingEngine = engine;
nsCOMPtr<mozIPersonalDictionary> personalDictionary = do_GetService("@mozilla.org/spellchecker/personaldictionary;1");
mSpellCheckingEngine->SetPersonalDictionary(personalDictionary.get());
nsXPIDLString language;
nsresult rv;
nsCOMPtr<mozISpellI18NManager> serv = do_GetService("@mozilla.org/spellchecker/i18nmanager;1", &rv);
if(serv && NS_SUCCEEDED(rv)) {
serv->GetUtil(language.get(), getter_AddRefs(mConverter));
}
return NS_OK;
}
nsresult res;
res = mSpellCheckingEngine->SetDictionary(PromiseFlatString(aDictionary).get());
if(NS_FAILED(res)){
NS_WARNING("Dictionary load failed");
return res;
}
// There are no dictionaries available
return NS_OK;
mSpellCheckingEngine->SetPersonalDictionary(mPersonalDictionary);
nsXPIDLString language;
nsCOMPtr<mozISpellI18NManager> serv(do_GetService("@mozilla.org/spellchecker/i18nmanager;1", &res));
if(serv && NS_SUCCEEDED(res)){
res = serv->GetUtil(language.get(),getter_AddRefs(mConverter));
}
return res;
}
nsresult
@ -528,10 +477,11 @@ mozSpellChecker::GetCurrentBlockIndex(nsITextServicesDocument *aDoc, PRInt32 *ou
}
nsresult
mozSpellChecker::GetEngineList(nsCOMArray<mozISpellCheckingEngine>* aSpellCheckingEngines)
mozSpellChecker::InitSpellCheckDictionaryMap()
{
nsresult rv;
PRBool hasMoreEngines;
nsTArray<nsCString> contractIds;
nsCOMPtr<nsICategoryManager> catMgr = do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
if (!catMgr)
@ -558,24 +508,52 @@ mozSpellChecker::GetEngineList(nsCOMArray<mozISpellCheckingEngine>* aSpellChecki
if (NS_FAILED(rv))
return rv;
contractIds.AppendElement(contractId);
}
contractIds.AppendElement(NS_LITERAL_CSTRING(DEFAULT_SPELL_CHECKER));
// Retrieve dictionaries from all available spellcheckers and
// fill mDictionariesMap hash (only the first dictionary with the
// each name is used).
for (PRUint32 i=0;i < contractIds.Length();i++){
PRUint32 count,k;
PRUnichar **words;
const nsCString& contractId = contractIds[i];
// Try to load spellchecker engine. Ignore errors silently
// except for the last one (HunSpell).
nsCOMPtr<mozISpellCheckingEngine> engine =
do_GetService(contractId.get(), &rv);
if (NS_SUCCEEDED(rv)) {
aSpellCheckingEngines->AppendObject(engine);
}
}
if (NS_FAILED(rv)){
// Fail if not succeeded to load HunSpell. Ignore errors
// for external spellcheck engines.
if (i==contractIds.Length()-1){
return rv;
}
// Try to load HunSpell spellchecker engine.
nsCOMPtr<mozISpellCheckingEngine> engine =
do_GetService(DEFAULT_SPELL_CHECKER, &rv);
if (NS_FAILED(rv)) {
// Fail if not succeeded to load HunSpell. Ignore errors
// for external spellcheck engines.
return rv;
continue;
}
engine->GetDictionaryList(&words,&count);
for(k=0;k<count;k++){
nsAutoString dictName;
dictName.Assign(words[k]);
nsCString dictCName = NS_ConvertUTF16toUTF8(dictName);
// Skip duplicate dictionaries. Only take the first one
// for each name.
if (mDictionariesMap.Get(dictName, NULL))
continue;
mDictionariesMap.Put(dictName, new nsCString(contractId));
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words);
}
aSpellCheckingEngines->AppendObject(engine);
return NS_OK;
}

10
extensions/spellcheck/src/mozSpellChecker.h
View File

@ -20,7 +20,6 @@
* the Initial Developer. All Rights Reserved.
*
* Contributor(s): David Einstein Deinst@world.std.com
* Jesper Kristensen <mail@jesperkristensen.dk>
*
* 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
@ -40,7 +39,6 @@
#define mozSpellChecker_h__
#include "nsCOMPtr.h"
#include "nsCOMArray.h"
#include "nsISpellChecker.h"
#include "nsString.h"
#include "nsITextServicesDocument.h"
@ -77,13 +75,17 @@ public:
NS_IMETHOD GetDictionaryList(nsTArray<nsString> *aDictionaryList);
NS_IMETHOD GetCurrentDictionary(nsAString &aDictionary);
NS_IMETHOD SetCurrentDictionary(const nsAString &aDictionary);
NS_IMETHOD CheckCurrentDictionary();
protected:
nsCOMPtr<mozISpellI18NUtil> mConverter;
nsCOMPtr<nsITextServicesDocument> mTsDoc;
nsCOMPtr<mozIPersonalDictionary> mPersonalDictionary;
// Hastable maps directory name to the spellchecker contract ID
nsClassHashtable<nsStringHashKey, nsCString> mDictionariesMap;
nsString mDictionaryName;
nsCString *mCurrentEngineContractId;
nsCOMPtr<mozISpellCheckingEngine> mSpellCheckingEngine;
PRBool mFromStart;
@ -91,6 +93,6 @@ protected:
nsresult GetCurrentBlockIndex(nsITextServicesDocument *aDoc, PRInt32 *outBlockIndex);
nsresult GetEngineList(nsCOMArray<mozISpellCheckingEngine> *aDictionaryList);
nsresult InitSpellCheckDictionaryMap();
};
#endif // mozSpellChecker_h__

34
extensions/spellcheck/src/mozSpellCheckerFactory.cpp
View File

@ -59,7 +59,39 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(mozHunspellDirProvider)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(mozSpellChecker, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(mozPersonalDictionary, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR(mozSpellI18NManager)
NS_GENERIC_FACTORY_CONSTRUCTOR(mozInlineSpellChecker)
// This special constructor for the inline spell checker asks the inline
// spell checker if we can create spell checking objects at all (ie, if there
// are any dictionaries loaded) before trying to create one. The static
// CanEnableInlineSpellChecking caches the value so this will be faster (we
// have to run this code for every edit box we create, as well as for every
// right click in those edit boxes).
static nsresult
mozInlineSpellCheckerConstructor(nsISupports *aOuter, REFNSIID aIID,
void **aResult)
{
if (! mozInlineSpellChecker::CanEnableInlineSpellChecking())
return NS_ERROR_FAILURE;
nsresult rv;
*aResult = NULL;
if (NULL != aOuter) {
rv = NS_ERROR_NO_AGGREGATION;
return rv;
}
mozInlineSpellChecker* inst = new mozInlineSpellChecker();
if (NULL == inst) {
rv = NS_ERROR_OUT_OF_MEMORY;
return rv;
}
NS_ADDREF(inst);
rv = inst->QueryInterface(aIID, aResult);
NS_RELEASE(inst);
return rv;
}
NS_DEFINE_NAMED_CID(MOZ_HUNSPELL_CID);
NS_DEFINE_NAMED_CID(HUNSPELLDIRPROVIDER_CID);

48
extensions/spellcheck/tests/Makefile.in
View File

@ -1,48 +0,0 @@
#
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla 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/MPL/
#
# 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.
#
# The Original Code is mozilla.org code.
#
# 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.
#
# Contributor(s):
#
# Alternatively, the contents of this file may be used under the terms of
# either of 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 MPL, 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 MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****
DEPTH = ../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
relativesrcdir = extensions/spellcheck/tests
include $(DEPTH)/config/autoconf.mk
DIRS = chrome
include $(topsrcdir)/config/rules.mk

54
extensions/spellcheck/tests/chrome/Makefile.in
View File

@ -1,54 +0,0 @@
#
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla 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/MPL/
#
# 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.
#
# The Original Code is mozilla.org code.
#
# 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.
#
# Contributor(s):
#
# Alternatively, the contents of this file may be used under the terms of
# either of 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 MPL, 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 MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****
DEPTH = ../../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
relativesrcdir = extensions/spellcheck/tests/chrome
include $(DEPTH)/config/autoconf.mk
DIRS = base map
include $(topsrcdir)/config/rules.mk
_TEST_FILES = test_add_remove_dictionaries.xul \
$(NULL)
libs:: $(_TEST_FILES)
$(INSTALL) $^ $(DEPTH)/_tests/testing/mochitest/chrome/$(relativesrcdir)

52
extensions/spellcheck/tests/chrome/base/Makefile.in
View File

@ -1,52 +0,0 @@
#
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla 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/MPL/
#
# 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.
#
# The Original Code is mozilla.org code.
#
# 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.
#
# Contributor(s):
#
# Alternatively, the contents of this file may be used under the terms of
# either of 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 MPL, 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 MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****
DEPTH = ../../../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
relativesrcdir = extensions/spellcheck/tests/chrome/base
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/rules.mk
_TEST_FILES = base_utf.dic \
base_utf.aff \
$(NULL)
libs:: $(_TEST_FILES)
$(INSTALL) $^ $(DEPTH)/_tests/testing/mochitest/chrome/$(relativesrcdir)

198
extensions/spellcheck/tests/chrome/base/base_utf.aff
View File

@ -1,198 +0,0 @@
# OpenOffice.org’s en_US.aff file
# with Unicode apostrophe: ’
SET UTF-8
TRY esianrtolcdugmphbyfvkwzESIANRTOLCDUGMPHBYFVKWZ'
MAXNGRAMSUGS 1
WORDCHARS .'’
PFX A Y 1
PFX A 0 re .
PFX I Y 1
PFX I 0 in .
PFX U Y 1
PFX U 0 un .
PFX C Y 1
PFX C 0 de .
PFX E Y 1
PFX E 0 dis .
PFX F Y 1
PFX F 0 con .
PFX K Y 1
PFX K 0 pro .
SFX V N 2
SFX V e ive e
SFX V 0 ive [^e]
SFX N Y 3
SFX N e ion e
SFX N y ication y
SFX N 0 en [^ey]
SFX X Y 3
SFX X e ions e
SFX X y ications y
SFX X 0 ens [^ey]
SFX H N 2
SFX H y ieth y
SFX H 0 th [^y]
SFX Y Y 1
SFX Y 0 ly .
SFX G Y 2
SFX G e ing e
SFX G 0 ing [^e]
SFX J Y 2
SFX J e ings e
SFX J 0 ings [^e]
SFX D Y 4
SFX D 0 d e
SFX D y ied [^aeiou]y
SFX D 0 ed [^ey]
SFX D 0 ed [aeiou]y
SFX T N 4
SFX T 0 st e
SFX T y iest [^aeiou]y
SFX T 0 est [aeiou]y
SFX T 0 est [^ey]
SFX R Y 4
SFX R 0 r e
SFX R y ier [^aeiou]y
SFX R 0 er [aeiou]y
SFX R 0 er [^ey]
SFX Z Y 4
SFX Z 0 rs e
SFX Z y iers [^aeiou]y
SFX Z 0 ers [aeiou]y
SFX Z 0 ers [^ey]
SFX S Y 4
SFX S y ies [^aeiou]y
SFX S 0 s [aeiou]y
SFX S 0 es [sxzh]
SFX S 0 s [^sxzhy]
SFX P Y 3
SFX P y iness [^aeiou]y
SFX P 0 ness [aeiou]y
SFX P 0 ness [^y]
SFX M Y 1
SFX M 0 's .
SFX B Y 3
SFX B 0 able [^aeiou]
SFX B 0 able ee
SFX B e able [^aeiou]e
SFX L Y 1
SFX L 0 ment .
REP 88
REP a ei
REP ei a
REP a ey
REP ey a
REP ai ie
REP ie ai
REP are air
REP are ear
REP are eir
REP air are
REP air ere
REP ere air
REP ere ear
REP ere eir
REP ear are
REP ear air
REP ear ere
REP eir are
REP eir ere
REP ch te
REP te ch
REP ch ti
REP ti ch
REP ch tu
REP tu ch
REP ch s
REP s ch
REP ch k
REP k ch
REP f ph
REP ph f
REP gh f
REP f gh
REP i igh
REP igh i
REP i uy
REP uy i
REP i ee
REP ee i
REP j di
REP di j
REP j gg
REP gg j
REP j ge
REP ge j
REP s ti
REP ti s
REP s ci
REP ci s
REP k cc
REP cc k
REP k qu
REP qu k
REP kw qu
REP o eau
REP eau o
REP o ew
REP ew o
REP oo ew
REP ew oo
REP ew ui
REP ui ew
REP oo ui
REP ui oo
REP ew u
REP u ew
REP oo u
REP u oo
REP u oe
REP oe u
REP u ieu
REP ieu u
REP ue ew
REP ew ue
REP uff ough
REP oo ieu
REP ieu oo
REP ier ear
REP ear ier
REP ear air
REP air ear
REP w qu
REP qu w
REP z ss
REP ss z
REP shun tion
REP shun sion
REP shun cion
McDonalds’sá/w
McDonald’sszá/g3) st:McDonald’s po:noun_prs is:TRANS
McDonald’sszal/g4) st:McDonald’s po:noun_prs is:INSTR
McDonald’ssal/w

29
extensions/spellcheck/tests/chrome/base/base_utf.dic
View File

@ -1,29 +0,0 @@
28
created/U
create/XKVNGADS
imply/GNSDX
natural/PUY
like/USPBY
convey/BDGS
look/GZRDS
text
hello
said
sawyer
NASA
rotten
day
tomorrow
seven
FAQ/SM
can’t
doesn’t
etc
won’t
lip
text
horrifying
speech
suggest
uncreate/V
Hunspell

52
extensions/spellcheck/tests/chrome/map/Makefile.in
View File

@ -1,52 +0,0 @@
#
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla 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/MPL/
#
# 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.
#
# The Original Code is mozilla.org code.
#
# 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.
#
# Contributor(s):
#
# Alternatively, the contents of this file may be used under the terms of
# either of 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 MPL, 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 MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****
DEPTH = ../../../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
relativesrcdir = extensions/spellcheck/tests/chrome/map
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/rules.mk
_TEST_FILES = maputf.dic \
maputf.aff \
$(NULL)
libs:: $(_TEST_FILES)
$(INSTALL) $^ $(DEPTH)/_tests/testing/mochitest/chrome/$(relativesrcdir)

11
extensions/spellcheck/tests/chrome/map/maputf.aff
View File

@ -1,11 +0,0 @@
# With MAP suggestion, Hunspell can add missing accents to a word.
SET UTF-8
# switch off ngram suggestion for testing
MAXNGRAMSUGS 0
MAP 3
MAP uúü
MAP öóo
MAP ß(ss)

4
extensions/spellcheck/tests/chrome/map/maputf.dic
View File

@ -1,4 +0,0 @@
3
Frühstück
tükörfúró
groß

110
extensions/spellcheck/tests/chrome/test_add_remove_dictionaries.xul
View File

@ -1,110 +0,0 @@
<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
<window title="Add and remove dictionaries test"
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
onload="RunTest();">
<title>Add and remove dictionaries test</title>
<script type="application/javascript"
src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
<script type="application/javascript">
<![CDATA[
SimpleTest.waitForExplicitFinish();
function getMisspelledWords(editor) {
return editor.selectionController.getSelection(Components.interfaces.nsISelectionController.SELECTION_SPELLCHECK).toString();
}
function getDictionaryList(editor) {
var spellchecker = editor.getInlineSpellChecker(true).spellChecker;
var o1 = {};
spellchecker.GetDictionaryList(o1, {});
return o1.value;
}
function getCurrentDictionary(editor) {
var spellchecker = editor.getInlineSpellChecker(true).spellChecker;
return spellchecker.GetCurrentDictionary();
}
function setCurrentDictionary(editor, dictionary) {
var spellchecker = editor.getInlineSpellChecker(true).spellChecker;
spellchecker.SetCurrentDictionary(dictionary);
}
function RunTest() {
var editor = document.getElementById('textbox').editor;
var dir = Components.classes["@mozilla.org/file/directory_service;1"].
getService(Components.interfaces.nsIProperties).
get("CurWorkD", Components.interfaces.nsIFile);
dir.append("chrome");
dir.append("extensions");
dir.append("spellcheck");
dir.append("tests");
dir.append("chrome");
var hunspell = Components
.classes["@mozilla.org/spellchecker/engine;1"]
.getService(Components.interfaces.mozISpellCheckingEngine);
// install base dictionary
var base = dir.clone();
base.append("base");
ok(base.exists());
hunspell.addDirectory(base);
// install map dictionary
var map = dir.clone();
map.append("map");
ok(map.exists());
hunspell.addDirectory(map);
// test that base and map dictionaries are available
var dicts = getDictionaryList(editor);
isnot(dicts.indexOf("base_utf"), -1, "base is available");
isnot(dicts.indexOf("maputf"), -1, "map is available");
// select base dictionary
setCurrentDictionary(editor, "base_utf");
SimpleTest.executeSoon(function() {
// test that base dictionary is in use
is(getMisspelledWords(editor), "Frühstück" + "qwertyu", "base misspellings");
is(getCurrentDictionary(editor), "base_utf", "current dictionary");
// select map dictionary
setCurrentDictionary(editor, "maputf");
SimpleTest.executeSoon(function() {
// test that map dictionary is in use
is(getMisspelledWords(editor), "created" + "imply" + "tomorrow" + "qwertyu", "map misspellings");
is(getCurrentDictionary(editor), "maputf", "current dictionary");
// uninstall map dictionary
hunspell.removeDirectory(map);
SimpleTest.executeSoon(function() {
// test that map dictionary is not in use
isnot(getMisspelledWords(editor), "created" + "imply" + "tomorrow" + "qwertyu", "map misspellings");
isnot(getCurrentDictionary(editor), "maputf", "current dictionary");
// test that base dictionary is available and map dictionary is unavailable
var dicts = getDictionaryList(editor);
isnot(dicts.indexOf("base_utf"), -1, "base is available");
is(dicts.indexOf("maputf"), -1, "map is unavailable");
// uninstall base dictionary
hunspell.removeDirectory(base);
SimpleTest.finish();
});
});
});
}
]]>
</script>
<textbox id="textbox" spellcheck="true" value="created imply Frühstück tomorrow qwertyu"/>
</window>