+++ /dev/null
-/***************************************************************************
-* this file is from kdeedu project. Filename: keduvocarticle.cpp
-***************************************************************************/
-
-/***************************************************************************
-
- Copyright 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
- Copyright 2004, 2005, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
- Copyright 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
-
- ***************************************************************************/
-
-/***************************************************************************
- * *
- * 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 "keduvocarticle.h"
-#include "keduvocwordflags.h"
-
-#include <QtCore/QMap>
-
-class KEduVocArticle::Private
-{
-public:
- QMap <KEduVocWordFlags, QString> m_articles;
-};
-
-KEduVocArticle::KEduVocArticle()
- :d( new Private )
-{}
-
-KEduVocArticle::KEduVocArticle( const KEduVocArticle &other )
- :d( new Private )
-{
- d->m_articles = other.d->m_articles;
-}
-
-KEduVocArticle &KEduVocArticle::operator= ( const KEduVocArticle& other )
-{
- d->m_articles = other.d->m_articles;
- return *this;
-}
-
-KEduVocArticle::KEduVocArticle( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &neu_def, const QString &neu_indef )
- :d( new Private )
-{
- setArticle( mal_def, KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Masculine );
- setArticle( fem_def, KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Feminine );
- setArticle( neu_def, KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Neuter );
-
- setArticle( mal_indef, KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Masculine );
- setArticle( fem_indef, KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Feminine );
- setArticle( neu_indef, KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Neuter );
-}
-
-KEduVocArticle::~KEduVocArticle()
-{
- delete d;
-}
-
-
-QString KEduVocArticle::article(const KEduVocWordFlags& flags)
-{
- return d->m_articles.value(flags & (KEduVocWordFlag::genders | KEduVocWordFlag::numbers | KEduVocWordFlag::Definite | KEduVocWordFlag::Indefinite));
-}
-
-void KEduVocArticle::setArticle(const QString & article, const KEduVocWordFlags& flags)
-{
- d->m_articles[flags & (KEduVocWordFlag::genders | KEduVocWordFlag::numbers | KEduVocWordFlag::Definite | KEduVocWordFlag::Indefinite)] = article;
-}
-
-
-bool KEduVocArticle::isArticle(const QString & article) const
-{
- return d->m_articles.values().contains(article);
-}
-
-bool KEduVocArticle::isEmpty()
-{
- // we don't count empty strings as articles
- foreach(const QString& s, d->m_articles)
- {
- if (!s.isEmpty())
- return false;
- }
- return true;
-}
-
-
-
Boston, MA 02110-1301, USA.
*/
-#ifndef LIBKEDUVOCDOCUMENT_EXPORT_H
-#define LIBKEDUVOCDOCUMENT_EXPORT_H
+#ifndef LIBQMVOCDOCUMENT_EXPORT_H
+#define LIBQMVOCDOCUMENT_EXPORT_H
/* needed for KDE_EXPORT and KDE_IMPORT macros */
// #include <kdemacros.h>
#ifndef KEDUVOCDOCUMENT_EXPORT
# if defined(MAKE_KEDUVOCDOCUMENT_LIB)
/* We are building this library */
-# define KEDUVOCDOCUMENT_EXPORT KDE_EXPORT
+# define QMVOCDOCUMENT_EXPORT KDE_EXPORT
# else
/* We are using this library */
-# define KEDUVOCDOCUMENT_EXPORT KDE_IMPORT
+# define QMVOCDOCUMENT_EXPORT KDE_IMPORT
# endif
#endif
# ifndef KEDUVOCDOCUMENT_EXPORT_DEPRECATED
-# define KEDUVOCDOCUMENT_EXPORT_DEPRECATED KDE_DEPRECATED KEDUVOCDOCUMENT_EXPORT
+# define KEDUVOCDOCUMENT_EXPORT_DEPRECATED KDE_DEPRECATED QMVOCDOCUMENT_EXPORT
# endif
#endif
-#define KUrl QUrl
--- /dev/null
+/***************************************************************************
+* this file is from kdeedu project. Filename: keduvocarticle.cpp
+***************************************************************************/
+
+/***************************************************************************
+
+ Copyright 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
+ Copyright 2004, 2005, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
+ Copyright 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.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 "qmvocarticle.h"
+#include "qmvocwordflags.h"
+
+#include <QtCore/QMap>
+
+class QmVocArticle::Private
+{
+public:
+ QMap <QmVocWordFlags, QString> m_articles;
+};
+
+QmVocArticle::QmVocArticle()
+ :d( new Private )
+{}
+
+QmVocArticle::QmVocArticle( const QmVocArticle &other )
+ :d( new Private )
+{
+ d->m_articles = other.d->m_articles;
+}
+
+QmVocArticle &QmVocArticle::operator= ( const QmVocArticle& other )
+{
+ d->m_articles = other.d->m_articles;
+ return *this;
+}
+
+QmVocArticle::QmVocArticle( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &neu_def, const QString &neu_indef )
+ :d( new Private )
+{
+ setArticle( mal_def, QmVocWordFlag::Singular | QmVocWordFlag::Definite | QmVocWordFlag::Masculine );
+ setArticle( fem_def, QmVocWordFlag::Singular | QmVocWordFlag::Definite | QmVocWordFlag::Feminine );
+ setArticle( neu_def, QmVocWordFlag::Singular | QmVocWordFlag::Definite | QmVocWordFlag::Neuter );
+
+ setArticle( mal_indef, QmVocWordFlag::Singular | QmVocWordFlag::Indefinite | QmVocWordFlag::Masculine );
+ setArticle( fem_indef, QmVocWordFlag::Singular | QmVocWordFlag::Indefinite | QmVocWordFlag::Feminine );
+ setArticle( neu_indef, QmVocWordFlag::Singular | QmVocWordFlag::Indefinite | QmVocWordFlag::Neuter );
+}
+
+QmVocArticle::~QmVocArticle()
+{
+ delete d;
+}
+
+
+QString QmVocArticle::article(const QmVocWordFlags& flags)
+{
+ return d->m_articles.value(flags & (QmVocWordFlag::genders | QmVocWordFlag::numbers | QmVocWordFlag::Definite | QmVocWordFlag::Indefinite));
+}
+
+void QmVocArticle::setArticle(const QString & article, const QmVocWordFlags& flags)
+{
+ d->m_articles[flags & (QmVocWordFlag::genders | QmVocWordFlag::numbers | QmVocWordFlag::Definite | QmVocWordFlag::Indefinite)] = article;
+}
+
+
+bool QmVocArticle::isArticle(const QString & article) const
+{
+ return d->m_articles.values().contains(article);
+}
+
+bool QmVocArticle::isEmpty()
+{
+ // we don't count empty strings as articles
+ foreach(const QString& s, d->m_articles)
+ {
+ if (!s.isEmpty())
+ return false;
+ }
+ return true;
+}
+
+
+
Copyright 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
Copyright 2005, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
Copyright 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCARTICLE_H
-#define KEDUVOCARTICLE_H
+#ifndef QMVOCARTICLE_H
+#define QMVOCARTICLE_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
#include <QtCore/QStringList>
-#include "keduvocwordflags.h"
+#include "qmvocwordflags.h"
-class KEduVocWordType;
+class QmVocWordType;
/**
* Class representing the articles of a language
*
* It contains all available articles of the language as QString
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocArticle
+class QMVOCDOCUMENT_EXPORT QmVocArticle
{
public:
/**
* The constructor without arguments
*/
- explicit KEduVocArticle();
+ explicit QmVocArticle();
/** copy constructor for d-pointer safety
* @param other article object to copy
*/
- KEduVocArticle( const KEduVocArticle &other );
+ QmVocArticle( const QmVocArticle &other );
/**
* DEPRECATED The constructor with arguments, assumes singular!
* @param nat_def reference to a QString with the definite neutral article
* @param nat_indef reference to a QString with the indefinite neutral article
*/
- KDE_DEPRECATED KEduVocArticle( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &nat_def, const QString &nat_indef );
+ KDE_DEPRECATED QmVocArticle( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &nat_def, const QString &nat_indef );
/**
* default destructor, deletes the d pointer
*/
- ~KEduVocArticle();
+ ~QmVocArticle();
/**
* assignment operator for d-pointer copying
*/
- KEduVocArticle &operator= ( const KEduVocArticle& other );
+ QmVocArticle &operator= ( const QmVocArticle& other );
- QString article(const KEduVocWordFlags&);
+ QString article(const QmVocWordFlags&);
- void setArticle(const QString& article, const KEduVocWordFlags&);
+ void setArticle(const QString& article, const QmVocWordFlags&);
bool isArticle(const QString& article) const;
/***************************************************************************
* Copyright 2007 Jeremy Whiting <jpwhiting@kde.org> *
* Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net> *
+ * Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.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 *
* (at your option) any later version. *
***************************************************************************/
-#ifndef KEDUVOCCOMMON_P_H
-#define KEDUVOCCOMMON_P_H
+#ifndef QMVOCCOMMON_P_H
+#define QMVOCCOMMON_P_H
#define KVD_VERS_PREFIX " v" // kvoctrain v0.1.0
/***************************************************************************
- C++ Implementation: keduvocconjugation
+ C++ Implementation: qmvocconjugation
-----------------------------------------------------------------------
begin : Di Aug 28 2007
copyright : (C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
-----------------------------------------------------------------------
* *
***************************************************************************/
-#include "keduvocconjugation.h"
-#include "keduvoccommon_p.h"
-#include "keduvoctext.h"
+#include "qmvocconjugation.h"
+#include "qmvoccommon_p.h"
+#include "qmvoctext.h"
#include "kvtml2defs.h"
#include <QtCore/QMap>
#include <QtXml/QDomDocument>
-#include <kdebug.h>
+#include <QDebug>
-class KEduVocConjugation::Private
+class QmVocConjugation::Private
{
public:
- QMap<KEduVocWordFlags, KEduVocText> m_conjugations;
+ QMap<QmVocWordFlags, QmVocText> m_conjugations;
};
-KEduVocConjugation::KEduVocConjugation()
+QmVocConjugation::QmVocConjugation()
: d( new Private )
{}
-KEduVocConjugation::KEduVocConjugation( const KEduVocConjugation& other )
+QmVocConjugation::QmVocConjugation( const QmVocConjugation& other )
: d( new Private )
{
d->m_conjugations = other.d->m_conjugations;
}
-KEduVocConjugation::~KEduVocConjugation()
+QmVocConjugation::~QmVocConjugation()
{
delete d;
}
-KEduVocConjugation& KEduVocConjugation::operator = ( const KEduVocConjugation& other )
+QmVocConjugation& QmVocConjugation::operator = ( const QmVocConjugation& other )
{
d->m_conjugations = other.d->m_conjugations;
return *this;
}
-bool KEduVocConjugation::operator ==(const KEduVocConjugation& other) const
+bool QmVocConjugation::operator ==(const QmVocConjugation& other) const
{
return d->m_conjugations == other.d->m_conjugations;
}
-KEduVocText& KEduVocConjugation::conjugation(KEduVocWordFlags flags) const
+QmVocText& QmVocConjugation::conjugation(QmVocWordFlags flags) const
{
- return d->m_conjugations[flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers | KEduVocWordFlag::genders)];
+ return d->m_conjugations[flags & (QmVocWordFlag::persons | QmVocWordFlag::numbers | QmVocWordFlag::genders)];
}
-void KEduVocConjugation::setConjugation(const KEduVocText& conjugation, KEduVocWordFlags flags)
+void QmVocConjugation::setConjugation(const QmVocText& conjugation, QmVocWordFlags flags)
{
- d->m_conjugations[flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers | KEduVocWordFlag::genders)] = conjugation;
+ d->m_conjugations[flags & (QmVocWordFlag::persons | QmVocWordFlag::numbers | QmVocWordFlag::genders)] = conjugation;
}
-bool KEduVocConjugation::isEmpty()
+bool QmVocConjugation::isEmpty()
{
return d->m_conjugations.isEmpty();
}
-QList< KEduVocWordFlags > KEduVocConjugation::keys()
+QList< QmVocWordFlags > QmVocConjugation::keys()
{
return d->m_conjugations.keys();
}
-void KEduVocConjugation::toKVTML2(QDomElement & parent, const QString &tense)
+void QmVocConjugation::toKVTML2(QDomElement & parent, const QString &tense)
{
if (isEmpty()) {
return;
}
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> persons;
- persons[0] = KEduVocWordFlag::First;
- persons[1] = KEduVocWordFlag::Second;
- persons[2] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
- persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
- persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> persons;
+ persons[0] = QmVocWordFlag::First;
+ persons[1] = QmVocWordFlag::Second;
+ persons[2] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Masculine);
+ persons[3] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Feminine);
+ persons[4] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Neuter);
QDomDocument domDoc = parent.ownerDocument();
tenseElement.appendChild( domDoc.createTextNode(tense) );
parent.appendChild(tenseElement);
} else {
- kDebug() << "Saving conjugation with empty tense";
+ qDebug() << "Saving conjugation with empty tense";
}
for ( int num = 0; num <= 2; ++num) {
QDomElement numberElement = domDoc.createElement( KVTML_GRAMMATICAL_NUMBER[num] );
for ( int person = 0; person < 5; ++person) {
- KEduVocWordFlags curFlags = numbers[num] | persons[person];
+ QmVocWordFlags curFlags = numbers[num] | persons[person];
if (keys().contains(curFlags) && !conjugation(curFlags).isEmpty()) {
QDomElement personElement = domDoc.createElement( KVTML_GRAMMATICAL_PERSON[person] );
/*
QString first = conjugation.conjugation(
- KEduVocConjugation::First, num );
+ QmVocConjugation::First, num );
QString second = conjugation.conjugation(
- KEduVocConjugation::Second, num );
+ QmVocConjugation::Second, num );
QString third_male = conjugation.conjugation(
- KEduVocConjugation::ThirdMale, num );
+ QmVocConjugation::ThirdMale, num );
QString third_female = conjugation.conjugation(
- KEduVocConjugation::ThirdFemale, num );
+ QmVocConjugation::ThirdFemale, num );
QString third_neutral = conjugation.conjugation(
- KEduVocConjugation::ThirdNeutralCommon, num );
+ QmVocConjugation::ThirdNeutralCommon, num );
if ( !first.isEmpty() || !second.isEmpty() || !third_female.isEmpty() ||
!third_male.isEmpty() || !third_neutral.isEmpty() ) {
QDomElement number;
switch (num) {
- case KEduVocConjugation::Singular:
+ case QmVocConjugation::Singular:
number = m_domDoc.createElement( KVTML_SINGULAR );
break;
- case KEduVocConjugation::Dual:
+ case QmVocConjugation::Dual:
number = m_domDoc.createElement( KVTML_DUAL );
break;
- case KEduVocConjugation::Plural:
+ case QmVocConjugation::Plural:
number = m_domDoc.createElement( KVTML_PLURAL );
break;
}
/*
- for ( KEduVocWordFlag::DeclensionNumber num = KEduVocWordFlag::Singular; num <= KEduVocWordFlag::Plural; num = KEduVocWordFlag::DeclensionNumber(num +1) ) {
+ for ( QmVocWordFlag::DeclensionNumber num = QmVocWordFlag::Singular; num <= QmVocWordFlag::Plural; num = QmVocWordFlag::DeclensionNumber(num +1) ) {
QDomElement numberElement = domDoc.createElement( KVTML_GRAMMATICAL_NUMBER[num] );
- for ( KEduVocWordFlag::DeclensionCase dcase = KEduVocWordFlag::Nominative; dcase < KEduVocWordFlag::DeclensionCaseMAX; dcase = KEduVocWordFlag::DeclensionCase(dcase +1) ) {
+ for ( QmVocWordFlag::DeclensionCase dcase = QmVocWordFlag::Nominative; dcase < QmVocWordFlag::DeclensionCaseMAX; dcase = QmVocWordFlag::DeclensionCase(dcase +1) ) {
QDomElement caseElement = domDoc.createElement( KVTML_DECLENSION_CASE[dcase] );
declension(num, dcase).toKVTML2(caseElement);
-KEduVocConjugation* KEduVocConjugation::fromKVTML2(QDomElement & parent)
+QmVocConjugation* QmVocConjugation::fromKVTML2(QDomElement & parent)
{
// sanity check
if (parent.isNull()) {
return 0;
}
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> persons;
- persons[0] = KEduVocWordFlag::First;
- persons[1] = KEduVocWordFlag::Second;
- persons[2] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
- persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
- persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> persons;
+ persons[0] = QmVocWordFlag::First;
+ persons[1] = QmVocWordFlag::Second;
+ persons[2] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Masculine);
+ persons[3] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Feminine);
+ persons[4] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Neuter);
- KEduVocConjugation* conjugation = new KEduVocConjugation;
+ QmVocConjugation* conjugation = new QmVocConjugation;
for ( int num = 0; num <= 2; num++ ) {
QDomElement numberElement = parent.firstChildElement( KVTML_GRAMMATICAL_NUMBER[num] );
for (int person = 0; person < 5; person++) {
QDomElement personElement = numberElement.firstChildElement( KVTML_GRAMMATICAL_PERSON[person] );
if (!personElement.isNull()) {
- KEduVocText text;
+ QmVocText text;
text.fromKVTML2(personElement);
if (text.text().isEmpty()) {
// compatibility for kde 4.0. There the text was directly below the person, not enabling grades per conjugation form.
/***************************************************************************
- C++ Interface: keduvocconjugation
+ C++ Interface: qmvocconjugation
-----------------------------------------------------------------------
begin : Di Aug 28 2007
copyright : (C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
-----------------------------------------------------------------------
***************************************************************************/
-#ifndef KEDUVOCCONJUGATION_H
-#define KEDUVOCCONJUGATION_H
+#ifndef QMVOCCONJUGATION_H
+#define QMVOCCONJUGATION_H
-#include "libkeduvocdocument_export.h"
-#include "keduvoctext.h"
-#include "keduvocwordflags.h"
+#include "libqmvocdocument_export.h"
+#include "qmvoctext.h"
+#include "qmvocwordflags.h"
#include <QtCore/QStringList>
/**
* The conjugation of a verb
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocConjugation
+class QMVOCDOCUMENT_EXPORT QmVocConjugation
{
public:
/**
* The constructor
*/
- explicit KEduVocConjugation();
+ explicit QmVocConjugation();
- KEduVocConjugation( const KEduVocConjugation& rhs );
+ QmVocConjugation( const QmVocConjugation& rhs );
- ~KEduVocConjugation();
+ ~QmVocConjugation();
- KEduVocConjugation& operator = ( const KEduVocConjugation& a );
- bool operator == ( const KEduVocConjugation& a ) const;
+ QmVocConjugation& operator = ( const QmVocConjugation& a );
+ bool operator == ( const QmVocConjugation& a ) const;
/**
* Returns an existing conjugation object. It is an error and leads to undefined behaviour
* @param flags Flags obtained by a previous call to keys()
* @return The existing conjugation object with the specified properties
*/
- KEduVocText& conjugation(KEduVocWordFlags flags) const;
+ QmVocText& conjugation(QmVocWordFlags flags) const;
/**
* Updates or creates the conjugation object for the given word flags.
*/
- void setConjugation(const KEduVocText& conjugation, KEduVocWordFlags flags);
+ void setConjugation(const QmVocText& conjugation, QmVocWordFlags flags);
- QList<KEduVocWordFlags> keys();
+ QList<QmVocWordFlags> keys();
bool isEmpty();
* @param parent
* @return
*/
- static KEduVocConjugation* fromKVTML2(QDomElement& parent);
+ static QmVocConjugation* fromKVTML2(QDomElement& parent);
private:
class Private;
Private* const d;
};
-
-#endif // KEDUVOCCONJUGATION_H
-
+#endif // QMVOCCONJUGATION_H
* *
***************************************************************************/
-#include "keduvoccontainer.h"
+#include "qmvoccontainer.h"
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
-#include <KDebug>
+// #include <KDebug>
#include <QList>
+#include <QtDebug>
/** private class to store information about a lesson */
-class KEduVocContainer::Private
+class QmVocContainer::Private
{
public:
~Private();
bool m_inPractice;
// other lessons in the tree
- KEduVocContainer *m_parentContainer;
- QList < KEduVocContainer * > m_childContainers;
+ QmVocContainer *m_parentContainer;
+ QList < QmVocContainer * > m_childContainers;
EnumContainerType m_type;
- QList < KEduVocExpression* > m_childLessonEntries;
+ QList < QmVocExpression* > m_childLessonEntries;
bool m_childLessonEntriesValid;
/// Image url
- KUrl m_imageUrl;
+ QUrl m_imageUrl;
};
-KEduVocContainer::Private::~Private()
+QmVocContainer::Private::~Private()
{
qDeleteAll(m_childContainers);
}
-KEduVocContainer::KEduVocContainer(const QString& name, EnumContainerType type, KEduVocContainer *parent)
+QmVocContainer::QmVocContainer(const QString& name, EnumContainerType type, QmVocContainer *parent)
: d( new Private )
{
d->m_parentContainer = parent;
d->m_childLessonEntriesValid = false;
}
-KEduVocContainer::KEduVocContainer( const KEduVocContainer &other )
+QmVocContainer::QmVocContainer( const QmVocContainer &other )
: d( new Private )
{
d->m_name = other.d->m_name;
d->m_childLessonEntriesValid = false;
}
-KEduVocContainer::~KEduVocContainer()
+QmVocContainer::~QmVocContainer()
{
delete d;
}
-void KEduVocContainer::appendChildContainer(KEduVocContainer * child)
+void QmVocContainer::appendChildContainer(QmVocContainer * child)
{
d->m_childContainers.append(child);
child->d->m_parentContainer = this;
invalidateChildLessonEntries();
}
-KEduVocContainer * KEduVocContainer::childContainer(int row)
+QmVocContainer * QmVocContainer::childContainer(int row)
{
return d->m_childContainers.value(row);
}
-KEduVocContainer * KEduVocContainer::childContainer(const QString & name)
+QmVocContainer * QmVocContainer::childContainer(const QString & name)
{
if (d->m_name == name) {
return this;
}
- foreach (KEduVocContainer *container, d->m_childContainers) {
- KEduVocContainer *found = container->childContainer(name);
+ foreach (QmVocContainer *container, d->m_childContainers) {
+ QmVocContainer *found = container->childContainer(name);
if (found) {
return found;
}
}
-void KEduVocContainer::deleteChildContainer(int row)
+void QmVocContainer::deleteChildContainer(int row)
{
- kDebug() << "Delete of container - check entry deletion!";
+ qDebug() << "Delete of container - check entry deletion!";
delete d->m_childContainers.takeAt(row);
invalidateChildLessonEntries();
}
-void KEduVocContainer::removeChildContainer(int row)
+void QmVocContainer::removeChildContainer(int row)
{
d->m_childContainers.removeAt(row);
invalidateChildLessonEntries();
}
-int KEduVocContainer::childContainerCount() const
+int QmVocContainer::childContainerCount() const
{
return d->m_childContainers.count();
}
-int KEduVocContainer::row() const
+int QmVocContainer::row() const
{
if (d->m_parentContainer) {
- return d->m_parentContainer->d->m_childContainers.indexOf(const_cast<KEduVocContainer*>(this));
+ return d->m_parentContainer->d->m_childContainers.indexOf(const_cast<QmVocContainer*>(this));
}
return 0;
}
-KEduVocContainer& KEduVocContainer::operator= ( const KEduVocContainer &other )
+QmVocContainer& QmVocContainer::operator= ( const QmVocContainer &other )
{
d->m_name = other.d->m_name;
d->m_inPractice = other.d->m_inPractice;
return *this;
}
-bool KEduVocContainer::operator==(const KEduVocContainer &other)
+bool QmVocContainer::operator==(const QmVocContainer &other)
{
return d->m_name == other.d->m_name &&
d->m_inPractice == other.d->m_inPractice
;
}
-void KEduVocContainer::setName( const QString &name )
+void QmVocContainer::setName( const QString &name )
{
d->m_name = name;
}
-QString KEduVocContainer::name()
+QString QmVocContainer::name()
{
return d->m_name;
}
-bool KEduVocContainer::inPractice()
+bool QmVocContainer::inPractice()
{
return d->m_inPractice;
}
-void KEduVocContainer::setInPractice(bool inPractice)
+void QmVocContainer::setInPractice(bool inPractice)
{
d->m_inPractice = inPractice;
}
-void KEduVocContainer::removeTranslation(int translation)
+void QmVocContainer::removeTranslation(int translation)
{
- foreach(KEduVocContainer *childContainer, d->m_childContainers) {
+ foreach(QmVocContainer *childContainer, d->m_childContainers) {
childContainer->removeTranslation(translation);
}
- foreach(KEduVocExpression *entry, entries() ) {
+ foreach(QmVocExpression *entry, entries() ) {
entry->removeTranslation( translation );
}
}
-QList< KEduVocExpression * > KEduVocContainer::entriesRecursive()
+QList< QmVocExpression * > QmVocContainer::entriesRecursive()
{
if (!d->m_childLessonEntriesValid) {
updateChildLessonEntries();
return d->m_childLessonEntries;
}
-QList< KEduVocContainer * > KEduVocContainer::childContainers()
+QList< QmVocContainer * > QmVocContainer::childContainers()
{
return d->m_childContainers;
}
-KEduVocContainer * KEduVocContainer::parent()
+QmVocContainer * QmVocContainer::parent()
{
return d->m_parentContainer;
}
-void KEduVocContainer::setContainerType(KEduVocContainer::EnumContainerType type)
+void QmVocContainer::setContainerType(QmVocContainer::EnumContainerType type)
{
d->m_type = type;
}
-KEduVocContainer::EnumContainerType KEduVocContainer::containerType()
+QmVocContainer::EnumContainerType QmVocContainer::containerType()
{
return d->m_type;
}
-KUrl KEduVocContainer::imageUrl()
+QUrl QmVocContainer::imageUrl()
{
return d->m_imageUrl;
}
-void KEduVocContainer::setImageUrl(const KUrl &url)
+void QmVocContainer::setImageUrl(const QUrl &url)
{
d->m_imageUrl = url;
}
-void KEduVocContainer::insertChildContainer(int row, KEduVocContainer * child)
+void QmVocContainer::insertChildContainer(int row, QmVocContainer * child)
{
d->m_childContainers.insert(row, child);
child->d->m_parentContainer = this;
invalidateChildLessonEntries();
}
-void KEduVocContainer::updateChildLessonEntries()
+void QmVocContainer::updateChildLessonEntries()
{
- QList < KEduVocExpression* > entriesRecursive = entries();
+ QList < QmVocExpression* > entriesRecursive = entries();
- foreach(KEduVocContainer *childContainer, d->m_childContainers)
- foreach(KEduVocExpression * expr, childContainer->entries(Recursive))
+ foreach(QmVocContainer *childContainer, d->m_childContainers)
+ foreach(QmVocExpression * expr, childContainer->entries(Recursive))
entriesRecursive.append(expr);
d->m_childLessonEntries = entriesRecursive;
d->m_childLessonEntriesValid = true;
}
-void KEduVocContainer::invalidateChildLessonEntries()
+void QmVocContainer::invalidateChildLessonEntries()
{
d->m_childLessonEntriesValid = false;
// propagate to parent
}
}
-double KEduVocContainer::averageGrade(int translation, EnumEntriesRecursive recursive)
+double QmVocContainer::averageGrade(int translation, EnumEntriesRecursive recursive)
{
// grades range from 0..7 right now
int sum = 0;
- foreach (KEduVocExpression *entry, entries(recursive)) {
+ foreach (QmVocExpression *entry, entries(recursive)) {
sum += entry->translation(translation)->grade();
}
// make that a percentage
return (sum * 100.0/7.0)/entryCount(recursive);
}
-int KEduVocContainer::expressionsOfGrade(int translation, grade_t grade, EnumEntriesRecursive recursive)
+int QmVocContainer::expressionsOfGrade(int translation, grade_t grade, EnumEntriesRecursive recursive)
{
int sum = 0;
- foreach (KEduVocExpression *entry, entries(recursive)) {
+ foreach (QmVocExpression *entry, entries(recursive)) {
if (entry->translation(translation)->grade() == grade) {
sum++;
}
return sum;
}
-void KEduVocContainer::resetGrades(int translation, EnumEntriesRecursive recursive)
+void QmVocContainer::resetGrades(int translation, EnumEntriesRecursive recursive)
{
- foreach (KEduVocExpression *entry, entries(recursive)) {
+ foreach (QmVocExpression *entry, entries(recursive)) {
entry->resetGrades(translation);
}
}
* *
***************************************************************************/
-#ifndef KEDUVOCCONTAINER_H
-#define KEDUVOCCONTAINER_H
+#ifndef QMVOCCONTAINER_H
+#define QMVOCCONTAINER_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvoctext.h"
+#include "qmvoctext.h"
-#include <KDE/KUrl>
+// #include <KDE/KUrl>
+#include <QUrl>
#include <QtCore/QList>
-class KEduVocExpression;
+class QmVocExpression;
/** class to store information about a container - that can be a lesson or word types */
-class KEDUVOCDOCUMENT_EXPORT KEduVocContainer
+class QMVOCDOCUMENT_EXPORT QmVocContainer
{
// make this a template?
};
/** default constructor */
- explicit KEduVocContainer(const QString& name, EnumContainerType type, KEduVocContainer *parent = 0);
+ explicit QmVocContainer(const QString& name, EnumContainerType type, QmVocContainer *parent = 0);
- void appendChildContainer(KEduVocContainer *child);
- void insertChildContainer(int row, KEduVocContainer *child);
+ void appendChildContainer(QmVocContainer *child);
+ void insertChildContainer(int row, QmVocContainer *child);
void deleteChildContainer(int row);
void removeChildContainer(int row);
- KEduVocContainer *childContainer(int row);
+ QmVocContainer *childContainer(int row);
/**
* Retrieve a child container by its name
* @param name container name
* @return the child container
*/
- KEduVocContainer *childContainer(const QString& name);
+ QmVocContainer *childContainer(const QString& name);
- QList<KEduVocContainer *> childContainers();
+ QList<QmVocContainer *> childContainers();
/**
* Find a child container
* @param name
* @return
*/
-// KEduVocContainer *childContainer(const QString& name);
+// QmVocContainer *childContainer(const QString& name);
int childContainerCount() const;
int row() const;
- virtual KEduVocContainer *parent();
+ virtual QmVocContainer *parent();
/** copy constructor for d-pointer safe copying */
- KEduVocContainer( const KEduVocContainer &other );
+ QmVocContainer( const QmVocContainer &other );
/** destructor */
- virtual ~KEduVocContainer();
+ virtual ~QmVocContainer();
/** assignment operator */
- KEduVocContainer& operator= ( const KEduVocContainer& );
+ QmVocContainer& operator= ( const QmVocContainer& );
/** set the container name
* @param name text to set for the name
QString name();
/** get a list of all entries in the container */
- virtual QList < KEduVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive) =0;
+ virtual QList < QmVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive) =0;
virtual int entryCount(EnumEntriesRecursive recursive = NotRecursive) =0;
- virtual KEduVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive) =0;
+ virtual QmVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive) =0;
/**
* Removes a translation. This has to be called when a language is removed from a document.
void setInPractice( bool inPractice );
/** equality operator */
- bool operator==(const KEduVocContainer &other);
+ bool operator==(const QmVocContainer &other);
/**
* The type of this container. @see EnumContainerType
* @return
*/
- KEduVocContainer::EnumContainerType containerType();
+ QmVocContainer::EnumContainerType containerType();
/**
* Set the type of container.
* For convenience by default this is taken over from the parent, so no need to set.
* @param type the new type
*/
- void setContainerType(KEduVocContainer::EnumContainerType type);
+ void setContainerType(QmVocContainer::EnumContainerType type);
/** get the image url for this container if it exists */
- KUrl imageUrl();
+ QUrl imageUrl();
/** set the image url for this container
* @param url url of the image
*/
- void setImageUrl(const KUrl &url);
+ void setImageUrl(const QUrl &url);
double averageGrade(int translation, EnumEntriesRecursive recursive);
void resetGrades(int translation, EnumEntriesRecursive recursive);
protected:
- QList< KEduVocExpression * > entriesRecursive();
+ QList< QmVocExpression * > entriesRecursive();
/**
* Set the child entry cache to invalid
/***************************************************************************
- create a KEduVocDocument from a text file
+ create a QmVocDocument from a text file
-----------------------------------------------------------------------
* *
***************************************************************************/
-#include "keduvoccsvreader.h"
+#include "qmvoccsvreader.h"
#include <QIODevice>
#include <QTextStream>
// #include <klocale.h>
-#include "keduvocdocument.h"
-#include "keduvoclesson.h"
-#include "keduvocexpression.h"
+#include "qmvocdocument.h"
+#include "qmvoclesson.h"
+#include "qmvocexpression.h"
-KEduVocCsvReader::KEduVocCsvReader( QIODevice *file )
+QmVocCsvReader::QmVocCsvReader( QIODevice *file )
{
// the file must be already open
m_inputFile = file;
}
-bool KEduVocCsvReader::readDoc( KEduVocDocument *doc )
+bool QmVocCsvReader::readDoc( QmVocDocument *doc )
{
m_doc = doc;
int languageCount = 0;
- KEduVocLesson* lesson = new KEduVocLesson( "Vocabulary", m_doc->lesson());
+ QmVocLesson* lesson = new QmVocLesson( "Vocabulary", m_doc->lesson());
m_doc->lesson()->appendChildContainer(lesson);
while ( !inputStream.atEnd() ) {
QString s = inputStream.readLine();
if ( !s.simplified().isEmpty() ) {
- KEduVocExpression* expression = new KEduVocExpression( s.split(separator) );
+ QmVocExpression* expression = new QmVocExpression( s.split(separator) );
languageCount = qMax( languageCount,
expression->translationIndices().count() );
lesson->appendEntry( expression );
***************************************************************************/
/***************************************************************************
- create a KEduVocDocument from a text file
+ create a QmVocDocument from a text file
-----------------------------------------------------------------------
copyright : (C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCCSVREADER_H
-#define KEDUVOCCSVREADER_H
+#ifndef QMVOCCSVREADER_H
+#define QMVOCCSVREADER_H
#include <QString>
class QIODevice;
-class KEduVocDocument;
+class QmVocDocument;
-class KEduVocCsvReader
+class QmVocCsvReader
{
public:
- KEduVocCsvReader( QIODevice *file );
+ QmVocCsvReader( QIODevice *file );
- bool readDoc( KEduVocDocument *doc );
+ bool readDoc( QmVocDocument *doc );
QString errorMessage() const
{
private:
QIODevice *m_inputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
QString m_errorMessage;
};
***************************************************************************/
/***************************************************************************
- export a KEduVocDocument to a delimited text file
+ export a QmVocDocument to a delimited text file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
* *
***************************************************************************/
-#include "keduvoccsvwriter.h"
+#include "qmvoccsvwriter.h"
#include <QFile>
#include <QTextStream>
// #include <KLocale>
-#include "keduvocdocument.h"
-#include "keduvoclesson.h"
-#include "keduvocexpression.h"
+#include "qmvocdocument.h"
+#include "qmvoclesson.h"
+#include "qmvocexpression.h"
-KEduVocCsvWriter::KEduVocCsvWriter( QFile *file )
+QmVocCsvWriter::QmVocCsvWriter( QFile *file )
{
// the file must be already open
m_outputFile = file;
}
-bool KEduVocCsvWriter::writeDoc( KEduVocDocument *doc, const QString &generator )
+bool QmVocCsvWriter::writeDoc( QmVocDocument *doc, const QString &generator )
{
Q_UNUSED( generator );
outputStream << "Title:" << separator << m_doc->title() << "\n";
outputStream << "Author:" << separator << m_doc->author() << "\n";
- KEduVocExpression *expression;
+ QmVocExpression *expression;
int idCount = m_doc->identifierCount();
QString currentRow;
- for ( int e = 0; e < m_doc->lesson()->entryCount(KEduVocLesson::Recursive); e++ ) {
- expression = m_doc->lesson()->entries(KEduVocLesson::Recursive).value( e );
+ for ( int e = 0; e < m_doc->lesson()->entryCount(QmVocLesson::Recursive); e++ ) {
+ expression = m_doc->lesson()->entries(QmVocLesson::Recursive).value( e );
currentRow = "";
bool sep = false;
***************************************************************************/
/***************************************************************************
- export a KEduVocDocument to a delimited text file
+ export a QmVocDocument to a delimited text file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
(C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
+ (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCCSVWRITER_H
-#define KEDUVOCCSVWRITER_H
+#ifndef QMVOCCSVWRITER_H
+#define QMVOCCSVWRITER_H
class QFile;
class QString;
-class KEduVocDocument;
+class QmVocDocument;
-class KEduVocCsvWriter
+class QmVocCsvWriter
{
public:
- KEduVocCsvWriter( QFile *file );
+ QmVocCsvWriter( QFile *file );
- bool writeDoc( KEduVocDocument *doc, const QString &generator );
+ bool writeDoc( QmVocDocument *doc, const QString &generator );
private:
QFile *m_outputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
};
#endif
/***************************************************************************
- C++ Implementation: keduvocdeclension
+ C++ Implementation: qmvocdeclension
-----------------------------------------------------------------------
begin : Do Sep 20 2007
copyright : (C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
-----------------------------------------------------------------------
* *
***************************************************************************/
-#include "keduvocdeclension.h"
+#include "qmvocdeclension.h"
#include "kvtml2defs.h"
-#include "keduvockvtml2writer.h"
+#include "qmvockvtml2writer.h"
#include <QtXml/QDomDocument>
#include <QtCore/QMap>
-class KEduVocDeclension::Private
+class QmVocDeclension::Private
{
public:
- QMap<KEduVocWordFlags, KEduVocText> m_declensions;
+ QMap<QmVocWordFlags, QmVocText> m_declensions;
};
-KEduVocDeclension::KEduVocDeclension()
+QmVocDeclension::QmVocDeclension()
:d (new Private)
{
}
-KEduVocDeclension::KEduVocDeclension(const KEduVocDeclension & other)
+QmVocDeclension::QmVocDeclension(const QmVocDeclension & other)
:d (new Private)
{
d->m_declensions = other.d->m_declensions;
}
-KEduVocDeclension & KEduVocDeclension::operator =(const KEduVocDeclension & other)
+QmVocDeclension & QmVocDeclension::operator =(const QmVocDeclension & other)
{
d->m_declensions = other.d->m_declensions;
return *this;
}
-KEduVocDeclension::~KEduVocDeclension()
+QmVocDeclension::~QmVocDeclension()
{
delete d;
}
-KEduVocText& KEduVocDeclension::declension(KEduVocWordFlags flags)
+QmVocText& QmVocDeclension::declension(QmVocWordFlags flags)
{
return d->m_declensions[flags];
}
-void KEduVocDeclension::setDeclension(const KEduVocText & declension, KEduVocWordFlags flags)
+void QmVocDeclension::setDeclension(const QmVocText & declension, QmVocWordFlags flags)
{
d->m_declensions[flags] = declension;
}
-bool KEduVocDeclension::isEmpty()
+bool QmVocDeclension::isEmpty()
{
return d->m_declensions.isEmpty();
}
-void KEduVocDeclension::toKVTML2(QDomElement & parent)
+void QmVocDeclension::toKVTML2(QDomElement & parent)
{
if (isEmpty()) {
return;
QDomDocument domDoc = parent.ownerDocument();
QDomElement declensionElement = domDoc.createElement( KVTML_DECLENSION );
- QMap<int, KEduVocWordFlags> genders;
- genders[0] = KEduVocWordFlag::Masculine;
- genders[1] = KEduVocWordFlag::Feminine;
- genders[2] = KEduVocWordFlag::Neuter;
+ QMap<int, QmVocWordFlags> genders;
+ genders[0] = QmVocWordFlag::Masculine;
+ genders[1] = QmVocWordFlag::Feminine;
+ genders[2] = QmVocWordFlag::Neuter;
- QMap<int, KEduVocWordFlags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
+ QMap<int, QmVocWordFlags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
- QMap<int, KEduVocWordFlags> cases;
- cases[0] = KEduVocWordFlag::Nominative;
- cases[1] = KEduVocWordFlag::Genitive;
- cases[2] = KEduVocWordFlag::Dative;
- cases[3] = KEduVocWordFlag::Accusative;
- cases[4] = KEduVocWordFlag::Ablative;
- cases[5] = KEduVocWordFlag::Locative;
- cases[6] = KEduVocWordFlag::Vocative;
+ QMap<int, QmVocWordFlags> cases;
+ cases[0] = QmVocWordFlag::Nominative;
+ cases[1] = QmVocWordFlag::Genitive;
+ cases[2] = QmVocWordFlag::Dative;
+ cases[3] = QmVocWordFlag::Accusative;
+ cases[4] = QmVocWordFlag::Ablative;
+ cases[5] = QmVocWordFlag::Locative;
+ cases[6] = QmVocWordFlag::Vocative;
for ( int gen = 0; gen <= 2; ++gen)
}
}
-KEduVocDeclension* KEduVocDeclension::fromKVTML2(QDomElement & parent)
+QmVocDeclension* QmVocDeclension::fromKVTML2(QDomElement & parent)
{
QDomElement declensionElement = parent.firstChildElement( KVTML_DECLENSION );
// we don't create empty objects, if necessary, create later on demand.
}
- QMap<int, KEduVocWordFlags> genders;
- genders[0] = KEduVocWordFlag::Masculine;
- genders[1] = KEduVocWordFlag::Feminine;
- genders[2] = KEduVocWordFlag::Neuter;
+ QMap<int, QmVocWordFlags> genders;
+ genders[0] = QmVocWordFlag::Masculine;
+ genders[1] = QmVocWordFlag::Feminine;
+ genders[2] = QmVocWordFlag::Neuter;
- QMap<int, KEduVocWordFlags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
+ QMap<int, QmVocWordFlags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
- QMap<int, KEduVocWordFlags> cases;
- cases[0] = KEduVocWordFlag::Nominative;
- cases[1] = KEduVocWordFlag::Genitive;
- cases[2] = KEduVocWordFlag::Dative;
- cases[3] = KEduVocWordFlag::Accusative;
- cases[4] = KEduVocWordFlag::Ablative;
- cases[5] = KEduVocWordFlag::Locative;
- cases[6] = KEduVocWordFlag::Vocative;
+ QMap<int, QmVocWordFlags> cases;
+ cases[0] = QmVocWordFlag::Nominative;
+ cases[1] = QmVocWordFlag::Genitive;
+ cases[2] = QmVocWordFlag::Dative;
+ cases[3] = QmVocWordFlag::Accusative;
+ cases[4] = QmVocWordFlag::Ablative;
+ cases[5] = QmVocWordFlag::Locative;
+ cases[6] = QmVocWordFlag::Vocative;
- KEduVocDeclension* declension = new KEduVocDeclension;
+ QmVocDeclension* declension = new QmVocDeclension;
for ( int gen = 0; gen <= 2; ++gen ) {
QDomElement genderElement = declensionElement.firstChildElement( KVTML_GRAMMATICAL_GENDER[gen] );
for ( int dcase = 0; dcase <= 6; ++dcase) {
QDomElement caseElement = numberElement.firstChildElement( KVTML_DECLENSION_CASE[dcase] );
if (!caseElement.isNull()) {
- KEduVocText text;
+ QmVocText text;
text.fromKVTML2(caseElement);
declension->setDeclension(text, genders[gen] | numbers[num] | cases[dcase]);
}
/***************************************************************************
- C++ Interface: keduvocdeclension
+ C++ Interface: qmvocdeclension
-----------------------------------------------------------------------
begin : Do Sep 20 2007
copyright : (C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
-----------------------------------------------------------------------
* (at your option) any later version. *
* *
***************************************************************************/
-#ifndef KEDUVOCDECLENSION_H
-#define KEDUVOCDECLENSION_H
+#ifndef QMVOCDECLENSION_H
+#define QMVOCDECLENSION_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvoctext.h"
-#include "keduvocwordflags.h"
+#include "qmvoctext.h"
+#include "qmvocwordflags.h"
/**
A declension contains all forms that a NOUN possibly can have.
@author Frederik Gladhorn <frederik.gladhorn@kdemail.net>
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocDeclension{
+class QMVOCDOCUMENT_EXPORT QmVocDeclension{
public:
/**
* The constructor without arguments
*/
- explicit KEduVocDeclension();
+ explicit QmVocDeclension();
/** copy constructor
* @param other comparison object to copy
*/
- KEduVocDeclension( const KEduVocDeclension &other );
+ QmVocDeclension( const QmVocDeclension &other );
- ~KEduVocDeclension();
+ ~QmVocDeclension();
/** equality operator
* @param a object to compare to
* @returns true if comparisons are the same, false otherwise
*/
// will probably not be necessary
-// bool operator == ( const KEduVocDeclension& a ) const;
+// bool operator == ( const QmVocDeclension& a ) const;
/** assignment operator for d-pointer copying
* @param other object to copy from
* @returns reference to this object
*/
- KEduVocDeclension& operator= ( const KEduVocDeclension& other );
+ QmVocDeclension& operator= ( const QmVocDeclension& other );
/**
* The grammatical number, there is singular and plural for english, some languages have dual for exactly two items.
* @param decCase
* @return
*/
- KEduVocText& declension(KEduVocWordFlags flags);
+ QmVocText& declension(QmVocWordFlags flags);
/**
* Set a declension
* @param number
* @param decCase
*/
- void setDeclension(const KEduVocText& declension, KEduVocWordFlags flags);
+ void setDeclension(const QmVocText& declension, QmVocWordFlags flags);
bool isEmpty();
* @param parent
* @return
*/
- static KEduVocDeclension* fromKVTML2(QDomElement& parent);
+ static QmVocDeclension* fromKVTML2(QDomElement& parent);
private:
class Private;
* *
***************************************************************************/
-#include "keduvocdocument.h"
+#include "qmvocdocument.h"
#include <QtCore/QFileInfo>
// #include <QtCore/QTextStream>
// #include <krandomsequence.h>
// #include <kfilterdev.h>
-#include "keduvocexpression.h"
-#include "keduvoclesson.h"
-#include "keduvocleitnerbox.h"
-#include "keduvocwordtype.h"
-#include "keduvockvtmlwriter.h"
-#include "keduvockvtml2writer.h"
-#include "keduvoccsvreader.h"
-#include "keduvoccsvwriter.h"
-#include "keduvockvtml2reader.h"
-#include "keduvocwqlreader.h"
-#include "keduvocpaukerreader.h"
-#include "keduvocvokabelnreader.h"
-#include "keduvocxdxfreader.h"
+#include "qmvocexpression.h"
+#include "qmvoclesson.h"
+#include "qmvocleitnerbox.h"
+#include "qmvocwordtype.h"
+#include "qmvockvtmlwriter.h"
+#include "qmvockvtml2writer.h"
+#include "qmvoccsvreader.h"
+#include "qmvoccsvwriter.h"
+#include "qmvockvtml2reader.h"
+#include "qmvocwqlreader.h"
+#include "qmvocpaukerreader.h"
+#include "qmvocvokabelnreader.h"
+#include "qmvocxdxfreader.h"
#define WQL_IDENT "WordQuiz"
#define TXT_EXT "txt"
#define WQL_EXT "wql"
-class KEduVocDocument::KEduVocDocumentPrivate
+class QmVocDocument::QmVocDocumentPrivate
{
public:
- KEduVocDocumentPrivate( KEduVocDocument* qq )
+ QmVocDocumentPrivate( QmVocDocument* qq )
: q( qq )
{
m_lessonContainer = 0;
init();
}
- ~KEduVocDocumentPrivate();
+ ~QmVocDocumentPrivate();
void init();
- KEduVocDocument* q;
+ QmVocDocument* q;
bool m_dirty;
- KUrl m_url;
+ QUrl m_url;
// save these to document
- QList<KEduVocIdentifier> m_identifiers;
+ QList<QmVocIdentifier> m_identifiers;
QList<int> m_extraSizeHints;
QList<int> m_sizeHints;
*/
QString m_category;
- KEduVocLesson * m_lessonContainer;
- KEduVocWordType * m_wordTypeContainer;
- KEduVocLeitnerBox * m_leitnerContainer;
+ QmVocLesson * m_lessonContainer;
+ QmVocWordType * m_wordTypeContainer;
+ QmVocLeitnerBox * m_leitnerContainer;
};
-KEduVocDocument::KEduVocDocumentPrivate::~KEduVocDocumentPrivate()
+QmVocDocument::QmVocDocumentPrivate::~QmVocDocumentPrivate()
{
delete m_lessonContainer;
delete m_wordTypeContainer;
delete m_leitnerContainer;
}
-void KEduVocDocument::KEduVocDocumentPrivate::init()
+void QmVocDocument::QmVocDocumentPrivate::init()
{
delete m_lessonContainer;
- m_lessonContainer = new KEduVocLesson( "Document Lesson");
- m_lessonContainer->setContainerType(KEduVocLesson::Lesson);
+ m_lessonContainer = new QmVocLesson( "Document Lesson");
+ m_lessonContainer->setContainerType(QmVocLesson::Lesson);
delete m_wordTypeContainer;
- m_wordTypeContainer = new KEduVocWordType( "Word types" );
+ m_wordTypeContainer = new QmVocWordType( "Word types" );
delete m_leitnerContainer;
- m_leitnerContainer = new KEduVocLeitnerBox( "Leitner Box" );
+ m_leitnerContainer = new QmVocLeitnerBox( "Leitner Box" );
m_tenseDescriptions.clear();
m_identifiers.clear();
}
-KEduVocDocument::KEduVocDocument( QObject *parent )
- : QObject( parent ), d( new KEduVocDocumentPrivate( this ) )
+QmVocDocument::QmVocDocument( QObject *parent )
+ : QObject( parent ), d( new QmVocDocumentPrivate( this ) )
{
qDebug() << "constructor done";
}
-KEduVocDocument::~KEduVocDocument()
+QmVocDocument::~QmVocDocument()
{
delete d;
}
-void KEduVocDocument::setModified( bool dirty )
+void QmVocDocument::setModified( bool dirty )
{
d->m_dirty = dirty;
emit docModified( d->m_dirty );
}
-KEduVocDocument::FileType KEduVocDocument::detectFileType( const QString &fileName )
+QmVocDocument::FileType QmVocDocument::detectFileType( const QString &fileName )
{
// QIODevice * f = KFilterDev::deviceForFile( fileName );
QFile f(fileName);
}
-int KEduVocDocument::open( const KUrl& url )
+int QmVocDocument::open( const QUrl& url )
{
// temp solution for KUrl -> QString
QString myFile = url.path();
switch ( ft ) {
case Kvtml: {
qDebug() << "Reading KVTML document...";
- KEduVocKvtml2Reader kvtmlReader( f );
+ QmVocKvtml2Reader kvtmlReader( f );
read = kvtmlReader.readDoc( this );
if ( !read ) {
errorMessage = kvtmlReader.errorMessage();
qDebug() << "Reading WordQuiz (WQL) document...";
qCritical ("WordQuiz (WQL) document not yet supported...");
errorMessage = "WordQuiz (WQL) document not yet supported...";
-// KEduVocWqlReader wqlReader( f );
+// QmVocWqlReader wqlReader( f );
// d->m_url.setFileName( "Untitled" );
// read = wqlReader.readDoc( this );
// if ( !read ) {
qDebug() << "Reading Pauker document...";
qCritical ("Pauker document not yet supported...");
errorMessage = "Pauker document not yet supported...";
-// KEduVocPaukerReader paukerReader( this );
+// QmVocPaukerReader paukerReader( this );
// d->m_url.setFileName( "Untitled" );
// read = paukerReader.read( f );
// if ( !read ) {
qDebug() << "Reading Vokabeln document...";
qCritical ("Vokabeln document not yet supported...");
errorMessage = "Vokabeln document not yet supported...";
-// KEduVocVokabelnReader vokabelnReader( f );
+// QmVocVokabelnReader vokabelnReader( f );
// d->m_url.setFileName( "Untitled" );
// read = vokabelnReader.readDoc( this );
// if ( !read ) {
qDebug() << "Reading CVS document...";
qCritical ("CVS document not yet supported...");
errorMessage = "CVS document not yet supported...";
-// KEduVocCsvReader csvReader( f );
+// QmVocCsvReader csvReader( f );
// read = csvReader.readDoc( this );
// if ( !read ) {
// errorMessage = csvReader.errorMessage();
qDebug() << "Reading XDXF document...";
qCritical ("XDXF document not yet supported...");
errorMessage = "XDXF document not yet supported...";
-// KEduVocXdxfReader xdxfReader( this );
+// QmVocXdxfReader xdxfReader( this );
// d->m_url.setFileName( "Untitled" );
// read = xdxfReader.read( f );
// if ( !read ) {
default: {
qDebug() << "Reading KVTML document (fallback)...";
- KEduVocKvtml2Reader kvtmlReader( f );
+ QmVocKvtml2Reader kvtmlReader( f );
read = kvtmlReader.readDoc( this );
if ( !read ) {
errorMessage = kvtmlReader.errorMessage();
}
-int KEduVocDocument::saveAs( const KUrl & url, FileType ft, const QString & generator )
+int QmVocDocument::saveAs( const QUrl & url, FileType ft, const QString & generator )
{
- KUrl tmp( url );
+ QUrl tmp( url );
if ( ft == Automatic ) {
if ( tmp.path().right( strlen( "." KVTML_EXT ) ) == "." KVTML_EXT )
switch ( ft ) {
case Kvtml: {
// write version 2 file
- KEduVocKvtml2Writer kvtmlWriter( &f );
+ QmVocKvtml2Writer kvtmlWriter( &f );
saved = kvtmlWriter.writeDoc( this, generator );
}
break;
///@todo port me
// case Kvtml1: {
// // write old version 1 file
-// KEduVocKvtmlWriter kvtmlWriter( &f );
+// QmVocKvtmlWriter kvtmlWriter( &f );
// saved = kvtmlWriter.writeDoc( this, generator );
// }
// break;
case Csv: {
- KEduVocCsvWriter csvWriter( &f );
+ QmVocCsvWriter csvWriter( &f );
saved = csvWriter.writeDoc( this, generator );
}
break;
return 0;
}
-QByteArray KEduVocDocument::toByteArray(const QString &generator)
+QByteArray QmVocDocument::toByteArray(const QString &generator)
{
// no file needed
- KEduVocKvtml2Writer kvtmlWriter(0);
+ QmVocKvtml2Writer kvtmlWriter(0);
return kvtmlWriter.toByteArray( this, generator );
}
-void KEduVocDocument::merge( KEduVocDocument *docToMerge, bool matchIdentifiers )
+void QmVocDocument::merge( QmVocDocument *docToMerge, bool matchIdentifiers )
{
Q_UNUSED(docToMerge)
Q_UNUSED(matchIdentifiers)
if (equal) { // easy way: same language codes, just append
for (int i = 0; i < docToMerge->entryCount(); i++) {
- KEduVocExpression *expr = docToMerge->entry(i);
+ QmVocExpression *expr = docToMerge->entry(i);
expr->setLesson(expr->lesson() + lesson_offset);
expr->translation(lang).setUsageLabel (tg);
}
- KEduVocConjugation conj = expr->translation(lang).conjugation();
+ QmVocConjugation conj = expr->translation(lang).conjugation();
bool condirty = false;
for (int ci = 0; ci < conj.entryCount(); ci++) {
t = conj.getType(ci);
move_matrix.append(docToMerge->indexOfIdentifier(identifier(i)));
for (int j = 0; j < docToMerge->entryCount(); j++) {
- KEduVocExpression new_expr;
- KEduVocExpression *expr = docToMerge->entry(j);
+ QmVocExpression new_expr;
+ QmVocExpression *expr = docToMerge->entry(j);
new_expr.setLesson(expr->lesson()+lesson_offset);
for (int i = 0; i < move_matrix.count(); i++) {
new_expr.setUsageLabel(i, t2);
}
- KEduVocConjugation conj = expr->conjugation(lpos);
+ QmVocConjugation 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) {
*/
}
-const KEduVocIdentifier& KEduVocDocument::identifier( int index ) const
+const QmVocIdentifier& QmVocDocument::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 )
+QmVocIdentifier& QmVocDocument::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 )
+void QmVocDocument::setIdentifier( int idx, const QmVocIdentifier &id )
{
if ( idx >= 0 && idx < d->m_identifiers.size() ) {
d->m_identifiers[idx] = id;
}
// works if const is removed
-int KEduVocDocument::indexOfIdentifier( const QString &name ) const
+int QmVocDocument::indexOfIdentifier( const QString &name ) const
{
for (int i = 0; i < identifierCount(); i++)
if (identifier(i).locale() == name)
return -1;
}
-void KEduVocDocument::removeIdentifier( int index )
+void QmVocDocument::removeIdentifier( int index )
{
if ( index < d->m_identifiers.size() && index >= 0 ) {
d->m_identifiers.removeAt( index );
}
-bool KEduVocDocument::isModified() const
+bool QmVocDocument::isModified() const
{
return d->m_dirty;
}
-int KEduVocDocument::identifierCount() const
+int QmVocDocument::identifierCount() const
{
return d->m_identifiers.count(); // number of translations
}
-int KEduVocDocument::appendIdentifier( const KEduVocIdentifier& id )
+int QmVocDocument::appendIdentifier( const QmVocIdentifier& id )
{
int i = d->m_identifiers.size();
qDebug() << "appendIdentifier: " << i << id.name() << id.locale();
return i;
}
-KEduVocLesson * KEduVocDocument::lesson()
+QmVocLesson * QmVocDocument::lesson()
{
return d->m_lessonContainer;
}
-KEduVocWordType * KEduVocDocument::wordTypeContainer()
+QmVocWordType * QmVocDocument::wordTypeContainer()
{
return d->m_wordTypeContainer;
}
-KEduVocLeitnerBox * KEduVocDocument::leitnerContainer()
+QmVocLeitnerBox * QmVocDocument::leitnerContainer()
{
return d->m_leitnerContainer;
}
-KUrl KEduVocDocument::url() const
+QUrl QmVocDocument::url() const
{
return d->m_url;
}
-void KEduVocDocument::setUrl( const KUrl& url )
+void QmVocDocument::setUrl( const QUrl& url )
{
d->m_url = url;
}
-QString KEduVocDocument::title() const
+QString QmVocDocument::title() const
{
if ( d->m_title.isEmpty() )
return d->m_url.path();
return d->m_title;
}
-void KEduVocDocument::setTitle( const QString & title )
+void QmVocDocument::setTitle( const QString & title )
{
d->m_title = title;
d->m_lessonContainer->setName(title);
setModified(true);
}
-QString KEduVocDocument::author() const
+QString QmVocDocument::author() const
{
return d->m_author;
}
-void KEduVocDocument::setAuthor( const QString & s )
+void QmVocDocument::setAuthor( const QString & s )
{
d->m_author = s.simplified();
setModified(true);
}
-QString KEduVocDocument::authorContact() const
+QString QmVocDocument::authorContact() const
{
return d->m_authorContact;
}
-void KEduVocDocument::setAuthorContact( const QString & s )
+void QmVocDocument::setAuthorContact( const QString & s )
{
d->m_authorContact = s.simplified();
setModified(true);
}
-QString KEduVocDocument::license() const
+QString QmVocDocument::license() const
{
return d->m_license;
}
-QString KEduVocDocument::documentComment() const
+QString QmVocDocument::documentComment() const
{
return d->m_comment;
}
-void KEduVocDocument::setCategory( const QString & category )
+void QmVocDocument::setCategory( const QString & category )
{
d->m_category = category;
setModified(true);
}
-QString KEduVocDocument::category() const
+QString QmVocDocument::category() const
{
return d->m_category;
///@todo make writer/reader use this
}
-void KEduVocDocument::queryIdentifier( QString &org, QString &trans ) const
+void QmVocDocument::queryIdentifier( QString &org, QString &trans ) const
{
org = d->m_queryorg;
trans = d->m_querytrans;
}
-void KEduVocDocument::setQueryIdentifier( const QString &org, const QString &trans )
+void QmVocDocument::setQueryIdentifier( const QString &org, const QString &trans )
{
d->m_queryorg = org;
d->m_querytrans = trans;
setModified(true);
}
-void KEduVocDocument::setLicense( const QString & s )
+void QmVocDocument::setLicense( const QString & s )
{
d->m_license = s.simplified();
setModified(true);
}
-void KEduVocDocument::setDocumentComment( const QString & s )
+void QmVocDocument::setDocumentComment( const QString & s )
{
d->m_comment = s.trimmed();
setModified(true);
}
-void KEduVocDocument::setGenerator( const QString & generator )
+void QmVocDocument::setGenerator( const QString & generator )
{
d->m_generator = generator;
setModified(true);
}
-QString KEduVocDocument::generator() const
+QString QmVocDocument::generator() const
{
return d->m_generator;
}
-QString KEduVocDocument::version() const
+QString QmVocDocument::version() const
{
return d->m_version;
}
-void KEduVocDocument::setVersion( const QString & vers )
+void QmVocDocument::setVersion( const QString & vers )
{
d->m_version = vers;
setModified(true);
}
-QString KEduVocDocument::csvDelimiter() const
+QString QmVocDocument::csvDelimiter() const
{
return d->m_csvDelimiter;
}
-void KEduVocDocument::setCsvDelimiter( const QString &delimiter )
+void QmVocDocument::setCsvDelimiter( const QString &delimiter )
{
d->m_csvDelimiter = delimiter;
setModified(true);
}
-QString KEduVocDocument::pattern( FileDialogMode mode )
+QString QmVocDocument::pattern( FileDialogMode mode )
{
static const struct SupportedFilter {
bool reading;
return newfilters.join( "\n" );
}
-QString KEduVocDocument::errorDescription( int errorCode )
+QString QmVocDocument::errorDescription( int errorCode )
{
switch (errorCode) {
case NoError:
}
}
-// #include "keduvocdocument.moc"
* *
***************************************************************************/
-#ifndef KEDUVOCDOCUMENT_H
-#define KEDUVOCDOCUMENT_H
+#ifndef QMVOCDOCUMENT_H
+#define QMVOCDOCUMENT_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvocidentifier.h"
-#include "keduvocarticle.h"
-#include "keduvocconjugation.h"
+#include "qmvocidentifier.h"
+#include "qmvocarticle.h"
+#include "qmvocconjugation.h"
#include <QtCore/QObject>
#include <QtCore/QList>
#include <QUrl>
class QStringList;
-class KEduVocExpression;
-class KEduVocLesson;
-class KEduVocWordType;
-class KEduVocLeitnerBox;
+class QmVocExpression;
+class QmVocLesson;
+class QmVocWordType;
+class QmVocLeitnerBox;
/**
* This class contains the expressions of your vocabulary
* as well as other information about the vocabulary
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocDocument : public QObject
+class QMVOCDOCUMENT_EXPORT QmVocDocument : public QObject
{
Q_OBJECT
public:
*
* @param parent calling object
*/
- explicit KEduVocDocument( QObject* parent = 0 );
+ explicit QmVocDocument( QObject* parent = 0 );
/**
* Destructor
*/
- ~KEduVocDocument();
+ ~QmVocDocument();
// *** whole document methods ***
* @param url url to file to open
* @returns ErrorCode
*/
- int open( const KUrl& url );
+ int open( const QUrl& url );
/**
* Saves the data under the given name
* @param generator the name of the application saving the document
* @returns ErrorCode
*/
- int saveAs( const KUrl & url, FileType ft, const QString & generator );
+ int saveAs( const QUrl & url, FileType ft, const QString & generator );
QByteArray toByteArray(const QString &generator);
* @param matchIdentifiers if true only entries having identifiers present in the
* current document will be mergedurl is empty (or NULL) actual name is preserved
*/
- void merge( KEduVocDocument *docToMerge, bool matchIdentifiers );
+ void merge( QmVocDocument *docToMerge, bool matchIdentifiers );
/**
* Indicates if the document is modified
/**
* Sets the URL of the XML file
*/
- void setUrl( const KUrl& url );
+ void setUrl( const QUrl& url );
/** @returns the URL of the XML file */
- KUrl url() const;
+ QUrl url() const;
/** Set the title of the file
* @param identifier the identifier to append. If empty default names are used.
* @returns the identifier number
*/
- int appendIdentifier( const KEduVocIdentifier & identifier = KEduVocIdentifier());
+ int appendIdentifier( const QmVocIdentifier & identifier = QmVocIdentifier());
/**
* Sets the identifier of translation
* @param index number of translation 0..x
* @param lang the language identifier: en=english, de=german, ...
*/
- void setIdentifier( int index, const KEduVocIdentifier& lang );
+ void setIdentifier( int index, const QmVocIdentifier& lang );
/**
* Returns the identifier of translation @p index
* @param index number of translation 0..x
* @returns the language identifier: en=english, de=german, ...
*/
- KEduVocIdentifier& identifier( int index );
+ QmVocIdentifier& identifier( int index );
/**
* Const overload of identifier(int);
*/
- const KEduVocIdentifier& identifier( int index ) const;
+ const QmVocIdentifier& identifier( int index ) const;
/**
* Removes identifier and the according translation in all entries
/** Get the lesson root object
* @returns a pointer to the lesson object
*/
- KEduVocLesson * lesson();
+ QmVocLesson * lesson();
- KEduVocWordType * wordTypeContainer();
+ QmVocWordType * wordTypeContainer();
- KEduVocLeitnerBox * leitnerContainer();
+ QmVocLeitnerBox * leitnerContainer();
// *** file format specific methods ***
static QString errorDescription( int errorCode );
Q_SIGNALS:
- void progressChanged( KEduVocDocument *, int curr_percent );
+ void progressChanged( QmVocDocument *, int curr_percent );
/**
* Emitted when the document becomes modified or saved.
void docModified( bool mod );
private:
- // The private data of this - see KEduVocDocument::Private, implemented in keduvocdocument.cpp
- class KEduVocDocumentPrivate;
- KEduVocDocumentPrivate* const d;
+ // The private data of this - see QmVocDocument::Private, implemented in qmvocdocument.cpp
+ class QmVocDocumentPrivate;
+ QmVocDocumentPrivate* const d;
- Q_DISABLE_COPY( KEduVocDocument )
+ Q_DISABLE_COPY( QmVocDocument )
};
-#endif // KEDUVOCDOCUMENT_H
+#endif // QMVOCDOCUMENT_H
***************************************************************************/
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
-class KEduVocExpression::KEduVocExpressionPrivate
+class QmVocExpression::QmVocExpressionPrivate
{
public:
- KEduVocExpressionPrivate()
+ QmVocExpressionPrivate()
{
m_active = true;
m_lesson = 0;
}
- ~KEduVocExpressionPrivate();
+ ~QmVocExpressionPrivate();
- KEduVocExpressionPrivate(const KEduVocExpressionPrivate &other);
- KEduVocExpressionPrivate& operator= (const KEduVocExpressionPrivate &other);
+ QmVocExpressionPrivate(const QmVocExpressionPrivate &other);
+ QmVocExpressionPrivate& operator= (const QmVocExpressionPrivate &other);
- bool operator== ( const KEduVocExpressionPrivate &p ) const;
+ bool operator== ( const QmVocExpressionPrivate &p ) const;
- KEduVocLesson* m_lesson;
+ QmVocLesson* m_lesson;
bool m_active;
- QMap <int, KEduVocTranslation*> m_translations;
+ QMap <int, QmVocTranslation*> m_translations;
};
-KEduVocExpression::KEduVocExpressionPrivate::~KEduVocExpressionPrivate()
+QmVocExpression::QmVocExpressionPrivate::~QmVocExpressionPrivate()
{
- QMap <int, KEduVocTranslation*> translations = m_translations;
+ QMap <int, QmVocTranslation*> translations = m_translations;
// empty the translations map, otherwise removal from word type will try to access them again when they don't exist any more
m_translations.clear();
qDeleteAll(translations);
}
-KEduVocExpression::KEduVocExpressionPrivate::KEduVocExpressionPrivate(const KEduVocExpressionPrivate & other)
+QmVocExpression::QmVocExpressionPrivate::QmVocExpressionPrivate(const QmVocExpressionPrivate & other)
{
m_active = other.m_active;
m_lesson = 0;
}
-KEduVocExpression::KEduVocExpressionPrivate & KEduVocExpression::KEduVocExpressionPrivate::operator =(const KEduVocExpressionPrivate & other)
+QmVocExpression::QmVocExpressionPrivate & QmVocExpression::QmVocExpressionPrivate::operator =(const QmVocExpressionPrivate & other)
{
m_active = other.m_active;
m_lesson = 0;
return *this;
}
-bool KEduVocExpression::KEduVocExpressionPrivate::operator== ( const KEduVocExpression::KEduVocExpressionPrivate &p ) const
+bool QmVocExpression::QmVocExpressionPrivate::operator== ( const QmVocExpression::QmVocExpressionPrivate &p ) const
{
return
m_translations == p.m_translations &&
m_active == p.m_active;
}
-KEduVocExpression::KEduVocExpression()
- : d( new KEduVocExpressionPrivate )
+QmVocExpression::QmVocExpression()
+ : d( new QmVocExpressionPrivate )
{}
-KEduVocExpression::KEduVocExpression( const QString & expression )
- : d( new KEduVocExpressionPrivate )
+QmVocExpression::QmVocExpression( const QString & expression )
+ : d( new QmVocExpressionPrivate )
{
setTranslation( 0, expression.simplified() );
}
-KEduVocExpression::KEduVocExpression( const QStringList & translations)
- : d( new KEduVocExpressionPrivate )
+QmVocExpression::QmVocExpression( const QStringList & translations)
+ : d( new QmVocExpressionPrivate )
{
foreach ( const QString &translation, translations ) {
setTranslation(d->m_translations.count(), translation);
}
-KEduVocExpression::KEduVocExpression(const KEduVocExpression & other)
- : d(new KEduVocExpressionPrivate(*other.d))
+QmVocExpression::QmVocExpression(const QmVocExpression & other)
+ : d(new QmVocExpressionPrivate(*other.d))
{
foreach (int key, other.d->m_translations.keys()) {
- d->m_translations[key] = new KEduVocTranslation(*other.d->m_translations.value(key));
+ d->m_translations[key] = new QmVocTranslation(*other.d->m_translations.value(key));
d->m_translations[key]->setEntry(this);
}
}
-KEduVocExpression& KEduVocExpression::operator= ( const KEduVocExpression &other )
+QmVocExpression& QmVocExpression::operator= ( const QmVocExpression &other )
{
*d = *other.d;
foreach (int key, other.d->m_translations.keys()) {
- d->m_translations[key] = new KEduVocTranslation(*other.d->m_translations.value(key));
+ d->m_translations[key] = new QmVocTranslation(*other.d->m_translations.value(key));
d->m_translations[key]->setEntry(this);
}
return *this;
}
-KEduVocExpression::~KEduVocExpression()
+QmVocExpression::~QmVocExpression()
{
setLesson(0);
delete d;
}
-void KEduVocExpression::removeTranslation( int index )
+void QmVocExpression::removeTranslation( int index )
{
int count = d->m_translations.count();
}
-void KEduVocExpression::setTranslation( int index, const QString & expr )
+void QmVocExpression::setTranslation( int index, const QString & expr )
{
if ( index < 0 ) {
return;
}
if (!d->m_translations.contains(index)) {
- d->m_translations[index] = new KEduVocTranslation(this);
+ d->m_translations[index] = new QmVocTranslation(this);
}
d->m_translations[index]->setText(expr.simplified());
}
-KEduVocLesson* KEduVocExpression::lesson() const
+QmVocLesson* QmVocExpression::lesson() const
{
return d->m_lesson;
}
-bool KEduVocExpression::isActive() const
+bool QmVocExpression::isActive() const
{
return d->m_active;
}
-void KEduVocExpression::setActive( bool flag )
+void QmVocExpression::setActive( bool flag )
{
d->m_active = flag;
}
-void KEduVocExpression::resetGrades( int index )
+void QmVocExpression::resetGrades( int index )
{
if ( index == -1 ) { // clear grades for all languages
- foreach( KEduVocTranslation* trans, d->m_translations ) {
+ foreach( QmVocTranslation* trans, d->m_translations ) {
trans->resetGrades();
}
return;
}
}
-bool KEduVocExpression::operator== ( const KEduVocExpression &expression ) const
+bool QmVocExpression::operator== ( const QmVocExpression &expression ) const
{
return ( *d == *expression.d );
}
-KEduVocTranslation* KEduVocExpression::translation( int index )
+QmVocTranslation* QmVocExpression::translation( int index )
{
if(translationIndices().contains(index)) {
return d->m_translations[index];
}
- d->m_translations[index] = new KEduVocTranslation(this);
+ d->m_translations[index] = new QmVocTranslation(this);
return d->m_translations[index];
}
-KEduVocTranslation * KEduVocExpression::translation(int index) const
+QmVocTranslation * QmVocExpression::translation(int index) const
{
if(d->m_translations.contains(index)) {
return 0;
return d->m_translations[index];
}
-QList< int > KEduVocExpression::translationIndices() const
+QList< int > QmVocExpression::translationIndices() const
{
return d->m_translations.keys();
}
-void KEduVocExpression::setLesson(KEduVocLesson * l)
+void QmVocExpression::setLesson(QmVocLesson * l)
{
if (d->m_lesson) {
d->m_lesson->removeEntry(this);
* *
***************************************************************************/
-#ifndef KEDUVOCEXPRESSION_H
-#define KEDUVOCEXPRESSION_H
+#ifndef QMVOCEXPRESSION_H
+#define QMVOCEXPRESSION_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
#include <QtCore/QDateTime>
#include <QMap>
-#include "keduvoclesson.h"
-#include "keduvocarticle.h"
-#include "keduvocmultiplechoice.h"
-#include "keduvoctranslation.h"
+#include "qmvoclesson.h"
+#include "qmvocarticle.h"
+#include "qmvocmultiplechoice.h"
+#include "qmvoctranslation.h"
-class KEduVocLesson;
+class QmVocLesson;
/**
This class contains one vocabulary expression as an original with one or more
translations
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocExpression
+class QMVOCDOCUMENT_EXPORT QmVocExpression
{
public:
/** default constructor for an empty vocabulary expression
*/
- explicit KEduVocExpression();
+ explicit QmVocExpression();
/** Constructor for a vocabulary expression with one translation
*
* @param expression translation
* @param lesson lesson number
*/
- explicit KEduVocExpression( const QString & expression );
+ explicit QmVocExpression( const QString & expression );
/** Constructor for a vocabulary expression with an original and one or more translations
*
* @param separator expression will be split into an original and one or more translations using separator
* @param lesson lesson number, 0 for none
*/
- explicit KEduVocExpression( const QStringList & translations );
+ explicit QmVocExpression( const QStringList & translations );
- KEduVocExpression(const KEduVocExpression& other);
+ QmVocExpression(const QmVocExpression& other);
- ~KEduVocExpression();
+ ~QmVocExpression();
/** return the lesson
*/
- KEduVocLesson * lesson() const;
+ QmVocLesson * lesson() const;
/** reset all grades of the entry
int sizeHint() const;
void setSizeHint( int sizeHint );
- void setTranslation( int index, KEduVocTranslation* translation );
+ void setTranslation( int index, QmVocTranslation* translation );
/**
* Add a translation to this expression
* @param index number of translation = the identifier
* @param index of the language identifier
* @return the translation
*/
- KEduVocTranslation* translation( int index );
- KEduVocTranslation* translation( int index ) const;
+ QmVocTranslation* translation( int index );
+ QmVocTranslation* translation( int index ) const;
QList<int> translationIndices() const;
- KEduVocExpression& operator= ( const KEduVocExpression &expression );
- bool operator== ( const KEduVocExpression &expression ) const;
+ QmVocExpression& operator= ( const QmVocExpression &expression );
+ bool operator== ( const QmVocExpression &expression ) const;
private:
- class KEduVocExpressionPrivate;
- KEduVocExpressionPrivate* const d;
+ class QmVocExpressionPrivate;
+ QmVocExpressionPrivate* const d;
/** only called by lesson to add itself to the lesson list
*/
- void setLesson( KEduVocLesson * l );
+ void setLesson( QmVocLesson * l );
- friend class KEduVocLesson;
+ friend class QmVocLesson;
};
-#endif // KEduVocExpression_H
+#endif // QMVOCEXPRESSION_H
/***************************************************************************
Copyright 2007-2008 Frederik Gladhorn <gladhorn@kde.org>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* (at your option) any later version. *
* *
***************************************************************************/
-#include "keduvocidentifier.h"
+#include "qmvocidentifier.h"
-class KEduVocIdentifier::Private
+class QmVocIdentifier::Private
{
public:
/// the name: English, Anatomy, Fruit salad
QString m_type;
/** I, you, he, she, it... */
- KEduVocPersonalPronoun m_personalPronouns;
+ QmVocPersonalPronoun m_personalPronouns;
/** the for english ;)
der, die, das ... in german */
- KEduVocArticle m_articles;
+ QmVocArticle m_articles;
/** Future, present and past... and many more */
QStringList m_tenses;
};
-KEduVocIdentifier::KEduVocIdentifier()
+QmVocIdentifier::QmVocIdentifier()
: d( new Private )
{
///@todo maybe the user locale would be more appropriate
d->m_locale = "en";
}
-KEduVocIdentifier::~KEduVocIdentifier()
+QmVocIdentifier::~QmVocIdentifier()
{
delete d;
}
-KEduVocIdentifier::KEduVocIdentifier( const KEduVocIdentifier &other )
+QmVocIdentifier::QmVocIdentifier( const QmVocIdentifier &other )
: d( new Private( *other.d ) )
{
#if 0
#endif
}
-KEduVocIdentifier& KEduVocIdentifier::operator= ( const KEduVocIdentifier &other )
+QmVocIdentifier& QmVocIdentifier::operator= ( const QmVocIdentifier &other )
{
d->m_locale = other.d->m_locale;
d->m_name = other.d->m_name;
return *this;
}
-QString KEduVocIdentifier::name() const
+QString QmVocIdentifier::name() const
{
return d->m_name;
}
-void KEduVocIdentifier::setName(const QString & name)
+void QmVocIdentifier::setName(const QString & name)
{
d->m_name = name;
}
-QString KEduVocIdentifier::locale() const
+QString QmVocIdentifier::locale() const
{
return d->m_locale;
}
-void KEduVocIdentifier::setLocale(const QString & locale)
+void QmVocIdentifier::setLocale(const QString & locale)
{
d->m_locale = locale;
}
-void KEduVocIdentifier::setArticle( const KEduVocArticle& articles )
+void QmVocIdentifier::setArticle( const QmVocArticle& articles )
{
d->m_articles = articles;
}
-KEduVocArticle& KEduVocIdentifier::article() const
+QmVocArticle& QmVocIdentifier::article() const
{
return d->m_articles;
}
-KEduVocPersonalPronoun& KEduVocIdentifier::personalPronouns() const
+QmVocPersonalPronoun& QmVocIdentifier::personalPronouns() const
{
return d->m_personalPronouns;
}
-void KEduVocIdentifier::setPersonalPronouns( const KEduVocPersonalPronoun & pronouns )
+void QmVocIdentifier::setPersonalPronouns( const QmVocPersonalPronoun & pronouns )
{
d->m_personalPronouns = pronouns;
}
-QString KEduVocIdentifier::tense(int tenseIndex) const
+QString QmVocIdentifier::tense(int tenseIndex) const
{
Q_ASSERT(d->m_tenses.size() > tenseIndex);
return d->m_tenses.value(tenseIndex);
}
-void KEduVocIdentifier::setTense(int tenseIndex, const QString& tense)
+void QmVocIdentifier::setTense(int tenseIndex, const QString& tense)
{
Q_ASSERT(d->m_tenses.size() >= tenseIndex);
if (tenseIndex == d->m_tenses.size()) {
}
}
-QStringList KEduVocIdentifier::tenseList() const
+QStringList QmVocIdentifier::tenseList() const
{
return d->m_tenses;
}
-void KEduVocIdentifier::setTenseList(const QStringList& tenses)
+void QmVocIdentifier::setTenseList(const QStringList& tenses)
{
d->m_tenses = tenses;
}
/***************************************************************************
Copyright 2007-2008 Frederik Gladhorn <gladhorn@kde.org>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* (at your option) any later version. *
* *
***************************************************************************/
-#ifndef KEDUVOCIDENTIFIER_H
-#define KEDUVOCIDENTIFIER_H
+#ifndef QMVOCIDENTIFIER_H
+#define QMVOCIDENTIFIER_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvocpersonalpronoun.h"
-#include "keduvocarticle.h"
+#include "qmvocpersonalpronoun.h"
+#include "qmvocarticle.h"
#include <QtCore/QList>
#include <QtCore/QString>
/**
Class to store meta information about a language or any other category in the vocabulary.
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocIdentifier
+class QMVOCDOCUMENT_EXPORT QmVocIdentifier
{
public:
/**
* Default ctor.
*/
- explicit KEduVocIdentifier();
+ explicit QmVocIdentifier();
/**
* Copy ctor.
* @param other
*/
- KEduVocIdentifier( const KEduVocIdentifier &other );
+ QmVocIdentifier( const QmVocIdentifier &other );
/**
* dtor
*/
- ~KEduVocIdentifier();
+ ~QmVocIdentifier();
/**
* assignment operator
* @param other
* @return
*/
- KEduVocIdentifier& operator= ( const KEduVocIdentifier &other );
+ QmVocIdentifier& operator= ( const QmVocIdentifier &other );
public:
/**
* Articles (a, the in English, el, la,... in Spanish)
* @returns articles
*/
- KEduVocArticle& article() const;
+ QmVocArticle& article() const;
/**
* Sets the articles for this identifier
* @param art article block
*/
- void setArticle( const KEduVocArticle& article );
+ void setArticle( const QmVocArticle& article );
/**
* Get the personal pronouns for this identifier
- * @returns a KEduVocPersonalPronoun containing the personal pronouns
+ * @returns a QmVocPersonalPronoun containing the personal pronouns
*/
- KEduVocPersonalPronoun& personalPronouns() const;
+ QmVocPersonalPronoun& personalPronouns() const;
/**
* Sets personal pronouns
- * @param pronouns a KEduVocConjugation containing the personal pronouns
+ * @param pronouns a QmVocConjugation containing the personal pronouns
*/
- void setPersonalPronouns( const KEduVocPersonalPronoun &pronouns );
+ void setPersonalPronouns( const QmVocPersonalPronoun &pronouns );
/**
* Returns the name of tense number @p tenseIndex
***************************************************************************/
/***************************************************************************
- read a KEduVocDocument from a KVTML file
+ read a QmVocDocument from a KVTML file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
* *
***************************************************************************/
-#include "keduvockvtml2reader.h"
+#include "qmvockvtml2reader.h"
#include <QtCore/QTextStream>
#include <QtCore/QList>
// #include <klocale.h>
-#include "keduvocdocument.h"
-#include "keduvoclesson.h"
-#include "keduvocleitnerbox.h"
-#include "keduvocwordtype.h"
+#include "qmvocdocument.h"
+#include "qmvoclesson.h"
+#include "qmvocleitnerbox.h"
+#include "qmvocwordtype.h"
#include "kvtml2defs.h"
-#include "keduvockvtmlreader.h"
-#include "keduvoccommon_p.h"
+#include "qmvockvtmlreader.h"
+#include "qmvoccommon_p.h"
// #include <KDebug>
-KEduVocKvtml2Reader::KEduVocKvtml2Reader( QFile *file )
+QmVocKvtml2Reader::QmVocKvtml2Reader( QFile *file )
: m_inputFile( file )
{
// the file must be already open
if ( !m_inputFile->isOpen() ) {
m_errorMessage = "file must be opened first" ;
}
- qDebug("KEduVocKvtml2Reader constructor");
+ qDebug("QmVocKvtml2Reader constructor");
}
-bool KEduVocKvtml2Reader::readDoc( KEduVocDocument *doc )
+bool QmVocKvtml2Reader::readDoc( QmVocDocument *doc )
{
- qDebug("KEduVocKvtml2Reader::readDoc");
+ qDebug("QmVocKvtml2Reader::readDoc");
m_doc = doc;
- QDomDocument domDoc( "KEduVocDocument" );
+ QDomDocument domDoc( "QmVocDocument" );
if ( !domDoc.setContent( m_inputFile, &m_errorMessage ) )
return false;
// first reset the file to the beginning
m_inputFile->seek( 0 );
- KEduVocKvtmlReader oldFormat( m_inputFile );
+ QmVocKvtmlReader oldFormat( m_inputFile );
// get the return value
bool retval = oldFormat.readDoc( doc );
return result;
}
-bool KEduVocKvtml2Reader::readInformation( QDomElement &informationElement )
+bool QmVocKvtml2Reader::readInformation( QDomElement &informationElement )
{
// read the generator
QDomElement currentElement = informationElement.firstChildElement( KVTML_GENERATOR );
return true;
}
-bool KEduVocKvtml2Reader::readGroups( QDomElement &domElementParent )
+bool QmVocKvtml2Reader::readGroups( QDomElement &domElementParent )
{
bool result = false;
}
// Additional cleanup: Put orphaned entries without a lesson into a default lesson.
- KEduVocLesson *defaultLesson = new KEduVocLesson("Default Lesson", m_doc->lesson());
+ QmVocLesson *defaultLesson = new QmVocLesson("Default Lesson", m_doc->lesson());
// now make sure we don't have any orphan entries
- foreach (KEduVocExpression * entry, m_allEntries) {
+ foreach (QmVocExpression * entry, m_allEntries) {
if (!entry->lesson())
{
defaultLesson->appendEntry(entry);
}
-bool KEduVocKvtml2Reader::readIdentifier( QDomElement &identifierElement )
+bool QmVocKvtml2Reader::readIdentifier( QDomElement &identifierElement )
{
bool result = true;
int id = identifierElement.attribute( KVTML_ID ).toInt( &result );
// generate empty identifiers in the doc
for ( int i = m_doc->identifierCount(); i <= id; i++ ) {
- m_doc->appendIdentifier( KEduVocIdentifier() );
+ m_doc->appendIdentifier( QmVocIdentifier() );
}
// the first element, create the identifier, even if empty
currentElement = identifierElement.firstChildElement( KVTML_PERSONALPRONOUNS );
if ( !currentElement.isNull() ) {
- KEduVocPersonalPronoun personalPronoun;
+ QmVocPersonalPronoun personalPronoun;
readPersonalPronoun( currentElement, personalPronoun );
m_doc->identifier(id).setPersonalPronouns( personalPronoun );
}
return result;
}
-bool KEduVocKvtml2Reader::readEntry( QDomElement &entryElement )
+bool QmVocKvtml2Reader::readEntry( QDomElement &entryElement )
{
QDomElement currentElement;
bool result = true;
return false;
}
- KEduVocExpression *expr = new KEduVocExpression;
+ QmVocExpression *expr = new QmVocExpression;
// read info tags: inactive, inquery, and sizehint
currentElement = entryElement.firstChildElement( KVTML_DEACTIVATED );
return result;
}
-bool KEduVocKvtml2Reader::readTranslation( QDomElement &translationElement,
- KEduVocExpression *expr, int index )
+bool QmVocKvtml2Reader::readTranslation( QDomElement &translationElement,
+ QmVocExpression *expr, int index )
{
// read the text, grade, declension and conjugation
expr->translation(index)->fromKVTML2(translationElement);
// article grade
currentElement = translationElement.firstChildElement( KVTML_ARTICLE );
if ( !currentElement.isNull() ) {
- KEduVocText article;
+ QmVocText article;
article.fromKVTML2(currentElement);
expr->translation(index)->setArticle(article);
}
return true;
}
-bool KEduVocKvtml2Reader::readChildLessons( KEduVocLesson* parentLesson, QDomElement &lessonElement )
+bool QmVocKvtml2Reader::readChildLessons( QmVocLesson* parentLesson, QDomElement &lessonElement )
{
QDomElement currentElement = lessonElement.firstChildElement( KVTML_CONTAINER );
while ( !currentElement.isNull() ) {
return true;
}
-bool KEduVocKvtml2Reader::readLesson( KEduVocLesson* parentLesson, QDomElement &lessonElement )
+bool QmVocKvtml2Reader::readLesson( QmVocLesson* parentLesson, QDomElement &lessonElement )
{
//<name>Lesson name</name>
QDomElement currentElement = lessonElement.firstChildElement( KVTML_NAME );
- KEduVocLesson * lesson = new KEduVocLesson(currentElement.text(), parentLesson);
+ QmVocLesson * lesson = new QmVocLesson(currentElement.text(), parentLesson);
parentLesson->appendChildContainer( lesson );
readChildLessons( lesson, lessonElement );
return true;
}
-bool KEduVocKvtml2Reader::readSynonymsAntonymsFalseFriends( QDomElement &rootElement )
+bool QmVocKvtml2Reader::readSynonymsAntonymsFalseFriends( QDomElement &rootElement )
{
QDomElement pairElement;
- for(int type = KEduVocTranslation::Synonym; type <= KEduVocTranslation::FalseFriend; type++) {
+ for(int type = QmVocTranslation::Synonym; type <= QmVocTranslation::FalseFriend; type++) {
switch (type) {
- case KEduVocTranslation::Synonym:
+ case QmVocTranslation::Synonym:
pairElement= rootElement.firstChildElement( KVTML_SYNONYM );
break;
- case KEduVocTranslation::Antonym:
+ case QmVocTranslation::Antonym:
pairElement= rootElement.firstChildElement( KVTML_ANTONYM );
break;
- case KEduVocTranslation::FalseFriend:
+ case QmVocTranslation::FalseFriend:
pairElement= rootElement.firstChildElement( KVTML_FALSEFRIEND );
break;
}
int secondTranslationId = translationElement.attribute( KVTML_ID ).toInt();
// pair them up
- KEduVocTranslation *first = m_allEntries[firstEntryId]->translation(firstTranslationId);
- KEduVocTranslation *second = m_allEntries[secondEntryId]->translation(secondTranslationId);
+ QmVocTranslation *first = m_allEntries[firstEntryId]->translation(firstTranslationId);
+ QmVocTranslation *second = m_allEntries[secondEntryId]->translation(secondTranslationId);
switch (type) {
- case KEduVocTranslation::Synonym:
+ case QmVocTranslation::Synonym:
first->addSynonym(second);
second->addSynonym(first);
break;
- case KEduVocTranslation::Antonym:
+ case QmVocTranslation::Antonym:
first->addAntonym(second);
second->addAntonym(first);
break;
- case KEduVocTranslation::FalseFriend:
+ case QmVocTranslation::FalseFriend:
first->addFalseFriend(second);
second->addFalseFriend(first);
break;
return true;
}
-bool KEduVocKvtml2Reader::readArticle( QDomElement &articleElement, int identifierNum )
+bool QmVocKvtml2Reader::readArticle( QDomElement &articleElement, int identifierNum )
/*
<article>
<singlular>
</article>
*/
{
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> genders;
- genders[0] = KEduVocWordFlag::Masculine;
- genders[1] = KEduVocWordFlag::Feminine;
- genders[2] = KEduVocWordFlag::Neuter;
- QMap<int, KEduVocWordFlag::Flags> defs;
- defs[0] = KEduVocWordFlag::Definite;
- defs[1] = KEduVocWordFlag::Indefinite;
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> genders;
+ genders[0] = QmVocWordFlag::Masculine;
+ genders[1] = QmVocWordFlag::Feminine;
+ genders[2] = QmVocWordFlag::Neuter;
+ QMap<int, QmVocWordFlag::Flags> defs;
+ defs[0] = QmVocWordFlag::Definite;
+ defs[1] = QmVocWordFlag::Indefinite;
for ( int num = 0; num <= 2; ++num) {
QDomElement numberElement = articleElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[num] );
}
-bool KEduVocKvtml2Reader::readChildWordTypes(KEduVocWordType* parentContainer, QDomElement &lessonElement)
+bool QmVocKvtml2Reader::readChildWordTypes(QmVocWordType* parentContainer, QDomElement &lessonElement)
{
QDomElement currentElement = lessonElement.firstChildElement( KVTML_CONTAINER );
while ( !currentElement.isNull() ) {
return true;
}
-bool KEduVocKvtml2Reader::readLeitner( KEduVocLeitnerBox* parentContainer, QDomElement &leitnerParentElement )
+bool QmVocKvtml2Reader::readLeitner( QmVocLeitnerBox* parentContainer, QDomElement &leitnerParentElement )
{
QDomElement leitnerElement = leitnerParentElement.firstChildElement( KVTML_CONTAINER );
while ( !leitnerElement.isNull() ) {
QString name = leitnerElement.firstChildElement( KVTML_NAME ).text();
- KEduVocLeitnerBox * leitner = new KEduVocLeitnerBox(name, parentContainer);
+ QmVocLeitnerBox * leitner = new QmVocLeitnerBox(name, parentContainer);
parentContainer->appendChildContainer(leitner);
// for leitner we only allow a flat list, no sub boxes.
return true;
}
-bool KEduVocKvtml2Reader::readWordType( KEduVocWordType* parentContainer, QDomElement &typeElement )
+bool QmVocKvtml2Reader::readWordType( QmVocWordType* parentContainer, QDomElement &typeElement )
{
// set type and specialtype
QString typeName =
typeElement.firstChildElement( KVTML_NAME ).text();
- KEduVocWordType * wordTypeContainer = new KEduVocWordType(typeName, parentContainer);
+ QmVocWordType * wordTypeContainer = new QmVocWordType(typeName, parentContainer);
parentContainer->appendChildContainer(wordTypeContainer);
QString specialType = typeElement.firstChildElement( KVTML_SPECIALWORDTYPE ).text();
if ( !specialType.isEmpty() ) {
// get the localized version
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Noun);
+ wordTypeContainer->setWordType(QmVocWordFlag::Noun);
}
if ( specialType == KVTML_SPECIALWORDTYPE_VERB ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Verb);
+ wordTypeContainer->setWordType(QmVocWordFlag::Verb);
}
if ( specialType == KVTML_SPECIALWORDTYPE_ADVERB ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Adverb);
+ wordTypeContainer->setWordType(QmVocWordFlag::Adverb);
}
if ( specialType == KVTML_SPECIALWORDTYPE_ADJECTIVE ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Adjective);
+ wordTypeContainer->setWordType(QmVocWordFlag::Adjective);
}
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN_MALE ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Masculine);
+ wordTypeContainer->setWordType(QmVocWordFlag::Noun | QmVocWordFlag::Masculine);
}
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN_FEMALE ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Feminine);
+ wordTypeContainer->setWordType(QmVocWordFlag::Noun | QmVocWordFlag::Feminine);
}
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN_NEUTRAL ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Noun| KEduVocWordFlag::Neuter);
+ wordTypeContainer->setWordType(QmVocWordFlag::Noun| QmVocWordFlag::Neuter);
}
if ( specialType == KVTML_SPECIALWORDTYPE_CONJUNCTION ) {
- wordTypeContainer->setWordType(KEduVocWordFlag::Conjunction);
+ wordTypeContainer->setWordType(QmVocWordFlag::Conjunction);
}
} // special type
return true;
}
-QStringList KEduVocKvtml2Reader::readTenses( QDomElement &tensesElement )
+QStringList QmVocKvtml2Reader::readTenses( QDomElement &tensesElement )
{
QStringList tenses;
return tenses;
}
-bool KEduVocKvtml2Reader::readComparison( QDomElement &domElementParent, KEduVocTranslation* translation )
+bool QmVocKvtml2Reader::readComparison( QDomElement &domElementParent, QmVocTranslation* translation )
/*
<comparison>
<comparative>better</comparative>
currentElement = domElementParent.firstChildElement( KVTML_COMPARATIVE );
if ( !currentElement.isNull() )
{
- KEduVocText comparative;
+ QmVocText comparative;
comparative.fromKVTML2(currentElement);
// be compatible for KDE < 4.5
currentElement = domElementParent.firstChildElement( KVTML_SUPERLATIVE );
if ( !currentElement.isNull() )
{
- KEduVocText superlative;
+ QmVocText superlative;
superlative.fromKVTML2(currentElement);
// be compatible for KDE < 4.5
return true;
}
-bool KEduVocKvtml2Reader::readMultipleChoice( QDomElement &multipleChoiceElement, KEduVocTranslation* translation )
+bool QmVocKvtml2Reader::readMultipleChoice( QDomElement &multipleChoiceElement, QmVocTranslation* translation )
/*
<multiplechoice>
<choice>good</choice>
}
-bool KEduVocKvtml2Reader::readPersonalPronoun(QDomElement & pronounElement, KEduVocPersonalPronoun & pronoun)
+bool QmVocKvtml2Reader::readPersonalPronoun(QDomElement & pronounElement, QmVocPersonalPronoun & pronoun)
{
pronoun.setMaleFemaleDifferent(!pronounElement.firstChildElement(
KVTML_THIRD_PERSON_MALE_FEMALE_DIFFERENT).isNull());
QDomElement personElement = pronounElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[0] );
if ( !personElement.isNull() ) {
- readPersonalPronounChild( personElement, pronoun, KEduVocWordFlag::Singular );
+ readPersonalPronounChild( personElement, pronoun, QmVocWordFlag::Singular );
}
personElement = pronounElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[1] );
if ( !personElement.isNull() ) {
- readPersonalPronounChild( personElement, pronoun, KEduVocWordFlag::Dual );
+ readPersonalPronounChild( personElement, pronoun, QmVocWordFlag::Dual );
}
personElement = pronounElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[2] );
if ( !personElement.isNull() ) {
- readPersonalPronounChild( personElement, pronoun, KEduVocWordFlag::Plural );
+ readPersonalPronounChild( personElement, pronoun, QmVocWordFlag::Plural );
}
return true;
}
-bool KEduVocKvtml2Reader::readPersonalPronounChild(QDomElement & personElement, KEduVocPersonalPronoun & pronoun, KEduVocWordFlags number)
+bool QmVocKvtml2Reader::readPersonalPronounChild(QDomElement & personElement, QmVocPersonalPronoun & pronoun, QmVocWordFlags number)
{
- QMap<int, KEduVocWordFlag::Flags> persons;
- persons[0] = KEduVocWordFlag::First;
- persons[1] = KEduVocWordFlag::Second;
- persons[2] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
- persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
- persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+ QMap<int, QmVocWordFlag::Flags> persons;
+ persons[0] = QmVocWordFlag::First;
+ persons[1] = QmVocWordFlag::Second;
+ persons[2] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Masculine);
+ persons[3] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Feminine);
+ persons[4] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Neuter);
}
-// #include "keduvockvtml2reader.moc"
***************************************************************************/
/***************************************************************************
- read a KEduVocDocument from a KVTML2 file
+ read a QmVocDocument from a KVTML2 file
-----------------------------------------------------------------------
copyright : (C) 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
* *
***************************************************************************/
-#ifndef KEDUVOCKVTML2READER_H
-#define KEDUVOCKVTML2READER_H
+#ifndef QMVOCKVTML2READER_H
+#define QMVOCKVTML2READER_H
#include <QtXml/QDomDocument>
#include <QList>
#include <QFile>
-#include "keduvocexpression.h"
-#include "keduvocpersonalpronoun.h"
-#include "keduvocarticle.h"
-#include "keduvocmultiplechoice.h"
+#include "qmvocexpression.h"
+#include "qmvocpersonalpronoun.h"
+#include "qmvocarticle.h"
+#include "qmvocmultiplechoice.h"
class QIODevice;
-class KEduVocDocument;
-class KEduVocWordType;
+class QmVocDocument;
+class QmVocWordType;
/**
-* @brief class to read kvtml2 data files into keduvocdocument
+* @brief class to read kvtml2 data files into qmvocdocument
* @author Jeremy Whiting
*/
-class KEduVocKvtml2Reader : public QObject
+class QmVocKvtml2Reader : public QObject
{
Q_OBJECT
public:
/** default constructor
* @param file file to read from
*/
- KEduVocKvtml2Reader( QFile *file );
+ QmVocKvtml2Reader( QFile *file );
/** read the document
* @param doc document object to store the data in
*/
- bool readDoc( KEduVocDocument *doc );
+ bool readDoc( QmVocDocument *doc );
/** get the errormessage string
* @returns the errormessage string
*/
bool readArticle( QDomElement &articleElement, int identifierNum );
- bool readPersonalPronoun( QDomElement &conjugElement, KEduVocPersonalPronoun &pronoun );
+ bool readPersonalPronoun( QDomElement &conjugElement, QmVocPersonalPronoun &pronoun );
- bool readPersonalPronounChild(QDomElement & personElement, KEduVocPersonalPronoun &pronoun, KEduVocWordFlags flags);
+ bool readPersonalPronounChild(QDomElement & personElement, QmVocPersonalPronoun &pronoun, QmVocWordFlags flags);
/** read the types
* @param typesElement QDomElement for the types group
*/
- bool readWordType( KEduVocWordType* parentContainer, QDomElement &typesElement );
+ bool readWordType( QmVocWordType* parentContainer, QDomElement &typesElement );
/**
* Read a leitner box container.
* This is a grading system where the vocabulary are kept in boxes and promoted/demoted during the learning.
* Be aware that leitner boxes are a list only and no sub boxes will ever be read or written.
- * While reusing the lesson class is quite easy for this a proper subclass of KEduVocContainer would be the better solution.
+ * While reusing the lesson class is quite easy for this a proper subclass of QmVocContainer would be the better solution.
* @param parentContainer the parent to append the new leitner container to
* @param leitnerElement the element in the dom
* @return success
*/
- bool readLeitner( KEduVocLeitnerBox* parentContainer, QDomElement &leitnerElement );
+ bool readLeitner( QmVocLeitnerBox* parentContainer, QDomElement &leitnerElement );
/**
* Read all <container> tags within a word type definition.
* @param lessonElement
* @return
*/
- bool readChildWordTypes( KEduVocWordType* parentContainer, QDomElement &lessonElement );
+ bool readChildWordTypes( QmVocWordType* parentContainer, QDomElement &lessonElement );
/** read the tenses
* @param tensesElement QDomElement for the tenses group
/** read a translation
* @param translationElement QDomElement for the translation to read
*/
- bool readTranslation( QDomElement &translationElement, KEduVocExpression *expr, int index );
+ bool readTranslation( QDomElement &translationElement, QmVocExpression *expr, int index );
/** read a comparison
* @param comparisonElement comparison group element
* @param comp comparison object to read into
*/
- bool readComparison( QDomElement &comparisonElement, KEduVocTranslation *translation );
+ bool readComparison( QDomElement &comparisonElement, QmVocTranslation *translation );
/** read a multiple choice group
* @param multipleChoiceElement element to read from
- * @param mc KEduVocMultipleChoice object to read to
+ * @param mc QmVocMultipleChoice object to read to
*/
- bool readMultipleChoice( QDomElement &multipleChoiceElement, KEduVocTranslation* translation );
+ bool readMultipleChoice( QDomElement &multipleChoiceElement, QmVocTranslation* translation );
/**
* Read <lesson> tags.
* @param lessonElement
* @return
*/
- bool readChildLessons( KEduVocLesson* parentLesson, QDomElement &lessonElement );
+ bool readChildLessons( QmVocLesson* parentLesson, QDomElement &lessonElement );
/** read a lesson, and append it to the document
* @param lessonElement element to read from
*/
- bool readLesson( KEduVocLesson* parentLesson, QDomElement &lessonElement );
+ bool readLesson( QmVocLesson* parentLesson, QDomElement &lessonElement );
bool readSynonymsAntonymsFalseFriends( QDomElement &rootElement );
/** pre-opened QIODevice to read from */
QIODevice *m_inputFile;
- /** KEduVocDocument to read to */
- KEduVocDocument *m_doc;
+ /** QmVocDocument to read to */
+ QmVocDocument *m_doc;
/** because we read the entries first, we store them here temporarily.
* later we read the lessons and put the entries there based on the key (their id) */
- QMap<int, KEduVocExpression*> m_allEntries;
+ QMap<int, QmVocExpression*> m_allEntries;
/** error message */
QString m_errorMessage;
***************************************************************************/
/***************************************************************************
- export a KEduVocDocument to a KVTML file
+ export a QmVocDocument to a KVTML file
-----------------------------------------------------------------------
copyright : (C) 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007-2010 Frederik Gladhorn <gladhorn@kde.org>
* *
***************************************************************************/
-#include "keduvockvtml2writer.h"
+#include "qmvockvtml2writer.h"
#include <QtCore/QTextStream>
#include <QtCore/QFile>
// #include <KDebug>
#include <QDebug>
-#include "keduvocdocument.h"
-#include "keduvocexpression.h"
-#include "keduvoclesson.h"
-#include "keduvocleitnerbox.h"
-#include "keduvocwordtype.h"
+#include "qmvocdocument.h"
+#include "qmvocexpression.h"
+#include "qmvoclesson.h"
+#include "qmvocleitnerbox.h"
+#include "qmvocwordtype.h"
#include "kvtml2defs.h"
-KEduVocKvtml2Writer::KEduVocKvtml2Writer( QFile *file )
+QmVocKvtml2Writer::QmVocKvtml2Writer( QFile *file )
{
// the file must be already open
m_outputFile = file;
}
-bool KEduVocKvtml2Writer::writeDoc( KEduVocDocument *doc, const QString &generator )
+bool QmVocKvtml2Writer::writeDoc( QmVocDocument *doc, const QString &generator )
{
if (createXmlDocument(doc, generator)) {
QTextStream ts( m_outputFile );
return false;
}
-QByteArray KEduVocKvtml2Writer::toByteArray(KEduVocDocument * doc, const QString & generator)
+QByteArray QmVocKvtml2Writer::toByteArray(QmVocDocument * doc, const QString & generator)
{
if (createXmlDocument(doc, generator)) {
return m_domDoc.toByteArray();
return QByteArray();
}
-bool KEduVocKvtml2Writer::createXmlDocument( KEduVocDocument *doc, const QString &generator )
+bool QmVocKvtml2Writer::createXmlDocument( QmVocDocument *doc, const QString &generator )
{
m_doc = doc;
return true;
}
-bool KEduVocKvtml2Writer::writeInformation( QDomElement &informationElement, const QString &generator )
+bool QmVocKvtml2Writer::writeInformation( QDomElement &informationElement, const QString &generator )
{
QDomElement currentElement;
QDomText textNode;
}
-bool KEduVocKvtml2Writer::writeIdentifiers( QDomElement &identifiersElement )
+bool QmVocKvtml2Writer::writeIdentifiers( QDomElement &identifiersElement )
{
for ( int i = 0; i < m_doc->identifierCount(); ++i ) {
// create the node
return true;
}
-bool KEduVocKvtml2Writer::writeLessons( KEduVocLesson *parentLesson, QDomElement &lessonsElement )
+bool QmVocKvtml2Writer::writeLessons( QmVocLesson *parentLesson, QDomElement &lessonsElement )
{
// iterate over child lessons.
// the first time this is called with the root lesson which does not have a <lesson> entry.
for( int i = 0; i < parentLesson->childContainerCount(); i++ ) {
- KEduVocLesson *lesson = static_cast<KEduVocLesson*>(parentLesson->childContainer(i));
+ QmVocLesson *lesson = static_cast<QmVocLesson*>(parentLesson->childContainer(i));
// make lesson element
QDomElement thisLessonElement = m_domDoc.createElement( KVTML_CONTAINER );
writeLessons(lesson, thisLessonElement);
// child entries
- foreach(KEduVocExpression *entry, lesson->entries()) {
+ foreach(QmVocExpression *entry, lesson->entries()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(entry)) );
thisLessonElement.appendChild(entryElement);
-void KEduVocKvtml2Writer::writeSynonymAntonymFalseFriend(QDomElement & parentElement)
+void QmVocKvtml2Writer::writeSynonymAntonymFalseFriend(QDomElement & parentElement)
{
- QList< KEduVocTranslation* > currentList;
+ QList< QmVocTranslation* > currentList;
QDomElement synonymElement;
// synonym, antonym, false friend
- for(int type = KEduVocTranslation::Synonym; type <= KEduVocTranslation::FalseFriend; type++) {
+ for(int type = QmVocTranslation::Synonym; type <= QmVocTranslation::FalseFriend; type++) {
switch (type) {
- case KEduVocTranslation::Synonym:
+ case QmVocTranslation::Synonym:
synonymElement = m_domDoc.createElement( KVTML_SYNONYM );
currentList = m_synonyms;
break;
- case KEduVocTranslation::Antonym:
+ case QmVocTranslation::Antonym:
synonymElement = m_domDoc.createElement( KVTML_ANTONYM );
currentList = m_antonyms;
break;
- case KEduVocTranslation::FalseFriend:
+ case QmVocTranslation::FalseFriend:
synonymElement = m_domDoc.createElement( KVTML_FALSEFRIEND );
currentList = m_falseFriends;
break;
while (!currentList.isEmpty()) {
// after writing a translation, remove it from the list
- KEduVocTranslation* translation = currentList.takeFirst();
+ QmVocTranslation* translation = currentList.takeFirst();
QDomElement relatedElement;
- QList <KEduVocTranslation*> list;
+ QList <QmVocTranslation*> list;
switch (type) {
- case KEduVocTranslation::Synonym:
+ case QmVocTranslation::Synonym:
list = translation->synonyms();
break;
- case KEduVocTranslation::Antonym:
+ case QmVocTranslation::Antonym:
list = translation->antonyms();
break;
- case KEduVocTranslation::FalseFriend:
+ case QmVocTranslation::FalseFriend:
list = translation->falseFriends();
break;
}
- foreach (KEduVocTranslation* synonym, list) {
+ foreach (QmVocTranslation* synonym, list) {
// if it is not in the list it has already been written and we can move on
if (currentList.contains(synonym)) {
relatedElement = m_domDoc.createElement( KVTML_PAIR );
} // iterate over types
}
/*
-bool KEduVocKvtml2Writer::writeRelated(QDomElement & parentElement, QList< KEduVocTranslation * > relatedList)
+bool QmVocKvtml2Writer::writeRelated(QDomElement & parentElement, QList< QmVocTranslation * > relatedList)
{
- foreach (KEduVocTranslation* synonym, translation->synonyms()) {
+ foreach (QmVocTranslation* synonym, translation->synonyms()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(translation->entry())) );
}
}*/
-bool KEduVocKvtml2Writer::writeArticle( QDomElement &articleElement, int language )
+bool QmVocKvtml2Writer::writeArticle( QDomElement &articleElement, int language )
{
///@todo only write if not empty
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> genders;
- genders[0] = KEduVocWordFlag::Masculine;
- genders[1] = KEduVocWordFlag::Feminine;
- genders[2] = KEduVocWordFlag::Neuter;
- QMap<int, KEduVocWordFlag::Flags> defs;
- defs[0] = KEduVocWordFlag::Definite;
- defs[1] = KEduVocWordFlag::Indefinite;
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> genders;
+ genders[0] = QmVocWordFlag::Masculine;
+ genders[1] = QmVocWordFlag::Feminine;
+ genders[2] = QmVocWordFlag::Neuter;
+ QMap<int, QmVocWordFlag::Flags> defs;
+ defs[0] = QmVocWordFlag::Definite;
+ defs[1] = QmVocWordFlag::Indefinite;
for (int num = 0; num <= 2; num++)
{
}
-bool KEduVocKvtml2Writer::writeWordTypes( QDomElement &typesElement, KEduVocWordType* parentContainer )
+bool QmVocKvtml2Writer::writeWordTypes( QDomElement &typesElement, QmVocWordType* parentContainer )
{
- foreach( KEduVocContainer* container, parentContainer->childContainers() ) {
- KEduVocWordType* wordType = static_cast<KEduVocWordType*>(container);
+ foreach( QmVocContainer* container, parentContainer->childContainers() ) {
+ QmVocWordType* wordType = static_cast<QmVocWordType*>(container);
QDomElement typeDefinitionElement = m_domDoc.createElement( KVTML_CONTAINER );
typeDefinitionElement.appendChild( newTextElement( KVTML_NAME, wordType->name() ) );
- if (wordType->wordType().testFlag(KEduVocWordFlag::Noun))
+ if (wordType->wordType().testFlag(QmVocWordFlag::Noun))
{
- if (wordType->wordType().testFlag(KEduVocWordFlag::Masculine))
+ if (wordType->wordType().testFlag(QmVocWordFlag::Masculine))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_MALE ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Feminine))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Feminine))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_FEMALE ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Neuter))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Neuter))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_NEUTRAL ) );
else
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN ) );
}
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Verb))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Verb))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_VERB ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Adjective))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Adjective))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_ADJECTIVE ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Adverb))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Adverb))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_ADVERB ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Conjunction))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Conjunction))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_CONJUNCTION ) );
// child entries
// child entries
- foreach(KEduVocExpression *entry, wordType->entries()) {
+ foreach(QmVocExpression *entry, wordType->entries()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(entry)) );
for(int translation = 0; translation<m_doc->identifierCount(); translation++) {
return true;
}
-bool KEduVocKvtml2Writer::writeLeitnerBoxes( QDomElement &leitnerParentElement, KEduVocLeitnerBox* parentContainer )
+bool QmVocKvtml2Writer::writeLeitnerBoxes( QDomElement &leitnerParentElement, QmVocLeitnerBox* parentContainer )
{
- foreach( KEduVocContainer* container, parentContainer->childContainers() ) {
- KEduVocLeitnerBox* leitnerBox = static_cast<KEduVocLeitnerBox*>(container);
+ foreach( QmVocContainer* container, parentContainer->childContainers() ) {
+ QmVocLeitnerBox* leitnerBox = static_cast<QmVocLeitnerBox*>(container);
QDomElement containerElement = m_domDoc.createElement( KVTML_CONTAINER );
containerElement.appendChild( newTextElement( KVTML_NAME, leitnerBox->name() ) );
// child entries
- foreach(KEduVocExpression *entry, leitnerBox->entries()) {
+ foreach(QmVocExpression *entry, leitnerBox->entries()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(entry)) );
for(int translation = 0; translation<m_doc->identifierCount(); translation++) {
return true;
}
-bool KEduVocKvtml2Writer::writeEntries( QDomElement &entriesElement )
+bool QmVocKvtml2Writer::writeEntries( QDomElement &entriesElement )
{
- m_allEntries = m_doc->lesson()->entries(KEduVocLesson::Recursive);
+ m_allEntries = m_doc->lesson()->entries(QmVocLesson::Recursive);
// loop through entries
for ( int i = 0; i < m_allEntries.count(); ++i ) {
- KEduVocExpression *thisEntry = m_allEntries.value(i);
+ QmVocExpression *thisEntry = m_allEntries.value(i);
// write entry tag
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
}
-bool KEduVocKvtml2Writer::writeTranslation( QDomElement &translationElement, KEduVocTranslation* translation )
+bool QmVocKvtml2Writer::writeTranslation( QDomElement &translationElement, QmVocTranslation* translation )
{
- // so far only for KEduVocWord - text and grades
+ // so far only for QmVocWord - text and grades
translation->toKVTML2(translationElement);
// comparison
if ( !(translation->comparativeForm().text().isEmpty() || translation->superlativeForm().text().isEmpty())) {
- kDebug() << "Write comp";
+ qDebug() << "Write comp";
QDomElement comparisonElement = m_domDoc.createElement( KVTML_COMPARISON );
translationElement.appendChild(comparisonElement);
// }
// }
-bool KEduVocKvtml2Writer::writeMultipleChoice( QDomElement &multipleChoiceElement, KEduVocTranslation* translation )
+bool QmVocKvtml2Writer::writeMultipleChoice( QDomElement &multipleChoiceElement, QmVocTranslation* translation )
/*
<multiplechoice>
<choice>good</choice>
return true;
}
-QDomElement KEduVocKvtml2Writer::newTextElement( const QString &elementName, const QString &text )
+QDomElement QmVocKvtml2Writer::newTextElement( const QString &elementName, const QString &text )
{
QDomElement retval = m_domDoc.createElement( elementName );
QDomText textNode = m_domDoc.createTextNode( text );
return retval;
}
-bool KEduVocKvtml2Writer::writePersonalPronoun(QDomElement & pronounElement, const KEduVocPersonalPronoun & pronoun)
+bool QmVocKvtml2Writer::writePersonalPronoun(QDomElement & pronounElement, const QmVocPersonalPronoun & pronoun)
{
// general pronoun properties
if ( pronoun.maleFemaleDifferent() ) {
}
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> persons;
- persons[0] = KEduVocWordFlag::First;
- persons[1] = KEduVocWordFlag::Second;
- persons[2] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
- persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
- persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> persons;
+ persons[0] = QmVocWordFlag::First;
+ persons[1] = QmVocWordFlag::Second;
+ persons[2] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Masculine);
+ persons[3] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Feminine);
+ persons[4] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Neuter);
return true;
}
-void KEduVocKvtml2Writer::appendTextElement(QDomElement & parent, const QString & elementName, const QString & text)
+void QmVocKvtml2Writer::appendTextElement(QDomElement & parent, const QString & elementName, const QString & text)
{
// empty will never be written
if (text.isEmpty()) {
***************************************************************************/
/***************************************************************************
- export a KEduVocDocument to a KVTML file
+ export a QmVocDocument to a KVTML file
-----------------------------------------------------------------------
copyright : (C) 2007 Jeremy Whiting <jpwhiting@kde.org>
(C) 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCKVTML2WRITER_H
-#define KEDUVOCKVTML2WRITER_H
+#ifndef QMVOCKVTML2WRITER_H
+#define QMVOCKVTML2WRITER_H
#include <QtXml/QDomDocument>
#include <QtCore/QList>
#include <QtCore/QFile>
-#include "keduvocarticle.h"
-#include "keduvocmultiplechoice.h"
-#include "keduvoctranslation.h"
-#include "keduvocpersonalpronoun.h"
+#include "qmvocarticle.h"
+#include "qmvocmultiplechoice.h"
+#include "qmvoctranslation.h"
+#include "qmvocpersonalpronoun.h"
-class KEduVocDocument;
-class KEduVocExpression;
-class KEduVocLesson;
-class KEduVocLeitnerBox;
+class QmVocDocument;
+class QmVocExpression;
+class QmVocLesson;
+class QmVocLeitnerBox;
/**
-* @brief Class to write kvtml2 data files from KEduVocDocument
+* @brief Class to write kvtml2 data files from QmVocDocument
* @author Jeremy Whiting
*/
-class KEduVocKvtml2Writer
+class QmVocKvtml2Writer
{
public:
- KEduVocKvtml2Writer( QFile *file );
+ QmVocKvtml2Writer( QFile *file );
- bool writeDoc( KEduVocDocument *doc, const QString &generator );
+ bool writeDoc( QmVocDocument *doc, const QString &generator );
- QByteArray toByteArray( KEduVocDocument *doc, const QString &generator );
+ QByteArray toByteArray( QmVocDocument *doc, const QString &generator );
/**
* Helper function, appends a new element AND a text child to @p parent
private:
- bool createXmlDocument( KEduVocDocument *doc, const QString &generator );
+ bool createXmlDocument( QmVocDocument *doc, const QString &generator );
/** write information entries
* @param informationElement QDomElement information to write to
*/
bool writeArticle( QDomElement &articleElement, int article );
- bool writePersonalPronoun( QDomElement &pronounElement, const KEduVocPersonalPronoun &pronoun);
+ bool writePersonalPronoun( QDomElement &pronounElement, const QmVocPersonalPronoun &pronoun);
/** write types
* @param typesElement QDomElement types to write to
*/
- bool writeWordTypes( QDomElement &typesElement, KEduVocWordType* parentContainer );
+ bool writeWordTypes( QDomElement &typesElement, QmVocWordType* parentContainer );
/**
- * write the leitner boxes @see KEduVocLeitnerBox
+ * write the leitner boxes @see QmVocLeitnerBox
* @param leitnerParentElement parent dom element
- * @param parentContainer parent of the KEduVocLeitnerBoxes to write
+ * @param parentContainer parent of the QmVocLeitnerBoxes to write
* @return success
*/
- bool writeLeitnerBoxes( QDomElement &leitnerParentElement, KEduVocLeitnerBox* parentContainer );
+ bool writeLeitnerBoxes( QDomElement &leitnerParentElement, QmVocLeitnerBox* parentContainer );
/** write entries
* @param entriesElement QDomElement entries to write to
* @param translationElement QDomElement translation to write to, with id pre-set
* @param translation object to write
*/
- bool writeTranslation( QDomElement &translationElement, KEduVocTranslation* translation );
+ bool writeTranslation( QDomElement &translationElement, QmVocTranslation* translation );
/**
* Used to write synonym, antonym and false friend lists
* @param parentContainer
* @return
*/
- bool writeRelated( QDomElement &parentElement, QList<KEduVocTranslation*> relatedList );
+ bool writeRelated( QDomElement &parentElement, QList<QmVocTranslation*> relatedList );
/** write the lesson group
* @param parentLesson the parent lesson of the current lesson
* @param lessonsElement QDomElement lessons to write to
*/
- bool writeLessons( KEduVocLesson *parentLesson, QDomElement &lessonsElement );
+ bool writeLessons( QmVocLesson *parentLesson, QDomElement &lessonsElement );
void writeSynonymAntonymFalseFriend(QDomElement & parentElement);
* @param multipleChoiceElement QDomElement multiplechoice to write to
* @returns success
*/
- bool writeMultipleChoice( QDomElement &multipleChoiceElement, KEduVocTranslation* translation );
+ bool writeMultipleChoice( QDomElement &multipleChoiceElement, QmVocTranslation* translation );
QDomElement newTextElement( const QString &elementName, const QString &text );
QFile *m_outputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
- QList<KEduVocExpression*> m_allEntries;
- QList<KEduVocTranslation*> m_synonyms;
- QList<KEduVocTranslation*> m_antonyms;
- QList<KEduVocTranslation*> m_falseFriends;
+ QList<QmVocExpression*> m_allEntries;
+ QList<QmVocTranslation*> m_synonyms;
+ QList<QmVocTranslation*> m_antonyms;
+ QList<QmVocTranslation*> m_falseFriends;
QDomDocument m_domDoc;
};
/***************************************************************************
- C++ Implementation: keduvockvtml1compability_p
+ C++ Implementation: qmvockvtml1compability_p
-----------------------------------------------------------------------
* *
***************************************************************************/
-#include "keduvockvtmlcompability.h"
-#include "keduvocwordtype.h"
+#include "qmvockvtmlcompability.h"
+#include "qmvocwordtype.h"
// #include <KLocale>
// #include <KDebug>
#include <QDebug>
#include <QStringList>
-const QString KEduVocKvtmlCompability::KVTML_1_USER_DEFINED = QString( "#" );
-const QString KEduVocKvtmlCompability::KVTML_1_SEPERATOR = QString( ":" );
+const QString QmVocKvtmlCompability::KVTML_1_USER_DEFINED = QString( "#" );
+const QString QmVocKvtmlCompability::KVTML_1_SEPERATOR = QString( ":" );
-KEduVocKvtmlCompability::KEduVocKvtmlCompability()
+QmVocKvtmlCompability::QmVocKvtmlCompability()
{
m_userdefinedTenseCounter = 0;
m_userdefinedTypeCounter = 0;
////////////////// TYPES /////////////////////////////////////////
-void KEduVocKvtmlCompability::initOldTypeLists()
+void QmVocKvtmlCompability::initOldTypeLists()
{
m_oldMainTypeNames.clear();
m_oldMainTypeNames.insert( "v", "Verb" );
}
-KEduVocWordType* KEduVocKvtmlCompability::typeFromOldFormat(KEduVocWordType* parent, const QString & typeSubtypeString ) const
+QmVocWordType* QmVocKvtmlCompability::typeFromOldFormat(QmVocWordType* parent, const QString & typeSubtypeString ) const
{
// check if it's user defined
if ( typeSubtypeString.length() >= 2 && typeSubtypeString.left( 1 ) == QM_USER_TYPE ) {
// they started counting at 1, we need to know which index we are dealing with:
int selfDefinedTypeIndex = typeSubtypeString.right( typeSubtypeString.count()-1 ).toInt() -1;
- return static_cast<KEduVocWordType*>(parent->childContainer(selfDefinedTypeIndex));
+ return static_cast<QmVocWordType*>(parent->childContainer(selfDefinedTypeIndex));
}
// assume the parent is set up to contain the old types correctly
QString subTypeName = m_oldSubTypeNames.value( subType );
- foreach (KEduVocContainer* wordType, parent->childContainers()) {
+ foreach (QmVocContainer* wordType, parent->childContainers()) {
if (wordType->name() == typeName) {
if (subType.isEmpty()) {
- return static_cast<KEduVocWordType*>(wordType);
+ return static_cast<QmVocWordType*>(wordType);
} else {
- foreach (KEduVocContainer* subWordType, wordType->childContainers()) {
+ foreach (QmVocContainer* subWordType, wordType->childContainers()) {
if (subWordType->name() == subTypeName) {
- return static_cast<KEduVocWordType*>(subWordType);
+ return static_cast<QmVocWordType*>(subWordType);
}
}
}
-void KEduVocKvtmlCompability::initOldTenses()
+void QmVocKvtmlCompability::initOldTenses()
{
m_oldTenses["PrSi"] = "Simple Present" ;
m_oldTenses["PrPr"] = "Present Progressive" ;
}
-void KEduVocKvtmlCompability::addUserdefinedTense(const QString & tense)
+void QmVocKvtmlCompability::addUserdefinedTense(const QString & tense)
{
m_userdefinedTenseCounter++;
m_oldTenses[KVTML_1_USER_DEFINED + QString::number( m_userdefinedTenseCounter )] = tense;
}
-QString KEduVocKvtmlCompability::tenseFromKvtml1(const QString & oldTense)
+QString QmVocKvtmlCompability::tenseFromKvtml1(const QString & oldTense)
{
// in case the document got chaged, at least make up something as tense
if (!m_oldTenses.keys().contains(oldTense)) {
}
-QStringList KEduVocKvtmlCompability::documentTenses() const
+QStringList QmVocKvtmlCompability::documentTenses() const
{
return m_tenses.values();
}
-QString KEduVocKvtmlCompability::oldTense(const QString & tense)
+QString QmVocKvtmlCompability::oldTense(const QString & tense)
{
///@todo writing of the user defined tenses is probably messed up
if ( !m_oldTenses.values().contains(tense) ) {
return m_oldTenses.key(tense);
}
-void KEduVocKvtmlCompability::setupWordTypes(KEduVocWordType * parent)
+void QmVocKvtmlCompability::setupWordTypes(QmVocWordType * parent)
{
QStringList wordTypeNames;
wordTypeNames
<< "Question" ;
foreach (const QString &typeName, wordTypeNames) {
- KEduVocWordType* wordType = new KEduVocWordType(typeName, parent);
+ QmVocWordType* wordType = new QmVocWordType(typeName, parent);
parent->appendChildContainer(wordType);
m_userdefinedTypeCounter++;
}
- static_cast<KEduVocWordType*>(parent->childContainer(4))->setWordType(KEduVocWordFlag::Adjective);
- static_cast<KEduVocWordType*>(parent->childContainer(5))->setWordType(KEduVocWordFlag::Adverb);
+ static_cast<QmVocWordType*>(parent->childContainer(4))->setWordType(QmVocWordFlag::Adjective);
+ static_cast<QmVocWordType*>(parent->childContainer(5))->setWordType(QmVocWordFlag::Adverb);
- KEduVocWordType* numeral = static_cast<KEduVocWordType*>(parent->childContainer(8));
- KEduVocWordType* wordType = new KEduVocWordType( "Ordinal", numeral);
- wordType->setWordType(KEduVocWordFlag::Adjective);
+ QmVocWordType* numeral = static_cast<QmVocWordType*>(parent->childContainer(8));
+ QmVocWordType* wordType = new QmVocWordType( "Ordinal", numeral);
+ wordType->setWordType(QmVocWordFlag::Adjective);
numeral->appendChildContainer(wordType);
- wordType = new KEduVocWordType( "Cardinal" , numeral);
+ wordType = new QmVocWordType( "Cardinal" , numeral);
- wordType->setWordType(KEduVocWordFlag::Adjective);
+ wordType->setWordType(QmVocWordFlag::Adjective);
numeral->appendChildContainer(wordType);
- KEduVocWordType* article = static_cast<KEduVocWordType*>(parent->childContainer(3));
- wordType = new KEduVocWordType( "Definite" , article);
- wordType->setWordType(KEduVocWordFlag::Article | KEduVocWordFlag::Definite);
+ QmVocWordType* article = static_cast<QmVocWordType*>(parent->childContainer(3));
+ wordType = new QmVocWordType( "Definite" , article);
+ wordType->setWordType(QmVocWordFlag::Article | QmVocWordFlag::Definite);
article->appendChildContainer(wordType);
- wordType = new KEduVocWordType( "Indefinite" , article);
- wordType->setWordType(KEduVocWordFlag::Article | KEduVocWordFlag::Indefinite);
+ wordType = new QmVocWordType( "Indefinite" , article);
+ wordType->setWordType(QmVocWordFlag::Article | QmVocWordFlag::Indefinite);
article->appendChildContainer(wordType);
- KEduVocWordType* verb = static_cast<KEduVocWordType*>(parent->childContainer(0));
- verb->setWordType(KEduVocWordFlag::Verb);
- wordType = new KEduVocWordType( "Regular" , verb);
- wordType->setWordType(KEduVocWordFlag::Verb | KEduVocWordFlag::Regular);
+ QmVocWordType* verb = static_cast<QmVocWordType*>(parent->childContainer(0));
+ verb->setWordType(QmVocWordFlag::Verb);
+ wordType = new QmVocWordType( "Regular" , verb);
+ wordType->setWordType(QmVocWordFlag::Verb | QmVocWordFlag::Regular);
verb->appendChildContainer(wordType);
- wordType = new KEduVocWordType( "Irregular" , verb);
+ wordType = new QmVocWordType( "Irregular" , verb);
verb->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordFlag::Verb | KEduVocWordFlag::Irregular);
+ wordType->setWordType(QmVocWordFlag::Verb | QmVocWordFlag::Irregular);
- KEduVocWordType* noun = static_cast<KEduVocWordType*>(parent->childContainer(1));
- noun->setWordType(KEduVocWordFlag::Noun);
- wordType = new KEduVocWordType( "Male" , noun);
+ QmVocWordType* noun = static_cast<QmVocWordType*>(parent->childContainer(1));
+ noun->setWordType(QmVocWordFlag::Noun);
+ wordType = new QmVocWordType( "Male" , noun);
noun->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Masculine);
- wordType = new KEduVocWordType( "Female" , noun);
+ wordType->setWordType(QmVocWordFlag::Noun | QmVocWordFlag::Masculine);
+ wordType = new QmVocWordType( "Female" , noun);
noun->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Feminine);
- wordType = new KEduVocWordType( "Neutral" , noun);
+ wordType->setWordType(QmVocWordFlag::Noun | QmVocWordFlag::Feminine);
+ wordType = new QmVocWordType( "Neutral" , noun);
noun->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Neuter);
+ wordType->setWordType(QmVocWordFlag::Noun | QmVocWordFlag::Neuter);
- KEduVocWordType* pronoun = static_cast<KEduVocWordType*>(parent->childContainer(6));
- wordType = new KEduVocWordType( "Possessive" , pronoun);
- wordType->setWordType(KEduVocWordFlag::Pronoun);
+ QmVocWordType* pronoun = static_cast<QmVocWordType*>(parent->childContainer(6));
+ wordType = new QmVocWordType( "Possessive" , pronoun);
+ wordType->setWordType(QmVocWordFlag::Pronoun);
pronoun->appendChildContainer(wordType);
- wordType = new KEduVocWordType( "Personal" , pronoun);
- wordType->setWordType(KEduVocWordFlag::Pronoun);
+ wordType = new QmVocWordType( "Personal" , pronoun);
+ wordType->setWordType(QmVocWordFlag::Pronoun);
pronoun->appendChildContainer(wordType);
}
/***************************************************************************
- C++ Interface: keduvockvtml1compability_p
+ C++ Interface: qmvockvtml1compability_p
-----------------------------------------------------------------------
begin : Di Aug 28 2007
copyright : (C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
-----------------------------------------------------------------------
* *
***************************************************************************/
-#ifndef KEDUVOCKVTMLCOMPABILITY_H
-#define KEDUVOCKVTMLCOMPABILITY_H
+#ifndef QMVOCKVTMLCOMPABILITY_H
+#define QMVOCKVTMLCOMPABILITY_H
#include <QtCore/QString>
#include <QtCore/QMap>
#define UL_USER_USAGE "#" // designates number of user type
-class KEduVocWordType;
+class QmVocWordType;
/**
* @file contains defines and constants necessary for reading kvtml files prior to KDE4. kvtml version 1.
*/
-class KEduVocKvtmlCompability
+class QmVocKvtmlCompability
{
public:
/**
* Constructor, initialize the map.
*/
- KEduVocKvtmlCompability();
+ QmVocKvtmlCompability();
///// TYPES
/**
* @param typeSubtypeString the old string containing everything
* @return type
*/
- KEduVocWordType* typeFromOldFormat(KEduVocWordType* parent, const QString & typeSubtypeString ) const;
+ QmVocWordType* typeFromOldFormat(QmVocWordType* parent, const QString & typeSubtypeString ) const;
/**
* To write old docs: convert a nice new type to the ugly old style.
QStringList documentTenses() const;
QString oldTense( const QString& tense );
- void setupWordTypes(KEduVocWordType* parent);
+ void setupWordTypes(QmVocWordType* parent);
private:
static const QString KVTML_1_SEPERATOR;
};
-#endif // KEDUVOCKVTMLCOMPABILITY_H
+#endif // QMVOCKVTMLCOMPABILITY_H
***************************************************************************/
/***************************************************************************
- read a KEduVocDocument from a KVTML file
+ read a QmVocDocument from a KVTML file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
* *
***************************************************************************/
-#include "keduvockvtmlreader.h"
+#include "qmvockvtmlreader.h"
#include <QtCore/QTextStream>
#include <QtCore/QList>
// #include <klocale.h>
// #include <kglobal.h>
-#include "keduvocdocument.h"
-#include "keduvoclesson.h"
-#include "keduvocwordtype.h"
+#include "qmvocdocument.h"
+#include "qmvoclesson.h"
+#include "qmvocwordtype.h"
#include "kvtmldefs.h"
-#include "keduvoccommon_p.h"
+#include "qmvoccommon_p.h"
-KEduVocKvtmlReader::KEduVocKvtmlReader( QIODevice *file )
+QmVocKvtmlReader::QmVocKvtmlReader( QIODevice *file )
{
// the file must be already open
m_inputFile = file;
m_errorMessage = "";
- qDebug() << "KEduVocKvtmlReader for kvtml version 1 files started.";
+ qDebug() << "QmVocKvtmlReader for kvtml version 1 files started.";
}
-bool KEduVocKvtmlReader::readDoc( KEduVocDocument *doc )
+bool QmVocKvtmlReader::readDoc( QmVocDocument *doc )
{
m_doc = doc;
m_cols = 0;
m_lines = 0;
- QDomDocument domDoc( "KEduVocDocument" );
+ QDomDocument domDoc( "QmVocDocument" );
if ( !domDoc.setContent( m_inputFile, &m_errorMessage ) )
return false;
}
-bool KEduVocKvtmlReader::readBody( QDomElement &domElementParent )
+bool QmVocKvtmlReader::readBody( QDomElement &domElementParent )
{
bool result = false;
return false;
}
- KEduVocPersonalPronoun pronouns;
+ QmVocPersonalPronoun pronouns;
if (! readPersonalPronouns( domElementConjugChild, pronouns ) ) {
return false;
}
}
-bool KEduVocKvtmlReader::readLesson( QDomElement &domElementParent )
+bool QmVocKvtmlReader::readLesson( QDomElement &domElementParent )
{
QString s;
QDomAttr attribute;
}
s = currentElement.text();
- KEduVocLesson* lesson = new KEduVocLesson(s, m_doc->lesson());
+ QmVocLesson* lesson = new QmVocLesson(s, m_doc->lesson());
lesson->setInPractice(inQuery);
m_doc->lesson()->appendChildContainer( lesson );
if ( m_doc->lesson()->childContainerCount() != no-1 ) {
}
-bool KEduVocKvtmlReader::readArticle( QDomElement &domElementParent )
+bool QmVocKvtmlReader::readArticle( QDomElement &domElementParent )
/*
<article>
<e l="de"> lang determines also lang order in entries !!
for ( int i = 0; i < entryList.count(); ++i ) {
-//kDebug() << "KEduVocKvtmlReader::readArticle() read " << entryList.count() << " articles. ";
+//kDebug() << "QmVocKvtmlReader::readArticle() read " << entryList.count() << " articles. ";
currentElement = entryList.item( i ).toElement();
if ( currentElement.parentNode() == domElementParent ) {
QString lang;
nat_indef = "";
}
- m_doc->identifier(i).setArticle( KEduVocArticle( fem_def, fem_indef, mal_def, mal_indef, nat_def, nat_indef ) );
+ m_doc->identifier(i).setArticle( QmVocArticle( fem_def, fem_indef, mal_def, mal_indef, nat_def, nat_indef ) );
}
}
}
-bool KEduVocKvtmlReader::readTranslationConjugations( QDomElement &domElementParent, KEduVocTranslation* translation )
+bool QmVocKvtmlReader::readTranslationConjugations( QDomElement &domElementParent, QmVocTranslation* translation )
{
QString tense;
QString oldShortTense = domAttrLang.value();
tense = m_compability.tenseFromKvtml1( oldShortTense );
- KEduVocConjugation conjugation;
+ QmVocConjugation conjugation;
readConjugation(domElementConjugChild, conjugation);
translation->setConjugation(tense, conjugation);
return true;
}
-bool KEduVocKvtmlReader::readConjugation( QDomElement &domElementParent, KEduVocConjugation& conjugation )
+bool QmVocKvtmlReader::readConjugation( QDomElement &domElementParent, QmVocConjugation& conjugation )
/*
<conjugation> used in header for definiton of "prefix"
<e l="de"> lang determines also lang order in entries !!
// type - the tense?
// finally the person
- const KEduVocWordFlags numS = KEduVocWordFlag::Singular;
- const KEduVocWordFlags numP = KEduVocWordFlag::Plural;
+ const QmVocWordFlags numS = QmVocWordFlag::Singular;
+ const QmVocWordFlags numP = QmVocWordFlag::Plural;
- conjugation.setConjugation( pers1_sing, KEduVocWordFlag::First | numS);
- conjugation.setConjugation( pers2_sing, KEduVocWordFlag::Second | numS);
- conjugation.setConjugation( pers1_plur, KEduVocWordFlag::First | numP);
- conjugation.setConjugation( pers2_plur, KEduVocWordFlag::Second | numP);
+ conjugation.setConjugation( pers1_sing, QmVocWordFlag::First | numS);
+ conjugation.setConjugation( pers2_sing, QmVocWordFlag::Second | numS);
+ conjugation.setConjugation( pers1_plur, QmVocWordFlag::First | numP);
+ conjugation.setConjugation( pers2_plur, QmVocWordFlag::Second | numP);
if ( s3_common ) {
- conjugation.setConjugation( pers3_f_sing, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Singular );
+ conjugation.setConjugation( pers3_f_sing, QmVocWordFlag::Third | QmVocWordFlag::Neuter | QmVocWordFlag::Singular );
} else {
conjugation.setConjugation( pers3_m_sing,
- KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | KEduVocWordFlag::Singular );
+ QmVocWordFlag::Third | QmVocWordFlag::Masculine | QmVocWordFlag::Singular );
conjugation.setConjugation( pers3_f_sing,
- KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | KEduVocWordFlag::Singular );
+ QmVocWordFlag::Third | QmVocWordFlag::Feminine | QmVocWordFlag::Singular );
conjugation.setConjugation( pers3_n_sing,
- KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Singular );
+ QmVocWordFlag::Third | QmVocWordFlag::Neuter | QmVocWordFlag::Singular );
}
if ( p3_common ) {
- conjugation.setConjugation( pers3_f_plur, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Plural );
+ conjugation.setConjugation( pers3_f_plur, QmVocWordFlag::Third | QmVocWordFlag::Neuter | QmVocWordFlag::Plural );
} else {
conjugation.setConjugation( pers3_m_plur,
- KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | KEduVocWordFlag::Plural );
+ QmVocWordFlag::Third | QmVocWordFlag::Masculine | QmVocWordFlag::Plural );
conjugation.setConjugation( pers3_f_plur,
- KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | KEduVocWordFlag::Plural );
+ QmVocWordFlag::Third | QmVocWordFlag::Feminine | QmVocWordFlag::Plural );
conjugation.setConjugation( pers3_n_plur,
- KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Plural );
+ QmVocWordFlag::Third | QmVocWordFlag::Neuter | QmVocWordFlag::Plural );
}
return true;
-bool KEduVocKvtmlReader::readPersonalPronouns( QDomElement &domElementParent, KEduVocPersonalPronoun& pronouns )
+bool QmVocKvtmlReader::readPersonalPronouns( QDomElement &domElementParent, QmVocPersonalPronoun& pronouns )
{
// QString s;
bool p3_common;
// type - the tense?
// finally the person
- KEduVocWordFlags numS = KEduVocWordFlag::Singular;
+ QmVocWordFlags numS = QmVocWordFlag::Singular;
pronouns.setMaleFemaleDifferent(false);
- pronouns.setPersonalPronoun( pers1_sing, KEduVocWordFlag::First | numS );
- pronouns.setPersonalPronoun( pers2_sing, KEduVocWordFlag::Second | numS );
+ pronouns.setPersonalPronoun( pers1_sing, QmVocWordFlag::First | numS );
+ pronouns.setPersonalPronoun( pers2_sing, QmVocWordFlag::Second | numS );
// used to have common in female
if ( s3_common ) {
- pronouns.setPersonalPronoun( pers3_f_sing, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numS );
+ pronouns.setPersonalPronoun( pers3_f_sing, QmVocWordFlag::Third | QmVocWordFlag::Neuter | numS );
} else {
pronouns.setPersonalPronoun( pers3_m_sing,
- KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | numS );
+ QmVocWordFlag::Third | QmVocWordFlag::Masculine | numS );
pronouns.setPersonalPronoun( pers3_f_sing,
- KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | numS );
+ QmVocWordFlag::Third | QmVocWordFlag::Feminine | numS );
pronouns.setPersonalPronoun( pers3_n_sing,
- KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numS );
+ QmVocWordFlag::Third | QmVocWordFlag::Neuter | numS );
pronouns.setMaleFemaleDifferent(true);
}
- KEduVocWordFlags numP = KEduVocWordFlag::Plural;
+ QmVocWordFlags numP = QmVocWordFlag::Plural;
- pronouns.setPersonalPronoun( pers1_plur, KEduVocWordFlag::First | numP );
- pronouns.setPersonalPronoun( pers2_plur, KEduVocWordFlag::Second | numP );
+ pronouns.setPersonalPronoun( pers1_plur, QmVocWordFlag::First | numP );
+ pronouns.setPersonalPronoun( pers2_plur, QmVocWordFlag::Second | numP );
if ( p3_common ) {
- pronouns.setPersonalPronoun( pers3_f_plur, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numP );
+ pronouns.setPersonalPronoun( pers3_f_plur, QmVocWordFlag::Third | QmVocWordFlag::Neuter | numP );
} else {
pronouns.setPersonalPronoun( pers3_m_plur,
- KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | numP );
+ QmVocWordFlag::Third | QmVocWordFlag::Masculine | numP );
pronouns.setPersonalPronoun( pers3_f_plur,
- KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | numP );
+ QmVocWordFlag::Third | QmVocWordFlag::Feminine | numP );
pronouns.setPersonalPronoun( pers3_n_plur,
- KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numP );
+ QmVocWordFlag::Third | QmVocWordFlag::Neuter | numP );
pronouns.setMaleFemaleDifferent(true);
}
}
-bool KEduVocKvtmlReader::readType( QDomElement &domElementParent )
+bool QmVocKvtmlReader::readType( QDomElement &domElementParent )
{
QString s;
QDomElement currentElement;
qDebug() << "Adding old self defined type: " << currentElement.text();
// add the type to the list of available types
- KEduVocWordType* type = new KEduVocWordType(currentElement.text(), m_doc->wordTypeContainer());
+ QmVocWordType* type = new QmVocWordType(currentElement.text(), m_doc->wordTypeContainer());
m_doc->wordTypeContainer()->appendChildContainer( type );
// from this the #1 are transformed to something sensible again
}
-bool KEduVocKvtmlReader::readTense( QDomElement &domElementParent )
+bool QmVocKvtmlReader::readTense( QDomElement &domElementParent )
{
QDomElement currentElement;
}
-bool KEduVocKvtmlReader::readComparison( QDomElement &domElementParent, KEduVocTranslation * translation )
+bool QmVocKvtmlReader::readComparison( QDomElement &domElementParent, QmVocTranslation * translation )
/*
<comparison>
<l1>good</l1> --- this one is dead as it always has to be the word itself
}
-bool KEduVocKvtmlReader::readMultipleChoice( QDomElement &domElementParent, KEduVocTranslation* translation )
+bool QmVocKvtmlReader::readMultipleChoice( QDomElement &domElementParent, QmVocTranslation* translation )
/*
<multiplechoice>
<mc1>good</mc1>
}
-bool KEduVocKvtmlReader::readExpressionChildAttributes( QDomElement &domElementExpressionChild,
+bool QmVocKvtmlReader::readExpressionChildAttributes( QDomElement &domElementExpressionChild,
QString &lang,
grade_t &grade, grade_t &rev_grade,
int &count, int &rev_count,
}
-bool KEduVocKvtmlReader::readExpression( QDomElement &domElementParent )
+bool QmVocKvtmlReader::readExpression( QDomElement &domElementParent )
{
grade_t grade;
grade_t r_grade;
// so make sure this lesson is in the document
qDebug() << "Warning: lesson > m_doc->lessonCount() in readExpression.";
- KEduVocLesson* lesson = new KEduVocLesson( QString("Lesson %1").arg(lessonNumber) , m_doc->lesson());
+ QmVocLesson* lesson = new QmVocLesson( QString("Lesson %1").arg(lessonNumber) , m_doc->lesson());
m_doc->lesson()->appendChildContainer(lesson);
}
}
return false;
}
- KEduVocExpression* entry = 0;
+ QmVocExpression* entry = 0;
while ( !currentElement.isNull() ) {
textstr = currentElement.lastChild().toText().data();
if ( i == 0 ) {
- entry = new KEduVocExpression( textstr );
+ entry = new QmVocExpression( textstr );
entry->setActive( active );
if ( lessonNumber != -1 ) {
- static_cast<KEduVocLesson*>(m_doc->lesson()->childContainer(lessonNumber))->appendEntry(entry);
+ static_cast<QmVocLesson*>(m_doc->lesson()->childContainer(lessonNumber))->appendEntry(entry);
} else {
m_doc->lesson()->appendEntry(entry);
}
entry->setTranslation( i, textstr );
}
- if ( m_doc->lesson()->entries(KEduVocLesson::Recursive).count() == 1 ) { // this is because in kvtml the languages are saved in the FIRST ENTRY ONLY.
+ if ( m_doc->lesson()->entries(QmVocLesson::Recursive).count() == 1 ) { // this is because in kvtml the languages are saved in the FIRST ENTRY ONLY.
// new translation
if (!addLanguage(i, lang)) {
return false;
}
if ( !type.isEmpty() ) {
- KEduVocWordType* wordType = m_compability.typeFromOldFormat(m_doc->wordTypeContainer(), type);
+ QmVocWordType* wordType = m_compability.typeFromOldFormat(m_doc->wordTypeContainer(), type);
entry->translation(i)->setWordType(wordType);
}
}
-bool KEduVocKvtmlReader::addLanguage( int languageId, const QString& locale)
+bool QmVocKvtmlReader::addLanguage( int languageId, const QString& locale)
{
if ( m_doc->identifierCount() <= languageId ) {
m_doc->appendIdentifier();
}
-// #include "keduvockvtmlreader.moc"
***************************************************************************/
/***************************************************************************
- read a KEduVocDocument from a KVTML file
+ read a QmVocDocument from a KVTML file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
(C) 2005 Eric Pignet <eric at erixpage.com>
(C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
(C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCKVTMLREADER_H
-#define KEDUVOCKVTMLREADER_H
+#ifndef QMVOCKVTMLREADER_H
+#define QMVOCKVTMLREADER_H
#include <QtXml/QDomDocument>
#include <QtCore/QList>
-#include "keduvocexpression.h"
-#include "keduvocarticle.h"
-#include "keduvocmultiplechoice.h"
-#include "keduvockvtmlcompability.h"
-#include "keduvocpersonalpronoun.h"
+#include "qmvocexpression.h"
+#include "qmvocarticle.h"
+#include "qmvocmultiplechoice.h"
+#include "qmvockvtmlcompability.h"
+#include "qmvocpersonalpronoun.h"
class QIODevice;
-class KEduVocDocument;
+class QmVocDocument;
/**
@author Eric Pignet
*/
-class KEduVocKvtmlReader : public QObject
+class QmVocKvtmlReader : public QObject
{
Q_OBJECT
public:
- KEduVocKvtmlReader( QIODevice *file );
+ QmVocKvtmlReader( QIODevice *file );
- bool readDoc( KEduVocDocument *doc );
+ bool readDoc( QmVocDocument *doc );
/**
* Attempt to add a language/locale. Language/locale are set to the same value.
bool readLesson( QDomElement &domElementParent );
bool readArticle( QDomElement &domElementParent );
- bool readPersonalPronouns( QDomElement &domElementParent, KEduVocPersonalPronoun& pronouns );
- bool readConjugation( QDomElement &domElementParent, KEduVocConjugation &conjugation );
- bool readTranslationConjugations( QDomElement &domElementParent, KEduVocTranslation* translation );
+ bool readPersonalPronouns( QDomElement &domElementParent, QmVocPersonalPronoun& pronouns );
+ bool readConjugation( QDomElement &domElementParent, QmVocConjugation &conjugation );
+ bool readTranslationConjugations( QDomElement &domElementParent, QmVocTranslation* translation );
bool readType( QDomElement &domElementParent );
bool readTense( QDomElement &domElementParent );
bool readUsage( QDomElement &domElementParent );
- bool readComparison( QDomElement &domElementParent, KEduVocTranslation* translation );
- bool readMultipleChoice( QDomElement &domElementParent, KEduVocTranslation* translation );
+ bool readComparison( QDomElement &domElementParent, QmVocTranslation* translation );
+ bool readMultipleChoice( QDomElement &domElementParent, QmVocTranslation* translation );
bool readExpressionChildAttributes( QDomElement &domElementExpressionChild,
QString &lang,
grade_t &grade, grade_t &rev_grade,
private:
QIODevice *m_inputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
QString m_errorMessage;
int m_cols;
int m_lines;
QStringList m_oldSelfDefinedTypes;
- KEduVocKvtmlCompability m_compability;
+ QmVocKvtmlCompability m_compability;
};
#endif
***************************************************************************/
/***************************************************************************
- export a KEduVocDocument to a KVTML file
+ export a QmVocDocument to a KVTML file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
* *
***************************************************************************/
-#include "keduvockvtmlwriter.h"
+#include "qmvockvtmlwriter.h"
#include <QtCore/QLatin1String>
#include <QtCore/QTextStream>
// #include <KDebug>
#include <QDebug>
-#include "keduvocdocument.h"
-// #include "keduvocgrade.h"
-#include "keduvoclesson.h"
-#include "keduvocexpression.h"
+#include "qmvocdocument.h"
+// #include "qmvocgrade.h"
+#include "qmvoclesson.h"
+#include "qmvocexpression.h"
#include "kvtmldefs.h"
-#include "keduvoccommon_p.h"
+#include "qmtvoccommon_p.h"
-KEduVocKvtmlWriter::KEduVocKvtmlWriter( QFile *file )
+QmVocKvtmlWriter::QmVocKvtmlWriter( QFile *file )
{
// the file must be already open
m_outputFile = file;
}
-bool KEduVocKvtmlWriter::writeDoc( KEduVocDocument *doc, const QString &generator )
+bool QmVocKvtmlWriter::writeDoc( QmVocDocument *doc, const QString &generator )
{
bool first_expr = true;
if ( !writeArticle( domElementKvtml ) )
return false;
- QList<KEduVocPersonalPronoun> pronouns;
+ QList<QmVocPersonalPronoun> pronouns;
for ( int i = 0; i < m_doc->identifierCount(); i++ )
pronouns.append( m_doc->identifier(i).personalPronouns() );
if ( pronouns.count() > 0 ) {
int entryCount = m_doc->entryCount();
for ( int i = 0; i < entryCount; i++ ) {
- KEduVocExpression *entry = m_doc->entry( i );
+ QmVocExpression *entry = m_doc->entry( i );
QDomElement domElementExpression = m_domDoc.createElement( KV_EXPR );
if ( entry->lesson() != 0 ) {
} else if ( entype == QM_ADJ && !entry->translation( 0 ).comparison().isEmpty() ) {
- KEduVocComparison comp = entry->translation( 0 ).comparison();
+ QmVocComparison comp = entry->translation( 0 ).comparison();
if ( !writeComparison(domElementOriginal, comp ) )
return false;
}
}
if ( entype == QM_ADJ && !entry->translation( trans ).comparison().isEmpty() ) {
- KEduVocComparison comp = entry->translation( trans ).comparison();
+ QmVocComparison comp = entry->translation( trans ).comparison();
if ( !writeComparison(domElementTranslation, comp ) )
return false;
}
}
-bool KEduVocKvtmlWriter::writeLesson( QDomElement &domElementParent )
+bool QmVocKvtmlWriter::writeLesson( QDomElement &domElementParent )
{
if ( m_doc->lessonCount() == 0 )
return true;
}
-bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
+bool QmVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
/*
<article>
<e l="de"> lang determines also lang order in entries !!
QString articleString;
// female
- articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Feminine );
+ articleString = m_doc->identifier(i).article().article( QmVocWordFlag::Singular | QmVocWordFlag::Definite | QmVocWordFlag::Feminine );
if ( !articleString.isEmpty() ) {
QDomElement domElementFD = m_domDoc.createElement( KV_ART_FD );
QDomText domTextFD = m_domDoc.createTextNode( articleString );
domElementFD.appendChild( domTextFD );
domElementEntry.appendChild( domElementFD );
}
- articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Feminine );
+ articleString = m_doc->identifier(i).article().article( QmVocWordFlag::Singular | QmVocWordFlag::Indefinite | QmVocWordFlag::Feminine );
if ( !articleString.isEmpty() ) {
QDomElement domElementFI = m_domDoc.createElement( KV_ART_FI );
QDomText domTextFI = m_domDoc.createTextNode( articleString );
// male
- articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Masculine );
+ articleString = m_doc->identifier(i).article().article( QmVocWordFlag::Singular | QmVocWordFlag::Definite | QmVocWordFlag::Masculine );
if ( !articleString.isEmpty() ) {
QDomElement domElementMD = m_domDoc.createElement( KV_ART_MD );
QDomText domTextMD = m_domDoc.createTextNode( articleString );
domElementMD.appendChild( domTextMD );
domElementEntry.appendChild( domElementMD );
}
- articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Masculine );
+ articleString = m_doc->identifier(i).article().article( QmVocWordFlag::Singular | QmVocWordFlag::Indefinite | QmVocWordFlag::Masculine );
if ( !articleString.isEmpty() ) {
QDomElement domElementMI = m_domDoc.createElement( KV_ART_MI );
QDomText domTextMI = m_domDoc.createTextNode( articleString );
}
// neutral
- articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Neutral );
+ articleString = m_doc->identifier(i).article().article( QmVocWordFlag::Singular | QmVocWordFlag::Definite | QmVocWordFlag::Neutral );
if ( !articleString.isEmpty() ) {
QDomElement domElementND = m_domDoc.createElement( KV_ART_ND );
QDomText domTextND = m_domDoc.createTextNode( articleString );
domElementND.appendChild( domTextND );
domElementEntry.appendChild( domElementND );
}
- articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Neutral );
+ articleString = m_doc->identifier(i).article().article( QmVocWordFlag::Singular | QmVocWordFlag::Indefinite | QmVocWordFlag::Neutral );
if ( !articleString.isEmpty() ) {
QDomElement domElementNI = m_domDoc.createElement( KV_ART_NI );
QDomText domTextNI = m_domDoc.createTextNode( articleString );
}
-bool KEduVocKvtmlWriter::writeType( QDomElement &domElementParent )
+bool QmVocKvtmlWriter::writeType( QDomElement &domElementParent )
{
/** @todo port to new type handling */
/*
}
/*
-bool KEduVocKvtmlWriter::writeTense( QDomElement &domElementParent )
+bool QmVocKvtmlWriter::writeTense( QDomElement &domElementParent )
{
if ( m_doc->tenseDescriptions().count() == 0 )
return true;
}
*/
-bool KEduVocKvtmlWriter::writeUsage( QDomElement &domElementParent )
+bool QmVocKvtmlWriter::writeUsage( QDomElement &domElementParent )
{
///@todo usages
}
-bool KEduVocKvtmlWriter::writeComparison( QDomElement &domElementParent, const KEduVocTranslation* translation )
+bool QmVocKvtmlWriter::writeComparison( QDomElement &domElementParent, const QmVocTranslation* translation )
/*
<comparison>
<l1>good</l1>
}
-bool KEduVocKvtmlWriter::writeMultipleChoice( QDomElement &domElementParent, const KEduVocMultipleChoice &mc )
+bool QmVocKvtmlWriter::writeMultipleChoice( QDomElement &domElementParent, const QmVocMultipleChoice &mc )
/*
<multiplechoice>
<mc1>good</mc1>
}
-bool KEduVocKvtmlWriter::writeConjugHeader( QDomElement &domElementParent, QList<KEduVocConjugation> &curr_conjug )
+bool QmVocKvtmlWriter::writeConjugHeader( QDomElement &domElementParent, QList<QmVocConjugation> &curr_conjug )
{
/*
<conjugation> used in header for definiton of "prefix"
}
-bool KEduVocKvtmlWriter::writeConjugEntry( QDomElement &domElementParent, KEduVocTranslation &translation )
+bool QmVocKvtmlWriter::writeConjugEntry( QDomElement &domElementParent, QmVocTranslation &translation )
/*
<conjugation> in entry for definition of tenses of (irreg.) verbs
<t n="sipa">
}
-bool KEduVocKvtmlWriter::writeConjug( QDomElement &domElementParent, const KEduVocConjugation &curr_conjug, const QString &type )
+bool QmVocKvtmlWriter::writeConjug( QDomElement &domElementParent, const QmVocConjugation &curr_conjug, const QString &type )
{
///@todo if we are to enable the writer: port this!
/*
return false;
}
-bool KEduVocKvtmlWriter::writePersonalPronouns( QDomElement &domElementParent, QList<KEduVocPersonalPronoun> &curr_conjug )
+bool QmVocKvtmlWriter::writePersonalPronouns( QDomElement &domElementParent, QList<QmVocPersonalPronoun> &curr_conjug )
{
/*
<conjugation> used in header for definiton of "prefix"
}
-bool KEduVocKvtmlWriter::writePersonalPronounChild( QDomElement &domElementParent, const KEduVocPersonalPronoun &curr_conjug )
+bool QmVocKvtmlWriter::writePersonalPronounChild( QDomElement &domElementParent, const QmVocPersonalPronoun &curr_conjug )
{
// the old stuff only has singular
- const KEduVocWordFlag::ConjugationNumber num = KEduVocWordFlag::Singular;
+ const QmVocWordFlag::ConjugationNumber num = QmVocWordFlag::Singular;
- if ( !curr_conjug.personalPronoun( KEduVocWordFlag::First, num ).isEmpty() ) {
- domElementParent.appendChild( newTextElement( KV_CON_P1S, curr_conjug.personalPronoun( KEduVocWordFlag::First, num ) ) );
+ if ( !curr_conjug.personalPronoun( QmVocWordFlag::First, num ).isEmpty() ) {
+ domElementParent.appendChild( newTextElement( KV_CON_P1S, curr_conjug.personalPronoun( QmVocWordFlag::First, num ) ) );
}
- if ( !curr_conjug.personalPronoun( KEduVocWordFlag::Second, num ).isEmpty() ) {
- domElementParent.appendChild( newTextElement( KV_CON_P2S, curr_conjug.personalPronoun( KEduVocWordFlag::Second, num ) ) );
+ if ( !curr_conjug.personalPronoun( QmVocWordFlag::Second, num ).isEmpty() ) {
+ domElementParent.appendChild( newTextElement( KV_CON_P2S, curr_conjug.personalPronoun( QmVocWordFlag::Second, num ) ) );
}
///@todo if the writer ever becomes enabled, write the other pronouns
return true;
}
-QDomElement KEduVocKvtmlWriter::newTextElement( const QString &elementName, const QString &text )
+QDomElement QmVocKvtmlWriter::newTextElement( const QString &elementName, const QString &text )
{
QDomElement retval = m_domDoc.createElement( elementName );
QDomText textNode = m_domDoc.createTextNode( text );
***************************************************************************/
/***************************************************************************
- export a KEduVocDocument to a KVTML file
+ export a QmVocDocument to a KVTML file
-----------------------------------------------------------------------
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
(C) 2005 Eric Pignet <eric at erixpage.com>
(C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
(C) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCKVTMLWRITER_H
-#define KEDUVOCKVTMLWRITER_H
+#ifndef QMVOCKVTMLWRITER_H
+#define QMVOCKVTMLWRITER_H
#include <QtXml/QDomDocument>
#include <QtCore/QList>
#include <QtCore/QFile>
-#include "keduvocarticle.h"
-#include "keduvocpersonalpronoun.h"
-#include "keduvocconjugation.h"
-#include "keduvocmultiplechoice.h"
-#include "keduvockvtmlcompability.h"
-#include "keduvoctranslation.h"
+#include "qmvocarticle.h"
+#include "qmvocpersonalpronoun.h"
+#include "qmvocconjugation.h"
+#include "qmvocmultiplechoice.h"
+#include "qmvockvtmlcompability.h"
+#include "qmvoctranslation.h"
-class KEduVocDocument;
+class QmVocDocument;
/**
@author Eric Pignet
*/
-class KEduVocKvtmlWriter
+class QmVocKvtmlWriter
{
public:
- KEduVocKvtmlWriter( QFile *file );
+ QmVocKvtmlWriter( QFile *file );
- bool writeDoc( KEduVocDocument *doc, const QString &generator );
+ bool writeDoc( QmVocDocument *doc, const QString &generator );
private:
bool writeLesson( QDomElement &domElementParent );
bool writeOption( QDomElement &domElementParent );
bool writeArticle( QDomElement &domElementParent );
- bool writePersonalPronouns( QDomElement &domElementParent, QList<KEduVocPersonalPronoun> &curr_conjug );
- bool writePersonalPronounChild( QDomElement &domElementParent, const KEduVocPersonalPronoun &curr_conjug );
+ bool writePersonalPronouns( QDomElement &domElementParent, QList<QmVocPersonalPronoun> &curr_conjug );
+ bool writePersonalPronounChild( QDomElement &domElementParent, const QmVocPersonalPronoun &curr_conjug );
- bool writeConjugHeader( QDomElement &domElementParent, QList<KEduVocConjugation> &curr_conjug );
- bool writeConjug( QDomElement &domElementParent, const KEduVocConjugation &curr_conjug, const QString &type );
- bool writeConjugEntry( QDomElement &domElementParent, KEduVocTranslation &translation );
- bool writeComparison( QDomElement &domElementParent, KEduVocTranslation* translation );
- bool writeMultipleChoice( QDomElement &domElementParent, const KEduVocMultipleChoice &mc );
+ bool writeConjugHeader( QDomElement &domElementParent, QList<QmVocConjugation> &curr_conjug );
+ bool writeConjug( QDomElement &domElementParent, const QmVocConjugation &curr_conjug, const QString &type );
+ bool writeConjugEntry( QDomElement &domElementParent, QmVocTranslation &translation );
+ bool writeComparison( QDomElement &domElementParent, QmVocTranslation* translation );
+ bool writeMultipleChoice( QDomElement &domElementParent, const QmVocMultipleChoice &mc );
QDomElement newTextElement( const QString &elementName, const QString &text );
QFile *m_outputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
QDomDocument m_domDoc;
- KEduVocKvtmlCompability m_compability;
+ QmVocKvtmlCompability m_compability;
};
#endif
/***************************************************************************
Copyright 2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#include "keduvocleitnerbox.h"
+#include "qmvocleitnerbox.h"
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
#include <QtCore/QSet>
-class KEduVocLeitnerBox::Private
+class QmVocLeitnerBox::Private
{
public:
// cache the entries
- QList<KEduVocExpression*> m_expressions;
+ QList<QmVocExpression*> m_expressions;
// list of translations
- QList<KEduVocTranslation*> m_translations;
+ QList<QmVocTranslation*> m_translations;
};
-KEduVocLeitnerBox::KEduVocLeitnerBox(const QString& name, KEduVocLeitnerBox *parent)
- : KEduVocContainer(name, Leitner, parent), d( new Private )
+QmVocLeitnerBox::QmVocLeitnerBox(const QString& name, QmVocLeitnerBox *parent)
+ : QmVocContainer(name, Leitner, parent), d( new Private )
{
// only one top level and children, this is only a list
Q_ASSERT(!parent || !parent->parent());
}
-KEduVocLeitnerBox::~KEduVocLeitnerBox()
+QmVocLeitnerBox::~QmVocLeitnerBox()
{
- foreach(KEduVocTranslation* translation, d->m_translations) {
+ foreach(QmVocTranslation* translation, d->m_translations) {
translation->setLeitnerBox(0);
}
delete d;
}
-QList<KEduVocExpression*> KEduVocLeitnerBox::entries(EnumEntriesRecursive recursive)
+QList<QmVocExpression*> QmVocLeitnerBox::entries(EnumEntriesRecursive recursive)
{
Q_UNUSED(recursive)
return d->m_expressions;
}
-int KEduVocLeitnerBox::entryCount(EnumEntriesRecursive recursive)
+int QmVocLeitnerBox::entryCount(EnumEntriesRecursive recursive)
{
Q_UNUSED(recursive)
return d->m_expressions.count();
}
-void KEduVocLeitnerBox::addTranslation(KEduVocTranslation* translation)
+void QmVocLeitnerBox::addTranslation(QmVocTranslation* translation)
{
// add to expression - if not already there because another translation of the same word is there.
bool found = false;
invalidateChildLessonEntries();
}
-void KEduVocLeitnerBox::removeTranslation(KEduVocTranslation* translation)
+void QmVocLeitnerBox::removeTranslation(QmVocTranslation* translation)
{
int index = d->m_translations.indexOf(translation);
d->m_translations.removeAt(index);
invalidateChildLessonEntries();
}
-KEduVocTranslation * KEduVocLeitnerBox::translation(int row)
+QmVocTranslation * QmVocLeitnerBox::translation(int row)
{
return d->m_translations.value(row);
}
-KEduVocExpression * KEduVocLeitnerBox::entry(int row, EnumEntriesRecursive recursive)
+QmVocExpression * QmVocLeitnerBox::entry(int row, EnumEntriesRecursive recursive)
{
Q_UNUSED(recursive)
return entries().value(row);
/***************************************************************************
Copyright 2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCLEITNERBOX_H
-#define KEDUVOCLEITNERBOX_H
+#ifndef QMVOCLEITNERBOX_H
+#define QMVOCLEITNERBOX_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvoccontainer.h"
+#include "qmvoccontainer.h"
#include <QtCore/QList>
#include <QtCore/QString>
-class KEduVocExpression;
-class KEduVocTranslation;
+class QmVocExpression;
+class QmVocTranslation;
/**
* Leitner Boxes are an alternative grading system.
* Classically flash cards are kept in boxes and moved corresponding to the users knowledge level.
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocLeitnerBox :public KEduVocContainer
+class QMVOCDOCUMENT_EXPORT QmVocLeitnerBox :public QmVocContainer
{
public:
/** default constructor */
- explicit KEduVocLeitnerBox(const QString& name, KEduVocLeitnerBox *parent = 0);
+ explicit QmVocLeitnerBox(const QString& name, QmVocLeitnerBox *parent = 0);
/** destructor */
- ~KEduVocLeitnerBox();
+ ~QmVocLeitnerBox();
/**
* The leitner box class keeps track of individual translations, because for one entry, the translations can have different grades.
* @param row
* @return
*/
- KEduVocTranslation * translation(int row);
+ QmVocTranslation * translation(int row);
/**
* get a list of all entries in the box
* @return
*/
- QList < KEduVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
+ QList < QmVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
- KEduVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive);
+ QmVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive);
/** get the number of entries in the lesson */
int entryCount(EnumEntriesRecursive recursive = NotRecursive);
/** add an entry to the lesson
* @param entryid id of the entry to add
*/
- void addTranslation(KEduVocTranslation* translation);
+ void addTranslation(QmVocTranslation* translation);
/** remove an entry from the lesson
* @param entryid id of the entry to remove
*/
- void removeTranslation(KEduVocTranslation* translation);
+ void removeTranslation(QmVocTranslation* translation);
- friend class KEduVocTranslation;
+ friend class QmVocTranslation;
};
#endif
Copyright 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#include "keduvoclesson.h"
+#include "qmvoclesson.h"
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
#include <QtCore/QList>
/** private class to store information about a lesson */
-class KEduVocLesson::Private
+class QmVocLesson::Private
{
public:
// entries
- QList<KEduVocExpression*> m_entries;
+ QList<QmVocExpression*> m_entries;
};
-KEduVocLesson::KEduVocLesson(const QString& name, KEduVocContainer *parent)
- : KEduVocContainer(name, Lesson, parent), d( new Private )
+QmVocLesson::QmVocLesson(const QString& name, QmVocContainer *parent)
+ : QmVocContainer(name, Lesson, parent), d( new Private )
{
}
-KEduVocLesson::KEduVocLesson( const KEduVocLesson &other )
- : KEduVocContainer(other), d( new Private )
+QmVocLesson::QmVocLesson( const QmVocLesson &other )
+ : QmVocContainer(other), d( new Private )
{
d->m_entries = other.d->m_entries;
}
-KEduVocLesson::~KEduVocLesson()
+QmVocLesson::~QmVocLesson()
{
qDeleteAll(d->m_entries);
delete d;
}
-QList<KEduVocExpression*> KEduVocLesson::entries(EnumEntriesRecursive recursive)
+QList<QmVocExpression*> QmVocLesson::entries(EnumEntriesRecursive recursive)
{
if (recursive == Recursive) {
return entriesRecursive();
return d->m_entries;
}
-int KEduVocLesson::entryCount(EnumEntriesRecursive recursive)
+int QmVocLesson::entryCount(EnumEntriesRecursive recursive)
{
if (recursive == Recursive) {
return entriesRecursive().count();
return d->m_entries.count();
}
-void KEduVocLesson::appendEntry(KEduVocExpression* entry)
+void QmVocLesson::appendEntry(QmVocExpression* entry)
{
insertEntry(d->m_entries.size(), entry);
}
-void KEduVocLesson::insertEntry(int index, KEduVocExpression * entry)
+void QmVocLesson::insertEntry(int index, QmVocExpression * entry)
{
Q_ASSERT(entry);
d->m_entries.insert( index, entry );
invalidateChildLessonEntries();
}
-void KEduVocLesson::removeEntry(KEduVocExpression* entry)
+void QmVocLesson::removeEntry(QmVocExpression* entry)
{
Q_ASSERT(entry);
if (d->m_entries.indexOf(entry) == -1) {
invalidateChildLessonEntries();
}
-KEduVocExpression * KEduVocLesson::entry(int row, EnumEntriesRecursive recursive)
+QmVocExpression * QmVocLesson::entry(int row, EnumEntriesRecursive recursive)
{
if (recursive == Recursive) {
return entriesRecursive().value(row);
Copyright 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCLESSON_H
-#define KEDUVOCLESSON_H
+#ifndef QMVOCLESSON_H
+#define QMVOCLESSON_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvoccontainer.h"
+#include "qmvoccontainer.h"
-class KEduVocExpression;
+class QmVocExpression;
/** class to store information about a lesson */
-class KEDUVOCDOCUMENT_EXPORT KEduVocLesson :public KEduVocContainer
+class QMVOCDOCUMENT_EXPORT QmVocLesson :public QmVocContainer
{
public:
/** default constructor */
- explicit KEduVocLesson(const QString& name, KEduVocContainer *parent = 0);
+ explicit QmVocLesson(const QString& name, QmVocContainer *parent = 0);
-// void appendChildLesson(KEduVocLesson *child);
+// void appendChildLesson(QmVocLesson *child);
-// QList<KEduVocLesson *> childLessons();
-// KEduVocLesson *childLesson(int row);
+// QList<QmVocLesson *> childLessons();
+// QmVocLesson *childLesson(int row);
// int childLessonCount() const;
// int row() const;
-// KEduVocLesson *parent();
+// QmVocLesson *parent();
/** copy constructor for d-pointer safe copying */
- KEduVocLesson( const KEduVocLesson &other );
+ QmVocLesson( const QmVocLesson &other );
/** destructor */
- ~KEduVocLesson();
+ ~QmVocLesson();
/** assignment operator */
- KEduVocLesson& operator= ( const KEduVocLesson& );
+ QmVocLesson& operator= ( const QmVocLesson& );
- KEduVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive);
+ QmVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive);
/** get a list of all entries in the lesson */
- QList < KEduVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
+ QList < QmVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
/** get the number of entries in the lesson */
int entryCount(EnumEntriesRecursive recursive = NotRecursive);
/** append an entry to the lesson
* @param entryid id of the entry to add
*/
- void appendEntry(KEduVocExpression* entry);
+ void appendEntry(QmVocExpression* entry);
/**
* insert an entry at a specific position
* @param index
* @param entry
*/
- void insertEntry(int index, KEduVocExpression* entry);
+ void insertEntry(int index, QmVocExpression* entry);
/** remove an entry from the lesson
* @param entryid id of the entry to remove
*/
- void removeEntry(KEduVocExpression* entry);
+ void removeEntry(QmVocExpression* entry);
private:
class Private;
copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
(C) 2005 Peter Hedlund <peter.hedlund@kdemail.net>
+
+ (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
-----------------------------------------------------------------------
* *
***************************************************************************/
-#include "keduvocmultiplechoice.h"
+#include "qmvocmultiplechoice.h"
-class KEduVocMultipleChoice::KEduVocMultipleChoicePrivate
+class QmVocMultipleChoice::QmVocMultipleChoicePrivate
{
public:
QStringList m_choices;
};
-KEduVocMultipleChoice::KEduVocMultipleChoice()
- : d( new KEduVocMultipleChoicePrivate )
+QmVocMultipleChoice::QmVocMultipleChoice()
+ : d( new QmVocMultipleChoicePrivate )
{}
-KEduVocMultipleChoice::KEduVocMultipleChoice( const KEduVocMultipleChoice &other )
- : d( new KEduVocMultipleChoicePrivate )
+QmVocMultipleChoice::QmVocMultipleChoice( const QmVocMultipleChoice &other )
+ : d( new QmVocMultipleChoicePrivate )
{
d->m_choices = other.choices();
}
-KEduVocMultipleChoice::KEduVocMultipleChoice( const QStringList &choices )
- : d( new KEduVocMultipleChoicePrivate )
+QmVocMultipleChoice::QmVocMultipleChoice( const QStringList &choices )
+ : d( new QmVocMultipleChoicePrivate )
{
foreach ( const QString &choice, choices ) {
// use appendChoice to check for empty entries
}
}
-KEduVocMultipleChoice::~KEduVocMultipleChoice()
+QmVocMultipleChoice::~QmVocMultipleChoice()
{
delete d;
}
-KEduVocMultipleChoice &KEduVocMultipleChoice::operator= ( const KEduVocMultipleChoice &other )
+QmVocMultipleChoice &QmVocMultipleChoice::operator= ( const QmVocMultipleChoice &other )
{
d->m_choices = other.choices();
return *this;
}
-QStringList KEduVocMultipleChoice::choices() const
+QStringList QmVocMultipleChoice::choices() const
{
return d->m_choices;
}
-bool KEduVocMultipleChoice::isEmpty() const
+bool QmVocMultipleChoice::isEmpty() const
{
return d->m_choices.isEmpty();
}
-void KEduVocMultipleChoice::clear()
+void QmVocMultipleChoice::clear()
{
d->m_choices.clear();
}
-QString KEduVocMultipleChoice::choice( int index ) const
+QString QmVocMultipleChoice::choice( int index ) const
{
QString choice;
if ( d->m_choices.size() > index ) {
return choice;
}
-unsigned KEduVocMultipleChoice::size() const
+unsigned QmVocMultipleChoice::size() const
{
return d->m_choices.size();
}
-bool KEduVocMultipleChoice::operator== ( const KEduVocMultipleChoice &choice ) const
+bool QmVocMultipleChoice::operator== ( const QmVocMultipleChoice &choice ) const
{
return d->m_choices == choice.choices();
}
-void KEduVocMultipleChoice::appendChoice( const QString &s )
+void QmVocMultipleChoice::appendChoice( const QString &s )
{
if ( !s.isEmpty() ) {
d->m_choices.append( s );
(C) 2005 Peter Hedlund <peter.hedlund@kdemail.net>
+ (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
+
-----------------------------------------------------------------------
***************************************************************************/
***************************************************************************/
-#ifndef KEDUVOCMULTIPLECHOICE_H
-#define KEDUVOCMULTIPLECHOICE_H
+#ifndef QMVOCMULTIPLECHOICE_H
+#define QMVOCMULTIPLECHOICE_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
#include <QtCore/QStringList>
-class KEDUVOCDOCUMENT_EXPORT KEduVocMultipleChoice
+class QMVOCDOCUMENT_EXPORT QmVocMultipleChoice
{
public:
- KEduVocMultipleChoice();
- KEduVocMultipleChoice( const KEduVocMultipleChoice &other );
- KEduVocMultipleChoice( const QStringList &choices );
+ QmVocMultipleChoice();
+ QmVocMultipleChoice( const QmVocMultipleChoice &other );
+ QmVocMultipleChoice( const QStringList &choices );
- ~KEduVocMultipleChoice();
+ ~QmVocMultipleChoice();
QStringList choices() const;
void appendChoice( const QString &s );
void clear();
unsigned size() const;
- bool operator== ( const KEduVocMultipleChoice &choice ) const;
+ bool operator== ( const QmVocMultipleChoice &choice ) const;
- KEduVocMultipleChoice &operator= ( const KEduVocMultipleChoice &other );
+ QmVocMultipleChoice &operator= ( const QmVocMultipleChoice &other );
private:
- class KEduVocMultipleChoicePrivate;
- KEduVocMultipleChoicePrivate * const d;
+ class QmVocMultipleChoicePrivate;
+ QmVocMultipleChoicePrivate * const d;
};
***************************************************************************/
/***************************************************************************
- create a KEduVocDocument from a Pauker file
+ create a QmVocDocument from a Pauker file
-----------------------------------------------------------------------
copyright : (C) 2004, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
(C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
* *
***************************************************************************/
-#include "keduvocpaukerreader.h"
+#include "qmvocpaukerreader.h"
#include <QIODevice>
// #include <KLocale>
-#include "keduvocexpression.h"
-#include "keduvoclesson.h"
-#include "keduvocdocument.h"
+#include "qmvocexpression.h"
+#include "qmvoclesson.h"
+#include "qmvocdocument.h"
-KEduVocPaukerReader::KEduVocPaukerReader( KEduVocDocument * doc )
+QmVocPaukerReader::QmVocPaukerReader( QmVocDocument * doc )
{
m_doc = doc;
}
-bool KEduVocPaukerReader::read( QIODevice * device )
+bool QmVocPaukerReader::read( QIODevice * device )
{
setDevice( device );
}
-void KEduVocPaukerReader::readUnknownElement()
+void QmVocPaukerReader::readUnknownElement()
{
while ( !atEnd() ) {
readNext();
}
-void KEduVocPaukerReader::readPauker()
+void QmVocPaukerReader::readPauker()
{
m_doc->setAuthor( "http://pauker.sf.net" );
///Pauker does not provide any column titles
}
-void KEduVocPaukerReader::readBatch()
+void QmVocPaukerReader::readBatch()
{
while ( !atEnd() ) {
readNext();
}
-void KEduVocPaukerReader::readCard()
+void QmVocPaukerReader::readCard()
{
QString front;
QString back;
}
}
- KEduVocLesson* lesson = new KEduVocLesson("Vocabulary", m_doc->lesson());
+ QmVocLesson* lesson = new QmVocLesson("Vocabulary", m_doc->lesson());
m_doc->lesson()->appendChildContainer(lesson);
- KEduVocExpression* expr = new KEduVocExpression( QStringList() << front << back);
+ QmVocExpression* expr = new QmVocExpression( QStringList() << front << back);
lesson->appendEntry( expr );
}
-QString KEduVocPaukerReader::readText()
+QString QmVocPaukerReader::readText()
{
QString result;
***************************************************************************/
/***************************************************************************
- create a KEduVocDocument from a Pauker file
+ create a QmVocDocument from a Pauker file
-----------------------------------------------------------------------
copyright : (C) 2004, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCPAUKERREADER_H
-#define KEDUVOCPAUKERREADER_H
+#ifndef QMVOCPAUKERREADER_H
+#define QMVOCPAUKERREADER_H
#include <QXmlStreamReader>
class QIODevice;
-class KEduVocDocument;
+class QmVocDocument;
-class KEduVocPaukerReader : public QXmlStreamReader
+class QmVocPaukerReader : public QXmlStreamReader
{
public:
- KEduVocPaukerReader( KEduVocDocument *doc );
+ QmVocPaukerReader( QmVocDocument *doc );
bool read( QIODevice *device );
void readCard();
QString readText();
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
};
#endif
/***************************************************************************
Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#include "keduvocpersonalpronoun.h"
-#include "keduvoccommon_p.h"
+#include "qmvocpersonalpronoun.h"
+#include "qmvoccommon_p.h"
#include <QtCore/QMap>
-class KEduVocPersonalPronoun::Private
+class QmVocPersonalPronoun::Private
{
public:
Private();
bool m_maleFemaleDifferent;
bool m_neutralExists;
bool m_dualExists;
- QMap<KEduVocWordFlags, QString> m_personalpronouns;
+ QMap<QmVocWordFlags, QString> m_personalpronouns;
};
-KEduVocPersonalPronoun::Private::Private()
+QmVocPersonalPronoun::Private::Private()
{
m_maleFemaleDifferent = false;
m_neutralExists = false;
m_dualExists = false;
}
-KEduVocPersonalPronoun::KEduVocPersonalPronoun()
+QmVocPersonalPronoun::QmVocPersonalPronoun()
: d( new Private )
{}
-KEduVocPersonalPronoun::KEduVocPersonalPronoun( const KEduVocPersonalPronoun& other )
+QmVocPersonalPronoun::QmVocPersonalPronoun( const QmVocPersonalPronoun& other )
: d( new Private )
{
d->m_maleFemaleDifferent = other.d->m_maleFemaleDifferent;
}
-KEduVocPersonalPronoun::~KEduVocPersonalPronoun()
+QmVocPersonalPronoun::~QmVocPersonalPronoun()
{
delete d;
}
-KEduVocPersonalPronoun& KEduVocPersonalPronoun::operator = ( const KEduVocPersonalPronoun& other )
+QmVocPersonalPronoun& QmVocPersonalPronoun::operator = ( const QmVocPersonalPronoun& other )
{
d->m_maleFemaleDifferent = other.d->m_maleFemaleDifferent;
d->m_neutralExists = other.d->m_neutralExists;
}
-bool KEduVocPersonalPronoun::operator ==(const KEduVocPersonalPronoun& other) const
+bool QmVocPersonalPronoun::operator ==(const QmVocPersonalPronoun& other) const
{
return d->m_personalpronouns == other.d->m_personalpronouns &&
d->m_maleFemaleDifferent == other.d->m_maleFemaleDifferent &&
}
-QString KEduVocPersonalPronoun::personalPronoun(KEduVocWordFlags flags) const
+QString QmVocPersonalPronoun::personalPronoun(QmVocWordFlags flags) const
{
- QString p = d->m_personalpronouns.value(flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers| KEduVocWordFlag::genders));
- if (p.isEmpty() && !(flags & KEduVocWordFlag::genders) && d->m_maleFemaleDifferent && d->m_neutralExists)
+ QString p = d->m_personalpronouns.value(flags & (QmVocWordFlag::persons | QmVocWordFlag::numbers| QmVocWordFlag::genders));
+ if (p.isEmpty() && !(flags & QmVocWordFlag::genders) && d->m_maleFemaleDifferent && d->m_neutralExists)
{
//initial flag lookup failed, adding neuter gender flag
- flags |= KEduVocWordFlag::Neuter;
- p = d->m_personalpronouns.value(flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers| KEduVocWordFlag::genders));
+ flags |= QmVocWordFlag::Neuter;
+ p = d->m_personalpronouns.value(flags & (QmVocWordFlag::persons | QmVocWordFlag::numbers| QmVocWordFlag::genders));
}
return p;
}
-void KEduVocPersonalPronoun::setPersonalPronoun(const QString & personalpronoun, KEduVocWordFlags flags)
+void QmVocPersonalPronoun::setPersonalPronoun(const QString & personalpronoun, QmVocWordFlags flags)
{
- d->m_personalpronouns[flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers| KEduVocWordFlag::genders)] = personalpronoun;
+ d->m_personalpronouns[flags & (QmVocWordFlag::persons | QmVocWordFlag::numbers| QmVocWordFlag::genders)] = personalpronoun;
}
-bool KEduVocPersonalPronoun::maleFemaleDifferent() const
+bool QmVocPersonalPronoun::maleFemaleDifferent() const
{
return d->m_maleFemaleDifferent;
}
-void KEduVocPersonalPronoun::setMaleFemaleDifferent(bool different)
+void QmVocPersonalPronoun::setMaleFemaleDifferent(bool different)
{
d->m_maleFemaleDifferent = different;
}
-bool KEduVocPersonalPronoun::neutralExists() const
+bool QmVocPersonalPronoun::neutralExists() const
{
return d->m_neutralExists;
}
-void KEduVocPersonalPronoun::setNeutralExists(bool exists)
+void QmVocPersonalPronoun::setNeutralExists(bool exists)
{
d->m_neutralExists = exists;
}
-bool KEduVocPersonalPronoun::dualExists() const
+bool QmVocPersonalPronoun::dualExists() const
{
return d->m_dualExists;
}
-void KEduVocPersonalPronoun::setDualExists(bool exists)
+void QmVocPersonalPronoun::setDualExists(bool exists)
{
d->m_dualExists = exists;
}
/***************************************************************************
Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
***************************************************************************/
-#ifndef KEDUVOCPERSONALPRONOUN_H
-#define KEDUVOCPERSONALPRONOUN_H
+#ifndef QMVOCPERSONALPRONOUN_H
+#define QMVOCPERSONALPRONOUN_H
-#include "libkeduvocdocument_export.h"
-#include "keduvocconjugation.h"
+#include "libqmvocdocument_export.h"
+#include "qmvocconjugation.h"
#include <QtCore/QStringList>
/**
* The conjugation of a verb
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocPersonalPronoun
+class QMVOCDOCUMENT_EXPORT QmVocPersonalPronoun
{
public:
/**
* The constructor
*/
- explicit KEduVocPersonalPronoun();
+ explicit QmVocPersonalPronoun();
- KEduVocPersonalPronoun( const KEduVocPersonalPronoun& rhs );
+ QmVocPersonalPronoun( const QmVocPersonalPronoun& rhs );
- ~KEduVocPersonalPronoun();
+ ~QmVocPersonalPronoun();
- KEduVocPersonalPronoun& operator = ( const KEduVocPersonalPronoun& a );
- bool operator == ( const KEduVocPersonalPronoun& a ) const;
+ QmVocPersonalPronoun& operator = ( const QmVocPersonalPronoun& a );
+ bool operator == ( const QmVocPersonalPronoun& a ) const;
- QString personalPronoun(KEduVocWordFlags flags) const;
- void setPersonalPronoun(const QString& conjugation, KEduVocWordFlags flags);
+ QString personalPronoun(QmVocWordFlags flags) const;
+ void setPersonalPronoun(const QString& conjugation, QmVocWordFlags flags);
bool maleFemaleDifferent() const;
void setMaleFemaleDifferent(bool different);
-#endif // KEDUVOCCONJUGATION_H
+#endif // QMVOCCONJUGATION_H
/***************************************************************************
Copyright 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#include "keduvoctext.h"
+#include "qmvoctext.h"
#include "kvtml2defs.h"
-#include "keduvockvtml2writer.h"
+#include "qmvockvtml2writer.h"
#include <QtXml/QDomDocument>
-class KEduVocText::KEduVocTextPrivate
+class QmVocText::QmVocTextPrivate
{
public:
/// This is the word itself. The vocabulary. This is what it is all about.
QDateTime m_practiceDate;
};
-KEduVocText::KEduVocText(const QString& text)
- :d( new KEduVocTextPrivate )
+QmVocText::QmVocText(const QString& text)
+ :d( new QmVocTextPrivate )
{
d->m_text = text;
resetGrades();
}
-KEduVocText::KEduVocText( const KEduVocText &other )
- :d( new KEduVocTextPrivate )
+QmVocText::QmVocText( const QmVocText &other )
+ :d( new QmVocTextPrivate )
{
d->m_text = other.d->m_text;
setGrade( other.grade() );
setPracticeDate( other.practiceDate() );
}
-KEduVocText::~KEduVocText()
+QmVocText::~QmVocText()
{
delete d;
}
-QString KEduVocText::text() const
+QString QmVocText::text() const
{
return d->m_text;
}
-void KEduVocText::setText( const QString & expr )
+void QmVocText::setText( const QString & expr )
{
d->m_text = expr.simplified();
}
-void KEduVocText::resetGrades()
+void QmVocText::resetGrades()
{
d->m_grade = KV_NORM_GRADE;
d->m_totalPracticeCount = 0;
}
-grade_t KEduVocText::grade() const
+grade_t QmVocText::grade() const
{
return d->m_grade;
}
-void KEduVocText::setGrade( grade_t grade )
+void QmVocText::setGrade( grade_t grade )
{
if ( grade > KV_MAX_GRADE ) {
grade = KV_MAX_GRADE;
}
-void KEduVocText::incGrade()
+void QmVocText::incGrade()
{
setGrade( qMax<grade_t>(grade() + 1, KV_LEV1_GRADE ) );
}
-void KEduVocText::decGrade()
+void QmVocText::decGrade()
{
if ( grade() == KV_MIN_GRADE ) {
return;
}
-count_t KEduVocText::practiceCount() const
+count_t QmVocText::practiceCount() const
{
return d->m_totalPracticeCount;
}
-void KEduVocText::incPracticeCount()
+void QmVocText::incPracticeCount()
{
setPracticeCount( practiceCount() + 1 );
}
-void KEduVocText::incBadCount()
+void QmVocText::incBadCount()
{
setBadCount( badCount() + 1 );
}
-void KEduVocText::setPracticeCount( count_t count )
+void QmVocText::setPracticeCount( count_t count )
{
d->m_totalPracticeCount = count;
}
-count_t KEduVocText::badCount() const
+count_t QmVocText::badCount() const
{
return d->m_badCount;
}
-void KEduVocText::setBadCount( count_t count )
+void QmVocText::setBadCount( count_t count )
{
d->m_badCount = count;
}
-QDateTime KEduVocText::practiceDate() const
+QDateTime QmVocText::practiceDate() const
{
return d->m_practiceDate;
}
-void KEduVocText::setPracticeDate( const QDateTime & date )
+void QmVocText::setPracticeDate( const QDateTime & date )
{
d->m_practiceDate = date;
}
-KEduVocText & KEduVocText::operator =(const KEduVocText & other)
+QmVocText & QmVocText::operator =(const QmVocText & other)
{
d->m_text = other.d->m_text;
d->m_grade = other.d->m_grade;
return *this;
}
-bool KEduVocText::operator ==(const KEduVocText & other) const
+bool QmVocText::operator ==(const QmVocText & other) const
{
return
d->m_text == other.d->m_text &&
d->m_practiceDate == other.d->m_practiceDate;
}
-void KEduVocText::toKVTML2(QDomElement& parent)
+void QmVocText::toKVTML2(QDomElement& parent)
{
QDomDocument domDoc = parent.ownerDocument();
if (d->m_text.isEmpty() && d->m_totalPracticeCount == 0) {
}
// the text
- KEduVocKvtml2Writer::appendTextElement( parent, KVTML_TEXT, text() );
+ QmVocKvtml2Writer::appendTextElement( parent, KVTML_TEXT, text() );
// grades
if ( d->m_totalPracticeCount > 0 ) {
QDomElement gradeElement = domDoc.createElement( KVTML_GRADE );
//<currentgrade>2</currentgrade>
- KEduVocKvtml2Writer::appendTextElement( gradeElement, KVTML_CURRENTGRADE, QString::number( grade() ) );
+ QmVocKvtml2Writer::appendTextElement( gradeElement, KVTML_CURRENTGRADE, QString::number( grade() ) );
//<count>6</count>
- KEduVocKvtml2Writer::appendTextElement( gradeElement, KVTML_COUNT, QString::number( practiceCount() ) );
+ QmVocKvtml2Writer::appendTextElement( gradeElement, KVTML_COUNT, QString::number( practiceCount() ) );
//<errorcount>1</errorcount>
- KEduVocKvtml2Writer::appendTextElement( gradeElement, KVTML_ERRORCOUNT, QString::number( badCount() ) );
+ QmVocKvtml2Writer::appendTextElement( gradeElement, KVTML_ERRORCOUNT, QString::number( badCount() ) );
//<date>949757271</date>
- KEduVocKvtml2Writer::appendTextElement( gradeElement, KVTML_DATE, practiceDate().toString( Qt::ISODate ) );
+ QmVocKvtml2Writer::appendTextElement( gradeElement, KVTML_DATE, practiceDate().toString( Qt::ISODate ) );
parent.appendChild( gradeElement );
}
}
-void KEduVocText::fromKVTML2(QDomElement & parent)
+void QmVocText::fromKVTML2(QDomElement & parent)
{
setText( parent.firstChildElement( KVTML_TEXT ).text() );
}
}
-bool KEduVocText::isEmpty()
+bool QmVocText::isEmpty()
{
return d->m_text.isEmpty();
}
/***************************************************************************
Copyright 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCTEXT_H
-#define KEDUVOCTEXT_H
+#ifndef QMVOCTEXT_H
+#define QMVOCTEXT_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
#include <QtCore/QDateTime>
* This should be used instead of strings for all things that can be tested and thus get a grade.
@author Frederik Gladhorn <frederik.gladhorn@kdemail.net>
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocText
+class QMVOCDOCUMENT_EXPORT QmVocText
{
public:
/** default constructor */
- KEduVocText(const QString& text = QString());
+ QmVocText(const QString& text = QString());
/** copy constructor
* provides safe copy of d pointer
* @param other object to copy from
*/
- KEduVocText( const KEduVocText &other );
+ QmVocText( const QmVocText &other );
/** default destructor */
- ~KEduVocText();
+ ~QmVocText();
/**
* The translation as string (the word itself)
* @param other grades copied
* @return reference to the new grades
*/
- KEduVocText& operator= ( const KEduVocText &other );
+ QmVocText& operator= ( const QmVocText &other );
/**
* Compare two sets of grades.
* @param other
* @return true if equal
*/
- bool operator== ( const KEduVocText &other ) const;
+ bool operator== ( const QmVocText &other ) const;
/** returns how often this entry has been practiced as int
void toKVTML2(QDomElement& parent);
private:
- class KEduVocTextPrivate;
- KEduVocTextPrivate * const d;
+ class QmVocTextPrivate;
+ QmVocTextPrivate * const d;
};
#endif
***************************************************************************/
-#include "keduvoctranslation.h"
+#include "qmvoctranslation.h"
-#include "keduvocdeclension.h"
-#include "keduvocwordtype.h"
-#include "keduvocleitnerbox.h"
+#include "qmvocdeclension.h"
+#include "qmvocwordtype.h"
+#include "qmvocleitnerbox.h"
#include "kvtml2defs.h"
-#include "keduvockvtml2writer.h"
+#include "qmvockvtml2writer.h"
#include <QtCore/QMap>
-class KEduVocTranslation::KEduVocTranslationPrivate
+class QmVocTranslation::QmVocTranslationPrivate
{
public:
- KEduVocTranslationPrivate(KEduVocExpression* parent);
+ QmVocTranslationPrivate(QmVocExpression* parent);
- ~KEduVocTranslationPrivate();
+ ~QmVocTranslationPrivate();
- KEduVocExpression* m_entry;
+ QmVocExpression* m_entry;
/// Type of a word noun, verb, adjective etc
- KEduVocWordType* m_wordType;
+ QmVocWordType* m_wordType;
/// Leitner box of the translation.
- KEduVocLeitnerBox* m_leitnerBox;
+ QmVocLeitnerBox* m_leitnerBox;
/// A comment giving additional information.
QString m_comment;
/// Pronunciation
QString m_pronunciation;
/// Image url
- KUrl m_imageUrl;
+ QUrl m_imageUrl;
/// Sound url
- KUrl m_soundUrl;
+ QUrl m_soundUrl;
/// When creating multiple choice tests, these are possible answers. (otherwise other words are added randomly)
QStringList m_multipleChoice;
/// Conjugations of a word (I go, you go, he goes... boring in english)
- QMap <QString, KEduVocConjugation> m_conjugations;
+ QMap <QString, QmVocConjugation> m_conjugations;
/// The comparison forms of adjectives and adverbs: (fast), faster, fastest
- KEduVocText* m_comparative;
- KEduVocText* m_superlative;
+ QmVocText* m_comparative;
+ QmVocText* m_superlative;
/// The grade of an article. The text part should not be used.
- KEduVocText* m_articleGrade;
+ QmVocText* m_articleGrade;
- KEduVocDeclension* m_declension;
+ QmVocDeclension* m_declension;
// connections to other translations
/// Synonyms for a word: sick and ill, student and pupil
- QList< KEduVocTranslation* > m_synonyms;
+ QList< QmVocTranslation* > m_synonyms;
/// An antonym - the opposite: hot - cold
- QList< KEduVocTranslation* > m_antonyms;
+ QList< QmVocTranslation* > m_antonyms;
/// List of false friends
- QList< KEduVocTranslation* > m_falseFriends;
+ QList< QmVocTranslation* > m_falseFriends;
};
-KEduVocTranslation::KEduVocTranslationPrivate::KEduVocTranslationPrivate(KEduVocExpression* parent)
+QmVocTranslation::QmVocTranslationPrivate::QmVocTranslationPrivate(QmVocExpression* parent)
{
m_entry = parent;
m_wordType = 0;
}
-KEduVocTranslation::KEduVocTranslationPrivate::~KEduVocTranslationPrivate()
+QmVocTranslation::QmVocTranslationPrivate::~QmVocTranslationPrivate()
{
delete m_declension;
}
-KEduVocTranslation::KEduVocTranslation(KEduVocExpression* entry) : d( new KEduVocTranslationPrivate(entry) )
+QmVocTranslation::QmVocTranslation(QmVocExpression* entry) : d( new QmVocTranslationPrivate(entry) )
{
}
-KEduVocTranslation::KEduVocTranslation(KEduVocExpression* entry, const QString &translation ) : d( new KEduVocTranslationPrivate(entry) )
+QmVocTranslation::QmVocTranslation(QmVocExpression* entry, const QString &translation ) : d( new QmVocTranslationPrivate(entry) )
{
setText(translation.simplified());
}
-KEduVocTranslation::KEduVocTranslation( const KEduVocTranslation &other )
- : KEduVocText(other),
+QmVocTranslation::QmVocTranslation( const QmVocTranslation &other )
+ : QmVocText(other),
// set the entry to 0, the translation will be put into a copied entry by the expression copy constructor
- d( new KEduVocTranslationPrivate(0) )
+ d( new QmVocTranslationPrivate(0) )
{
// beter no word type copy as this is pointer copying
// will not work as this is not added to the word type container!
// d->m_antonyms = other.d->m_antonyms;
// d->m_falseFriends = other.d->m_falseFriends;
if (other.d->m_declension) {
- d->m_declension = new KEduVocDeclension(*other.d->m_declension);
+ d->m_declension = new QmVocDeclension(*other.d->m_declension);
}
}
-KEduVocTranslation::~KEduVocTranslation()
+QmVocTranslation::~QmVocTranslation()
{
setWordType(0);
setLeitnerBox(0);
- foreach (KEduVocTranslation *synonym, d->m_synonyms) {
+ foreach (QmVocTranslation *synonym, d->m_synonyms) {
synonym->removeSynonym(this);
}
- foreach (KEduVocTranslation *antonym, d->m_antonyms) {
+ foreach (QmVocTranslation *antonym, d->m_antonyms) {
antonym->removeAntonym(this);
}
- foreach (KEduVocTranslation *falseFriend, d->m_falseFriends) {
+ foreach (QmVocTranslation *falseFriend, d->m_falseFriends) {
falseFriend->removeFalseFriend(this);
}
delete d;
}
-bool KEduVocTranslation::operator == ( const KEduVocTranslation & translation ) const
+bool QmVocTranslation::operator == ( const QmVocTranslation & translation ) const
{
- return KEduVocText::operator==(translation) &&
+ return QmVocText::operator==(translation) &&
d->m_wordType == translation.d->m_wordType &&
d->m_leitnerBox == translation.d->m_leitnerBox &&
d->m_comment == translation.d->m_comment &&
/// @todo check and include declensions d->m_declension == translation.d->m_declension;
}
-KEduVocTranslation & KEduVocTranslation::operator = ( const KEduVocTranslation & translation )
+QmVocTranslation & QmVocTranslation::operator = ( const QmVocTranslation & translation )
{
- KEduVocText::operator=(translation);
+ QmVocText::operator=(translation);
d->m_entry = translation.d->m_entry;
// d->m_wordType = translation.d->m_wordType;
// d->m_leitnerBox = translation.d->m_leitnerBox;
d->m_antonyms = translation.d->m_antonyms;
d->m_conjugations = translation.d->m_conjugations;
if (translation.d->m_declension) {
- d->m_declension = new KEduVocDeclension(*translation.d->m_declension);
+ d->m_declension = new QmVocDeclension(*translation.d->m_declension);
}
return *this;
}
-QString KEduVocTranslation::comment() const
+QString QmVocTranslation::comment() const
{
return d->m_comment;
}
-void KEduVocTranslation::setComment( const QString & expr )
+void QmVocTranslation::setComment( const QString & expr )
{
d->m_comment = expr.simplified();
}
-void KEduVocTranslation::addFalseFriend( KEduVocTranslation* falseFriend )
+void QmVocTranslation::addFalseFriend( QmVocTranslation* falseFriend )
{
d->m_falseFriends.append(falseFriend);
}
-void KEduVocTranslation::removeFalseFriend(KEduVocTranslation * falseFriend)
+void QmVocTranslation::removeFalseFriend(QmVocTranslation * falseFriend)
{
d->m_falseFriends.removeAt(d->m_falseFriends.indexOf(falseFriend));
}
-QList< KEduVocTranslation* > KEduVocTranslation::falseFriends() const
+QList< QmVocTranslation* > QmVocTranslation::falseFriends() const
{
return d->m_falseFriends;
}
-void KEduVocTranslation::addSynonym( KEduVocTranslation* synonym )
+void QmVocTranslation::addSynonym( QmVocTranslation* synonym )
{
d->m_synonyms.append(synonym);
}
-void KEduVocTranslation::removeSynonym(KEduVocTranslation * synonym)
+void QmVocTranslation::removeSynonym(QmVocTranslation * synonym)
{
d->m_synonyms.removeAt(d->m_synonyms.indexOf(synonym));
}
-QList<KEduVocTranslation*> KEduVocTranslation::synonyms() const
+QList<QmVocTranslation*> QmVocTranslation::synonyms() const
{
return d->m_synonyms;
}
-void KEduVocTranslation::addAntonym( KEduVocTranslation* antonym )
+void QmVocTranslation::addAntonym( QmVocTranslation* antonym )
{
d->m_antonyms.append(antonym);
}
-QList<KEduVocTranslation*> KEduVocTranslation::antonyms() const
+QList<QmVocTranslation*> QmVocTranslation::antonyms() const
{
return d->m_antonyms;
}
-void KEduVocTranslation::removeAntonym(KEduVocTranslation * antonym)
+void QmVocTranslation::removeAntonym(QmVocTranslation * antonym)
{
d->m_antonyms.removeAt(d->m_antonyms.indexOf(antonym));
}
-void KEduVocTranslation::setExample( const QString & expr )
+void QmVocTranslation::setExample( const QString & expr )
{
d->m_example = expr.simplified();
}
-QString KEduVocTranslation::example() const
+QString QmVocTranslation::example() const
{
return d->m_example;
}
-void KEduVocTranslation::setParaphrase( const QString & expr )
+void QmVocTranslation::setParaphrase( const QString & expr )
{
d->m_paraphrase = expr.simplified();
}
-QString KEduVocTranslation::paraphrase() const
+QString QmVocTranslation::paraphrase() const
{
return d->m_paraphrase;
}
-void KEduVocTranslation::setConjugation( const QString& tense, const KEduVocConjugation& con )
+void QmVocTranslation::setConjugation( const QString& tense, const QmVocConjugation& con )
{
d->m_conjugations[tense] = con;
}
-KEduVocConjugation& KEduVocTranslation::conjugation( const QString& tense )
+QmVocConjugation& QmVocTranslation::conjugation( const QString& tense )
{
return d->m_conjugations[tense];
}
-QStringList & KEduVocTranslation::multipleChoice()
+QStringList & QmVocTranslation::multipleChoice()
{
return d->m_multipleChoice;
}
-QString KEduVocTranslation::pronunciation() const
+QString QmVocTranslation::pronunciation() const
{
return d->m_pronunciation;
}
-void KEduVocTranslation::setPronunciation( const QString & expr )
+void QmVocTranslation::setPronunciation( const QString & expr )
{
d->m_pronunciation = expr.simplified();
}
-QStringList KEduVocTranslation::conjugationTenses() const
+QStringList QmVocTranslation::conjugationTenses() const
{
return d->m_conjugations.keys();
}
-QMap< QString, KEduVocConjugation > KEduVocTranslation::conjugations() const
+QMap< QString, QmVocConjugation > QmVocTranslation::conjugations() const
{
return d->m_conjugations;
}
-void KEduVocTranslation::setConjugations(const QMap< QString, KEduVocConjugation > & conjugations)
+void QmVocTranslation::setConjugations(const QMap< QString, QmVocConjugation > & conjugations)
{
d->m_conjugations = conjugations;
}
/** get the sound url for this translation if it exists */
-KUrl KEduVocTranslation::soundUrl()
+QUrl QmVocTranslation::soundUrl()
{
return d->m_soundUrl;
}
/** set the sound url for this translation
* @param url url of the sound file */
-void KEduVocTranslation::setSoundUrl(const KUrl &url)
+void QmVocTranslation::setSoundUrl(const QUrl &url)
{
d->m_soundUrl = url;
}
/** get the image url for this translation if it exists */
-KUrl KEduVocTranslation::imageUrl()
+QUrl QmVocTranslation::imageUrl()
{
return d->m_imageUrl;
}
/** set the image url for this translation
* @param url url of the image
*/
-void KEduVocTranslation::setImageUrl(const KUrl &url)
+void QmVocTranslation::setImageUrl(const QUrl &url)
{
d->m_imageUrl = url;
}
-KEduVocWordType * KEduVocTranslation::wordType() const
+QmVocWordType * QmVocTranslation::wordType() const
{
if (d) {
return d->m_wordType;
}
}
-void KEduVocTranslation::setWordType(KEduVocWordType * wordType)
+void QmVocTranslation::setWordType(QmVocWordType * wordType)
{
if ( d->m_wordType ) {
d->m_wordType->removeTranslation(this);
d->m_wordType = wordType;
}
-KEduVocLeitnerBox * KEduVocTranslation::leitnerBox() const
+QmVocLeitnerBox * QmVocTranslation::leitnerBox() const
{
return d->m_leitnerBox;
}
-void KEduVocTranslation::setLeitnerBox(KEduVocLeitnerBox * leitnerBox)
+void QmVocTranslation::setLeitnerBox(QmVocLeitnerBox * leitnerBox)
{
if ( d->m_leitnerBox ) {
d->m_leitnerBox->removeTranslation(this);
d->m_leitnerBox = leitnerBox;
}
-KEduVocExpression * KEduVocTranslation::entry()
+QmVocExpression * QmVocTranslation::entry()
{
return d->m_entry;
}
-QString KEduVocTranslation::comparative() const
+QString QmVocTranslation::comparative() const
{
if (d->m_comparative) {
return d->m_comparative->text();
return QString();
}
-void KEduVocTranslation::setComparative(const QString & comparative)
+void QmVocTranslation::setComparative(const QString & comparative)
{
if (!d->m_comparative) {
- d->m_comparative = new KEduVocText(comparative);
+ d->m_comparative = new QmVocText(comparative);
} else {
d->m_comparative->setText(comparative);
}
}
-QString KEduVocTranslation::superlative() const
+QString QmVocTranslation::superlative() const
{
if (d->m_superlative) {
return d->m_superlative->text();
return QString();
}
-void KEduVocTranslation::setSuperlative(const QString & superlative)
+void QmVocTranslation::setSuperlative(const QString & superlative)
{
if (!d->m_superlative) {
- d->m_superlative = new KEduVocText(superlative);
+ d->m_superlative = new QmVocText(superlative);
} else {
d->m_superlative->setText(superlative);
}
}
-KEduVocText KEduVocTranslation::comparativeForm() const
+QmVocText QmVocTranslation::comparativeForm() const
{
if (!d->m_comparative) {
- return KEduVocText();
+ return QmVocText();
}
- KEduVocText t(*(d->m_comparative));
+ QmVocText t(*(d->m_comparative));
return t;
}
-void KEduVocTranslation::setComparativeForm(const KEduVocText& comparative)
+void QmVocTranslation::setComparativeForm(const QmVocText& comparative)
{
if (!d->m_comparative) {
- d->m_comparative = new KEduVocText();
+ d->m_comparative = new QmVocText();
}
*(d->m_comparative) = comparative;
}
-KEduVocText KEduVocTranslation::superlativeForm() const
+QmVocText QmVocTranslation::superlativeForm() const
{
if (!d->m_superlative) {
- return KEduVocText();
+ return QmVocText();
}
- KEduVocText t(*d->m_superlative);
+ QmVocText t(*d->m_superlative);
return t;
}
-void KEduVocTranslation::setSuperlativeForm(const KEduVocText& superlative)
+void QmVocTranslation::setSuperlativeForm(const QmVocText& superlative)
{
if (!d->m_superlative) {
- d->m_superlative = new KEduVocText();
+ d->m_superlative = new QmVocText();
}
*d->m_superlative = superlative;
}
-KEduVocText KEduVocTranslation::article() const
+QmVocText QmVocTranslation::article() const
{
if (!d->m_articleGrade) {
- return KEduVocText();
+ return QmVocText();
}
- KEduVocText t(*d->m_articleGrade);
+ QmVocText t(*d->m_articleGrade);
return t;
}
-void KEduVocTranslation::setArticle(const KEduVocText& article)
+void QmVocTranslation::setArticle(const QmVocText& article)
{
if (!d->m_articleGrade) {
- d->m_articleGrade = new KEduVocText();
+ d->m_articleGrade = new QmVocText();
}
*d->m_articleGrade = article;
}
-KEduVocDeclension * KEduVocTranslation::declension()
+QmVocDeclension * QmVocTranslation::declension()
{
return d->m_declension;
}
-void KEduVocTranslation::setDeclension(KEduVocDeclension * declension)
+void QmVocTranslation::setDeclension(QmVocDeclension * declension)
{
// remove the old declension object
delete d->m_declension;
d->m_declension = declension;
}
-void KEduVocTranslation::toKVTML2(QDomElement & parent)
+void QmVocTranslation::toKVTML2(QDomElement & parent)
{
// text and grade
- KEduVocText::toKVTML2(parent);
+ QmVocText::toKVTML2(parent);
// declension
if (d->m_declension) {
}
// <comment>
- KEduVocKvtml2Writer::appendTextElement( parent, KVTML_COMMENT, comment() );
+ QmVocKvtml2Writer::appendTextElement( parent, KVTML_COMMENT, comment() );
// <pronunciation>
- KEduVocKvtml2Writer::appendTextElement( parent, KVTML_PRONUNCIATION, pronunciation() );
+ QmVocKvtml2Writer::appendTextElement( parent, KVTML_PRONUNCIATION, pronunciation() );
// <example>
- KEduVocKvtml2Writer::appendTextElement( parent, KVTML_EXAMPLE, example() );
+ QmVocKvtml2Writer::appendTextElement( parent, KVTML_EXAMPLE, example() );
// <paraphrase>
- KEduVocKvtml2Writer::appendTextElement( parent, KVTML_PARAPHRASE, paraphrase() );
+ QmVocKvtml2Writer::appendTextElement( parent, KVTML_PARAPHRASE, paraphrase() );
///@todo synonyms, antonyms
///@todo false friends
}
-void KEduVocTranslation::fromKVTML2(QDomElement & parent)
+void QmVocTranslation::fromKVTML2(QDomElement & parent)
{
- KEduVocText::fromKVTML2(parent);
+ QmVocText::fromKVTML2(parent);
- setDeclension(KEduVocDeclension::fromKVTML2(parent));
+ setDeclension(QmVocDeclension::fromKVTML2(parent));
setComment( parent.firstChildElement( KVTML_COMMENT ).text() );
while ( !conjugationElement.isNull() ) {
QDomElement tenseElement = conjugationElement.firstChildElement( KVTML_TENSE );
QString tense = tenseElement.text();
- KEduVocConjugation *conjugation = KEduVocConjugation::fromKVTML2(conjugationElement);
+ QmVocConjugation *conjugation = QmVocConjugation::fromKVTML2(conjugationElement);
setConjugation(tense, *conjugation);
delete conjugation;
conjugationElement = conjugationElement.nextSiblingElement( KVTML_CONJUGATION );
///@todo false friends
}
-void KEduVocTranslation::setEntry(KEduVocExpression * entry)
+void QmVocTranslation::setEntry(QmVocExpression * entry)
{
d->m_entry = entry;
}
***************************************************************************/
-#ifndef KEDUVOCTRANSLATION_H
-#define KEDUVOCTRANSLATION_H
+#ifndef QMVOCTRANSLATION_H
+#define QMVOCTRANSLATION_H
-#include "libkeduvocdocument_export.h"
-#include "keduvocconjugation.h"
-#include "keduvoctext.h"
+#include "libqmvocdocument_export.h"
+#include "qmvocconjugation.h"
+#include "qmvoctext.h"
// #include <KDE/KUrl>
#include <QUrl>
#include <QtCore/QString>
-class KEduVocExpression;
-class KEduVocString;
-class KEduVocWordType;
-class KEduVocLeitnerBox;
-class KEduVocDeclension;
+class QmVocExpression;
+class QmVocString;
+class QmVocWordType;
+class QmVocLeitnerBox;
+class QmVocDeclension;
/**
@author Frederik Gladhorn <frederik.gladhorn@kdemail.net>
*/
-class KEDUVOCDOCUMENT_EXPORT KEduVocTranslation
- :public KEduVocText
+class QMVOCDOCUMENT_EXPORT QmVocTranslation
+ :public QmVocText
{
public:
enum Related {
/**
* Default constructor for an empty translation.
*/
- KEduVocTranslation(KEduVocExpression* entry);
+ QmVocTranslation(QmVocExpression* entry);
/**
* Constructor
* @param translation is used as translation
*/
- KEduVocTranslation(KEduVocExpression* entry, const QString &translation );
+ QmVocTranslation(QmVocExpression* entry, const QString &translation );
/** copy constructor for d-pointer safety */
- KEduVocTranslation( const KEduVocTranslation &other );
+ QmVocTranslation( const QmVocTranslation &other );
/**
* Destructor
*/
- ~KEduVocTranslation();
+ ~QmVocTranslation();
- KEduVocExpression* entry();
+ QmVocExpression* entry();
/** Sets the pronunciation of this expression
* @param expression pronunciation of this index
*
* @return type or "" if no type available
*/
- KEduVocWordType* wordType() const;
+ QmVocWordType* wordType() const;
/** Sets the word type of this expression
* @param type type of this expression ("" = none)
*/
- void setWordType( KEduVocWordType* wordType );
+ void setWordType( QmVocWordType* wordType );
/** Returns the leitner box of this translation
* @return the box
*/
- KEduVocLeitnerBox* leitnerBox() const;
+ QmVocLeitnerBox* leitnerBox() const;
/** Sets the leitner box of this translation
* @param leitnerBox the box
*/
- void setLeitnerBox( KEduVocLeitnerBox* leitnerBox );
+ void setLeitnerBox( QmVocLeitnerBox* leitnerBox );
/**
* Returns a conjugation if available
* @param tense tense of the requested conjugation
* @return the conjugation
*/
- KEduVocConjugation& conjugation( const QString& tense );
+ QmVocConjugation& conjugation( const QString& tense );
/** adds conjugations or replaces them, if they exist.
* @param conjugation conjugation
*/
- void setConjugation( const QString& tense, const KEduVocConjugation & conjugation );
+ void setConjugation( const QString& tense, const QmVocConjugation & conjugation );
/**
* Returns a pointer to the declension object of this translation.
* Returns 0 if no declension object exists!
* @return the declension
*/
- KEduVocDeclension* declension();
+ QmVocDeclension* declension();
/**
* Set a new declension for a translation
* @param declension
*/
- void setDeclension(KEduVocDeclension* declension);
+ void setDeclension(QmVocDeclension* declension);
/**
* Bad, only used for tense entry page, will be deleted later. Deprecated.
* @param conjugation
*/
- void setConjugations( const QMap<QString, KEduVocConjugation>& conjugations );
+ void setConjugations( const QMap<QString, QmVocConjugation>& conjugations );
QStringList conjugationTenses() const;
* Bad, only compatibility. Deprecated.
* @return
*/
- KDE_DEPRECATED QMap <QString, KEduVocConjugation> conjugations() const;
+ KDE_DEPRECATED QMap <QString, QmVocConjugation> conjugations() const;
/**
* Comparison forms of adjectives/adverbs.
KDE_DEPRECATED QString comparative() const;
KDE_DEPRECATED void setComparative(const QString& comparative);
// TODO rename to comparative and remove the deprecated function
- KEduVocText comparativeForm() const;
- void setComparativeForm(const KEduVocText& comparative);
+ QmVocText comparativeForm() const;
+ void setComparativeForm(const QmVocText& comparative);
KDE_DEPRECATED QString superlative() const;
KDE_DEPRECATED void setSuperlative(const QString& superlative);
- KEduVocText superlativeForm() const;
- void setSuperlativeForm(const KEduVocText& superlative);
+ QmVocText superlativeForm() const;
+ void setSuperlativeForm(const QmVocText& superlative);
- KEduVocText article() const;
- void setArticle(const KEduVocText& article);
+ QmVocText article() const;
+ void setArticle(const QmVocText& article);
/** Returns multiple choice if available
*/
// void setMultipleChoice( const QStringList &mc );
/** Get the sound url for this translation if it exists */
- KUrl soundUrl();
+ QUrl soundUrl();
/** Set the sound url for this translation
* @param url url of the sound file */
- void setSoundUrl(const KUrl &url);
+ void setSoundUrl(const QUrl &url);
/** Get the image url for this translation if it exists */
- KUrl imageUrl();
+ QUrl imageUrl();
/** Set the image url for this translation
* @param url url of the image
*/
- void setImageUrl(const KUrl &url);
+ void setImageUrl(const QUrl &url);
/**
* Add a false friend
* @param falseFriend false friend of this index
*/
- void addFalseFriend( KEduVocTranslation* falseFriend );
+ void addFalseFriend( QmVocTranslation* falseFriend );
/**
* Remove a false friend
* @param falseFriend false friend of this index
*/
- void removeFalseFriend( KEduVocTranslation* falseFriend );
+ void removeFalseFriend( QmVocTranslation* falseFriend );
/**
* Returns false friends of this expression
* @return list of false friends
*/
- QList<KEduVocTranslation*> falseFriends() const;
+ QList<QmVocTranslation*> falseFriends() const;
/**
* Add a synonym
* @param synonym
*/
- void addSynonym( KEduVocTranslation* synonym );
+ void addSynonym( QmVocTranslation* synonym );
/**
* Remove a synonym
* @param synonym
*/
- void removeSynonym( KEduVocTranslation* synonym );
+ void removeSynonym( QmVocTranslation* synonym );
/**
* Returns synonyms of this expression
* @return synonyms
*/
- QList<KEduVocTranslation*> synonyms() const;
+ QList<QmVocTranslation*> synonyms() const;
/**
* Add a antonym
* @param antonym
*/
- void addAntonym( KEduVocTranslation* antonym );
+ void addAntonym( QmVocTranslation* antonym );
/**
* Remove a antonym
* @param antonym
*/
- void removeAntonym( KEduVocTranslation* antonym );
+ void removeAntonym( QmVocTranslation* antonym );
/**
* Returns antonyms of this expression
* @return antonyms
*/
- QList<KEduVocTranslation*> antonyms() const;
+ QList<QmVocTranslation*> antonyms() const;
/**
* Equal operator to assing a translation to another one.
* @param translation translation to be copied
* @return reference to the new translation
*/
- KEduVocTranslation& operator= ( const KEduVocTranslation &translation );
+ QmVocTranslation& operator= ( const QmVocTranslation &translation );
/**
* Compare two translations, including word type etc.
* @param translation
* @return true if equal
*/
- bool operator== ( const KEduVocTranslation &translation ) const;
+ bool operator== ( const QmVocTranslation &translation ) const;
void fromKVTML2(QDomElement& parent);
void toKVTML2(QDomElement& parent);
private:
- class KEduVocTranslationPrivate;
- KEduVocTranslationPrivate* const d;
+ class QmVocTranslationPrivate;
+ QmVocTranslationPrivate* const d;
// for the copy constructor
- void setEntry(KEduVocExpression* entry);
- friend class KEduVocExpression;
+ void setEntry(QmVocExpression* entry);
+ friend class QmVocExpression;
};
#endif
/***************************************************************************
- create a KEduVocDocument from a Vokabeln file
+ create a QmVocDocument from a Vokabeln file
-----------------------------------------------------------------------
* *
***************************************************************************/
-#include "keduvocvokabelnreader.h"
+#include "qmvocvokabelnreader.h"
#include <QIODevice>
// #include <kdebug.h>
#include <QDebug>
-#include "keduvocdocument.h"
-#include "keduvocexpression.h"
+#include "qmvocdocument.h"
+#include "qmvocexpression.h"
-KEduVocVokabelnReader::KEduVocVokabelnReader( QIODevice *file )
+QmVocVokabelnReader::QmVocVokabelnReader( QIODevice *file )
{
// the file must be already open
m_inputFile = file;
}
-bool KEduVocVokabelnReader::readDoc( KEduVocDocument *doc )
+bool QmVocVokabelnReader::readDoc( QmVocDocument *doc )
{
qDebug() << "Reading vokabeln.de document...";
m_doc = doc;
}
while(m_doc->lesson()->childContainerCount() <= lessonNumber) {
- KEduVocLesson* lesson = new KEduVocLesson(QString("Lesson %1").arg(lessonNumber), m_doc->lesson());
+ QmVocLesson* lesson = new QmVocLesson(QString("Lesson %1").arg(lessonNumber), m_doc->lesson());
m_doc->lesson()->appendChildContainer(lesson);
qDebug() << "Created lesson " << lessonNumber;
}
- KEduVocExpression* kve = new KEduVocExpression;
+ QmVocExpression* kve = new QmVocExpression;
kve->setTranslation( 0, original );
kve->setTranslation( 1, translation );
- static_cast<KEduVocLesson*>(m_doc->lesson()->childContainer(lessonNumber))->appendEntry(kve);
+ static_cast<QmVocLesson*>(m_doc->lesson()->childContainer(lessonNumber))->appendEntry(kve);
inputStream.readLine();
inputStream.readLine();
***************************************************************************/
/***************************************************************************
- create a KEduVocDocument from a Vokabeln file
+ create a QmVocDocument from a Vokabeln file
-----------------------------------------------------------------------
copyright : (C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCVOKABELNREADER_H
-#define KEDUVOCVOKABELNREADER_H
+#ifndef QMVOCVOKABELNREADER_H
+#define QMVOCVOKABELNREADER_H
#include <QString>
class QIODevice;
-class KEduVocDocument;
+class QmVocDocument;
-class KEduVocVokabelnReader
+class QmVocVokabelnReader
{
public:
- KEduVocVokabelnReader( QIODevice *file );
+ QmVocVokabelnReader( QIODevice *file );
- bool readDoc( KEduVocDocument *doc );
+ bool readDoc( QmVocDocument *doc );
QString errorMessage() const
{
private:
QIODevice *m_inputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
QString m_errorMessage;
};
/***************************************************************************
Copyright 2008 David Capel <wot.narg@gmail.com>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#ifndef KEDUVOCWORDFLAGS_H
-#define KEDUVOCWORDFLAGS_H
+#ifndef QMVOCWORDFLAGS_H
+#define QMVOCWORDFLAGS_H
#include <QFlags>
-class KEduVocWordFlag
+class QmVocWordFlag
{
public:
enum Flags
static const Flags numbers = (Flags)(Singular | Plural | Dual);
static const Flags cases = (Flags)(Nominative|Genitive|Dative|Accusative|Ablative|Locative|Vocative);
static const Flags persons = (Flags)(First | Second | Third);
-
};
-Q_DECLARE_FLAGS(KEduVocWordFlags, KEduVocWordFlag::Flags)
-Q_DECLARE_OPERATORS_FOR_FLAGS(KEduVocWordFlags)
+Q_DECLARE_FLAGS(QmVocWordFlags, QmVocWordFlag::Flags)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QmVocWordFlags)
+
#endif
Copyright 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#include "keduvocwordtype.h"
+#include "qmvocwordtype.h"
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
#include <QtCore/QList>
#include <QtCore/QSet>
-class KEduVocWordType::Private
+class QmVocWordType::Private
{
public:
// bitvector of word type flags
- KEduVocWordFlags m_flags;
- QList<KEduVocExpression*> m_expressions;
+ QmVocWordFlags m_flags;
+ QList<QmVocExpression*> m_expressions;
// list of translations
- QList<KEduVocTranslation*> m_translations;
+ QList<QmVocTranslation*> m_translations;
};
-KEduVocWordType::KEduVocWordType(const QString& name, KEduVocWordType *parent)
- : KEduVocContainer(name, WordType, parent), d( new Private )
+QmVocWordType::QmVocWordType(const QString& name, QmVocWordType *parent)
+ : QmVocContainer(name, WordType, parent), d( new Private )
{}
-KEduVocWordType::~KEduVocWordType()
+QmVocWordType::~QmVocWordType()
{
- foreach(KEduVocTranslation* translation, d->m_translations) {
+ foreach(QmVocTranslation* translation, d->m_translations) {
translation->setWordType(0);
}
delete d;
}
-QList<KEduVocExpression*> KEduVocWordType::entries(EnumEntriesRecursive recursive)
+QList<QmVocExpression*> QmVocWordType::entries(EnumEntriesRecursive recursive)
{
if (recursive == Recursive) {
return entriesRecursive();
return d->m_expressions;
}
-int KEduVocWordType::entryCount(EnumEntriesRecursive recursive)
+int QmVocWordType::entryCount(EnumEntriesRecursive recursive)
{
if (recursive == Recursive) {
return entriesRecursive().count();
return d->m_expressions.count();
}
-void KEduVocWordType::addTranslation(KEduVocTranslation* translation)
+void QmVocWordType::addTranslation(QmVocTranslation* translation)
{
// add to expression - if not already there because another translation of the same word is there.
bool found = false;
invalidateChildLessonEntries();
}
-void KEduVocWordType::removeTranslation(KEduVocTranslation* translation)
+void QmVocWordType::removeTranslation(QmVocTranslation* translation)
{
d->m_translations.removeAt( d->m_translations.indexOf(translation) );
invalidateChildLessonEntries();
}
-KEduVocTranslation * KEduVocWordType::translation(int row)
+QmVocTranslation * QmVocWordType::translation(int row)
{
return d->m_translations.value(row);
}
-KEduVocExpression * KEduVocWordType::entry(int row, EnumEntriesRecursive recursive)
+QmVocExpression * QmVocWordType::entry(int row, EnumEntriesRecursive recursive)
{
if (recursive == Recursive) {
return entriesRecursive().value(row);
return entries().value(row);
}
-KEduVocWordFlags KEduVocWordType::wordType() const
+QmVocWordFlags QmVocWordType::wordType() const
{
return d->m_flags;
}
-void KEduVocWordType::setWordType(KEduVocWordFlags flags)
+void QmVocWordType::setWordType(QmVocWordFlags flags)
{
d->m_flags = flags;
}
-KEduVocWordType* KEduVocWordType::childOfType(const KEduVocWordFlags& flags)
+QmVocWordType* QmVocWordType::childOfType(const QmVocWordFlags& flags)
{
if(d->m_flags == flags) {
return this;
}
- foreach(KEduVocContainer* child, childContainers()) {
- KEduVocWordType* result = static_cast<KEduVocWordType*>(child)->childOfType(flags);
+ foreach(QmVocContainer* child, childContainers()) {
+ QmVocWordType* result = static_cast<QmVocWordType*>(child)->childOfType(flags);
if(result) {
return result;
}
Copyright 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+ Copyright (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCWORDTYPE_H
-#define KEDUVOCWORDTYPE_H
+#ifndef QMVOCWORDTYPE_H
+#define QMVOCWORDTYPE_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
-#include "keduvoccontainer.h"
+#include "qmvoccontainer.h"
-#include "keduvocwordflags.h"
+#include "qmvocwordflags.h"
#include <QtCore/QList>
#include <QtCore/QString>
-class KEduVocExpression;
-class KEduVocTranslation;
+class QmVocExpression;
+class QmVocTranslation;
/** class to store translation word types */
-class KEDUVOCDOCUMENT_EXPORT KEduVocWordType :public KEduVocContainer
+class QMVOCDOCUMENT_EXPORT QmVocWordType :public QmVocContainer
{
public:
/** default constructor */
- explicit KEduVocWordType(const QString& name, KEduVocWordType *parent = 0);
+ explicit QmVocWordType(const QString& name, QmVocWordType *parent = 0);
/** destructor */
- ~KEduVocWordType();
+ ~QmVocWordType();
/** assignment operator */
-// KEduVocWordType& operator= ( const KEduVocWordType& );
+// QmVocWordType& operator= ( const QmVocWordType& );
/**
* Internally (different from the name) the class can have one of the preset word types. These are used to determine special properties (verbs have conjugations available for example).
* @param type
*/
- void setWordType(KEduVocWordFlags flags);
+ void setWordType(QmVocWordFlags flags);
/**
* Return the raw WordTypeFlags. Returns NoInformation if no flags are set.
* @return WordTypeFlags
*/
- KEduVocWordFlags wordType() const;
+ QmVocWordFlags wordType() const;
/**
* Return a child class (or this class) that is of the specified type. Returns 0 if no class of that type is found.
* @param type
* @return
*/
- KEduVocWordType* childOfType(const KEduVocWordFlags& flags);
+ QmVocWordType* childOfType(const QmVocWordFlags& flags);
/**
* The word type class does keep track of individual translations, because for one entry, the translations can have different word types (eg. genders of nouns tend to be different in different langues).
* @param row
* @return
*/
- KEduVocTranslation * translation(int row);
+ QmVocTranslation * translation(int row);
/**
* get a list of all entries in the lesson
* @param recursive include entries in sublessons
* @return
*/
- QList < KEduVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
+ QList < QmVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
- KEduVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive);
+ QmVocExpression* entry(int row, EnumEntriesRecursive recursive = NotRecursive);
/** get the number of entries in the lesson */
int entryCount(EnumEntriesRecursive recursive = NotRecursive);
/** add an entry to the lesson
* @param entryid id of the entry to add
*/
- void addTranslation(KEduVocTranslation* translation);
+ void addTranslation(QmVocTranslation* translation);
/** remove an entry from the lesson
* @param entryid id of the entry to remove
*/
- void removeTranslation(KEduVocTranslation* translation);
+ void removeTranslation(QmVocTranslation* translation);
- friend class KEduVocTranslation;
+ friend class QmVocTranslation;
};
#endif
***************************************************************************/
/***************************************************************************
- read a KEduVocDocument from a WQL file
+ read a QmVocDocument from a WQL file
-----------------------------------------------------------------------
copyright : (C) 2004, 2007, 2008 Peter Hedlund <peter.hedlund@kdemail.net>
(C) 2005 Eric Pignet
* *
***************************************************************************/
-#include "keduvocwqlreader.h"
+#include "qmvocwqlreader.h"
#include <QTextStream>
#include <QIODevice>
// #include <KLocale>
-#include "keduvocdocument.h"
-#include "keduvocexpression.h"
+#include "qmvocdocument.h"
+#include "qmvocexpression.h"
-KEduVocWqlReader::KEduVocWqlReader( QIODevice *file )
+QmVocWqlReader::QmVocWqlReader( QIODevice *file )
{
// the file must be already open
m_inputFile = file;
}
-bool KEduVocWqlReader::readDoc( KEduVocDocument *doc )
+bool QmVocWqlReader::readDoc( QmVocDocument *doc )
{
m_doc = doc;
if ( inputStream.atEnd() )
return false;
- KEduVocLesson* lesson = new KEduVocLesson( "Vocabulary", m_doc->lesson());
+ QmVocLesson* lesson = new QmVocLesson( "Vocabulary", m_doc->lesson());
m_doc->lesson()->appendChildContainer(lesson);
s = inputStream.readLine();
QString b;
b = inputStream.readLine();
- KEduVocExpression * expr = new KEduVocExpression( s );
+ QmVocExpression * expr = new QmVocExpression( s );
expr->setTranslation( 1, b );
lesson->appendEntry( expr );
}
***************************************************************************/
/***************************************************************************
- read a KEduVocDocument from a WQL file
+ read a QmVocDocument from a WQL file
-----------------------------------------------------------------------
copyright : (C) 2004, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
: (c) 2005 Eric Pignet
+ : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCWQLREADER_H
-#define KEDUVOCWQLREADER_H
+#ifndef QMVOCWQLREADER_H
+#define QMVOCWQLREADER_H
#include <QString>
class QIODevice;
-class KEduVocDocument;
+class QmVocDocument;
-class KEduVocWqlReader
+class QmVocWqlReader
{
public:
- KEduVocWqlReader( QIODevice *file );
+ QmVocWqlReader( QIODevice *file );
- bool readDoc( KEduVocDocument *doc );
+ bool readDoc( QmVocDocument *doc );
QString errorMessage() const
{
private:
QIODevice *m_inputFile;
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
QString m_errorMessage;
};
***************************************************************************/
/***************************************************************************
- create a KEduVocDocument from a XDXF file
+ create a QmVocDocument from a XDXF file
-----------------------------------------------------------------------
copyright : (C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
* *
***************************************************************************/
-#include "keduvocxdxfreader.h"
+#include "qmvocxdxfreader.h"
#include <QIODevice>
// #include <KLocale>
-#include "keduvocexpression.h"
-#include "keduvocdocument.h"
+#include "qmvocexpression.h"
+#include "qmvocdocument.h"
-KEduVocXdxfReader::KEduVocXdxfReader( KEduVocDocument *doc )
+QmVocXdxfReader::QmVocXdxfReader( QmVocDocument *doc )
{
m_doc = doc;
}
-bool KEduVocXdxfReader::read( QIODevice *device )
+bool QmVocXdxfReader::read( QIODevice *device )
{
setDevice( device );
}
-void KEduVocXdxfReader::readUnknownElement()
+void QmVocXdxfReader::readUnknownElement()
{
while ( !atEnd() ) {
readNext();
}
-void KEduVocXdxfReader::readXdxf()
+void QmVocXdxfReader::readXdxf()
{
///The language attributes are required and should be ISO 639-2 codes, but you never know...
QStringRef id1 = attributes().value( "lang_from" );
}
-void KEduVocXdxfReader::readEntry()
+void QmVocXdxfReader::readEntry()
{
QString front;
QString back;
back.append( text().toString() );
}
- KEduVocExpression expr = KEduVocExpression( front );
+ QmVocExpression expr = QmVocExpression( front );
expr.setTranslation( 1, back );
m_doc->lesson()->appendEntry( &expr );
}
***************************************************************************/
/***************************************************************************
- create a KEduVocDocument from a XDXF file
+ create a QmVocDocument from a XDXF file
-----------------------------------------------------------------------
copyright : (C) 2007 Peter Hedlund <peter.hedlund@kdemail.net>
+ Copyright : (C) 2010 Reto Zingg <g.d0b3rm4n@gmail.com>
***************************************************************************/
* *
***************************************************************************/
-#ifndef KEDUVOCXDXFREADER_H
-#define KEDUVOCXDXFREADER_H
+#ifndef QMVOCXDXFREADER_H
+#define QMVOCXDXFREADER_H
#include <QXmlStreamReader>
class QIODevice;
-class KEduVocDocument;
+class QmVocDocument;
-class KEduVocXdxfReader : public QXmlStreamReader
+class QmVocXdxfReader : public QXmlStreamReader
{
public:
- KEduVocXdxfReader( KEduVocDocument *doc );
+ QmVocXdxfReader( QmVocDocument *doc );
bool read( QIODevice *device );
void readXdxf();
void readEntry();
- KEduVocDocument *m_doc;
+ QmVocDocument *m_doc;
};
#endif
#include "sharedkvtmlfiles.h"
-#include "keduvocdocument.h"
+#include "qmvocdocument.h"
// #include <kio/copyjob.h>
// #include <kio/job.h>
// }
// }
//
-// KEduVocDocument *doc = new KEduVocDocument();
+// QmVocDocument *doc = new QmVocDocument();
// for ( int i = 0; i < this->m_fileList.size(); ++i ) {
//
// // open the file
// QString( "kvtml/*.kvtml" ) );
//
//
-// KEduVocDocument doc;
+// QmVocDocument doc;
//
// while ( !unsortedFiles.isEmpty() ) {
// KUrl fileUrl( KUrl::fromPath( unsortedFiles.first() ) );
#ifndef SHAREDKVTMLFILES_H
#define SHAREDKVTMLFILES_H
-#include "libkeduvocdocument_export.h"
+#include "libqmvocdocument_export.h"
#include <QtCore/QStringList>
namespace SharedKvtmlFiles
{
/** get list of all languages found in any files */
- KEDUVOCDOCUMENT_EXPORT QStringList languages();
+ QMVOCDOCUMENT_EXPORT QStringList languages();
/** get list of filenames found of given language
*@param language language requested QString() for all languages
*@return a list of filenames with words in language
*/
- KEDUVOCDOCUMENT_EXPORT QStringList fileNames( const QString &language = QString() );
+ QMVOCDOCUMENT_EXPORT QStringList fileNames( const QString &language = QString() );
/** get the list of document titles found of a given language
*@param language requested language QString() for all titles
*@return a list of document titles with words in language
*/
- KEDUVOCDOCUMENT_EXPORT QStringList titles( const QString &language = QString() );
+ QMVOCDOCUMENT_EXPORT QStringList titles( const QString &language = QString() );
/** get the list of document remarks found of a given language
*@param language requested language QString() for all comments
*@return a list of document remarks with words in language
*/
- KEDUVOCDOCUMENT_EXPORT QStringList comments( const QString &language = QString() );
+ QMVOCDOCUMENT_EXPORT QStringList comments( const QString &language = QString() );
/** rescan the shared kvtml locations */
- KEDUVOCDOCUMENT_EXPORT void rescan();
+ QMVOCDOCUMENT_EXPORT void rescan();
/** sort files downloaded to kvtml top-level dir into locale sub-folders */
- KEDUVOCDOCUMENT_EXPORT void sortDownloadedFiles();
+ QMVOCDOCUMENT_EXPORT void sortDownloadedFiles();
}
#endif
GIT / libqmvoc.git / commitdiff