kverbos/kverbos/kverbosdoc.cpp

   1 /***************************************************************************
   2                           kverbosdoc.cpp  -  description
   3                              -------------------
   4     begin                : Fre Dez 14 19:28:09 CET 2001
   5     copyright            : (C) 2001 by Arnold Kraschinski
   6     email                : arnold.k67@gmx.de
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 // include eines Standardheaders
  19 #include <iostream>
  20 #include <ctime>
  21 #include <cstdlib>
  22
  23 // include files for Qt
  24 #include <qmessagebox.h>
  25
  26 // include files for KDE
  27 #include <klocale.h>
  28 #include <kmessagebox.h>
  29 #include <kio/netaccess.h>
  30
  31 // application specific includes
  32 #include "verbspanish.h"
  33 #include "kverbosdoc.h"
  34 #include "kverbosview.h"
  35 #include "kverbosuser.h"
  36
  37
  38
  39
  40 QPtrList<KVerbosView> *KVerbosDoc::pViewList = 0L;
  41
  42 KVerbosDoc::KVerbosDoc(QWidget *parent, const char *name) : QObject(parent, name)
  43 {
  44         if(!pViewList)
  45         {
  46                 pViewList = new QPtrList<KVerbosView>();
  47         };
  48         pViewList->setAutoDelete(true);
  49         // Zufallsgenerator mit einem seed-Wert versorgen
  50         srand((unsigned int)time((time_t *)NULL));
  51         // Den Zeiger auf einen Benutzer initialisieren
  52         benutzer = new KVerbosUser(getList(), DEFAULTUSER);
  53 }
  54
  55 KVerbosDoc::~KVerbosDoc()
  56 {
  57         if (benutzer != 0)
  58         {
  59                 int result, number;
  60                 pViewList->first()->userChanged(result, number);
  61                 benutzer->saveUser(result, number);
  62                 delete benutzer;
  63                 benutzer = 0;
  64         };
  65         verbList2.clear();
  66 }
  67
  68 void KVerbosDoc::addView(KVerbosView *view)
  69 {
  70         pViewList->append(view);
  71         connect(this, SIGNAL(changeView()), view, SLOT(zeigeVerb()));
  72 }
  73
  74 void KVerbosDoc::removeView(KVerbosView *view)
  75 {
  76         pViewList->remove(view);
  77 }
  78
  79 void KVerbosDoc::setURL(const KURL &url)
  80 {
  81         doc_url=url;
  82 }
  83
  84 const KURL& KVerbosDoc::URL() const
  85 {
  86         return doc_url;
  87 }
  88
  89 void KVerbosDoc::slotUpdateAllViews(KVerbosView *sender)
  90 {
  91         KVerbosView *w;
  92         if(pViewList)
  93                 for(w=pViewList->first(); w!=0; w=pViewList->next())
  94                         if(w!=sender)
  95                                 w->repaint();
  96 }
  97
  98 bool KVerbosDoc::saveModified()
  99 {
 100   bool completed=true;
 101
 102   if(modified)
 103   {
 104     KVerbosApp *win=(KVerbosApp *) parent();
 105     int want_save = KMessageBox::warningYesNoCancel(win,
 106                 i18n("The current file has been modified.\nDo you want to save it?"),
 107                 i18n("Warning"));
 108     switch(want_save)
 109     {
 110       // ich habe die Nummern gegenüber den originalen Nummern in der case-Anweisung
 111       // vertauscht, weil die originalen Nummern verkehrt zugeordnet sind!.
 112       // In der Dokumentation zu KMessageBox kann man die richtige Zuordnung der Buttons finden.
 113       case 2: // CANCEL
 114            completed=false;
 115            break;
 116       case 3: // YES
 117            if (doc_url.fileName() == i18n("Untitled"))
 118            {
 119              win->slotFileSaveAs();
 120            }
 121            else
 122            {
 123              saveDocument(URL());
 124            };
 125
 126            deleteContents();
 127            completed=true;
 128            break;
 129       case 4: // NO
 130            setModified(false);
 131            deleteContents();
 132            completed=true;
 133            break;
 134       default: // Verhalten wie CANCEL
 135            completed=false;
 136            break;
 137     }
 138   }
 139
 140   return completed;
 141 }
 142
 143 void KVerbosDoc::closeDocument()
 144 {
 145         deleteContents();
 146 }
 147
 148 bool KVerbosDoc::newDocument()
 149 {
 150         // Die Verbenlist wird gelöscht, damit sie sicher leer ist.
 151         verbList2.clear();
 152
 153         modified=false;
 154         doc_url.setFileName(i18n("Untitled"));
 155         emit anzahlVerbenGeaendert(getAnzahl());
 156         return true;
 157 }
 158
 159 bool KVerbosDoc::openDocument(const KURL& url, const char *format /*=0*/)
 160 {
 161         bool b = false;
 162         QString tmpfile;
 163         KIO::NetAccess::download( url, tmpfile );
 164
 165         QFile file(url.path());
 166         if ( file.open(IO_ReadOnly) ) {    // file opened successfully
 167                 deleteContents();
 168         if ((url.fileName().right(4) == "html")||(url.fileName().right(3) == "htm"))
 169         {
 170                 // qWarning("öffnen eines HTML-files");
 171                 b = openDocHTML(file);
 172         }
 173         else
 174         {
 175                 // qWarning("öffnen eines .verbos-files");
 176                 b = openDocVERBOS(file);
 177         };
 178         file.close();
 179         // Liste der Verben sortieren
 180     spanishVerbList vl;
 181     spanishVerbList::Iterator it1 = verbList2.begin();
 182     spanishVerbList::Iterator it2;
 183         while (it1 != verbList2.end())
 184     {
 185                         it2 = vl.begin();
 186                 bool inserted = false;
 187                 while (it2  != vl.end())
 188         {
 189                                 if (*it1 < *it2)
 190                 {
 191                 vl.insert(it2, *it1);
 192                 inserted = true;
 193           it2 = vl.end();
 194         }
 195               else
 196               it2++;
 197       };
 198       if (!inserted)
 199         vl.insert(it2, *it1);
 200       it1++;
 201     };
 202     verbList2.clear();
 203     verbList2 = vl;
 204     benutzer->fillList(getList());
 205     emit changeView();
 206   };
 207
 208   KIO::NetAccess::removeTempFile( tmpfile );
 209
 210   modified=false;
 211   emit anzahlVerbenGeaendert(getAnzahl());
 212   return b;
 213 }
 214
 215 // Liesteine Datei als HTML-Dokument ein
 216 bool KVerbosDoc::openDocHTML(QFile &f)
 217 {
 218         bool result = true;
 219         QTextStream t( &f );          // use a text stream
 220         int count1;
 221         int count2;
 222         QString s;
 223         QString v[3];
 224         QString forms[60];
 225         verbSpanish NewVerb;
 226         while (!f.atEnd())
 227         {
 228                 count1 = 0;
 229                 // drei einlesen, das sind der Infinitiv, die deutsche Bedeutung, und der Typ
 230                 while ((count1<3) && (!f.atEnd()))
 231                 {
 232                         s = t.readLine();
 233                         if (s.left(9) == "<td width")
 234                         {
 235                                 int a = s.find('>', 22, true);
 236                                 a++;
 237                                 int e = s.find('<', a, true);
 238                                 v[count1] = s.mid(a, e-a);
 239                                 count1++;
 240                         };
 241                 }; // while ((count1<3) && (!f.atEnd()))
 242                 if (3 == count1)
 243                 {
 244                         NewVerb.setSpanish(v[0]);
 245                         NewVerb.setForeign(v[1]);
 246                         if (v[2] != "unregelm&auml;&szlig;ig")
 247                         {
 248                                 // read a regular or a group verb
 249                                 int g = 0;
 250                                 if (v[2] == "regelm&auml;&szlig;ig")
 251                                         g = 0;
 252                                 else if (v[2] == "&lt;e &gt; ie&gt;")
 253                                         g = 2;
 254                                 else if (v[2] == "&lt;o &gt; ue&gt;")
 255                                         g = 3;
 256                                 else if (v[2] == "&lt;u &gt; ue&gt;")
 257                                         g = 4;
 258                                 else if (v[2] == "&lt;e &gt; i&gt;")
 259                                         g = 5;
 260                                 else if (v[2] == "&lt;c &gt; qu&gt;")
 261                                         g = 6;
 262                                 else if (v[2] == "&lt;g &gt; gu&gt;")
 263                                         g = 7;
 264                                 else if (v[2] == "&lt;z &gt; c&gt;")
 265                                         g = 8;
 266                                 else if (v[2] == "&lt;gu &gt; gü&gt;")
 267                                         g = 9;
 268                                 else if (v[2] == "&lt;c &gt; z&gt;")
 269                                         g = 10;
 270                                 else if (v[2] == "&lt;g &gt; j&gt;")
 271                                         g = 11;
 272                                 else if (v[2] == "&lt;gu &gt; g&gt;")
 273                                         g = 12;
 274                                 else if (v[2] == "&lt;qu &gt; c&gt;")
 275                                         g = 13;
 276                                 else if (v[2] == "&lt;accent like 'enviar'&gt;")
 277                                         g = 14;
 278                                 else if (v[2] == "&lt;accent like 'continuar&gt;")
 279                                         g = 15;
 280                                 else if (v[2] == "&lt;missing i&gt;")
 281                                         g = 16;
 282                                 else
 283                                         result = false;
 284                                 NewVerb.setGroup(g);
 285                         }
 286                         else
 287                         {
 288                                 // ein unregelmäßiges Verb
 289                                 NewVerb.setGroup(IRREGULAR);
 290                                 // weitere 60 Zeilen einlesen, das sind die ganzen Formen
 291                                 count2 = 0;
 292                                 while ((count2<60) && (!f.atEnd()))
 293                                 {
 294                                         s = t.readLine();
 295                                         if ((s.left(4) == "<td>") && (s != "<td></td><td></td><td></td><td></td><td></td></tr><tr>"))
 296                                         {
 297                                                 int a = s.find('>', 2, true);
 298                                                 a++;
 299                                                 int e = s.find('<', a, true);
 300                                                 forms[count2] = s.mid(a, e-a);
 301                                                 count2++;
 302                                                 if (14 == count2)
 303                                                 {
 304                                                         forms[count2] = "participio";
 305                                                         count2++;
 306                                                 };
 307                                         };
 308                                 }; // while ((count2<60) && (!f.atEnd()))
 309                                 int i;
 310                                 // den ersten Tabellenteil übertragen
 311                                 for (i=0; (i<30) && (i<count2); i++)
 312                                 {
 313                                         int a = i % 5;
 314                                         int b = i / 5;
 315                                         // In der fünften ( a == 4 ) Spalte stehen die Gerundform und das Partizip
 316                                         if (a == 4)
 317                                         {
 318                                                 if (b == 0)
 319                                                 NewVerb.setGerund(forms[i]);
 320                                                 if (b == 3)
 321                                                 NewVerb.setPartizip(forms[i]);
 322                                         }
 323                                         else
 324                                         {
 325                                                 // kommt ein Leerzeichen vor, muss man die Form aufteilen: In das
 326                                                 // Reflexivpronomen und das eigentliche Verb
 327                                                 if (forms[i].find(' ') >= 0)
 328                                                 {
 329                                                         NewVerb.setForm(a, b, forms[i].right(forms[i].length()-forms[i].find(' ')-1));
 330                                                 }
 331                                                 else
 332                                                 {
 333                                                         NewVerb.setForm(a, b, forms[i]);
 334                                                 }
 335                                         };
 336                                 };
 337                                 // den zweiten Tabellenteil übertragen
 338                                 for (i=0; (i<30) && (i+30<count2); i++)
 339                                 {
 340                                         int a = i % 5 + 4;
 341                                         int b = i / 5;
 342                                         // In der Spalte 3 der zweiten Tabellenhälfte steht der subjuntivo futuro,
 343                                         // den ich vergessen habe und der deshalb zur Zeit ausgelassen wird.
 344                                         int offs = 30;
 345                                         // kommt ein Leerzeichen vor, muss man die Form aufteilen: In das
 346                                         // Reflexivpronomen und das eigentliche Verb
 347                                         if (forms[i+offs].find(' ') >= 0)
 348                                         {
 349                                                 NewVerb.setForm(a, b, forms[i+offs].right(forms[i+offs].length()-forms[i+offs].find(' ')-1));
 350                                         }
 351                                         else
 352                                         {
 353                                                 NewVerb.setForm(a, b, forms[i+offs]);
 354                                         };
 355                                 };
 356                         }; // if (v[2] == "unregelm&auml;&szlig;ig")
 357                         appendVerb(NewVerb, false); // an die Liste anhängen
 358                 };
 359         }; // while (!f.atEnd())
 360         emit anzahlVerbenGeaendert(getAnzahl());
 361         return result;
 362 }
 363
 364 bool KVerbosDoc::openDocVERBOS(QFile &f)
 365 {
 366         QTextStream t( &f );          // use a text stream
 367         int count;
 368         QString v[3];
 369         while (!f.atEnd())
 370         {
 371                 count = 0;
 372                 // drei einlesen, das sind der Infinitiv, die deutsche Bedeutung, und der Typ
 373                 while ((count<3) && (!f.atEnd()))
 374                 {
 375                         v[count] = t.readLine();
 376                         count++;
 377                 }; // while ((count<3) && (!f.atEnd()))
 378                 if (3 == count)
 379                 {
 380                         verbSpanish NewVerb;
 381                         NewVerb.setSpanish(v[0]);
 382                         NewVerb.setForeign(v[1]);
 383                         int     g = v[2].toInt();
 384                         if (IRREGULAR != g)
 385                         {
 386                                 // ein regelmäßiges Verb
 387                                 NewVerb.setGroup(g);
 388                         }
 389                         else
 390                         {
 391                                 // ein unregelmäßiges Verb
 392                                 NewVerb.setGroup(IRREGULAR);
 393                                 // erst den Gerund und das Partizip einlesen und dann die restlichen Formen.
 394                                 NewVerb.setGerund(t.readLine());
 395                                 NewVerb.setPartizip(t.readLine());
 396                                 count = 0;
 397                                 for (int i = presente; i <= imperativo; i++)
 398                                         for (int j = yo; j <= ellos; j++)
 399                                                 if (!f.atEnd())
 400                                                 {
 401                                                         NewVerb.setForm(i, j, t.readLine());
 402                                                         count++;
 403                                                 };
 404                                 if (count < 54)
 405                                 {
 406                                         QMessageBox mb("kverbos warning", "An uncomplete verb has been found in the file",
 407                                                                         QMessageBox::Warning, 1, 0, 0, 0);
 408                                         mb.exec();
 409                                         //qWarning("Ein unvollständiges Verb kam vor!");
 410                                 };
 411                         };
 412                         appendVerb(NewVerb, false); // an die Liste anhängen
 413                 };
 414         }; // while (!f.atEnd())
 415         emit anzahlVerbenGeaendert(getAnzahl());
 416         return true;
 417 }
 418
 419 // sichert die Datei. Die Verben werden in einer Datei im HTML Format gespeichert.
 420 bool KVerbosDoc::saveDocument(const KURL& url, const char *format /*=0*/)
 421 {
 422         bool b = false;
 423         QFile file(url.path());
 424         if ( file.open(IO_WriteOnly) )
 425         {    // file opened successfully
 426                 if ((url.fileName().right(4) == "html")||(url.fileName().right(3) == "htm"))
 427                 {
 428                         // qWarning("als HTML speichern");
 429                         b = saveDocHTML(file);
 430                 }
 431                 else
 432                 {
 433                         // qWarning("als .verbos speichern");
 434                         b = saveDocVERBOS(file);
 435                 };
 436         };
 437         file.close();
 438         modified=false;
 439         return b;
 440 }
 441
 442 // Die Verben als HTML-Datei abspeichern
 443 bool KVerbosDoc::saveDocHTML(QFile &f)
 444 {
 445         bool good = true;
 446   QTextStream t( &f );           // use a text stream
 447   // Den Anfang der HTML Datei schreiben
 448   t << "<html>" << endl;
 449   t << "<head>" << endl;
 450   t << "<title>verbos espa&ntilde;oles</title>" << endl;
 451   t << "<style type=\"text/css\">" << endl;
 452         t << "<!--" << endl;
 453         t << "h1 { font-size:48pt; color:#FF0000; font-family:Arial; text-align:center; }" << endl;
 454         t << ".n { font-size:12pt; color:#000000; font-family:Arial; margin:0pt; }" << endl;
 455         t << ".v   { font-size:16pt; color:#0000ff; font-family:Arial; }" << endl;
 456         t << ".r   { font-size:16pt; color:#b0b0ff; font-family:Arial; }" << endl;
 457         t << ".t { background-color:#f0f0f0; padding:4pt; font-size:12pt; color:#000000; font-family:Arial; margin:0pt; }" << endl;
 458         t << "td { background-color:#ffffff; padding:4pt; font-size:12pt; color:#000000; font-family:Arial; margin:0pt; }" << endl;
 459         t << "//-->" << endl;
 460   t << "</style>" << endl;
 461   t << "</head>" << endl;
 462   t << "<body>" << endl;
 463   t << "<h1>verbos espa&ntilde;oles</h1>" << endl;
 464         t << "<p class=\"n\">";
 465         t << "Als regelm&auml;&szlig;ig gelten in diesem Programm alle Verben, die sich " << endl;
 466         t << "ohne geringste Abweichung an das Konjugationsschema für die Verben mit den " << endl;
 467         t << "Endungen -ar, -er und -ir halten. Die Gruppenverben, die auch eine gewisse " << endl;
 468         t << "Regelm&auml;&szlig;keit f&uuml;r eine Gruppe von Verben erkennen lassen, " << endl;
 469         t << "m&uuml;ssen als unregelm&auml;&szlig;ige eingegeben werden. </p>" << endl;
 470         t << "<p class=\"n\">";
 471         t << "Die Formen des 'subjuntivo futuro' werden einstweilen nicht mit in das " << endl;
 472         t << "Programm aufgenommen. </p>" << endl;
 473         t << "<p class=\"n\">";
 474         t << "Diese Datei wurde automatisch durch das Programm KVerbos erstellt. Die " << endl;
 475         t << "Verben wurden dabei in einem Format ausgegeben, die das Programm auch " << endl;
 476         t << "wieder einlesen kann. Deshalb sollten an der Datei keine &Auml;nderungen " << endl;
 477         t << "vorgenommen werden. Durch &Auml;nderungen kann die Datei f&uuml;r das Programm " << endl;
 478         t << "unlesbar werden. <br></p>" << endl;
 479   // Die Verbenliste in die Datei schreiben.
 480   if (verbList2.isEmpty())
 481   {
 482     t << "<p class=\"n\">Es wurden keine Verben eingegeben.</p>" << endl;
 483   }
 484   else
 485   {
 486     spanishVerbList::Iterator it;
 487     for (it = verbList2.begin(); it != verbList2.end(); ++it)
 488     {
 489         // erst die spanische und die deutsche Bedeutung abspeichern und den Typ
 490         t << "<hr color=#000000 size=3 noshade>" << endl;
 491                 t << "<table width=100% border=\"0\"><tr>" << endl;
 492                 t << "<td width=37% class=\"v\">" << (*it).getSpanish() << "</td>" << endl;
 493         t << "<td width=37% class=\"v\">" << (*it).getForeign() << "</td>" << endl;
 494         if ((*it).isGroupVerb())
 495         {
 496           t << "<td width=26% class=\"r\">";
 497                                 switch ((*it).getGroup())
 498                                 {
 499                                         case 0:
 500                                                 t << "regelm&auml;&szlig;ig</td>" << endl; break;
 501                                         case 2:
 502                                                 t << "&lt;e &gt; ie&gt;</td>" << endl; break;
 503                                         case 3:
 504                                                 t << "&lt;o &gt; ue&gt;</td>" << endl; break;
 505                                         case 4:
 506                                                 t << "&lt;u &gt; ue&gt;</td>" << endl; break;
 507                                         case 5:
 508                                                 t << "&lt;e &gt; i&gt;</td>" << endl; break;
 509                                         case 6:
 510                                                 t << "&lt;c &gt; qu&gt;</td>" << endl; break;
 511                                         case 7:
 512                                                 t << "&lt;g &gt; gu&gt;</td>" << endl; break;
 513                                         case 8:
 514                                                 t << "&lt;z &gt; c&gt;</td>" << endl; break;
 515                                         case 9:
 516                                                 t << "&lt;gu &gt; gü&gt;</td>" << endl; break;
 517                                         case 10:
 518                                                 t << "&lt;c &gt; z&gt;</td>" << endl; break;
 519                                         case 11:
 520                                                 t << "&lt;g &gt; j&gt;</td>" << endl; break;
 521                                         case 12:
 522                                                 t << "&lt;gu &gt; g&gt;</td>" << endl; break;
 523                                         case 13:
 524                                                 t << "&lt;qu &gt; c&gt;</td>" << endl; break;
 525                                         case 14:
 526                                                 t << "&lt;accent like 'enviar'&gt;</td>" << endl; break;
 527                                         case 15:
 528                                                 t << "&lt;accent like 'continuar&gt;</td>" << endl; break;
 529                                         case 16:
 530                                                 t << "&lt;missing i&gt;</td>" << endl; break;
 531                                         default:
 532                                                 good = false;
 533                                                 //qWarning("Error! Wrong group!!");
 534                                 };
 535         }
 536         else
 537         {
 538           t << "<td width=26% class=\"r\">unregelm&auml;&szlig;ig</td>" << endl;
 539         };
 540         t << "</tr></table>" << endl;
 541         // Im Falle eines unregelmäßigen Verbes, die Formen sichern
 542         if ((*it).isGroupVerb() == false)
 543         {
 544                         t << "<table width=100%  border=\"0\">" << endl;
 545                                 t << "<colgroup><col width=20%><col width=20%><col width=20%><col width=20%><col width=20%></colgroup>" << endl;
 546                                 // erster Teil der Tabelle
 547                                 t << "<tr>" << endl;
 548                                 t << "<td class=\"t\">presente</td>" << endl;
 549                                 t << "<td class=\"t\">imperfecto</td>" << endl;
 550                                 t << "<td class=\"t\">indefinido</td>" << endl;
 551                                 t << "<td class=\"t\">futuro</td>" << endl;
 552                                 t << "<td class=\"t\">gerundio</td>" << endl;
 553                                 t << "</tr>" << endl;
 554                                 int i;
 555                                 for (i = yo; i <= ellos; i++)
 556                                 {
 557                                   t << "<tr>" << endl;
 558                                   for (int j = presente; j <= futuro; j++)
 559                                   {
 560                                   // Formen presente, imperfecto, indefinido, futuro
 561                                   t << "<td>";
 562                                   if ((*it).isReflexiv())
 563               t << (*it).getRefPron(i) << ' ';
 564                                     t << (*it).getForm(j, i) << "</td>" << endl;
 565                                   };
 566                                   // Sonderformen gerundio und participo
 567                                   switch (i)
 568                                   {
 569                                     case 0:
 570                     t << "<td>" << (*it).getGerund() << "</td>" << endl;
 571                                                         break;
 572                                                 case 2:
 573                                                   t << "<td class=\"t\">" << "participo</td>" << endl;
 574                                                         break;
 575                                                 case 3:
 576                                                   t << "<td>" << (*it).getPartizip() << "</td>" << endl;
 577                                                         break;
 578                                                 default:
 579                                                   t << "<td></td>" << endl;
 580                                   }
 581                                   t << "</tr>" << endl;
 582                                 }
 583                                 t << "<tr>" << endl;
 584                                 t << "<td></td><td></td><td></td><td></td><td></td>";
 585                                 t << "</tr>";
 586         // zweiter Teil der Tabelle
 587                                 t << "<tr>" << endl;
 588                                 t << "<td class=\"t\">condicional</td>" << endl;
 589                                 t << "<td class=\"t\">subjuntivo presente</td>" << endl;
 590                                 t << "<td class=\"t\">subjuntivo imperfecto</td>" << endl;
 591                                 t << "<td class=\"t\">subjuntivo futuro</td>" << endl;
 592                                 t << "<td class=\"t\">imperativo</td>" << endl;
 593                                 t << "</tr>" << endl;
 594                                 for (i = yo; i <= ellos; i++)
 595                                 {
 596                                   t << "<tr>" << endl;
 597                                   for (int j = condicional; j <= imperativo; j++)
 598                                   {
 599                                   // Formen condicional, subjuntivo presente, subjuntivo imperfecto
 600                                   // subjuntivo futuro, imperativo
 601                                   t << "<td>";
 602                                   if ((*it).isReflexiv())
 603               t << (*it).getRefPron(i) << ' ';
 604                                     t << (*it).getForm(j, i) << "</td>" << endl;
 605                             };
 606                                   t << "</tr>" << endl;
 607                                 }
 608                                 t << "</table>" << endl;
 609         }
 610                   t << "<p></p>" << endl;
 611                 };
 612         };
 613   // Das Ende der HTML Datei anfügen.
 614   t << "</body>" << endl;
 615   t << "</html>" << endl;
 616   return good;
 617 }
 618
 619 bool KVerbosDoc::saveDocVERBOS(QFile &f)
 620 {
 621   QTextStream t( &f );           // use a text stream
 622   // Die Verbenliste in die Datei schreiben.
 623   if (verbList2.isEmpty())
 624   {
 625     t << "Es wurden keine Verben eingegeben." << endl;
 626   }
 627   else
 628   {
 629     spanishVerbList::Iterator it;
 630     for (it = verbList2.begin(); it!=verbList2.end(); ++it)
 631     {
 632         // erst die spanische und die deutsche Bedeutung abspeichern und den Typ
 633                 t << (*it).getSpanish() << endl;
 634         t << (*it).getForeign() << endl;
 635         t << (*it).getGroup() << endl;
 636         // Im Falle eines unregelmäßigen Verbes, die Formen sichern
 637         if ((*it).isGroupVerb() == false)
 638         {
 639                           t << (*it).getGerund() << endl;
 640                           t << (*it).getPartizip() << endl;
 641                           for (int j = presente; j <= imperativo; j++)
 642                                 {
 643                                 for (int i = yo; i <= ellos; i++)
 644                                   {
 645                                     t << (*it).getForm(j, i) << endl;
 646                                   };
 647                                 };
 648                         };
 649                 };
 650         };
 651   return true;
 652 }
 653
 654 void KVerbosDoc::deleteContents()
 655 {
 656         verbList2.clear();
 657         emit anzahlVerbenGeaendert(getAnzahl());
 658 }
 659
 660 // Ein Verb wird der Liste hinzugefügt.
 661 void KVerbosDoc::appendVerb(const verbSpanish v, bool emitStatus /*= true*/)
 662 {
 663   verbList2.append(v);
 664   if (emitStatus)
 665     emit anzahlVerbenGeaendert(getAnzahl());
 666 }
 667
 668 // es wird geprüft, ob die Liste leer ist.
 669 bool KVerbosDoc::isEmpty() const
 670 {
 671   return verbList2.isEmpty();
 672 }
 673
 674 // Gibt die Liste des Dokumentes zurück.
 675 spanishVerbList* KVerbosDoc::getList()
 676 {
 677   return &verbList2;
 678 }
 679
 680 // Diese Funktion ist auch die einzige über die diese Abfrage läuft, deshalb erhält sie auch
 681 // die Aufgabe eine Auswahl anzuregen.
 682 // Reihenfolge in dem Stringfeld: yo, tu, el, nosotros, vosotros, ellos, aleman, espanol
 683 // Wird "- - - - - -" zurückgegeben, dann gibt es kein Verb in der Liste. Normalerweise
 684 // wird die spanische Verbform zurückgegeben.
 685 QString KVerbosDoc::getAuswahl(QString s[][3], int &t)
 686 {
 687         bool verbOK = true;
 688         // feststellen, wie viele aktivierte Zeiten in den Optionen vorhanden sind
 689         int ti[MAX_TIEMPOS*MAX_SUBTYPES], ty[MAX_TIEMPOS*MAX_SUBTYPES];
 690         bool op[MAX_TIEMPOS][MAX_SUBTYPES];
 691         int zeitenZahl = 0;
 692         KVerbosApp *app = dynamic_cast<KVerbosApp*>(parent());
 693         if (app) {
 694                 app->getTimeOptions(op);
 695         }
 696         for (int i=0; i<MAX_TIEMPOS; i++)
 697                 for (int j=0; j<MAX_SUBTYPES; j++)
 698                         if (op[i][j])
 699                         {
 700                                 ti[zeitenZahl] = i;
 701                                 ty[zeitenZahl] = j;
 702                                 zeitenZahl++;
 703                         };
 704         if ((0 == verbList2.count()) || (0 == zeitenZahl))
 705         {
 706                 // Die Liste ist leer oder keine Zeit ist ausgewählt.
 707                 for (int i=0; i<PERSONEN+1; i++)
 708                 {
 709                         s[i][0] = "- - - - - -";
 710                         s[i][1] = "- - - - - -";
 711                         s[i][2] = "- - - - - -";
 712                         t = 0;
 713                 };
 714         }
 715         else
 716         {
 717                 spanishVerbList::Iterator it = findVerb(benutzer->suggestVerb());
 718                 if (it == verbList2.end())
 719                 {
 720                         it = verbList2.at(rand() % verbList2.count());
 721                 };
 722                 zeitenZahl = rand() % zeitenZahl;
 723                 // die deutsche und die spanische Form übernehmen
 724                 s[6][0] = (*it).getSpanish();
 725                 s[6][1] = (*it).getForeign();
 726                 // die einzelnen Formen zusammenstellen
 727                 for (int i=0; i<PERSONEN; i++)
 728                 {
 729                         verbOK = verbOK && (*it).getForm(ti[zeitenZahl], i, ty[zeitenZahl], s[i]);
 730                 };
 731                 t = ti[zeitenZahl] + ty[zeitenZahl]*MAX_TIEMPOS;
 732         };
 733         if (!verbOK)
 734         {
 735                 QMessageBox mb("kverbos warning", "There is a problem with the verb " + s[6][0] +
 736                                                 ".\nPlease check the verb in the edit dialog.", QMessageBox::Warning, 1, 0, 0, 0);
 737                 mb.exec();
 738                 for (int i=0; i<PERSONEN+1; i++)
 739                 {
 740                         s[i][0] = "- - - - - -";
 741                         s[i][1] = "- - - - - -";
 742                         s[i][2] = "- - - - - -";
 743                         t = 0;
 744                 };
 745         };
 746         return s[6][1];
 747 }
 748
 749 spanishVerbList::Iterator KVerbosDoc::findVerb(const QString& s)
 750 {
 751         spanishVerbList::Iterator it = verbList2.begin();
 752         while ((it != verbList2.end()) && (!((*it) == s)))
 753                 it++;
 754         return it;
 755 }
 756
 757 void KVerbosDoc::solved(const bool b)
 758 {
 759         if (benutzer!=0)
 760                 if (b)
 761                   benutzer->right();
 762                 else
 763                   benutzer->wrong();
 764 }
 765
 766 // sets a new user name, and deletes the old one. If the old one is differet from
 767 // the default name'-------' then some information is stored about the user. The
 768 // Program look if some information about the user is stored.
 769 void KVerbosDoc::setNewUser(const QString n)
 770 {
 771         if (0 != benutzer)
 772         {
 773                 int result, number;
 774                 pViewList->first()->userChanged(result, number);
 775                 benutzer->saveUser(result, number);
 776                 delete benutzer;
 777         };
 778         // prüfen ob über den Nutzer schon was gespeichert ist.
 779         benutzer = new KVerbosUser(getList(), n);
 780 }
 781
 782 #include "kverbosdoc.moc"