diff options
Diffstat (limited to 'Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/SpellerHFT.h')
| -rw-r--r-- | Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/SpellerHFT.h | 554 |
1 files changed, 554 insertions, 0 deletions
diff --git a/Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/SpellerHFT.h b/Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/SpellerHFT.h new file mode 100644 index 0000000..3cf2298 --- /dev/null +++ b/Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/SpellerHFT.h @@ -0,0 +1,554 @@ +/*********************************************************************
+
+ ADOBE SYSTEMS INCORPORATED
+ Copyright (C) 2000-2006 Adobe Systems Incorporated
+ All rights reserved.
+
+ NOTICE: Adobe permits you to use, modify, and distribute this file
+ in accordance with the terms of the Adobe license agreement
+ accompanying it. If you have received this file from a source other
+ than Adobe, then your use, modification, or distribution of it
+ requires the prior written permission of Adobe.
+
+ ---------------------------------------------------------------------
+
+ SpellerHFT.h
+
+ - HFT definitions for Acrobat Spell Check procedures.
+
+ - Acrobat Spelling plug-in provides a spell check API. To use the
+ Spelling HFT, a plug-in must include the header file SpellerHFT.h,
+ which includes Speller_Sel.h. The plug-in must also import the HFT
+ using ASExtensionMgrGetHFT and assign the HFT returned by this call
+ to a plug-in-defined global variable named gSpellerHFT.
+
+ The easiest way to do this is to use the Init_SpellingHFT macro
+ defined below.
+
+*********************************************************************/
+
+#ifndef _H_SpellerHFT
+#define _H_SpellerHFT
+
+
+#if __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+extern HFT gSpellerHFT;
+
+#include "Speller_Sel.h"
+
+
+/* Init_SpellingHFT
+** Use this to initialize and make the Spelling HFT functions available to your plug-in.
+*/
+#define Init_SpellerHFT ASExtensionMgrGetHFT(ASAtomFromString(SpellerHFT_NAME), SpellerHFT_LATEST_VERSION)
+
+
+/* =============================== */
+/* === Spelling check services === */
+/* =============================== */
+
+/*
+** ASBool SpellCheck(AVDoc avd, const char* textBuffer, ASInt16* dialogResult, ASBool bLastBuffer, char** dictionaryArray, ASInt32 dictionaryCount)
+**
+** Call the Spelling PI to have it check a text buffer and interact with the user.
+** This service will display the Spell Check dialog.
+**
+** avd - The current active document.
+** textBuffer - The input text buffer to be checked for spelling.
+** dialogResult - see enum SpellDialogResult for possible dialog results.
+** When dialogResult == kSpellDone, the client should terminate any domain search loops.
+** bLastBuffer - when this is true, the Spelling PI will close the dialog box when the end
+** of the inTextBuffer is reached. Otherwise, the dialog will stay open
+** expecting another SpellCheck call form the same spelling client.
+** dictionaryArray - optional char* array of dictionary names to be searched
+** dictionaryCount - count of dictionary names in dictionaryArray
+**
+** Returns: - a new text buffed if the user made any changes to the inTextBuffer,
+** otherwise NULL == no changes.
+*/
+#define SpellCheck (*((SpellCheck_SELPROTO)(gSpellerHFT[SpellCheck_SEL])))
+
+/*
+** ASBool SpellCheckRTF(AVDoc avd, void* vReserved, ASText astPlainText, char** dictionaryArray, ASInt32 dictionaryCount, SCRTFChangeProc pRTFchangeProc, void* vClientData);
+**
+** Check a text buffer and receive a call back for each change as the user interacts with the Spelling dialog.
+** This service will display the Spell Check dialog.
+**
+** This service is the same as SpellCheck (above) except a call back procedure is used to see each change to the
+** plain text input buffer as it occurs.
+**
+** avd - The current active document.
+** vReserved - reserved for future use.
+** astPlainText - The input plain text buffer to be checked for spelling.
+** dictionaryArray - optional char* array of dictionary names to be searched
+** dictionaryCount - count of dictionary names in dictionaryArray
+** pRTFchangeProc - change proc, called with each user change as it occurs, see SCRTFChangeProc in Speller_Sel.h
+** vClientData - client data, passed back to caller's change proc
+**
+** Returns: - SpellDialogResult.
+*/
+#define SpellCheckRTF (*((SpellCheckRTF_SELPROTO)(gSpellerHFT[SpellCheckRTF_SEL])))
+
+/*
+** ASBool SpellCheckText(const char* textbuffer, ASUns32* startOffset, ASUns32* endOffset, char** dictionaryArray, ASInt32 dictionaryCount)
+**
+** Check the spelling of the words in a text buffer starting at startOffset and ending at endOffset.
+** This service DOES NOT display the Spell Check dialog.
+** Returns true if all the words in the range were in the current dictionaries.
+** Returns false and the startOffset and endOffset of the first misspelled word found in the text buffer.
+**
+** textbuffer - Text buffer to be checked for spelling.
+** startOffset - Spelling PI returns the starting offset of the first misspelled word
+** in the textBuffer.
+** endOffset - Spelling PI returns the ending offset of the first misspelled word
+** in the textBuffer.
+** dictionaryArray - optional char* array of dictionary names to be searched
+** dictionaryCount - count of dictionary names in dictionaryArray
+**
+** Returns: - true if all words in the buffer are correct, false if a misspelled word was found.
+**
+** Notes: typically you would call this function when you want to silently check the spelling of a text buffer.
+** AcroForms uses this call to underline unknown words in a form text field.
+*/
+#define SpellCheckText (*((SpellCheckText_SELPROTO)(gSpellerHFT[SpellCheckText_SEL])))
+
+/*
+** ASBool SpellCheckWord(AVDoc avd, const char* cWord, char** dictionaryArray, ASInt32 dictionaryCount, char** alternativeArray, ASInt32 *alternativeCount)
+**
+** Call the Spelling PI to have it check a word.
+** This service DOES NOT display the Spell Check dialog.
+**
+** avd - The current active document.
+** textBuffer - Text buffer containing the word to be checked for spelling.
+** wordLength - length of text buffer.
+** dictionaryArray - optional char* array of dictionary names to be searched
+** dictionaryCount - count of dictionary names in dictionaryArray
+** alternativeArray - optional pointer for a char* array of alternative spellings of an incorrect word if any
+** NOTE: The caller is responsible for freeing this memory.
+** alternativeCount - count of alternative words in alternativeArray
+**
+** Returns: - true if the word in the buffer is correct, false if the word is unknown.
+**
+** Notes: typically you would call this function when you want to silently check the spelling of a word.
+*/
+#define SpellCheckWord (*((SpellCheckWord_SELPROTO)(gSpellerHFT[SpellCheckWord_SEL])))
+
+/*
+** ASBool SpellCountKnownWords(const char* textBuffer, ASInt32 dictionaryCount, char** dictionaryArray, ASInt32* counterArray)
+**
+** Call the Spelling PI to have it count the known words in a text buffer.
+** This service DOES NOT display the Spell Check dialog.
+**
+** textBuffer - Text buffer.
+** dictionaryCount - count of dictionary names in dictionaryArray and counters in counterArray
+** dictionaryArray - char* array of dictionary names to be searched
+** counterArray - array of counters. For each dictionary in dictionaryArray the Spelling PI
+** will increment the corresponding counter in this array when a word is found in that
+** dictionary.
+**
+** Returns: - index of dictionary with the highest correct count, -1 on error
+**
+** Notes: typically you would call this function when you want to attempt to discover the language of a text buffer.
+*/
+#define SpellCountKnownWords (*((SpellCountKnownWords_SELPROTO)(gSpellerHFT[SpellCountKnownWords_SEL])))
+
+/*
+** ASText SpellGetNextWord(ASText inBuffer, ASText outWord, ASInt32* nStart, ASInt32* nEnd, ASBool bFilter);
+**
+** Scan a text buffer and return the next word.
+**
+** inBuffer - text buffer.
+** nStart - character offset from start of buffer, if scan is successful the offset to the word start will be returned.
+** nEnd - character offset to terminate the scan set to zero to scan to the end of the text buffer,
+** If scan is successful the offset to the character past the last character of the word will be returned.
+** To scan for the next word, set nStart to this new offset.
+** bFilter - if true, apply standard ignore filters: single character words,
+** long words (48 characters max),
+** words that have digits,
+** all UPPERCASE,
+** Roman Numerals,
+** words that have non-roman unicode (CJK) characters
+**
+** Returns: - ASText with word if one was found.
+*/
+#define SpellGetNextWord (*((SpellGetNextWord_SELPROTO)(gSpellerHFT[SpellGetNextWord_SEL])))
+
+
+/* ======================================= */
+/* === Spelling client domain handling === */
+/* ======================================= */
+
+/*
+** ASBool SpellDomainNames(char** domainArray, ASInt32 *domainCount)
+**
+** Returns an array of the current domain names.
+**
+** domainArray - the spelling plugin will allocate and return a char* array of the domain names
+** NOTE: The caller is responsible for freeing this memory.
+** domainCount - the spelling plugin will return the count of names in the array
+**
+** Returns: - true if successful; domain names if any are listed in the output domainArray.
+*/
+#define SpellDomainNames (*((SpellDomainNames_SELPROTO)(gSpellerHFT[SpellDomainNames_SEL])))
+
+/*
+** ASBool SpellAddDomain(SpellCheckParamPtr scp)
+**
+** Add a spelling domain (search scope) to the Spell Check dialog Search menu.
+**
+** Returns: - true if successful; domain name was added to the menu, false otherwise.
+*/
+#define SpellAddDomain (*((SpellAddDomain_SELPROTO)(gSpellerHFT[SpellAddDomain_SEL])))
+
+/*
+** ASBool SpellRemoveDomain(SpellCheckParamPtr scp)
+**
+** Remove a spelling domain (search scope) from the Spell Check dialog Search menu.
+**
+** Returns: - true if successful; domain name was removed to the menu, false if the domain was not in the menu.
+*/
+#define SpellRemoveDomain (*((SpellRemoveDomain_SELPROTO)(gSpellerHFT[SpellRemoveDomain_SEL])))
+
+
+/* ==================================== */
+/* === Spelling dictionary handling === */
+/* ==================================== */
+
+/*
+** ASBool SpellDictionaryNames(char** dictionaryArray, ASInt32 *dictionaryCount)
+**
+** Returns an array of the currently available dictionary names.
+**
+** dictionaryArray - the spelling plugin will allocate and return a char* array of the dictionary names
+** NOTE: The caller is responsible for freeing this memory.
+** dictionaryCount - the spelling plugin will return the count of names in the array
+**
+** Returns: - true if successful; dictionary names if any are listed in the output dictionaryArray.
+*/
+#define SpellDictionaryNames (*((SpellDictionaryNames_SELPROTO)(gSpellerHFT[SpellDictionaryNames_SEL])))
+
+/** Add Dictionary *** OBSOLETE *** **/
+/*
+** ASBool SpellAddDictionary(char* cName, char *cFile, ASBool bShow)
+**
+** *** OBSOLETE ***
+**
+** Returns: - false.
+*/
+#define SpellAddDictionary (*((SpellAddDictionary_SELPROTO)(gSpellerHFT[SpellAddDictionary_SEL])))
+
+/*
+** ASBool SpellRemoveDictionary(char* cName)
+**
+** *** OBSOLETE ***
+**
+** Returns: - false.
+*/
+#define SpellRemoveDictionary (*((SpellRemoveDictionary_SELPROTO)(gSpellerHFT[SpellRemoveDictionary_SEL])))
+
+
+/* =========================================== */
+/* === Spelling custom dictionary handling === */
+/* =========================================== */
+
+/*
+** ASBool SpellCustomDictionaryOpen(ASText astName, ASPathName filePath, ASBool bShow)
+**
+** Open a custom dictionary file and add it to the list of available dictionaries.
+**
+** astName - the dictionary name to be used in the spelling dialogs and can be
+** used as the input parameter to the SpellCheck, SpellCheckText, and SpellCheckWord methods.
+** filePath - path of the dictionary file.
+** bShow - when bShow is true, Spelling will combine the cName parameter with "User: " and show
+** that name in all lists and menus. For example if cName is "Test", Spelling will
+** add "User: Test" to all lists and menus. When bShow is false, Spelling will not show
+** this custom dictionary in any lists or menus.
+**
+** Returns: - true if successful; the dictionary is now available for use.
+*/
+#define SpellCustomDictionaryOpen (*((SpellCustomDictionaryOpen_SELPROTO)(gSpellerHFT[SpellCustomDictionaryOpen_SEL])))
+
+/*
+** ASBool SpellCustomDictionaryCreate(ASText astName, ASPathName folderPath, ASBool bShow)
+**
+** Create a custom dictionary file and add it to the list of available dictionaries.
+**
+** astName - the dictionary name to be used in the spelling dialogs and can be
+** used as the input parameter to the SpellCheck, SpellCheckText, and SpellCheckWord methods.
+** astLanguage - one of the language codes returned by SpellLanguages.
+** bShow - when bShow is true, Spelling will combine the cName parameter with "User: " and show
+** that name in all lists and menus. For example if cName is "Test", Spelling will
+** add "User: Test" to all lists and menus. When bShow is false, Spelling will not show
+** this custom dictionary in any lists or menus.
+**
+** Returns: - true if successful; the dictionary is now available for use.
+*/
+#define SpellCustomDictionaryCreate (*((SpellCustomDictionaryCreate_SELPROTO)(gSpellerHFT[SpellCustomDictionaryCreate_SEL])))
+
+/*
+** ASBool SpellCustomDictionaryClose(ASText astName)
+**
+** This method will remove a custom dictionary that was opened via SpellCustomDictionaryOpen,
+** or created via SpellCustomDictionaryCreate.
+** cName must be the same name as was used with SpellCustomDictionaryOpen or SpellCustomDictionaryCreate.
+**
+** astName - the same dictionary name that was passed to SpellCustomDictionaryOpen or SpellCustomDictionaryCreate.
+**
+** Returns: - true if successful; the dictionary is no longer available for use.
+*/
+#define SpellCustomDictionaryClose (*((SpellCustomDictionaryClose_SELPROTO)(gSpellerHFT[SpellCustomDictionaryClose_SEL])))
+
+/*
+** ASBool SpellCustomDictionaryDelete(ASText astName)
+**
+** This method will delete a custom dictionary that was opened via SpellCustomDictionaryOpen,
+** or created via SpellCustomDictionaryCreate.
+** cName must be the same name as was used with SpellCustomDictionaryOpen or SpellCustomDictionaryCreate.
+** The delete will fail if the user does not have write permission to the dictionary file.
+**
+** astName - the same dictionary name that was passed to SpellCustomDictionaryOpen or SpellCustomDictionaryCreate.
+**
+** Returns: - true if successful; the dictionary is no longer available for use.
+*/
+#define SpellCustomDictionaryDelete (*((SpellCustomDictionaryDelete_SELPROTO)(gSpellerHFT[SpellCustomDictionaryDelete_SEL])))
+
+/*
+** ASBool SpellCustomDictionaryExport(ASText astName, ASPathName folderPath, void* reserved)
+**
+** Export an open custom dictionary file to the specified directory.
+** Export will fail if the user does not have read and write permissions to the dictionary folder.
+**
+** astName - the same dictionary name that was passed to SpellCustomDictionaryOpen or SpellCustomDictionaryCreate.
+** folderPath - path of the directory where the exported custom dictionary file will be created.
+** reserved - reserved for future use.
+**
+** Returns: - true if successful; the dictionary has been exported.
+*/
+#define SpellCustomDictionaryExport (*((SpellCustomDictionaryExport_SELPROTO)(gSpellerHFT[SpellCustomDictionaryExport_SEL])))
+
+
+/* =================================== */
+/* === Spelling Languages handling === */
+/* =================================== */
+
+/*
+** ASBool SpellLanguages(char*** languageArrayPtr, ASInt32 *languageCount)
+**
+** Returns an array of the currently available dictionaries as an array of ISO 639-2 and 3166 language codes.
+**
+** languageArray - the spelling plugin will allocate and return a char* array of the language codes
+** NOTE: The caller is responsible for freeing this memory.
+** languageCount - the spelling plugin will return the count of language codes in the array
+**
+** Returns: - true if successful; language codes if any are listed in the output languageArray.
+*/
+#define SpellLanguages (*((SpellLanguages_SELPROTO)(gSpellerHFT[SpellLanguages_SEL])))
+
+/*
+** ASBool SpellUserDictionaryOrder(char*** languageArrayPtr, ASInt32 *languageCount)
+**
+** Returns the user's dictionary search order from the Spelling Preference Panel as an array of ISO 639-2 and 3166 language codes.
+**
+** languageArray - the spelling plugin will allocate and return a char* array of the language codes.
+** The order in the list is the dictionary search order from the Spelling Preferences Panel.
+** NOTE: The caller is responsible for freeing this memory.
+** languageCount - the spelling plugin will return the count of codes in the array
+**
+** Returns: - true if successful; dictionary search order names are listed in the output languageArray.
+*/
+#define SpellUserLanguageOrder (*((SpellUserLanguageOrder_SELPROTO)(gSpellerHFT[SpellUserLanguageOrder_SEL])))
+
+/*
+** ASBool SpellGetDocLanguageOrder(AVDoc avd, char*** languageArrayPtr, ASInt32 *languageCount)
+**
+** Returns the document search order as an array of ISO 639-2 and 3166 language codes.
+** If this array is NULL then Spelling will use the order defined by the user in the Spelling Preference Panel.
+** Spelling will search the document order first followed by the users' order.
+**
+** avd - The document.
+** languageArray - the spelling plugin will allocate and return a char* array of the language codes.
+** The order in the list is the dictionary search order for this document.
+** NOTE: The caller is responsible for freeing this memory.
+** languageCount - the spelling plugin will return the count of codes in the array
+**
+** Returns: - true if successful; dictionary search order names are listed in the output languageArray.
+*/
+#define SpellGetDocLanguageOrder (*((SpellGetDocLanguageOrder_SELPROTO)(gSpellerHFT[SpellGetDocLanguageOrder_SEL])))
+
+/*
+** ASBool SpellSetDocLanguageOrder(AVDoc avd, char** languageArray, ASInt32 languageCount)
+**
+** Sets the document search order from an array of ISO 639-2 and 3166 language codes.
+** If this array is NULL then Spelling will use the order defined by the user in the Spelling Preference Panel.
+** Spelling will search the document order first followed by the users' order.
+**
+** avd - The document.
+** languageArray - This required parameter is a char* array of ordered language codes to be searched
+** before searching the list specified by the user in Spelling Preferences Panel.
+** languageCount - number of language codes in the languageArray.
+** Pass zero to clear the document order list.
+**
+** Returns: - true if successful; the dictionary search order for this document has been set.
+*/
+#define SpellSetDocLanguageOrder (*((SpellSetDocLanguageOrder_SELPROTO)(gSpellerHFT[SpellSetDocLanguageOrder_SEL])))
+
+
+/* =================================== */
+/* === Spelling user word handling === */
+/* =================================== */
+
+/*
+** ASBool SpellUserWords(char* cName, ASBool bAdded, char** wordArray, ASInt32 *wordCount)
+**
+** Returns an array of the currently available dictionary names.
+**
+** cName - the dictionary name. This must be on of the dictionaries from SpellDictionaryNames.
+** bAdded - if true, the list of added words will be returned. if false, the removed words list will be returned.
+** wordArray - the spelling plugin will allocate and return a char* array of the user added/removed words
+** NOTE: The caller is responsible for freeing this memory.
+** wordCount - the spelling plugin will return the count of words in the array
+**
+** Returns: - true if successful; the user words if any are listed in the output wordArray.
+*/
+#define SpellUserWords (*((SpellUserWords_SELPROTO)(gSpellerHFT[SpellUserWords_SEL])))
+
+/*
+** ASBool SpellAddWord(char* cName, char *cWord)
+**
+** Add a word to a dictionary.
+**
+** cName - the dictionary name. An array of the currently installed dictionaries can be
+** obtained using SpellDictionaryNames.
+** cWord - the word to be added to the cName dictionary.
+**
+** Note: Internally the Spelling plug-in will scan the user "Not-A-Word" dictionary and remove the word
+** if it is listed there. Otherwise, the word is added to the user dictionary.
+** The actual dictionary is not modifed.
+**
+** Returns: - true if successful; the dictionary is now available for use.
+*/
+#define SpellAddWord (*((SpellAddWord_SELPROTO)(gSpellerHFT[SpellAddWord_SEL])))
+
+/*
+** ASBool SpellRemoveWord(char* cName, char *cWord)
+**
+** Remove a word from a dictionary.
+**
+** cName - the dictionary name. An array of the currently installed dictionaries can be
+** obtained using SpellDictionaryNames.
+** cWord - the word to be removed to the cName dictionary.
+**
+** Note: Internally the Spelling plug-in will scan the user dictionary and remove the previously added
+** word if it is there. Otherwise the word will be added to the userŐs "Not-A-Word" dictionary.
+** The actual dictionary is not modifed.
+**
+** Returns: - true if successful; the dictionary is now available for use.
+*/
+#define SpellRemoveWord (*((SpellRemoveWord_SELPROTO)(gSpellerHFT[SpellRemoveWord_SEL])))
+
+/*
+** Ignore a word in a document.
+**
+** avd - The document.
+** cWord - the word to be ingored. The input string is PDText which is either a big-endian
+** Unicode string pre-pended with the bytes 0xFE 0xFF or a string with PDFDocEncoding.
+** In either case the string is expected to have the appropriate NULL-termination.
+**
+** Returns: - true if successful; the word will be ignored.
+*/
+#define SpellIgnoreAll (*((SpellIgnoreAll_SELPROTO)(gSpellerHFT[SpellIgnoreAll_SEL])))
+
+
+/* ======================================== */
+/* === Spelling dictionary search order === */
+/* ======================================== */
+
+/*
+** ASBool SpellUserDictionaryOrder(char** dictionaryArray, ASInt32 *dictionaryCount)
+**
+** Returns the user's dictionary search order from the Spelling Preference Panel.
+**
+** dictionaryArray - the spelling plugin will allocate and return a char* array of the dictionary names.
+** The order in the list is the dictionary search order from the Spelling Preferences Panel.
+** NOTE: The caller is responsible for freeing this memory.
+** dictionaryCount - the spelling plugin will return the count of names in the array
+**
+** Returns: - true if successful; dictionary search order names are listed in the output dictionaryArray.
+*/
+#define SpellUserDictionaryOrder (*((SpellUserDictionaryOrder_SELPROTO)(gSpellerHFT[SpellUserDictionaryOrder_SEL])))
+
+/*
+** ASBool SpellGetDocDictionaryOrder(AVDoc avd, char** dictionaryArray, ASInt32 *dictionaryCount)
+**
+** Returns the document search order if any. If this array is NULL then Spelling will use the order defined by the user
+** in the Spelling Preference Panel. Spelling will search the document order first followed by the users' order.
+**
+** avd - The document.
+** dictionaryArray - the spelling plugin will allocate and return a char* array of the dictionary names.
+** The order in the list is the dictionary search order for this document.
+** NOTE: The caller is responsible for freeing this memory.
+** dictionaryCount - the spelling plugin will return the count of names in the array
+**
+** Returns: - true if successful; dictionary search order names are listed in the output dictionaryArray.
+*/
+#define SpellGetDocDictionaryOrder (*((SpellGetDocDictionaryOrder_SELPROTO)(gSpellerHFT[SpellGetDocDictionaryOrder_SEL])))
+
+/*
+** ASBool SpellSetDocDictionaryOrder(AVDoc avd, char** dictionaryArray, ASInt32 dictionaryCount)
+**
+** Sets the document search order. If this array is NULL then Spelling will use the order defined by the user
+** in the Spelling Preference Panel. Spelling will search the document order first followed by the users' order.
+**
+** avd - The document.
+** dictionaryArray - This required parameter is a char* array of ordered dictionary names to be searched
+** before searching the list specified by the user in Spelling Preferences Panel.
+** dictionaryCount - number of dictionaries in the dictionaryArray.
+** Pass zero to clear the document order list.
+**
+** Returns: - true if successful; the dictionary search order for this document has been set.
+*/
+#define SpellSetDocDictionaryOrder (*((SpellSetDocDictionaryOrder_SELPROTO)(gSpellerHFT[SpellSetDocDictionaryOrder_SEL])))
+
+/** Call the Spelling plug-in to have it hyphenate a word.
+
+ <p>Sets the document search order. If this array is <code>NULL</code>, Spelling will use the order defined by the user
+ in the Spelling Preferences panel. Spelling will search the document order first followed by the users' order.</p>
+
+ @example
+ <p><code>HyphenationRecordPtr hyphenArray = NULL; </code></p>
+ <p><code>ASInt32 nHyphenations = SpellHyphenateWord(avd, cWord, <code>NULL</code>, 0, &hyphenArray); </code></p>
+ <p><code>for (ASInt32 nIndex = 0; nIndex < nHyphenations; nIndex++) { </code></p>
+ <p><code> HyphenationRecordPtr pHyphenRecord = hyphenArray[nIndex]; </code></p>
+ <p><code> if (pHyphenRecord->eType == kHyphenType_preferred) { </code></p>
+ <p><code> char* cLeft = ASTextGetEncodedCopy(pHyphenRecord->astLeft, ASHostEncoding(PDGetHostEncoding())); </code></p>
+ <p><code> char* cRight = ASTextGetEncodedCopy(pHyphenRecord->astRight, ASHostEncoding(PDGetHostEncoding())); </code></p>
+ <p><code> } </code></p>
+ <p><code>} // don't forget to free cLeft, cRight, each element of hyphenArray and the hyphenArray itself. </code></p>
+
+
+ @param avd IN The document.
+ @param astWord IN ASText containing the word to be hyphenated.
+ @param dictionaryArray IN An optional array of dictionary names to be used for hyphenation.
+ When provided, this dictionary list overrides the default dictionary list for this document.
+ Use SpellDictionaryNames() to obtain a list of the currently available dictionaries.
+ The dictionary names are PDText which is either a big-endian Unicode string prepended with the
+ bytes <code>0xFE 0xFF</code>, or a string with PDFDocEncoding. In either case the
+ string is expected to have the appropriate <code>NULL</code>-termination.
+ @param dictionaryCount IN A count of dictionary names in <code>dictionaryArray</code>
+ @param hyphenationArrayPtr IN An optional pointer for an an arrray of HyphenationRecord pointers, if any.
+ Note that the caller is responsible for freeing this memory.
+
+ @return The count of hyphenations for this word.
+
+
+#define SpellHyphenateWord (*((SpellHyphenateWord_SELPROTO)(gSpellerHFT[SpellHyphenateWord_SEL])))
+*/
+
+#if __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _H_SpellerHFT */
|