kvoctrain/kvoctrain/kvt-core/GrammerManager.cpp

   1 /***************************************************************************
   2
   3              manage grammar parts (articles, conjugation)
   4
   5     -----------------------------------------------------------------------
   6
   7     begin          : Sat Nov 27 09:50:53 MET 1999
   8
   9     copyright      : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
  10                      (C) 2001 The KDE-EDU team
  11                      (C) 2004-2005 Peter Hedlund <peter@peterandlinda.com>
  12
  13     -----------------------------------------------------------------------
  14
  15  ***************************************************************************/
  16
  17 /***************************************************************************
  18  *                                                                         *
  19  *   This program is free software; you can redistribute it and/or modify  *
  20  *   it under the terms of the GNU General Public License as published by  *
  21  *   the Free Software Foundation; either version 2 of the License, or     *
  22  *   (at your option) any later version.                                   *
  23  *                                                                         *
  24  ***************************************************************************/
  25
  26 #include "GrammerManager.h"
  27
  28 #include <klocale.h>
  29
  30 Conjugation::conjug_name_t
  31 Conjugation::names [] =
  32 {
  33   { CONJ_SIMPLE_PRESENT,    I18N_NOOP("Simple Preset") },
  34   { CONJ_PRESENT_PROGR,     I18N_NOOP("Preset Progressive") },
  35   { CONJ_PRESENT_PERFECT,   I18N_NOOP("Preset Perfect") },
  36
  37   { CONJ_SIMPLE_PAST,       I18N_NOOP("Simple Past") },
  38   { CONJ_PAST_PROGR,        I18N_NOOP("Past Progressive") },
  39   { CONJ_PAST_PARTICIPLE,   I18N_NOOP("Past Participle") },
  40
  41   { CONJ_FUTURE,            I18N_NOOP("Future") }
  42 };
  43
  44
  45 vector<QString> Conjugation::userTenses;
  46
  47
  48 //================================================================
  49
  50 Comparison::Comparison (
  51            const QString &l1,
  52            const QString &l2,
  53            const QString &l3
  54           )
  55 {
  56    setL1 (l1);
  57    setL2 (l2);
  58    setL3 (l3);
  59 }
  60
  61
  62 bool Comparison::isEmpty() const
  63 {
  64   return   ls1.stripWhiteSpace().isEmpty()
  65         && ls2.stripWhiteSpace().isEmpty()
  66         && ls3.stripWhiteSpace().isEmpty();
  67 }
  68
  69
  70 void Comparison::clear()
  71 {
  72    ls1 = "";
  73    ls2 = "";
  74    ls3 = "";
  75 }
  76
  77
  78 //=================================================================
  79
  80
  81 Article::Article
  82           (const QString &fem_def, const QString &fem_indef,
  83            const QString &mal_def, const QString &mal_indef,
  84            const QString &nat_def, const QString &nat_indef
  85           )
  86 {
  87    setFemale  (fem_def, fem_indef);
  88    setMale    (mal_def, mal_indef);
  89    setNatural (nat_def, nat_indef);
  90 }
  91
  92
  93 void Article::setFemale
  94   (const QString &def, const QString &indef)
  95 {
  96    fem_def = def;
  97    fem_indef = indef;
  98 }
  99
 100
 101 void Article::setMale
 102   (const QString &def, const QString &indef)
 103 {
 104    mal_def = def;
 105    mal_indef = indef;
 106 }
 107
 108
 109 void Article::setNatural
 110   (const QString &def, const QString &indef)
 111 {
 112    nat_def = def;
 113    nat_indef = indef;
 114 }
 115
 116
 117 void Article::female
 118   (QString &def, QString &indef) const
 119 {
 120    def = fem_def;
 121    indef = fem_indef;
 122 }
 123
 124
 125 void Article::male
 126   (QString &def, QString &indef) const
 127 {
 128    def = mal_def;
 129    indef = mal_indef;
 130 }
 131
 132
 133 void Article::natural
 134   (QString &def, QString &indef) const
 135 {
 136    def = nat_def;
 137    indef = nat_indef;
 138 }
 139
 140
 141
 142 //==============================================================
 143
 144
 145 int Conjugation::numEntries() const
 146 {
 147    return conjugations.size();
 148 }
 149
 150
 151 vector<TenseRelation> Conjugation::getRelation ()
 152 {
 153   vector<TenseRelation> vec;
 154
 155   for (int i = 0; i < numInternalNames(); i++) {
 156     vec.push_back(TenseRelation(names[i].abbrev,
 157                                 i18n(names[i].name)));
 158   }
 159
 160   for (int i = 0; i < (int) userTenses.size(); i++) {
 161     QString s;
 162     s.setNum(i+1);
 163     s.insert(0, UL_USER_TENSE);
 164     vec.push_back(TenseRelation(s, userTenses[i]));
 165   }
 166
 167   return vec;
 168 }
 169
 170
 171 void Conjugation::setTenseNames (vector<QString> names)
 172 {
 173   userTenses = names;
 174 }
 175
 176
 177 QString Conjugation::getName (const QString &abbrev)
 178 {
 179    if (abbrev.length() >= 2 && abbrev[0] == QString(UL_USER_TENSE)) {
 180      QString s = abbrev;
 181      s.remove(0, 1);
 182      int i = s.toInt() - 1;
 183
 184      if (i < (int) userTenses.size() )
 185        return userTenses[i];
 186      else
 187        return "";
 188    }
 189    else {
 190      for (int i = 0; i < (int) numInternalNames(); i++)
 191        if (names[i].abbrev == abbrev) {
 192          return i18n(names[i].name);
 193        }
 194    }
 195
 196    return "";
 197 }
 198
 199
 200 QString Conjugation::getName (int idx)
 201 {
 202    if (idx < numInternalNames() )
 203      return i18n(names[idx].name);
 204
 205    else if (idx < numTenses() )
 206      return userTenses[idx-numInternalNames()];
 207
 208    else
 209      return "";
 210 }
 211
 212
 213 QString Conjugation::getAbbrev (const QString &name)
 214 {
 215    for (int i = 0; i < (int) userTenses.size(); i++)
 216      if (userTenses[i] == name) {
 217        QString s;
 218        s.setNum(i+1);
 219        s.insert(0, UL_USER_TENSE);
 220        return s;
 221      }
 222
 223    for (int i = 0; i < (int) numInternalNames(); i++)
 224      if (names[i].name == name)
 225        return names[i].abbrev;
 226
 227    return "";
 228 }
 229
 230
 231 QString Conjugation::getAbbrev (int idx)
 232 {
 233    if (idx < numInternalNames() )
 234      return names[idx].abbrev;
 235
 236    else if (idx < numTenses() ) {
 237      QString s;
 238      s.setNum(idx-numInternalNames()+1);
 239      s.insert(0, UL_USER_TENSE);
 240      return s;
 241    }
 242
 243    else
 244      return "";
 245 }
 246
 247
 248 int Conjugation::numInternalNames()
 249 {
 250    return sizeof(names) / sizeof(names[0]);
 251 }
 252
 253
 254 int Conjugation::numTenses()
 255 {
 256    return numInternalNames()+userTenses.size();
 257 }
 258
 259
 260 QString Conjugation::getType (int idx)
 261 {
 262   if (idx >= (int) conjugations.size() )
 263     return "";
 264
 265   return conjugations[idx].type;
 266 }
 267
 268
 269 void Conjugation::setType (int idx, const QString & type)
 270 {
 271   if (idx >= (int) conjugations.size() )
 272     return;
 273
 274   conjugations[idx].type = type;
 275 }
 276
 277
 278 void Conjugation::cleanUp ()
 279 {
 280   for (int i = (int)conjugations.size()-1; i >= 0; i--) {
 281     const conjug_t *ctp = &conjugations[i];
 282     if (   ctp->pers1_sing.stripWhiteSpace().isEmpty()
 283         && ctp->pers2_sing.stripWhiteSpace().isEmpty()
 284         && ctp->pers3_m_sing.stripWhiteSpace().isEmpty()
 285         && ctp->pers3_f_sing.stripWhiteSpace().isEmpty()
 286         && ctp->pers3_n_sing.stripWhiteSpace().isEmpty()
 287         && ctp->pers1_plur.stripWhiteSpace().isEmpty()
 288         && ctp->pers2_plur.stripWhiteSpace().isEmpty()
 289         && ctp->pers3_m_plur.stripWhiteSpace().isEmpty()
 290         && ctp->pers3_f_plur.stripWhiteSpace().isEmpty()
 291         && ctp->pers3_n_plur.stripWhiteSpace().isEmpty()
 292        )
 293      conjugations.erase(conjugations.begin() + i);
 294   }
 295 }
 296
 297
 298 bool Conjugation::isEmpty (int idx)
 299 {
 300   if (idx < (int) conjugations.size()) {
 301     const conjug_t *ctp = &conjugations[idx];
 302     return ctp->pers1_sing.stripWhiteSpace().isEmpty()
 303         && ctp->pers2_sing.stripWhiteSpace().isEmpty()
 304         && ctp->pers3_m_sing.stripWhiteSpace().isEmpty()
 305         && ctp->pers3_f_sing.stripWhiteSpace().isEmpty()
 306         && ctp->pers3_n_sing.stripWhiteSpace().isEmpty()
 307         && ctp->pers1_plur.stripWhiteSpace().isEmpty()
 308         && ctp->pers2_plur.stripWhiteSpace().isEmpty()
 309         && ctp->pers3_m_plur.stripWhiteSpace().isEmpty()
 310         && ctp->pers3_f_plur.stripWhiteSpace().isEmpty()
 311         && ctp->pers3_n_plur.stripWhiteSpace().isEmpty();
 312   }
 313   return true;
 314 }
 315
 316
 317 #define _GET_CON_(elem, type, default) \
 318    for (int i = 0; i < (int) conjugations.size(); i++) \
 319      if (conjugations[i].type == type) \
 320         return conjugations[i].elem; \
 321    return default;
 322
 323
 324 bool Conjugation::pers3SingularCommon(const QString &type) const
 325 {
 326   _GET_CON_(s3common, type, false);
 327 }
 328
 329
 330 bool Conjugation::pers3PluralCommon(const QString &type) const
 331 {
 332   _GET_CON_(p3common, type, false);
 333 }
 334
 335
 336 QString Conjugation::pers1Singular
 337   (const QString &type) const
 338 {
 339   _GET_CON_(pers1_sing, type, "");
 340 }
 341
 342
 343 QString Conjugation::pers2Singular
 344   (const QString &type) const
 345 {
 346   _GET_CON_(pers2_sing, type, "");
 347 }
 348
 349
 350 QString Conjugation::pers3FemaleSingular
 351   (const QString &type) const
 352 {
 353   _GET_CON_(pers3_f_sing, type, "");
 354 }
 355
 356
 357 QString Conjugation::pers3MaleSingular
 358   (const QString &type) const
 359 {
 360   _GET_CON_(pers3_m_sing, type, "");
 361 }
 362
 363
 364 QString Conjugation::pers3NaturalSingular
 365   (const QString &type) const
 366 {
 367   _GET_CON_(pers3_n_sing, type, "");
 368 }
 369
 370
 371 QString Conjugation::pers1Plural
 372   (const QString &type) const
 373 {
 374   _GET_CON_(pers1_plur, type, "");
 375 }
 376
 377
 378 QString Conjugation::pers2Plural
 379   (const QString &type) const
 380 {
 381   _GET_CON_(pers2_plur, type, "");
 382 }
 383
 384
 385 QString Conjugation::pers3FemalePlural
 386   (const QString &type) const
 387 {
 388   _GET_CON_(pers3_f_plur, type, "");
 389 }
 390
 391
 392 QString Conjugation::pers3MalePlural
 393   (const QString &type) const
 394 {
 395   _GET_CON_(pers3_m_plur, type, "");
 396 }
 397
 398
 399 QString Conjugation::pers3NaturalPlural
 400   (const QString &type) const
 401 {
 402   _GET_CON_(pers3_n_plur, type, "");
 403 }
 404
 405
 406 #undef _GET_CON_
 407
 408
 409 #define _SET_CON_(elem, type, str) \
 410    for (int i = 0; i < (int) conjugations.size(); i++) \
 411      if (conjugations[i].type == type) { \
 412        conjugations[i].elem = str; \
 413        return; \
 414      } \
 415    conjug_t ct; \
 416    ct.type = type; \
 417    ct.elem = str; \
 418    conjugations.push_back(ct);
 419
 420
 421 void Conjugation::setPers3PluralCommon(const QString &type, bool f)
 422 {
 423   _SET_CON_(p3common, type, f);
 424 }
 425
 426
 427 void Conjugation::setPers3SingularCommon(const QString &type, bool f)
 428 {
 429   _SET_CON_(s3common, type, f);
 430 }
 431
 432
 433 void Conjugation::setPers1Singular
 434   (const QString &type, const QString &str)
 435 {
 436   _SET_CON_(pers1_sing, type, str);
 437 }
 438
 439
 440 void Conjugation::setPers2Singular
 441   (const QString &type, const QString &str)
 442 {
 443   _SET_CON_(pers2_sing, type, str);
 444 }
 445
 446
 447 void Conjugation::setPers3FemaleSingular
 448   (const QString &type, const QString &str)
 449 {
 450   _SET_CON_(pers3_f_sing, type, str);
 451 }
 452
 453
 454 void Conjugation::setPers3MaleSingular
 455   (const QString &type, const QString &str)
 456 {
 457   _SET_CON_(pers3_m_sing, type, str);
 458 }
 459
 460
 461 void Conjugation::setPers3NaturalSingular
 462   (const QString &type, const QString &str)
 463 {
 464   _SET_CON_(pers3_n_sing, type, str);
 465 }
 466
 467
 468 void Conjugation::setPers1Plural
 469   (const QString &type, const QString &str)
 470 {
 471   _SET_CON_(pers1_plur, type, str);
 472 }
 473
 474
 475 void Conjugation::setPers2Plural
 476   (const QString &type, const QString &str)
 477 {
 478   _SET_CON_(pers2_plur, type, str);
 479 }
 480
 481
 482 void Conjugation::setPers3FemalePlural
 483   (const QString &type, const QString &str)
 484 {
 485   _SET_CON_(pers3_f_plur, type, str);
 486 }
 487
 488
 489 void Conjugation::setPers3MalePlural
 490   (const QString &type, const QString &str)
 491 {
 492   _SET_CON_(pers3_m_plur, type, str);
 493 }
 494
 495
 496 void Conjugation::setPers3NaturalPlural
 497   (const QString &type, const QString &str)
 498 {
 499   _SET_CON_(pers3_n_plur, type, str);
 500 }
 501
 502 #undef _SET_CON_
 503