Scintilla autocomplete

src/Cmd.cpp

@@ -41,7 +41,9 @@ const TCHAR* Cmd::CmdName[] = {
     _T("Search in Source Files"),       // GREP
     _T("Search in Other Files"),        // GREP_TEXT
     _T("About"),                        // VERSION
-    _T("About CTags")                   // CTAGS_VERSION
+    _T("About CTags"),                  // CTAGS_VERSION
+    _T("AutoComplete Scintilla"),       // AUTOCOMPLETE_SCINTILLA
+    _T("AutoComplete Scintilla")        // AUTOCOMPLETE_SCINTILLA_SYMBOL
 };
 
 

src/CmdDefines.h

@@ -45,7 +45,9 @@ enum CmdId_t
     GREP,
     GREP_TEXT,
     VERSION,
-    CTAGS_VERSION
+    CTAGS_VERSION,
+    AUTOCOMPLETE_SCINTILLA,
+    AUTOCOMPLETE_SCINTILLA_SYMBOL
 };
 
 

src/CmdEngine.cpp

@@ -50,7 +50,9 @@ const TCHAR* CmdEngine::CmdLine[] = {
     _T("\"%s\\global.exe\" -g --result=grep \"%s\""),                       // GREP
     _T("\"%s\\global.exe\" -gO --result=grep \"%s\""),                      // GREP_TEXT
     _T("\"%s\\global.exe\" --version"),                                     // VERSION
-    _T("\"%s\\ctags.exe\" --version")                                       // CTAGS_VERSION
+    _T("\"%s\\ctags.exe\" --version"),                                      // CTAGS_VERSION
+    _T("\"%s\\global.exe\" -cT \"%s\""),                                    // AUTOCOMPLETE_SCINTILLA
+    _T("\"%s\\global.exe\" -cs \"%s\"")                                     // AUTOCOMPLETE_SCINTILLA_SYMBOL
 };
 
 
@@ -125,6 +127,9 @@ unsigned CmdEngine::start()
         return 1;
 
     bool showActivityWin = true;
+    if (_cmd->_id == AUTOCOMPLETE_SCINTILLA || _cmd->_id == AUTOCOMPLETE_SCINTILLA_SYMBOL)
+        showActivityWin = false;
+
     if (_cmd->_id != CREATE_DATABASE && _cmd->_id != UPDATE_SINGLE)
     {
         // Wait 300 ms and if process has finished don't show Activity Window

src/Config.cpp

@@ -53,6 +53,9 @@ const TCHAR DbConfig::cUseLibDbKey[]        = _T("UseLibraryDBs = ");
 const TCHAR DbConfig::cLibDbPathsKey[]      = _T("LibraryDBPaths = ");
 const TCHAR DbConfig::cUsePathFilterKey[]   = _T("UsePathFilters = ");
 const TCHAR DbConfig::cPathFiltersKey[]     = _T("PathFilters = ");
+const TCHAR DbConfig::cUseSciAutoCKey[]     = _T("UseSciAutoC = ");
+const TCHAR DbConfig::cSciAutoCIgnoreCaseKey[] = _T("SciAutoCIgnoreCase = ");
+const TCHAR DbConfig::cSciAutoCFromNCharKey[]  = _T("SciAutoFromNChar = ");
 
 const TCHAR DbConfig::cDefaultParser[]   = _T("default");
 const TCHAR DbConfig::cCtagsParser[]     = _T("ctags");
@@ -85,6 +88,9 @@ void DbConfig::SetDefaults()
     _libDbPaths.clear();
     _usePathFilter = false;
     _pathFilters.clear();
+    _useSciAutoC = false;
+    _SciAutoCIgnoreCase = false;
+    _SciAutoCFromNChar = 3;
 }
 
 
@@ -137,6 +143,29 @@ bool DbConfig::ReadOption(TCHAR* line)
         const unsigned pos = _countof(cPathFiltersKey) - 1;
         FiltersFromBuf(&line[pos], _T(";"));
     }
+    else if (!_tcsncmp(line, cUseSciAutoCKey, _countof(cUseSciAutoCKey) - 1))
+    {
+        const unsigned pos = _countof(cUseSciAutoCKey) - 1;
+        if (!_tcsncmp(&line[pos], _T("yes"), _countof(_T("yes")) - 1))
+            _useSciAutoC = true;
+        else
+            _useSciAutoC = false;
+    }
+    else if (!_tcsncmp(line, cSciAutoCIgnoreCaseKey, _countof(cSciAutoCIgnoreCaseKey) - 1))
+    {
+        const unsigned pos = _countof(cSciAutoCIgnoreCaseKey) - 1;
+        if (!_tcsncmp(&line[pos], _T("yes"), _countof(_T("yes")) - 1))
+            _SciAutoCIgnoreCase = true;
+        else
+            _SciAutoCIgnoreCase = false;
+    }
+    else if (!_tcsncmp(line, cSciAutoCFromNCharKey, _countof(cSciAutoCFromNCharKey) - 1))
+    {
+        const unsigned pos = _countof(cSciAutoCFromNCharKey) - 1;
+        _SciAutoCFromNChar = _tstoi(&line[pos]);
+        if (_SciAutoCFromNChar < SCIAUTOCNCHAR_MIN || _SciAutoCFromNChar > SCIAUTOCNCHAR_MAX)
+            _SciAutoCFromNChar = 3;
+    }
     else
     {
         return false;
@@ -166,6 +195,9 @@ bool DbConfig::Write(FILE* fp) const
     if (_ftprintf_s(fp, _T("%s%s\n"), cLibDbPathsKey, libDbPaths.C_str()) > 0)
     if (_ftprintf_s(fp, _T("%s%s\n"), cUsePathFilterKey, (_usePathFilter ? _T("yes") : _T("no"))) > 0)
     if (_ftprintf_s(fp, _T("%s%s\n"), cPathFiltersKey, pathFilters.C_str()) > 0)
+    if (_ftprintf_s(fp, _T("%s%s\n"), cUseSciAutoCKey, (_useSciAutoC ? _T("yes") : _T("no"))) > 0)
+    if (_ftprintf_s(fp, _T("%s%s\n"), cSciAutoCIgnoreCaseKey, (_SciAutoCIgnoreCase ? _T("yes") : _T("no"))) > 0)
+    if (_ftprintf_s(fp, _T("%s%i\n"), cSciAutoCFromNCharKey, _SciAutoCFromNChar) > 0)
         success = true;
 
     return success;
@@ -294,6 +326,9 @@ const DbConfig& DbConfig::operator=(const DbConfig& rhs)
         _libDbPaths     = rhs._libDbPaths;
         _usePathFilter  = rhs._usePathFilter;
         _pathFilters    = rhs._pathFilters;
+        _useSciAutoC    = rhs._useSciAutoC;
+        _SciAutoCIgnoreCase = rhs._SciAutoCIgnoreCase;
+        _SciAutoCFromNChar  = rhs._SciAutoCFromNChar;
     }
 
     return *this;
@@ -310,7 +345,9 @@ bool DbConfig::operator==(const DbConfig& rhs) const
 
     return (_parserIdx == rhs._parserIdx && _autoUpdate == rhs._autoUpdate &&
             _useLibDb == rhs._useLibDb && _libDbPaths == rhs._libDbPaths &&
-            _usePathFilter == rhs._usePathFilter && _pathFilters == rhs._pathFilters);
+            _usePathFilter == rhs._usePathFilter && _pathFilters == rhs._pathFilters &&
+            _useSciAutoC == rhs._useSciAutoC && _SciAutoCIgnoreCase == rhs._SciAutoCIgnoreCase &&
+            _SciAutoCFromNChar == rhs._SciAutoCFromNChar);
 }
 
 

src/Config.h

@@ -78,6 +78,9 @@ class DbConfig
     std::vector<CPath>  _libDbPaths;
     bool                _usePathFilter;
     std::vector<CPath>  _pathFilters;
+    bool                _useSciAutoC;
+    bool                _SciAutoCIgnoreCase;
+    int                 _SciAutoCFromNChar;
 
 private:
     bool ReadOption(TCHAR* line);
@@ -91,6 +94,9 @@ class DbConfig
     static const TCHAR cLibDbPathsKey[];
     static const TCHAR cUsePathFilterKey[];
     static const TCHAR cPathFiltersKey[];
+    static const TCHAR cUseSciAutoCKey[];
+    static const TCHAR cSciAutoCIgnoreCaseKey[];
+    static const TCHAR cSciAutoCFromNCharKey[];
 
     static const TCHAR cDefaultParser[];
     static const TCHAR cCtagsParser[];

src/GTags.cpp

@@ -58,6 +58,47 @@ constexpr int MIN_NOTEPADPP_VERSION = ((MIN_NOTEPADPP_VERSION_MAJOR << 16) | MIN
 std::unique_ptr<CPath>  ChangedFile;
 bool                    DeInitCOM = false;
 
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+#define REGIMGIDL 22680
+const char *xpmGtL[] = {
+/* columns rows colors chars-per-pixel */
+    "16 16 14 1 ",
+    "  c #000000",
+    ". c #800000",
+    "X c #FF0000",
+    "o c #008000",
+    "O c #00FF00",
+    "+ c #808000",
+    "@ c #FFFF00",
+    "# c #000080",
+    "$ c #0000FF",
+    "% c #800080",
+    "& c #008080",
+    "* c #808080",
+    "= c #C0C0C0",
+    "- c None",
+    /* pixels */
+    "-----=*=**=-----",
+    "----#O$&&&$ =---",
+    "--=@$$OOoOO$o---",
+    "-=@#**&&&&$O$O=-",
+    "-+@+=#%%$$$$$$o-",
+    "=@*++%$%$$$$$$&*",
+    "*@@=#$#%X$$$$$$=",
+    "-@*+=+$*$$$$$$$=",
+    "=@+@%*&$$$$$$$$=",
+    "=@=**$=*$&$$&$$=",
+    "-+%+@+$%&&*&$$$*",
+    "-=$&+*++%*$$$$o-",
+    "-=+$*+%@.%*$$&*-",
+    "---$$*%$*$$$&o--",
+    "---=$$$$$$$#=---",
+    "------*=*==-----"
+};
+std::string sciAutoCList;
+std::string _defaultCharList;
+#define SCIAUTOCLIST_LONG 256
 
 /**
  *  \brief
@@ -147,7 +188,7 @@ void dbWriteCB(const CmdPtr_t& cmd);
 /**
  *  \brief
  */
-DbHandle getDatabase(bool writeEn = false)
+DbHandle getDatabase(bool writeEn = false, bool createDb = true)
 {
     INpp& npp = INpp::Get();
     bool success;
@@ -160,6 +201,9 @@ DbHandle getDatabase(bool writeEn = false)
     if (!db && !writeEn && GTagsSettings._useDefDb && !GTagsSettings._defDbPath.IsEmpty())
         db = DbManager::Get().GetDbAt(GTagsSettings._defDbPath, writeEn, &success);
 
+    if (!createDb)
+        return db;
+
     if (!db)
     {
         if (writeEn)
@@ -260,6 +304,115 @@ void halfComplCB(const CmdPtr_t& cmd)
 }
 
 
+/**
+ *  \brief
+ */
+std::string ws2s(const std::wstring& wstr)
+{
+    int size_needed = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), int(wstr.length() + 1), 0, 0, 0, 0);
+    std::string strTo(size_needed, 0);
+    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), int(wstr.length() + 1), &strTo[0], size_needed, 0, 0);
+    return strTo;
+}
+
+
+/**
+ *  \brief
+ */
+std::wstring s2ws(const std::string& str)
+{
+    int size_needed = MultiByteToWideChar(CP_ACP, 0, str.c_str(), int(str.length() + 1), 0, 0);
+    std::wstring strTo(size_needed, 0);
+    MultiByteToWideChar(CP_ACP, 0, str.c_str(), int(str.length() + 1), &strTo[0], size_needed);
+    return strTo;
+}
+
+
+/**
+ *  \brief
+ */
+void ShowSciAutoComplete(BOOL ignoreCase, size_t len)
+{
+    SendMessage(INpp::Get().GetSciHandle(), SCI_AUTOCSETSEPARATOR, ' ', 0);
+    SendMessage(INpp::Get().GetSciHandle(), SCI_AUTOCSETTYPESEPARATOR, WPARAM('\x1E'), 0 );
+    SendMessage(INpp::Get().GetSciHandle(), SCI_AUTOCSETIGNORECASE, ignoreCase, 0);
+    SendMessage(INpp::Get().GetSciHandle(), SCI_REGISTERIMAGE, REGIMGIDL, (LPARAM)xpmGtL);
+    SendMessage(INpp::Get().GetSciHandle(), SCI_AUTOCSHOW, len, (LPARAM) sciAutoCList.c_str());
+}
+
+
+/**
+ *  \brief
+ */
+void sciAutoComplCB(const CmdPtr_t& cmd)
+{
+    DbManager::Get().PutDb(cmd->Db());
+
+    if (cmd->Status() == OK && cmd->Result())
+    {
+        size_t size = cmd->Parser()->GetList().size();
+        if (size == 0)
+            return;
+
+        sciAutoCList.clear();
+        int i = 0;
+        for (const auto& complEntry : cmd->Parser()->GetList())
+        {
+            sciAutoCList += ws2s(complEntry).c_str();
+            sciAutoCList += '\x1E';
+            sciAutoCList += STR(REGIMGIDL);
+            i++;
+            if (i < size)
+                sciAutoCList += " ";
+        }
+        ShowSciAutoComplete(cmd->IgnoreCase(), cmd->Tag().Len());
+        return;
+    }
+
+    if (cmd->Status() == FAILED)
+    {
+        CText msg(cmd->Result());
+        msg += _T("\nTry re-creating database.");
+        MessageBox(INpp::Get().GetHandle(), msg.C_str(), cmd->Name(), MB_OK | MB_ICONEXCLAMATION);
+    }
+    else if (cmd->Status() == RUN_ERROR)
+    {
+        MessageBox(INpp::Get().GetHandle(), _T("Running GTags failed"), cmd->Name(), MB_OK | MB_ICONERROR);
+    }
+}
+
+
+/**
+ *  \brief
+ */
+void sciHalfComplCB(const CmdPtr_t& cmd)
+{
+    if (cmd->Status() == OK)
+    {
+        cmd->Id(AUTOCOMPLETE_SCINTILLA_SYMBOL);
+
+        ParserPtr_t parser(new LineParser);
+        cmd->Parser(parser);
+
+        CmdEngine::Run(cmd, sciAutoComplCB);
+        return;
+    }
+
+    DbManager::Get().PutDb(cmd->Db());
+
+    if (cmd->Status() == FAILED)
+    {
+        CText msg(cmd->Result());
+        msg += _T("\nTry re-creating database.");
+        MessageBox(INpp::Get().GetHandle(), msg.C_str(), cmd->Name(), MB_OK | MB_ICONEXCLAMATION);
+    }
+    else if (cmd->Status() == RUN_ERROR)
+    {
+        MessageBox(INpp::Get().GetHandle(), _T("Running GTags failed"), cmd->Name(), MB_OK | MB_ICONERROR);
+    }
+}
+
+
 /**
  *  \brief
  */
@@ -941,6 +1094,13 @@ void OnNppReady()
 
         ::DrawMenuBar(npp.GetHandle());
 	}
+
+    auto defaultCharListLen = SendMessage(npp.GetSciHandle(), SCI_GETWORDCHARS, 0, 0);
+    char *defaultCharList = new char[defaultCharListLen + 1];
+    SendMessage(npp.GetSciHandle(), SCI_GETWORDCHARS, 0, reinterpret_cast<LPARAM>(defaultCharList));
+    defaultCharList[defaultCharListLen] = '\0';
+    _defaultCharList = defaultCharList;
+    delete[] defaultCharList;
 }
 
 
@@ -1024,4 +1184,55 @@ void OnFileDelete(const CPath& file)
     }
 }
 
+
+/**
+ *  \brief
+ */
+void SciAutoComplete(int ch)
+{
+    INpp& npp = INpp::Get();
+    Sci_Position curPos, startPos, endPos;
+    char tagStr[32 + 1] = { 0 };
+
+    DbHandle db = getDatabase(false, false);
+    if (!db)
+        return;
+
+    if (!db->GetConfig()._useSciAutoC)
+        return;
+
+    curPos   = static_cast<Sci_Position>(npp.GetPos());
+    startPos = static_cast<Sci_Position>(npp.GetWordStartPos(curPos));
+    endPos   = static_cast<Sci_Position>(npp.GetWordEndPos(curPos));
+    if ((curPos - startPos) > 32)
+        return;
+
+    if (_defaultCharList.find(char(ch)) == std::string::npos)
+    {
+        sciAutoCList.clear();
+        return;
+    }
+
+
+    if ((0 < sciAutoCList.length()) && (sciAutoCList.length() < SCIAUTOCLIST_LONG))
+        ShowSciAutoComplete(db->GetConfig()._SciAutoCIgnoreCase, (size_t)(curPos - startPos));
+    else
+    {
+        Sci_TextRangeFull tr;
+        tr.chrg.cpMin = startPos;
+        tr.chrg.cpMax = endPos;
+        tr.lpstrText  = tagStr;
+        ::SendMessage(npp.GetSciHandle(), SCI_GETTEXTRANGEFULL, 0, (LPARAM)&tr);
+
+        if (strlen(tagStr) < db->GetConfig()._SciAutoCFromNChar)
+            return;
+
+        std::wstring tag = s2ws(tagStr);
+
+        CmdPtr_t cmd(new Cmd(AUTOCOMPLETE_SCINTILLA, db, NULL, tag.c_str(), db->GetConfig()._SciAutoCIgnoreCase));
+
+        CmdEngine::Run(cmd, sciHalfComplCB);
+    }
+}
+
 } // namespace GTags