You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdelibs/tdeui/tdespell.h

569 lines
17 KiB

/* This file is part of the KDE libraries
Copyright (C) 1997 David Sweet <dsweet@kde.org>
Copyright (C) 2003 Zack Rusin <zack@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef __TDESPELL_H__
#define __TDESPELL_H__
#include "ksconfig.h"
#include <tqobject.h>
#include <tqstringlist.h>
#include <tqstring.h>
#include <tdelibs_export.h>
class TQTextCodec;
class KProcIO;
class TDEProcess;
class KSpellDlg;
/**
* %KDE Spellchecker
*
* A %KDE programmer's interface to International ISpell 3.1, ASpell,
* HSpell and ZPSpell..
* A static method, modalCheck() is provided for convenient
* access to the spellchecker.
*
* @author David Sweet <dsweet@kde.org>
* @see KSpellConfig, KSyntaxHighlighter
*/
class TDEUI_EXPORT KSpell : public TQObject
{
Q_OBJECT
public:
/**
* Possible states of the spell checker.
*
* @li @p Starting - After creation of KSpell.
* @li @p Running - After the ready signal has been emitted.
* @li @p Cleaning - After cleanUp() has been called.
* @li @p Finished - After cleanUp() has been completed.
*
* The following error states exist:
*
* @li @p Error - An error occurred in the @p Starting state.
* @li @p Crashed - An error occurred in the @p Running state.
**/
enum spellStatus { Starting = 0, Running, Cleaning, Finished, Error, Crashed, FinishedNoMisspellingsEncountered };
/**
* These are possible types of documents which the spell checker can check.
*
* @li @p Text - The default type, checks every word
* @li @p HTML - For HTML/SGML/XML documents, will skip the tags,
* @li @p TeX - For TeX/LaTeX documents, will skip commands,
* @li @p Nroff - For nroff/troff documents.
*
* Please note that not every option is supported on every type of
* checker (e.g. ASpell doesn't support Nroff). In case a type
* of a document is not supported the default Text option will
* be used.
*/
enum SpellerType { Text = 0, HTML, TeX, Nroff };
/**
* Starts the spellchecker.
*
* KSpell emits ready() when it has verified that
* ISpell/ASpell is working properly. Pass the name of a slot -- do not pass zero!
* Be sure to call cleanUp() when you are done with KSpell.
*
* If KSpell could not be started correctly, death() is emitted.
*
* @param parent Parent of KSpellConfig dialog..
* @param caption Caption of KSpellConfig dialog.
* @param receiver Receiver object for the ready(KSpell *) signal.
* @param slot Receiver's slot, will be connected to the ready(KSpell *) signal.
* @param kcs Configuration for KSpell.
* @param progressbar Indicates if progress bar should be shown.
* @param modal Indicates modal or non-modal dialog.
*/
KSpell(TQWidget *parent, const TQString &caption,
TQObject *receiver, const char *slot, KSpellConfig *kcs=0,
bool progressbar = true, bool modal = false);
/**
* Starts the spellchecker.
*
* KSpell emits ready() when it has verified that
* ISpell/ASpell is working properly. Pass the name of a slot -- do not pass zero!
* Be sure to call cleanUp() when you are done with KSpell.
*
* If KSpell could not be started correctly, death() is emitted.
*
* @param parent Parent of KSpellConfig dialog..
* @param caption Caption of KSpellConfig dialog.
* @param receiver Receiver object for the ready(KSpell *) signal.
* @param slot Receiver's slot, will be connected to the ready(KSpell *) signal.
* @param kcs Configuration for KSpell.
* @param progressbar Indicates if progress bar should be shown.
* @param modal Indicates modal or non-modal dialog.
* @param type Type of the document to check
*/
KSpell(TQWidget *parent, const TQString &caption,
TQObject *receiver, const char *slot, KSpellConfig *kcs,
bool progressbar, bool modal, SpellerType type);
/**
* Returns the status of KSpell.
*
* @see spellStatus()
*/
spellStatus status() const { return m_status; }
/**
* Cleans up ISpell.
*
* Write out the personal dictionary and close ISpell's
* stdin. A death() signal will be emitted when the cleanup is
* complete, but this method will return immediately.
*/
virtual void cleanUp ();
/**
* Sets the auto-delete flag. If this is set, the KSpell object
* is automatically deleted after emitting death().
*/
void setAutoDelete(bool _autoDelete) { autoDelete = _autoDelete; }
/**
* Spellchecks a buffer of many words in plain text
* format.
*
* The @p _buffer is not modified. The signal done() will be
* sent when check() is finished and the argument will be a
* spell-corrected version of @p _buffer.
*
* The spell check may be stopped by the user before the entire buffer
* has been checked. You can check lastPosition() to see how far
* in @p _buffer check() reached before stopping.
*/
virtual bool check (const TQString &_buffer, bool usedialog = true);
/**
* Returns the position (when using check()) or word
* number (when using checkList()) of
* the last word checked.
*/
int lastPosition() const
{ return lastpos;}
/**
* Spellchecks a list of words.
*
* checkList() is more flexible than check(). You could parse
* any type
* of document (HTML, TeX, etc.) into a list of spell-checkable words
* and send the list to checkList(). Sending a marked-up document
* to check() would result in the mark-up tags being
* spell checked.
*/
virtual bool checkList (TQStringList *_wordlist, bool usedialog = true);
/**
* Spellchecks a single word.
*
* checkWord() is the most flexible function. Some applications
* might need this flexibility but will sacrifice speed when
* checking large numbers of words. Consider checkList() for
* checking many words.
*
* Use this method for implementing "online" spellchecking (i.e.,
* spellcheck as-you-type).
*
* checkWord() returns @p false if @p buffer is not a single word (e.g.
* if it contains white space), otherwise it returns @p true;
*
* If @p usedialog is set to @p true, KSpell will open the standard
* dialog if the word is not found. The dialog results can be queried
* by using dlgResult() and replacement().
*
* The signal corrected() is emitted when the check is
* complete. You can look at suggestions() to see what the
* suggested replacements were.
*/
virtual bool checkWord (const TQString &_buffer, bool usedialog = false);
bool checkWord( const TQString & buffer, bool _usedialog, bool suggest );
/**
* Hides the dialog box.
*
* You'll need to do this when you are done with checkWord();
*/
void hide ();
/**
* Returns list of suggested word replacements.
*
* After calling checkWord() (an in response to
* a misspelled() signal you can
* use this to get the list of
* suggestions (if any were available).
*/
TQStringList suggestions () const { return sugg; }
/**
* Gets the result code of the dialog box.
*
* After calling checkWord, you can use this to get the dialog box's
* result code.
* The possible
* values are (from tdespelldlg.h):
* @li KS_CANCEL
* @li KS_REPLACE
* @li KS_REPLACEALL
* @li KS_IGNORE
* @li KS_IGNOREALL
* @li KS_ADD
* @li KS_STOP
*
*/
int dlgResult () const
{ return dlgresult; }
/**
* Moves the dialog.
*
* If the dialog is not currently visible, it will
* be placed at this position when it becomes visible.
* Use this to get the dialog out of the way of a highlighted
* misspelled word in a document.
*/
void moveDlg (int x, int y);
/**
* Returns the height of the dialog box.
*/
int heightDlg () const;
/**
* Returns the width of the dialog box.
*/
int widthDlg () const;
/**
* Returns the partially spellchecked buffer.
*
* You might want the full buffer in its partially-checked state.
*/
TQString intermediateBuffer () const {return newbuffer;}
/**
* Tells ISpell/ASpell to ignore this word for the life of this KSpell instance.
*
* @return false if @p word is not a word or there was an error
* communicating with ISpell/ASpell.
*/
virtual bool ignore (const TQString & word);
/**
* Adds a word to the user's personal dictionary.
*
* @return false if @p word
* is not a word or there was an error communicating with ISpell/ASpell.
*/
virtual bool addPersonal (const TQString & word);
/**
* @return the KSpellConfig object being used by this KSpell instance.
*/
KSpellConfig ksConfig () const;
/**
* Sets the resolution (in percent) of the progress() signals.
*
* E.g. setProgressResolution (10) instructs KSpell to send progress
* signals (at most) every 10% (10%, 20%, 30%...).
* The default is 10%.
*/
void setProgressResolution (unsigned int res);
/**
* The destructor instructs ISpell/ASpell to write out the personal
* dictionary and then terminates ISpell/ASpell.
*/
virtual ~KSpell();
/**
* @deprecated
* Performs a synchronous spellcheck.
*
* This method does not return until spellchecking is done or canceled.
* Your application's GUI will still be updated, however.
*
*/
static int modalCheck( TQString& text ) KDE_DEPRECATED;
/**
* Performs a synchronous spellcheck.
*
* This method does not return until spellchecking is done or canceled.
* Your application's GUI will still be updated, however.
*
* This overloaded method uses the spell-check configuration passed as parameter.
*/
static int modalCheck( TQString& text, KSpellConfig * kcs );
/**
* Call setIgnoreUpperWords(true) to tell the spell-checker to ignore
* words that are completely uppercase. They are spell-checked by default.
*/
void setIgnoreUpperWords(bool b);
/**
* Call setIgnoreTitleCase(true) to tell the spell-checker to ignore
* words with a 'title' case, i.e. starting with an uppercase letter.
* They are spell-checked by default.
*/
void setIgnoreTitleCase(bool b);
signals:
/**
* Emitted whenever a misspelled word is found by check() or
* by checkWord().
* If it is emitted by checkWord(), @p pos=0.
* If it is emitted by check(), then @p pos indicates the position of
* the misspelled word in the (original) @p _buffer.
* (The first position is zero.)
* If it is emitted by checkList(), @p pos is the index to
* the misspelled
* word in the TQStringList passed to checkList().
* Note, that @p originalword can be only a word part, if it's
* word with hyphens.
*
* These are called _before_ the dialog is opened, so that the
* calling program's GUI may be updated. (e.g. the misspelled word may
* be highlighted).
*/
void misspelling (const TQString & originalword, const TQStringList & suggestions,
unsigned int pos);
/**
* Emitted after the "Replace" or "Replace All" buttons of the dialog
* was pressed, or if the word was
* corrected without calling the dialog (i.e., the user previously chose
* "Replace All" for this word).
*
* Results from the dialog may be checked with dlgResult()
* and replacement().
*
* Note, that when using checkList() this signal can occur
* more then once with same list position, when checking a word with
* hyphens. In this case @p originalword is the last replacement.
*
* @see check()
*/
void corrected (const TQString & originalword, const TQString & newword, unsigned int pos);
/**
* Emitted when the user pressed "Ignore All" in the dialog.
* This could be used to make an application or file specific
* user dictionary.
*
*/
void ignoreall (const TQString & originalword);
/**
* Emitted when the user pressed "Ignore" in the dialog.
* Don't know if this could be useful.
*
*/
void ignoreword (const TQString & originalword);
/**
* Emitted when the user pressed "Add" in the dialog.
* This could be used to make an external user dictionary
* independent of the ISpell personal dictionary.
*
*/
void addword (const TQString & originalword);
/**
* Emitted when the user pressed "ReplaceAll" in the dialog.
*/
void replaceall( const TQString & origword , const TQString &replacement );
/**
* Emitted after KSpell has verified that ISpell/ASpell is running
* and working properly.
*/
void ready(KSpell *);
/**
* Emitted during a check().
* @p i is between 1 and 100.
*/
void progress (unsigned int i);
/**
* Emitted when check() is done.
*
* Be sure to copy the results of @p buffer if you need them.
* You can only rely
* on the contents of buffer for the life of the slot which was signaled
* by done().
*/
void done (const TQString &buffer);
/**
* Emitted when checkList() is done.
*
* If the argument is
* @p true, then you should update your text from the
* wordlist, otherwise not.
*/
void done(bool);
/**
* Emitted on terminal errors and after clean up.
*
* You can delete the KSpell object in this signal.
*
* You can check status() to see what caused the death:
* @li @p Error - KSpell could not start.
* @li @p Crashed - KSpell encountered an unexpected error during execution.
* @li @p Finished - Clean up finished.
*/
void death( );
protected slots:
/* All of those signals from KProcIO get sent here. */
void KSpell2 (KProcIO *);
void checkWord2 (KProcIO *);
void checkWord3 ();
void check2 (KProcIO *);
void checkList2 ();
void checkList3a (KProcIO *);
void checkListReplaceCurrent ();
void checkList4 ();
void dialog2 (int dlgresult);
void check3 ();
void suggestWord( KProcIO * );
void slotStopCancel (int);
void ispellExit (TDEProcess *);
void emitDeath();
void ispellErrors (TDEProcess *, char *, int);
void checkNext();
private slots:
/**
* Used for modalCheck().
*/
void slotModalReady();
/**
* Used for modalCheck().
*/
void slotModalDone( const TQString & );
/**
* Used for modalCheck().
*/
void slotSpellCheckerCorrected( const TQString & oldText, const TQString & newText, unsigned int );
/**
* Used for modalCheck().
*/
void slotModalSpellCheckerFinished( );
signals:
void dialog3 ();
protected:
KProcIO *proc;
TQWidget *parent;
KSpellConfig *ksconfig;
KSpellDlg *ksdlg;
TQStringList *wordlist;
TQStringList::Iterator wlIt;
TQStringList ignorelist;
TQStringList replacelist;
TQStringList sugg;
TQTextCodec* codec;
spellStatus m_status;
bool usedialog;
bool texmode;
bool dlgon;
bool personaldict;
bool dialogwillprocess;
bool progressbar;
bool dialogsetup;
bool autoDelete;
TQString caption;
TQString orig;
TQString origbuffer;
TQString newbuffer;
TQString cwword;
TQString dlgorigword;
TQString dlgreplacement;
TQString dialog3slot;
int dlgresult;
int trystart;
int maxtrystart;
int lastpos;
unsigned int totalpos;
unsigned int lastline;
unsigned int posinline;
unsigned int lastlastline;
unsigned int offset;
unsigned int progres;
unsigned int curprog;
/**
* Used for modalCheck.
*/
bool modaldlg;
static TQString modaltext;
static int modalreturn;
static TQWidget* modalWidgetHack;
int parseOneResponse (const TQString &_buffer, TQString &word, TQStringList &sugg);
TQString funnyWord (const TQString & word);
void dialog (const TQString & word, TQStringList & sugg, const char* _slot);
TQString replacement () const
{ return dlgreplacement; }
void setUpDialog ( bool reallyusedialogbox = true);
void emitProgress ();
bool cleanFputs (const TQString & s, bool appendCR=true);
bool cleanFputsWord (const TQString & s, bool appendCR=true);
void startIspell();
bool writePersonalDictionary();
void initialize( TQWidget *_parent, const TQString &_caption,
TQObject *obj, const char *slot, KSpellConfig *_ksc,
bool _progressbar, bool _modal, SpellerType type );
private:
class KSpellPrivate;
KSpellPrivate *d;
};
#endif