From d24f813f3f2a05c112e803e4256b53535895fc98 Mon Sep 17 00:00:00 2001 From: Jedidiah Barber Date: Wed, 14 Jul 2021 11:49:10 +1200 Subject: Initial mirror commit --- src/main-view/AboutDialog.cpp | 27 + src/main-view/AboutDialog.h | 17 + src/main-view/AppModel.cpp | 196 +++++ src/main-view/AppModel.h | 64 ++ src/main-view/CardFilterModel.cpp | 24 + src/main-view/CardFilterModel.h | 21 + src/main-view/CardPreview.cpp | 55 ++ src/main-view/CardPreview.h | 30 + src/main-view/DictTableDelegate.cpp | 128 +++ src/main-view/DictTableDelegate.h | 44 + src/main-view/DictTableDelegatePainter.cpp | 61 ++ src/main-view/DictTableDelegatePainter.h | 36 + src/main-view/DictTableModel.cpp | 142 +++ src/main-view/DictTableModel.h | 52 ++ src/main-view/DictTableView.cpp | 84 ++ src/main-view/DictTableView.h | 36 + src/main-view/DictionaryTabWidget.cpp | 108 +++ src/main-view/DictionaryTabWidget.h | 46 + src/main-view/FieldContentCodec.cpp | 52 ++ src/main-view/FieldContentCodec.h | 28 + src/main-view/FieldContentPainter.h | 16 + src/main-view/FindPanel.cpp | 258 ++++++ src/main-view/FindPanel.h | 66 ++ src/main-view/LanguageMenu.cpp | 64 ++ src/main-view/LanguageMenu.h | 28 + src/main-view/MainWindow.cpp | 1313 ++++++++++++++++++++++++++++ src/main-view/MainWindow.h | 218 +++++ src/main-view/PacksTreeModel.cpp | 93 ++ src/main-view/PacksTreeModel.h | 32 + src/main-view/RecentFilesManager.cpp | 99 +++ src/main-view/RecentFilesManager.h | 43 + src/main-view/RecordEditor.cpp | 122 +++ src/main-view/RecordEditor.h | 46 + src/main-view/UndoCommands.cpp | 322 +++++++ src/main-view/UndoCommands.h | 109 +++ src/main-view/WelcomeScreen.cpp | 51 ++ src/main-view/WelcomeScreen.h | 25 + 37 files changed, 4156 insertions(+) create mode 100644 src/main-view/AboutDialog.cpp create mode 100644 src/main-view/AboutDialog.h create mode 100644 src/main-view/AppModel.cpp create mode 100644 src/main-view/AppModel.h create mode 100644 src/main-view/CardFilterModel.cpp create mode 100644 src/main-view/CardFilterModel.h create mode 100644 src/main-view/CardPreview.cpp create mode 100644 src/main-view/CardPreview.h create mode 100644 src/main-view/DictTableDelegate.cpp create mode 100644 src/main-view/DictTableDelegate.h create mode 100644 src/main-view/DictTableDelegatePainter.cpp create mode 100644 src/main-view/DictTableDelegatePainter.h create mode 100644 src/main-view/DictTableModel.cpp create mode 100644 src/main-view/DictTableModel.h create mode 100644 src/main-view/DictTableView.cpp create mode 100644 src/main-view/DictTableView.h create mode 100644 src/main-view/DictionaryTabWidget.cpp create mode 100644 src/main-view/DictionaryTabWidget.h create mode 100644 src/main-view/FieldContentCodec.cpp create mode 100644 src/main-view/FieldContentCodec.h create mode 100644 src/main-view/FieldContentPainter.h create mode 100644 src/main-view/FindPanel.cpp create mode 100644 src/main-view/FindPanel.h create mode 100644 src/main-view/LanguageMenu.cpp create mode 100644 src/main-view/LanguageMenu.h create mode 100644 src/main-view/MainWindow.cpp create mode 100644 src/main-view/MainWindow.h create mode 100644 src/main-view/PacksTreeModel.cpp create mode 100644 src/main-view/PacksTreeModel.h create mode 100644 src/main-view/RecentFilesManager.cpp create mode 100644 src/main-view/RecentFilesManager.h create mode 100644 src/main-view/RecordEditor.cpp create mode 100644 src/main-view/RecordEditor.h create mode 100644 src/main-view/UndoCommands.cpp create mode 100644 src/main-view/UndoCommands.h create mode 100644 src/main-view/WelcomeScreen.cpp create mode 100644 src/main-view/WelcomeScreen.h (limited to 'src/main-view') diff --git a/src/main-view/AboutDialog.cpp b/src/main-view/AboutDialog.cpp new file mode 100644 index 0000000..f1a7839 --- /dev/null +++ b/src/main-view/AboutDialog.cpp @@ -0,0 +1,27 @@ +#include "AboutDialog.h" +#include "../strings.h" +#include "../version.h" + +AboutDialog::AboutDialog(QWidget* parent): + QMessageBox(parent) +{ + setIconPixmap(QPixmap(":/images/freshmemory.png")); + setWindowTitle(tr("About %1").arg( Strings::tr(Strings::s_appTitle))); + setText(createAboutText()); + setEscapeButton(addButton(QMessageBox::Ok)); +} + +QString AboutDialog::createAboutText() +{ + QString formattedBuildStr; + if( !BuildStr.isEmpty() ) + formattedBuildStr = "

" + BuildStr + "

"; + return QString("

") + Strings::tr(Strings::s_appTitle) + " " + FM_VERSION + "

" + + formattedBuildStr + + "

" + tr("Learn new things quickly and keep your memory fresh with time spaced repetition.") + "

" + + "

" + Strings::tr(Strings::s_author) + "

" + + "

fresh-memory.com

" + + "

" + + "

" + tr("License:") + " GPL 3" + + "

" + "

"; + } diff --git a/src/main-view/AboutDialog.h b/src/main-view/AboutDialog.h new file mode 100644 index 0000000..d05c11c --- /dev/null +++ b/src/main-view/AboutDialog.h @@ -0,0 +1,17 @@ +#ifndef ABOUT_DIALOG_H +#define ABOUT_DIALOG_H + +#include + +class AboutDialog: public QMessageBox +{ + Q_OBJECT + +public: + AboutDialog(QWidget* parent); + +private: + QString createAboutText(); +}; + +#endif diff --git a/src/main-view/AppModel.cpp b/src/main-view/AppModel.cpp new file mode 100644 index 0000000..45e1956 --- /dev/null +++ b/src/main-view/AppModel.cpp @@ -0,0 +1,196 @@ +#include "AppModel.h" + +#include + +#include "../utils/RandomGenerator.h" +#include "../dictionary/Dictionary.h" +#include "../main-view/DictTableModel.h" +#include "../study/WordDrillModel.h" +#include "../study/SpacedRepetitionModel.h" +#include "../dictionary/CardPack.h" + +AppModel::AppModel(): + curDictIndex(-1), curCardPackIndex(0) +{ +} + +AppModel::~AppModel() +{ + while(!dictionaries.isEmpty()) + { + QPair pair = dictionaries.takeLast(); + delete pair.second; + delete pair.first; + } +} + +bool AppModel::openDictionary(const QString& filePath) +{ + Dictionary* dict = new Dictionary( "", false, this ); + bool ok = dict->load(filePath); + if(ok) + addDictionary(dict); + else + { + errorMessage = dict->getErrorMessage(); + delete dict; + } + return ok; +} + +void AppModel::addDictionary( Dictionary* aDict ) +{ + DictTableModel* dictModel = new DictTableModel( aDict ); + dictionaries << qMakePair( aDict, dictModel ); + curDictIndex = dictionaries.size() - 1; +} + +Dictionary* AppModel::newDictionary() +{ + Dictionary* dict = new Dictionary( "", false, this ); + dict->setDefaultFields(); + addDictionary( dict ); + return dict; +} + +void AppModel::fixupCurDictIx() +{ + if( curDictIndex < 0 || curDictIndex >= dictionaries.size() ) + curDictIndex = dictionaries.size()-1; +} + +Dictionary* AppModel::curDictionary() + { + if( dictionaries.isEmpty() ) + return NULL; + fixupCurDictIx(); + return dictionaries[curDictIndex].first; + } + +DictTableModel* AppModel::curDictModel() + { + if( dictionaries.isEmpty() ) + return NULL; + fixupCurDictIx(); + return dictionaries[curDictIndex].second; + } + +Dictionary* AppModel::dictionary(int aIndex) const + { + if( aIndex < 0 || aIndex >= dictionaries.size() ) + return NULL; + return dictionaries[aIndex].first; + } + +int AppModel::indexOfDictionary( Dictionary* aDic ) const + { + for( int i = 0; i < dictionaries.size(); i++ ) + { + QPair pair = dictionaries.at( i ); + if( pair.first == aDic ) + return i; + } + return -1; // Not found + } + +int AppModel::indexOfDictionary( const QString& aFilePath ) const + { + for( int i = 0; i < dictionaries.size(); i++ ) + { + QPair pair = dictionaries.at( i ); + Q_ASSERT( pair.first ); + if( pair.first->getFilePath() == aFilePath ) + return i; + } + return -1; // Not found + } + +CardPack* AppModel::curCardPack() + { + Dictionary* curDic = curDictionary(); + if( curDic ) + return curDic->cardPack( curCardPackIndex ); + else + return NULL; + } + +bool AppModel::setCurDictionary(int index) + { + if( dictionaries.isEmpty() ) + { + curDictIndex = -1; + return false; + } + if( index < 0 || index >= dictionaries.size()) + { + curDictIndex = dictionaries.size()-1; + return false; + } + curDictIndex = index; + return true; + } + +bool AppModel::removeDictionary( int aIndex ) + { + if( aIndex < 0 || aIndex >= dictionaries.size() ) + return false; + QPair pair = dictionaries.takeAt( aIndex ); + delete pair.second; + delete pair.first; + return true; + } + +/** Destroys dic model and the dictionary itself. + */ +void AppModel::removeDictModel( QAbstractItemModel* aDictModel ) + { + int i = 0; + for( ;i < dictionaries.size(); i++ ) + { + QPair pair = dictionaries.at( i ); + if( pair.second == aDictModel ) + { + dictionaries.removeAt( i ); // Update the size of m_dictionaries before destroying + delete pair.first; + delete pair.second; + break; + } + } + } + +IStudyModel* AppModel::createStudyModel(int studyType, int cardPackIndex) + { + Dictionary* curDic = curDictionary(); + if(!curDic) + { + errorMessage = tr("No dictionary opened."); + return NULL; + } + if(curDic->entriesNum() == 0) + { + errorMessage = tr("The current dictionary is empty."); + return NULL; + } + + curCardPackIndex = cardPackIndex; + CardPack* cardPack = curDic->cardPack(curCardPackIndex); + if(!cardPack || cardPack->cardsNum() == 0) + { + errorMessage = tr("The current dictionary is empty."); + return NULL; + } + + IStudyModel* studyModel = NULL; + switch(studyType) + { + case WordDrill: + studyModel = new WordDrillModel(cardPack); + break; + case SpacedRepetition: + studyModel = new SpacedRepetitionModel(cardPack, new RandomGenerator); + break; + } + if(studyModel) + studyModel->setDictModel( curDictModel() ); + return studyModel; + } diff --git a/src/main-view/AppModel.h b/src/main-view/AppModel.h new file mode 100644 index 0000000..bf1ddd2 --- /dev/null +++ b/src/main-view/AppModel.h @@ -0,0 +1,64 @@ +#ifndef APPMODEL_H +#define APPMODEL_H + +#include +#include +#include +#include + +class Dictionary; +class DictTableModel; +class CardPack; +class IStudyModel; + +class AppModel: public QObject +{ +Q_OBJECT + +public: + enum StudyType + { + WordDrill, + SpacedRepetition, + StudyTypesNum + }; + +public: + AppModel(); + ~AppModel(); + + bool openDictionary( const QString& filePath ); + void addDictionary( Dictionary* aDict ); + Dictionary* newDictionary(); + Dictionary* curDictionary(); + int getCurDictIndex() const { return curDictIndex; } + DictTableModel* curDictModel(); + int dictionariesNum() const { return dictionaries.size(); } + Dictionary* dictionary(int aIndex) const; + int indexOfDictionary( Dictionary* aDic ) const; + int indexOfDictionary( const QString& aFilePath ) const; + // TODO: Synchronize this with the pack tree view selection + int curCardPackIx() const { return curCardPackIndex; } + CardPack* curCardPack(); + QString getErrorMessage() const { return errorMessage; } + +public slots: + /** @return true, if the dictionary was successfully set. false, if there are no dictionaries, or the index is out of range. + * If the index is out of range, the last dictionary from the list is set. + */ + bool setCurDictionary(int index); + bool removeDictionary(int aIndex); + void removeDictModel(QAbstractItemModel* aDictModel); + IStudyModel* createStudyModel(int studyType, int cardPackIndex); + +private: + void fixupCurDictIx(); + +private: + QList< QPair > dictionaries; + QString errorMessage; + int curDictIndex; + int curCardPackIndex; +}; + +#endif diff --git a/src/main-view/CardFilterModel.cpp b/src/main-view/CardFilterModel.cpp new file mode 100644 index 0000000..50ac75d --- /dev/null +++ b/src/main-view/CardFilterModel.cpp @@ -0,0 +1,24 @@ +#include "CardFilterModel.h" + +CardFilterModel::CardFilterModel( QObject* parent ): + QSortFilterProxyModel( parent ) + { + } + +void CardFilterModel::addFilterRow( int aRow ) + { + if( m_filterRows.contains( aRow ) ) + return; + m_filterRows << aRow; + } + +void CardFilterModel::removeFilterRow( int aRow ) + { + m_filterRows.removeOne( aRow ); + } + +bool CardFilterModel::filterAcceptsRow( int source_row, const QModelIndex& source_parent ) const + { + Q_UNUSED( source_parent ); + return m_filterRows.contains( source_row ); + } diff --git a/src/main-view/CardFilterModel.h b/src/main-view/CardFilterModel.h new file mode 100644 index 0000000..7c6e9f2 --- /dev/null +++ b/src/main-view/CardFilterModel.h @@ -0,0 +1,21 @@ +#ifndef CARDFILTERMODEL_H +#define CARDFILTERMODEL_H + +#include + +class CardFilterModel : public QSortFilterProxyModel + { + Q_OBJECT +public: + CardFilterModel( QObject* parent ); + void addFilterRow( int aRow ); + void removeFilterRow( int aRow ); + +protected: + bool filterAcceptsRow( int source_row, const QModelIndex& source_parent ) const; + +private: + QList m_filterRows; + }; + +#endif // CARDFILTERMODEL_H diff --git a/src/main-view/CardPreview.cpp b/src/main-view/CardPreview.cpp new file mode 100644 index 0000000..aa59031 --- /dev/null +++ b/src/main-view/CardPreview.cpp @@ -0,0 +1,55 @@ +#include "CardPreview.h" +#include "../study/CardSideView.h" +#include "../dictionary/Card.h" + +CardPreview::CardPreview(QWidget* parent): + QDockWidget(parent) +{ + setDockProperties(); + createCardSides(); + createInternalWidget(); +} + +void CardPreview::setDockProperties() +{ + setWindowTitle(tr("Card preview")); + setObjectName("Card-preview"); + setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); +} + +void CardPreview::createCardSides() +{ + questionSide = new CardSideView(CardSideView::QstMode); + answerSide = new CardSideView(CardSideView::AnsMode); +} + +void CardPreview::createInternalWidget() +{ + QVBoxLayout* mainLt = new QVBoxLayout; + mainLt->addWidget(questionSide, 1); + mainLt->addWidget(answerSide, 1); + + QWidget* internalWidget = new QWidget; + internalWidget->setLayout(mainLt); + setWidget(internalWidget); +} + +void CardPreview::setPack(const CardPack* pack) +{ + questionSide->setPack(pack); + answerSide->setPack(pack); +} + +void CardPreview::setContent(const CardPack* pack, Card* card) +{ + setPack(pack); + QString question; + QStringList answers; + if(card) + { + question = card->getQuestion(); + answers = card->getAnswers(); + } + questionSide->setQuestion(question); + answerSide->setQstAnsr(question, answers); +} diff --git a/src/main-view/CardPreview.h b/src/main-view/CardPreview.h new file mode 100644 index 0000000..6217c96 --- /dev/null +++ b/src/main-view/CardPreview.h @@ -0,0 +1,30 @@ +#ifndef CARD_PREVIEW_H +#define CARD_PREVIEW_H + +#include +#include + +class CardSideView; +class Card; +class CardPack; + +class CardPreview: public QDockWidget +{ + Q_OBJECT + +public: + CardPreview(QWidget* parent); + void setContent(const CardPack* pack, Card* card); + +private: + void createCardSides(); + void createInternalWidget(); + void setDockProperties(); + void setPack(const CardPack* pack); + +private: + CardSideView* questionSide; + CardSideView* answerSide; +}; + +#endif diff --git a/src/main-view/DictTableDelegate.cpp b/src/main-view/DictTableDelegate.cpp new file mode 100644 index 0000000..1e1d609 --- /dev/null +++ b/src/main-view/DictTableDelegate.cpp @@ -0,0 +1,128 @@ +#include "DictTableDelegate.h" +#include + +#include "DictTableModel.h" +#include "UndoCommands.h" +#include "DictTableDelegatePainter.h" +#include "FieldContentCodec.h" +#include "../dictionary/Dictionary.h" + +QWidget* DictTableDelegate::createEditor( QWidget* parent, + const QStyleOptionViewItem& option, const QModelIndex& /*index*/ ) const +{ + editor = new RecordEditor(parent, option.rect); + connect( editor, SIGNAL(destroyed()), SIGNAL(editorDestroyed()) ); + emit editorCreated(); + return editor; +} + +void DictTableDelegate::updateEditorGeometry(QWidget* editor, + const QStyleOptionViewItem& /*option*/, const QModelIndex& index) const +{ + setEditorData(editor, index); + RecordEditor* recordEditor = qobject_cast(editor); + recordEditor->updateEditor(); +} + +bool DictTableDelegate::eventFilter(QObject *object, QEvent *event) +{ + QWidget* editor = qobject_cast(object); + if (!editor) + return false; + if(event->type() == QEvent::KeyPress) + switch( static_cast(event)->key() ) + { + case Qt::Key_Enter: + case Qt::Key_Return: + case Qt::Key_Tab: + emit commitData(editor); + emit closeEditor(editor, QAbstractItemDelegate::EditNextItem); + return true; + default: + break; + } + return QStyledItemDelegate::eventFilter(object, event); +} + +void DictTableDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const +{ + RecordEditor* recordEditor = qobject_cast(editor); + FieldContentCodec codec(recordEditor); + codec.parse(getDisplayText(index)); +} + +QString DictTableDelegate::getDisplayText(const QModelIndex& index) const +{ + return index.data(Qt::EditRole).toString(); +} + +void DictTableDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, + const QModelIndex& index) const + { + RecordEditor* recordEditor = qobject_cast(editor); + DictTableModel* tableModel = qobject_cast( model ); + QString editorText = recordEditor->getText(); + QModelIndex origIndex = index; + if( !tableModel ) + { + QAbstractProxyModel* proxyModel = qobject_cast( model ); + if( !proxyModel ) + return; + tableModel = qobject_cast( proxyModel->sourceModel() ); + if( !tableModel ) + return; + origIndex = proxyModel->mapToSource( index ); + } + if(editorText == getDisplayText(index) && !indexIsLastCell(origIndex, model)) + return; + QString newText = tableModel->dictionary()->shortenImagePaths(editorText); + QUndoCommand* command = new EditRecordCmd( tableModel, origIndex, newText ); + tableModel->undoStack()->push( command ); +} + +bool DictTableDelegate::indexIsLastCell(const QModelIndex& index, + QAbstractItemModel* model) const +{ + return index.row() == model->rowCount() - 1 && + index.column() == model->columnCount() - 1; +} + +void DictTableDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, + const QModelIndex& index) const +{ + QStyledItemDelegate::paint(painter, option, index); + DictTableDelegatePainter dPainter(painter, getMarginRect(option), + option.fontMetrics); + FieldContentCodec codec(&dPainter); + codec.parse(getDisplayText(index)); +} + +QRect DictTableDelegate::getMarginRect(const QStyleOptionViewItem& option) const +{ + const int margin = 2; + return option.rect.adjusted(margin, 0, -margin, 0); +} + +int DictTableDelegate::getCursorPos() const +{ + if(editor) + return editor->textCursor().position(); + else + return -1; +} + +void DictTableDelegate::setCursorPos(int pos) +{ + if(!editor) + return; + QTextCursor cursor = editor->textCursor(); + cursor.setPosition(pos); + editor->setTextCursor(cursor); +} + +void DictTableDelegate::insertImageIntoEditor(int cursorPos, const QString& filePath) +{ + if(!editor) + return; + editor->insertImage(cursorPos, filePath); +} diff --git a/src/main-view/DictTableDelegate.h b/src/main-view/DictTableDelegate.h new file mode 100644 index 0000000..cf43fc5 --- /dev/null +++ b/src/main-view/DictTableDelegate.h @@ -0,0 +1,44 @@ +#ifndef DICT_TABLE_DELEGATE_H +#define DICT_TABLE_DELEGATE_H + +#include + +#include "RecordEditor.h" + +class DictTableDelegate: public QStyledItemDelegate +{ +Q_OBJECT + +public: + DictTableDelegate(QObject* parent): + QStyledItemDelegate(parent), editor(NULL) {} + QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, + const QModelIndex& index) const; + void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, + const QModelIndex& index) const; + bool eventFilter(QObject *object, QEvent *event); + void setEditorData(QWidget* editor, const QModelIndex& index) const; + void setModelData(QWidget* editor, QAbstractItemModel* model, + const QModelIndex& index) const; + void paint(QPainter* painter, const QStyleOptionViewItem& option, + const QModelIndex& index) const; + int getCursorPos() const; + void setCursorPos(int pos); + void insertImageIntoEditor(int cursorPos, const QString& filePath); + QWidget* getEditor() const { return editor; } + +private: + QString getDisplayText(const QModelIndex& index) const; + QRect getMarginRect(const QStyleOptionViewItem& option) const; + bool indexIsLastCell(const QModelIndex& index, QAbstractItemModel* model) const; + +signals: + void editorCreated() const; + void editorDestroyed() const; + +private: + mutable RecordEditor* editor; +}; + +#endif + diff --git a/src/main-view/DictTableDelegatePainter.cpp b/src/main-view/DictTableDelegatePainter.cpp new file mode 100644 index 0000000..2714bdc --- /dev/null +++ b/src/main-view/DictTableDelegatePainter.cpp @@ -0,0 +1,61 @@ +#include "DictTableDelegatePainter.h" + +DictTableDelegatePainter::DictTableDelegatePainter(QPainter* painter, + const QRect& contentRect, const QFontMetrics& fontMetrics): + painter(painter), contentRect(contentRect), fontMetrics(fontMetrics) +{ + initLoopParams(); +} + +void DictTableDelegatePainter::initLoopParams() +{ + offset = 0; + textFitstoRect = true; +} + +void DictTableDelegatePainter::startDrawing() +{ + painter->save(); + painter->setClipRect(contentRect); + initLoopParams(); +} + +void DictTableDelegatePainter::endDrawing() +{ + painter->restore(); +} + +void DictTableDelegatePainter::drawText(const QString& text) +{ + if(!textFitstoRect) + return; + QString elidedText = getElidedText(text); + textFitstoRect = elidedText == text; + painter->drawText(contentRect.translated(offset, 0), + elidedText, getTextOption()); + offset += fontMetrics.width(elidedText); +} + +void DictTableDelegatePainter::drawImage(const QString& filePath) +{ + if(!textFitstoRect) + return; + QPixmap image(filePath); + if(image.isNull()) + image = QPixmap(":/images/broken-image.png"); + image = image.scaledToHeight(ThumbnailSize, Qt::SmoothTransformation); + painter->drawPixmap(contentRect.topLeft() + QPoint(offset, 0), image); + offset += image.width(); +} + +QString DictTableDelegatePainter::getElidedText(const QString& text) +{ + return fontMetrics.elidedText(text, Qt::ElideRight, contentRect.width() - offset); +} + +QTextOption DictTableDelegatePainter::getTextOption() +{ + QTextOption textOption(Qt::AlignVCenter); + textOption.setWrapMode(QTextOption::NoWrap); + return textOption; +} diff --git a/src/main-view/DictTableDelegatePainter.h b/src/main-view/DictTableDelegatePainter.h new file mode 100644 index 0000000..985ecac --- /dev/null +++ b/src/main-view/DictTableDelegatePainter.h @@ -0,0 +1,36 @@ +#ifndef DICT_TABLE_DELEGATE_PAINTER_H +#define DICT_TABLE_DELEGATE_PAINTER_H + +#include + +#include "FieldContentPainter.h" + +class DictTableDelegatePainter: public FieldContentPainter +{ +private: + static QTextOption getTextOption(); + +private: + static const int ThumbnailSize = 25; + +public: + DictTableDelegatePainter(QPainter* painter, const QRect& contentRect, + const QFontMetrics& fontMetrics); + void startDrawing(); + void endDrawing(); + void drawText(const QString& text); + void drawImage(const QString& filePath); + +private: + void initLoopParams(); + QString getElidedText(const QString& text); + +private: + QPainter* painter; + QRect contentRect; + QFontMetrics fontMetrics; + int offset; + bool textFitstoRect; +}; +#endif + diff --git a/src/main-view/DictTableModel.cpp b/src/main-view/DictTableModel.cpp new file mode 100644 index 0000000..b7b7eed --- /dev/null +++ b/src/main-view/DictTableModel.cpp @@ -0,0 +1,142 @@ +#include + +#include "DictTableModel.h" +#include "UndoCommands.h" +#include "../dictionary/Dictionary.h" +#include "../dictionary/DicRecord.h" +#include "../dictionary/Field.h" + +DictTableModel::DictTableModel( Dictionary* aDict, QObject *parent ): + QAbstractTableModel( parent ), m_dictionary( aDict ) + { + m_undoStack = new QUndoStack( this ); + connect( m_dictionary, SIGNAL(destroyed(QObject*)), SLOT(discardCurDictionary()) ); + } + +int DictTableModel::rowCount( const QModelIndex &/*parent*/ ) const + { + if( m_dictionary ) + return m_dictionary->entriesNum(); + else + return 0; + } + +int DictTableModel::columnCount(const QModelIndex &/*parent*/) const + { + if( m_dictionary ) + return m_dictionary->fieldsNum(); + else + return 0; + } + +QVariant DictTableModel::data( const QModelIndex &index, int role ) const + { + if( !m_dictionary || !index.isValid() || index.row() >= rowCount() || + index.column() >= columnCount() ) + return QVariant(); + QString text = m_dictionary->getFieldValue(index.row(), index.column()); + switch(role) + { + case Qt::DisplayRole: + return QVariant(); + case Qt::EditRole: + return m_dictionary->extendImagePaths(text); + case DicRecordRole: + { + const DicRecord* record = m_dictionary->getRecord(index.row()); + return QVariant::fromValue(*record); + } + default: + return QVariant(); + } + } + +QVariant DictTableModel::headerData( int section, Qt::Orientation orientation, int role ) const + { + if( !m_dictionary ) + return QVariant(); + switch( role ) + { + case Qt::DisplayRole: + if(orientation == Qt::Vertical) + return QString::number( section + 1 ); + else + { + if( section < columnCount() ) + return m_dictionary->field( section )->name(); + else + return QVariant(); + } + default: + return QVariant(); + } + } + +bool DictTableModel::setData( const QModelIndex &index, const QVariant &value, int role ) + { + if( !index.isValid() || !m_dictionary ) + return false; + if( value == data( index, role ) ) + return false; + + switch( role ) + { + case Qt::DisplayRole: + case Qt::EditRole: + m_dictionary->setFieldValue(index.row(), index.column(), value.toString()); + break; + case DicRecordRole: + { + DicRecord record = value.value(); + m_dictionary->setRecord( index.row(), record ); + break; + } + default: + return false; + } + emit dataChanged( index, index ); + return true; + } + +bool DictTableModel::insertRows( int position, int rows, const QModelIndex& /*parent*/ ) + { + if( !m_dictionary ) + return false; + beginInsertRows( QModelIndex(), position, position + rows - 1 ); + m_dictionary->insertEntries( position, rows ); + endInsertRows(); + return true; + } + +bool DictTableModel::addFields( QStringList aFields ) + { + if( !m_dictionary ) + return false; + beginInsertColumns( QModelIndex(), columnCount(), columnCount() + aFields.size() - 1 ); + m_dictionary->addFields( aFields ); + endInsertColumns(); + return true; + } + +bool DictTableModel::removeRows( int position, int rows, const QModelIndex& /*parent*/ ) + { + if( !m_dictionary ) + return false; + beginRemoveRows( QModelIndex(), position, position + rows - 1 ); + m_dictionary->removeRecords( position, rows ); + endRemoveRows(); + return true; + } + +void DictTableModel::resetData() // TODO: Suspicious method, just reveals protected methods + { + beginResetModel(); + endResetModel(); + } + +void DictTableModel::discardCurDictionary() + { + beginResetModel(); + m_dictionary = NULL; + endResetModel(); + } diff --git a/src/main-view/DictTableModel.h b/src/main-view/DictTableModel.h new file mode 100644 index 0000000..0293ace --- /dev/null +++ b/src/main-view/DictTableModel.h @@ -0,0 +1,52 @@ +#ifndef DICTTABLEMODEL_H +#define DICTTABLEMODEL_H + +#include +#include + +class Dictionary; +class DicRecord; + +class DictTableModel: public QAbstractTableModel +{ + Q_OBJECT + +public: + enum + { + DicRecordRole = Qt::UserRole + }; + + DictTableModel( Dictionary* aDict, QObject *parent = 0 ); + + // Getters + + const Dictionary* dictionary() const { return m_dictionary; } + QUndoStack* undoStack() const { return m_undoStack; } + + Qt::ItemFlags flags( const QModelIndex& index ) const { return QAbstractItemModel::flags( index ) | Qt::ItemIsEditable; } + int rowCount( const QModelIndex& parent = QModelIndex() ) const; + int columnCount( const QModelIndex& parent = QModelIndex() ) const; + QVariant data(const QModelIndex& index, int role) const; + QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const; + + // Setters + + bool setData( const QModelIndex &index, const QVariant& value, int role = Qt::EditRole ); + bool insertRows( int position, int rows, const QModelIndex& index = QModelIndex() ); + bool addFields( QStringList aFields ); + bool removeRows( int position, int rows, const QModelIndex& index = QModelIndex() ); + +public slots: + void resetData(); + +private slots: + void discardCurDictionary(); + +private: + static const int ThumbnailSize = 25; ///< Size of image thumbnails + + Dictionary* m_dictionary; // not own + QUndoStack* m_undoStack; +}; +#endif diff --git a/src/main-view/DictTableView.cpp b/src/main-view/DictTableView.cpp new file mode 100644 index 0000000..9d61fad --- /dev/null +++ b/src/main-view/DictTableView.cpp @@ -0,0 +1,84 @@ +#include "DictTableView.h" +#include "DictTableDelegate.h" + +#include +#include +#include + +#include "DictTableModel.h" + +DictTableView::DictTableView( QAbstractItemModel* aModel, QWidget* aParent ): + QTableView( aParent ) + { + setModel( aModel ); + connect( aModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)), + SLOT(disableUpdates()) ); + connect( aModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), + SLOT(enableUpdates()) ); + setItemDelegate( new DictTableDelegate(this) ); + setAlternatingRowColors(true); + setShowGrid(true); + verticalHeader()->setDefaultSectionSize( RowHeight ); + setSelectionBehavior( QAbstractItemView::SelectRows ); + resizeColumnsToContents(); + horizontalHeader()->stretchLastSection(); + } + +DictTableView::~DictTableView() + { + emit destroyed( model() ); + } + +DictTableModel* DictTableView::dicTableModel() const + { + DictTableModel* tableModel = qobject_cast( model() ); + if( tableModel ) + return tableModel; + QAbstractProxyModel* proxyModel = qobject_cast( model() ); + if( proxyModel ) + { + tableModel = qobject_cast( proxyModel->sourceModel() ); + if( tableModel ) + return tableModel; + } + return NULL; + } + +void DictTableView::resizeColumnsToContents() + { + QTableView::resizeColumnsToContents(); + for( int i=0; icolumnCount(); i++ ) + if( columnWidth( i ) < KMinColWidth ) + setColumnWidth( i, KMinColWidth ); + else if ( columnWidth( i ) > KMaxColWidth ) + setColumnWidth( i, KMaxColWidth ); +} + +void DictTableView::startEditing(int row, int col) +{ + edit(model()->index(row, col)); +} + +void DictTableView::commitEditing() +{ + DictTableDelegate* delegate = qobject_cast(itemDelegate()); + if(!delegate) + return; + commitData(delegate->getEditor()); +} + +int DictTableView::getEditorCursorPos() const +{ + DictTableDelegate* delegate = qobject_cast(itemDelegate()); + if(!delegate) + return -1; + return delegate->getCursorPos(); +} + +void DictTableView::insertImageIntoEditor(int cursorPos, const QString& filePath) const +{ + DictTableDelegate* delegate = qobject_cast(itemDelegate()); + if(!delegate) + return; + delegate->insertImageIntoEditor(cursorPos, filePath); +} diff --git a/src/main-view/DictTableView.h b/src/main-view/DictTableView.h new file mode 100644 index 0000000..b34df65 --- /dev/null +++ b/src/main-view/DictTableView.h @@ -0,0 +1,36 @@ +#ifndef DICTTABLEVIEW_h +#define DICTTABLEVIEW_h + +#include +#include + +class DictTableModel; + +class DictTableView: public QTableView +{ +Q_OBJECT + +public: + DictTableView( QAbstractItemModel* aModel, QWidget* aParent = 0 ); + virtual ~DictTableView(); + void resizeColumnsToContents(); + DictTableModel* dicTableModel() const; + void startEditing(int row, int col); + void commitEditing(); + int getEditorCursorPos() const; + void insertImageIntoEditor(int cursorPos, const QString& filePath) const; + +private slots: + void enableUpdates() { setUpdatesEnabled(true); } + void disableUpdates() { setUpdatesEnabled(false); } + +signals: + void destroyed( QAbstractItemModel* aDictModel ); + +private: + static const int KMinColWidth = 170; + static const int KMaxColWidth = 400; + static const int RowHeight = 27; +}; + +#endif diff --git a/src/main-view/DictionaryTabWidget.cpp b/src/main-view/DictionaryTabWidget.cpp new file mode 100644 index 0000000..94f090c --- /dev/null +++ b/src/main-view/DictionaryTabWidget.cpp @@ -0,0 +1,108 @@ +#include "DictionaryTabWidget.h" +#include "MainWindow.h" +#include "DictTableModel.h" +#include "DictTableView.h" +#include "../dictionary/Dictionary.h" + +DictionaryTabWidget::DictionaryTabWidget(MainWindow* aMainWin): + QTabWidget( aMainWin ), m_mainWin( aMainWin ), createdEditorsNum(0) + { + setDocumentMode( true ); + setTabsClosable( true ); + setMovable( true ); + connect( this, SIGNAL(tabCloseRequested(int)), SLOT(closeTab(int)) ); + m_undoGroup = new QUndoGroup( this ); + + m_continueLbl = new QLabel( this ); + m_continueLbl->hide(); + m_continueLbl->setPixmap(QPixmap(":/images/continue-search.png")); + } + + +/** The tab is removed automatically when the widget is destroyed. + The undo stack is removed from group automatically, when the stack is destroyed. + */ +void DictionaryTabWidget::closeTab( int aIndex ) + { + if( aIndex == -1 ) + aIndex = currentIndex(); + bool canRemove = m_mainWin->proposeToSave( aIndex ); + if( canRemove ) + delete widget( aIndex ); + } + +int DictionaryTabWidget::addDictTab( DictTableModel* aDictModel ) + { + DictTableView* dictView = new DictTableView( aDictModel ); + int tabIx = addTab( dictView, "" ); + setCurrentIndex( tabIx ); + QUndoStack* undoStack = aDictModel->undoStack(); + m_undoGroup->addStack( undoStack ); + m_undoGroup->setActiveStack( undoStack ); + connect( undoStack, SIGNAL(cleanChanged(bool)), aDictModel->dictionary(), SLOT(setContentClean(bool)) ); + connect( dictView->itemDelegate(), SIGNAL(editorCreated()), SLOT(createEditor()) ); + connect( dictView->itemDelegate(), SIGNAL(editorDestroyed()), SLOT(destroyEditor()) ); + return tabIx; + } + +const DictTableView* DictionaryTabWidget::curDictView() const + { + QWidget* curWidget = currentWidget(); + if( !curWidget ) + return NULL; + DictTableView* curView = static_cast( curWidget ); + return curView; + } + +void DictionaryTabWidget::setCurrentIndex( int aTabIx ) + { + QTabWidget::setCurrentIndex( aTabIx ); + const DictTableView* dictView = curDictView(); + if( dictView ) + { + const DictTableModel* dictModel = dictView->dicTableModel(); + if( dictModel ) + m_undoGroup->setActiveStack( dictModel->undoStack() ); + } + } + +void DictionaryTabWidget::goToDictionaryRecord( int aDictIx, int aRecordRow ) + { + setCurrentIndex( aDictIx ); + QWidget* curWidget = currentWidget(); + Q_ASSERT( curWidget ); + QAbstractItemView* curView = static_cast( curWidget ); + Q_ASSERT( curView ); + curView->setFocus(); + QModelIndex index = curView->model()->index( aRecordRow, 0 ); + curView->setCurrentIndex( index ); + } + +void DictionaryTabWidget::cleanUndoStack() +{ + m_undoGroup->activeStack()->setClean(); +} + +bool DictionaryTabWidget::undoStackIsClean() const +{ + return m_undoGroup->isClean(); +} + +void DictionaryTabWidget::showContinueSearch() +{ + m_continueLbl->move( rect().center() - m_continueLbl->rect().center() ); + m_continueLbl->show(); + QTimer::singleShot( 500, m_continueLbl, SLOT(hide()) ); +} + +void DictionaryTabWidget::createEditor() +{ + createdEditorsNum++; + emit editingStateChanged(); +} + +void DictionaryTabWidget::destroyEditor() +{ + createdEditorsNum--; + emit editingStateChanged(); +} diff --git a/src/main-view/DictionaryTabWidget.h b/src/main-view/DictionaryTabWidget.h new file mode 100644 index 0000000..b5bd3c7 --- /dev/null +++ b/src/main-view/DictionaryTabWidget.h @@ -0,0 +1,46 @@ +#ifndef DICTIONARYTABWIDGET_H +#define DICTIONARYTABWIDGET_H + +#include +#include + +class MainWindow; +class FilterBar; +class DictTableModel; +class DictTableView; +class Dictionary; + +class DictionaryTabWidget : public QTabWidget +{ + Q_OBJECT +public: + DictionaryTabWidget(MainWindow* aMainWin); + + int addDictTab( DictTableModel* aDictModel ); + void setCurrentIndex( int aTabIx ); + void goToDictionaryRecord( int aDictIx, int aRecordRow ); + void cleanUndoStack(); + void showContinueSearch(); + + const DictTableView* curDictView() const; + QUndoGroup* undoGroup() const { return m_undoGroup; } + bool undoStackIsClean() const; + bool isInEditingState() const { return createdEditorsNum > 0; } + +public slots: + void closeTab( int aIndex = -1 ); + +private slots: + void createEditor(); + void destroyEditor(); + +signals: + void editingStateChanged(); + +private: + MainWindow* m_mainWin; // parent, now own + QUndoGroup* m_undoGroup; + QLabel* m_continueLbl; // Continue search icon + int createdEditorsNum; +}; +#endif // DICTIONARYTABWIDGET_H diff --git a/src/main-view/FieldContentCodec.cpp b/src/main-view/FieldContentCodec.cpp new file mode 100644 index 0000000..ac9e6c5 --- /dev/null +++ b/src/main-view/FieldContentCodec.cpp @@ -0,0 +1,52 @@ +#include "FieldContentCodec.h" + +#include "FieldContentPainter.h" + +FieldContentCodec::FieldContentCodec(FieldContentPainter* painter): + painter(painter), + imageRx("") +{ + initLoopParams(); +} + +void FieldContentCodec::initLoopParams() +{ + textPos = 0; + prevTextPos = 0; +} + +void FieldContentCodec::parse(const QString& text) +{ + painter->startDrawing(); + initLoopParams(); + this->text = text; + + while(findNextImage() >= 0) + { + drawTextChunk(textPos - prevTextPos); + drawImage(); + textPos += imageRx.matchedLength(); + prevTextPos = textPos; + } + drawTextChunk(-1); + painter->endDrawing(); +} + +int FieldContentCodec::findNextImage() +{ + textPos = imageRx.indexIn(text, textPos); + return textPos; +} + +void FieldContentCodec::drawTextChunk(int len) +{ + painter->drawText(text.mid(prevTextPos, len)); +} + +void FieldContentCodec::drawImage() +{ + QString imagePath = imageRx.cap(1); + if(!QFileInfo(imagePath).exists()) + imagePath = ":/images/broken-image.png"; + painter->drawImage(imagePath); +} diff --git a/src/main-view/FieldContentCodec.h b/src/main-view/FieldContentCodec.h new file mode 100644 index 0000000..8a13dba --- /dev/null +++ b/src/main-view/FieldContentCodec.h @@ -0,0 +1,28 @@ +#ifndef FIELD_CONTENT_CODEC_H +#define FIELD_CONTENT_CODEC_H + +#include + +class FieldContentPainter; + +class FieldContentCodec +{ +public: + FieldContentCodec(FieldContentPainter* painter); + void parse(const QString& text); + +private: + void initLoopParams(); + int findNextImage(); + void drawTextChunk(int len); + void drawImage(); + +private: + FieldContentPainter* painter; + QString text; + QRegExp imageRx; + int textPos; + int prevTextPos; +}; +#endif + diff --git a/src/main-view/FieldContentPainter.h b/src/main-view/FieldContentPainter.h new file mode 100644 index 0000000..eb0679a --- /dev/null +++ b/src/main-view/FieldContentPainter.h @@ -0,0 +1,16 @@ +#ifndef FIELD_CONTENT_PAINTER_H +#define FIELD_CONTENT_PAINTER_H + +#include + +class FieldContentPainter +{ +public: + virtual ~FieldContentPainter() {} + virtual void startDrawing() = 0; + virtual void endDrawing() = 0; + virtual void drawText(const QString& text) = 0; + virtual void drawImage(const QString& filePath) = 0; +}; +#endif + diff --git a/src/main-view/FindPanel.cpp b/src/main-view/FindPanel.cpp new file mode 100644 index 0000000..755fa50 --- /dev/null +++ b/src/main-view/FindPanel.cpp @@ -0,0 +1,258 @@ +#include "FindPanel.h" + +#include +#include +#include +#include + +#include "DictTableView.h" +#include "MainWindow.h" + +FindPanel::FindPanel( MainWindow* aMainWindow ): + QWidget( aMainWindow ), + m_mainWindow( aMainWindow ), m_direction( 1 ), m_foundOnce(false) + { + m_closeButton = new QToolButton; + m_closeButton->setAutoRaise(true); + m_closeButton->setIcon(QIcon(":/images/gray-cross.png")); + m_closeButton->setToolTip(tr("Close")); + + QLabel* textLabel = new QLabel(tr("Find:", "Title of the find pane")); + + m_textEdit = new QComboBox; + textLabel->setBuddy(m_textEdit); + m_textEdit->setEditable(true); + m_textEdit->setInsertPolicy( QComboBox::NoInsert ); + m_textEdit->setMaxCount( ComboBoxMaxItems ); + m_textEdit->setMinimumWidth( TextEditMinWidth ); + m_textEdit->setFocus(); + + m_findBackwardBtn = new QToolButton; + m_findBackwardBtn->resize(32, 32); + m_findBackwardBtn->setObjectName("backward"); + m_findBackwardBtn->setIcon(QIcon(":/images/1leftarrow.png")); + m_findBackwardBtn->setToolTip(tr("Find previous")); + m_findBackwardBtn->setEnabled(false); + + m_findForwardBtn = new QToolButton; + m_findForwardBtn->setObjectName("forward"); + m_findForwardBtn->setIcon(QIcon(":/images/1rightarrow.png")); + m_findForwardBtn->setToolTip(tr("Find next")); + m_findForwardBtn->setEnabled(false); + + m_caseSensitiveBtn = new QToolButton; + m_caseSensitiveBtn->setAutoRaise(true); + m_caseSensitiveBtn->setCheckable( true ); + m_caseSensitiveBtn->setIcon(QIcon(":/images/Aa.png")); + m_caseSensitiveBtn->setToolTip(tr("Case sensitive")); + + m_wholeWordsBtn = new QToolButton; + m_wholeWordsBtn->setAutoRaise(true); + m_wholeWordsBtn->setCheckable( true ); + m_wholeWordsBtn->setIcon(QIcon(":/images/whole-words.png")); + m_wholeWordsBtn->setToolTip(tr("Whole words")); + + m_regExpBtn = new QToolButton; + m_regExpBtn->setAutoRaise(true); + m_regExpBtn->setCheckable( true ); + m_regExpBtn->setIcon(QIcon(":/images/RX.png")); + m_regExpBtn->setToolTip(tr("Regular expression")); + + m_inSelectionBtn = new QToolButton; + m_inSelectionBtn->setAutoRaise(true); + m_inSelectionBtn->setCheckable( true ); + m_inSelectionBtn->setIcon(QIcon(":/images/selection.png")); + m_inSelectionBtn->setToolTip(tr("In selection")); + + QLabel* infoIconLbl = new QLabel; + infoIconLbl->setPixmap( QPixmap(":/images/warning.png").scaled( + 16, 16, Qt::KeepAspectRatio, Qt::SmoothTransformation ) ); + m_infoLbl = new QLabel(tr("String is not found")); + QHBoxLayout* infoLt = new QHBoxLayout; + infoLt->setContentsMargins( QMargins() ); + infoLt->addWidget( infoIconLbl ); + infoLt->addWidget( m_infoLbl ); + m_infoPane = new QWidget; + m_infoPane->setLayout( infoLt ); + m_infoPane->hide(); + + QHBoxLayout* mainLayout = new QHBoxLayout; + mainLayout->addWidget( m_closeButton ); + mainLayout->addWidget( textLabel ); + mainLayout->addWidget( m_textEdit ); + mainLayout->addWidget( m_findBackwardBtn ); + mainLayout->addWidget( m_findForwardBtn ); + mainLayout->addWidget( m_caseSensitiveBtn ); + mainLayout->addWidget( m_wholeWordsBtn ); + mainLayout->addWidget( m_regExpBtn ); + mainLayout->addWidget( m_inSelectionBtn ); + mainLayout->addSpacing( 50 ); + mainLayout->addWidget( m_infoPane ); + mainLayout->addStretch(); + mainLayout->setContentsMargins( QMargins() ); + setLayout( mainLayout ); + + connect( m_inSelectionBtn, SIGNAL(toggled(bool)), SLOT(updateFindButtons()) ); + connect( m_textEdit, SIGNAL(editTextChanged(const QString&)), SLOT(updateFindButtons()) ); + connect( m_textEdit, SIGNAL(editTextChanged(const QString&)), m_infoPane, SLOT(hide()) ); + connect( m_findForwardBtn, SIGNAL(clicked()), this, SLOT(find()) ); + connect( m_findBackwardBtn, SIGNAL(clicked()), this, SLOT(find()) ); + connect( m_closeButton, SIGNAL(clicked()), this, SLOT(hide()) ); + } + +void FindPanel::show() + { + m_textEdit->setFocus(); + m_textEdit->lineEdit()->selectAll(); + QWidget::show(); + } + +void FindPanel::keyPressEvent( QKeyEvent* event ) + { + if( event->key() == Qt::Key_Return ) + find(); + else + QWidget::keyPressEvent( event ); + } + +/** + @arg aDirection 1 = forward; -1 = backward; 0 = previous direction + */ +void FindPanel::find() + { + // Check controls + QString searchText = m_textEdit->currentText(); + if( searchText.isEmpty() ) + return; + + DictTableView* tableView = const_cast( m_mainWindow->getCurDictView() ); + QModelIndexList rows = tableView->selectionModel()->selectedRows(); + if( rows.size() <= 1 && m_inSelectionBtn->isChecked() ) + m_inSelectionBtn->setChecked( false ); + + // Process search parameters + bool inSelection = m_inSelectionBtn->isChecked(); + bool fromCursor = true; + if( inSelection || (rows.size() == 1 && rows.first().row() == 0 ) ) + fromCursor = false; + + // Process direction + if( sender() ) + { + if( sender()->objectName() == "forward" ) + m_direction = 1; + else if( sender()->objectName() == "backward" ) + m_direction = -1; + } + // For "find again" case, the direction stays the same + + // Save the entered text to combobox + int textIndex = m_textEdit->findText( searchText ); + if( textIndex != 0 ) // Don't re-add the same text at the first line + { + if( textIndex > -1 ) // Remove duplicates + m_textEdit->removeItem( textIndex ); + m_textEdit->insertItem( 0, searchText ); + } + + // Create the search regular expression + QString searchRegExpStr; + if( !m_regExpBtn->isChecked() ) + searchRegExpStr = QRegExp::escape( searchText ); + else + searchRegExpStr = searchText; + if( m_wholeWordsBtn->isChecked() ) + searchRegExpStr = "\\b" + searchText + "\\b"; + + QRegExp searchRegExp = QRegExp( searchRegExpStr, + m_caseSensitiveBtn->isChecked()? Qt::CaseSensitive : Qt::CaseInsensitive); + + // Get sorted search range + QModelIndexList searchRange; + if( inSelection ) + { + searchRange = tableView->selectionModel()->selectedIndexes(); + qSort( searchRange ); + } + else // all indexes + { + QAbstractItemModel* tableModel = tableView->model(); + for(int r=0; r < tableModel->rowCount(); r++) + for(int c=0; c < tableModel->columnCount(); c++) + searchRange << tableModel->index(r, c); + } + + // Get the starting search point (iterator) + QListIterator startingPoint( searchRange ); + if( fromCursor ) + { + bool ok = startingPoint.findNext( tableView->currentIndex() ); + if( !ok ) + startingPoint.toFront(); + if( ok && m_direction < 0 ) + startingPoint.previous(); // Go one item backwards + } + else + if( m_direction < 0 ) + startingPoint.toBack(); + + // Try to find the regexp + bool found = findRegExp( searchRegExp, startingPoint ); + if ( !found && fromCursor ) + { + // Continue searching + m_mainWindow->showContinueSearch(); + if( m_direction > 0 ) + startingPoint.toFront(); + else + startingPoint.toBack(); + if( findRegExp( searchRegExp, startingPoint ) ) + found = true; + } + if( !found ) + m_infoPane->show(); + } + +bool FindPanel::findRegExp( const QRegExp& aSearchRegExp, QListIterator aStartingPoint ) + { + DictTableView* tableView = const_cast( m_mainWindow->getCurDictView() ); + QModelIndex foundIndex; + while( (m_direction > 0)? aStartingPoint.hasNext() : aStartingPoint.hasPrevious() ) + { + QModelIndex index = (m_direction > 0)? aStartingPoint.next() : aStartingPoint.previous(); + QString valueStr = index.data( Qt::EditRole ).toString(); // Search in display, not edit, strings. Matters for . + if( valueStr.contains( aSearchRegExp ) ) + { + foundIndex = index; + break; + } + } + if( foundIndex.isValid() ) + { + tableView->setFocus(); + tableView->setCurrentIndex( foundIndex ); + return true; + } + else + return false; + } + +void FindPanel::updateFindButtons() + { + m_findForwardBtn->setEnabled( !m_textEdit->currentText().isEmpty() ); + m_findBackwardBtn->setEnabled( !m_textEdit->currentText().isEmpty() && !m_inSelectionBtn->isChecked() ); + } + +bool FindPanel::canFindAgain() + { + if( !m_foundOnce ) + return false; + const DictTableView* tableView = m_mainWindow->getCurDictView(); + if( tableView && !m_textEdit->currentText().isEmpty() ) + return true; + else + return false; + } + + + diff --git a/src/main-view/FindPanel.h b/src/main-view/FindPanel.h new file mode 100644 index 0000000..553522e --- /dev/null +++ b/src/main-view/FindPanel.h @@ -0,0 +1,66 @@ +#ifndef FINDPANEL_H +#define FINDPANEL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class DictTableView; +class MainWindow; + +/** + * Modern find panel for dictionary records. + */ + +class FindPanel: public QWidget +{ + Q_OBJECT +public: + FindPanel( MainWindow* aMainWindow ); + + void setTableView( DictTableView* aTableView ); + bool canFindAgain(); + +protected: + void keyPressEvent( QKeyEvent* event ); + +private: + bool findRegExp( const QRegExp& aSearchRegExp, QListIterator aStartingPoint ); + +public slots: + void show(); + void find(); + +private slots: + void updateFindButtons(); + +private: + static const int ComboBoxMaxItems = 10; + static const int TextEditMinWidth = 300; + +private: + // Data + MainWindow* m_mainWindow; + int m_direction; // Search direction: 1 or -1 + bool m_foundOnce; // The search text was already found once. For "Find again". + + // GUI + QToolButton* m_closeButton; + QComboBox* m_textEdit; + QToolButton* m_findForwardBtn; + QToolButton* m_findBackwardBtn; + QToolButton* m_caseSensitiveBtn; + QToolButton* m_wholeWordsBtn; + QToolButton* m_regExpBtn; + QToolButton* m_inSelectionBtn; + QWidget* m_infoPane; + QLabel* m_infoLbl; +}; + +#endif diff --git a/src/main-view/LanguageMenu.cpp b/src/main-view/LanguageMenu.cpp new file mode 100644 index 0000000..84ffd46 --- /dev/null +++ b/src/main-view/LanguageMenu.cpp @@ -0,0 +1,64 @@ +#include "LanguageMenu.h" +#include "../main.h" +#include "../strings.h" + +LanguageMenu::LanguageMenu(QMenu* parent): + QMenu(tr("&Language"), parent), + locale(QSettings().value("lang").toString()), + systemLocale(QLocale::system().name().split("_").first()) +{ + initUi(parent); + initLangs(); + createActionsGroup(); + foreach(QString key, langs.keys()) + createAction(key); +} + +void LanguageMenu::initUi(QMenu* parent) +{ + parent->addMenu(this); + setIcon(QIcon(":/images/language.png")); +} + +void LanguageMenu::initLangs() +{ + langs["cs"] = "Čeština (Czech)"; + langs["fi"] = "Suomi (Finnish)"; + langs["fr"] = "Français (French)"; + langs["de"] = "Deutsch (German)"; + langs["en"] = "English"; + langs["ru"] = "Русский (Russian)"; + langs["es"] = "Español (Spanish)"; + langs["uk"] = "Українська (Ukrainian)"; + langs[""] = tr("System") + ": " + langs[systemLocale]; +} + +void LanguageMenu::createActionsGroup() +{ + actionsGroup = new QActionGroup(this); + actionsGroup->setExclusive(true); +} + +void LanguageMenu::createAction(const QString& key) +{ + QAction* action = addAction(langs[key]); + action->setCheckable(true); + if(key == locale) + action->setChecked(true); + action->setData(key); + actionsGroup->addAction(action); + connect(action, SIGNAL(triggered()), SLOT(saveLanguage())); +} + +void LanguageMenu::saveLanguage() +{ + QAction *action = qobject_cast(sender()); + QString newLocale = action->data().toString(); + QSettings().setValue("lang", newLocale); + if(newLocale.isEmpty()) + newLocale = systemLocale; + + installTranslator("freshmemory_" + newLocale, getResourcePath() + "/tr"); + QMessageBox::information(this, Strings::tr(Strings::s_appTitle), + tr("The application must be restarted to use the selected language")); +} diff --git a/src/main-view/LanguageMenu.h b/src/main-view/LanguageMenu.h new file mode 100644 index 0000000..d03984d --- /dev/null +++ b/src/main-view/LanguageMenu.h @@ -0,0 +1,28 @@ +#ifndef LANGUAGE_MENU_H +#define LANGUAGE_MENU_H + +#include + +class LanguageMenu: public QMenu +{ + Q_OBJECT +public: + LanguageMenu(QMenu* parent); + +private: + void initUi(QMenu* parent); + void initLangs(); + void createActionsGroup(); + void createAction(const QString& key); + +private slots: + void saveLanguage(); + +private: + QMap langs; + QString locale; + QString systemLocale; + QActionGroup* actionsGroup; +}; + +#endif diff --git a/src/main-view/MainWindow.cpp b/src/main-view/MainWindow.cpp new file mode 100644 index 0000000..e5b285c --- /dev/null +++ b/src/main-view/MainWindow.cpp @@ -0,0 +1,1313 @@ +#include "MainWindow.h" +#include "AppModel.h" +#include "DictTableModel.h" +#include "DictTableView.h" +#include "FindPanel.h" +#include "DictTableDelegate.h" +#include "PacksTreeModel.h" +#include "AboutDialog.h" +#include "RecentFilesManager.h" +#include "LanguageMenu.h" +#include "CardPreview.h" +#include "WelcomeScreen.h" +#include "../version.h" +#include "../strings.h" +#include "../dictionary/DicRecord.h" +#include "../dictionary/CardPack.h" +#include "../dictionary/DicCsvWriter.h" +#include "../dictionary/DicCsvReader.h" +#include "../dic-options/DictionaryOptionsDialog.h" +#include "../export-import/CsvExportDialog.h" +#include "../export-import/CsvImportDialog.h" +#include "../settings/FontColorSettingsDialog.h" +#include "../settings/StudySettingsDialog.h" +#include "../field-styles/FieldStyleFactory.h" +#include "../study/WordDrillModel.h" +#include "../study/SpacedRepetitionModel.h" +#include "../study/WordDrillWindow.h" +#include "../study/SpacedRepetitionWindow.h" +#include "../study/CardSideView.h" +#include "../utils/RandomGenerator.h" +#include "../statistics/StatisticsView.h" + +MainWindow::MainWindow(AppModel* model): + workPath(""), + addImagePath(""), + model(model), welcomeScreen(NULL), studyWindow(NULL) +{ + init(); + createCentralWidget(); + createActions(); + createMenus(); + createToolBars(); + createStatusBar(); + FieldStyleFactory::inst()->load(); + createDockWindows(); + readSettings(); + openSession(); +} + +MainWindow::~MainWindow() +{ + delete studyWindow; +} + +void MainWindow::init() +{ + setWindowTitle(Strings::tr(Strings::s_appTitle)); + setWindowIcon(QIcon(":/images/freshmemory.png")); +} + +void MainWindow::activate() +{ + activateWindow(); + raise(); +} + +void MainWindow::updateDictTab() +{ + int curIndex = dictTabWidget->currentIndex(); + const Dictionary* curDict = model->curDictionary(); + if(!curDict) + return; + if(!curDict->contentModified()) + dictTabWidget->setTabIcon( curIndex, QIcon(":/images/openbook-24.png") ); + else + dictTabWidget->setTabIcon( curIndex, QIcon(":/images/filesave.png") ); + dictTabWidget->setTabText(curIndex, curDict->shortName()); + dictTabWidget->setTabToolTip(curIndex, QDir::toNativeSeparators( curDict->getFilePath())); +} + +void MainWindow::updateTotalRecordsLabel() +{ + const Dictionary* curDict = model->curDictionary(); + if(curDict) + { + totalRecordsLabel->show(); + totalRecordsLabel->setText( tr("Records: %1").arg(curDict->entriesNum()) ); + } + else + totalRecordsLabel->hide(); +} + +void MainWindow::updateActions() +{ + const Dictionary* curDict = model->curDictionary(); + bool isCurDictModified = curDict && curDict->contentModified(); + + saveAct->setEnabled( isCurDictModified ); + saveAsAct->setEnabled( curDict ); + saveCopyAct->setEnabled( curDict ); + exportAct->setEnabled( curDict ); + removeTabAct->setEnabled( curDict ); + updatePasteAction(); + insertRecordsAct->setEnabled( curDict ); + findAct->setEnabled( curDict ); + if( findPanel ) + findAgainAct->setEnabled( findPanel->canFindAgain() ); + wordDrillAct->setEnabled(curDict); + spacedRepetitionAct->setEnabled(curDict); + statisticsAct->setEnabled(curDict); + dictionaryOptionsAct->setEnabled(curDict); +} + +void MainWindow::updateAddImageAction() +{ + addImageAct->setEnabled(dictTabWidget->isInEditingState()); +} + +void MainWindow::updateSelectionActions() + { + if( !model->curDictionary() ) + return; + const DictTableView* tableView = getCurDictView(); + if( !tableView ) + return; + Q_ASSERT( tableView->selectionModel() ); + bool hasSelection = tableView->selectionModel()->hasSelection(); + foreach( QAction* action, selectionActions ) + action->setEnabled( hasSelection ); + } + +void MainWindow::updatePasteAction() +{ + bool isCurTabValid = dictTabWidget->currentIndex() >= 0; + bool hasClipboardText = !QApplication::clipboard()->text().isEmpty(); + pasteAct->setEnabled( isCurTabValid && hasClipboardText ); +} + +void MainWindow::closeEvent(QCloseEvent *event) +{ +if( proposeToSave() ) + { + writeSettings(); + event->accept(); + qApp->quit(); + } +else + event->ignore(); +} + +void MainWindow::newFile() + { + addDictTab(model->newDictionary()); + updatePacksTreeView(); + } + +void MainWindow::openFileWithDialog() + { + openFileWithDialog(workPath); + } + +void MainWindow::openOnlineDictionaries() + { + QDesktopServices::openUrl(QUrl("http://fresh-memory.com/dictionaries")); + } + +void MainWindow::openFileWithDialog(const QString& dirPath) + { + QString filePath = QFileDialog::getOpenFileName(this, tr("Open dictionary"), dirPath, + tr("Dictionaries", "Filter name in dialog")+ " (*.fmd)"); + if( filePath.isEmpty() ) + return; + openFile(filePath); + } + +void MainWindow::openFile(const QString& filePath) + { + QString internalFilePath = QDir::fromNativeSeparators(filePath); + workPath = QFileInfo(internalFilePath).path(); + int dictIndex = model->indexOfDictionary(internalFilePath); + if(isDictOpened(dictIndex)) + setCurDictionary(dictIndex); + else + if(!loadFile(internalFilePath)) + return; + updateAfterOpenedDictionary(internalFilePath); + } + +bool MainWindow::isDictOpened(int index) +{ + return index > -1; +} + +void MainWindow::setCurDictionary(int index) +{ + if(index == -1) + return; + model->setCurDictionary(index); + setCurDictTab(index); +} + +bool MainWindow::loadFile(const QString& filePath) +{ + bool ok = model->openDictionary(filePath); + if(ok) + addDictTab(model->curDictionary()); + else + showOpenFileError(); + return ok; +} + +void MainWindow::showOpenFileError() +{ + QMessageBox::critical(this, Strings::errorTitle(), model->getErrorMessage()); +} + +void MainWindow::updateAfterOpenedDictionary(const QString& filePath) +{ + recentFilesMan->addFile(filePath); + updatePacksTreeView(); + updateCardPreview(); +} + +void MainWindow::addDictTab(Dictionary* dict) + { + connect( dict, SIGNAL(contentModifiedChanged(bool)), SLOT(updateDictTab()) ); + connect( dict, SIGNAL(contentModifiedChanged(bool)), SLOT(updateActions()) ); + connect( dict, SIGNAL(studyModifiedChanged(bool)), SLOT(saveStudyWithDelay(bool)) ); + connect( dict, SIGNAL(filePathChanged()), SLOT(updateDictTab()) ); + connect( dict, SIGNAL(entriesInserted(int,int)), SLOT(updateTotalRecordsLabel()) ); + connect( dict, SIGNAL(entriesRemoved(int,int)), SLOT(updateTotalRecordsLabel()) ); + connect( dict, SIGNAL(cardsGenerated()), SLOT(updatePacksTreeView()) ); + connect( dict, SIGNAL(cardsGenerated()), SLOT(updateCardPreview()) ); + connect( dict, SIGNAL(destroyed()), SLOT(updatePacksTreeView()) ); + + dictTabWidget->addDictTab(model->curDictModel()); + DictTableView* tableView = const_cast( dictTabWidget->curDictView() ); + + tableView->addActions(contextMenuActions); + tableView->verticalHeader()->addActions(contextMenuActions); + tableView->setContextMenuPolicy( Qt::ActionsContextMenu ); + tableView->verticalHeader()->setContextMenuPolicy( Qt::ActionsContextMenu ); + + connect( tableView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), + SLOT(updateSelectionActions()) ); + connect( tableView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), + SLOT(updateCardPreview()) ); + connect( tableView, SIGNAL(destroyed(QAbstractItemModel*)), model, SLOT(removeDictModel(QAbstractItemModel*)) ); + updateDictTab(); + updateTotalRecordsLabel(); + updateSelectionActions(); + packsTreeView->reset(); + QModelIndex firstIx = tableView->model()->index(0, 0, QModelIndex()); + tableView->setCurrentIndex(firstIx); + tableView->setFocus(); + } + +const DictTableView* MainWindow::getCurDictView() const + { + if(studyWindow) + { + const DictTableView* editCardView = studyWindow->cardEditView(); + if( editCardView ) + return editCardView; + } + return dictTabWidget->curDictView(); + } + +/// Fork to SaveAs() or really save in DoSave() +bool MainWindow::Save() +{ +Dictionary* dict = model->curDictionary(); +if( !dict ) + return false; +QString filePath = dict->getFilePath(); +if( filePath.isEmpty() || dict->nameIsTemp() ) + return SaveAs(); +else + return doSave( filePath ); +} + +bool MainWindow::SaveAs( bool aChangeFilePath ) +{ +Dictionary* dict = model->curDictionary(); +if( !dict ) + return false; +QString filePath = dict->getFilePath(); +if( filePath.isEmpty() ) + filePath = workPath + "/" + Dictionary::tr( Dictionary::NoName ) + Dictionary::DictFileExtension; +filePath = QFileDialog::getSaveFileName(this, tr("Save dictionary as ..."), filePath); +if( filePath.isEmpty() ) + return false; +workPath = QFileInfo( filePath ).path(); +if( doSave( filePath, aChangeFilePath ) ) + { + recentFilesMan->addFile(filePath); + return true; + } +else + return false; +} + +void MainWindow::SaveCopy() +{ + SaveAs( false ); // Do not change the file name +} + +void MainWindow::importFromCsv() +{ + QString filePath = QFileDialog::getOpenFileName(this, tr("Import CSV file"), workPath); + if( filePath.isEmpty() ) + return; + workPath = QFileInfo( filePath ).path(); + CsvImportDialog importDialog( this, filePath, model ); + if( importDialog.exec() ) + { + model->addDictionary( importDialog.getDictionary() ); + addDictTab(importDialog.getDictionary()); + importDialog.getDictionary()->generateCards(); + updatePacksTreeView(); + } +} + +void MainWindow::exportToCsv() +{ + Dictionary* dict = model->curDictionary(); + if( !dict ) + return; + CsvExportDialog exportDialog( this, dict ); + if( exportDialog.exec() ) + { + QString dictFilePath( dict->getFilePath() ); + if( dictFilePath.isEmpty() ) + dictFilePath = workPath + "/" + Dictionary::tr( Dictionary::NoName ) + Dictionary::DictFileExtension; + QString filePath = QFileDialog::getSaveFileName( this, tr("Export to CSV file"), dictFilePath + ".txt" ); + if( filePath.isEmpty() ) + return; + workPath = QFileInfo( filePath ).path(); + exportDialog.SaveCSVToFile( filePath ); + } +} + +bool MainWindow::doSave( const QString& aFilePath, bool aChangeFilePath ) +{ + QFile::FileError error = model->curDictionary()->save( aFilePath, aChangeFilePath ); + if( error != QFile::NoError ) + { + QMessageBox::warning( this, Strings::errorTitle(), (tr("Cannot save dictionary:") + "\n%1"). + arg(QDir::toNativeSeparators(aFilePath)) ); + return false; + } + dictTabWidget->cleanUndoStack(); + updateDictTab(); + updateActions(); + return true; +} + +bool MainWindow::saveStudy() +{ + QTime saveTime; + saveTime.start(); + Dictionary* dict = model->curDictionary(); + if(!dict) + return false; + if(dict->saveStudy() != QFile::NoError) + { + QMessageBox::warning(this, Strings::errorTitle(), + (tr("Cannot save study file:") + "\n%1"). + arg(QDir::toNativeSeparators( + model->curDictionary()->getStudyFilePath()))); + return false; + } + return true; +} + +void MainWindow::saveStudyWithDelay(bool studyModified) +{ + if(studyModified) + QTimer::singleShot(AutoSaveStudyInterval, this, SLOT(saveStudy())); +} + +/** + * Checks if all files are saved. If not, proposes to the user to save them. + * This function is called before closing the application. + * @return true, if all files are now saved and the application can be closed + */ +bool MainWindow::proposeToSave() +{ +for(int i=0; icount(); i++) + if( !proposeToSave(i) ) + return false; +return true; +} + +/** + * Checks if the specified file is modified and if it is, proposes to the user to save it. + * If the specified file is not modified, the function just returns true. + * + * Function silently saves the study data, if it is modified. + * + * @param aTabIndex Index of the tab containing the modified file + * @return true, if the file is saved and the application can be closed. + * false, if the user declined the proposition to save the file. + */ +bool MainWindow::proposeToSave(int aTabIndex) +{ +const Dictionary* dict = model->dictionary( aTabIndex ); + +if( dict->contentModified() ) + { + dictTabWidget->setCurrentIndex( aTabIndex ); + QMessageBox::StandardButton pressedButton; + pressedButton = QMessageBox::warning( this, tr("Save dictionary?"), tr("Dictionary %1 was modified.\n" + "Save changes?").arg( dict->shortName(false) ), + QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel ); + if( pressedButton == QMessageBox::Yes ) + { + bool saved = Save(); + if( !saved ) + return false; + } + else if( pressedButton == QMessageBox::Cancel ) + return false; + } +if(dict->studyModified()) + saveStudy(); +return true; +} + +void MainWindow::openSession() +{ + QSettings settings; + QStringList sessionFiles = settings.value("session").toStringList(); + if(sessionFiles.isEmpty()) + { + QString lastFile = recentFilesMan->getLastUsedFilePath(); + if(lastFile.isEmpty()) + return; + sessionFiles << recentFilesMan->getLastUsedFilePath(); + } + foreach(QString fileName, sessionFiles) + openFile(fileName); + int curTab = settings.value("session-cur-tab").toInt(); + setCurDictionary(curTab); +} + +void MainWindow::help() + { + QString fullVersion = QString(FM_VERSION); + QString version = fullVersion.left(fullVersion.lastIndexOf('.')); + QString url = QString("http://fresh-memory.com/docs/%1/index.html").arg(version); + QDesktopServices::openUrl(QUrl(url)); + } + +void MainWindow::about() +{ + AboutDialog dialog(this); + dialog.exec(); + dialog.setParent(NULL); +} + +void MainWindow::addImage() + { + int cursorPos = getCurEditorCursorPos(); + if(cursorPos < 0) + return; + const_cast(getCurDictView())->commitEditing(); + QString selectedFile = selectAddImageFile(); + if(selectedFile.isEmpty()) + return; + selectedFile = copyImageFileToImagesDir(selectedFile); + if(selectedFile.isEmpty()) + return; + insertImageIntoCurEditor(cursorPos, selectedFile); + } + +QString MainWindow::selectAddImageFile() + { + checkAddImagePath(); + QString filePath = QFileDialog::getOpenFileName(this, tr("Add image"), + addImagePath, + tr("Images", "Filter name in dialog") + + " (*.png *.jpg *.jpeg *.gif *.svg *.xpm *.ico *.mng *.tiff);; " + + tr("All files") + " (*.*)"); + if(filePath.isEmpty()) + return QString(); + addImagePath = QFileInfo(filePath).path(); + return filePath; + } + +void MainWindow::checkAddImagePath() +{ + if(!addImagePath.isEmpty()) + return; + if(!getCurDict()) + return; + QString dicFilePath = getCurDict()->getFilePath(); + addImagePath = QFileInfo(dicFilePath).path(); +} + +QString MainWindow::copyImageFileToImagesDir(const QString& filePath) +{ + QString dicImagesDir = getCurDict()->getImagesPath(); + QString imageDir = QFileInfo(filePath).path(); + if(imageDir == dicImagesDir) + return filePath; + QString newFilePath = createNewImageFilePath(dicImagesDir, filePath); + if(!QFileInfo(dicImagesDir).exists()) + QDir(dicImagesDir).mkpath("."); + if(!QFile::copy(filePath, newFilePath)) + return QString(); + return newFilePath; +} + +QString MainWindow::createNewImageFilePath(const QString& dicImagesDir, + const QString& filePath) +{ + int num = 0; + QString newFilePath; + do + { + newFilePath = createImagesDirFilePath(dicImagesDir, filePath, num); + num++; + } + while(QFileInfo(newFilePath).exists()); + return newFilePath; +} + +QString MainWindow::createImagesDirFilePath(const QString& dicImagesDir, + const QString& filePath, int suffixNum) +{ + QString imageFileName = QFileInfo(filePath).completeBaseName(); + if(suffixNum > 0) + imageFileName += "-" + QString::number(suffixNum); + imageFileName += "." + QFileInfo(filePath).suffix(); + return QDir(dicImagesDir).filePath(imageFileName); +} + +int MainWindow::getCurEditorCursorPos() + { + const DictTableView* dictView = getCurDictView(); + if(!dictView) + return -1; + return dictView->getEditorCursorPos(); + } + +int MainWindow::getCurRow() +{ + return getCurDictView()->currentIndex().row(); +} + +int MainWindow::getCurColumn() +{ + return getCurDictView()->currentIndex().column(); +} + +Dictionary* MainWindow::getCurDict() +{ + return model->curDictionary(); +} + +void MainWindow::insertImageIntoCurEditor(int cursorPos, const QString& filePath) +{ + const DictTableView* dictView = getCurDictView(); + const_cast(dictView)->startEditing(getCurRow(), getCurColumn()); + dictView->insertImageIntoEditor(cursorPos, filePath); +} + +void MainWindow::insertRecords() + { + pushToUnoStack(new InsertRecordsCmd(this)); + } + +void MainWindow::removeRecords() + { + pushToUnoStack(new RemoveRecordsCmd(this)); + } + +void MainWindow::pushToUnoStack(QUndoCommand* command) + { + getCurDictView()->dicTableModel()->undoStack()->push(command); + } + +void MainWindow::find() + { + findPanel->show(); + findAgainAct->setEnabled(true); + } + +void MainWindow::findAgain() + { + findPanel->find(); + } + +void MainWindow::createActions() +{ + createFileActions(); + createEditActions(); + createDictContextMenuActions(); + createSelectionActions(); + createToolsActions(); + createSettingsActions(); + createHelpActions(); + initActions(); +} + +void MainWindow::createFileActions() +{ + newAct = new QAction(QIcon(":/images/filenew.png"), tr("&New"), this); + newAct->setShortcut(tr("Ctrl+N")); + connect(newAct, SIGNAL(triggered()), SLOT(newFile())); + + loadAct = new QAction(QIcon(":/images/fileopen.png"), tr("&Open ..."), this); + loadAct->setShortcut(tr("Ctrl+O")); + connect(loadAct, SIGNAL(triggered()), SLOT(openFileWithDialog())); + + openFlashcardsAct = new QAction(tr("Online dictionaries"), this); + connect(openFlashcardsAct, SIGNAL(triggered()), SLOT(openOnlineDictionaries())); + + saveAct = new QAction(QIcon(":/images/filesave.png"), tr("&Save"), this); + saveAct->setShortcut(tr("Ctrl+S")); + connect(saveAct, SIGNAL(triggered()), SLOT(Save())); + + saveAsAct = new QAction(QIcon(":/images/filesaveas.png"), tr("Save &as ..."), this); + connect(saveAsAct, SIGNAL(triggered()), SLOT(SaveAs())); + + saveCopyAct = new QAction(tr("Save © ..."), this); + connect(saveCopyAct, SIGNAL(triggered()), SLOT(SaveCopy())); + + importAct = new QAction(tr("&Import from CSV ..."), this); + connect(importAct, SIGNAL(triggered()), SLOT(importFromCsv())); + + exportAct = new QAction(tr("&Export to CSV ..."), this); + connect(exportAct, SIGNAL(triggered()), SLOT(exportToCsv())); + + removeTabAct = new QAction(QIcon(":/images/remove.png"), + tr("&Close dictionary"), this); + removeTabAct->setShortcut(tr("Ctrl+W")); + connect(removeTabAct, SIGNAL(triggered()), dictTabWidget, SLOT(closeTab())); + + quitAct = new QAction(QIcon(":/images/exit.png"), tr("&Quit"), this); + quitAct->setShortcut(tr("Ctrl+Q")); + connect(quitAct, SIGNAL(triggered()), SLOT(close())); +} + +void MainWindow::createEditActions() +{ + undoAct = dictTabWidget->undoGroup()->createUndoAction(this); + undoAct->setShortcut(tr("Ctrl+Z")); + + redoAct = dictTabWidget->undoGroup()->createRedoAction(this); + redoAct->setShortcut(tr("Ctrl+Y")); + + copyAct = new QAction(QIcon(":/images/editcopy.png"), tr("&Copy"), this); + copyAct->setShortcuts(QList() << tr("Ctrl+C") << QString("Ctrl+Insert")); + connect(copyAct, SIGNAL(triggered()), SLOT(copyEntries())); + + cutAct = new QAction(QIcon(":/images/editcut.png"), tr("Cu&t"), this); + cutAct->setShortcuts(QList() << tr("Ctrl+X") << QString("Shift+Delete")); + connect(cutAct, SIGNAL(triggered()), SLOT(cutEntries())); + + pasteAct = new QAction(QIcon(":/images/editpaste.png"), tr("&Paste"), this); + pasteAct->setShortcuts(QList() << tr("Ctrl+V") << QString("Shift+Insert")); + connect(pasteAct, SIGNAL(triggered()), SLOT(pasteEntries())); + connect(QApplication::clipboard(), SIGNAL(dataChanged()), SLOT(updatePasteAction())); + + createAddImageAct(); + createinsertRecordsAct(); + createRemoveRecordsAct(); + + findAct = new QAction(QIcon(":/images/find.png"), tr("&Find..."), this); + findAct->setShortcut(tr("Ctrl+F")); + connect(findAct, SIGNAL(triggered()), SLOT(find())); + + findAgainAct = new QAction(QIcon(":/images/next.png"), tr("Find &again"), this); + findAgainAct->setShortcut(QString("F3")); + connect(findAgainAct, SIGNAL(triggered()), SLOT(findAgain())); +} + +void MainWindow::createAddImageAct() +{ + addImageAct = new QAction(QIcon(":/images/add-image.png"), tr("&Add image"), this); + addImageAct->setShortcut(tr("Ctrl+G")); + connect(addImageAct, SIGNAL(triggered()), SLOT(addImage())); + connect(dictTabWidget, SIGNAL(editingStateChanged()), SLOT(updateAddImageAction())); +} + +void MainWindow::createinsertRecordsAct() +{ + insertRecordsAct = new QAction(QIcon(":/images/add.png"), + tr("&Insert record"), this); + insertRecordsAct->setShortcut(tr("Ctrl+I")); + connect(insertRecordsAct, SIGNAL(triggered()), SLOT(insertRecords())); +} + +void MainWindow::createRemoveRecordsAct() +{ + removeRecordsAct = new QAction(QIcon(":/images/delete.png"), + tr("&Remove record"), this); + removeRecordsAct->setShortcut(Qt::Key_Delete); + connect(removeRecordsAct, SIGNAL(triggered()), SLOT(removeRecords())); +} + +void MainWindow::createToolsActions() +{ + QSignalMapper* startStudySignalMapper = new QSignalMapper(this); + connect(startStudySignalMapper, SIGNAL(mapped(int)), SLOT(startStudy(int))); + + wordDrillAct = new QAction(QIcon(":/images/word-drill.png"), tr("&Word drill"), + this); + wordDrillAct->setShortcut(QString("F5")); + connect(wordDrillAct, SIGNAL(triggered()), startStudySignalMapper, SLOT(map())); + startStudySignalMapper->setMapping(wordDrillAct, AppModel::WordDrill); + + spacedRepetitionAct = new QAction(QIcon(":/images/spaced-rep.png"), + tr("&Spaced repetition"), this); + spacedRepetitionAct->setShortcut(QString("F6")); + connect(spacedRepetitionAct, SIGNAL(triggered()), startStudySignalMapper, + SLOT(map())); + startStudySignalMapper->setMapping(spacedRepetitionAct, AppModel::SpacedRepetition); + + statisticsAct = new QAction(QIcon(":/images/statistics.png"), tr("S&tatistics"), + this); + statisticsAct->setShortcut(QString("F7")); + connect(statisticsAct, SIGNAL(triggered()), SLOT(showStatistics())); +} + +void MainWindow::createSettingsActions() +{ + dictionaryOptionsAct = new QAction(QIcon(":/images/dic-options.png"), + tr("&Dictionary options"), this); + dictionaryOptionsAct->setShortcut(QString("Ctrl+1")); + connect(dictionaryOptionsAct, SIGNAL(triggered()), SLOT(openDictionaryOptions())); + + fontColorSettingsAct = new QAction(QIcon(":/images/font-style.png"), + tr("&Font and color settings"), this); + fontColorSettingsAct->setShortcut(QString("Ctrl+2")); + connect(fontColorSettingsAct, SIGNAL(triggered()), SLOT(openFontColorSettings())); + + studySettingsAct = new QAction(QIcon(":/images/study-settings.png"), + tr("&Study settings"), this); + studySettingsAct->setShortcut(QString("Ctrl+3")); + connect(studySettingsAct, SIGNAL(triggered()), SLOT(openStudySettings())); +} + +void MainWindow::createHelpActions() +{ + helpAct = new QAction(tr("Help"), this); + helpAct->setShortcut(QString("F1")); + connect(helpAct, SIGNAL(triggered()), SLOT(help())); + + aboutAct = new QAction(QIcon(":/images/freshmemory.png"), tr("About"), this); + connect(aboutAct, SIGNAL(triggered()), SLOT(about())); +} + +void MainWindow::initActions() +{ + saveAct->setEnabled(false); + saveAsAct->setEnabled(false); + saveCopyAct->setEnabled(false); + exportAct->setEnabled(false); + removeTabAct->setEnabled(false); + + cutAct->setEnabled(false); + copyAct->setEnabled(false); + pasteAct->setEnabled(false); + addImageAct->setEnabled(false); + insertRecordsAct->setEnabled(false); + removeRecordsAct->setEnabled(false); + findAct->setEnabled(false); + findAgainAct->setEnabled(false); + + statisticsAct->setEnabled(false); + wordDrillAct->setEnabled(false); + spacedRepetitionAct->setEnabled(false); + + dictionaryOptionsAct->setEnabled(false); +} + +void MainWindow::createDictContextMenuActions() +{ + contextMenuActions << copyAct; + contextMenuActions << cutAct; + contextMenuActions << pasteAct; + contextMenuActions << insertRecordsAct; + contextMenuActions << removeRecordsAct; +} + +void MainWindow::createSelectionActions() +{ + selectionActions << copyAct; + selectionActions << cutAct; + selectionActions << removeRecordsAct; +} + +void MainWindow::createMenus() +{ + createFileMenu(); + + editMenu = menuBar()->addMenu( tr("&Edit") ); + editMenu->addAction( undoAct ); + editMenu->addAction( redoAct ); + editMenu->addSeparator(); + + editMenu->addAction(cutAct); + editMenu->addAction(copyAct); + editMenu->addAction(pasteAct); + editMenu->addSeparator(); + + editMenu->addAction(addImageAct); + editMenu->addAction(insertRecordsAct); + editMenu->addAction(removeRecordsAct); + editMenu->addSeparator(); + editMenu->addAction(findAct); + editMenu->addAction(findAgainAct); + + viewMenu = menuBar()->addMenu( tr("&View") ); + + toolsMenu = menuBar()->addMenu( tr("&Tools") ); + toolsMenu->addAction(wordDrillAct); + toolsMenu->addAction(spacedRepetitionAct); + toolsMenu->addAction(statisticsAct); + + createOptionsMenu(); + + menuBar()->addSeparator(); + + helpMenu = menuBar()->addMenu( tr("&Help") ); + helpMenu->addAction(helpAct); + helpMenu->addAction(aboutAct); +} + +void MainWindow::createFileMenu() +{ + fileMenu = menuBar()->addMenu(tr("&File")); + fileMenu->addAction(newAct); + fileMenu->addAction(loadAct); + fileMenu->addAction(openFlashcardsAct); + fileMenu->addAction(saveAct); + fileMenu->addAction(saveAsAct); + fileMenu->addAction(saveCopyAct); + fileMenu->addAction(importAct); + fileMenu->addAction(exportAct); + + createRecentFilesMenu(); + + fileMenu->addSeparator(); + fileMenu->addAction(removeTabAct); + fileMenu->addAction(quitAct); +} + +void MainWindow::createRecentFilesMenu() +{ + QMenu* recentFilesMenu = fileMenu->addMenu(tr("&Recent files")); + welcomeScreen->setRecentFilesMenu(recentFilesMenu); + recentFilesMan = new RecentFilesManager(this, recentFilesMenu); + connect(recentFilesMan, SIGNAL(recentFileTriggered(const QString&)), + SLOT(openFile(const QString&))); + connect(recentFilesMan, SIGNAL(addedFile()), welcomeScreen, + SLOT(updateRecentFilesButton())); +} + +void MainWindow::createOptionsMenu() +{ + optionsMenu = menuBar()->addMenu(tr("&Options")); + optionsMenu->addAction( dictionaryOptionsAct ); + optionsMenu->addAction( fontColorSettingsAct ); + optionsMenu->addAction( studySettingsAct ); + + new LanguageMenu(optionsMenu); +} + +void MainWindow::createToolBars() +{ + QToolBar* toolBar = addToolBar( tr("Main") ); + toolBar->setObjectName("Main"); + toolBar->addAction(newAct); + toolBar->addAction(loadAct); + toolBar->addAction(saveAct); + toolBar->addSeparator(); + toolBar->addAction(findAct); + toolBar->addAction(wordDrillAct); + toolBar->addAction(spacedRepetitionAct); + toolBar->addAction(statisticsAct); + toolBar->addAction(addImageAct); +} + +void MainWindow::createStatusBar() +{ + statusBar()->addPermanentWidget( totalRecordsLabel = new QLabel ); + updateTotalRecordsLabel(); +} + +void MainWindow::createCentralWidget() + { + mainStackedWidget = new QStackedWidget; + welcomeScreen = new WelcomeScreen(this); + mainStackedWidget->addWidget(welcomeScreen); + mainStackedWidget->addWidget(createDictionaryView()); + setCentralWidget(mainStackedWidget); + } + +QWidget* MainWindow::createDictionaryView() +{ + dictTabWidget = new DictionaryTabWidget(this); + connect(dictTabWidget, SIGNAL(currentChanged(int)), SLOT(curTabChanged(int))); + findPanel = new FindPanel(this); + findPanel->hide(); + + QVBoxLayout* dictionaryViewLt = new QVBoxLayout; + dictionaryViewLt->setContentsMargins(0, 0, 0, 0); + dictionaryViewLt->addWidget(dictTabWidget); + dictionaryViewLt->addWidget(findPanel); + + QWidget* dictionaryView = new QWidget; + dictionaryView->setLayout(dictionaryViewLt); + return dictionaryView; +} + +void MainWindow::curTabChanged(int tabIndex) +{ + updateMainStackedWidget(tabIndex); + model->setCurDictionary(tabIndex); + updateActions(); + updateSelectionActions(); + updateTotalRecordsLabel(); + updatePackSelection(tabIndex); + updateCardPreview(); +} + +void MainWindow::updateMainStackedWidget(int tabIndex) +{ + if (tabIndex == -1) + mainStackedWidget->setCurrentIndex(0); + else + mainStackedWidget->setCurrentIndex(1); +} + +void MainWindow::createDockWindows() + { + createPacksTreeDock(); + createCardPreviewDock(); + } + +void MainWindow::createPacksTreeDock() +{ + QDockWidget* packsDock = new QDockWidget(tr("Card packs")); + packsDock->setObjectName("Card-packs"); + packsDock->setAllowedAreas( + Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); + packsTreeView = new QTreeView; + packsTreeView->setAllColumnsShowFocus(true); + packsTreeView->setRootIsDecorated(false); + packsTreeView->header()->setDefaultSectionSize(150); + PacksTreeModel* packsTreeModel = new PacksTreeModel(model); + packsTreeView->setModel(packsTreeModel); + packsDock->setWidget(packsTreeView); + addDockWidget(Qt::LeftDockWidgetArea, packsDock); + viewMenu->addAction(packsDock->toggleViewAction()); + connect(packsTreeView->selectionModel(), + SIGNAL(currentChanged(const QModelIndex&, const QModelIndex&)), + SLOT(setCurDictTabByTreeIndex(const QModelIndex&))); + connect(packsTreeView->selectionModel(), + SIGNAL(currentChanged(const QModelIndex&, const QModelIndex&)), + SLOT(updateCardPreview())); + connect(packsTreeView, SIGNAL(activated(const QModelIndex&)), + SLOT(startSpacedRepetitionStudy())); +} + +void MainWindow::createCardPreviewDock() +{ + cardPreview = new CardPreview(this); + addDockWidget(Qt::LeftDockWidgetArea, cardPreview); + viewMenu->addAction(cardPreview->toggleViewAction()); +} + +void MainWindow::updatePacksTreeView() +{ + static_cast( packsTreeView->model() )->updateData(); + packsTreeView->expandAll(); + packsTreeView->resizeColumnToContents( 1 ); + packsTreeView->resizeColumnToContents( 2 ); + updatePackSelection(); +} + +void MainWindow::updateCardPreview() +{ + CardPack* pack = getCurCardPack(); + Card* card = getCurCardFromPack(pack); + cardPreview->setContent(pack, card); +} + +CardPack* MainWindow::getCurCardPack() const +{ + const Dictionary* dict = model->curDictionary(); + if(!dict) + return NULL; + int packId = packsTreeView->currentIndex().row(); + return dict->cardPack(packId); +} + +const DicRecord* MainWindow::getCurDictRecord(const Dictionary* dict, + const QAbstractItemView* dictView) const +{ + if(!dict || !dictView) + return NULL; + return dict->getRecord(dictView->currentIndex().row()); +} + +const DicRecord* MainWindow::getCurDictRecord() const +{ + return getCurDictRecord(model->curDictionary(), getCurDictView()); +} + +Card* MainWindow::getCurCardFromPack(CardPack* pack) const +{ + const DicRecord* record = getCurDictRecord(); + if(!record) + return NULL; + return pack->getCard(record->getPreviewQuestionForPack(pack)); +} + +/// Proxy-view-aware copying +void MainWindow::copyEntries() + { + const DictTableView* tableView = getCurDictView(); // May be proxy view + if( !tableView ) + return; + QModelIndexList selectedIndexes = tableView->selectionModel()->selectedRows(); + QAbstractProxyModel* proxyModel = qobject_cast( tableView->model() ); + if( proxyModel ) + { + QModelIndexList srcIndexes; + foreach( QModelIndex index, selectedIndexes ) + { + QModelIndex srcIndex = proxyModel->mapToSource( index ); + srcIndexes << srcIndex; + } + selectedIndexes = srcIndexes; + } + Dictionary* dict = model->curDictionary(); + QList entries; + foreach( QModelIndex index, selectedIndexes ) + entries << const_cast(dict->getRecord( index.row() )); + + CsvExportData params; + params.commentChar = '#'; + params.fieldSeparators = "& "; + params.quoteAllFields = false; + params.textDelimiter = '"'; + params.writeColumnNames = true; + DicCsvWriter csvWriter( entries ); + QString copiedStr = csvWriter.toCsvString( params ); + QClipboard *clipboard = QApplication::clipboard(); + clipboard->setText( copiedStr ); + } + +void MainWindow::cutEntries() + { + copyEntries(); + removeRecords(); + } + +void MainWindow::pasteEntries() + { + // Get text from clipboard + QClipboard *clipboard = QApplication::clipboard(); + QString pastedStr = clipboard->text(); + if( pastedStr.isEmpty() ) + return; + + const DictTableView* dictView = getCurDictView(); // May be proxy view + Q_ASSERT( dictView ); + DictTableModel* dictModel = dictView->dicTableModel(); // Always original model + Q_ASSERT( dictModel ); + + // Parse records to be pasted + DicCsvReader csvReader; + CsvImportData params; + params.firstLineIsHeader = true; + params.commentChar = '#'; + params.fieldSeparationMode = EFieldSeparatorExactString; + params.fieldSeparators = "& "; + params.fromLine = 1; + params.textDelimiter = '"'; + params.colsToImport = 0; // All + QList records = csvReader.readEntries( pastedStr, params ); + if( records.empty() ) + return; + QStringList pastedFieldNames = csvReader.fieldNames(); + + // Check for new pasted fields. Ask user what to do with them. + QStringList dicFieldNames = model->curDictionary()->fieldNames(); + QStringList newFieldNames; + foreach( QString name, pastedFieldNames ) + if( !dicFieldNames.contains( name ) ) + newFieldNames << name; + if( !newFieldNames.isEmpty() ) + { + QMessageBox msgBox; + msgBox.setWindowTitle( windowTitle() ); + bool existingFields = pastedFieldNames.size() - newFieldNames.size() > 0; + msgBox.setText( tr("The pasted records contain %n new field(s)", "", newFieldNames.size()) + ":\n" + newFieldNames.join(", ") + "." ); + msgBox.setInformativeText(tr("Do you want to add new fields to this dictionary?")); + msgBox.setIcon( QMessageBox::Question ); + QPushButton* addFieldsBtn = msgBox.addButton( tr("Add new fields"), QMessageBox::YesRole ); + QPushButton* pasteExistingBtn = msgBox.addButton( tr("Paste only existing fields"), QMessageBox::NoRole ); + pasteExistingBtn->setEnabled( existingFields ); + msgBox.addButton( QMessageBox::Cancel ); + msgBox.setDefaultButton( addFieldsBtn ); + int res = msgBox.exec(); + QAbstractButton* clickedBtn = msgBox.clickedButton(); + if( clickedBtn == addFieldsBtn ) + dictModel->addFields( newFieldNames ); + else if( res == QMessageBox::Cancel ) // do not paste records + return; + // If paste only existing fields, don't make any changes here, just continue. + } + + QUndoCommand* command = new PasteRecordsCmd( records, this ); // Takes ownership of records + dictModel->undoStack()->push( command ); + } + +void MainWindow::readSettings() +{ + loadGeneralSettings(); + StudySettings::inst()->load(); +} + +void MainWindow::loadGeneralSettings() +{ + QSettings settings; + move(settings.value("main-pos", QPoint(100, 100)).toPoint()); + resize(settings.value("main-size", QSize(600, 500)).toSize()); + if (settings.value("main-maximized", false).toBool()) + showMaximized(); + + restoreState(settings.value("main-state").toByteArray(), 0); + QStringList recentFiles = settings.value("main-recent-files").toStringList(); + recentFilesMan->createRecentFileActs(recentFiles); + workPath = settings.value("work-path", + QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation)). + toString(); +} + +void MainWindow::writeSettings() +{ + saveGeneralSettings(); +} + +void MainWindow::saveGeneralSettings() +{ + QSettings settings; + settings.setValue("main-maximized", isMaximized()); + if(!isMaximized()) + { + settings.setValue("main-pos", pos()); + settings.setValue("main-size", size()); + } + settings.setValue("main-state", saveState(0)); + settings.setValue("main-recent-files", recentFilesMan->getFiles()); + settings.setValue("work-path", workPath); + saveSession(); +} + +void MainWindow::saveSession() +{ + QSettings settings; + QStringList sessionFiles; + for(int i = 0; i < dictTabWidget->count(); i++) + { + const Dictionary* dict = model->dictionary(i); + sessionFiles << dict->getFilePath(); + } + settings.setValue("session", sessionFiles); + settings.setValue("session-cur-tab", model->getCurDictIndex()); +} + +void MainWindow::startStudy(int studyType) + { + int packIx = packsTreeView->currentIndex().row(); + + if(studyWindow) + { + if((int)studyWindow->getStudyType() == studyType) + { + studyWindow->showNormal(); + studyWindow->raise(); + studyWindow->activateWindow(); + return; + } + else + { + disconnect(studyWindow, SIGNAL(destroyed()), this, SLOT(activate())); + studyWindow->close(); + } + } + + IStudyModel* studyModel = model->createStudyModel(studyType, packIx); + if(!studyModel) + { + QMessageBox::critical(this, Strings::errorTitle(), + tr("The study cannot be started.", "First part of error message") + "\n" + + model->getErrorMessage()); + return; + } + + if( studyType == AppModel::SpacedRepetition ) + connect(studyModel, SIGNAL(nextCardSelected()), SLOT(updatePacksTreeView())); + + // Create study window + switch( studyType ) + { + case AppModel::WordDrill: + studyWindow = new WordDrillWindow(dynamic_cast(studyModel), this ); + break; + case AppModel::SpacedRepetition: + studyWindow = new SpacedRepetitionWindow(dynamic_cast(studyModel), this ); + break; + } + connect(studyWindow, SIGNAL(destroyed()), SLOT(activate())); + studyWindow->show(); + } + +void MainWindow::startSpacedRepetitionStudy() + { + startStudy( AppModel::SpacedRepetition ); + } + +void MainWindow::goToDictionaryRecord(const Dictionary* aDictionary, int aRecordRow ) + { + int dicIx = model->indexOfDictionary( const_cast( aDictionary ) ); + if( dicIx < 0 ) + return; + show(); + raise(); + activateWindow(); + dictTabWidget->goToDictionaryRecord( dicIx, aRecordRow ); + } + +void MainWindow::openDictionaryOptions() +{ + Dictionary* curDict = model->curDictionary(); + if( !curDict ) + return; + DictionaryOptionsDialog dicOptions( curDict, this ); + int res = dicOptions.exec(); + if (res == QDialog::Accepted) + { + curDict->setDictConfig( &dicOptions.m_dict ); + getCurDictView()->dicTableModel()->resetData(); + updatePacksTreeView(); + } +} + +void MainWindow::openFontColorSettings() +{ + FontColorSettingsDialog dialog( this ); + int res = dialog.exec(); + if (res == QDialog::Accepted) + { + *(FieldStyleFactory::inst()) = *dialog.styleFactory(); + FieldStyleFactory::inst()->save(); + } +} + +void MainWindow::openStudySettings() +{ + StudySettingsDialog dialog(this); + if(dialog.exec() == QDialog::Accepted) + { + *(StudySettings::inst()) = dialog.getSettings(); + StudySettings::inst()->save(); + } +} + +void MainWindow::setCurDictTab(int index) +{ + dictTabWidget->setCurrentIndex(index); +} + +void MainWindow::setCurDictTabByTreeIndex( const QModelIndex& aIndex ) +{ + if( !aIndex.isValid() ) + return; + dictTabWidget->setCurrentIndex( static_cast( aIndex.internalPointer() )->topParentRow() ); +} + +// Set the pack selection to the correct dictionary +void MainWindow::updatePackSelection( int aDic ) +{ + if( !model->curDictionary() ) + return; + if( aDic == -1 ) // default value + aDic = model->curDictionary()->row(); + QModelIndex curIx = packsTreeView->currentIndex(); + if( curIx.isValid() && static_cast( curIx.internalPointer() )->topParentRow() == aDic ) + return; + QAbstractItemModel* packsTreeModel = packsTreeView->model(); + QModelIndex dicIx = packsTreeModel->index( aDic, 0, QModelIndex() ); + int curPackIx; + if( !studyWindow.isNull() ) + curPackIx = model->curCardPackIx(); + else + curPackIx = 0; // first pack + QModelIndex packIndex = packsTreeModel->index( curPackIx, 0, dicIx ); + packsTreeView->selectionModel()->setCurrentIndex( packIndex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows ); +} + +void MainWindow::showStatistics() +{ + StatisticsView(getCurDict()).exec(); +} diff --git a/src/main-view/MainWindow.h b/src/main-view/MainWindow.h new file mode 100644 index 0000000..5165118 --- /dev/null +++ b/src/main-view/MainWindow.h @@ -0,0 +1,218 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include + +class AppModel; +class DictTableView; +class Dictionary; +class IStudyWindow; +class FindPanel; +class CardPreview; +class RecentFilesManager; +class DicRecord; +class Card; +class CardPack; +class WelcomeScreen; + +#include "UndoCommands.h" +#include "DictionaryTabWidget.h" + +class MainWindow: public QMainWindow +{ + Q_OBJECT + +public: + MainWindow(AppModel* model); + ~MainWindow(); + + const DictTableView* getCurDictView() const; + QList getContextMenuActions() const { return contextMenuActions; } + + void showContinueSearch() { dictTabWidget->showContinueSearch(); } + void goToDictionaryRecord( const Dictionary* aDictionary, int aRecordRow ); + +public slots: + void openFile(const QString& filePath); + +private: + void init(); + void addDictTab(Dictionary* dict); + + void createActions(); + void createFileActions(); + void createEditActions(); + void createAddImageAct(); + void createinsertRecordsAct(); + void createInsertRecordsAfterAct(); + void createRemoveRecordsAct(); + void createDictContextMenuActions(); + void createSelectionActions(); + void createToolsActions(); + void createSettingsActions(); + void createHelpActions(); + void initActions(); + + void createMenus(); + void createToolBars(); + void createStatusBar(); + + void createCentralWidget(); + void updateMainStackedWidget(int tabIndex); + QWidget* createDictionaryView(); + + void createDockWindows(); + void createPacksTreeDock(); + void createCardPreviewDock(); + + void readSettings(); + void writeSettings(); + bool doSave( const QString& aFilePath, bool aChangeFilePath = true ); + bool proposeToSave(); + void openSession(); + void closeEvent(QCloseEvent *event); + void saveGeneralSettings(); + void saveSession(); + void loadGeneralSettings(); + + void updatePackSelection( int aDic = -1 ); + Dictionary* getCurDict(); + QString selectAddImageFile(); + void checkAddImagePath(); + QString copyImageFileToImagesDir(const QString& filePath); + QString createNewImageFilePath(const QString& dicImagesDir, const QString& filePath); + QString createImagesDirFilePath(const QString& dicImagesDir, const QString& filePath, + int suffixNum); + int getCurEditorCursorPos(); + int getCurRow(); + int getCurColumn(); + void insertImageIntoCurEditor(int cursorPos, const QString& filePath); + + void createFileMenu(); + void createOptionsMenu(); + void createRecentFilesMenu(); + + CardPack* getCurCardPack() const; + const DicRecord* getCurDictRecord() const; + const DicRecord* getCurDictRecord(const Dictionary* dict, + const QAbstractItemView* dictView) const; + Card* getCurCardFromPack(CardPack* pack) const; + bool isDictOpened(int index); + void setCurDictionary(int index); + void openFileWithDialog(const QString& dirPath); + bool loadFile(const QString& filePath); + void showOpenFileError(); + void updateAfterOpenedDictionary(const QString& filePath); + +public slots: + void updateDictTab(); + void updateActions(); + void updatePasteAction(); + void updateSelectionActions(); + bool proposeToSave(int i); + +private slots: + void activate(); + void curTabChanged(int tabIndex); + void updatePacksTreeView(); + void updateCardPreview(); + void updateAddImageAction(); + void newFile(); + void openFileWithDialog(); + void openOnlineDictionaries(); + bool Save(); + bool saveStudy(); + bool SaveAs( bool aChangeFilePath = true ); + void SaveCopy(); + void importFromCsv(); + void exportToCsv(); + + void copyEntries(); + void cutEntries(); + void pasteEntries(); + void addImage(); + void insertRecords(); + void removeRecords(); + void pushToUnoStack(QUndoCommand* command); + void find(); + void findAgain(); + void openDictionaryOptions(); + void openFontColorSettings(); + void openStudySettings(); + + void startStudy(int aStudyType); + void startSpacedRepetitionStudy(); + void help(); + void about(); + void updateTotalRecordsLabel(); + void setCurDictTab(int index); + void setCurDictTabByTreeIndex(const QModelIndex& aIndex); + void showStatistics(); + + void saveStudyWithDelay(bool studyModified); + +private: + static const int AutoSaveStudyInterval = 3 * 60 * 1000; // ms + +private: + QString workPath; + QString addImagePath; + AppModel* model; // not own + + // UI elements + QStackedWidget* mainStackedWidget; + DictionaryTabWidget* dictTabWidget; + WelcomeScreen* welcomeScreen; + QLabel* totalRecordsLabel; + QPointer studyWindow; + FindPanel* findPanel; + QTreeView* packsTreeView; + CardPreview* cardPreview; + + QMenu* fileMenu; + QMenu* editMenu; + QMenu* viewMenu; + QMenu* toolsMenu; + QMenu* optionsMenu; + QMenu* helpMenu; + + RecentFilesManager* recentFilesMan; + + // Actions + QAction* newAct; + QAction* loadAct; + QAction* openFlashcardsAct; + QAction* saveAct; + QAction* saveAsAct; + QAction* saveCopyAct; + QAction* importAct; + QAction* exportAct; + QAction* removeTabAct; + QAction* quitAct; + + QAction* undoAct; + QAction* redoAct; + QAction* cutAct; + QAction* copyAct; + QAction* pasteAct; + QAction* addImageAct; + QAction* insertRecordsAct; + QAction* removeRecordsAct; + QAction* findAgainAct; + QAction* findAct; + QList contextMenuActions; + QList selectionActions; + + QAction* wordDrillAct; + QAction* spacedRepetitionAct; + QAction* statisticsAct; + + QAction* dictionaryOptionsAct; + QAction* fontColorSettingsAct; + QAction* studySettingsAct; + + QAction* helpAct; + QAction* aboutAct; +}; + +#endif diff --git a/src/main-view/PacksTreeModel.cpp b/src/main-view/PacksTreeModel.cpp new file mode 100644 index 0000000..55b8c34 --- /dev/null +++ b/src/main-view/PacksTreeModel.cpp @@ -0,0 +1,93 @@ +#include "PacksTreeModel.h" +#include "AppModel.h" +#include "../dictionary/TreeItem.h" + +PacksTreeModel::PacksTreeModel( AppModel* aAppModel, QObject* aParent ): + QAbstractItemModel( aParent ), m_appModel( aAppModel ) + { + } + +QVariant PacksTreeModel::data(const QModelIndex &index, int role) const + { + if( !index.isValid() ) + return QVariant(); + if( role != Qt::DisplayRole ) + return QVariant(); + TreeItem* item = static_cast( index.internalPointer() ); + return item->data( index.column() ); + } + +Qt::ItemFlags PacksTreeModel::flags(const QModelIndex &index) const + { + if( !index.isValid() ) + return 0; + if( !index.parent().isValid() ) // First level item = dictionary + return Qt::ItemIsEnabled; + else // pack + return Qt::ItemIsEnabled | Qt::ItemIsSelectable; + } + +QVariant PacksTreeModel::headerData(int section, Qt::Orientation orientation, int role) const + { + if( orientation == Qt::Horizontal && role == Qt::DisplayRole ) + switch( section ) + { + case 0: return tr("Card pack"); break; + case 1: return tr("Sched"); break; + case 2: return tr("New"); break; + } + return QVariant(); + } + +QModelIndex PacksTreeModel::index(int row, int column, const QModelIndex &parent) const + { + if( !hasIndex(row, column, parent) ) + return QModelIndex(); + if( !parent.isValid() ) // First level item = dictionary + { + Dictionary* dic = m_appModel->dictionary( row ); + if( dic ) + return createIndex( row, column, dic ); + else + return QModelIndex(); + } + TreeItem* parentItem = static_cast( parent.internalPointer() ); + const TreeItem* childItem = parentItem->child( row ); + if( childItem ) + return createIndex( row, column, (void*)childItem ); + else + return QModelIndex(); + } + +QModelIndex PacksTreeModel::parent(const QModelIndex &index) const + { + if( !index.isValid() ) + return QModelIndex(); + TreeItem* childItem = static_cast( index.internalPointer() ); + if( !childItem ) + return QModelIndex(); + const TreeItem* parentItem = childItem->parent(); + + if( parentItem ) + return createIndex( parentItem->row(), 0, (void*)parentItem ); + else + return QModelIndex(); // The root item + } + +int PacksTreeModel::rowCount(const QModelIndex &parent) const + { + if( parent.column() > 0 ) // Only the first column may have children + return 0; + if( !parent.isValid() ) // Root item + return m_appModel->dictionariesNum(); + TreeItem* parentItem = static_cast( parent.internalPointer() ); + return parentItem->childCount(); + } + +void PacksTreeModel::updateData() // TODO: Suspicious method, just reveals protected methods + { + beginResetModel(); + endResetModel(); + } + + diff --git a/src/main-view/PacksTreeModel.h b/src/main-view/PacksTreeModel.h new file mode 100644 index 0000000..f04036d --- /dev/null +++ b/src/main-view/PacksTreeModel.h @@ -0,0 +1,32 @@ +#ifndef PACKSTREEMODEL_H +#define PACKSTREEMODEL_H + +#include + +#include "../dictionary/CardPack.h" + +class AppModel; + +class PacksTreeModel : public QAbstractItemModel +{ + Q_OBJECT + +public: + PacksTreeModel( AppModel* aAppModel, QObject* aParent = 0); + + QVariant data( const QModelIndex &index, int role ) const; + Qt::ItemFlags flags( const QModelIndex &index ) const; + QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const; + QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() ) const; + QModelIndex parent( const QModelIndex &index ) const; + int rowCount( const QModelIndex &parent = QModelIndex() ) const; + int columnCount( const QModelIndex &/*parent*/ = QModelIndex() ) const { return 3; } + +public slots: + void updateData(); + +private: + AppModel* m_appModel; +}; + +#endif // PACKSTREEMODEL_H diff --git a/src/main-view/RecentFilesManager.cpp b/src/main-view/RecentFilesManager.cpp new file mode 100644 index 0000000..d554eb4 --- /dev/null +++ b/src/main-view/RecentFilesManager.cpp @@ -0,0 +1,99 @@ +#include "RecentFilesManager.h" + +RecentFilesManager::RecentFilesManager(QObject* parent, QMenu* recentFilesMenu): + QObject(parent), recentFilesMenu(recentFilesMenu) +{ +} + +void RecentFilesManager::createRecentFileActs(const QStringList& recentFiles) +{ + if(recentFiles.isEmpty()) + { + recentFilesMenu->setEnabled(false); + return; + } + int recentFilesNum = recentFiles.size(); + if(recentFilesNum > MaxRecentFiles) + recentFilesNum = MaxRecentFiles; + for(int i = 0; i < recentFilesNum; i++) + recentFilesMenu->addAction(createRecentFileAction(recentFiles[i])); + updateActionTexts(); +} + +QAction* RecentFilesManager::createRecentFileAction(const QString& filePath) +{ + QAction* action = new QAction(this); + action->setData(QDir::fromNativeSeparators(filePath)); + connect(action, SIGNAL(triggered()), this, SLOT(triggerRecentFile())); + return action; +} + +void RecentFilesManager::updateActionTexts() +{ + for(int i = 0; i < recentFilesMenu->actions().size(); i++) + { + QAction* action = recentFilesMenu->actions()[i]; + QString filePath = getActionFile(action); + QString fileName = getShortFileName(filePath); + QString fileDir = QDir::toNativeSeparators(getShortDirPath(filePath)); + QString text = QString("&%1 %2 (%3)").arg((i + 1) % 10) + .arg(fileName).arg(fileDir); + action->setText(text); + } +} + +QString RecentFilesManager::getActionFile(QAction* action) +{ + return action->data().toString(); +} + +QString RecentFilesManager::getLastUsedFilePath() const +{ + if(recentFilesMenu->actions().isEmpty()) + return QString(); + return getActionFile(recentFilesMenu->actions().first()); +} + +QString RecentFilesManager::getShortDirPath(const QString& filePath) const +{ + QString path = QFileInfo(filePath).absolutePath(); + QFontMetrics metrics(recentFilesMenu->font()); + return metrics.elidedText(path, Qt::ElideMiddle, MaxPathLength); +} + +void RecentFilesManager::triggerRecentFile() +{ + QAction *action = qobject_cast(sender()); + if(action) + emit recentFileTriggered(getActionFile(action)); +} + +void RecentFilesManager::addFile( const QString& filePath) +{ + addRecentFileAction(filePath); + updateActionTexts(); + emit addedFile(); +} + +void RecentFilesManager::addRecentFileAction(const QString& filePath) +{ + recentFilesMenu->setEnabled(true); + foreach(QAction* action, recentFilesMenu->actions()) + if(action->data() == filePath) + recentFilesMenu->removeAction(action); + QAction* newAction = createRecentFileAction(filePath); + if(!recentFilesMenu->actions().isEmpty()) + recentFilesMenu->insertAction(recentFilesMenu->actions().first(), newAction); + else + recentFilesMenu->addAction(newAction); + if(recentFilesMenu->actions().size() > MaxRecentFiles) + recentFilesMenu->removeAction(recentFilesMenu->actions().last()); +} + +QStringList RecentFilesManager::getFiles() const +{ + QStringList list; + foreach(QAction* action, recentFilesMenu->actions()) + list << getActionFile(action); + return list; +} diff --git a/src/main-view/RecentFilesManager.h b/src/main-view/RecentFilesManager.h new file mode 100644 index 0000000..7988a0e --- /dev/null +++ b/src/main-view/RecentFilesManager.h @@ -0,0 +1,43 @@ +#ifndef RECENT_FILES_MANAGER_H +#define RECENT_FILES_MANAGER_H + +#include +#include + +class RecentFilesManager: public QObject +{ + Q_OBJECT + +public: + RecentFilesManager(QObject* parent, QMenu* recentFilesMenu); + void createRecentFileActs(const QStringList& recentFiles); + void addFile( const QString& filePath); + QString getLastUsedFilePath() const; + QStringList getFiles() const; + +private: + static QString getShortFileName(const QString& filePath) + { return QFileInfo(filePath).fileName(); } + static QString getActionFile(QAction* action); + +private: + QAction* createRecentFileAction(const QString& filePath); + void updateActionTexts(); + QString getShortDirPath(const QString& filePath) const; + void addRecentFileAction(const QString& filePath); + +private slots: + void triggerRecentFile(); + +signals: + void recentFileTriggered(const QString& filePath); + void addedFile(); + +private: + static const int MaxRecentFiles = 10; + static const int MaxPathLength = 300; + +private: + QMenu* recentFilesMenu; +}; +#endif diff --git a/src/main-view/RecordEditor.cpp b/src/main-view/RecordEditor.cpp new file mode 100644 index 0000000..3f7a96c --- /dev/null +++ b/src/main-view/RecordEditor.cpp @@ -0,0 +1,122 @@ +#include "RecordEditor.h" + +#include + +const float RecordEditor::EditorWidthIncrease = 1.5; + +RecordEditor::RecordEditor(QWidget* parent, const QRect& cellRect) : + QTextEdit(parent), cellRect(cellRect), + enabledSizeUpdates(true) +{ + setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); + setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + connect( this, SIGNAL(textChanged()), SLOT(updateEditor()) ); +} + +void RecordEditor::startDrawing() +{ + clear(); + enabledSizeUpdates = false; +} + +void RecordEditor::endDrawing() +{ + enabledSizeUpdates = true; + updateEditor(); +} + +void RecordEditor::drawText(const QString& text) +{ + textCursor().insertText(text); +} + +void RecordEditor::drawImage(const QString& filePath) +{ + QTextImageFormat format; + format.setVerticalAlignment(QTextCharFormat::AlignBaseline); + format.setName(filePath); + format.setHeight(ThumbnailSize); + textCursor().insertImage(format); +} + +void RecordEditor::insertImage(int cursorPos, const QString& filePath) +{ + moveCursor(cursorPos); + drawImage(filePath); +} + +void RecordEditor::moveCursor(int cursorPos) +{ + QTextCursor cursor = textCursor(); + cursor.setPosition(cursorPos); + setTextCursor(cursor); +} + +QString RecordEditor::getText() const +{ + QString text; + QTextBlock block = document()->begin(); + while(block.isValid()) + { + for(QTextBlock::iterator it = block.begin(); !it.atEnd(); it++) + { + QTextCharFormat format = it.fragment().charFormat(); + if(format.isImageFormat()) + text += QString(""; + else + text += it.fragment().text(); + } + block = block.next(); + } + return text; +} + +QSize RecordEditor::sizeHint() const +{ + int width = getEditorWidth(); + return QSize(width, getEditorHeight()); +} + +int RecordEditor::getEditorWidth() const +{ + int horMargins = contentsMargins().left() * 2; + int textWidth = cellRect.width() - horMargins; + document()->setTextWidth(textWidth); + if(textWrapped() && textWidth < MinWidth) + { + textWidth = MinWidth; + document()->setTextWidth(textWidth); + } + return textWidth + horMargins; +} + +bool RecordEditor::textWrapped() const +{ + return document()->size().height() > cellRect.height(); +} + +int RecordEditor::getEditorHeight() const +{ + return document()->size().height() + contentsMargins().top() * 2; +} + +void RecordEditor::updateEditor() +{ + if(!enabledSizeUpdates) + return; + adjustSize(); + updatePos(); +} + +void RecordEditor::updatePos() +{ + QRect editorRect = cellRect; + editorRect.setSize(size()); + QSize viewportSize = qobject_cast(parent())->size(); + if(editorRect.right() > viewportSize.width()) + editorRect.moveRight(viewportSize.width()); + if(editorRect.bottom() > viewportSize.height()) + editorRect.moveBottom(viewportSize.height()); + move(editorRect.topLeft()); +} diff --git a/src/main-view/RecordEditor.h b/src/main-view/RecordEditor.h new file mode 100644 index 0000000..40b5dc5 --- /dev/null +++ b/src/main-view/RecordEditor.h @@ -0,0 +1,46 @@ +#ifndef RECORD_EDITOR_H +#define RECORD_EDITOR_H + +#include + +#include "FieldContentPainter.h" + +class RecordEditor: public QTextEdit, public FieldContentPainter +{ +Q_OBJECT + +private: + static const int ThumbnailSize = 25; + static const int MinWidth = 150; + static const int MaxWidth = 400; + static const float EditorWidthIncrease; + +public: + RecordEditor(QWidget* parent, const QRect& cellRect); + QRect getCellRect() const { return cellRect; } + void startDrawing(); + void endDrawing(); + void drawText(const QString& text); + void drawImage(const QString& filePath); + void insertImage(int cursorPos, const QString& filePath); + QString getText() const; + +protected: + QSize sizeHint() const; + +private: + int getEditorWidth() const; + int getEditorHeight() const; + void updatePos(); + bool textWrapped() const; + void moveCursor(int cursorPos); + +public slots: + void updateEditor(); + +private: + QRect cellRect; + bool enabledSizeUpdates; +}; +#endif + diff --git a/src/main-view/UndoCommands.cpp b/src/main-view/UndoCommands.cpp new file mode 100644 index 0000000..349b2a7 --- /dev/null +++ b/src/main-view/UndoCommands.cpp @@ -0,0 +1,322 @@ +#include "UndoCommands.h" +#include "DictTableModel.h" +#include "DictTableView.h" +#include "../dictionary/Dictionary.h" +#include "../dictionary/DicRecord.h" +#include "../main-view/MainWindow.h" +#include "../main-view/CardFilterModel.h" + +UndoRecordCmd::UndoRecordCmd( const MainWindow* aMainWin ): + m_mainWindow( aMainWin ) + { + } + +const DictTableView* UndoRecordCmd::getCurView() + { + if( !m_mainWindow ) + return NULL; + const DictTableView* dictView = m_mainWindow->getCurDictView(); // May be proxy view + return dictView; + } + +CardFilterModel* UndoRecordCmd::getProxyModel( const DictTableView* aCurDictView ) + { + CardFilterModel* proxyModel = qobject_cast( aCurDictView->model() ); + return proxyModel; + } + +void UndoRecordCmd::insertRows( QList aRowNumbers ) + { + const DictTableView* dictView = getCurView(); + CardFilterModel* proxyModel = getProxyModel( dictView ); + + // Insert rows by positions in the direct order + foreach( int row, aRowNumbers ) + { + if( proxyModel ) + proxyModel->addFilterRow( row ); + m_dictModel->insertRows( row, 1 ); + } + } + +void UndoRecordCmd::setRecords( QMap aRecords ) + { + Dictionary* dict = const_cast( m_dictModel->dictionary() ); + dict->disableRecordUpdates(); + + // Init rows by positions in the direct order + foreach( int row, aRecords.keys() ) + { + QModelIndex index = m_dictModel->index( row, 0 ); + DicRecord* record = aRecords.value( row ); + m_dictModel->setData( index, QVariant::fromValue( *record ), DictTableModel::DicRecordRole ); + } + dict->enableRecordUpdates(); + } + +void UndoRecordCmd::removeRows( QList aRowNumbers ) + { + const DictTableView* dictView = m_mainWindow->getCurDictView(); // May be proxy view + CardFilterModel* proxyModel = getProxyModel( dictView ); + Dictionary* dict = const_cast( m_dictModel->dictionary() ); + dict->disableRecordUpdates(); + + // Remove records by ranges from back + QListIterator i( aRowNumbers ); + i.toBack(); + while( i.hasPrevious() ) + { + int pos = i.previous(); + if( proxyModel ) + proxyModel->removeFilterRow( pos ); + m_dictModel->removeRows( pos, 1 ); + } + dict->enableRecordUpdates(); + } + + +/** Selects rows in the list. + * Sets the first row in the list as current. + */ +void UndoRecordCmd::selectRows( QList aRowNumbers ) + { + const DictTableView* dictView = m_mainWindow->getCurDictView(); // May be proxy view + CardFilterModel* proxyModel = getProxyModel( dictView ); + int topRow = aRowNumbers.first(); + if( topRow > m_dictModel->rowCount() - 1 ) // don't go beyond table boundaries + topRow = m_dictModel->rowCount() - 1; + QModelIndex topIndex = m_dictModel->index( topRow, 0, QModelIndex() ); + QItemSelectionModel* selectionModel = dictView->selectionModel(); + selectionModel->clear(); + foreach( int row, aRowNumbers ) + { + if( row > m_dictModel->rowCount() - 1 ) // don't go beyond table boundaries + row = m_dictModel->rowCount() - 1; + QModelIndex index = m_dictModel->index( row, 0, QModelIndex() ); + if( proxyModel ) + { + index = proxyModel->mapFromSource( index ); + if( !index.isValid() ) + continue; + } + selectionModel->setCurrentIndex( index, QItemSelectionModel::Select | QItemSelectionModel::Rows ); + } + if( proxyModel ) + topIndex = proxyModel->mapFromSource( topIndex ); + if( topIndex.isValid() ) + selectionModel->setCurrentIndex( topIndex, QItemSelectionModel::Current ); + } + +void UndoRecordCmd::selectRow( int aRow ) + { + QList list; + list << aRow; + selectRows( list ); + } + +//============================================================================================================== + +InsertRecordsCmd::InsertRecordsCmd( const MainWindow* aMainWin): + UndoRecordCmd( aMainWin ) + { + const DictTableView* dictView = getCurView(); + m_dictModel = dictView->dicTableModel(); // Always original model + + // If no selection, insert 1 row in the end + int pos = m_dictModel->rowCount(); + int rowsNum = 1; + QModelIndexList selectedRows = dictView->selectionModel()->selectedRows(); + if( !selectedRows.isEmpty() ) + // Insert number of rows equal to the selected rows + { + QAbstractProxyModel* proxyModel = qobject_cast( dictView->model() ); + if( proxyModel ) + { // convert selection to source indexes + QModelIndexList list; + foreach( QModelIndex index, selectedRows ) + list << proxyModel->mapToSource( index ); + selectedRows = list; + } + + qSort( selectedRows ); // to find the top row + pos = selectedRows.first().row(); + rowsNum = selectedRows.size(); + } + for( int r = pos; r < pos + rowsNum; r++ ) + m_rowNumbers << r; + + updateText(); + } + +void InsertRecordsCmd::updateText() + { + setText(QObject::tr("Insert %n record(s)", "Undo action of inserting records", m_rowNumbers.size() )); + } + +void InsertRecordsCmd::redo() + { + insertRows( m_rowNumbers ); + selectRows( m_rowNumbers ); + } + +void InsertRecordsCmd::undo() + { + removeRows( m_rowNumbers ); + selectRow( m_rowNumbers.first() ); + } + +bool InsertRecordsCmd::mergeWith( const QUndoCommand* command ) + { + const InsertRecordsCmd* otherInsertCmd = static_cast( command ); + if( !otherInsertCmd ) + return false; + if( otherInsertCmd->m_dictModel != m_dictModel ) + return false; + + // Find where to insert the other row numbers + int otherFirstRow = otherInsertCmd->m_rowNumbers.first(); + int otherRowsNum = otherInsertCmd->m_rowNumbers.size(); + int i = 0; + for( i = 0; i < m_rowNumbers.size(); i++ ) + if( otherFirstRow <= m_rowNumbers[i] ) + break; + int insertPos = i; + // Increment this row numbers by the number of other rows, after the insertion point + for( int i = insertPos; i < m_rowNumbers.size(); i++ ) + m_rowNumbers[i] += otherRowsNum; + // Do the insertion of other rows + for( int i = 0; i < otherRowsNum; i++ ) + m_rowNumbers.insert( insertPos + i, otherInsertCmd->m_rowNumbers[i] ); + + updateText(); + return true; + } + +//============================================================================================================== + +RemoveRecordsCmd::RemoveRecordsCmd( const MainWindow* aMainWin ): + UndoRecordCmd( aMainWin ) + { + const DictTableView* dictView = getCurView(); + m_dictModel = dictView->dicTableModel(); // Always original model + + int recordsNum = 0; + QModelIndexList selectedRows = dictView->selectionModel()->selectedRows(); + QAbstractProxyModel* proxyModel = qobject_cast( dictView->model() ); + if( proxyModel ) + { // convert selection to source indexes + QModelIndexList list; + foreach( QModelIndex index, selectedRows ) + list << proxyModel->mapToSource( index ); + selectedRows = list; + } + + foreach( QModelIndex index, selectedRows ) + { + int row = index.row(); + DicRecord record = index.data( DictTableModel::DicRecordRole ).value(); + Q_ASSERT( !index.data( DictTableModel::DicRecordRole ).isNull() ); + m_records.insert( row, new DicRecord( record ) ); + recordsNum++; + } + setText(QObject::tr( "Remove %n record(s)", "Undo action of removing records", recordsNum )); + } + +RemoveRecordsCmd::~RemoveRecordsCmd() + { + qDeleteAll( m_records ); + } + +void RemoveRecordsCmd::redo() + { + removeRows( m_records.keys() ); + selectRow( m_records.keys().first() ); + } + +void RemoveRecordsCmd::undo() + { + insertRows( m_records.keys() ); + setRecords( m_records ); + selectRows( m_records.keys() ); + } + +//============================================================================================================== + +EditRecordCmd::EditRecordCmd( QAbstractItemModel* aTableModel, const QModelIndex& aIndex, const QVariant& aValue ): + m_dictModel( aTableModel ), m_insertedRow( -1 ) + { + m_row = aIndex.row(); + m_col = aIndex.column(); + m_oldStr = aIndex.data( Qt::EditRole ).toString(); + m_newStr = aValue.toString(); + if( m_row == m_dictModel->rowCount() - 1 && m_col == m_dictModel->columnCount() - 1 ) + m_insertedRow = m_dictModel->rowCount(); + QString editStr = m_newStr; + if( editStr.length() > MaxMenuEditStrLen ) + editStr = editStr.left( MaxMenuEditStrLen ) + QChar( 8230 ); + setText( QObject::tr( "Edit \"%1\"", "Undo action of editing a record").arg( editStr ) ); + } + +void EditRecordCmd::redo() + { + QModelIndex index = m_dictModel->index( m_row, m_col ); + m_dictModel->setData( index, m_newStr, Qt::EditRole ); + if( m_insertedRow > -1 ) + m_dictModel->insertRows( m_insertedRow, 1 ); + } + +void EditRecordCmd::undo() + { + if( m_insertedRow > -1 ) + m_dictModel->removeRows( m_insertedRow, 1 ); + QModelIndex index = m_dictModel->index( m_row, m_col ); + m_dictModel->setData( index, m_oldStr, Qt::EditRole ); + } + +//============================================================================================================== + +PasteRecordsCmd::PasteRecordsCmd( QList aRecords, const MainWindow* aMainWin ): + UndoRecordCmd( aMainWin ) + { + const DictTableView* dictView = getCurView(); + m_dictModel = dictView->dicTableModel(); // Always original model + + // Find position where to insert records + // Paste above selection. If no selection -> paste in the end of dictionary + QModelIndexList selectedRows = dictView->selectionModel()->selectedRows(); + int pastePos = m_dictModel->rowCount(); + if( !selectedRows.isEmpty() ) + { + qSort( selectedRows ); + QModelIndex posIndex = selectedRows.first(); + + // If proxy view, convert position to source index + QAbstractProxyModel* proxyModel = qobject_cast( dictView->model() ); + if( proxyModel ) + posIndex = proxyModel->mapToSource( posIndex ); + + pastePos = posIndex.row(); + } + for( int i = 0; i < aRecords.size(); i++ ) + m_records.insert( pastePos + i, aRecords.value( i ) ); + + setText(QObject::tr("Paste %n record(s)", "Undo action of pasting records", m_records.size() )); + } + +PasteRecordsCmd::~PasteRecordsCmd() + { + qDeleteAll( m_records.values() ); + } + +void PasteRecordsCmd::redo() + { + insertRows( m_records.keys() ); + setRecords( m_records ); + selectRows( m_records.keys() ); + } + +void PasteRecordsCmd::undo() + { + removeRows( m_records.keys() ); + selectRow( m_records.keys().first() ); + } diff --git a/src/main-view/UndoCommands.h b/src/main-view/UndoCommands.h new file mode 100644 index 0000000..a4affec --- /dev/null +++ b/src/main-view/UndoCommands.h @@ -0,0 +1,109 @@ +#ifndef UNDOCOMMANDS_H +#define UNDOCOMMANDS_H + +#include +#include + +class DicRecord; +class MainWindow; +class DictTableView; +class DictTableModel; +class CardFilterModel; + +class UndoRecordCmd: public QUndoCommand +{ +public: + UndoRecordCmd( const MainWindow* aMainWin ); + +protected: + const DictTableView* getCurView(); + CardFilterModel* getProxyModel( const DictTableView* aCurDictView ); + + void insertRows( QList aRowNumbers ); + void setRecords( QMap aRecords ); + void removeRows( QList aRowNumbers ); + void selectRows( QList aRowNumbers ); + void selectRow( int aRow ); + +protected: + const MainWindow* m_mainWindow; + DictTableModel* m_dictModel; +}; + +class InsertRecordsCmd: public UndoRecordCmd +{ +public: + InsertRecordsCmd(const MainWindow* aMainWin); + + static const int Id = 1; + + void updateText(); + void redo(); + void undo(); + bool mergeWith( const QUndoCommand* command ); + int id() const { return Id; } + +private: + QList m_rowNumbers; +}; + +class RemoveRecordsCmd: public UndoRecordCmd +{ +public: + RemoveRecordsCmd( const MainWindow* aMainWin ); + ~RemoveRecordsCmd(); + + static const int Id = 2; + + void redo(); + void undo(); + bool mergeWith( const QUndoCommand* ) { return false; } + int id() const { return Id; } + +private: + QMap m_records; // row number -> pointer to dic record. Sorted by key: rows + // The first element is the top row +}; + +/// Doesn't inherit UndoRecordCmd! +class EditRecordCmd: public QUndoCommand +{ +public: + EditRecordCmd( QAbstractItemModel* aTableModel, const QModelIndex& aIndex, const QVariant& aValue ); + + static const int Id = 3; + + void redo(); + void undo(); + bool mergeWith( const QUndoCommand* ) { return false; } + int id() const { return Id; } + +private: + static const int MaxMenuEditStrLen = 20; + + QAbstractItemModel* m_dictModel; + int m_row; + int m_col; + QString m_oldStr; + QString m_newStr; + int m_insertedRow; +}; + +class PasteRecordsCmd: public UndoRecordCmd +{ +public: + PasteRecordsCmd( QList aRecords, const MainWindow* aMainWin ); + ~PasteRecordsCmd(); + + static const int Id = 4; + + void redo(); + void undo(); + bool mergeWith( const QUndoCommand* ) { return false; } + int id() const { return Id; } + +private: + QMap m_records; // row number -> pointer to dic record. Sorted by key: rows +}; + +#endif // UNDOCOMMANDS_H diff --git a/src/main-view/WelcomeScreen.cpp b/src/main-view/WelcomeScreen.cpp new file mode 100644 index 0000000..806a57a --- /dev/null +++ b/src/main-view/WelcomeScreen.cpp @@ -0,0 +1,51 @@ +#include "WelcomeScreen.h" + +WelcomeScreen::WelcomeScreen(QWidget* parent): + QWidget(parent) +{ + QPushButton* newButton = createWelcomeButton("filenew", + tr("Create new dictionary"), SLOT(newFile())); + QPushButton* openButton = createWelcomeButton("fileopen", + tr("Open existing dictionary"), SLOT(openFileWithDialog())); + QPushButton* openExampleButton = createWelcomeButton("", + tr("Open online dictionaries"), SLOT(openOnlineDictionaries())); + QPushButton* importButton = createWelcomeButton("", + tr("Import from CSV file"), SLOT(importFromCsv())); + recentFilesButton = createWelcomeButton("", + tr("Recent dictionaries"), NULL); + + QVBoxLayout* buttonsLt = new QVBoxLayout; + buttonsLt->addWidget(newButton); + buttonsLt->addWidget(openButton); + buttonsLt->addWidget(openExampleButton); + buttonsLt->addWidget(importButton); + buttonsLt->addWidget(recentFilesButton); + + QGridLayout* paddingLt = new QGridLayout; + paddingLt->addLayout(buttonsLt, 1, 1); + setLayout(paddingLt); +} + +QPushButton* WelcomeScreen::createWelcomeButton(const QString& iconName, + const QString& text, const char* slot) +{ + static const QSize ButtonSize(350, 50); + QPushButton* button = new QPushButton(QIcon(QString(":/images/%1.png"). + arg(iconName)), text); + button->setMaximumSize(ButtonSize); + if(slot) + connect(button, SIGNAL(clicked()), parentWidget(), slot); + return button; +} + +void WelcomeScreen::updateRecentFilesButton() +{ + recentFilesButton->setEnabled(recentFilesButton->menu() && + !recentFilesButton->menu()->actions().isEmpty()); +} + +void WelcomeScreen::setRecentFilesMenu(QMenu* menu) +{ + recentFilesButton->setMenu(menu); + updateRecentFilesButton(); +} diff --git a/src/main-view/WelcomeScreen.h b/src/main-view/WelcomeScreen.h new file mode 100644 index 0000000..17ca18e --- /dev/null +++ b/src/main-view/WelcomeScreen.h @@ -0,0 +1,25 @@ +#ifndef WELCOME_SCREEN_H +#define WELCOME_SCREEN_H + +#include +#include + +class WelcomeScreen: public QWidget +{ + Q_OBJECT + +public: + WelcomeScreen(QWidget* parent); + void setRecentFilesMenu(QMenu* menu); + +public slots: + void updateRecentFilesButton(); + +private: + QPushButton* createWelcomeButton(const QString& iconName, const QString& text, + const char* slot); + +private: + QPushButton* recentFilesButton; +}; +#endif -- cgit