// KEduVocDocument
//********************************************************
-KEduVocDocument::KEduVocDocument(QObject *parent)
+KEduVocDocument::KEduVocDocument(QObject */*parent*/)
{
Init();
}
void KEduVocDocument::setVersion (const QString & vers)
{
- doc_version = vers;
+ m_version = vers;
}
void KEduVocDocument::Init ()
{
- lesson_descr.clear();
- type_descr.clear();
- tense_descr.clear();
- langs.clear();
- sort_lang.clear();
- extraSizehints.clear();
- sizehints.clear();
- vocabulary.clear();
- dirty = false;
- sort_allowed = true;
- unknown_attr = false;
- unknown_elem = false;
- sort_lesson = false;
+ m_lessonDescriptions.clear();
+ m_typeDescriptions.clear();
+ m_tenseDescriptions.clear();
+ m_languages.clear();
+ m_sortLanguage.clear();
+ m_extraSizeHints.clear();
+ m_sizeHints.clear();
+ m_vocabulary.clear();
+ m_dirty = false;
+ m_enableSorting = true;
+ m_unknownAttribute = false;
+ m_unknownElement = false;
+ m_sortLesson = false;
setCurrentLesson (0);
- queryorg = "";
- querytrans = "";
- doc_url.setFileName(i18n("Untitled"));
- doctitle = "";
+ m_queryorg = "";
+ m_querytrans = "";
+ m_url.setFileName(i18n("Untitled"));
+ m_title = "";
m_author = "";
- doc_remark = "";
- doc_version = "";
+ m_remark = "";
+ m_version = "";
m_font = NULL;
- activeLeitnerSystem = false;
+ m_activeLeitnerSystem = false;
m_leitnerSystem = NULL;
}
-bool KEduVocDocument::open(const KURL& url, bool append)
+bool KEduVocDocument::open(const KURL& url, bool /*append*/)
{
Init();
if (!url.isEmpty())
- doc_url = url;
+ m_url = url;
// TODO EPT connect( this, SIGNAL(progressChanged(KEduVocDocument*,int)), parent, SLOT(slotProgress(KEduVocDocument*,int)) );
return false;
}
- FileType ft = detectFT(url.path());
+ FileType ft = detectFileType(url.path());
bool read = false;
while (!read) {
QApplication::restoreOverrideCursor();
if (!read) {
- if (unknown_attr || unknown_elem ) {
+ if (m_unknownAttribute || m_unknownElement ) {
Init();
return false;
}
if ( result == KMessageBox::Cancel ) return false;
}
}
- doc_url = tmp;
- dirty = false;
+ m_url = tmp;
+ m_dirty = false;
emit docModified(false);
return true;
}
KEduVocExpression *KEduVocDocument::entry(int index)
{
- if (index < 0 || index >= (int)vocabulary.size() )
+ if (index < 0 || index >= (int)m_vocabulary.size() )
return 0;
else
- return &vocabulary[index];
+ return &m_vocabulary[index];
}
void KEduVocDocument::removeEntry(int index)
{
- if (index >= 0 && index < (int)vocabulary.size() )
- vocabulary.erase (vocabulary.begin() + index);
+ if (index >= 0 && index < (int)m_vocabulary.size() )
+ m_vocabulary.erase(m_vocabulary.at(index));
}
-int KEduVocDocument::findIdent (const QString &lang) const
+int KEduVocDocument::findIdentifier(const QString &lang) const
{
- vector<QString>::const_iterator first = langs.begin();
+ QStringList::const_iterator first = m_languages.begin();
int count = 0;
- while (first != langs.end()) {
+ while (first != m_languages.end()) {
if ( *first == lang)
return count;
first++;
}
-QString KEduVocDocument::ident (int index) const
+QString KEduVocDocument::identifier(int index) const
{
- if (index >= (int)langs.size() || index < 1 )
+ if (index >= (int)m_languages.size() || index < 1 )
return "";
else
- return langs[index];
+ return m_languages[index];
}
-void KEduVocDocument::setIdent (int idx, const QString &id)
+void KEduVocDocument::setIdentifier(int idx, const QString &id)
{
- if (idx < (int)langs.size() && idx >= 1 ) {
- langs[idx] = id;
+ if (idx < (int)m_languages.size() && idx >= 1 ) {
+ m_languages[idx] = id;
}
}
QString KEduVocDocument::typeName (int index) const
{
- if (index >= (int)type_descr.size())
+ if (index >= (int)m_typeDescriptions.count())
return "";
else
- return type_descr[index];
+ return m_typeDescriptions[index];
}
-void KEduVocDocument::setTypeName (int idx, QString &id)
+void KEduVocDocument::setTypeName(int idx, QString &id)
{
- if (idx >= (int)type_descr.size())
- for (int i = (int)type_descr.size(); i <= idx; i++)
- type_descr.push_back ("");
+ if (idx >= (int)m_typeDescriptions.size())
+ for (int i = (int)m_typeDescriptions.size(); i <= idx; i++)
+ m_typeDescriptions.push_back ("");
- type_descr[idx] = id;
+ m_typeDescriptions[idx] = id;
}
-QString KEduVocDocument::tenseName (int index) const
+QString KEduVocDocument::tenseName(int index) const
{
- if (index >= (int)tense_descr.size())
+ if (index >= (int)m_tenseDescriptions.size())
return "";
else
- return tense_descr[index];
+ return m_tenseDescriptions[index];
}
-void KEduVocDocument::setTenseName (int idx, QString &id)
+void KEduVocDocument::setTenseName(int idx, QString &id)
{
- if (idx >= (int)tense_descr.size())
- for (int i = (int)tense_descr.size(); i <= idx; i++)
- tense_descr.push_back ("");
+ if (idx >= (int)m_tenseDescriptions.size())
+ for (int i = (int)m_tenseDescriptions.size(); i <= idx; i++)
+ m_tenseDescriptions.push_back ("");
- tense_descr[idx] = id;
+ m_tenseDescriptions[idx] = id;
}
-QString KEduVocDocument::usageName (int index) const
+QString KEduVocDocument::usageName(int index) const
{
- if (index >= (int)usage_descr.size())
+ if (index >= (int)m_usageDescriptions.size())
return "";
else
- return usage_descr[index];
+ return m_usageDescriptions[index];
}
-void KEduVocDocument::setUsageName (int idx, QString &id)
+void KEduVocDocument::setUsageName(int idx, QString &id)
{
- if (idx >= (int)usage_descr.size())
- for (int i = (int)usage_descr.size(); i <= idx; i++)
- usage_descr.push_back ("");
+ if (idx >= (int)m_usageDescriptions.size())
+ for (int i = (int)m_usageDescriptions.size(); i <= idx; i++)
+ m_usageDescriptions.push_back ("");
- usage_descr[idx] = id;
+ m_usageDescriptions[idx] = id;
}
-void KEduVocDocument::setConjugation (int idx, const Conjugation &con)
+void KEduVocDocument::setConjugation(int idx, const Conjugation &con)
{
if ( idx < 0) return;
// extend conjugation with empty elements
- if ((int)conjugations.size() <= idx )
- for (int i = conjugations.size(); i < idx+1; i++)
- conjugations.push_back (Conjugation());
+ if ((int)m_conjugations.size() <= idx )
+ for (int i = m_conjugations.size(); i < idx+1; i++)
+ m_conjugations.push_back (Conjugation());
- conjugations[idx] = con;
+ m_conjugations[idx] = con;
}
Conjugation KEduVocDocument::conjugation (int idx) const
{
- if (idx >= (int)conjugations.size() || idx < 0) {
+ if (idx >= (int)m_conjugations.size() || idx < 0) {
return Conjugation();
}
else {
- return conjugations[idx];
+ return m_conjugations[idx];
}
}
-void KEduVocDocument::setArticle (int idx, const Article &art)
+void KEduVocDocument::setArticle(int idx, const Article &art)
{
if ( idx < 0) return;
// extend conjugation with empty elements
- if ((int)articles.size() <= idx )
- for (int i = articles.size(); i < idx+1; i++)
- articles.push_back (Article());
+ if ((int)m_articles.size() <= idx )
+ for (int i = m_articles.size(); i < idx+1; i++)
+ m_articles.push_back (Article());
- articles[idx] = art;
+ m_articles[idx] = art;
}
Article KEduVocDocument::article (int idx) const
{
- if (idx >= (int)articles.size() || idx < 0) {
+ if (idx >= (int)m_articles.size() || idx < 0) {
return Article();
}
else {
- return articles[idx];
+ return m_articles[idx];
}
}
{
if (idx < 0) {
idx = -idx;
- if (idx >= (int)extraSizehints.size() )
+ if (idx >= (int)m_extraSizeHints.size() )
return 80; // make a good guess about column size
else {
// cout << "gsh " << idx << " " << extraSizehints[idx] << endl;
- return extraSizehints[idx];
+ return m_extraSizeHints[idx];
}
}
else {
- if (idx >= (int)sizehints.size() )
+ if (idx >= (int)m_sizeHints.size() )
return 150; // make a good guess about column size
else {
// cout << "gsh " << idx << " " << sizehints[idx] << endl;
- return sizehints[idx];
+ return m_sizeHints[idx];
}
}
}
// cout << "ssh " << idx << " " << width << endl;
if (idx < 0) {
idx = -idx;
- if (idx >= (int)extraSizehints.size()) {
- for (int i = (int)extraSizehints.size(); i <= idx; i++)
- extraSizehints.push_back (80);
+ if (idx >= (int)m_extraSizeHints.size()) {
+ for (int i = (int)m_extraSizeHints.size(); i <= idx; i++)
+ m_extraSizeHints.push_back (80);
}
- extraSizehints[idx] = width;
+ m_extraSizeHints[idx] = width;
}
else {
- if (idx >= (int)sizehints.size()) {
- for (int i = (int)sizehints.size(); i <= idx; i++)
- sizehints.push_back (150);
+ if (idx >= (int)m_sizeHints.size()) {
+ for (int i = (int)m_sizeHints.size(); i <= idx; i++)
+ m_sizeHints.push_back (150);
}
- sizehints[idx] = width;
+ m_sizeHints[idx] = width;
}
}
};
-void KEduVocDocument::removeIdent (int index)
+void KEduVocDocument::removeIdentifier(int index)
{
- if (index < (int)langs.size() && index >= 1 ) {
- langs.erase(langs.begin() + index);
- for_each (vocabulary.begin(), vocabulary.end(), eraseTrans(index));
+ if (index < (int)m_languages.size() && index >= 1 ) {
+ m_languages.erase(m_languages.at(index));
+ for_each (m_vocabulary.begin(), m_vocabulary.end(), eraseTrans(index));
}
}
-QString KEduVocDocument::originalIdent () const
+QString KEduVocDocument::originalIdentifier() const
{
- if (langs.size() > 0)
- return langs[0];
+ if (m_languages.size() > 0)
+ return m_languages[0];
else
return "";
}
-void KEduVocDocument::setOriginalIdent (const QString &id)
+void KEduVocDocument::setOriginalIdentifier(const QString &id)
{
- if (langs.size() > 0) {
- langs[0] = id;
+ if (m_languages.size() > 0) {
+ m_languages[0] = id;
}
}
if (x.lesson() != y.lesson() )
return
!dir
- ? (QString::compare(doc.lessonDescr(x.lesson()).upper(),
- doc.lessonDescr(y.lesson()).upper() ) < 0)
- : (QString::compare(doc.lessonDescr(x.lesson()).upper(),
- doc.lessonDescr(y.lesson()).upper() ) > 0);
+ ? (QString::compare(doc.lessonDescription(x.lesson()).upper(),
+ doc.lessonDescription(y.lesson()).upper() ) < 0)
+ : (QString::compare(doc.lessonDescription(x.lesson()).upper(),
+ doc.lessonDescription(y.lesson()).upper() ) > 0);
else
return
!dir
bool KEduVocDocument::sort (int index)
{
- if (!sort_allowed)
+ /*if (!sort_allowed)
return false;
if (index >= numLangs())
else
std::sort (vocabulary.begin(), vocabulary.end(), sortByTrans(index, sort_lang[index]));
sort_lang[index] = !sort_lang[index];
- return sort_lang[index];
+ return sort_lang[index];*/
}
-bool KEduVocDocument::sortByLesson_alpha ()
+bool KEduVocDocument::sortByLessonAlpha ()
{
- if (!sort_allowed)
+ /* if (!sort_allowed)
return false;
std::sort (vocabulary.begin(), vocabulary.end(), sortByLessonAndOrg_alpha(sort_lesson, *this ));
sort_lesson = !sort_lesson;
- return sort_lesson;
+ return sort_lesson;*/
}
-bool KEduVocDocument::sortByLesson_index ()
+bool KEduVocDocument::sortByLessonIndex ()
{
- if (!sort_allowed)
+ /* if (!sort_allowed)
return false;
if (sort_lang.size() < langs.size())
std::sort (vocabulary.begin(), vocabulary.end(), sortByLessonAndOrg_index(sort_lesson, *this ));
sort_lesson = !sort_lesson;
sort_lang[0] = sort_lesson;
- return sort_lesson;
+ return sort_lesson;*/
}
bool KEduVocDocument::leitnerSystemActive()
{
- return activeLeitnerSystem;
+ return m_activeLeitnerSystem;
}
void KEduVocDocument::setLeitnerSystemActive( bool yes )
if (m_leitnerSystem == 0)
createStandardLeitnerSystem(); //if nothing is loaded yet
- activeLeitnerSystem = true;
+ m_activeLeitnerSystem = true;
}
else if( !yes )
- activeLeitnerSystem = false;
+ m_activeLeitnerSystem = false;
}
void KEduVocDocument::createStandardLeitnerSystem()
void KEduVocDocument::resetEntry (int index, int lesson)
{
if (index < 0)
- for_each (vocabulary.begin(), vocabulary.end(), resetAll(lesson) );
+ for_each (m_vocabulary.begin(), m_vocabulary.end(), resetAll(lesson) );
else
- for_each (vocabulary.begin(), vocabulary.end(), resetOne(index, lesson) );
+ for_each (m_vocabulary.begin(), m_vocabulary.end(), resetOne(index, lesson) );
}
-QString KEduVocDocument::lessonDescr(int idx) const
+QString KEduVocDocument::lessonDescription(int idx) const
{
if (idx == 0)
return i18n("<no lesson>");
- if (idx <= 0 || idx > (int) lesson_descr.size() )
+ if (idx <= 0 || idx > (int) m_lessonDescriptions.size() )
return "";
- return lesson_descr[idx-1];
+ return m_lessonDescriptions[idx-1];
}
-vector<int> KEduVocDocument::lessonsInQuery() const
+QValueList<int> KEduVocDocument::lessonsInQuery() const
{
- vector<int> iqvec;
- for (unsigned i = 0; i < lessons_in_query.size(); i++)
- if (lessons_in_query[i]) {
+ QValueList<int> iqvec;
+ for (unsigned i = 0; i < m_lessonsInQuery.size(); i++)
+ if (m_lessonsInQuery[i]) {
iqvec.push_back(i+1); // Offset <no lesson>
// cout << "getliq: " << i+1 << endl;
}
}
-void KEduVocDocument::setLessonsInQuery(vector<int> lesson_iq)
+void KEduVocDocument::setLessonsInQuery(QValueList<int> lesson_iq)
{
- lessons_in_query.clear();
- for (unsigned i = 0; i < lesson_descr.size(); i++)
- lessons_in_query.push_back(false);
+ m_lessonsInQuery.clear();
+ for (unsigned i = 0; i < m_lessonDescriptions.size(); i++)
+ m_lessonsInQuery.push_back(false);
for (unsigned i = 0; i < lesson_iq.size(); i++)
- if (lesson_iq[i] <= (int) lessons_in_query.size() ) {
- lessons_in_query[lesson_iq[i]-1] = true; // Offset <no lesson>
+ if (lesson_iq[i] <= (int) m_lessonsInQuery.size() ) {
+ m_lessonsInQuery[lesson_iq[i]-1] = true; // Offset <no lesson>
// cout << "setliq: " << lesson_iq[i] << " " << i << endl;
}
}
QString KEduVocDocument::title() const
{
- if (doctitle.isEmpty())
- return doc_url.fileName();
+ if (m_title.isEmpty())
+ return m_url.fileName();
else
- return doctitle;
+ return m_title;
}
QString KEduVocDocument::docRemark() const
{
- return doc_remark;
+ return m_remark;
}
void KEduVocDocument::setTitle(const QString & title)
{
- doctitle = title.stripWhiteSpace();
+ m_title = title.stripWhiteSpace();
}
void KEduVocDocument::setDocRemark(const QString & s)
{
- doc_remark = s.stripWhiteSpace();
+ m_remark = s.stripWhiteSpace();
}
if (first < 0)
first = 0;
- if (id >= numLangs()
+ if (id >= numLanguages()
|| last < first
)
return -1;
}
-KEduVocDocument::FileType KEduVocDocument::detectFT(const QString &filename)
+KEduVocDocument::FileType KEduVocDocument::detectFileType(const QString &filename)
{
QFile f( filename );
if (!f.open( IO_ReadOnly ))
vector<expRef> shadow;
vector<int> to_delete;
- for (int i = 0; i < (int) vocabulary.size(); i++)
+ for (int i = 0; i < (int) m_vocabulary.size(); i++)
shadow.push_back (expRef (entry(i), i));
std::sort(shadow.begin(), shadow.end());
#endif
int ent_no = 0;
- int ent_percent = vocabulary.size () / 100;
- float f_ent_percent = vocabulary.size () / 100.0;
+ int ent_percent = m_vocabulary.size () / 100;
+ float f_ent_percent = m_vocabulary.size () / 100.0;
emit progressChanged(this, 0);
for (int i = shadow.size()-1; i > 0; i--) {
bool equal = true;
if (kve1->original() == kve2->original() ) {
- for (int l = 1; equal && l < (int) numLangs(); l++ )
+ for (int l = 1; equal && l < (int) numLanguages(); l++ )
if (kve1->translation(l) != kve2->translation(l))
equal = false;
kvtbin,
vt_lex, vt_vcb, csv /*, kvoclearn, qvocab*/ };
- /** Constructor for the fileclass of the application
+ /** Constructor for a KdeEdu vocabulary document
*
* @param obj calling object
*/
- KEduVocDocument(QObject* obj);
+ KEduVocDocument(QObject* parent);
- /** Destructor for the fileclass of the application */
+ /** Destructor for the document class */
~KEduVocDocument();
- /** indicates that doc is (not) modified
+ /** indicates if the document is modified
*
* @param dirty new state
*/
- inline void setModified (bool _dirty = true) { emit docModified(dirty = _dirty); }
+ inline void setModified (bool dirty = true) { emit docModified(m_dirty = dirty); }
- /** appends another entry at the end
+ /** appends a new expression to the end of the vocabulary
*
* @param expr expression to append
*/
- inline void appendEntry (KEduVocExpression *expr)
- { vocabulary.push_back (*expr); dirty = true; }
+ inline void appendEntry (KEduVocExpression *expression)
+ { m_vocabulary.append(*expression); m_dirty = true; }
- /** insert an entry
+ /** inserts a new expression
*
- * @param expr expression to append
+ * @param expr expression to insert
* @param index index of entry
*/
- inline void insertEntry(KEduVocExpression *expr, int index)
- { vocabulary.insert(vocabulary.begin()+index, *expr); dirty = true; }
+ inline void insertEntry(KEduVocExpression *expression, int index)
+ { m_vocabulary.insert(m_vocabulary.at(index), *expression); m_dirty = true; }
- /** removes entry from doc
+ /** removes an expression from the document
*
- * @param index index of entry
+ * @param index index of expression
*/
- void removeEntry (int index);
+ void removeEntry(int index);
- /** removes all entries from doc (clears vocabulary)
+ /** removes all expressions from the document (clears vocabulary)
*/
- inline void removeAllEntries ()
- { vocabulary.clear(); dirty = true; }
+ inline void removeAllEntries()
+ { m_vocabulary.clear(); m_dirty = true; }
/** sorts vocabulary alphabetically
*
* @param index index expression
* @result direction of sorting: true = ascending
*/
- bool sort (int index);
+ bool sort(int index);
/** removes equal entries (orig + all translations)
*
/** sorts vocabulary by lesson indices
* @result direction of sorting: true = ascending
*/
- bool sortByLesson_index ();
+ bool sortByLessonIndex();
/** sorts vocabulary by lesson name
* @result direction of sorting: true = ascending
*/
- bool sortByLesson_alpha ();
+ bool sortByLessonAlpha();
/** enables sorting
*/
- inline void allowSorting(bool allow) { sort_allowed = allow; }
+ inline void enableSorting(bool enable) { m_enableSorting = enable; }
- /** enables sorting
+ /** returns whether sorting is enabled
*/
- inline bool isAllowedSorting() { return sort_allowed; }
+ inline bool isSortingEnabled() { return m_enableSorting; }
/** returns the modification state of the doc */
- inline bool isModified () const { return dirty; }
+ inline bool isModified() const { return m_dirty; }
/** returns originals identifier
*/
- QString originalIdent () const;
+ QString originalIdentifier() const;
/** set originals identifier
*/
- void setOriginalIdent (const QString &id);
+ void setOriginalIdentifier(const QString &id);
/** returns identifier of translation x
*
* @param index number of translation 1..x
* @result ident string: de=german, en=englisch, ..
*/
- QString ident (int index) const;
+ QString identifier(int index) const;
/** sets identifier of translation
*
* @param index number of translation 1..x
* @param lang ident string: de=german, en=englisch, ..
*/
- void setIdent (int index, const QString &lang);
+ void setIdentifier(int index, const QString &lang);
/** removes identifier an the according translation in all entries
*
* @param index number of translation 1..x
*/
- void removeIdent (int index);
+ void removeIdentifier(int index);
/** determines if given translation is available and where
*
* @param lang identifier of language
* @result index of translation, 0=original, -1=none
*/
- int findIdent (const QString &lang) const;
+ int findIdentifier(const QString &lang) const;
/** returns attribute string
*
* @param index number of attribute
* @result string
*/
- QString typeName (int index) const;
+ QString typeName(int index) const;
/** sets attribute string
*
* @param index number of attribute
* @param str name of attribute
*/
- void setTypeName (int index, QString &str);
+ void setTypeName(int index, QString &str);
/** gets descr of types */
- inline vector<QString> typeDescr() const { return type_descr; }
+ inline QStringList typeDescriptions() const { return m_typeDescriptions; }
/** sets descr of types */
- inline void setTypeDescr(vector<QString> names) { type_descr = names; }
+ inline void setTypeDescriptions(QStringList names) { m_typeDescriptions = names; }
/** returns tense string
*
* @param index number of tense
* @result string
*/
- QString tenseName (int index) const;
+ QString tenseName(int index) const;
/** sets tense string
*
* @param index number of tense
* @param str name of tense
*/
- void setTenseName (int index, QString &str);
+ void setTenseName(int index, QString &str);
/** gets descr of tenses */
- inline vector<QString> tenseDescr() const { return tense_descr; }
+ inline QStringList tenseDescriptions() const { return m_tenseDescriptions; }
/** sets descr of tenses */
- inline void setTenseDescr(vector<QString> names) { tense_descr = names; }
+ inline void setTenseDescriptions(QStringList names) { m_tenseDescriptions = names; }
/** returns usage string
*
* @param index number of usage
* @result string
*/
- QString usageName (int index) const;
+ QString usageName(int index) const;
/** sets usage string
*
* @param index number of usage
* @param str name of usage
*/
- void setUsageName (int index, QString &str);
+ void setUsageName(int index, QString &str);
/** gets descr of usages */
- inline vector<QString> usageDescr() const { return usage_descr; }
+ inline QStringList usageDescriptions() const { return m_usageDescriptions; }
/** sets descr of usages */
- inline void setUsageDescr(vector<QString> names) { usage_descr = names; }
+ inline void setUsageDescriptions(QStringList names) { m_usageDescriptions = names; }
/** open a document file
*
/** returns count of entries
*/
- inline int numEntries() const { return vocabulary.size(); }
+ inline int numEntries() const { return m_vocabulary.count(); }
/** sets grades to KV_NORM_GRADE, counts to 0 ...
*
* @param lesson lesson id, if this is 0 all lesson are affected,
* otherwise only matching numbers
*/
- void resetEntry (int index = -1, int lesson = 0);
+ void resetEntry(int index = -1, int lesson = 0);
/** returns count of different languages
*/
- inline int numLangs() const { return langs.size(); } // org + translations
+ inline int numLanguages() const { return m_languages.count(); } // org + translations
/** append new lang ident
*/
- inline void appendLang(const QString & id) { langs.push_back(id); }
+ inline void appendLanguage(const QString & id) { m_languages.append(id); }
/** returns pointer to expression object x
*
* @param tolerant
* @result index of found entry, -1 if none
*/
- int search(QString substr, int id,
- int first=0, int last=-1, bool word_start = false, bool tolerant=false);
+ int search(QString substr, int id, int first=0, int last=-1, bool word_start = false, bool tolerant=false);
/** returns url of xml file */
- inline KURL URL() const {return doc_url; }
+ inline KURL URL() const {return m_url; }
/** sets url of xml file */
- inline void setURL(const KURL& url) {doc_url = url;}
+ inline void setURL(const KURL& url) {m_url = url;}
/** returns title of xml file */
QString title() const;
QFont* font() const;
inline void queryLang(QString &org, QString &trans) const
- { org = queryorg; trans = querytrans; }
+ { org = m_queryorg; trans = m_querytrans; }
inline void setQueryLang(const QString &org, const QString &trans)
- { queryorg = org; querytrans = trans; }
+ { m_queryorg = org; m_querytrans = trans; }
/** sets title of xml file */
void setTitle(const QString & title);
void version(int &major, int &minor, int &patch);
/** returns current lesson index */
- inline int currentLesson() const { return current_lesson; }
+ inline int currentLesson() const { return m_currentLesson; }
/** sets current lesson index
* @param lesson index of lesson
*/
- inline void setCurrentLesson(int lesson) { current_lesson = lesson; }
+ inline void setCurrentLesson(int lesson) { m_currentLesson = lesson; }
/** returns descr of lesson */
- QString lessonDescr(int index) const;
+ QString lessonDescription(int index) const;
/** returns lessons in current query */
- vector<int> lessonsInQuery() const;
+ QValueList<int> lessonsInQuery() const;
/** sets lessons in current query */
- void setLessonsInQuery(vector<int>);
+ void setLessonsInQuery(QValueList<int>);
- inline vector<QString> lessonDescr() const { return lesson_descr; }
+ inline QStringList lessonDescriptions() const { return m_lessonDescriptions; }
- inline int numLessons () const {return (int) lesson_descr.size(); }
+ inline int numLessons () const {return (int) m_lessonDescriptions.count(); }
/** sets descr of lesson */
- inline void setLessonDescr(vector<QString> names) { lesson_descr = names; }
+ inline void setLessonDescriptions(QStringList names) { m_lessonDescriptions = names; }
/** returns pointer to conjugations if available
*
* @param index number of expr, -1 = lesson
* @result width of column
*/
- int sizeHint (int index) const;
+ int sizeHint(int index) const;
/** sets recommended size
*
void setLeitnerSystem( LeitnerSystem* system );
LeitnerSystem* leitnerSystem();
- bool unknownAttribute (int line, const QString &name, const QString &attr);
- void unknownElement (int line, const QString &elem );
- void errorKvtMl (int line, const QString &text );
- void warningKvtMl (int line, const QString &text );
-
- void errorLex (int line, const QString &text );
+ bool unknownAttribute(int line, const QString &name, const QString &attr);
+ void unknownElement(int line, const QString &elem );
+ void errorKvtMl(int line, const QString &text );
+ void warningKvtMl(int line, const QString &text );
- void errorCsv (int line, const QString &text );
+ void errorLex(int line, const QString &text );
- FileType detectFT(const QString &filename);
+ void errorCsv(int line, const QString &text );
- friend class QueryManager;
+ FileType detectFileType(const QString &filename);
signals:
void progressChanged (KEduVocDocument *, int curr_percent);
*/
private:
- bool dirty;
- KURL doc_url;
- vector<bool> sort_lang;
- bool sort_lesson;
- bool unknown_attr;
- bool unknown_elem;
- bool sort_allowed;
+ bool m_dirty;
+ KURL m_url;
+ QValueList<bool> m_sortLanguage;
+ bool m_sortLesson;
+ bool m_unknownAttribute;
+ bool m_unknownElement;
+ bool m_enableSorting;
// save these to document
- vector<QString> langs; //0= origin, 1,.. translations
- int cols,
- lines;
- int current_lesson;
- vector<int> extraSizehints;
- vector<int> sizehints;
- QFont* m_font;
-
- QString generator;
- QString queryorg,
- querytrans;
- vector<KEduVocExpression> vocabulary;
- vector<bool> lessons_in_query;
- vector<QString> lesson_descr;
- vector<QString> type_descr;
- vector<QString> tense_descr;
- vector<QString> usage_descr;
- QString doctitle;
- QString m_author;
- QString m_license;
- QString doc_remark;
- QString doc_version;
-
- vector<Article> articles;
- vector<Conjugation> conjugations;
+ QStringList m_languages; //0= origin, 1,.. translations
+ int m_cols;
+ int m_lines;
+ int m_currentLesson;
+ QValueList<int> m_extraSizeHints;
+ QValueList<int> m_sizeHints;
+ QFont* m_font;
+
+ QString m_generator;
+ QString m_queryorg;
+ QString m_querytrans;
+ QValueList<KEduVocExpression> m_vocabulary;
+ QValueList<bool> m_lessonsInQuery;
+ QStringList m_lessonDescriptions;
+ QStringList m_typeDescriptions;
+ QStringList m_tenseDescriptions;
+ QStringList m_usageDescriptions;
+ QString m_title;
+ QString m_author;
+ QString m_license;
+ QString m_remark;
+ QString m_version;
+
+ QValueList<Article> m_articles;
+ QValueList<Conjugation> m_conjugations;
LeitnerSystem* m_leitnerSystem;
- bool activeLeitnerSystem;
+ bool m_activeLeitnerSystem;
};
bool KEduVocKvtmlReader::readLesson(QDomElement &domElementParent)
{
QString s;
- m_doc->lesson_descr.clear();
+ m_doc->m_lessonDescriptions.clear();
//-------------------------------------------------------------------------
// Attributes
QDomAttr domAttrQuery = domElementChild.attributeNode(KV_LESS_QUERY);
if (!domAttrQuery.isNull())
- m_doc->lessons_in_query.push_back(domAttrQuery.value().toInt() != 0);
+ m_doc->m_lessonsInQuery.push_back(domAttrQuery.value().toInt() != 0);
else
- m_doc->lessons_in_query.push_back(false);
+ m_doc->m_lessonsInQuery.push_back(false);
//-----
// Text
s = domElementChild.text();
if (s.isNull())
s = "";
- m_doc->lesson_descr.push_back(s);
+ m_doc->m_lessonDescriptions.push_back(s);
}
else
{
bool inEntry = false;
int count = 0;
QString s;
- m_doc->articles.clear();
+ m_doc->m_articles.clear();
QDomElement domElementEntry = domElementParent.firstChild().toElement();
QString lang;
QDomAttr domAttrLang = domElementEntry.attributeNode(KV_LANG);
- if ((int)m_doc->langs.size() <= count)
+ if ((int)m_doc->m_languages.size() <= count)
{
// first entry
if (!domAttrLang.isNull()) // no definition in first entry
lang = domAttrLang.value();
else
lang = "original";
- m_doc->langs.push_back(lang);
+ m_doc->m_languages.push_back(lang);
}
else
{
- if (!domAttrLang.isNull() && domAttrLang.value() != m_doc->langs[count])
+ if (!domAttrLang.isNull() && domAttrLang.value() != m_doc->m_languages[count])
{
// different originals ?
domError(i18n("ambiguous definition of language code"));
domElementEntryChild = domElementEntryChild.nextSibling().toElement();
}
- m_doc->articles.push_back(Article( fem_def, fem_indef,
+ m_doc->m_articles.push_back(Article( fem_def, fem_indef,
mal_def, mal_indef,
nat_def, nat_indef));
bool KEduVocKvtmlReader::readConjug(QDomElement &domElementParent,
- vector<Conjugation> &curr_conjug,
+ QValueList<Conjugation> &curr_conjug,
const QString &entry_tag)
/*
<conjugation> used in header for definiton of "prefix"
QString lang;
QDomAttr domAttrLang = domElementConjugChild.attributeNode(KV_LANG);
- if ((int)m_doc->langs.size() <= count)
+ if ((int)m_doc->m_languages.size() <= count)
{
// first entry
if (!domAttrLang.isNull()) // no definition in first entry
lang = domAttrLang.value();
else
lang = "original";
- m_doc->langs.push_back(lang);
+ m_doc->m_languages.push_back(lang);
}
else
{
- if (!domAttrLang.isNull() && domAttrLang.value() != m_doc->langs[count])
+ if (!domAttrLang.isNull() && domAttrLang.value() != m_doc->m_languages[count])
{
// different originals ?
domError(i18n("ambiguous definition of language code"));
if (type.length() != 0 && type.left(1) == UL_USER_TENSE)
{
int num = QMIN(type.mid (1, 40).toInt(), 1000); // paranoia check
- if( num > (int) m_doc->tense_descr.size() )
+ if( num > (int) m_doc->m_tenseDescriptions.size() )
{
// description missing ?
QString s;
- for (int i = m_doc->tense_descr.size(); i < num; i++)
+ for (int i = m_doc->m_tenseDescriptions.size(); i < num; i++)
{
s.setNum (i+1);
s.insert (0, "#"); // invent descr according to number
- m_doc->tense_descr.push_back(s);
+ m_doc->m_tenseDescriptions.push_back(s);
}
}
}
{
if (domElementSort.tagName() == KV_OPT_SORT)
{
- m_doc->sort_allowed = true;
+ m_doc->m_enableSorting = true;
QDomAttr domAttrOn = domElementSort.attributeNode(KV_BOOL_FLAG);
if (!domAttrOn.isNull())
{
bool ok = true;
- m_doc->sort_allowed = domAttrOn.value().toInt(&ok); // returns 0 if the conversion fails
+ m_doc->m_enableSorting = domAttrOn.value().toInt(&ok); // returns 0 if the conversion fails
if (!ok)
- m_doc->sort_allowed = true;
+ m_doc->m_enableSorting = true;
}
}
bool KEduVocKvtmlReader::readType(QDomElement &domElementParent)
{
QString s;
- m_doc->type_descr.clear();
+ m_doc->m_typeDescriptions.clear();
QDomElement domElementDesc = domElementParent.firstChild().toElement();
if (s.isNull())
s = "";
- m_doc->type_descr.push_back (s);
+ m_doc->m_typeDescriptions.push_back (s);
}
else
{
bool KEduVocKvtmlReader::readTense(QDomElement &domElementParent)
{
QString s;
- m_doc->tense_descr.clear();
+ m_doc->m_tenseDescriptions.clear();
QDomElement domElementDesc = domElementParent.firstChild().toElement();
if (s.isNull())
s = "";
- m_doc->tense_descr.push_back (s);
+ m_doc->m_tenseDescriptions.push_back (s);
}
else
{
bool KEduVocKvtmlReader::readUsage(QDomElement &domElementParent)
{
QString s;
- m_doc->usage_descr.clear();
+ m_doc->m_usageDescriptions.clear();
QDomElement domElementDesc = domElementParent.firstChild().toElement();
if (s.isNull())
s = "";
- m_doc->usage_descr.push_back (s);
+ m_doc->m_usageDescriptions.push_back (s);
}
else
{
if (usage.length() != 0 && usage.left(1) == UL_USER_USAGE)
{
int num = QMIN(usage.mid (1, 40).toInt(), 1000); // paranioa check
- if( num > (int) m_doc->usage_descr.size() )
+ if( num > (int) m_doc->m_usageDescriptions.size() )
{
// description missing ?
QString s;
- for (int i = m_doc->usage_descr.size(); i < num; i++)
+ for (int i = m_doc->m_usageDescriptions.size(); i < num; i++)
{
s.setNum (i+1);
s.insert (0, "#"); // invent descr according to number
- m_doc->usage_descr.push_back (s);
+ m_doc->m_usageDescriptions.push_back (s);
}
}
}
if (type.length() != 0 && type.left(1) == QM_USER_TYPE)
{
int num = QMIN(type.mid (1, 40).toInt(), 1000); // paranoia check
- if( num > (int) m_doc->type_descr.size() )
+ if( num > (int) m_doc->m_typeDescriptions.size() )
{
// description missing ?
QString s;
- for (int i = m_doc->type_descr.size(); i < num; i++)
+ for (int i = m_doc->m_typeDescriptions.size(); i < num; i++)
{
s.setNum (i+1);
s.insert (0, "#"); // invent descr according to number
- m_doc->type_descr.push_back (s);
+ m_doc->m_typeDescriptions.push_back (s);
}
}
}
QString antonym;
QString usage;
QString paraphrase;
- vector<Conjugation> conjug;
+ QValueList<Conjugation> conjug;
Comparison comparison;
MultipleChoice mc;
if (exprtype.length() != 0 && exprtype.left(1) == QM_USER_TYPE)
{
int num = QMIN(exprtype.mid (1, 40).toInt(), 1000); // paranoia check
- if( num > (int) m_doc->type_descr.size() )
+ if( num > (int) m_doc->m_typeDescriptions.size() )
{
// description missing ?
QString s;
- for (int i = m_doc->type_descr.size(); i < num; i++)
+ for (int i = m_doc->m_typeDescriptions.size(); i < num; i++)
{
s.setNum (i+1);
s.insert (0, "#"); // invent descr according to number
- m_doc->type_descr.push_back (s);
+ m_doc->m_typeDescriptions.push_back (s);
}
}
}
}
- if (lesson && lesson > (int) m_doc->lesson_descr.size() )
+ if (lesson && lesson > (int) m_doc->m_lessonDescriptions.size() )
{
// description missing ?
QString s;
- for (int i = m_doc->lesson_descr.size(); i < lesson; i++)
+ for (int i = m_doc->m_lessonDescriptions.size(); i < lesson; i++)
{
s.setNum (i+1);
s.insert (0, "#"); // invent descr according to number
- m_doc->lesson_descr.push_back (s);
+ m_doc->m_lessonDescriptions.push_back (s);
}
}
return false;
- if (m_doc->vocabulary.size() == 0)
+ if (m_doc->m_vocabulary.size() == 0)
{
// only accept in first entry
if (width >= 0)
q_trans = lang;
}
- if (m_doc->langs.size() == 0)
+ if (m_doc->m_languages.size() == 0)
{
// first entry
if (lang.isEmpty()) // no definition in first entry
lang = "original";
- m_doc->langs.push_back(lang);
+ m_doc->m_languages.push_back(lang);
}
else
{
- if (lang != m_doc->langs[0] && !lang.isEmpty())
+ if (lang != m_doc->m_languages[0] && !lang.isEmpty())
{
// different originals ?
domError(i18n("ambiguous definition of language code"));
paraphrase))
return false;
- if (m_doc->vocabulary.size() == 0)
+ if (m_doc->m_vocabulary.size() == 0)
{
// only accept in first entry
if (width >= 0)
}
- if (m_doc->langs.size() <= count)
+ if (m_doc->m_languages.size() <= count)
{
// new translation
if (lang.isEmpty())
{
// no definition in first entry ?
- lang.setNum (m_doc->langs.size() );
+ lang.setNum (m_doc->m_languages.size() );
lang.insert (0, "translation ");
}
- m_doc->langs.push_back(lang);
+ m_doc->m_languages.push_back(lang);
}
else
{
- if (lang != m_doc->langs[count] && !lang.isEmpty())
+ if (lang != m_doc->m_languages[count] && !lang.isEmpty())
{ // different language ?
domError(i18n("ambiguous definition of language code"));
return false;
}
if (m_doc->numEntries() == 0)
m_doc->setQueryLang(q_org, q_trans);
- m_doc->vocabulary.push_back(expr);
+ m_doc->m_vocabulary.push_back(expr);
return true;
}
bool conjuggroup = false;
int ent_no = 0;
- int ent_percent = (int) m_doc->lines / 100;
- float f_ent_percent = (int) m_doc->lines / 100.0;
+ int ent_percent = (int) m_doc->m_lines / 100;
+ float f_ent_percent = (int) m_doc->m_lines / 100.0;
/* TODO EPT
if (lines != 0)
emit progressChanged(this, 0);
return false;
}
conjuggroup = true;
- if (!readConjug(domElementChild, m_doc->conjugations, KV_CON_ENTRY))
+ if (!readConjug(domElementChild, m_doc->m_conjugations, KV_CON_ENTRY))
return false;
}
return false;
}
- m_doc->langs.clear();
- m_doc->vocabulary.clear();
+ m_doc->m_languages.clear();
+ m_doc->m_vocabulary.clear();
- m_doc->generator = "";
- m_doc->cols = 0;
- m_doc->lines = 0;
- m_doc->doctitle = "";
+ m_doc->m_generator = "";
+ m_doc->m_cols = 0;
+ m_doc->m_lines = 0;
+ m_doc->m_title = "";
m_doc->m_author = "";
m_doc->m_license = "";
- m_doc->doc_remark = "";
+ m_doc->m_remark = "";
QDomElement domElementKvtml = domDoc.documentElement();
QDomAttr domAttrTitle = domElementKvtml.attributeNode(KV_TITLE);
if (!domAttrTitle.isNull())
{
- m_doc->doctitle = domAttrTitle.value();
+ m_doc->m_title = domAttrTitle.value();
}
QDomAttr domAttrAuthor = domElementKvtml.attributeNode(KV_AUTHOR);
QDomAttr domAttrRemark = domElementKvtml.attributeNode(KV_DOC_REM);
if (!domAttrRemark.isNull())
{
- m_doc->doc_remark = domAttrRemark.value();
+ m_doc->m_remark = domAttrRemark.value();
}
QDomAttr domAttrGenerator = domElementKvtml.attributeNode(KV_GENERATOR);
if (!domAttrGenerator.isNull())
{
- m_doc->generator = domAttrGenerator.value();
- int pos = m_doc->generator.findRev (KVD_VERS_PREFIX);
+ m_doc->m_generator = domAttrGenerator.value();
+ int pos = m_doc->m_generator.findRev (KVD_VERS_PREFIX);
if (pos >= 0)
{
- m_doc->doc_version = m_doc->generator;
- m_doc->doc_version.remove (0, pos+2);
+ m_doc->m_version = m_doc->m_generator;
+ m_doc->m_version.remove (0, pos+2);
}
}
QDomAttr domAttrCols = domElementKvtml.attributeNode(KV_COLS);
if (!domAttrCols.isNull())
{
- m_doc->cols = domAttrCols.value().toInt();
+ m_doc->m_cols = domAttrCols.value().toInt();
}
QDomAttr domAttrLines = domElementKvtml.attributeNode(KV_LINES);
if (!domAttrLines.isNull())
{
- m_doc->lines = domAttrLines.value().toInt();
+ m_doc->m_lines = domAttrLines.value().toInt();
}
bool readLesson(QDomElement &domElementParent);
bool readArticle(QDomElement &domElementParent);
bool readConjug(QDomElement &domElementParent,
- vector<Conjugation> &curr_conjug,
+ QValueList<Conjugation> &curr_conjug,
const QString &entry_tag);
bool readOptions(QDomElement &domElementParent);
bool readType(QDomElement &domElementParent);
bool KEduVocKvtmlWriter::saveTypeNameKvtMl (QDomDocument &domDoc, QDomElement &domElementParent)
{
- if (m_doc->type_descr.size() == 0)
+ if (m_doc->m_typeDescriptions.size() == 0)
return true;
QDomElement domElementType = domDoc.createElement(KV_TYPE_GRP);
- for (int lfn = 0; lfn < (int) m_doc->type_descr.size(); lfn++)
+ for (int lfn = 0; lfn < (int) m_doc->m_typeDescriptions.size(); lfn++)
{
- if (!(m_doc->type_descr[lfn].isNull()) )
+ if (!(m_doc->m_typeDescriptions[lfn].isNull()) )
{
QDomElement domElementDesc = domDoc.createElement(KV_TYPE_DESC);
- QDomText domTextDesc = domDoc.createTextNode(m_doc->type_descr[lfn]);
+ QDomText domTextDesc = domDoc.createTextNode(m_doc->m_typeDescriptions[lfn]);
domElementDesc.setAttribute(KV_TYPE_NO, lfn+1);
domElementDesc.appendChild(domTextDesc);
bool KEduVocKvtmlWriter::saveTenseNameKvtMl (QDomDocument &domDoc, QDomElement &domElementParent)
{
- if (m_doc->tense_descr.size() == 0)
+ if (m_doc->m_tenseDescriptions.size() == 0)
return true;
QDomElement domElementTense = domDoc.createElement(KV_TENSE_GRP);
- for (int lfn = 0; lfn < (int) m_doc->tense_descr.size(); lfn++)
+ for (int lfn = 0; lfn < (int) m_doc->m_tenseDescriptions.size(); lfn++)
{
- if (!(m_doc->tense_descr[lfn].isNull()) ) {
+ if (!(m_doc->m_tenseDescriptions[lfn].isNull()) ) {
QDomElement domElementDesc = domDoc.createElement(KV_TENSE_DESC);
- QDomText domTextDesc = domDoc.createTextNode(m_doc->tense_descr[lfn]);
+ QDomText domTextDesc = domDoc.createTextNode(m_doc->m_tenseDescriptions[lfn]);
domElementDesc.setAttribute(KV_TENSE_NO, lfn+1);
domElementDesc.appendChild(domTextDesc);
bool KEduVocKvtmlWriter::saveUsageNameKvtMl (QDomDocument &domDoc, QDomElement &domElementParent)
{
- if (m_doc->usage_descr.size() == 0)
+ if (m_doc->m_usageDescriptions.size() == 0)
return true;
QDomElement domElementUsage = domDoc.createElement(KV_USAGE_GRP);
- for (int lfn = 0; lfn < (int) m_doc->usage_descr.size(); lfn++)
+ for (int lfn = 0; lfn < (int) m_doc->m_usageDescriptions.size(); lfn++)
{
- if (!(m_doc->usage_descr[lfn].isNull()) )
+ if (!(m_doc->m_usageDescriptions[lfn].isNull()) )
{
QDomElement domElementDesc = domDoc.createElement(KV_USAGE_DESC);
- QDomText domTextDesc = domDoc.createTextNode(m_doc->usage_descr[lfn]);
+ QDomText domTextDesc = domDoc.createTextNode(m_doc->m_usageDescriptions[lfn]);
domElementDesc.setAttribute(KV_USAGE_NO, lfn+1);
domElementDesc.appendChild(domTextDesc);
bool KEduVocKvtmlWriter::saveLessonKvtMl (QDomDocument &domDoc, QDomElement &domElementParent)
{
- if (m_doc->lesson_descr.size() == 0)
+ if (m_doc->m_lessonDescriptions.size() == 0)
return true;
QDomElement domElementLesson = domDoc.createElement(KV_LESS_GRP);
domElementLesson.setAttribute(KV_SIZEHINT, m_doc->sizeHint(-1));
- for (int lfn = 0; lfn < (int) m_doc->lesson_descr.size(); lfn++)
+ for (int lfn = 0; lfn < (int) m_doc->m_lessonDescriptions.size(); lfn++)
{
- if (!(m_doc->lesson_descr[lfn].isNull()) )
+ if (!(m_doc->m_lessonDescriptions[lfn].isNull()) )
{
QDomElement domElementDesc = domDoc.createElement(KV_LESS_DESC);
- QDomText domTextDesc = domDoc.createTextNode(m_doc->lesson_descr[lfn]);
+ QDomText domTextDesc = domDoc.createTextNode(m_doc->m_lessonDescriptions[lfn]);
domElementDesc.setAttribute(KV_LESS_NO, lfn+1);
if (m_doc->currentLesson() == lfn+1)
domElementDesc.setAttribute (KV_LESS_CURR, 1);
- if (lfn < (int) m_doc->lessons_in_query.size() && m_doc->lessons_in_query[lfn])
+ if (lfn < (int) m_doc->m_lessonsInQuery.size() && m_doc->m_lessonsInQuery[lfn])
domElementDesc.setAttribute (KV_LESS_QUERY, 1);
domElementDesc.appendChild(domTextDesc);
}
bool KEduVocKvtmlWriter::saveConjugHeader(QDomDocument &domDoc, QDomElement &domElementParent,
- vector<Conjugation> &curr_conjug)
+ QValueList<Conjugation> &curr_conjug)
{
/*
<conjugation> used in header for definiton of "prefix"
QDomElement domElementConjug = domDoc.createElement(KV_CONJUG_GRP);
QString s;
- for (int ent = 0; ent < QMIN((int) curr_conjug.size(), m_doc->numLangs()); ent++)
+ for (int ent = 0; ent < QMIN((int) curr_conjug.size(), m_doc->numLanguages()); ent++)
{
QDomElement domElementEntry = domDoc.createElement(KV_CON_ENTRY);
if (ent == 0)
{
- s = m_doc->originalIdent().stripWhiteSpace(); //EPT le Ident doit �re superflu
+ s = m_doc->originalIdentifier().stripWhiteSpace(); //EPT le Ident doit �re superflu
if (s.isEmpty() )
s = "original";
}
else
{
- s = m_doc->ident(ent).stripWhiteSpace();
+ s = m_doc->identifier(ent).stripWhiteSpace();
if (s.isEmpty() )
{
s.setNum(ent);
</article>
*/
{
- if (m_doc->articles.size() == 0)
+ if (m_doc->m_articles.size() == 0)
return true;
QDomElement domElementArticle = domDoc.createElement(KV_ARTICLE_GRP);
QString def, indef, s;
- for (int lfn = 0; lfn < QMIN((int) m_doc->articles.size(), m_doc->numLangs()); lfn++)
+ for (int lfn = 0; lfn < QMIN((int) m_doc->m_articles.size(), m_doc->numLanguages()); lfn++)
{
QDomElement domElementEntry = domDoc.createElement(KV_ART_ENTRY);
if (lfn == 0)
{
- s = m_doc->originalIdent().stripWhiteSpace();
+ s = m_doc->originalIdentifier().stripWhiteSpace();
if (s.isEmpty() )
s = "original";
}
else
{
- s = m_doc->ident(lfn).stripWhiteSpace();
+ s = m_doc->identifier(lfn).stripWhiteSpace();
if (s.isEmpty() )
{
s.setNum(lfn);
}
domElementEntry.setAttribute(KV_LANG, s);
- m_doc->articles[lfn].female(def, indef);
+ m_doc->m_articles[lfn].female(def, indef);
if (!def.isEmpty() )
{
QDomElement domElementFD = domDoc.createElement(KV_ART_FD);
domElementEntry.appendChild(domElementFI);
}
- m_doc->articles[lfn].male(def, indef);
+ m_doc->m_articles[lfn].male(def, indef);
if (!def.isEmpty() )
{
QDomElement domElementMD = domDoc.createElement(KV_ART_MD);
domElementEntry.appendChild(domElementMI);
}
- m_doc->articles[lfn].natural(def, indef);
+ m_doc->m_articles[lfn].natural(def, indef);
if (!def.isEmpty() )
{
QDomElement domElementND = domDoc.createElement(KV_ART_ND);
QDomElement domElementOption = domDoc.createElement(KV_OPTION_GRP);
QDomElement domElementSort = domDoc.createElement(KV_OPT_SORT);
- domElementSort.setAttribute(KV_BOOL_FLAG, (m_doc->sort_allowed?1:0));
+ domElementSort.setAttribute(KV_BOOL_FLAG, (m_doc->m_enableSorting?1:0));
domElementOption.appendChild(domElementSort);
domElementParent.appendChild(domElementOption);
domElementKvtml.setAttribute(KV_ENCODING, (QString)"UTF-8");
domElementKvtml.setAttribute(KV_GENERATOR, generator);
- domElementKvtml.setAttribute(KV_COLS, m_doc->numLangs() );
+ domElementKvtml.setAttribute(KV_COLS, m_doc->numLanguages() );
domElementKvtml.setAttribute(KV_LINES, m_doc->numEntries() );
- if (!m_doc->doctitle.isEmpty())
- domElementKvtml.setAttribute(KV_TITLE, m_doc->doctitle);
+ if (!m_doc->m_title.isEmpty())
+ domElementKvtml.setAttribute(KV_TITLE, m_doc->m_title);
if (!m_doc->m_author.isEmpty())
domElementKvtml.setAttribute(KV_AUTHOR, m_doc->author() );
if (!m_doc->m_license.isEmpty())
domElementKvtml.setAttribute(KV_LICENSE, m_doc->license() );
- if (!m_doc->doc_remark.isEmpty())
+ if (!m_doc->m_remark.isEmpty())
domElementKvtml.setAttribute(KV_DOC_REM, m_doc->docRemark() );
if (!saveLessonKvtMl(domDoc, domElementKvtml))
if (!saveArticleKvtMl(domDoc, domElementKvtml))
return false;
- if (!saveConjugHeader(domDoc, domElementKvtml, m_doc->conjugations))
+ if (!saveConjugHeader(domDoc, domElementKvtml, m_doc->m_conjugations))
return false;
if (!saveOptionsKvtMl(domDoc, domElementKvtml))
return false;
QString q_org, q_trans;
- vector<KEduVocExpression>::const_iterator first = m_doc->vocabulary.begin ();
+ QValueList<KEduVocExpression>::const_iterator first = m_doc->m_vocabulary.begin ();
m_doc->queryLang(q_org, q_trans);
int ent_no = 0;
- int ent_percent = (int) m_doc->vocabulary.size () / 100;
- float f_ent_percent = (int) m_doc->vocabulary.size () / 100.0;
+ int ent_percent = (int) m_doc->m_vocabulary.size () / 100;
+ float f_ent_percent = (int) m_doc->m_vocabulary.size () / 100.0;
//TODO emit progressChanged(this, 0);
- while (first != m_doc->vocabulary.end ())
+ while (first != m_doc->m_vocabulary.end ())
{
QDomElement domElementExpression = domDoc.createElement(KV_EXPR);
// entry belongs to lesson x
QString ls;
int lm = (*first).lesson();
- if (lm > (int) m_doc->lesson_descr.size() )
+ if (lm > (int) m_doc->m_lessonDescriptions.size() )
{
// should not be
kdError() << "index of lesson member too high: " << lm << endl;
s.setNum (m_doc->sizeHint (0));
domElementOriginal.setAttribute(KV_SIZEHINT, s);
- s = m_doc->originalIdent().stripWhiteSpace();
+ s = m_doc->originalIdentifier().stripWhiteSpace();
if (s.isEmpty() )
s = "original";
domElementOriginal.setAttribute (KV_LANG, s);
domElementExpression.appendChild(domElementOriginal);
int trans = 1;
- while (trans < (int)m_doc->langs.size())
+ while (trans < (int)m_doc->m_languages.size())
{
QDomElement domElementTranslation = domDoc.createElement(KV_TRANS);
if (first_expr)
s.setNum (m_doc->sizeHint (trans));
domElementTranslation.setAttribute(KV_SIZEHINT, s);
- s = m_doc->ident(trans).stripWhiteSpace();
+ s = m_doc->identifier(trans).stripWhiteSpace();
if (s.isEmpty() )
{
s.setNum (trans);
bool saveOptionsKvtMl (QDomDocument &domDoc, QDomElement &domElementParent);
bool saveArticleKvtMl (QDomDocument &domDoc, QDomElement &domElementParent);
bool saveConjugHeader (QDomDocument &domDoc, QDomElement &domElementParent,
- vector<Conjugation> &curr_conjug);
+ QValueList<Conjugation> &curr_conjug);
bool saveConjug (QDomDocument &domDoc, QDomElement &domElementParent,
const Conjugation &curr_conjug, QString type);
bool saveConjugEntry (QDomDocument &domDoc, QDomElement &domElementParent,
bool KEduVocWqlReader::readDoc(KEduVocDocument *doc)
{
m_doc = doc;
-
+
QTextStream inputStream(m_inputFile);
inputStream.setEncoding(QTextStream::Latin1);
m_doc->setFont(new QFont(fam, ps, b, it));
/* TODO
- while (inputStream.readLine() != "[Character Info]");
- s = inputStream.readLine();
+ while (inputStream.readLine() != "[Character Info]");
+ s = inputStream.readLine();
p = s.find("=", 0);
m_specialCharacters = s.right(s.length() - (p + 1));
*/
p = s.find(" [", 0);
s = s.left(p);
s = s.stripWhiteSpace();
- m_doc->langs.push_back(s);
- m_doc->langs.push_back(inputStream.readLine());
+ m_doc->m_languages.push_back(s);
+ m_doc->m_languages.push_back(inputStream.readLine());
while (!s.isNull())
{
int h = r.toInt();
s = s.left(p);
s = s.stripWhiteSpace();
-
+
QString b;
b = inputStream.readLine();
-
+
KEduVocExpression expr = KEduVocExpression(s);
expr.setTranslation(1, b);
m_doc->appendEntry(&expr);
{
writeSelection(g->currentColumn(), g->currentRow(), g->currentColumn(), g->currentRow());
}*/
- writeFirstItem(m_doc->originalIdent(), m_doc->ident(1));
+ writeFirstItem(m_doc->originalIdentifier(), m_doc->identifier(1));
int r = m_doc->numEntries();
for (int w=0; w < r; w++)
{
GIT / libqmvoc.git / commitdiff