File indexing completed on 2024-04-28 15:30:46

 /*
     SPDX-FileCopyrightText: 2009-2010 Michel Ludwig <michel.ludwig@kdemail.net>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "spellingmenu.h"
 
 #include "katedocument.h"
 #include "kateglobal.h"
 #include "kateview.h"
 #include "ontheflycheck.h"
 #include "spellcheck/spellcheck.h"
 
 #include "katepartdebug.h"
 
 #include <QActionGroup>
 
 #include <KLocalizedString>
 #include <KTextEditor/Range>
 
 KateSpellingMenu::KateSpellingMenu(KTextEditor::ViewPrivate *view)
     : QObject(view)
     , m_view(view)
     , m_spellingMenuAction(nullptr)
     , m_ignoreWordAction(nullptr)
     , m_addToDictionaryAction(nullptr)
     , m_spellingMenu(nullptr)
     , m_currentMisspelledRange(nullptr)
 {
 }
 
 KateSpellingMenu::~KateSpellingMenu()
 {
     m_currentMisspelledRange = nullptr; // it shouldn't be accessed anymore as it could
 }
 
 bool KateSpellingMenu::isEnabled() const
 {
     if (!m_spellingMenuAction) {
         return false;
     }
     return m_spellingMenuAction->isEnabled();
 }
 
 bool KateSpellingMenu::isVisible() const
 {
     if (!m_spellingMenuAction) {
         return false;
     }
     return m_spellingMenuAction->isVisible();
 }
 
 void KateSpellingMenu::setEnabled(bool b)
 {
     if (m_spellingMenuAction) {
         m_spellingMenuAction->setEnabled(b);
     }
 }
 
 void KateSpellingMenu::setVisible(bool b)
 {
     if (m_spellingMenuAction) {
         m_spellingMenuAction->setVisible(b);
     }
 }
 
 void KateSpellingMenu::createActions(KActionCollection *ac)
 {
     m_spellingMenuAction = new KActionMenu(i18n("Spelling"), this);
     ac->addAction(QStringLiteral("spelling_suggestions"), m_spellingMenuAction);
     m_spellingMenu = m_spellingMenuAction->menu();
     connect(m_spellingMenu, &QMenu::aboutToShow, this, &KateSpellingMenu::populateSuggestionsMenu);
 
     m_ignoreWordAction = new QAction(i18n("Ignore Word"), this);
     connect(m_ignoreWordAction, &QAction::triggered, this, &KateSpellingMenu::ignoreCurrentWord);
 
     m_addToDictionaryAction = new QAction(i18n("Add to Dictionary"), this);
     connect(m_addToDictionaryAction, &QAction::triggered, this, &KateSpellingMenu::addCurrentWordToDictionary);
 
     m_dictionaryGroup = new QActionGroup(this);
     QMapIterator<QString, QString> i(Sonnet::Speller().preferredDictionaries());
     while (i.hasNext()) {
         i.next();
         QAction *action = m_dictionaryGroup->addAction(i.key());
         action->setData(i.value());
     }
     connect(m_dictionaryGroup, &QActionGroup::triggered, [this](QAction *action) {
         if (m_selectedRange.isValid() && !m_selectedRange.isEmpty()) {
             const bool blockmode = m_view->blockSelection();
             m_view->doc()->setDictionary(action->data().toString(), m_selectedRange, blockmode);
         }
     });
 
     setVisible(false);
 }
 
 void KateSpellingMenu::caretEnteredMisspelledRange(KTextEditor::MovingRange *range)
 {
     if (m_currentMisspelledRange == range) {
         return;
     }
     m_currentMisspelledRange = range;
 }
 
 void KateSpellingMenu::caretExitedMisspelledRange(KTextEditor::MovingRange *range)
 {
     if (range != m_currentMisspelledRange) {
         // The order of 'exited' and 'entered' signals was wrong
         return;
     }
     m_currentMisspelledRange = nullptr;
 }
 
 void KateSpellingMenu::rangeDeleted(KTextEditor::MovingRange *range)
 {
     if (m_currentMisspelledRange == range) {
         m_currentMisspelledRange = nullptr;
     }
 }
 
 void KateSpellingMenu::cleanUpAfterShown()
 {
     // Ugly hack to avoid segfaults.
     // cleanUpAfterShown/ViewPrivate::aboutToHideContextMenu is called before
     // some action slot is processed.
     QTimer::singleShot(0, [this]() {
         if (m_currentMisspelledRangeNeedCleanUp) {
             m_currentMisspelledRange = nullptr;
             m_currentMisspelledRangeNeedCleanUp = false;
         }
 
         // We need to remove our list or they will accumulated on next show event
         for (auto act : m_menuOnTopSuggestionList) {
             act->parentWidget()->removeAction(act);
             delete act;
         }
         m_menuOnTopSuggestionList.clear();
     });
 }
 
 void KateSpellingMenu::prepareToBeShown(QMenu *contextMenu)
 {
     Q_ASSERT(contextMenu);
 
     if (!m_view->doc()->onTheFlySpellChecker()) {
         // Nothing todo!
         return;
     }
 
     m_selectedRange = m_view->selectionRange();
     if (m_selectedRange.isValid() && !m_selectedRange.isEmpty()) {
         // Selected words need a special handling to work properly
         auto imv = m_view->doc()->onTheFlySpellChecker()->installedMovingRanges(m_selectedRange);
         for (int i = 0; i < imv.size(); ++i) {
             if (imv.at(i)->toRange() == m_selectedRange) {
                 m_currentMisspelledRange = imv.at(i);
                 m_currentMisspelledRangeNeedCleanUp = true;
                 break;
             }
         }
     }
 
     if (m_currentMisspelledRange != nullptr) {
         setVisible(true);
         m_selectedRange = m_currentMisspelledRange->toRange(); // Support actions of m_dictionaryGroup
         const QString &misspelledWord = m_view->doc()->text(*m_currentMisspelledRange);
         m_spellingMenuAction->setText(i18n("Spelling '%1'", misspelledWord));
         // Add suggestions on top of menu
         m_currentDictionary = m_view->doc()->dictionaryForMisspelledRange(*m_currentMisspelledRange);
         m_currentSuggestions = KTextEditor::EditorPrivate::self()->spellCheckManager()->suggestions(misspelledWord, m_currentDictionary);
         int counter = 5;
         QFont boldFont; // Emphasize on-top suggestions, so does Falkon
         boldFont.setBold(true);
         for (QStringList::const_iterator i = m_currentSuggestions.cbegin(); i != m_currentSuggestions.cend() && counter > 0; ++i) {
             const QString &suggestion = *i;
             QAction *action = new QAction(suggestion, contextMenu);
             action->setFont(boldFont);
             m_menuOnTopSuggestionList.append(action);
             connect(action, &QAction::triggered, this, [suggestion, this]() {
                 replaceWordBySuggestion(suggestion);
             });
             m_spellingMenu->addAction(action);
             --counter;
         }
         contextMenu->insertActions(m_spellingMenuAction, m_menuOnTopSuggestionList);
 
     } else if (m_selectedRange.isValid() && !m_selectedRange.isEmpty()) {
         setVisible(true);
         m_spellingMenuAction->setText(i18n("Spelling"));
     } else {
         setVisible(false);
     }
 }
 
 void KateSpellingMenu::populateSuggestionsMenu()
 {
     m_spellingMenu->clear();
 
     if (m_currentMisspelledRange) {
         m_spellingMenu->addAction(m_ignoreWordAction);
         m_spellingMenu->addAction(m_addToDictionaryAction);
 
         m_spellingMenu->addSeparator();
         bool dictFound = false;
         for (auto action : m_dictionaryGroup->actions()) {
             action->setCheckable(true);
             if (action->data().toString() == m_currentDictionary) {
                 dictFound = true;
                 action->setChecked(true);
             }
             m_spellingMenu->addAction(action);
         }
         if (!dictFound && !m_currentDictionary.isEmpty()) {
             const QString dictName = Sonnet::Speller().availableDictionaries().key(m_currentDictionary);
             QAction *action = m_dictionaryGroup->addAction(dictName);
             action->setData(m_currentDictionary);
             action->setCheckable(true);
             action->setChecked(true);
             m_spellingMenu->addAction(action);
         }
 
         m_spellingMenu->addSeparator();
         int counter = 10;
         for (QStringList::const_iterator i = m_currentSuggestions.cbegin(); i != m_currentSuggestions.cend() && counter > 0; ++i) {
             const QString &suggestion = *i;
             QAction *action = new QAction(suggestion, m_spellingMenu);
             connect(action, &QAction::triggered, this, [suggestion, this]() {
                 replaceWordBySuggestion(suggestion);
             });
             m_spellingMenu->addAction(action);
             --counter;
         }
 
     } else if (m_selectedRange.isValid() && !m_selectedRange.isEmpty()) {
         for (auto action : m_dictionaryGroup->actions()) {
             action->setCheckable(false);
             m_spellingMenu->addAction(action);
         }
     }
 }
 
 void KateSpellingMenu::replaceWordBySuggestion(const QString &suggestion)
 {
     if (!m_currentMisspelledRange) {
         return;
     }
     // Ensure we keep some special dictionary setting...
     const QString dictionary = m_view->doc()->dictionaryForMisspelledRange(*m_currentMisspelledRange);
     KTextEditor::Range newRange = m_currentMisspelledRange->toRange();
     newRange.setEnd(KTextEditor::Cursor(newRange.start().line(), newRange.start().column() + suggestion.size()));
 
     KTextEditor::DocumentPrivate *doc = m_view->doc();
     KTextEditor::EditorPrivate::self()->spellCheckManager()->replaceCharactersEncodedIfNecessary(suggestion, doc, *m_currentMisspelledRange);
 
     // ...on the replaced word
     m_view->doc()->setDictionary(dictionary, newRange);
     m_view->clearSelection(); // Ensure cursor move and next right click works properly if there was a selection
 }
 
 void KateSpellingMenu::addCurrentWordToDictionary()
 {
     if (!m_currentMisspelledRange) {
         return;
     }
     const QString &misspelledWord = m_view->doc()->text(*m_currentMisspelledRange);
     const QString dictionary = m_view->doc()->dictionaryForMisspelledRange(*m_currentMisspelledRange);
     KTextEditor::EditorPrivate::self()->spellCheckManager()->addToDictionary(misspelledWord, dictionary);
     m_view->doc()->clearMisspellingForWord(misspelledWord); // WARNING: 'm_currentMisspelledRange' is deleted here!
     m_view->clearSelection();
 }
 
 void KateSpellingMenu::ignoreCurrentWord()
 {
     if (!m_currentMisspelledRange) {
         return;
     }
     const QString &misspelledWord = m_view->doc()->text(*m_currentMisspelledRange);
     const QString dictionary = m_view->doc()->dictionaryForMisspelledRange(*m_currentMisspelledRange);
     KTextEditor::EditorPrivate::self()->spellCheckManager()->ignoreWord(misspelledWord, dictionary);
     m_view->doc()->clearMisspellingForWord(misspelledWord); // WARNING: 'm_currentMisspelledRange' is deleted here!
     m_view->clearSelection();
 }
 
 #include "moc_spellingmenu.cpp"