Initial mirror commitHEADmaster

1 files changed, 601 insertions, 0 deletions

diff --git a/src/dictionary/Dictionary.cpp b/src/dictionary/Dictionary.cpp
new file mode 100644
index 0000000..0779651
--- /dev/null
+++ b/src/dictionary/Dictionary.cpp
@@ -0,0 +1,601 @@
+#include "Dictionary.h"
+#include "CardPack.h"
+#include "../version.h"
+#include "DicRecord.h"
+#include "DictionaryWriter.h"
+#include "DictionaryReader.h"
+#include "../study/StudyFileWriter.h"
+#include "../study/StudyFileReader.h"
+#include "../field-styles/FieldStyleFactory.h"
+#include "../main-view/AppModel.h"
+
+#include <QTextStream>
+#include <QStringList>
+#include <QtAlgorithms>
+#include <QDateTime>
+#include <QSettings>
+#include <QDir>
+
+const QString Dictionary::DictFileExtension(".fmd");
+const QString Dictionary::StudyFileExtension(".fms");
+const char* Dictionary::NoName( QT_TRANSLATE_NOOP("Dictionary", "noname") );
+
+Dictionary::Dictionary(const QString& aFilePath, bool aNameIsTemp, const AppModel* aAppModel):
+    IDictionary(aFilePath), m_appModel(aAppModel),
+    obsoleteId(QUuid()),
+    m_contentModified(true), m_studyModified(false), m_nameIsTemp(aNameIsTemp)
+    {
+    }
+
+Dictionary::~Dictionary()
+    {
+    foreach( Field* field, m_fields )
+        delete field;
+    foreach( CardPack* pack, m_cardPacks )
+        delete pack;
+    }
+
+const TreeItem* Dictionary::child( int aRow ) const
+    {
+    return cardPack( aRow );
+    }
+
+QVariant Dictionary::data( int aColumn ) const
+    {
+    if( aColumn == 0 )
+        return shortName( false );
+    else
+        return QVariant();
+    }
+
+int Dictionary::row() const
+    {
+    if( m_appModel )
+        return m_appModel->indexOfDictionary( const_cast<Dictionary*>(this) );
+    else
+        return 0;
+    }
+
+void Dictionary::clearFieldPackConfig()
+    {
+    while( !m_fields.isEmpty() )
+        delete m_fields.takeLast();
+    while( !m_cardPacks.isEmpty() )
+        delete m_cardPacks.takeLast();
+    }
+
+/** Copies from another dictionary:
+  *   - fields, packs, study data.
+  * The old configuration is deleted.
+  * The dic records are not changed.
+  */
+void Dictionary::setDictConfig( const Dictionary* aOtherDic )
+    {
+    clearFieldPackConfig();
+
+    // Replace fields
+    foreach( Field* f, aOtherDic->fields() )
+        {
+        m_fields << new Field( f->name(), f->style() );
+            // Fix the renamed fields in the entries
+            // TODO: Refactor to remove the old name
+        foreach( DicRecord* entry, records )
+            entry->renameField( f->oldName(), f->name() );
+        }
+
+    // Replace card packs
+    foreach( CardPack* otherPack, aOtherDic->cardPacks() )
+        {
+        /* The packs are copied together with study data, because
+         * afterwards it's impossible to find correct modified pack
+         */
+        CardPack* newPack = new CardPack( this, otherPack );
+        addCardPack( newPack );
+        }
+
+    setContentModified();
+    generateCards();
+    }
+
+void Dictionary::setDefaultFields()
+{
+    m_fields << new Field( tr("Question"), FieldStyleFactory::DefaultStyle );
+    m_fields << new Field( tr("Answer"), FieldStyleFactory::DefaultStyle );
+    m_fields << new Field( tr("Example"), "Example" );
+
+    if( records.isEmpty() )
+        records << new DicRecord();
+
+    CardPack* pack;
+    QList<const Field*> ansFields;
+
+    // Question->Answer
+    pack = new CardPack( this );
+    pack->setQstField( m_fields[0] );
+    ansFields << m_fields[1] << m_fields[2];
+    pack->setAnsFields( ansFields );
+    addCardPack( pack );
+
+    // Answer->Question
+    ansFields.clear();
+    pack = new CardPack( this );
+    pack->setQstField( m_fields[1] );
+    ansFields << m_fields[0] << m_fields[2];
+    pack->setAnsFields( ansFields );
+    addCardPack( pack );
+}
+
+bool Dictionary::load(const QString filePath)
+{
+    if(!loadDictFile(filePath))
+        return false;
+    generateCards();
+    cleanObsoleteId();
+    QString studyFilePath = getStudyFilePath();
+    if(!QFile::exists(studyFilePath))
+        return true;
+    return loadStudyFile(studyFilePath);
+}
+
+bool Dictionary::loadDictFile(const QString filePath)
+{
+    cleanRecords();
+    QFile dicFile(filePath);
+    if(!dicFile.open(QIODevice::ReadOnly | QFile::Text))
+    {
+        errorMessage = tr("Cannot open dictionary file:") +
+            QString("<p>%1</p>").arg(QDir::toNativeSeparators(filePath));
+        return false;
+    }
+    this->filePath = filePath;
+    DictionaryReader dicReader(this);
+    bool ok = dicReader.read( &dicFile );
+    dicFile.close();
+    if(!ok)
+        {
+        errorMessage = dicReader.errorString();
+        return false;
+        }
+
+    if(m_contentModified)
+        {
+        if(save() != QFile::NoError)
+            return false;
+        }
+    return true;
+}
+
+void Dictionary::cleanRecords()
+{
+    while (!records.isEmpty())
+        delete records.takeFirst();
+}
+
+void Dictionary::cleanObsoleteId()
+{
+    if(!obsoleteId.isNull())
+        obsoleteId = QUuid();
+}
+
+bool Dictionary::loadStudyFile(const QString filePath)
+{
+    QFile studyFile(filePath);
+    if(!studyFile.open(QIODevice::ReadOnly | QFile::Text))
+    {
+        errorMessage = tr("Cannot open study file:") +
+            QString("<p>%1</p>").arg(QDir::toNativeSeparators(filePath));
+        return false;
+    }
+    StudyFileReader studyReader( this );
+    bool ok = studyReader.read( &studyFile );
+    studyFile.close();
+    if(!ok)
+        errorMessage = studyReader.errorString() + QString(" at %1:%2")
+            .arg( studyReader.lineNumber() )
+            .arg( studyReader.columnNumber() );
+
+    if(m_studyModified)
+        {
+        if(saveStudy() != QFile::NoError)
+            return false;
+        }
+    return true;
+}
+
+QFile::FileError Dictionary::save( const QString aFilePath, bool aChangeFilePath )
+{
+    QFile::FileError error = saveContent( aFilePath );
+    if(error != QFile::NoError)
+        return error;
+
+    if(aChangeFilePath && aFilePath != filePath)
+        {
+        filePath = aFilePath;
+        m_studyModified = true;
+        emit filePathChanged();
+        }
+
+    if(m_studyModified)
+        {
+        error = saveStudy();
+        if(error != QFile::NoError)
+            return error;
+        }
+
+    return QFile::NoError;
+}
+
+QFile::FileError Dictionary::saveContent( const QString aFilePath )
+    {
+    QFile file( aFilePath );
+    if( !file.open( QIODevice::WriteOnly | QFile::Text ) )
+        return file.error();
+    DictionaryWriter writer( this );
+    writer.write( &file );
+    file.close();
+    setContentModified( false );
+    m_nameIsTemp = false;
+    return QFile::NoError;
+    }
+
+QFile::FileError Dictionary::saveStudy()
+    {
+    if(!m_studyModified)
+        return QFile::NoError;
+    QFile file( getStudyFilePath() );
+    if(!file.open(QIODevice::WriteOnly | QFile::Text))
+        return file.error();
+    StudyFileWriter writer(this);
+    writer.write(&file);
+    file.close();
+    setStudyModified(false);
+    return QFile::NoError;
+    }
+
+QString Dictionary::shortName( bool aMarkModified ) const
+{
+QString fileName;
+if( !filePath.isEmpty() )
+    fileName = QFileInfo(filePath).fileName();
+else
+    fileName = tr(NoName) + DictFileExtension;
+if(aMarkModified && m_contentModified)
+    fileName += "*";
+return fileName;
+}
+
+QString Dictionary::getStudyFilePath() const
+{
+QString studyFilePath;
+if(obsoleteId.isNull())
+    {
+    // Take study file from the same dictionary directory
+    QFileInfo fileInfo(filePath);
+    studyFilePath = fileInfo.path() + "/" + fileInfo.completeBaseName() + StudyFileExtension;
+    }
+else
+    {
+    // Old dictionary. Take study file from the user settings directory
+    QSettings settings;
+    QFileInfo settingsInfo( settings.fileName() );
+    studyFilePath = settingsInfo.path() + "/study/" + obsoleteId.toString() + StudyFileExtension;
+    }
+return studyFilePath;
+}
+
+void Dictionary::setContentModified( bool aModified )
+{
+if( aModified != m_contentModified )  // The Content Modified state is changed
+    {
+    m_contentModified = aModified;
+    emit contentModifiedChanged( m_contentModified );
+    }
+}
+
+void Dictionary::setStudyModified(bool aModified)
+{
+if(aModified != m_studyModified)
+    {
+    m_studyModified = aModified;
+    emit studyModifiedChanged(m_studyModified);
+    }
+}
+
+const DicRecord* Dictionary::getRecord(int aIndex) const
+{
+    return records.value( aIndex );
+}
+
+const DicRecord* Dictionary::entry04( const QString aId04 ) const
+    {
+    if( aId04.isEmpty() )
+        return NULL;
+    foreach( DicRecord* entry, records )
+        if( entry->id04() == aId04 )
+            return entry;
+    return NULL;
+    }
+
+void Dictionary::setFieldValue( int aEntryIx, int aFieldIx, QString aValue )
+    {
+    DicRecord* entry = records.value(aEntryIx);
+    if( !entry )
+        return;
+    const Field* field = m_fields[aFieldIx];
+    if( field->name().isNull() )
+        return;
+    entry->setField( field->name(), aValue );
+    setContentModified();
+    emit entryChanged( aEntryIx, aFieldIx );
+    }
+
+    /// @return -1, if the given ID 0.4 was not found
+int Dictionary::fieldId04ToIx( const QString aId ) const
+    {
+    if( aId.isEmpty() )
+        return -1;
+    int i=0;
+    foreach( Field* f, m_fields )
+        {
+        if( f->id04() == aId )
+            return i;
+        i++;
+        }
+    return -1;
+    }
+
+const Field* Dictionary::field( const QString aFieldName ) const
+    {
+    foreach( Field* f, m_fields )
+        if( f->name() == aFieldName )
+            return f;
+    return NULL;
+    }
+
+QStringList Dictionary::fieldNames() const
+    {
+    QStringList names;
+    foreach( Field* f, m_fields )
+        names << f->name();
+    return names;
+    }
+
+CardPack* Dictionary::cardPack( QString aId ) const
+    {
+    foreach( CardPack* pack, m_cardPacks )
+        {
+        if( pack->id() == aId )
+            return pack;
+        }
+    return NULL;
+    }
+
+void Dictionary::setFieldName( int aField, QString aName )
+    {
+    if( aField >= m_fields.size() )
+        return;
+    m_fields[aField]->setName(aName);
+    setContentModified();
+    emit fieldChanged( aField );
+    }
+
+void Dictionary::setFieldStyle( int aField, QString aStyle )
+    {
+    if( aField >= m_fields.size() )
+        return;
+    m_fields[aField]->setStyle(aStyle);
+    setContentModified();
+    emit fieldChanged( aField );
+    }
+
+void Dictionary::insertField( int aPos, QString aName )
+    {
+    if( aPos > m_fields.size() )
+        return;
+    m_fields.insert( aPos, new Field(aName) );
+    setContentModified();
+    emit fieldInserted( aPos );
+    }
+
+void Dictionary::insertField( int aPos, Field* aFieldPtr )
+    {
+    if( aPos > m_fields.size() )
+        return;
+    m_fields.insert( aPos, aFieldPtr );
+    setContentModified();
+    emit fieldInserted( aPos );
+    }
+
+void Dictionary::addField( QString aName, QString aStyle )
+    {
+    m_fields << new Field( aName, aStyle );
+    setContentModified();
+    emit fieldInserted( m_fields.size()-1 );
+    }
+
+// TODO: Make undo command
+void Dictionary::addFields( QStringList aFieldNames )
+    {
+    foreach( QString aName, aFieldNames )
+        addField( aName );
+    }
+
+/// Just removes field pointer from list
+void Dictionary::removeField( int aPos )
+    {
+    if( aPos >= m_fields.size() )
+        return;
+    m_fields.removeAt( aPos );
+    setContentModified();
+    emit fieldRemoved( aPos );
+    }
+
+/// Removes the field pointer and destroys the field itself!
+void Dictionary::destroyField( int aPos )
+    {
+    if( aPos >= m_fields.size() )
+        return;
+
+    Field* removedField = m_fields.takeAt( aPos );
+    setContentModified();
+
+    // Remove this field in all packs
+    foreach( CardPack* pack, m_cardPacks )
+        pack->removeField( removedField );
+
+    delete removedField;
+    emit fieldRemoved( aPos );
+    emit fieldDestroyed( removedField );
+    }
+
+void Dictionary::insertPack( int aPos, CardPack* aPack )
+    {
+    if( aPos > m_cardPacks.size() )
+        return;
+    m_cardPacks.insert( aPos, aPack );
+    connect( aPack, SIGNAL(studyRecordAdded()), SLOT(setStudyModified()) );
+    connect( aPack, SIGNAL(cardsGenerated()), SIGNAL(cardsGenerated()) );
+    emit packInserted( aPos );
+    }
+
+
+void Dictionary::addCardPack( CardPack* aCardPack )
+    {
+    insertPack( m_cardPacks.size(), aCardPack );
+    }
+
+/// Just removes pack pointer from list
+void Dictionary::removePack( int aPos )
+    {
+    if( aPos >= m_cardPacks.size() )
+        return;
+    m_cardPacks.removeAt( aPos );
+    emit packRemoved( aPos );
+    }
+
+/// Removes the field pointer and destroys the field itself!
+void Dictionary::destroyPack( int aPos )
+    {
+    if( aPos >= m_cardPacks.size() )
+        return;
+    CardPack* removedPack = m_cardPacks.takeAt( aPos );
+    delete removedPack;
+    emit packRemoved( aPos );
+    emit packDestroyed( removedPack );
+    }
+
+void Dictionary::setRecord( int aIndex, const DicRecord& aRecord )
+    {
+    if( aIndex < 0 || aIndex >= records.size() )
+        return;
+    DicRecord* newRecord = new DicRecord( aRecord );
+    delete records.value( aIndex );   // delete old record
+    records.replace( aIndex, newRecord );
+    setContentModified();
+    emit entryChanged( aIndex, AllFields );
+    }
+
+void Dictionary::insertEntry(int aIndex, DicRecord* aEntry)
+    {
+    records.insert( aIndex, aEntry );
+    notifyRecordsInserted(aIndex, 1);
+    }
+
+void Dictionary::insertEntries( int aIndex, int aNum )
+    {
+    for(int i=0; i < aNum; i++)
+        records.insert( aIndex + i, new DicRecord() );
+    notifyRecordsInserted(aIndex, aNum);
+    }
+
+void Dictionary::insertEntries( int aIndex, QList<DicRecord*> aEntries )
+    {
+    int i = 0;
+    foreach( DicRecord* entry, aEntries )
+        {
+        records.insert( aIndex + i, entry );
+        i++;
+        }
+    notifyRecordsInserted(aIndex, aEntries.size());
+    }
+
+void Dictionary::notifyRecordsInserted(int index, int num)
+{
+    setContentModified();
+    emit entriesInserted(index, num);
+}
+
+void Dictionary::removeRecords(int aIndex, int aNum)
+    {
+    Q_ASSERT( aIndex + aNum <= records.size() );    
+    for( int i=0; i < aNum; i++ )
+        delete records.takeAt( aIndex );
+    setContentModified();
+    emit entriesRemoved( aIndex, aNum );
+    }
+
+void Dictionary::removeRecord( QString aQuestion )
+    {
+    QMutableListIterator<DicRecord*> it( records );
+    int i = 0;
+    int removedIndex = -1;  // First removed record
+    while( it.hasNext() )
+        {
+        DicRecord* record = it.next();
+        foreach( QString fieldStr, record->getFields() )
+            {
+            QStringList elements = fieldStr.split( CardPack::SynonymDelimiter, QString::SkipEmptyParts );
+            if( elements.contains( aQuestion ) )
+                {
+                it.remove();
+                if( removedIndex < 0 )
+                    removedIndex = i;
+                break;
+                }
+            }
+        i++;
+        }
+    if( removedIndex >= 0 ) // if something was removed
+        {
+        setContentModified();
+        emit entriesRemoved( removedIndex, 1 );
+        }
+    }
+
+void Dictionary::generateCards()
+    {
+    if( m_cardPacks.isEmpty() )
+        return;
+    foreach( CardPack* pack, m_cardPacks )
+        pack->generateQuestions();
+    }
+
+void Dictionary::disableRecordUpdates()
+    {
+    if( m_cardPacks.isEmpty() )
+        return;
+    foreach( CardPack* pack, m_cardPacks )
+        pack->disableDictRecordUpdates();
+    }
+
+void Dictionary::enableRecordUpdates()
+    {
+    if( m_cardPacks.isEmpty() )
+        return;
+    foreach( CardPack* pack, m_cardPacks )
+        pack->enableDictRecordUpdates();
+    generateCards();
+    }
+
+QString Dictionary::shortenImagePaths(QString text) const
+{
+    QRegExp imgRx(QString("(<img\\s+src=\")%1([/\\\\])").arg(getImagesPath()));
+    text.replace(imgRx, "\\1%%\\2");
+    return text;
+}
+
+QString Dictionary::getFieldValue(int recordNum, int fieldNum) const
+{
+    QString fieldName = field(fieldNum)->name();
+    return getRecord(recordNum)-> getFieldValue(fieldName);
+}