/***************************************************************************
                     read a KEduVocDocument from a KVTML file
    -----------------------------------------------------------------------
    copyright            : (C) 1999-2001 Ewald Arnold
                           (C) 2001 The KDE-EDU team
                           (C) 2005 Eric Pignet
    email                : eric at erixpage.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <tdeapplication.h>
#include <kdebug.h>
#include <tdelocale.h>
#include <tdemessagebox.h>

#include <tqdom.h>
#include <tqtextstream.h>

#include "keduvockvtmlreader.h"
#include "keduvocdocument.h"

KEduVocKvtmlReader::KEduVocKvtmlReader(TQFile *file)
{
  // the file must be already open
  m_inputFile = file;
}

KEduVocKvtmlReader::~KEduVocKvtmlReader()
{
}


bool KEduVocKvtmlReader::readLesson(TQDomElement &domElementParent)
{
  TQString s;
  m_doc->lesson_descr.clear();

  //-------------------------------------------------------------------------
  // Attributes
  //-------------------------------------------------------------------------

  TQDomAttr domAttrWidth = domElementParent.attributeNode(KV_SIZEHINT);
  if (!domAttrWidth.isNull())
    m_doc->setSizeHint(-1, domAttrWidth.value().toInt());

  //-------------------------------------------------------------------------
  // Children
  //-------------------------------------------------------------------------

  TQDomElement domElementChild = domElementParent.firstChild().toElement();

  while (!domElementChild.isNull())
  {
    if (domElementChild.tagName() == KV_LESS_DESC)
    {
      //-----------
      // Attributes

      int no = 0;
      bool isCurr = false;

      TQDomAttr domAttrNo = domElementChild.attributeNode(KV_LESS_NO);
      if (!domAttrNo.isNull())
        no = domAttrNo.value().toInt();

      TQDomAttr domAttrCurrent = domElementChild.attributeNode(KV_LESS_CURR);
      if (!domAttrCurrent.isNull())
        isCurr = domAttrCurrent.value().toInt() != 0;

      if (isCurr && no != 0)
        m_doc->setCurrentLesson(no);

      TQDomAttr domAttrQuery = domElementChild.attributeNode(KV_LESS_QUERY);
      if (!domAttrQuery.isNull())
        m_doc->lessons_in_query.push_back(domAttrQuery.value().toInt() != 0);
      else
        m_doc->lessons_in_query.push_back(false);

      //-----
      // Text

      s = domElementChild.text();
      if (s.isNull())
        s = "";
      m_doc->lesson_descr.push_back(s);
    }
    else
    {
      domErrorUnknownElement(domElementChild.tagName());
      return false;
    }

    domElementChild = domElementChild.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readArticle(TQDomElement &domElementParent)
/*
 <article>
  <e l="de">        lang determines also lang order in entries !!
   <fi>eine</fi>    which must NOT differ
   <fd>die</fd>
   <mi>ein</mi>
   <md>der</md>
   <ni>ein</ni>
   <nd>das</nd>
  </e>
 </article>
*/
{
  bool endOfGroup = false;
  bool inEntry = false;
  int count = 0;
  TQString s;
  m_doc->articles.clear();

  TQDomElement domElementEntry = domElementParent.firstChild().toElement();

  while (!domElementEntry.isNull())
  {
    if (domElementEntry.tagName() != KV_ART_ENTRY)
    {
      domError(i18n("expected tag <%1>").arg(KV_ART_ENTRY));
      return false;
    }

    //----------
    // Attribute

    TQString lang;
    TQDomAttr domAttrLang = domElementEntry.attributeNode(KV_LANG);

    if ((int)m_doc->langs.size() <= count)
    {
      // first entry
      if (!domAttrLang.isNull())         // no definition in first entry
        lang = domAttrLang.value();
      else
        lang = "original";
      m_doc->langs.push_back(lang);
    }
    else
    {
      if (!domAttrLang.isNull() && domAttrLang.value() != m_doc->langs[count])
      {
        // different originals ?
        domError(i18n("ambiguous definition of language code"));
        return false;
      }
    }

    //---------
    // Children

    TQString fem_def = "";
    TQString  mal_def = "";
    TQString  nat_def = "";
    TQString  fem_indef = "";
    TQString  mal_indef = "";
    TQString  nat_indef = "";

    TQDomElement domElementEntryChild = domElementEntry.firstChild().toElement();
    while (!domElementEntryChild.isNull())
    {
      if (domElementEntryChild.tagName() == KV_ART_FD)
      {
        fem_def = domElementEntryChild.text();
        if (fem_def.isNull())
          fem_def = "";
      }
      else if (domElementEntryChild.tagName() == KV_ART_FI)
      {
        fem_indef = domElementEntryChild.text();
        if (fem_indef.isNull())
          fem_indef = "";
      }
      else if (domElementEntryChild.tagName() == KV_ART_MD)
      {
        mal_def = domElementEntryChild.text();
        if (mal_def.isNull())
          mal_def = "";
      }
      else if (domElementEntryChild.tagName() == KV_ART_MI)
      {
        mal_indef = domElementEntryChild.text();
        if (mal_indef.isNull())
          mal_indef = "";
      }
      else if (domElementEntryChild.tagName() == KV_ART_ND)
      {
        nat_def = domElementEntryChild.text();
        if (nat_def.isNull())
          nat_def = "";
      }
      else if (domElementEntryChild.tagName() == KV_ART_NI)
      {
        nat_indef = domElementEntryChild.text();
        if (nat_indef.isNull())
          nat_indef = "";
      }
      else
      {
        domErrorUnknownElement(domElementEntryChild.tagName());
        return false;
      }

      domElementEntryChild = domElementEntryChild.nextSibling().toElement();
    }

    m_doc->articles.push_back(Article(  fem_def, fem_indef,
                                        mal_def, mal_indef,
                                        nat_def, nat_indef));

    domElementEntry = domElementEntry.nextSibling().toElement();
    count++;
  }

  return true;
}


bool KEduVocKvtmlReader::readConjug(TQDomElement &domElementParent,
                                    vector<Conjugation> &curr_conjug,
                                    const TQString &entry_tag)
/*
 <conjugation>        used in header for definiton of "prefix"
  <e l="de">          lang determines also lang order in entries !!
   <s1>I</s1>         which must NOT differ
   <s2>you<2>
   <s3f>he</s3f>
   <s3m>she</s3m>
   <s3n>it</s3n>
   <p1>we</p1>
   <p2>you</p2>
   <p3f>they</p3f>
   <p3m>they</p3m>
   <p3n>they</p3n>
  </e>
 </conjugation>

 <conjugation>        and in entry for definition of tenses of (irreg.) verbs
  <t n="sipa">
   <s1>go</s1>
   <s2>go</s2>
   <s3f>goes</s3f>
   <s3m>goes</s3m>
   <s3n>goes</s3n>
   <p1>go</p1>
   <p2>go</p2>
   <p3f>go</p3f>
   <p3m>go</p3m>
   <p3n>go</p3n>
  </t>
 </conjugation>
*/
{
  TQString s;

  curr_conjug.clear();

  bool    p3_common,
      s3_common;
  TQString pers1_sing,
      pers2_sing,
      pers3_m_sing,
      pers3_f_sing,
      pers3_n_sing,
      pers1_plur,
      pers2_plur,
      pers3_m_plur,
      pers3_f_plur,
      pers3_n_plur;

  TQString lang;
  TQString type;
  int count = 0;
  curr_conjug.push_back(Conjugation());

  TQDomElement domElementConjugChild = domElementParent.firstChild().toElement();
  while (!domElementConjugChild.isNull())
  {
    if (domElementConjugChild.tagName() == KV_CON_ENTRY)
    {
      type = CONJ_PREFIX;

      //----------
      // Attribute

      TQString lang;
      TQDomAttr domAttrLang = domElementConjugChild.attributeNode(KV_LANG);

      if ((int)m_doc->langs.size() <= count)
      {
        // first entry
        if (!domAttrLang.isNull())            // no definition in first entry
          lang = domAttrLang.value();
        else
          lang = "original";
        m_doc->langs.push_back(lang);
      }
      else
      {
        if (!domAttrLang.isNull() && domAttrLang.value() != m_doc->langs[count])
        {
          // different originals ?
          domError(i18n("ambiguous definition of language code"));
          return false;
        }
      }
    }
    else if (domElementConjugChild.tagName() == KV_CON_TYPE)
    {
      //----------
      // Attribute

      TQDomAttr domAttrLang = domElementConjugChild.attributeNode(KV_CON_NAME);
      type = domAttrLang.value();
      if (type.isNull())
        type = "";

      if (type.length() != 0 && type.left(1) == UL_USER_TENSE)
      {
        int num = TQMIN(type.mid (1, 40).toInt(), 1000); // paranoia check
        if( num > (int) m_doc->tense_descr.size() )
        {
          // description missing ?
          TQString s;
          for (int i = m_doc->tense_descr.size(); i < num; i++)
          {
            s.setNum (i+1);
            s.insert (0, "#");  // invent descr according to number
            m_doc->tense_descr.push_back(s);
          }
        }
      }
    }

    pers1_sing = "";
    pers2_sing = "";
    pers3_m_sing = "";
    pers3_f_sing = "";
    pers3_n_sing = "";
    pers1_plur = "";
    pers2_plur = "";
    pers3_m_plur = "";
    pers3_f_plur = "";
    pers3_n_plur = "";
    p3_common = false;
    s3_common = false;

    TQDomElement domElementConjugGrandChild = domElementConjugChild.firstChild().toElement();
    while (!domElementConjugGrandChild.isNull())
    {
      if (domElementConjugGrandChild.tagName() == KV_CON_P1S)
      {
        pers1_sing = domElementConjugGrandChild.text();
        if (pers1_sing.isNull())
          pers1_sing = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P2S)
      {
        pers2_sing = domElementConjugGrandChild.text();
        if (pers2_sing.isNull())
          pers2_sing = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P3SF)
      {
        TQDomAttr domAttrCommon = domElementConjugGrandChild.attributeNode(KV_CONJ_COMMON);
        if (!domAttrCommon.isNull())
          s3_common = domAttrCommon.value().toInt();  // returns 0 if the conversion fails

        pers3_f_sing = domElementConjugGrandChild.text();
        if (pers3_f_sing.isNull())
          pers3_f_sing = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P3SM)
      {
        pers3_m_sing = domElementConjugGrandChild.text();
        if (pers3_m_sing.isNull())
          pers3_m_sing = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P3SN)
      {
        pers3_n_sing = domElementConjugGrandChild.text();
        if (pers3_n_sing.isNull())
          pers3_n_sing = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P1P)
      {
        pers1_plur = domElementConjugGrandChild.text();
        if (pers1_plur.isNull())
          pers1_plur = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P2P)
      {
        pers2_plur = domElementConjugGrandChild.text();
        if (pers2_plur.isNull())
          pers2_plur = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P3PF)
      {
        TQDomAttr domAttrCommon = domElementConjugGrandChild.attributeNode(KV_CONJ_COMMON);
        if (!domAttrCommon.isNull())
          p3_common = domAttrCommon.value().toInt();  // returns 0 if the conversion fails

        pers3_f_plur = domElementConjugGrandChild.text();
        if (pers3_f_plur.isNull())
          pers3_f_plur = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P3PM)
      {
        pers3_m_plur = domElementConjugGrandChild.text();
        if (pers3_m_plur.isNull())
          pers3_m_plur = "";
      }
      else if (domElementConjugGrandChild.tagName() == KV_CON_P3PN)
      {
        pers3_n_plur = domElementConjugGrandChild.text();
        if (pers3_n_plur.isNull())
          pers3_n_plur = "";
      }
      else
      {
        domErrorUnknownElement(domElementConjugGrandChild.tagName());
        return false;
      }

      domElementConjugGrandChild = domElementConjugGrandChild.nextSibling().toElement();
    }

    if (domElementConjugChild.tagName() == KV_CON_ENTRY)
      while (count+1 > (int) curr_conjug.size() )
        curr_conjug.push_back(Conjugation());

    curr_conjug[count].setPers3SingularCommon(type, s3_common);
    curr_conjug[count].setPers3PluralCommon(type, p3_common);
    curr_conjug[count].setPers1Singular(type, pers1_sing);
    curr_conjug[count].setPers2Singular(type, pers2_sing);
    curr_conjug[count].setPers3FemaleSingular(type, pers3_f_sing);
    curr_conjug[count].setPers3MaleSingular(type, pers3_m_sing);
    curr_conjug[count].setPers3NaturalSingular(type, pers3_n_sing);
    curr_conjug[count].setPers1Plural(type, pers1_plur);
    curr_conjug[count].setPers2Plural(type, pers2_plur);
    curr_conjug[count].setPers3FemalePlural(type, pers3_f_plur);
    curr_conjug[count].setPers3MalePlural(type, pers3_m_plur);
    curr_conjug[count].setPers3NaturalPlural(type, pers3_n_plur);

    if (domElementConjugChild.tagName() == KV_CON_ENTRY)
      count++;

    domElementConjugChild = domElementConjugChild.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readOptions(TQDomElement &domElementParent)
{
  TQDomElement domElementSort = domElementParent.firstChild().toElement();
  while (!domElementSort.isNull())
  {
    if (domElementSort.tagName() == KV_OPT_SORT)
    {
      m_doc->sort_allowed = true;
      TQDomAttr domAttrOn = domElementSort.attributeNode(KV_BOOL_FLAG);
      if (!domAttrOn.isNull())
            {
                bool ok = true;
        m_doc->sort_allowed = domAttrOn.value().toInt(&ok);  // returns 0 if the conversion fails
          if (!ok)
              m_doc->sort_allowed = true;
            }
    }

    domElementSort = domElementSort.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readType(TQDomElement &domElementParent)
{
  TQString s;
  m_doc->type_descr.clear();

  TQDomElement domElementDesc = domElementParent.firstChild().toElement();

  while (!domElementDesc.isNull())
  {
    if (domElementDesc.tagName() == KV_TYPE_DESC)
    {
      //-----------
      // Attributes

      int no = 0;
      bool isCurr = false;

      TQDomAttr domAttrNo = domElementDesc.attributeNode(KV_TYPE_NO);
      if (!domAttrNo.isNull())
        no = domAttrNo.value().toInt();

      // TODO use 'no' to sort types
      // but 'no' seems useless, since types are already ordered by their position in the XML doc

      s = domElementDesc.text();
      if (s.isNull())
        s = "";

      m_doc->type_descr.push_back (s);
    }
    else
    {
      domErrorUnknownElement(domElementDesc.tagName());
      return false;
    }

    domElementDesc = domElementDesc.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readTense(TQDomElement &domElementParent)
{
  TQString s;
  m_doc->tense_descr.clear();

  TQDomElement domElementDesc = domElementParent.firstChild().toElement();

  while (!domElementDesc.isNull())
  {
    if (domElementDesc.tagName() == KV_TENSE_DESC)
    {
      //-----------
      // Attributes

      int no = 0;
      bool isCurr = false;

      TQDomAttr domAttrNo = domElementDesc.attributeNode(KV_TENSE_NO);
      if (!domAttrNo.isNull())
        no = domAttrNo.value().toInt();

      // TODO use 'no' to sort tenses
      // but 'no' seems useless, since tenses are already ordered by their position in the XML doc

      s = domElementDesc.text();
      if (s.isNull())
        s = "";

      m_doc->tense_descr.push_back (s);
    }
    else
    {
      domErrorUnknownElement(domElementDesc.tagName());
      return false;
    }

    domElementDesc = domElementDesc.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readUsage(TQDomElement &domElementParent)
{
  TQString s;
  m_doc->usage_descr.clear();

  TQDomElement domElementDesc = domElementParent.firstChild().toElement();

  while (!domElementDesc.isNull())
  {
    if (domElementDesc.tagName() == KV_USAGE_DESC)
    {
      //-----------
      // Attributes

      int no = 0;
      bool isCurr = false;

      TQDomAttr domAttrNo = domElementDesc.attributeNode(KV_USAGE_NO);
      if (!domAttrNo.isNull())
        no = domAttrNo.value().toInt();

      // TODO use 'no' to sort usages
      // but 'no' seems useless, since usages are already ordered by their position in the XML doc

      s = domElementDesc.text();
      if (s.isNull())
        s = "";

      m_doc->usage_descr.push_back (s);
    }
    else
    {
      domErrorUnknownElement(domElementDesc.tagName());
      return false;
    }

    domElementDesc = domElementDesc.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readComparison(TQDomElement &domElementParent,
                                        Comparison &comp)
/*
 <comparison>
   <l1>good</l1>
   <l2>better</l2>
   <l3>best</l3>
 </comparison>
*/
{
  TQString s;
  comp.clear();

  TQDomElement domElementComparisonChild = domElementParent.firstChild().toElement();
  while (!domElementComparisonChild.isNull())
  {
    if (domElementComparisonChild.tagName() == KV_COMP_L1)
    {
      s = domElementComparisonChild.text();
      if (s.isNull())
        s = "";
      comp.setL1(s);
    }

    else if (domElementComparisonChild.tagName() == KV_COMP_L2)
    {
      s = domElementComparisonChild.text();
      if (s.isNull())
        s = "";
      comp.setL2(s);
    }

    else if (domElementComparisonChild.tagName() == KV_COMP_L3)
    {
      s = domElementComparisonChild.text();
      if (s.isNull())
        s = "";
      comp.setL3(s);
    }

    else
    {
      domErrorUnknownElement(domElementComparisonChild.tagName());
      return false;
    }

    domElementComparisonChild = domElementComparisonChild.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readMultipleChoice(TQDomElement &domElementParent,
                                            MultipleChoice &mc)
/*
 <multiplechoice>
   <mc1>good</mc1>
   <mc2>better</mc2>
   <mc3>best</mc3>
   <mc4>best 2</mc4>
   <mc5>best 3</mc5>
 </multiplechoice>
*/

{
  TQString s;
  mc.clear();

  TQDomElement domElementChild = domElementParent.firstChild().toElement();
  while (!domElementChild.isNull())
  {
    if (domElementChild.tagName() == KV_MC_1)
    {
      s = domElementChild.text();
      if (s.isNull())
        s = "";
      mc.setMC1(s);
    }

    else if (domElementChild.tagName() == KV_MC_2)
    {
      s = domElementChild.text();
      if (s.isNull())
        s = "";
      mc.setMC2(s);
    }

    else if (domElementChild.tagName() == KV_MC_3)
    {
      s = domElementChild.text();
      if (s.isNull())
        s = "";
      mc.setMC3(s);
    }

    else if (domElementChild.tagName() == KV_MC_4)
    {
      s = domElementChild.text();
      if (s.isNull())
        s = "";
      mc.setMC4(s);
    }

    else if (domElementChild.tagName() == KV_MC_5)
    {
      s = domElementChild.text();
      if (s.isNull())
        s = "";
      mc.setMC5(s);
    }

    else
    {
      domErrorUnknownElement(domElementChild.tagName());
      return false;
    }

    domElementChild = domElementChild.nextSibling().toElement();
  }

  mc.normalize();
  return true;
}


bool KEduVocKvtmlReader::readExpressionChildAttributes( TQDomElement &domElementExpressionChild,
                                                        TQString &lang,
                                                        grade_t &grade, grade_t &rev_grade,
                                                        int &count, int &rev_count,
                                                        time_t &date, time_t &rev_date,
                                                        TQString &remark,
                                                        int &bcount, int &rev_bcount,
                                                        TQString &query_id,
                                                        TQString &pronunce,
                                                        int &width,
                                                        TQString &type,
                                                        TQString &faux_ami_f,
                                                        TQString &faux_ami_t,
                                                        TQString &synonym,
                                                        TQString &example,
                                                        TQString &antonym,
                                                        TQString &usage,
                                                        TQString &paraphrase)
{
  int pos;

  lang = "";
  TQDomAttr domAttrLang = domElementExpressionChild.attributeNode(KV_LANG);
  if (!domAttrLang.isNull())
    lang = domAttrLang.value();

  width = -1;
  TQDomAttr domAttrWidth = domElementExpressionChild.attributeNode(KV_SIZEHINT);
  if (!domAttrWidth.isNull())
    width = domAttrWidth.value().toInt();

  grade = KV_NORM_GRADE;
  rev_grade = KV_NORM_GRADE;
  TQDomAttr domAttrGrade = domElementExpressionChild.attributeNode(KV_LANG);
  if (!domAttrGrade.isNull())
  {
    TQString s = domAttrGrade.value();
    if ((pos = s.find(';')) >= 1)
    {
      grade = s.left(pos).toInt();
      rev_grade = s.mid(pos+1, s.length()).toInt();
    }
    else
      grade = s.toInt();
  }

  count = 0;
  rev_count = 0;
  TQDomAttr domAttrCount = domElementExpressionChild.attributeNode(KV_COUNT);
  if (!domAttrCount.isNull())
  {
    TQString s = domAttrCount.value();
    if ((pos = s.find(';')) >= 1)
    {
      count = s.left(pos).toInt();
      rev_count = s.mid(pos+1, s.length()).toInt();
    }
    else
      count = s.toInt();
  }

  bcount = 0;
  rev_bcount = 0;
  TQDomAttr domAttrBad = domElementExpressionChild.attributeNode(KV_BAD);
  if (!domAttrBad.isNull())
  {
    TQString s = domAttrBad.value();
    if ((pos = s.find(';')) >= 1)
    {
      bcount = s.left(pos).toInt();
      rev_bcount = s.mid(pos+1, s.length()).toInt();
    }
    else
      bcount = s.toInt();
  }

  date = 0;
  rev_date = 0;
  TQDomAttr domAttrDate = domElementExpressionChild.attributeNode(KV_DATE);
  if (!domAttrDate.isNull())
  {
    TQString s = domAttrDate.value();
    if ((pos = s.find(';')) >= 1)
    {
      date = s.left(pos).toInt();
      rev_date = s.mid(pos+1, s.length()).toInt();
    }
    else
      date = s.toInt();
  }

  TQDomAttr domAttrDate2 = domElementExpressionChild.attributeNode(KV_DATE2);
  if (!domAttrDate2.isNull())
  {
    TQString s = domAttrDate2.value();
    if ((pos = s.find(';')) >= 1)
    {
      date = m_doc->decompressDate(s.left(pos));
      rev_date = m_doc->decompressDate(s.mid(pos+1, s.length()));
    }
    else
      date = m_doc->decompressDate(s);
  }

  remark = "";
  TQDomAttr domAttrRemark = domElementExpressionChild.attributeNode(KV_REMARK);
  if (!domAttrRemark.isNull())
    remark = domAttrRemark.value();

  faux_ami_f = "";
  TQDomAttr domAttrFauxAmiF = domElementExpressionChild.attributeNode(KV_FAUX_AMI_F);
  if (!domAttrFauxAmiF.isNull())
    faux_ami_f = domAttrFauxAmiF.value();

  faux_ami_t = "";
  TQDomAttr domAttrFauxAmiT = domElementExpressionChild.attributeNode(KV_FAUX_AMI_T);
  if (!domAttrFauxAmiT.isNull())
    faux_ami_t = domAttrFauxAmiT.value();

  synonym = "";
  TQDomAttr domAttrSynonym = domElementExpressionChild.attributeNode(KV_SYNONYM);
  if (!domAttrSynonym.isNull())
    synonym = domAttrSynonym.value();

  example = "";
  TQDomAttr domAttrExample = domElementExpressionChild.attributeNode(KV_EXAMPLE);
  if (!domAttrExample.isNull())
    example = domAttrExample.value();

  usage = "";
  TQDomAttr domAttrUsage = domElementExpressionChild.attributeNode(KV_USAGE);
  if (!domAttrUsage.isNull())
  {
    usage = domAttrUsage.value();
    if (usage.length() != 0 && usage.left(1) == UL_USER_USAGE)
    {
      int num = TQMIN(usage.mid (1, 40).toInt(), 1000); // paranioa check
      if( num > (int) m_doc->usage_descr.size() )
      {
        // description missing ?
        TQString s;
        for (int i = m_doc->usage_descr.size(); i < num; i++)
        {
          s.setNum (i+1);
          s.insert (0, "#");  // invent descr according to number
          m_doc->usage_descr.push_back (s);
        }
      }
    }
  }

  paraphrase = "";
  TQDomAttr domAttrParaphrase = domElementExpressionChild.attributeNode(KV_PARAPHRASE);
  if (!domAttrParaphrase.isNull())
    paraphrase = domAttrParaphrase.value();

  antonym = "";
  TQDomAttr domAttrAntonym = domElementExpressionChild.attributeNode(KV_ANTONYM);
  if (!domAttrAntonym.isNull())
    antonym = domAttrAntonym.value();

  TQDomAttr domAttrExprType = domElementExpressionChild.attributeNode(KV_EXPRTYPE);
  if (!domAttrExprType.isNull())
  {
    type = domAttrExprType.value();
    if (type == "1")
      type = TQM_VERB;
    else if (type == "2")  // convert from pre-0.5 versions
      type = TQM_NOUN;
    else if (type == "3")
      type = TQM_NAME;

    if (type.length() != 0 && type.left(1) == TQM_USER_TYPE)
    {
      int num = TQMIN(type.mid (1, 40).toInt(), 1000); // paranoia check
      if( num > (int) m_doc->type_descr.size() )
      {
        // description missing ?
        TQString s;
        for (int i = m_doc->type_descr.size(); i < num; i++)
        {
          s.setNum (i+1);
          s.insert (0, "#");  // invent descr according to number
          m_doc->type_descr.push_back (s);
        }
      }
    }
  }

  pronunce = "";
  TQDomAttr domAttrPronunce = domElementExpressionChild.attributeNode(KV_PRONUNCE);
  if (!domAttrPronunce.isNull())
    pronunce = domAttrPronunce.value();

  query_id = "";
  TQDomAttr domAttrQuery = domElementExpressionChild.attributeNode(KV_QUERY);
  if (!domAttrQuery.isNull())
    query_id = domAttrQuery.value();

  return true;
}


bool KEduVocKvtmlReader::readExpression(TQDomElement &domElementParent)
{
  grade_t       grade,
                r_grade;
  int           qcount,
                r_qcount;
  int           bcount,
                 r_bcount;
  TQString       remark;
  TQString       pronunce;
  time_t        qdate,
                r_qdate;
  bool          inquery;
  bool          active;
  TQString       lang;
  TQString       textstr;
  TQString       exprtype;
  bool          org_found = false;
  TQString       q_org,
                q_trans;
  TQString       query_id;
  KEduVocExpression expr;
  int           lesson = 0;
  int           width;
  TQString       type;
  TQString       faux_ami_f;
  TQString       faux_ami_t;
  TQString       synonym;
  TQString       example;
  TQString       antonym;
  TQString       usage;
  TQString       paraphrase;
  vector<Conjugation> conjug;
  Comparison     comparison;
  MultipleChoice mc;

  //-------------------------------------------------------------------------
  // Attributes
  //-------------------------------------------------------------------------

  TQDomAttr domAttrMember = domElementParent.attributeNode(KV_LESS_MEMBER);
  if (!domAttrMember.isNull())
    lesson = domAttrMember.value().toInt();

  TQDomAttr domAttrSelected = domElementParent.attributeNode(KV_SELECTED);
  if (!domAttrSelected.isNull())
    inquery = domAttrSelected.value().toInt();
  else
    inquery = false;

  TQDomAttr domAttrInactive = domElementParent.attributeNode(KV_INACTIVE);
  if (!domAttrInactive.isNull())
    active = !domAttrInactive.value().toInt();
  else
    active = false;

  TQDomAttr domAttrType = domElementParent.attributeNode(KV_EXPRTYPE);
  if (!domAttrType.isNull())
  {
    exprtype = !domAttrType.value().toInt();
    if (exprtype == "1")
      exprtype = TQM_VERB;
    else if (exprtype == "2")  // convert from pre-0.5 versions
      exprtype = TQM_NOUN;
    else if (exprtype == "3")
      exprtype = TQM_NAME;

    if (exprtype.length() != 0 && exprtype.left(1) == TQM_USER_TYPE)
    {
      int num = TQMIN(exprtype.mid (1, 40).toInt(), 1000); // paranoia check
      if( num > (int) m_doc->type_descr.size() )
      {
        // description missing ?
        TQString s;
        for (int i = m_doc->type_descr.size(); i < num; i++)
        {
          s.setNum (i+1);
          s.insert (0, "#");  // invent descr according to number
          m_doc->type_descr.push_back (s);
        }
      }
    }
  }

  if (lesson && lesson > (int) m_doc->lesson_descr.size() )
  {
    // description missing ?
    TQString s;
    for (int i = m_doc->lesson_descr.size(); i < lesson; i++)
    {
      s.setNum (i+1);
      s.insert (0, "#");  // invent descr according to number
      m_doc->lesson_descr.push_back (s);
    }
  }

  //-------------------------------------------------------------------------
  // Child 'Original'
  //-------------------------------------------------------------------------

  // now want "original" and one or more "translations"

  TQDomElement domElementExpressionChild = domElementParent.firstChild().toElement();

  unsigned int count = 0;
  org_found = false;

  if (domElementExpressionChild.tagName() != KV_ORG)
  {
    // must be preceded by "original"
    domError(i18n("starting tag <%1> is missing").arg(KV_ORG));
    return false;
  }

  // found original <o>

  org_found = true;

  type = exprtype;

  //-----------
  // Attributes

    if (!readExpressionChildAttributes( domElementExpressionChild,
                                        lang,
                                        grade,  r_grade,
                                        qcount, r_qcount,
                                        qdate,  r_qdate,
                                        remark,
                                        bcount, r_bcount,
                                        query_id,
                                        pronunce,
                                        width,
                                        type,
                                        faux_ami_t,
                                        faux_ami_f,
                                        synonym,
                                        example,
                                        antonym,
                                        usage,
                                        paraphrase))
    return false;


  if (m_doc->vocabulary.size() == 0)
  {
    // only accept in first entry
    if (width >= 0)
      m_doc->setSizeHint (count, width);

    if (query_id == KV_O)
      q_org = lang;

    if (query_id == KV_T)
      q_trans = lang;
  }

  if (m_doc->langs.size() == 0)
  {
    // first entry
    if (lang.isEmpty())                 // no definition in first entry
      lang = "original";
    m_doc->langs.push_back(lang);

  }
  else
  {
    if (lang != m_doc->langs[0] && !lang.isEmpty())
    {
      // different originals ?
      domError(i18n("ambiguous definition of language code"));
      return false;
    }
  }
  count = 0;

  //---------
  // Children

  bool bConjug = false;
  bool bComparison = false;
  bool bMultipleChoice = false;

  TQDomElement domElementOriginalChild = domElementExpressionChild.firstChild().toElement();
  while (!domElementOriginalChild.isNull())
  {
    if (domElementOriginalChild.tagName() == KV_CONJUG_GRP)
    {
      if (bConjug)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementOriginalChild.tagName()));
        return false;
      }
      bConjug = true;
      conjug.clear();
      if (!readConjug(domElementOriginalChild, conjug, (TQString) KV_CON_TYPE))
        return false;
    }

    else if (domElementOriginalChild.tagName() == KV_COMPARISON_GRP)
    {
      if (bComparison)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementOriginalChild.tagName()));
        return false;
      }
      bComparison = true;
      comparison.clear();
      if (!readComparison(domElementOriginalChild, comparison))
        return false;
    }

    else if (domElementOriginalChild.tagName() == KV_MULTIPLECHOICE_GRP)
    {
      if (bMultipleChoice)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementOriginalChild.tagName()));
        return false;
      }
      bMultipleChoice = true;
      mc.clear();
      if (!readMultipleChoice(domElementOriginalChild, mc))
        return false;
    }

    else
    {
      domErrorUnknownElement(domElementOriginalChild.tagName());
      return false;
    }

    domElementOriginalChild = domElementOriginalChild.nextSibling().toElement();
  }

  textstr = domElementExpressionChild.lastChild().toText().data();
  if (textstr.isNull())
    textstr = "";

  expr = KEduVocExpression(textstr);
  expr.setLesson (lesson);
  expr.setInQuery(inquery);
  expr.setActive(active);

  if (conjug.size() > 0)
  {
    expr.setConjugation(0, conjug[0]);
    conjug.clear();
  }
  if (!comparison.isEmpty())
  {
    expr.setComparison(0, comparison);
    comparison.clear();
  }
  if (!mc.isEmpty())
  {
    expr.setMultipleChoice(0, mc);
    mc.clear();
  }
  if (!remark.isEmpty() )
    expr.setRemark (0, remark);
  if (!pronunce.isEmpty() )
    expr.setPronunce (0, pronunce);
  if (!type.isEmpty() )
    expr.setType(0, type);
  if (!synonym.isEmpty() )
    expr.setSynonym(0, synonym);
  if (!example.isEmpty() )
    expr.setExample(0, example);
  if (!usage.isEmpty() )
    expr.setUsageLabel(0, usage);
  if (!paraphrase.isEmpty() )
    expr.setParaphrase(0, paraphrase);
  if (!antonym.isEmpty() )
    expr.setAntonym(0, antonym);


  //-------------------------------------------------------------------------
  // Children 'Translation'
  //-------------------------------------------------------------------------

  domElementExpressionChild = domElementExpressionChild.nextSibling().toElement();

  while (!domElementExpressionChild.isNull())
  {
    if (domElementExpressionChild.tagName() != KV_TRANS)
    {
      // "original" must be followed by "translations"
      domError(i18n("starting tag <%1> is missing").arg(KV_TRANS));
      return false;
    }

    // found translation <t>

    count++;
    type = exprtype;

    //-----------
    // Attributes

    if (!readExpressionChildAttributes( domElementExpressionChild,
                                        lang,
                                        grade,  r_grade,
                                        qcount, r_qcount,
                                        qdate,  r_qdate,
                                        remark,
                                        bcount, r_bcount,
                                        query_id,
                                        pronunce,
                                        width,
                                        type,
                                        faux_ami_f,
                                        faux_ami_t,
                                        synonym,
                                        example,
                                        antonym,
                                        usage,
                                        paraphrase))
      return false;

    if (m_doc->vocabulary.size() == 0)
    {
      // only accept in first entry
      if (width >= 0)
        m_doc->setSizeHint (count, width);

      if (query_id == KV_O)
        q_org = lang;

      if (query_id == KV_T)
        q_trans = lang;

    }

    if (m_doc->langs.size() <= count)
    {
      // new translation
      if (lang.isEmpty())
      {
        // no definition in first entry ?
        lang.setNum (m_doc->langs.size() );
        lang.insert (0, "translation ");
      }
      m_doc->langs.push_back(lang);

    }
    else
    {
      if (lang != m_doc->langs[count] && !lang.isEmpty())
      { // different language ?
        domError(i18n("ambiguous definition of language code"));
        return false;
      }
    }

    //---------
    // Children

    bool bConjug = false;
    bool bComparison = false;
    bool bMultipleChoice = false;

    TQDomElement domElementOriginalChild = domElementExpressionChild.firstChild().toElement();
    while (!domElementOriginalChild.isNull())
    {
      if (domElementOriginalChild.tagName() == KV_CONJUG_GRP)
      {
        if (bConjug)
        {
          domError(i18n("repeated occurrence of tag <%1>").arg(domElementOriginalChild.tagName()));
          return false;
        }
        bConjug = true;
        conjug.clear();
        if (!readConjug(domElementOriginalChild, conjug, (TQString) KV_CON_TYPE))
          return false;
      }

      else if (domElementOriginalChild.tagName() == KV_COMPARISON_GRP)
      {
        if (bComparison)
        {
          domError(i18n("repeated occurrence of tag <%1>").arg(domElementOriginalChild.tagName()));
          return false;
        }
        bComparison = true;
        comparison.clear();
        if (!readComparison(domElementOriginalChild, comparison))
          return false;
      }

      else if (domElementOriginalChild.tagName() == KV_MULTIPLECHOICE_GRP)
      {
        if (bMultipleChoice)
        {
          domError(i18n("repeated occurrence of tag <%1>").arg(domElementOriginalChild.tagName()));
          return false;
        }
        bMultipleChoice = true;
        mc.clear();
        if (!readMultipleChoice(domElementOriginalChild, mc))
          return false;
      }

      else
      {
        domErrorUnknownElement(domElementOriginalChild.tagName());
        return false;
      }

      domElementOriginalChild = domElementOriginalChild.nextSibling().toElement();
    }

    textstr = domElementExpressionChild.lastChild().toText().data();
    if (textstr.isNull())
      textstr = "";

    /*
      if (qcount == 0)
      {
      grade = KV_NORM_GRADE;
      }

      if (r_qcount == 0)
      {
      r_grade = KV_NORM_GRADE;
      }
    */
    expr.addTranslation (textstr, grade, r_grade);
    expr.setQueryCount  (count, qcount, false);
    expr.setQueryCount  (count, r_qcount, true);
    expr.setBadCount    (count, bcount, false);
    expr.setBadCount    (count, r_bcount, true);
    expr.setQueryDate   (count, qdate, false);
    expr.setQueryDate   (count, r_qdate, true);

    if (conjug.size() > 0)
    {
      expr.setConjugation(count, conjug[0]);
      conjug.clear();
    }
    if (!comparison.isEmpty())
    {
      expr.setComparison(count, comparison);
      comparison.clear();
    }
    if (!mc.isEmpty())
    {
      expr.setMultipleChoice(count, mc);
      mc.clear();
    }
    if (!type.isEmpty() )
      expr.setType (count, type);
    if (!remark.isEmpty() )
      expr.setRemark (count, remark);
    if (!pronunce.isEmpty() )
      expr.setPronunce (count, pronunce);
    if (!faux_ami_f.isEmpty() )
      expr.setFauxAmi (count, faux_ami_f, false);
    if (!faux_ami_t.isEmpty() )
      expr.setFauxAmi (count, faux_ami_t, true);
    if (!synonym.isEmpty() )
      expr.setSynonym (count, synonym);
    if (!example.isEmpty() )
      expr.setExample (count, example);
    if (!usage.isEmpty() )
      expr.setUsageLabel (count, usage);
    if (!paraphrase.isEmpty() )
      expr.setParaphrase (count, paraphrase);
    if (!antonym.isEmpty() )
      expr.setAntonym (count, antonym);

    domElementExpressionChild = domElementExpressionChild.nextSibling().toElement();
  }
  if (m_doc->numEntries() == 0)
    m_doc->setQueryLang(q_org, q_trans);
  m_doc->vocabulary.push_back(expr);

  return true;
}


bool KEduVocKvtmlReader::readBody(TQDomElement &domElementParent)
{
  bool lessgroup = false;
  bool optgroup = false;
  bool attrgroup = false;
  bool tensegroup = false;
  bool usagegroup = false;
  bool articlegroup = false;
  bool conjuggroup = false;

  int ent_no = 0;
  int ent_percent = (int) m_doc->lines / 100;
  float f_ent_percent = (int) m_doc->lines / 100.0;
/* TODO EPT
if (lines != 0)
    emit progressChanged(this, 0);
*/

  TQDomElement domElementChild = domElementParent.firstChild().toElement();

  while (!domElementChild.isNull())
  {
    if (domElementChild.tagName() == KV_LESS_GRP)
    {
      if (lessgroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      lessgroup = true;
      if (!readLesson(domElementChild))
        return false;
    }

    else if (domElementChild.tagName() == KV_ARTICLE_GRP)
    {
      if (articlegroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      articlegroup = true;
      if (!readArticle(domElementChild))
        return false;
    }

    else if (domElementChild.tagName() == KV_CONJUG_GRP)
    {
      if (conjuggroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      conjuggroup = true;
      if (!readConjug(domElementChild, m_doc->conjugations, KV_CON_ENTRY))
        return false;
    }

    else if (domElementChild.tagName() == KV_OPTION_GRP)
    {
      if (optgroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      optgroup = true;
      if (!readOptions(domElementChild))
        return false;
    }

    else if (domElementChild.tagName() == KV_TYPE_GRP)
    {
      if (attrgroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      attrgroup = true;
      if (!readType(domElementChild))
        return false;
    }

    else if (domElementChild.tagName() == KV_TENSE_GRP)
    {
      if (tensegroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      tensegroup = true;
      if (!readTense(domElementChild))
        return false;
    }

    else if (domElementChild.tagName() == KV_USAGE_GRP)
    {
      if (usagegroup)
      {
        domError(i18n("repeated occurrence of tag <%1>").arg(domElementChild.tagName()));
        return false;
      }
      usagegroup = true;
      if (!readUsage(domElementChild))
        return false;
    }

    else if (domElementChild.tagName() == KV_EXPR)
    {
      /* TODO EPT
      if (lines != 0)
      {
        ent_no++;
        if (ent_percent != 0 && (ent_no % ent_percent) == 0 )
          emit progressChanged(this, int(ent_no / f_ent_percent));
      }*/
      if (!readExpression(domElementChild))
        return false;
    }

    else
    {
      domErrorUnknownElement(domElementChild.tagName());
      return false;
    }

    domElementChild = domElementChild.nextSibling().toElement();
  }

  return true;
}


bool KEduVocKvtmlReader::readDoc(KEduVocDocument *doc)
{
  m_doc = doc;

  TQDomDocument domDoc("Kvtml" );
  TQString errorMsg;
  if( !domDoc.setContent( m_inputFile, &errorMsg ) )
  {
    domError(errorMsg);
    return false;
  }

  m_doc->langs.clear();
  m_doc->vocabulary.clear();

  m_doc->generator = "";
  m_doc->cols = 0;
  m_doc->lines = 0;
  m_doc->doctitle = "";
  m_doc->author = "";
  m_doc->license = "";
  m_doc->doc_remark = "";


  TQDomElement domElementKvtml = domDoc.documentElement();
  if( domElementKvtml.tagName() != KV_DOCTYPE )
  {
    domError(i18n("Tag <%1> was expected "
            "but tag <%2> was read." ).arg(KV_DOCTYPE).arg(domElementKvtml.tagName()));
    return false;
  }

  //-------------------------------------------------------------------------
  // Attributes
  //-------------------------------------------------------------------------

  TQDomAttr domAttrEncoding = domElementKvtml.attributeNode(KV_ENCODING);
  if (!domAttrEncoding.isNull())
  {
    // TODO handle old encodings
    // TQt DOM API autodetects encoding, so is there anything to do ?
  }

  TQDomAttr domAttrTitle = domElementKvtml.attributeNode(KV_TITLE);
  if (!domAttrTitle.isNull())
  {
    m_doc->doctitle = domAttrTitle.value();
  }

  TQDomAttr domAttrAuthor = domElementKvtml.attributeNode(KV_AUTHOR);
  if (!domAttrAuthor.isNull())
  {
    m_doc->author = domAttrAuthor.value();
  }

  TQDomAttr domAttrLicence = domElementKvtml.attributeNode(KV_LICENSE);
  if (!domAttrLicence.isNull())
  {
    m_doc->license = domAttrLicence.value();
  }

  TQDomAttr domAttrRemark = domElementKvtml.attributeNode(KV_DOC_REM);
  if (!domAttrRemark.isNull())
  {
    m_doc->doc_remark = domAttrRemark.value();
  }

  TQDomAttr domAttrGenerator = domElementKvtml.attributeNode(KV_GENERATOR);
  if (!domAttrGenerator.isNull())
  {
    m_doc->generator = domAttrGenerator.value();
    int pos = m_doc->generator.findRev (KVD_VERS_PREFIX);
    if (pos >= 0)
    {
      m_doc->doc_version = m_doc->generator;
      m_doc->doc_version.remove (0, pos+2);
    }
  }

  TQDomAttr domAttrCols = domElementKvtml.attributeNode(KV_COLS);
  if (!domAttrCols.isNull())
  {
    m_doc->cols = domAttrCols.value().toInt();
  }

  TQDomAttr domAttrLines = domElementKvtml.attributeNode(KV_LINES);
  if (!domAttrLines.isNull())
  {
    m_doc->lines = domAttrLines.value().toInt();
  }


  //-------------------------------------------------------------------------
  // Children
  //-------------------------------------------------------------------------

  bool result = readBody(domElementKvtml);  // read vocabulary

  // TODO EPT setModified (false);
  return result;
}


void KEduVocKvtmlReader::domErrorUnknownElement(const TQString &elem)
{
  TQString ln = i18n("File:\t%1\n").arg(m_doc->URL().path());

  TQString format = i18n(
      "Your document contains an unknown tag <%1>.  "  // keep trailing space
      "Maybe your version of KVocTrain is too old, "
      "or the document is damaged.\n"
      "Loading is aborted because KVocTrain cannot "
      "read documents with unknown elements.\n"
     );
  TQString msg = format.arg(elem);
  TQApplication::setOverrideCursor( arrowCursor, true );
  TQString s = kapp->makeStdCaption(i18n("Unknown Element"));
  KMessageBox::sorry(0, ln+msg, s);
  TQApplication::restoreOverrideCursor();
}

void KEduVocKvtmlReader::domError(const TQString &text )
{
  TQApplication::setOverrideCursor( arrowCursor, true );
  TQString s = kapp->makeStdCaption(i18n("Error"));
  TQString ln = i18n("File:\t%1\n").arg(m_doc->URL().path());
  TQString msg = text;
  KMessageBox::error(0, ln+msg, s);
  TQApplication::restoreOverrideCursor();
}

