File indexing completed on 2024-04-28 07:36:29

 /*
  * Vocabulary Document for KDE Edu
  * SPDX-FileCopyrightText: 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
  * SPDX-FileCopyrightText: 2005-2007 Peter Hedlund <peter.hedlund@kdemail.net>
  * SPDX-FileCopyrightText: 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 #include "keduvocdocument.h"
 
 #include <QCoreApplication>
 #include <QFileInfo>
 #include <QIODevice>
 #include <QTemporaryFile>
 #include <QTextStream>
 #include <QtAlgorithms>
 
 #include <KAutoSaveFile>
 #include <KCompressionDevice>
 #include <KLazyLocalizedString>
 #include <KLocalizedString>
 #include <QDebug>
 #include <kio/filecopyjob.h>
 
 #include "keduvoccsvwriter.h"
 #include "keduvocexpression.h"
 #include "keduvockvtml2writer.h"
 #include "keduvocleitnerbox.h"
 #include "keduvoclesson.h"
 #include "keduvocwordtype.h"
 #include "readerwriters/readerbase.h"
 #include "readerwriters/readermanager.h"
 
 #define WQL_IDENT "WordQuiz"
 
 #define KVTML_EXT "kvtml"
 #define CSV_EXT "csv"
 #define TXT_EXT "txt"
 #define WQL_EXT "wql"
 
 /** @details Private Data class for KEduVocDocument */
 class KEduVocDocument::KEduVocDocumentPrivate
 {
 public:
     /** constructor */
     KEduVocDocumentPrivate(KEduVocDocument *qq)
         : q(qq)
     {
         m_lessonContainer = nullptr;
         m_wordTypeContainer = nullptr;
         m_leitnerContainer = nullptr;
         m_autosave = new KAutoSaveFile;
         init();
     }
 
     /** destructor */
     ~KEduVocDocumentPrivate();
 
     /** initializer */
     void init();
 
     KEduVocDocument *q; ///< The Front End
 
     /** autosave file used to provide locking access to the underlying file
      * Note: It is a pointer to allow locking a new file, saving results and
      * then transferring the lock to m_autosave without risking loss of lock.
      * See saveAs for clarification*/
     KAutoSaveFile *m_autosave;
 
     bool m_dirty; ///< dirty bit
     bool m_isReadOnly; ///< FileOpenReadOnly was used for opening
 
     // save these to document
     QList<KEduVocIdentifier> m_identifiers; ///< list of identifiers
 
     QList<int> m_extraSizeHints; ///< unused
     QList<int> m_sizeHints; ///< unused
 
     QString m_generator; ///< name of generating application
     QString m_queryorg; ///< unused
     QString m_querytrans; ///< unused
 
     QStringList m_tenseDescriptions; ///< unused. Was used in merge
     QSet<QString> m_usages; ///< unused
 
     QString m_title; ///< Document title
     QString m_author; ///< Document author
     QString m_authorContact; ///< Author contact information
     QString m_license; ///< Document license
     QString m_comment; ///< Document comment
     QString m_version; ///< Document version
     QString m_csvDelimiter; ///< CSV delimiter
 
     /** Categories that can later be used to sork kvtml files:
      * language, music, children, anatomy
      */
     QString m_category; ///< Document category
 
     KEduVocLesson *m_lessonContainer; ///< Root lesson container
     KEduVocWordType *m_wordTypeContainer; ///< Root word types container
     /** Root Leitner container
      * (probably unused) This is not used in Parley
      * */
     KEduVocLeitnerBox *m_leitnerContainer;
 
     /** Creates an autosave file for fpath in order to lock the file
      *   @param autosave a reference to an allocated KAutosave
      *   @param fpath File path to the file to be locked
      *   @param flags Describes how to deal with locked file etc.
      *   @return ErrorCode where NoError is success
      *   */
     KEduVocDocument::ErrorCode initializeKAutoSave(KAutoSaveFile &autosave, QString const &fpath, FileHandlingFlags flags) const;
 };
 
 KEduVocDocument::KEduVocDocumentPrivate::~KEduVocDocumentPrivate()
 {
     delete m_lessonContainer;
     delete m_wordTypeContainer;
     delete m_leitnerContainer;
     delete m_autosave;
 }
 
 void KEduVocDocument::KEduVocDocumentPrivate::init()
 {
     delete m_lessonContainer;
     m_lessonContainer = new KEduVocLesson(i18nc("The top level lesson which contains all other lessons of the document.", "Document Lesson"), q);
     m_lessonContainer->setContainerType(KEduVocLesson::Lesson);
     delete m_wordTypeContainer;
     m_wordTypeContainer = new KEduVocWordType(i18n("Word types"));
 
     delete m_leitnerContainer;
     m_leitnerContainer = new KEduVocLeitnerBox(i18n("Leitner Box"));
 
     m_tenseDescriptions.clear();
     m_identifiers.clear();
     m_extraSizeHints.clear();
     m_sizeHints.clear();
     m_dirty = false;
     m_isReadOnly = false;
     m_queryorg = QLatin1String("");
     m_querytrans = QLatin1String("");
     m_autosave->setManagedFile(QUrl());
     m_author = QLatin1String("");
     m_title = QLatin1String("");
     m_comment = QLatin1String("");
     m_version = QLatin1String("");
     m_generator = QLatin1String("");
     m_csvDelimiter = QString('\t');
     m_usages.clear();
     m_license.clear();
     m_category.clear();
 }
 
 KEduVocDocument::ErrorCode
 KEduVocDocument::KEduVocDocumentPrivate::initializeKAutoSave(KAutoSaveFile &autosave, QString const &fpath, FileHandlingFlags flags) const
 {
     QList<KAutoSaveFile *> staleFiles = KAutoSaveFile::staleFiles(QUrl::fromLocalFile(fpath), QCoreApplication::instance()->applicationName());
     if (!staleFiles.isEmpty()) {
         if (flags & FileIgnoreLock) {
             foreach (KAutoSaveFile *f, staleFiles) {
                 f->open(QIODevice::ReadWrite);
                 f->remove();
                 delete f;
             }
         } else {
             qWarning() << i18n("Cannot lock file %1", fpath);
             return FileLocked;
         }
     }
 
     autosave.setManagedFile(QUrl::fromLocalFile(fpath));
     if (!autosave.open(QIODevice::ReadWrite)) {
         qWarning() << i18n("Cannot lock file %1", autosave.fileName());
         return FileCannotLock;
     }
 
     return NoError;
 }
 
 KEduVocDocument::KEduVocDocument(QObject *parent)
     : QObject(parent)
     , d(new KEduVocDocumentPrivate(this))
 {
 }
 
 KEduVocDocument::~KEduVocDocument()
 {
     delete d;
 }
 
 void KEduVocDocument::setModified(bool dirty)
 {
     d->m_dirty = dirty;
     Q_EMIT docModified(d->m_dirty);
 }
 
 KEduVocDocument::FileType KEduVocDocument::detectFileType(const QString &fileName)
 {
     KCompressionDevice f(fileName);
     f.open(QIODevice::ReadOnly);
 
     ReaderManager::ReaderPtr reader(ReaderManager::reader(f));
 
     f.close();
 
     return reader->fileTypeHandled();
 }
 
 KEduVocDocument::ErrorCode KEduVocDocument::open(const QUrl &url, FileHandlingFlags flags)
 {
     // save csv delimiter to preserve it in case this is a csv document
     QString csv = d->m_csvDelimiter;
     // clear all other properties
     d->init();
     if (!url.isEmpty()) {
         setUrl(url);
     }
     d->m_csvDelimiter = csv;
 
     KEduVocDocument::ErrorCode errStatus = Unknown;
     QString errorMessage = i18n("<qt>Cannot open file<br /><b>%1</b></qt>", url.toDisplayString());
 
     QString temporaryFile;
     QTemporaryFile tempFile;
     if (url.isLocalFile()) {
         temporaryFile = url.toLocalFile();
     } else {
         if (!tempFile.open()) {
             qWarning() << i18n("Cannot open tempfile %1", tempFile.fileName());
             return Unknown;
         }
         KIO::FileCopyJob *job = KIO::file_copy(url, QUrl::fromLocalFile(tempFile.fileName()), -1, KIO::Overwrite);
         if (!job->exec()) {
             qWarning() << i18n("Cannot download %1: %2", url.toDisplayString(), job->errorString());
             return FileDoesNotExist;
         }
         temporaryFile = tempFile.fileName();
     }
 
     if (flags & FileOpenReadOnly) {
         d->m_isReadOnly = true;
     }
 
     ErrorCode autosaveError = NoError;
 
     if (!d->m_isReadOnly) {
         autosaveError = d->initializeKAutoSave(*d->m_autosave, temporaryFile, flags);
         if (autosaveError != NoError) {
             return autosaveError;
         }
     }
 
     KCompressionDevice f(temporaryFile);
     if (f.open(QIODevice::ReadOnly)) {
         ReaderManager::ReaderPtr reader(ReaderManager::reader(f));
         errStatus = reader->read(*this);
 
         if (errStatus != KEduVocDocument::NoError) {
             errorMessage = i18n("Could not open or properly read \"%1\"\n(Error reported: %2)", url.toDisplayString(), reader->errorMessage());
         }
     } else {
         errStatus = FileCannotRead;
     }
 
     f.close();
 
     if (errStatus == KEduVocDocument::NoError) {
         setModified(false);
     } else {
         qWarning() << errorMessage;
     }
 
     return errStatus;
 }
 
 void KEduVocDocument::close()
 {
     if (!d->m_isReadOnly) {
         d->m_autosave->releaseLock();
     }
 }
 
 KEduVocDocument::ErrorCode KEduVocDocument::saveAs(const QUrl &url, FileType ft, FileHandlingFlags flags)
 {
     if (d->m_isReadOnly) {
         return FileIsReadOnly;
     }
 
     QUrl tmp(url);
 
     if (ft == Automatic) {
         if (tmp.path().right(strlen("." KVTML_EXT)) == "." KVTML_EXT)
             ft = Kvtml;
         else if (tmp.path().right(strlen("." CSV_EXT)) == "." CSV_EXT)
             ft = Csv;
         else {
             return FileTypeUnknown;
         }
     }
 
     QString errorMessage = i18n("Cannot write to file %1", tmp.toDisplayString());
 
     KAutoSaveFile *autosave;
 
     // If we don't care about the lock always create a new one
     // If we are changing files create a new lock
     if ((flags & FileIgnoreLock) || (d->m_autosave->managedFile() != tmp)) {
         autosave = new KAutoSaveFile;
         ErrorCode autosaveError = d->initializeKAutoSave(*autosave, tmp.toLocalFile(), flags);
         if (autosaveError != NoError) {
             delete autosave;
             return autosaveError;
         }
     }
 
     // We care about the lock and we think we still have it.
     else {
         autosave = d->m_autosave;
         // Is the lock still good?
         if (!autosave->exists()) {
             return FileCannotLock;
         }
     }
 
     QFile f(tmp.toLocalFile());
     if (!f.open(QIODevice::WriteOnly)) {
         qCritical() << i18n("Cannot write to file %1", f.fileName());
         return FileCannotWrite;
     }
 
     bool saved = false;
 
     switch (ft) {
     case Kvtml: {
         // write version 2 file
         KEduVocKvtml2Writer kvtmlWriter(&f);
         saved = kvtmlWriter.writeDoc(this, d->m_generator);
     } break;
         ///@todo port me
         //         case Kvtml1: {
         //             // write old version 1 file
         //             KEduVocKvtmlWriter kvtmlWriter( &f );
         //             saved = kvtmlWriter.writeDoc( this, d->m_generator );
         //         }
         //         break;
     case Csv: {
         KEduVocCsvWriter csvWriter(&f);
         saved = csvWriter.writeDoc(this, d->m_generator);
     } break;
     default: {
         qCritical() << "kvcotrainDoc::saveAs(): unknown filetype";
     } break;
     } // switch
 
     f.close();
 
     if (!saved) {
         qCritical() << "Error Saving File" << tmp.toDisplayString();
 
         if (autosave != d->m_autosave) {
             delete autosave;
         }
         return FileWriterFailed;
     }
 
     if (autosave != d->m_autosave) {
         // The order is important: release old lock, delete old locker and then claim new locker.
         d->m_autosave->releaseLock();
         delete d->m_autosave;
         d->m_autosave = autosave;
     }
 
     setModified(false);
     return NoError;
 }
 
 QByteArray KEduVocDocument::toByteArray(const QString &generator)
 {
     // no file needed
     KEduVocKvtml2Writer kvtmlWriter(nullptr);
     return kvtmlWriter.toByteArray(this, generator);
 }
 
 void KEduVocDocument::merge(KEduVocDocument *docToMerge, bool matchIdentifiers)
 {
     Q_UNUSED(docToMerge)
     Q_UNUSED(matchIdentifiers)
     qDebug() << "Merging of docs is not implemented"; /// @todo IMPLEMENT ME
     // This code was really horribly broken.
     // Now with the new classes we could attempt to reactivate it.
     // A rewrite might be easier.
 
     /*
       if (docToMerge) {
 
         QStringList new_names = docToMerge->lessonDescriptions();
 
         QStringList new_types = docToMerge->typeDescriptions();
 
         QStringList new_tenses = docToMerge->tenseDescriptions();
 
         QList<int> old_in_query = lessonsInPractice();
         QList<int> new_in_query = docToMerge->lessonsInPractice();
 
         QStringList new_usages = docToMerge->usageDescriptions();
 
         int lesson_offset = d->m_lessonDescriptions.count();
         for (int i = 0; i < new_names.count(); i++) {
           d->m_lessonDescriptions.append(new_names[i]);
         }
 
         for (int i = 0; i < new_in_query.count(); i++)
           old_in_query.append(new_in_query[i] + lesson_offset);
         setLessonsInPractice(old_in_query);
 
         int types_offset = d->m_typeDescriptions.count();
         for (int i = 0; i < new_types.count(); i++) {
           d->m_typeDescriptions.append(new_types[i]);
         }
 
         int tenses_offset = d->m_tenseDescriptions.count();
         for (int i = 0; i < new_tenses.count(); i++) {
           d->m_tenseDescriptions.append(new_tenses[i]);
         }
 
         int usages_offset = d->m_usageDescriptions.count();
         for (int i = 0; i < new_usages.count(); i++) {
           d->m_usageDescriptions.append(new_usages[i]);
         }
 
         bool equal = true;
         if (originalIdentifier() != docToMerge->originalIdentifier())
           equal = false;
         for (int i = 1; i < identifierCount(); i++)
           if (identifier(i) != docToMerge->identifier(i))
             equal = false;
 
         if (!matchIdentifiers)
           equal = true; ///@todo massive cheating, problem if docToMerge has more identifiers than this
 
         if (equal) {   // easy way: same language codes, just append
 
           for (int i = 0; i < docToMerge->entryCount(); i++) {
             KEduVocExpression *expr = docToMerge->entry(i);
 
             expr->setLesson(expr->lesson() + lesson_offset);
 
             for (int lang = 0; lang <= expr->translationCount(); lang++) {
               QString t = expr->translation(lang).type();
               // adjust type offset
               if (!t.isEmpty() && t.left(1) == QM_USER_TYPE) {
                 QString t2;
                 t.remove(0, 1);
                 t2.setNum(t.toInt() + types_offset);
                 t2.prepend(QM_USER_TYPE);
                 expr->translation(lang).setType (t2);
               }
 
               t = expr->translation(lang).usageLabel();
               // adjust usage offset
               QString tg;
               if (!t.isEmpty()) {
                 QString t2;
                 while (t.left(strlen(":")) == UL_USER_USAGE) {
                   QString n;
                   t.remove(0, 1);
                   int next;
                   if ((next = t.indexOf(":")) >= 0) {
                     n = t.left(next);
                     t.remove(0, next + 1);
                   }
                   else {
                     n = t;
                     t = "";
                   }
 
                   t2.setNum(n.toInt() + usages_offset);
                   t2.prepend(UL_USER_USAGE);
                   if (tg.length() == 0)
                     tg = t2;
                   else
                     tg += ':' + t2;
                 }
 
                 if (tg.length() == 0)
                   tg = t;
                 else if (t.length() != 0)
                   tg += ':' + t;
 
                 expr->translation(lang).setUsageLabel (tg);
               }
 
               KEduVocConjugation conj = expr->translation(lang).conjugation();
               bool condirty = false;
               for (int ci = 0; ci < conj.entryCount(); ci++) {
                 t = conj.getType(ci);
                 if (!t.isEmpty() && t.left(1) == UL_USER_TENSE) {
                   t.remove(0, strlen(UL_USER_TENSE));
                   QString t2;
                   t2.setNum(t.toInt() + tenses_offset);
                   t2.prepend(UL_USER_TENSE);
                   conj.setType(ci, t2);
                   condirty = true;
                 }
                 if (condirty)
                   expr->translation(lang).setConjugation(conj);
               }
             }
 
             appendEntry(expr);
           }
           setModified();
         }
         else { // hard way: move entries around, most attributes get lost
           QList<int> move_matrix;
           QList<bool> cs_equal;
           QString s;
 
           for (int i = 0; i < qMax (identifierCount(), docToMerge->identifierCount()); i++)
             cs_equal.append(false);
 
           move_matrix.append(docToMerge->indexOfIdentifier(originalIdentifier()));
           for (int i = 1; i < identifierCount(); i++)
             move_matrix.append(docToMerge->indexOfIdentifier(identifier(i)));
 
           for (int j = 0; j < docToMerge->entryCount(); j++) {
             KEduVocExpression new_expr;
             KEduVocExpression *expr = docToMerge->entry(j);
             new_expr.setLesson(expr->lesson()+lesson_offset);
 
             for (int i = 0; i < move_matrix.count(); i++) {
               int lpos = move_matrix[i];
               if (lpos >= 0) {
 
                 if (lpos == 0)
                   s = expr->original();
                 else
                   s = expr->translation(lpos);
 
                 if (!cs_equal[lpos]) {
                   cs_equal[lpos] = true;
                   QString id = lpos == 0 ? originalIdentifier() : identifier(lpos);
                 }
 
                 if (i == 0)
                   new_expr.setOriginal(s);
                 else
                   new_expr.setTranslation(i, s);
                 QString r = expr->remark(lpos);
                 new_expr.setRemark (i, r);
 
                 QString t = expr->type(lpos);
                 if (!t.isEmpty() && t.left(1) == QM_USER_TYPE) {
                   QString t2;
                   t.remove(0, 1);
                   t2.setNum(t.toInt() + types_offset);
                   t2.prepend(QM_USER_TYPE);
                   new_expr.setType(i, t2);
                 }
 
                 t = expr->usageLabel(lpos);
                 if (!t.isEmpty() && t.left(1) == QM_USER_TYPE) {
                   QString t2;
                   t.remove(0, 1);
                   t2.setNum(t.toInt() + usages_offset);
                   t2.prepend(QM_USER_TYPE);
                   new_expr.setUsageLabel(i, t2);
                 }
 
                 KEduVocConjugation conj = expr->conjugation(lpos);
                 for (int ci = 0; ci < conj.entryCount(); ci++) {
                   t = conj.getType(ci);
                   if (!t.isEmpty() && t.left(1) == QM_USER_TYPE) {
                     t.remove (0, strlen(QM_USER_TYPE));
                     QString t2;
                     t2.setNum(t.toInt() + tenses_offset);
                     t2.prepend(QM_USER_TYPE);
                     conj.setType(ci, t2);
                   }
                 }
 
               }
             }
             // only append if entries are used
             bool used = !new_expr.original().isEmpty();
             for (int i = 1; i < identifierCount(); i++)
               if (!new_expr.translation(i).isEmpty())
                 used = true;
 
             if (used) {
               appendEntry(&new_expr);
               setModified();
             }
           }
         }
       }
     */
 }
 
 const KEduVocIdentifier &KEduVocDocument::identifier(int index) const
 {
     if (index < 0 || index >= d->m_identifiers.size()) {
         qCritical() << " Error: Invalid identifier index: " << index;
     }
     return d->m_identifiers[index];
 }
 
 KEduVocIdentifier &KEduVocDocument::identifier(int index)
 {
     if (index < 0 || index >= d->m_identifiers.size()) {
         qCritical() << " Error: Invalid identifier index: " << index;
     }
     return d->m_identifiers[index];
 }
 
 void KEduVocDocument::setIdentifier(int idx, const KEduVocIdentifier &id)
 {
     if (idx >= 0 && idx < d->m_identifiers.size()) {
         d->m_identifiers[idx] = id;
     }
     setModified(true);
 }
 
 // works if const is removed
 int KEduVocDocument::indexOfIdentifier(const QString &name) const
 {
     for (int i = 0; i < identifierCount(); i++)
         if (identifier(i).locale() == name)
             return i;
     return -1;
 }
 
 void KEduVocDocument::removeIdentifier(int index)
 {
     if (index < d->m_identifiers.size() && index >= 0) {
         d->m_identifiers.removeAt(index);
         d->m_lessonContainer->removeTranslation(index);
     }
 }
 
 bool KEduVocDocument::isModified() const
 {
     return d->m_dirty;
 }
 
 int KEduVocDocument::identifierCount() const
 {
     return d->m_identifiers.count(); // number of translations
 }
 
 int KEduVocDocument::appendIdentifier(const KEduVocIdentifier &id)
 {
     int i = d->m_identifiers.size();
     // qDebug() << "appendIdentifier: " << i << id.name() << id.locale();
     d->m_identifiers.append(id);
     if (id.name().isEmpty()) {
         if (i == 0) {
             identifier(i).setName(i18nc("The name of the first language/column of vocabulary, if we have to guess it.", "Original"));
         } else {
             identifier(i).setName(i18nc("The name of the second, third ... language/column of vocabulary, if we have to guess it.", "Translation %1", i));
         }
     }
 
     return i;
 }
 
 KEduVocLesson *KEduVocDocument::lesson()
 {
     return d->m_lessonContainer;
 }
 
 KEduVocWordType *KEduVocDocument::wordTypeContainer()
 {
     return d->m_wordTypeContainer;
 }
 
 KEduVocLeitnerBox *KEduVocDocument::leitnerContainer()
 {
     return d->m_leitnerContainer;
 }
 
 QUrl KEduVocDocument::url() const
 {
     return d->m_autosave->managedFile();
 }
 
 void KEduVocDocument::setUrl(const QUrl &url)
 {
     d->m_autosave->setManagedFile(url);
 }
 
 QString KEduVocDocument::title() const
 {
     if (d->m_title.isEmpty())
         return d->m_autosave->managedFile().fileName();
     else
         return d->m_title;
 }
 
 void KEduVocDocument::setTitle(const QString &title)
 {
     d->m_title = title;
     ///@todo decouple document title and root lesson title
     d->m_lessonContainer->setName(title);
     setModified(true);
 }
 
 QString KEduVocDocument::author() const
 {
     return d->m_author;
 }
 
 void KEduVocDocument::setAuthor(const QString &s)
 {
     d->m_author = s.simplified();
     setModified(true);
 }
 
 QString KEduVocDocument::authorContact() const
 {
     return d->m_authorContact;
 }
 
 void KEduVocDocument::setAuthorContact(const QString &s)
 {
     d->m_authorContact = s.simplified();
     setModified(true);
 }
 
 QString KEduVocDocument::license() const
 {
     return d->m_license;
 }
 
 QString KEduVocDocument::documentComment() const
 {
     return d->m_comment;
 }
 
 void KEduVocDocument::setCategory(const QString &category)
 {
     d->m_category = category;
     setModified(true);
 }
 
 QString KEduVocDocument::category() const
 {
     return d->m_category;
     ///@todo make writer/reader use this
 }
 
 void KEduVocDocument::queryIdentifier(QString &org, QString &trans) const
 {
     org = d->m_queryorg;
     trans = d->m_querytrans;
 }
 
 void KEduVocDocument::setQueryIdentifier(const QString &org, const QString &trans)
 {
     d->m_queryorg = org;
     d->m_querytrans = trans;
     setModified(true);
 }
 
 void KEduVocDocument::setLicense(const QString &s)
 {
     d->m_license = s.simplified();
     setModified(true);
 }
 
 void KEduVocDocument::setDocumentComment(const QString &s)
 {
     d->m_comment = s.trimmed();
     setModified(true);
 }
 
 void KEduVocDocument::setGenerator(const QString &generator)
 {
     d->m_generator = generator;
     setModified(true);
 }
 
 QString KEduVocDocument::generator() const
 {
     return d->m_generator;
 }
 
 QString KEduVocDocument::version() const
 {
     return d->m_version;
 }
 
 void KEduVocDocument::setVersion(const QString &vers)
 {
     d->m_version = vers;
     setModified(true);
 }
 
 QString KEduVocDocument::csvDelimiter() const
 {
     return d->m_csvDelimiter;
 }
 
 void KEduVocDocument::setCsvDelimiter(const QString &delimiter)
 {
     d->m_csvDelimiter = delimiter;
     setModified(true);
 }
 
 QString KEduVocDocument::pattern(FileDialogMode mode)
 {
     static const struct SupportedFilter {
         bool reading;
         bool writing;
         const char *extensions;
         const KLazyLocalizedString description;
     } filters[] = {{true, true, "*.kvtml", kli18n("KDE Vocabulary Document")},
                    {true, false, "*.wql", kli18n("KWordQuiz Document")},
                    {true, false, "*.xml.qz *.pau.gz", kli18n("Pauker Lesson")},
                    {true, false, "*.voc", kli18n("Vokabeltrainer")},
                    {true, false, "*.xdxf", kli18n("XML Dictionary Exchange Format")},
                    {true, true, "*.csv", kli18n("Comma Separated Values (CSV)")},
                    // last is marker for the end, do not remove it
                    {false, false, nullptr, KLazyLocalizedString()}};
     QStringList newfilters;
     QStringList allext;
     for (int i = 0; filters[i].extensions; ++i) {
         if ((mode == Reading && filters[i].reading) || (mode == Writing && filters[i].writing)) {
             newfilters.append(KLocalizedString(filters[i].description).toString() + " (" + QLatin1String(filters[i].extensions) + ')');
             allext.append(QLatin1String(filters[i].extensions));
         }
     }
     if (mode == Reading) {
         newfilters.prepend(allext.join(QLatin1Char(' ')) + '|' + i18n("All supported documents"));
     }
     return newfilters.join(QLatin1String(";;"));
 }
 
 QString KEduVocDocument::errorDescription(int errorCode)
 {
     switch (errorCode) {
     case NoError:
         return i18n("No error found.");
 
     case InvalidXml:
         return i18n("Invalid XML in document.");
     case FileTypeUnknown:
         return i18n("Unknown file type.");
     case FileCannotWrite:
         return i18n("File is not writeable.");
     case FileWriterFailed:
         return i18n("File writer failed.");
     case FileCannotRead:
         return i18n("File is not readable.");
     case FileReaderFailed:
         return i18n("The file reader failed.");
     case FileDoesNotExist:
         return i18n("The file does not exist.");
     case FileLocked:
         return i18n("The file is locked by another process.");
     case FileCannotLock:
         return i18n("The lock file can't be created.");
     case Unknown:
     default:
         return i18n("Unknown error.");
     }
 }
 
 #include "moc_keduvocdocument.cpp"