Actually move the kde files that were renamed in the last commit

1 files changed, 1577 insertions, 0 deletions

diff --git a/tdeui/kspell.cpp b/tdeui/kspell.cpp
new file mode 100644
index 000000000..3a13e6e3d
--- /dev/null
+++ b/tdeui/kspell.cpp
@@ -0,0 +1,1577 @@
+/* This file is part of the KDE libraries
+   Copyright (C) 1997 David Sweet <dsweet@kde.org>
+   Copyright (C) 2000-2001 Wolfram Diestel <wolfram@steloj.de>
+   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.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <stdlib.h> // atoi
+
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+#include <tqregexp.h>
+#include <tqtextcodec.h>
+#include <tqtimer.h>
+
+#include <kapplication.h>
+#include <kmessagebox.h>
+#include <kdebug.h>
+#include <klocale.h>
+#include "kspell.h"
+#include "kspelldlg.h"
+#include <kwin.h>
+#include <kprocio.h>
+
+#define MAXLINELENGTH 10000
+#undef IGNORE //fix possible conflict
+
+enum {
+  GOOD=     0,
+  IGNORE=   1,
+  REPLACE=  2,
+  MISTAKE=  3
+};
+
+enum checkMethod { Method1 = 0, Method2 };
+
+struct BufferedWord
+{
+  checkMethod method;
+  TQString word;
+  bool useDialog;
+  bool suggest;
+};
+
+class KSpell::KSpellPrivate
+{
+public:
+  bool endOfResponse;
+  bool m_bIgnoreUpperWords;
+  bool m_bIgnoreTitleCase;
+  bool m_bNoMisspellingsEncountered;
+  SpellerType type;
+  KSpell* suggestSpell;
+  bool checking;
+  TQValueList<BufferedWord> unchecked;
+  TQTimer *checkNextTimer;
+  bool aspellV6;
+};
+
+//TODO
+//Parse stderr output
+//e.g. -- invalid dictionary name
+
+/*
+  Things to put in KSpellConfigDlg:
+    make root/affix combinations that aren't in the dictionary (-m)
+    don't generate any affix/root combinations (-P)
+    Report  run-together  words   with   missing blanks as spelling errors.  (-B)
+    default dictionary (-d [dictionary])
+    personal dictionary (-p [dictionary])
+    path to ispell -- NO: ispell should be in $PATH
+    */
+
+
+//  Connects a slot to KProcIO's output signal
+#define OUTPUT(x) (connect (proc, TQT_SIGNAL (readReady(KProcIO *)), this, TQT_SLOT (x(KProcIO *))))
+
+// Disconnect a slot from...
+#define NOOUTPUT(x) (disconnect (proc, TQT_SIGNAL (readReady(KProcIO *)), this, TQT_SLOT (x(KProcIO *))))
+
+
+
+KSpell::KSpell( TQWidget *_parent, const TQString &_caption,
+		TQObject *obj, const char *slot, KSpellConfig *_ksc,
+		bool _progressbar, bool _modal )
+{
+  initialize( _parent, _caption, obj, slot, _ksc,
+              _progressbar, _modal, Text );
+}
+
+KSpell::KSpell( TQWidget *_parent, const TQString &_caption,
+		TQObject *obj, const char *slot, KSpellConfig *_ksc,
+		bool _progressbar, bool _modal, SpellerType type )
+{
+  initialize( _parent, _caption, obj, slot, _ksc,
+              _progressbar, _modal, type );
+}
+
+void KSpell::hide() { ksdlg->hide(); }
+
+int KSpell::heightDlg() const { return ksdlg->height(); }
+int KSpell::widthDlg() const { return ksdlg->width(); }
+
+// Check if aspell is at least version 0.6
+static bool determineASpellV6()
+{
+  TQString result;
+  FILE *fs = popen("aspell -v", "r");
+  if (fs)
+  {
+    // Close textstream before we close fs
+    {
+      TQTextStream ts(fs, IO_ReadOnly);
+      result = ts.read().stripWhiteSpace();
+    }
+    pclose(fs);
+  }
+
+  TQRegExp rx("Aspell (\\d.\\d)");
+  if (rx.search(result) != -1)
+  {
+     float version = rx.cap(1).toFloat();
+     return (version >= 0.6);
+  }
+  return false;
+}
+
+
+void
+KSpell::startIspell()
+  //trystart = {0,1,2}
+{
+  if ((trystart == 0) && (ksconfig->client() == KS_CLIENT_ASPELL))
+     d->aspellV6 = determineASpellV6();
+
+  kdDebug(750) << "Try #" << trystart << endl;
+
+  if ( trystart > 0 ) {
+    proc->resetAll();
+  }
+
+  switch ( ksconfig->client() )
+  {
+  case KS_CLIENT_ISPELL:
+    *proc << "ispell";
+    kdDebug(750) << "Using ispell" << endl;
+    break;
+  case KS_CLIENT_ASPELL:
+    *proc << "aspell";
+    kdDebug(750) << "Using aspell" << endl;
+    break;
+  case KS_CLIENT_HSPELL:
+    *proc << "hspell";
+    kdDebug(750) << "Using hspell" << endl;
+    break;
+  case KS_CLIENT_ZEMBEREK:
+    *proc << "zpspell";
+    kdDebug(750) << "Using zemberek(zpspell)" << endl;
+    break;
+  }
+
+  if ( ksconfig->client() == KS_CLIENT_ISPELL || ksconfig->client() == KS_CLIENT_ASPELL )
+  {
+    *proc << "-a" << "-S";
+
+    switch ( d->type )
+    {
+    case HTML:
+      //Debian uses an ispell version that has the -h option instead.
+      //Not sure what they did, but the preferred spell checker
+      //on that platform is aspell anyway, so use -H untill I'll come
+      //up with something better.
+      *proc << "-H";
+      break;
+    case TeX:
+      //same for aspell and ispell
+      *proc << "-t";
+      break;
+    case Nroff:
+      //only ispell supports
+      if ( ksconfig->client() == KS_CLIENT_ISPELL )
+        *proc << "-n";
+      break;
+    case Text:
+    default:
+      //nothing
+      break;
+    }
+    if (ksconfig->noRootAffix())
+    {
+      *proc<<"-m";
+    }
+    if (ksconfig->runTogether())
+    {
+      *proc << "-B";
+    }
+    else
+    {
+      *proc << "-C";
+    }
+
+
+    if (trystart<2)
+    {
+      if (! ksconfig->dictionary().isEmpty())
+      {
+        kdDebug(750) << "using dictionary [" << ksconfig->dictionary() << "]" << endl;
+        *proc << "-d";
+        *proc << ksconfig->dictionary();
+      }
+    }
+
+  //Note to potential debuggers:  -Tlatin2 _is_ being added on the
+  //  _first_ try.  But, some versions of ispell will fail with this
+  // option, so kspell tries again without it.  That's why as 'ps -ax'
+  // shows "ispell -a -S ..." withou the "-Tlatin2" option.
+
+    if ( trystart<1 ) {
+      switch ( ksconfig->encoding() )
+      {
+      case KS_E_LATIN1:
+	*proc << "-Tlatin1";
+	break;
+      case KS_E_LATIN2:
+	*proc << "-Tlatin2";
+	break;
+      case KS_E_LATIN3:
+        *proc << "-Tlatin3";
+        break;
+
+        // add the other charsets here
+      case KS_E_LATIN4:
+      case KS_E_LATIN5:
+      case KS_E_LATIN7:
+      case KS_E_LATIN8:
+      case KS_E_LATIN9:
+      case KS_E_LATIN13:
+	// will work, if this is the default charset in the dictionary
+	kdError(750) << "charsets ISO-8859-4, -5, -7, -8, -9 and -13 not supported yet" << endl;
+	break;
+      case KS_E_LATIN15: // ISO-8859-15 (Latin 9)
+        if (ksconfig->client() == KS_CLIENT_ISPELL)
+        {
+          /*
+           * As far as I know, there are no ispell dictionary using ISO-8859-15
+           * but users have the tendency to select this encoding instead of ISO-8859-1
+           * So put ispell in ISO-8859-1 (Latin 1) mode.
+           */
+          *proc << "-Tlatin1";
+        }
+        else
+          kdError(750) << "ISO-8859-15 not supported for aspell yet." << endl;
+        break;
+      case KS_E_UTF8:
+        *proc << "-Tutf8";
+        if (ksconfig->client() == KS_CLIENT_ASPELL)
+          *proc << "--encoding=utf-8";
+        break;
+      case KS_E_KOI8U:
+	*proc << "-w'"; // add ' as a word char
+	break;
+      default:
+        break;
+      }
+    }
+
+  // -a : pipe mode
+  // -S : sort suggestions by probable correctness
+  }
+  else       // hspell and Zemberek(zpspell) doesn't need all the rest of the options
+    *proc << "-a";
+
+  if (trystart == 0) //don't connect these multiple times
+  {
+    connect( proc, TQT_SIGNAL(receivedStderr(KProcess *, char *, int)),
+             this, TQT_SLOT(ispellErrors(KProcess *, char *, int)) );
+
+    connect( proc, TQT_SIGNAL(processExited(KProcess *)),
+             this, TQT_SLOT(ispellExit (KProcess *)) );
+
+    OUTPUT(KSpell2);
+  }
+
+  if ( !proc->start() )
+  {
+    m_status = Error;
+    TQTimer::singleShot( 0, this, TQT_SLOT(emitDeath()));
+  }
+}
+
+void
+KSpell::ispellErrors( KProcess *, char *buffer, int buflen )
+{
+  buffer[buflen-1] = '\0';
+  //  kdDebug(750) << "ispellErrors [" << buffer << "]\n" << endl;
+}
+
+void KSpell::KSpell2( KProcIO * )
+
+{
+  TQString line;
+
+  kdDebug(750) << "KSpell::KSpell2" << endl;
+
+  trystart = maxtrystart;  //We've officially started ispell and don't want
+                           //to try again if it dies.
+
+  if ( proc->readln( line, true ) == -1 )
+  {
+     TQTimer::singleShot( 0, this, TQT_SLOT(emitDeath()) );
+     return;
+  }
+
+
+  if ( line[0] != '@' ) //@ indicates that ispell is working fine
+  {
+     TQTimer::singleShot( 0, this, TQT_SLOT(emitDeath()) );
+     return;
+  }
+
+  //We want to recognize KDE in any text!
+  if ( !ignore("kde") )
+  {
+     kdDebug(750) << "@KDE was false" << endl;
+     TQTimer::singleShot( 0, this, TQT_SLOT(emitDeath()) );
+     return;
+  }
+
+  //We want to recognize linux in any text!
+  if ( !ignore("linux") )
+  {
+     kdDebug(750) << "@Linux was false" << endl;
+     TQTimer::singleShot( 0, this, TQT_SLOT(emitDeath()) );
+     return;
+  }
+
+  NOOUTPUT( KSpell2 );
+
+  m_status = Running;
+  emit ready( this );
+}
+
+void
+KSpell::setUpDialog( bool reallyuseprogressbar )
+{
+  if ( dialogsetup )
+    return;
+
+  //Set up the dialog box
+  ksdlg = new KSpellDlg( parent, "dialog",
+                         progressbar && reallyuseprogressbar, modaldlg );
+  ksdlg->setCaption( caption );
+
+  connect( ksdlg, TQT_SIGNAL(command(int)),
+           this, TQT_SLOT(slotStopCancel(int)) );
+  connect( this, TQT_SIGNAL(progress(unsigned int)),
+	   ksdlg, TQT_SLOT(slotProgress(unsigned int)) );
+
+#ifdef Q_WS_X11 // FIXME(E): Implement for Qt/Embedded
+  KWin::setIcons( ksdlg->winId(), kapp->icon(), kapp->miniIcon() );
+#endif
+  if ( modaldlg )
+    ksdlg->setFocus();
+  dialogsetup = true;
+}
+
+bool KSpell::addPersonal( const TQString & word )
+{
+  TQString qs = word.simplifyWhiteSpace();
+
+  //we'll let ispell do the work here b/c we can
+  if ( qs.find(' ') != -1 || qs.isEmpty() )    // make sure it's a _word_
+    return false;
+
+  qs.prepend( "*" );
+  personaldict = true;
+
+  return proc->writeStdin( qs );
+}
+
+bool KSpell::writePersonalDictionary()
+{
+  return proc->writeStdin(TQString("#"));
+}
+
+bool KSpell::ignore( const TQString & word )
+{
+  TQString qs = word.simplifyWhiteSpace();
+
+  //we'll let ispell do the work here b/c we can
+  if ( qs.find (' ') != -1 || qs.isEmpty() )    // make sure it's a _word_
+    return false;
+
+  qs.prepend( "@" );
+
+  return proc->writeStdin( qs );
+}
+
+bool
+KSpell::cleanFputsWord( const TQString & s, bool appendCR )
+{
+  TQString qs(s);
+  bool empty = true;
+
+  for( unsigned int i = 0; i < qs.length(); i++ )
+  {
+    //we need some punctuation for ornaments
+    if ( qs[i] != '\'' && qs[i] != '\"' && qs[i] != '-'
+         && qs[i].isPunct() || qs[i].isSpace() )
+    {
+      qs.remove(i,1);
+      i--;
+    } else {
+      if ( qs[i].isLetter() )
+        empty=false;
+    }
+  }
+
+  // don't check empty words, otherwise synchronization will lost
+  if (empty)
+    return false;
+
+  return proc->writeStdin( "^"+qs, appendCR );
+}
+
+bool
+KSpell::cleanFputs( const TQString & s, bool appendCR )
+{
+  TQString qs(s);
+  unsigned l = qs.length();
+
+  // some uses of '$' (e.g. "$0") cause ispell to skip all following text
+  for( unsigned int i = 0; i < l; ++i )
+  {
+    if( qs[i] == '$' )
+      qs[i] = ' ';
+  }
+
+  if ( l<MAXLINELENGTH )
+  {
+    if ( qs.isEmpty() )
+      qs="";
+    return proc->writeStdin( "^"+qs, appendCR );
+  }
+  else
+    return proc->writeStdin( TQString::fromAscii( "^\n" ),appendCR );
+}
+
+bool KSpell::checkWord( const TQString & buffer, bool _usedialog )
+{
+  if (d->checking) { // don't check multiple words simultaneously
+    BufferedWord bufferedWord;
+    bufferedWord.method = Method1;
+    bufferedWord.word = buffer;
+    bufferedWord.useDialog = _usedialog;
+    d->unchecked.append( bufferedWord );
+    return true;
+  }
+  d->checking = true;
+  TQString qs = buffer.simplifyWhiteSpace();
+
+  if ( qs.find (' ') != -1 || qs.isEmpty() ) {   // make sure it's a _word_
+    d->checkNextTimer->start( 0, true );
+    return false;
+  }
+  ///set the dialog signal handler
+  dialog3slot = TQT_SLOT(checkWord3());
+
+  usedialog = _usedialog;
+  setUpDialog( false );
+  if ( _usedialog )
+  {
+    emitProgress();
+  }
+  else
+    ksdlg->hide();
+
+  TQString blank_line;
+  while (proc->readln( blank_line, true ) != -1); // eat spurious blanks
+
+  OUTPUT(checkWord2);
+  //  connect (this, TQT_SIGNAL (dialog3()), this, TQT_SLOT (checkWord3()));
+
+  proc->writeStdin(TQString("%")); // turn off terse mode
+  proc->writeStdin( buffer ); // send the word to ispell
+
+  return true;
+}
+
+bool KSpell::checkWord( const TQString & buffer, bool _usedialog, bool suggest )
+{
+  if (d->checking) { // don't check multiple words simultaneously
+    BufferedWord bufferedWord;
+    bufferedWord.method = Method2;
+    bufferedWord.word = buffer;
+    bufferedWord.useDialog = _usedialog;
+    bufferedWord.suggest = suggest;
+    d->unchecked.append( bufferedWord );
+    return true;
+  }
+  d->checking = true;
+  TQString qs = buffer.simplifyWhiteSpace();
+
+  if ( qs.find (' ') != -1 || qs.isEmpty() ) {   // make sure it's a _word_
+    d->checkNextTimer->start( 0, true );
+    return false;
+  }
+
+  ///set the dialog signal handler
+  if ( !suggest ) {
+    dialog3slot = TQT_SLOT(checkWord3());
+    usedialog = _usedialog;
+    setUpDialog( false );
+    if ( _usedialog )
+    {
+      emitProgress();
+    }
+    else
+      ksdlg->hide();
+  }
+  
+  TQString blank_line;
+  while (proc->readln( blank_line, true ) != -1); // eat spurious blanks
+
+  OUTPUT(checkWord2);
+  //  connect (this, TQT_SIGNAL (dialog3()), this, TQT_SLOT (checkWord3()));
+
+  proc->writeStdin(TQString("%")); // turn off terse mode
+  proc->writeStdin( buffer ); // send the word to ispell
+
+  return true;
+}
+
+void KSpell::checkWord2( KProcIO* )
+{
+  TQString word;
+  TQString line;
+  proc->readln( line, true ); //get ispell's response
+
+/* ispell man page: "Each sentence of text input is terminated with an
+   additional blank line,  indicating that ispell has completed processing
+   the input line."
+   <sanders>
+   But there can be multiple lines returned in the case of an error,
+   in this case we should consume all the output given otherwise spell checking
+   can get out of sync.
+   </sanders>
+*/
+  TQString blank_line;
+  while (proc->readln( blank_line, true ) != -1); // eat the blank line
+  NOOUTPUT(checkWord2);
+  
+  bool mistake = ( parseOneResponse(line, word, sugg) == MISTAKE );
+  if ( mistake && usedialog )
+  {
+    cwword = word;
+    dialog( word, sugg, TQT_SLOT(checkWord3()) );
+    d->checkNextTimer->start( 0, true );
+    return;
+  }
+  else if( mistake )
+  {
+    emit misspelling( word, sugg, lastpos );
+  }
+
+  //emits a "corrected" signal _even_ if no change was made
+  //so that the calling program knows when the check is complete
+  emit corrected( word, word, 0L );
+  d->checkNextTimer->start( 0, true );
+}
+
+void KSpell::checkNext()
+{
+// Queue words to prevent kspell from turning into a fork bomb
+  d->checking = false;
+  if (!d->unchecked.empty()) {
+    BufferedWord buf = d->unchecked.front();
+    d->unchecked.pop_front();
+    
+    if (buf.method == Method1)
+      checkWord( buf.word, buf.useDialog );
+    else
+      checkWord( buf.word, buf.useDialog, buf.suggest );
+  }
+}
+
+void KSpell::suggestWord( KProcIO * )
+{
+  TQString word;
+  TQString line;
+  proc->readln( line, true ); //get ispell's response
+
+/* ispell man page: "Each sentence of text input is terminated with an
+   additional blank line,  indicating that ispell has completed processing
+   the input line." */
+  TQString blank_line;
+  proc->readln( blank_line, true ); // eat the blank line
+
+  NOOUTPUT(checkWord2);
+
+  bool mistake = ( parseOneResponse(line, word, sugg) == MISTAKE );
+  if ( mistake && usedialog )
+  {
+    cwword=word;
+    dialog( word, sugg, TQT_SLOT(checkWord3()) );
+    return;
+  }
+}
+
+void KSpell::checkWord3()
+{
+  disconnect( this, TQT_SIGNAL(dialog3()), this, TQT_SLOT(checkWord3()) );
+
+  emit corrected( cwword, replacement(), 0L );
+}
+
+TQString KSpell::funnyWord( const TQString & word )
+  // composes a guess from ispell to a readable word
+  // e.g. "re+fry-y+ies" -> "refries"
+{
+  TQString qs;
+  unsigned int i=0;
+
+  for( i=0; word [i]!='\0';i++ )
+  {
+    if (word [i]=='+')
+      continue;
+    if (word [i]=='-')
+    {
+      TQString shorty;
+      unsigned int j;
+      int k;
+
+      for( j = i+1; word[j] != '\0' && word[j] != '+' && word[j] != '-'; j++ )
+        shorty += word[j];
+
+      i = j-1;
+
+      if ( !( k = qs.findRev(shorty) ) || k != -1 )
+        qs.remove( k, shorty.length() );
+      else
+      {
+        qs += '-';
+        qs += shorty;  //it was a hyphen, not a '-' from ispell
+      }
+    }
+    else
+      qs += word[i];
+  }
+
+  return qs;
+}
+
+
+int KSpell::parseOneResponse( const TQString &buffer, TQString &word, TQStringList & sugg )
+  // buffer is checked, word and sugg are filled in
+  // returns
+  //   GOOD    if word is fine
+  //   IGNORE  if word is in ignorelist
+  //   REPLACE if word is in replacelist
+  //   MISTAKE if word is misspelled
+{
+  word = "";
+  posinline=0;
+
+  sugg.clear();
+
+  if ( buffer[0] == '*' || buffer[0] == '+' || buffer[0] == '-' )
+  {
+    return GOOD;
+  }
+
+  if ( buffer[0] == '&' || buffer[0] == '?' || buffer[0] == '#' )
+  {
+    int i,j;
+
+
+    word = buffer.mid( 2, buffer.find( ' ', 3 ) -2 );
+    //check() needs this
+    orig=word;
+
+    if( d->m_bIgnoreTitleCase && word == word.upper() )
+      return IGNORE;
+
+    if( d->m_bIgnoreUpperWords && word[0] == word[0].upper() )
+    {
+      TQString text = word[0] + word.right( word.length()-1 ).lower();
+      if( text == word )
+        return IGNORE;
+    }
+
+    /////// Ignore-list stuff //////////
+    //We don't take advantage of ispell's ignore function because
+    //we can't interrupt ispell's output (when checking a large
+    //buffer) to add a word to _it's_ ignore-list.
+    if ( ignorelist.findIndex( word.lower() ) != -1 )
+      return IGNORE;
+
+    //// Position in line ///
+    TQString qs2;
+
+    if ( buffer.find( ':' ) != -1 )
+      qs2 = buffer.left( buffer.find(':') );
+    else
+      qs2 = buffer;
+
+    posinline = qs2.right( qs2.length()-qs2.findRev(' ') ).toInt()-1;
+
+    ///// Replace-list stuff ////
+    TQStringList::Iterator it = replacelist.begin();
+    for( ;it != replacelist.end(); ++it, ++it ) // Skip two entries at a time.
+    {
+      if ( word == *it ) // Word matches
+      {
+        ++it;
+        word = *it;   // Replace it with the next entry
+        return REPLACE;
+      }
+    }
+
+    /////// Suggestions //////
+    if ( buffer[0] != '#' )
+    {
+      TQString qs = buffer.mid( buffer.find(':')+2, buffer.length() );
+      qs += ',';
+      sugg.clear();
+      i = j = 0;
+
+      while( (unsigned int)i < qs.length() )
+      {
+        TQString temp = qs.mid( i, (j=qs.find (',',i)) - i );
+        sugg.append( funnyWord(temp) );
+
+        i=j+2;
+      }
+    }
+
+    if ( (sugg.count()==1) && (sugg.first() == word) )
+      return GOOD;
+
+    return MISTAKE;
+  }
+
+  if ( buffer.isEmpty() ) {
+      kdDebug(750) << "Got an empty response: ignoring"<<endl;
+      return GOOD;
+  }
+
+  kdError(750) << "HERE?: [" << buffer << "]" << endl;
+  kdError(750) << "Please report this to zack@kde.org" << endl;
+  kdError(750) << "Thank you!" << endl;
+
+  emit done( false );
+  emit done( KSpell::origbuffer );
+  return MISTAKE;
+}
+
+bool KSpell::checkList (TQStringList *_wordlist, bool _usedialog)
+  // prepare check of string list
+{
+  wordlist=_wordlist;
+  if ((totalpos=wordlist->count())==0)
+    return false;
+  wlIt = wordlist->begin();
+  usedialog=_usedialog;
+
+  // prepare the dialog
+  setUpDialog();
+
+  //set the dialog signal handler
+  dialog3slot = TQT_SLOT (checkList4 ());
+
+  proc->writeStdin (TQString("%")); // turn off terse mode & check one word at a time
+
+  //lastpos now counts which *word number* we are at in checkListReplaceCurrent()
+  lastpos = -1;
+  checkList2();
+
+  // when checked, KProcIO calls checkList3a
+  OUTPUT(checkList3a);
+
+  return true;
+}
+
+void KSpell::checkList2 ()
+  // send one word from the list to KProcIO
+  // invoked first time by checkList, later by checkListReplaceCurrent and checkList4
+{
+  // send next word
+  if (wlIt != wordlist->end())
+  {
+    kdDebug(750) << "KS::cklist2 " << lastpos << ": " << *wlIt << endl;
+
+    d->endOfResponse = false;
+    bool put;
+    lastpos++; offset=0;
+    put = cleanFputsWord (*wlIt);
+    ++wlIt;
+
+    // when cleanFPutsWord failed (e.g. on empty word)
+    // try next word; may be this is not good for other
+    // problems, because this will make read the list up to the end
+    if (!put) {
+      checkList2();
+    }
+  }
+  else
+    // end of word list
+  {
+    NOOUTPUT(checkList3a);
+    ksdlg->hide();
+    emit done(true);
+  }
+}
+
+void KSpell::checkList3a (KProcIO *)
+  // invoked by KProcIO, when data from ispell are read
+{
+  //kdDebug(750) << "start of checkList3a" << endl;
+
+  // don't read more data, when dialog is waiting
+  // for user interaction
+  if ( dlgon ) {
+    //kdDebug(750) << "dlgon: don't read more data" << endl;
+    return;
+  }
+
+  int e, tempe;
+
+  TQString word;
+  TQString line;
+
+  do
+  {
+    tempe=proc->readln( line, true ); //get ispell's response
+
+    //kdDebug(750) << "checkList3a: read bytes [" << tempe << "]" << endl;
+
+
+    if ( tempe == 0 ) {
+      d->endOfResponse = true;
+      //kdDebug(750) << "checkList3a: end of resp" << endl;
+    } else if ( tempe>0 ) {
+      if ( (e=parseOneResponse( line, word, sugg ) ) == MISTAKE ||
+           e==REPLACE )
+      {
+        dlgresult=-1;
+
+        if ( e == REPLACE )
+        {
+          TQString old = *(--wlIt); ++wlIt;
+          dlgreplacement = word;
+          checkListReplaceCurrent();
+          // inform application
+          emit corrected( old, *(--wlIt), lastpos ); ++wlIt;
+        }
+        else if( usedialog )
+        {
+          cwword = word;
+          dlgon = true;
+          // show the dialog
+          dialog( word, sugg, TQT_SLOT(checkList4()) );
+          return;
+        }
+        else
+        {
+          d->m_bNoMisspellingsEncountered = false;
+          emit misspelling( word, sugg, lastpos );
+        }
+      }
+
+    }
+    emitProgress (); //maybe
+
+    // stop when empty line or no more data
+  } while (tempe > 0);
+
+  //kdDebug(750) << "checkList3a: exit loop with [" << tempe << "]" << endl;
+
+  // if we got an empty line, t.e. end of ispell/aspell response
+  // and the dialog isn't waiting for user interaction, send next word
+  if (d->endOfResponse && !dlgon) {
+    //kdDebug(750) << "checkList3a: send next word" << endl;
+    checkList2();
+  }
+}
+
+void KSpell::checkListReplaceCurrent()
+{
+
+  // go back to misspelled word
+  wlIt--;
+
+  TQString s = *wlIt;
+  s.replace(posinline+offset,orig.length(),replacement());
+  offset += replacement().length()-orig.length();
+  wordlist->insert (wlIt, s);
+  wlIt = wordlist->remove (wlIt);
+  // wlIt now points to the word after the repalced one
+
+}
+
+void KSpell::checkList4 ()
+  // evaluate dialog return, when a button was pressed there
+{
+  dlgon=false;
+  TQString old;
+
+  disconnect (this, TQT_SIGNAL (dialog3()), this, TQT_SLOT (checkList4()));
+
+  //others should have been processed by dialog() already
+  switch (dlgresult)
+  {
+  case KS_REPLACE:
+  case KS_REPLACEALL:
+    kdDebug(750) << "KS: cklist4: lastpos: " << lastpos << endl;
+    old = *(--wlIt);
+    ++wlIt;
+    // replace word
+    checkListReplaceCurrent();
+    emit corrected( old, *(--wlIt), lastpos );
+    ++wlIt;
+    break;
+  case KS_CANCEL:
+    ksdlg->hide();
+    emit done( false );
+    return;
+  case KS_STOP:
+    ksdlg->hide();
+    emit done( true );
+    return;
+  case KS_CONFIG:
+    ksdlg->hide();
+    emit done( false );
+    //check( origbuffer.mid( lastpos ), true );
+    //trystart = 0;
+    //proc->disconnect();
+    //proc->kill();
+    //delete proc;
+    //proc = new KProcIO( codec );
+    //startIspell();
+    return;
+  };
+
+  // read more if there is more, otherwise send next word
+  if (!d->endOfResponse) {
+    //kdDebug(750) << "checkList4: read more from response" << endl;
+    checkList3a(NULL);
+  }
+}
+
+bool KSpell::check( const TQString &_buffer, bool _usedialog )
+{
+  TQString qs;
+
+  usedialog = _usedialog;
+  setUpDialog();
+  //set the dialog signal handler
+  dialog3slot = TQT_SLOT(check3());
+
+  kdDebug(750) << "KS: check" << endl;
+  origbuffer = _buffer;
+  if ( ( totalpos = origbuffer.length() ) == 0 )
+  {
+    emit done( origbuffer );
+    return false;
+  }
+
+
+  // Torben: I corrected the \n\n problem directly in the
+  //         origbuffer since I got errors otherwise
+  if ( !origbuffer.endsWith("\n\n" ) )
+  {
+    if (origbuffer.tqat(origbuffer.length()-1)!='\n')
+    {
+      origbuffer+='\n';
+      origbuffer+='\n'; //shouldn't these be removed at some point?
+    }
+    else
+      origbuffer+='\n';
+  }
+
+  newbuffer = origbuffer;
+
+  // KProcIO calls check2 when read from ispell
+  OUTPUT( check2 );
+  proc->writeStdin(TQString("!"));
+
+  //lastpos is a position in newbuffer (it has offset in it)
+  offset = lastlastline = lastpos = lastline = 0;
+
+  emitProgress();
+
+  // send first buffer line
+  int i = origbuffer.find( '\n', 0 ) + 1;
+  qs = origbuffer.mid( 0, i );
+  cleanFputs( qs, false );
+
+  lastline=i; //the character position, not a line number
+
+  if ( usedialog )
+  {
+    emitProgress();
+  }
+  else
+    ksdlg->hide();
+
+  return true;
+}
+
+
+void KSpell::check2( KProcIO * )
+  // invoked by KProcIO when read from ispell
+{
+  int e, tempe;
+  TQString word;
+  TQString line;
+  static bool recursive = false;
+  if (recursive &&
+      !ksdlg )
+  {
+      return;
+  }
+  recursive = true;
+
+  do
+  {
+    tempe = proc->readln( line, false ); //get ispell's response
+    //kdDebug(750) << "KSpell::check2 (" << tempe << "b)" << endl;
+
+    if ( tempe>0 )
+    {
+      if ( ( e=parseOneResponse (line, word, sugg) )==MISTAKE ||
+           e==REPLACE)
+      {
+        dlgresult=-1;
+
+        // for multibyte encoding posinline needs correction
+        if ((ksconfig->encoding() == KS_E_UTF8) && !d->aspellV6) {
+          // kdDebug(750) << "line: " << origbuffer.mid(lastlastline,
+          // lastline-lastlastline) << endl;
+          // kdDebug(750) << "posinline uncorr: " << posinline << endl;
+
+          // convert line to UTF-8, cut at pos, convert back to UCS-2
+          // and get string length
+          posinline = (TQString::fromUtf8(
+                         origbuffer.mid(lastlastline,lastline-lastlastline).utf8(),
+                         posinline)).length();
+          // kdDebug(750) << "posinline corr: " << posinline << endl;
+        }
+
+        lastpos = posinline+lastlastline+offset;
+
+        //orig is set by parseOneResponse()
+
+        if (e==REPLACE)
+        {
+          dlgreplacement=word;
+          emit corrected( orig, replacement(), lastpos );
+          offset += replacement().length()-orig.length();
+          newbuffer.replace( lastpos, orig.length(), word );
+        }
+        else  //MISTAKE
+        {
+          cwword = word;
+          //kdDebug(750) << "(Before dialog) word=[" << word << "] cwword =[" << cwword << "]\n" << endl;
+          if ( usedialog ) {
+            // show the word in the dialog
+            dialog( word, sugg, TQT_SLOT(check3()) );
+          } else {
+            // No dialog, just emit misspelling and continue
+            d->m_bNoMisspellingsEncountered = false;
+            emit misspelling( word, sugg, lastpos );
+            dlgresult = KS_IGNORE;
+            check3();
+          }
+          recursive = false;
+          return;
+        }
+      }
+
+    }
+
+    emitProgress(); //maybe
+
+  } while( tempe>0 );
+
+  if ( tempe == -1 ) { //we were called, but no data seems to be ready...
+    // Make sure we don't get called directly again and make sure we do get
+    // called when new data arrives.
+    NOOUTPUT( check2 );
+    proc->enableReadSignals(true);
+    OUTPUT( check2 );
+    recursive = false;
+    return;
+  }
+
+  proc->ackRead();
+
+  //If there is more to check, then send another line to ISpell.
+  if ( (unsigned int)lastline < origbuffer.length() )
+  {
+    int i;
+    TQString qs;
+
+    //kdDebug(750) << "[EOL](" << tempe << ")[" << temp << "]" << endl;
+
+    lastpos = (lastlastline=lastline) + offset; //do we really want this?
+    i = origbuffer.find('\n', lastline) + 1;
+    qs = origbuffer.mid( lastline, i-lastline );
+    cleanFputs( qs, false );
+    lastline = i;
+    recursive = false;
+    return;
+  }
+  else
+    //This is the end of it all
+  {
+    ksdlg->hide();
+    //      kdDebug(750) << "check2() done" << endl;
+    newbuffer.truncate( newbuffer.length()-2 );
+    emitProgress();
+    emit done( newbuffer );
+  }
+  recursive = false;
+}
+
+void KSpell::check3 ()
+  // evaluates the return value of the dialog
+{
+  disconnect (this, TQT_SIGNAL (dialog3()), this, TQT_SLOT (check3()));
+  kdDebug(750) << "check3 [" << cwword << "] [" << replacement() << "] " << dlgresult << endl;
+
+  //others should have been processed by dialog() already
+  switch (dlgresult)
+  {
+  case KS_REPLACE:
+  case KS_REPLACEALL:
+    offset+=replacement().length()-cwword.length();
+    newbuffer.replace (lastpos, cwword.length(),
+                       replacement());
+    emit corrected (dlgorigword, replacement(), lastpos);
+    break;
+  case KS_CANCEL:
+    //      kdDebug(750) << "canceled\n" << endl;
+    ksdlg->hide();
+    emit done( origbuffer );
+    return;
+  case KS_CONFIG:
+    ksdlg->hide();
+    emit done( origbuffer );
+    KMessageBox::information( 0, i18n("You have to restart the dialog for changes to take effect") );
+    //check( origbuffer.mid( lastpos ), true );
+    return;
+  case KS_STOP:
+    ksdlg->hide();
+    //buffer=newbuffer);
+    emitProgress();
+    emit done (newbuffer);
+    return;
+  };
+
+  proc->ackRead();
+}
+
+void
+KSpell::slotStopCancel (int result)
+{
+  if (dialogwillprocess)
+    return;
+
+  kdDebug(750) << "KSpell::slotStopCancel [" << result << "]" << endl;
+
+  if (result==KS_STOP || result==KS_CANCEL)
+    if (!dialog3slot.isEmpty())
+    {
+      dlgresult=result;
+      connect (this, TQT_SIGNAL (dialog3()), this, dialog3slot.ascii());
+      emit dialog3();
+    }
+}
+
+
+void KSpell::dialog( const TQString & word, TQStringList & sugg, const char *_slot )
+{
+  dlgorigword = word;
+
+  dialog3slot = _slot;
+  dialogwillprocess = true;
+  connect( ksdlg, TQT_SIGNAL(command(int)), this, TQT_SLOT(dialog2(int)) );
+  TQString tmpBuf = newbuffer;
+  kdDebug(750)<<" position = "<<lastpos<<endl;
+
+  // extract a context string, replace all characters which might confuse
+  // the RichText display and highlight the possibly wrong word
+  TQString marker( "_MARKER_" );
+  tmpBuf.replace( lastpos, word.length(), marker );
+  TQString context = tmpBuf.mid(QMAX(lastpos-18,0), 2*18+marker.length());
+  context.replace( '\n',TQString::tqfromLatin1(" "));
+  context.replace( '<', TQString::tqfromLatin1("&lt;") );
+  context.replace( '>', TQString::tqfromLatin1("&gt;") );
+  context.replace( marker, TQString::tqfromLatin1("<b>%1</b>").arg( word ) );
+  context = "<qt>" + context + "</qt>";
+
+  ksdlg->init( word, &sugg, context );
+  d->m_bNoMisspellingsEncountered = false;
+  emit misspelling( word, sugg, lastpos );
+
+  emitProgress();
+  ksdlg->show();
+}
+
+void KSpell::dialog2( int result )
+{
+  TQString qs;
+
+  disconnect( ksdlg, TQT_SIGNAL(command(int)), this, TQT_SLOT(dialog2(int)) );
+  dialogwillprocess = false;
+  dlgresult = result;
+  ksdlg->standby();
+
+  dlgreplacement = ksdlg->replacement();
+
+  //process result here
+  switch ( dlgresult )
+  {
+  case KS_IGNORE:
+    emit ignoreword( dlgorigword );
+    break;
+  case KS_IGNOREALL:
+    // would be better to lower case only words with beginning cap
+    ignorelist.prepend( dlgorigword.lower() );
+    emit ignoreall( dlgorigword );
+    break;
+  case KS_ADD:
+    addPersonal( dlgorigword );
+    personaldict = true;
+    emit addword( dlgorigword );
+    // adding to pesonal dict takes effect at the next line, not the current
+    ignorelist.prepend( dlgorigword.lower() );
+    break;
+  case KS_REPLACEALL:
+  {
+    replacelist.append( dlgorigword );
+    TQString _replacement = replacement();
+    replacelist.append( _replacement );
+    emit replaceall( dlgorigword ,  _replacement );
+  }
+    break;
+  case KS_SUGGEST:
+    checkWord( ksdlg->replacement(), false, true );
+    return;
+    break;
+  }
+
+  connect( this, TQT_SIGNAL(dialog3()), this, dialog3slot.ascii() );
+  emit dialog3();
+}
+
+
+KSpell::~KSpell()
+{
+  delete proc;
+  delete ksconfig;
+  delete ksdlg;
+  delete d->checkNextTimer;
+  delete d;
+}
+
+
+KSpellConfig KSpell::ksConfig() const
+{
+  ksconfig->setIgnoreList(ignorelist);
+  ksconfig->setReplaceAllList(replacelist);
+  return *ksconfig;
+}
+
+void KSpell::cleanUp()
+{
+  if ( m_status == Cleaning )
+    return; // Ignore
+
+  if ( m_status == Running )
+  {
+    if ( personaldict )
+      writePersonalDictionary();
+    m_status = Cleaning;
+  }
+  proc->closeStdin();
+}
+
+void KSpell::ispellExit( KProcess* )
+{
+  kdDebug() << "KSpell::ispellExit() " << m_status << endl;
+
+  if ( (m_status == Starting) && (trystart < maxtrystart) )
+  {
+    trystart++;
+    startIspell();
+    return;
+  }
+
+  if ( m_status == Starting )
+     m_status = Error;
+  else if (m_status == Cleaning)
+     m_status = d->m_bNoMisspellingsEncountered ? FinishedNoMisspellingsEncountered : Finished;
+  else if ( m_status == Running )
+     m_status = Crashed;
+  else // Error, Finished, Crashed
+     return; // Dead already
+
+  kdDebug(750) << "Death" << endl;
+  TQTimer::singleShot( 0, this, TQT_SLOT(emitDeath()) );
+}
+
+// This is always called from the event loop to make
+// sure that the receiver can safely delete the
+// KSpell object.
+void KSpell::emitDeath()
+{
+  bool deleteMe = autoDelete; // Can't access object after next call!
+  emit death();
+  if ( deleteMe )
+    deleteLater();
+}
+
+void KSpell::setProgressResolution (unsigned int res)
+{
+  progres=res;
+}
+
+void KSpell::emitProgress ()
+{
+  uint nextprog = (uint) (100.*lastpos/(double)totalpos);
+
+  if ( nextprog >= curprog )
+  {
+    curprog = nextprog;
+    emit progress( curprog );
+  }
+}
+
+void KSpell::moveDlg( int x, int y )
+{
+  TQPoint pt( x,y ), pt2;
+  pt2 = parent->mapToGlobal( pt );
+  ksdlg->move( pt2.x(),pt2.y() );
+}
+
+void KSpell::setIgnoreUpperWords(bool _ignore)
+{
+  d->m_bIgnoreUpperWords=_ignore;
+}
+
+void KSpell::setIgnoreTitleCase(bool _ignore)
+{
+  d->m_bIgnoreTitleCase=_ignore;
+}
+// --------------------------------------------------
+// Stuff for modal (blocking) spell checking
+//
+// Written by Torben Weis <weis@kde.org>. So please
+// send bug reports regarding the modal stuff to me.
+// --------------------------------------------------
+
+int
+KSpell::modalCheck( TQString& text )
+{
+  return modalCheck( text,0 );
+}
+
+int
+KSpell::modalCheck( TQString& text, KSpellConfig* _kcs )
+{
+  modalreturn = 0;
+  modaltext = text;
+
+  KSpell* spell = new KSpell( 0L, i18n("Spell Checker"), 0 ,
+                              0, _kcs, true, true );
+
+  while (spell->status()!=Finished)
+    kapp->processEvents();
+
+  text = modaltext;
+
+  delete spell;
+  return modalreturn;
+}
+
+void KSpell::slotSpellCheckerCorrected( const TQString & oldText, const TQString & newText, unsigned int pos )
+{
+  modaltext=modaltext.replace(pos,oldText.length(),newText);
+}
+
+
+void KSpell::slotModalReady()
+{
+  //kdDebug() << tqApp->loopLevel() << endl;
+  //kdDebug(750) << "MODAL READY------------------" << endl;
+
+  Q_ASSERT( m_status == Running );
+  connect( this, TQT_SIGNAL( done( const TQString & ) ),
+           this, TQT_SLOT( slotModalDone( const TQString & ) ) );
+  TQObject::connect( this, TQT_SIGNAL( corrected( const TQString&, const TQString&, unsigned int ) ),
+                    this, TQT_SLOT( slotSpellCheckerCorrected( const TQString&, const TQString &, unsigned int ) ) );
+  TQObject::connect( this, TQT_SIGNAL( death() ),
+                    this, TQT_SLOT( slotModalSpellCheckerFinished( ) ) );
+  check( modaltext );
+}
+
+void KSpell::slotModalDone( const TQString &/*_buffer*/ )
+{
+  //kdDebug(750) << "MODAL DONE " << _buffer << endl;
+  //modaltext = _buffer;
+  cleanUp();
+
+  //kdDebug() << "ABOUT TO EXIT LOOP" << endl;
+  //tqApp->exit_loop();
+
+  //modalWidgetHack->close(true);
+  slotModalSpellCheckerFinished();
+}
+
+void KSpell::slotModalSpellCheckerFinished( )
+{
+  modalreturn=(int)this->status();
+}
+
+void KSpell::initialize( TQWidget *_parent, const TQString &_caption,
+                         TQObject *obj, const char *slot, KSpellConfig *_ksc,
+                         bool _progressbar, bool _modal, SpellerType type )
+{
+  d = new KSpellPrivate;
+
+  d->m_bIgnoreUpperWords =false;
+  d->m_bIgnoreTitleCase =false;
+  d->m_bNoMisspellingsEncountered = true;
+  d->type = type;
+  d->checking = false;
+  d->aspellV6 = false;
+  d->checkNextTimer = new TQTimer( this );
+  connect( d->checkNextTimer, TQT_SIGNAL( timeout() ),
+	   this, TQT_SLOT( checkNext() ));
+  autoDelete = false;
+  modaldlg = _modal;
+  progressbar = _progressbar;
+
+  proc     = 0;
+  ksconfig = 0;
+  ksdlg    = 0;
+  lastpos  = 0;
+
+  //won't be using the dialog in ksconfig, just the option values
+  if ( _ksc )
+    ksconfig = new KSpellConfig( *_ksc );
+  else
+    ksconfig = new KSpellConfig;
+
+  codec = 0;
+  switch ( ksconfig->encoding() )
+  {
+  case KS_E_LATIN1:
+     codec = TQTextCodec::codecForName("ISO 8859-1");
+     break;
+  case KS_E_LATIN2:
+     codec = TQTextCodec::codecForName("ISO 8859-2");
+     break;
+  case KS_E_LATIN3:
+      codec = TQTextCodec::codecForName("ISO 8859-3");
+      break;
+  case KS_E_LATIN4:
+      codec = TQTextCodec::codecForName("ISO 8859-4");
+      break;
+  case KS_E_LATIN5:
+      codec = TQTextCodec::codecForName("ISO 8859-5");
+      break;
+  case KS_E_LATIN7:
+      codec = TQTextCodec::codecForName("ISO 8859-7");
+      break;
+  case KS_E_LATIN8:
+      codec = TQTextCodec::codecForName("ISO 8859-8-i");
+      break;
+  case KS_E_LATIN9:
+      codec = TQTextCodec::codecForName("ISO 8859-9");
+      break;
+  case KS_E_LATIN13:
+      codec = TQTextCodec::codecForName("ISO 8859-13");
+      break;
+  case KS_E_LATIN15:
+      codec = TQTextCodec::codecForName("ISO 8859-15");
+      break;
+  case KS_E_UTF8:
+      codec = TQTextCodec::codecForName("UTF-8");
+      break;
+  case KS_E_KOI8R:
+      codec = TQTextCodec::codecForName("KOI8-R");
+      break;
+  case KS_E_KOI8U:
+      codec = TQTextCodec::codecForName("KOI8-U");
+      break;
+  case KS_E_CP1251:
+      codec = TQTextCodec::codecForName("CP1251");
+      break;
+  case KS_E_CP1255:
+      codec = TQTextCodec::codecForName("CP1255");
+      break;
+  default:
+     break;
+  }
+
+  kdDebug(750) << __FILE__ << ":" << __LINE__ << " Codec = " << (codec ? codec->name() : "<default>") << endl;
+
+  // copy ignore list from ksconfig
+  ignorelist += ksconfig->ignoreList();
+
+  replacelist += ksconfig->replaceAllList();
+  texmode=dlgon=false;
+  m_status = Starting;
+  dialogsetup = false;
+  progres=10;
+  curprog=0;
+
+  dialogwillprocess = false;
+  dialog3slot = TQString::null;
+
+  personaldict = false;
+  dlgresult = -1;
+
+  caption = _caption;
+
+  parent = _parent;
+
+  trystart = 0;
+  maxtrystart = 2;
+
+  if ( obj && slot )
+      // caller wants to know when kspell is ready
+      connect( this, TQT_SIGNAL(ready(KSpell *)), obj, slot);
+  else
+      // Hack for modal spell checking
+      connect( this, TQT_SIGNAL(ready(KSpell *)), this, TQT_SLOT(slotModalReady()) );
+
+  proc = new KProcIO( codec );
+
+  startIspell();
+}
+
+TQString KSpell::modaltext;
+int KSpell::modalreturn = 0;
+TQWidget* KSpell::modalWidgetHack = 0;
+
+#include "kspell.moc"
+