codecompletion.h

Go to the documentation of this file.

/*
 * This file is part of the Code::Blocks IDE and licensed under the GNU General Public License, version 3
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

#ifndef CODECOMPLETION_H
#define CODECOMPLETION_H

#include <settings.h> // SDK
#include <cbplugin.h>
#include <cbproject.h>
#include <sdk_events.h>

#include "coderefactoring.h"
#include "nativeparser.h"
#include "systemheadersthread.h"
#include "doxygen_parser.h"

#include <wx/arrstr.h>
#include <wx/listctrl.h>
#include <wx/string.h>
#include <wx/timer.h>

#include <map>
#include <vector>
#include <set>

class cbEditor;
class wxScintillaEvent;
class wxChoice;
class DocumentationHelper;

class CodeCompletion : public cbCodeCompletionPlugin
{
public:
    struct FunctionScope
    {
        FunctionScope() {}

        FunctionScope(const NameSpace& ns):
            StartLine(ns.StartLine), EndLine(ns.EndLine), Scope(ns.Name) {}

        int StartLine;      
        int EndLine;        
        wxString ShortName; 
        wxString Name;      
        wxString Scope;     
    };

    typedef std::vector<FunctionScope> FunctionsScopeVec;

    typedef std::vector<int> ScopeMarksVec;


    struct FunctionsScopePerFile
    {
        FunctionsScopeVec m_FunctionsScope; // all functions in the file
        NameSpaceVec m_NameSpaces;          // all namespaces in the file
        bool parsed;                        // indicates whether this file is parsed or not
    };
    typedef std::map<wxString, FunctionsScopePerFile> FunctionsScopeMap;

    CodeCompletion();
    virtual ~CodeCompletion();

    // the function below were virtual functions from the base class
    virtual void OnAttach();
    virtual void OnRelease(bool appShutDown);
    virtual int GetConfigurationGroup() const { return cgEditor; }

    virtual cbConfigurationPanel* GetConfigurationPanel(wxWindow* parent);
    virtual cbConfigurationPanel* GetProjectConfigurationPanel(wxWindow* parent, cbProject* project);
    virtual void BuildMenu(wxMenuBar* menuBar);
    virtual void BuildModuleMenu(const ModuleType type, wxMenu* menu, const FileTreeData* data = 0);
    virtual bool BuildToolBar(wxToolBar* toolBar);
    virtual int GetToolBarPriority() { return 10; }

    // override virtual functions in cbCodeCompletionPlugin class
    virtual CCProviderStatus GetProviderStatusFor(cbEditor* ed);
    virtual std::vector<CCToken> GetAutocompList(bool isAuto, cbEditor* ed, int& tknStart, int& tknEnd);
    virtual std::vector<CCCallTip> GetCallTips(int pos, int style, cbEditor* ed, int& argsPos);
    virtual wxString GetDocumentation(const CCToken& token);
    virtual std::vector<CCToken> GetTokenAt(int pos, cbEditor* ed, bool& allowCallTip);
    virtual wxString OnDocumentationLink(wxHtmlLinkEvent& event, bool& dismissPopup);
    virtual void DoAutocomplete(const CCToken& token, cbEditor* ed);

    wxArrayString GetLocalIncludeDirs(cbProject* project, const wxArrayString& buildTargets);

    wxArrayString& GetSystemIncludeDirs(cbProject* project, bool force);

    void GetAbsolutePath(const wxString& basePath, const wxArrayString& targets, wxArrayString& dirs);

    void EditorEventHook(cbEditor* editor, wxScintillaEvent& event);

    void RereadOptions(); // called by the configuration panel

private:
    void UpdateToolBar();

    void OnUpdateUI(wxUpdateUIEvent& event);

    void OnViewClassBrowser(wxCommandEvent& event);

    void OnGotoFunction(wxCommandEvent& event);

    void OnGotoPrevFunction(wxCommandEvent& event);

    void OnGotoNextFunction(wxCommandEvent& event);

    void OnClassMethod(wxCommandEvent& event);

    void OnUnimplementedClassMethods(wxCommandEvent& event);

    void OnGotoDeclaration(wxCommandEvent& event);

    void OnFindReferences(wxCommandEvent& event);

    void OnRenameSymbols(wxCommandEvent& event);

    void OnOpenIncludeFile(wxCommandEvent& event);

    void OnCurrentProjectReparse(wxCommandEvent& event);
    void OnSelectedProjectReparse(wxCommandEvent& event);
    void OnSelectedFileReparse(wxCommandEvent& event);

    // event handlers for the standard events sent from sdk core
    void OnAppDoneStartup(CodeBlocksEvent& event);
    void OnWorkspaceChanged(CodeBlocksEvent& event);
    void OnProjectActivated(CodeBlocksEvent& event);
    void OnProjectClosed(CodeBlocksEvent& event);
    void OnProjectSaved(CodeBlocksEvent& event);
    void OnProjectFileAdded(CodeBlocksEvent& event);
    void OnProjectFileRemoved(CodeBlocksEvent& event);
    void OnProjectFileChanged(CodeBlocksEvent& event);
    void OnEditorSave(CodeBlocksEvent& event);
    void OnEditorOpen(CodeBlocksEvent& event);
    void OnEditorActivated(CodeBlocksEvent& event);
    void OnEditorClosed(CodeBlocksEvent& event);

    void OnCCLogger(CodeBlocksThreadEvent& event);
    void OnCCDebugLogger(CodeBlocksThreadEvent& event);

    void OnParserStart(wxCommandEvent& event);

    void OnParserEnd(wxCommandEvent& event);

    void OnSystemHeadersThreadMessage(CodeBlocksThreadEvent& event);
    void OnSystemHeadersThreadFinish(CodeBlocksThreadEvent& event);

    void DoCodeComplete(int caretPos, cbEditor* ed, std::vector<CCToken>& tokens, bool preprocessorOnly = false);

    void DoCodeCompletePreprocessor(int tknStart, int tknEnd, cbEditor* ed, std::vector<CCToken>& tokens);

    void DoCodeCompleteIncludes(cbEditor* ed, int& tknStart, int tknEnd, std::vector<CCToken>& tokens);

    int DoClassMethodDeclImpl();

    int DoAllMethodsImpl();

    void MatchCodeStyle(wxString& str, int eolStyle = wxSCI_EOL_LF, const wxString& indent = wxEmptyString, bool useTabs = false, int tabSize = 4);

    // CC's toolbar related functions
    void FunctionPosition(int &scopeItem, int &functionItem) const;

    void GotoFunctionPrevNext(bool next = false);

    int NameSpacePosition() const;

    void OnScope(wxCommandEvent& event);

    void OnFunction(wxCommandEvent& event);

    void ParseFunctionsAndFillToolbar();

    void FindFunctionAndUpdate(int currentLine);

    void UpdateFunctions(unsigned int scopeItem);

    void EnableToolbarTools(bool enable = true);

    void DoParseOpenedProjectAndActiveEditor();

    void UpdateEditorSyntax(cbEditor* ed = NULL);

    void OnToolbarTimer(wxTimerEvent& event);

    void OnRealtimeParsingTimer(wxTimerEvent& event);

    void OnProjectSavedTimer(wxTimerEvent& event);

    void OnReparsingTimer(wxTimerEvent& event);

    void OnEditorActivatedTimer(wxTimerEvent& event);

    bool                    m_InitDone;

    wxMenu*                 m_EditMenu;
    wxMenu*                 m_SearchMenu;
    wxMenu*                 m_ViewMenu;
    wxMenu*                 m_ProjectMenu;

    NativeParser            m_NativeParser;

    CodeRefactoring         m_CodeRefactoring;

    int                     m_EditorHookId;

    wxTimer                 m_TimerRealtimeParsing;

    wxTimer                 m_TimerToolbar;

    /* FIXME (ollydbg#1#03/20/15): This timer is added by rev 6510, but I don't know what is the
     * exact reason to delay the reparsing by a timer
     * Note that we also save the project pointer in the m_TimerProjectSaved, so that we can
     * see which project is saved in the timer event handler, it looks like a bug here, which means
     * if two Project Saved event happens continuously, the first one will be overwritten because we
     * save the project pointer member of m_TimerProjectSaved.
     */

    wxTimer                 m_TimerProjectSaved;

    wxTimer                 m_TimerReparsing;

    wxTimer                 m_TimerEditorActivated;

    cbEditor*               m_LastEditor;

    // The variables below were related to CC's toolbar
    wxToolBar*              m_ToolBar;
    wxChoice*               m_Function;
    wxChoice*               m_Scope;

    FunctionsScopeVec       m_FunctionsScope;

    NameSpaceVec            m_NameSpaces;

    ScopeMarksVec           m_ScopeMarks;

    FunctionsScopeMap       m_AllFunctionsScopes;

    bool                    m_ToolbarNeedRefresh;

    bool                    m_ToolbarNeedReparse;

    int                     m_CurrentLine;

    wxString                m_LastFile;

    bool                    m_LexerKeywordsToInclude[9];

    bool                    m_NeedReparse;

    int                     m_CurrentLength;

    bool                    m_NeedsBatchColour;

    //options on code completion (auto suggestion list) feature

    size_t                  m_CCMaxMatches;

    bool                    m_CCAutoAddParentheses;

    bool                    m_CCDetectImplementation;

    wxString                m_CCFillupChars;

    bool                    m_CCEnableHeaders;

    bool                    m_CCEnablePlatformCheck;

    /* dir to files map, for example, there are two dirs c:/a and c:/b
     * so the map looks like: (usually the relative file path is stored)
     * c:/a  ---> {c:/a/a1.h, c:/a/a2.h} ---> {a1.h, a2.h}
     * c:/b  ---> {c:/b/b1.h, c:/b/b2.h} ---> {b1.h, b2.h}
     */
    SystemHeadersMap        m_SystemHeadersMap;

    std::list<SystemHeadersThread*> m_SystemHeadersThreads;

    wxCriticalSection               m_SystemHeadersThreadCS;

    typedef std::map<cbProject*, wxArrayString> ReparsingMap;

    ReparsingMap m_ReparsingMap;

    DocumentationHelper     m_DocHelper;

    // requires access to: m_NativeParser.GetParser().GetTokenTree()
    friend wxString DocumentationHelper::OnDocumentationLink(wxHtmlLinkEvent&, bool&);

    DECLARE_EVENT_TABLE()
};

#endif // CODECOMPLETION_H