Core: Merge Find and Locator into Core plugin

Change-Id: I7053310272235d854c9f409670ff52a10a7add8b
Reviewed-by: Christian Kandeler <[email protected]>
Reviewed-by: Orgad Shaneh <[email protected]>
Reviewed-by: Eike Ziller <[email protected]>

8 files changed, 66 insertions, 71 deletions

diff --git a/src/plugins/macros/findmacrohandler.cpp b/src/plugins/macros/findmacrohandler.cpp
index 4fe95088819..be7824019ae 100644
--- a/src/plugins/macros/findmacrohandler.cpp
+++ b/src/plugins/macros/findmacrohandler.cpp
@@ -32,11 +32,10 @@
 #include "macro.h"
 #include "macrotextfind.h"
 
-#include <find/ifindsupport.h>
-
 #include <coreplugin/icore.h>
 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/editormanager/ieditor.h>
+#include <coreplugin/find/ifindsupport.h>
 
 #include <aggregation/aggregate.h>
 
@@ -79,32 +78,32 @@ bool FindMacroHandler::executeEvent(const MacroEvent &macroEvent)
     if (!aggregate)
         return false;
 
-    Find::IFindSupport *currentFind = aggregate->component<Find::IFindSupport>();
+    Core::IFindSupport *currentFind = aggregate->component<Core::IFindSupport>();
     if (!currentFind)
         return false;
 
     switch (macroEvent.value(TYPE).toInt()) {
     case FINDINCREMENTAL:
         currentFind->findIncremental(macroEvent.value(BEFORE).toString(),
-                                  (Find::FindFlags)macroEvent.value(FLAGS).toInt());
+                                  (Core::FindFlags)macroEvent.value(FLAGS).toInt());
         break;
     case FINDSTEP:
         currentFind->findStep(macroEvent.value(BEFORE).toString(),
-                           (Find::FindFlags)macroEvent.value(FLAGS).toInt());
+                           (Core::FindFlags)macroEvent.value(FLAGS).toInt());
         break;
     case REPLACE:
         currentFind->replace(macroEvent.value(BEFORE).toString(),
                              macroEvent.value(AFTER).toString(),
-                             (Find::FindFlags)macroEvent.value(FLAGS).toInt());
+                             (Core::FindFlags)macroEvent.value(FLAGS).toInt());
     case REPLACESTEP:
         currentFind->replaceStep(macroEvent.value(BEFORE).toString(),
                               macroEvent.value(AFTER).toString(),
-                              (Find::FindFlags)macroEvent.value(FLAGS).toInt());
+                              (Core::FindFlags)macroEvent.value(FLAGS).toInt());
         break;
     case REPLACEALL:
         currentFind->replaceAll(macroEvent.value(BEFORE).toString(),
                              macroEvent.value(AFTER).toString(),
-                             (Find::FindFlags)macroEvent.value(FLAGS).toInt());
+                             (Core::FindFlags)macroEvent.value(FLAGS).toInt());
         break;
     case RESET:
         currentFind->resetIncrementalSearch();
@@ -113,7 +112,7 @@ bool FindMacroHandler::executeEvent(const MacroEvent &macroEvent)
     return true;
 }
 
-void FindMacroHandler::findIncremental(const QString &txt, Find::FindFlags findFlags)
+void FindMacroHandler::findIncremental(const QString &txt, Core::FindFlags findFlags)
 {
     if (!isRecording())
         return;
@@ -125,7 +124,7 @@ void FindMacroHandler::findIncremental(const QString &txt, Find::FindFlags findF
     addMacroEvent(e);
 }
 
-void FindMacroHandler::findStep(const QString &txt, Find::FindFlags findFlags)
+void FindMacroHandler::findStep(const QString &txt, Core::FindFlags findFlags)
 {
     if (!isRecording())
         return;
@@ -137,7 +136,7 @@ void FindMacroHandler::findStep(const QString &txt, Find::FindFlags findFlags)
     addMacroEvent(e);
 }
 
-void FindMacroHandler::replace(const QString &before, const QString &after, Find::FindFlags findFlags)
+void FindMacroHandler::replace(const QString &before, const QString &after, Core::FindFlags findFlags)
 {
     if (!isRecording())
         return;
@@ -150,7 +149,7 @@ void FindMacroHandler::replace(const QString &before, const QString &after, Find
     addMacroEvent(e);
 }
 
-void FindMacroHandler::replaceStep(const QString &before, const QString &after, Find::FindFlags findFlags)
+void FindMacroHandler::replaceStep(const QString &before, const QString &after, Core::FindFlags findFlags)
 {
     if (!isRecording())
         return;
@@ -163,7 +162,7 @@ void FindMacroHandler::replaceStep(const QString &before, const QString &after,
     addMacroEvent(e);
 }
 
-void FindMacroHandler::replaceAll(const QString &before, const QString &after, Find::FindFlags findFlags)
+void FindMacroHandler::replaceAll(const QString &before, const QString &after, Core::FindFlags findFlags)
 {
     if (!isRecording())
         return;
@@ -194,7 +193,7 @@ void FindMacroHandler::changeEditor(Core::IEditor *editor)
 
     Aggregation::Aggregate *aggregate = Aggregation::Aggregate::parentAggregate(editor->widget());
     if (aggregate) {
-        Find::IFindSupport *currentFind = aggregate->component<Find::IFindSupport>();
+        Core::IFindSupport *currentFind = aggregate->component<Core::IFindSupport>();
         if (currentFind) {
             MacroTextFind *macroFind = qobject_cast<MacroTextFind *>(currentFind);
             if (macroFind)
@@ -205,18 +204,18 @@ void FindMacroHandler::changeEditor(Core::IEditor *editor)
             aggregate->add(macroFind);
 
             // Connect all signals
-            connect(macroFind, SIGNAL(allReplaced(QString,QString,Find::FindFlags)),
-                    this, SLOT(replaceAll(QString,QString,Find::FindFlags)));
-            connect(macroFind, SIGNAL(incrementalFound(QString,Find::FindFlags)),
-                    this, SLOT(findIncremental(QString,Find::FindFlags)));
+            connect(macroFind, SIGNAL(allReplaced(QString,QString,Core::FindFlags)),
+                    this, SLOT(replaceAll(QString,QString,Core::FindFlags)));
+            connect(macroFind, SIGNAL(incrementalFound(QString,Core::FindFlags)),
+                    this, SLOT(findIncremental(QString,Core::FindFlags)));
             connect(macroFind, SIGNAL(incrementalSearchReseted()),
                     this, SLOT(resetIncrementalSearch()));
-            connect(macroFind, SIGNAL(replaced(QString,QString,Find::FindFlags)),
-                    this, SLOT(replace(QString,QString,Find::FindFlags)));
-            connect(macroFind, SIGNAL(stepFound(QString,Find::FindFlags)),
-                    this, SLOT(findStep(QString,Find::FindFlags)));
-            connect(macroFind, SIGNAL(stepReplaced(QString,QString,Find::FindFlags)),
-                    this, SLOT(replaceStep(QString,QString,Find::FindFlags)));
+            connect(macroFind, SIGNAL(replaced(QString,QString,Core::FindFlags)),
+                    this, SLOT(replace(QString,QString,Core::FindFlags)));
+            connect(macroFind, SIGNAL(stepFound(QString,Core::FindFlags)),
+                    this, SLOT(findStep(QString,Core::FindFlags)));
+            connect(macroFind, SIGNAL(stepReplaced(QString,QString,Core::FindFlags)),
+                    this, SLOT(replaceStep(QString,QString,Core::FindFlags)));
         }
     }
 }
diff --git a/src/plugins/macros/findmacrohandler.h b/src/plugins/macros/findmacrohandler.h
index 7f35f1adfd4..33a68e5766d 100644
--- a/src/plugins/macros/findmacrohandler.h
+++ b/src/plugins/macros/findmacrohandler.h
@@ -32,7 +32,7 @@
 
 #include "imacrohandler.h"
 
-#include <find/textfindconstants.h>
+#include <coreplugin/find/textfindconstants.h>
 
 namespace Core {
 class IEditor;
@@ -54,11 +54,11 @@ public:
     bool executeEvent(const MacroEvent &macroEvent);
 
 public slots:
-    void findIncremental(const QString &txt, Find::FindFlags findFlags);
-    void findStep(const QString &txt, Find::FindFlags findFlags);
-    void replace(const QString &before, const QString &after, Find::FindFlags findFlags);
-    void replaceStep(const QString &before, const QString &after, Find::FindFlags findFlags);
-    void replaceAll(const QString &before, const QString &after, Find::FindFlags findFlags);
+    void findIncremental(const QString &txt, Core::FindFlags findFlags);
+    void findStep(const QString &txt, Core::FindFlags findFlags);
+    void replace(const QString &before, const QString &after, Core::FindFlags findFlags);
+    void replaceStep(const QString &before, const QString &after, Core::FindFlags findFlags);
+    void replaceAll(const QString &before, const QString &after, Core::FindFlags findFlags);
     void resetIncrementalSearch();
 
 private slots:
diff --git a/src/plugins/macros/macrolocatorfilter.cpp b/src/plugins/macros/macrolocatorfilter.cpp
index e1cd889445d..e63f1f090ed 100644
--- a/src/plugins/macros/macrolocatorfilter.cpp
+++ b/src/plugins/macros/macrolocatorfilter.cpp
@@ -52,11 +52,11 @@ MacroLocatorFilter::~MacroLocatorFilter()
 {
 }
 
-QList<Locator::FilterEntry> MacroLocatorFilter::matchesFor(QFutureInterface<Locator::FilterEntry> &future, const QString &entry)
+QList<Core::LocatorFilterEntry> MacroLocatorFilter::matchesFor(QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry)
 {
     Q_UNUSED(future)
-    QList<Locator::FilterEntry> goodEntries;
-    QList<Locator::FilterEntry> betterEntries;
+    QList<Core::LocatorFilterEntry> goodEntries;
+    QList<Core::LocatorFilterEntry> betterEntries;
 
     const Qt::CaseSensitivity caseSensitivity_ = caseSensitivity(entry);
 
@@ -67,7 +67,7 @@ QList<Locator::FilterEntry> MacroLocatorFilter::matchesFor(QFutureInterface<Loca
         it.next();
         QString name = it.key();
 
-        QList<Locator::FilterEntry> *category = 0;
+        QList<Core::LocatorFilterEntry> *category = 0;
         if (name.startsWith(entry, caseSensitivity_))
             category = &betterEntries;
         else if (name.contains(entry, caseSensitivity_))
@@ -75,7 +75,7 @@ QList<Locator::FilterEntry> MacroLocatorFilter::matchesFor(QFutureInterface<Loca
 
         if (category) {
             QVariant id;
-            Locator::FilterEntry entry(this, it.key(), id, m_icon);
+            Core::LocatorFilterEntry entry(this, it.key(), id, m_icon);
             entry.extraInfo = it.value()->description();
             category->append(entry);
         }
@@ -84,7 +84,7 @@ QList<Locator::FilterEntry> MacroLocatorFilter::matchesFor(QFutureInterface<Loca
     return betterEntries;
 }
 
-void MacroLocatorFilter::accept(Locator::FilterEntry selection) const
+void MacroLocatorFilter::accept(Core::LocatorFilterEntry selection) const
 {
     // Give the focus back to the editor
     Core::IEditor *editor = Core::EditorManager::currentEditor();
diff --git a/src/plugins/macros/macrolocatorfilter.h b/src/plugins/macros/macrolocatorfilter.h
index 40a685d746f..700a597f097 100644
--- a/src/plugins/macros/macrolocatorfilter.h
+++ b/src/plugins/macros/macrolocatorfilter.h
@@ -30,7 +30,7 @@
 #ifndef MACROSPLUGIN_MACROLOCATORFILTER_H
 #define MACROSPLUGIN_MACROLOCATORFILTER_H
 
-#include <locator/ilocatorfilter.h>
+#include <coreplugin/locator/ilocatorfilter.h>
 
 #include <QIcon>
 
@@ -40,7 +40,7 @@ class MacroManager;
 
 namespace Internal {
 
-class MacroLocatorFilter : public Locator::ILocatorFilter
+class MacroLocatorFilter : public Core::ILocatorFilter
 {
     Q_OBJECT
 
@@ -48,8 +48,8 @@ public:
     MacroLocatorFilter();
     ~MacroLocatorFilter();
 
-    QList<Locator::FilterEntry> matchesFor(QFutureInterface<Locator::FilterEntry> &future, const QString &entry);
-    void accept(Locator::FilterEntry selection) const;
+    QList<Core::LocatorFilterEntry> matchesFor(QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry);
+    void accept(Core::LocatorFilterEntry selection) const;
     void refresh(QFutureInterface<void> &future);
 
 private:
diff --git a/src/plugins/macros/macros.qbs b/src/plugins/macros/macros.qbs
index b9e90960a06..f6dac5cb8f3 100644
--- a/src/plugins/macros/macros.qbs
+++ b/src/plugins/macros/macros.qbs
@@ -7,8 +7,6 @@ QtcPlugin {
 
     Depends { name: "Qt.widgets" }
     Depends { name: "Core" }
-    Depends { name: "Locator" }
-    Depends { name: "Find" }
     Depends { name: "TextEditor" }
     Depends { name: "app_version_header" }
 
diff --git a/src/plugins/macros/macros_dependencies.pri b/src/plugins/macros/macros_dependencies.pri
index 3ae94328b31..e7850c9d526 100644
--- a/src/plugins/macros/macros_dependencies.pri
+++ b/src/plugins/macros/macros_dependencies.pri
@@ -1,6 +1,4 @@
 QTC_PLUGIN_NAME = Macros
 QTC_PLUGIN_DEPENDS += \
     coreplugin \
-    locator \
-    find \
     texteditor
diff --git a/src/plugins/macros/macrotextfind.cpp b/src/plugins/macros/macrotextfind.cpp
index b56a81cdd33..1aeef19113c 100644
--- a/src/plugins/macros/macrotextfind.cpp
+++ b/src/plugins/macros/macrotextfind.cpp
@@ -34,8 +34,8 @@
 using namespace Macros;
 using namespace Macros::Internal;
 
-MacroTextFind::MacroTextFind(Find::IFindSupport *currentFind):
-    Find::IFindSupport(),
+MacroTextFind::MacroTextFind(Core::IFindSupport *currentFind):
+    Core::IFindSupport(),
     m_currentFind(currentFind)
 {
 }
@@ -46,7 +46,7 @@ bool MacroTextFind::supportsReplace() const
     return m_currentFind->supportsReplace();
 }
 
-Find::FindFlags MacroTextFind::supportedFindFlags() const
+Core::FindFlags MacroTextFind::supportedFindFlags() const
 {
     QTC_ASSERT(m_currentFind, return 0);
     return m_currentFind->supportedFindFlags();
@@ -77,38 +77,38 @@ QString MacroTextFind::completedFindString() const
     return m_currentFind->completedFindString();
 }
 
-void MacroTextFind::highlightAll(const QString &txt, Find::FindFlags findFlags)
+void MacroTextFind::highlightAll(const QString &txt, Core::FindFlags findFlags)
 {
     QTC_ASSERT(m_currentFind, return);
     m_currentFind->highlightAll(txt, findFlags);
 }
 
-Find::IFindSupport::Result MacroTextFind::findIncremental(const QString &txt, Find::FindFlags findFlags)
+Core::IFindSupport::Result MacroTextFind::findIncremental(const QString &txt, Core::FindFlags findFlags)
 {
     QTC_ASSERT(m_currentFind, return IFindSupport::NotFound);
-    Find::IFindSupport::Result result = m_currentFind->findIncremental(txt, findFlags);
+    Core::IFindSupport::Result result = m_currentFind->findIncremental(txt, findFlags);
     if (result == Found)
         emit incrementalFound(txt, findFlags);
     return result;
 }
 
-Find::IFindSupport::Result MacroTextFind::findStep(const QString &txt, Find::FindFlags findFlags)
+Core::IFindSupport::Result MacroTextFind::findStep(const QString &txt, Core::FindFlags findFlags)
 {
     QTC_ASSERT(m_currentFind, return IFindSupport::NotFound);
-    Find::IFindSupport::Result result = m_currentFind->findStep(txt, findFlags);
+    Core::IFindSupport::Result result = m_currentFind->findStep(txt, findFlags);
     if (result == Found)
         emit stepFound(txt, findFlags);
     return result;
 }
 
-void MacroTextFind::replace(const QString &before, const QString &after, Find::FindFlags findFlags)
+void MacroTextFind::replace(const QString &before, const QString &after, Core::FindFlags findFlags)
 {
     QTC_ASSERT(m_currentFind, return);
     m_currentFind->replace(before, after, findFlags);
     emit replaced(before, after, findFlags);
 }
 
-bool MacroTextFind::replaceStep(const QString &before, const QString &after, Find::FindFlags findFlags)
+bool MacroTextFind::replaceStep(const QString &before, const QString &after, Core::FindFlags findFlags)
 {
     QTC_ASSERT(m_currentFind, return false);
     bool result = m_currentFind->replaceStep(before, after, findFlags);
@@ -116,7 +116,7 @@ bool MacroTextFind::replaceStep(const QString &before, const QString &after, Fin
     return result;
 }
 
-int MacroTextFind::replaceAll(const QString &before, const QString &after, Find::FindFlags findFlags)
+int MacroTextFind::replaceAll(const QString &before, const QString &after, Core::FindFlags findFlags)
 {
     QTC_ASSERT(m_currentFind, return 0);
     int result = m_currentFind->replaceAll(before, after, findFlags);
diff --git a/src/plugins/macros/macrotextfind.h b/src/plugins/macros/macrotextfind.h
index f2e6fecb66e..f703664dfdd 100644
--- a/src/plugins/macros/macrotextfind.h
+++ b/src/plugins/macros/macrotextfind.h
@@ -30,50 +30,50 @@
 #ifndef MACROSPLUGIN_MACROTEXTFIND_H
 #define MACROSPLUGIN_MACROTEXTFIND_H
 
-#include <find/ifindsupport.h>
+#include <coreplugin/find/ifindsupport.h>
 
 #include <QPointer>
 
 namespace Macros {
 namespace Internal {
 
-class MacroTextFind : public Find::IFindSupport
+class MacroTextFind : public Core::IFindSupport
 {
     Q_OBJECT
 
 public:
-    MacroTextFind(Find::IFindSupport *currentFind);
+    MacroTextFind(Core::IFindSupport *currentFind);
 
     bool supportsReplace() const;
-    Find::FindFlags supportedFindFlags() const;
+    Core::FindFlags supportedFindFlags() const;
     void resetIncrementalSearch();
     void clearResults();
     QString currentFindString() const;
     QString completedFindString() const;
 
-    void highlightAll(const QString &txt, Find::FindFlags findFlags);
-    Find::IFindSupport::Result findIncremental(const QString &txt, Find::FindFlags findFlags);
-    Find::IFindSupport::Result findStep(const QString &txt, Find::FindFlags findFlags);
-    void replace(const QString &before, const QString &after, Find::FindFlags findFlags);
-    bool replaceStep(const QString &before, const QString &after, Find::FindFlags findFlags);
-    int replaceAll(const QString &before, const QString &after, Find::FindFlags findFlags);
+    void highlightAll(const QString &txt, Core::FindFlags findFlags);
+    Core::IFindSupport::Result findIncremental(const QString &txt, Core::FindFlags findFlags);
+    Core::IFindSupport::Result findStep(const QString &txt, Core::FindFlags findFlags);
+    void replace(const QString &before, const QString &after, Core::FindFlags findFlags);
+    bool replaceStep(const QString &before, const QString &after, Core::FindFlags findFlags);
+    int replaceAll(const QString &before, const QString &after, Core::FindFlags findFlags);
 
     void defineFindScope();
     void clearFindScope();
 
 signals:
     void incrementalSearchReseted();
-    void incrementalFound(const QString &txt, Find::FindFlags findFlags);
-    void stepFound(const QString &txt, Find::FindFlags findFlags);
+    void incrementalFound(const QString &txt, Core::FindFlags findFlags);
+    void stepFound(const QString &txt, Core::FindFlags findFlags);
     void replaced(const QString &before, const QString &after,
-        Find::FindFlags findFlags);
+        Core::FindFlags findFlags);
     void stepReplaced(const QString &before, const QString &after,
-        Find::FindFlags findFlags);
+        Core::FindFlags findFlags);
     void allReplaced(const QString &before, const QString &after,
-        Find::FindFlags findFlags);
+        Core::FindFlags findFlags);
 
 private:
-    QPointer<Find::IFindSupport> m_currentFind;
+    QPointer<Core::IFindSupport> m_currentFind;
 };
 
 } // namespace Internal