Registering a custom CodeInsight manager - What am I doing wrong? - c++

Question

This is a subsequent question to my fist one, asking how to register a custom CodeInsight manager to the IDE with C++Builder.
I switched my code to Remy Lebeau's version with the #pragma startup and #pragma exitdirectives.
What now happens when I try to use it (see my code below) is this:
With CodeGuard set to active:
I hit F9 -> Project compiles well (except for [TLIB Warning] Warning: library was too large for page size, rebuilt with page size 32)
A second instance of bds.exe starts (because i set it as the host app)
In the 2nd instance I try to install my package wich results in the following error:
I deactivate CodeGuard in the project debugging settings and try it again and now it seems to work, as I can see a sequence of MessageBoxes:
TMyCodeInsightSymbolList::TMyCodeInsightSymbolList
TMyCodeInsightManager::TMyCodeInsightManager
TMyCodeInsightManager::GetIDString
TMyCodeInsightManager::GetIDString
TMyCodeInsightManager::GetIDString
TMyCodeInsightManager::GetIDString
TMyCodeInsightManager::GetIDString
Now I create a new VCL Forms Application in the debugging instance and enter
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
this->|
}
in TForm1's constructor.
The resulting MessageBoxes:
TMyCodeInsightManager::HandlesFile
TMyCodeInsightManager::GetEnabled
TMyCodeInsightManager::AllowCodeInsight
TMyCodeInsightManager::EditorTokenValidChars
TMyCodeInsightManager::PreValidateCodeInsight
TMyCodeInsightManager::EditorTokenValidChars
TMyCodeInsightManager::InvokeCodeCompletion
TMyCodeInsightManager::GetSymbolList
TMyCodeInsightSymbolList::GetCount
TMyCodeInsightSymbolList::~TMyCodeInsightSymbolList
TMyCodeInsightManager::GetSymbolList
Error:
It drives me crazy...so what the heck am I doing wrong here?
{...}
Furthermore, in the IDE setting in the 2nd instance at Editor Options -> CodeInsight I see my new entry in the ComboBox Source file type but when I select it, there's an out of range error, so I think the IDE is missing some registry entries for my completion manager or stuff. Am I right?
Now, here's my code:
my_completion.cpp
#pragma hdrstop
#pragma package(smart_init)
#include "my_codeinsight_manager.h"
static int FCodeManagerIndex = -1;
void DoRegister()
{
_di_IOTACodeInsightServices CIS;
if (BorlandIDEServices->Supports(CIS))
FCodeManagerIndex = CIS->AddCodeInsightManager(new TMyCodeInsightManager);
}
#pragma startup DoRegister
void DoUnregister()
{
_di_IOTACodeInsightServices CIS;
if ((FCodeManagerIndex != -1) && BorlandIDEServices->Supports(CIS))
CIS->RemoveCodeInsightManager(FCodeManagerIndex);
}
#pragma exit DoUnregister
#pragma argsused
extern "C" int _libmain(unsigned long reason)
{
return 1;
}
my_codeinsight_manager.h
#ifndef my_codeinsight_managerH
#define my_codeinsight_managerH
//---------------------------------------------------------------------------
#include <memory>
#include <System.SysUtils.hpp>
#include <ToolsAPI.hpp>
#include "my_codeinsight_symbollist.h"
//---------------------------------------------------------------------------
class TMyCodeInsightManager : public TCppInterfacedObject<IOTANotifier, IOTACodeInsightManager>
{
public:
TMyCodeInsightManager();
virtual __fastcall ~TMyCodeInsightManager();
String __fastcall GetName();
String __fastcall GetIDString();
bool __fastcall GetEnabled();
void __fastcall SetEnabled(bool AValue) ;
TSysCharSet __fastcall EditorTokenValidChars(bool APreValidating);
void __fastcall AllowCodeInsight(bool& Allow, const WideChar AKey);
bool __fastcall PreValidateCodeInsight(const String AStr);
bool __fastcall IsViewerBrowsable(int AIndex);
bool __fastcall GetMultiSelect();
void __fastcall GetSymbolList(_di_IOTACodeInsightSymbolList& ASymbolList);
void __fastcall OnEditorKey(WideChar AKey, bool& ACloseViewer, bool& AAccept);
bool __fastcall HandlesFile(const String AFileName);
String __fastcall GetLongestItem();
void __fastcall GetParameterList(_di_IOTACodeInsightParameterList& AParameterList);
void __fastcall GetCodeInsightType(WideChar AChar, int AElement, TOTACodeInsightType& ACodeInsightType, TOTAInvokeType& AInvokeType);
bool __fastcall InvokeCodeCompletion(TOTAInvokeType AHowInvoked, String& AStr);
bool __fastcall InvokeParameterCodeInsight(TOTAInvokeType AHowInvoked, int& ASelectedIndex);
void __fastcall ParameterCodeInsightAnchorPos(TOTAEditPos& AEdPos);
int __fastcall ParameterCodeInsightParamIndex(const TOTAEditPos& AEdPos);
String __fastcall GetHintText(int AHintLine, int AHintCol);
String __fastcall GetOptionSetName();
bool __fastcall GotoDefinition(String& AFileName, int& ALineNum, int AIndex=0xFFFFFFFF);
void __fastcall Done(bool AAccepted, bool& ADisplayParams);
__property String Name = {read=GetName};
__property bool MultiSelect = {read=GetMultiSelect};
__property bool Enabled = {read=GetEnabled, write=SetEnabled};
/* IOTANotifier */
void __fastcall AfterSave() {}
void __fastcall BeforeSave() {}
void __fastcall Destroyed() {}
void __fastcall Modified() {}
private:
std::unique_ptr<TMyCodeInsightSymbolList> FSymbolList;
TSysCharSet FSysCharSet;
};
my_codeinsight_manager.cpp
#include <vcl.h>
#pragma hdrstop
#include "my_codeinsight_manager.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
TMyCodeInsightManager::TMyCodeInsightManager()
: FSymbolList(std::unique_ptr<TMyCodeInsightSymbolList>(new TMyCodeInsightSymbolList))
{
FSysCharSet = TSysCharSet() << 'A' << 'B' << 'C' << 'D' << 'E' << 'F' << 'G' << 'H' << 'I' << 'J' << 'K'
<< 'L' << 'M' << 'N' << 'O' << 'P' << 'Q' << 'R' << 'S' << 'T' << 'U' << 'V' << 'W'
<< 'X' << 'Y' << 'Z'
<< 'a' << 'b' << 'c' << 'd' << 'e' << 'f' << 'g' << 'h' << 'i' << 'j' << 'k' << 'l'
<< 'm' << 'n' << 'o' << 'p' << 'q' << 'r' << 's' << 't' << 'u' << 'v' << 'w' << 'x'
<< 'y' << 'z'
<< '0' << '1' << '2' << '3' << '4' << '5' << '6' << '7' << '8' << '9'
<< '+' << '-' << '*' << '/' << '^' << '\\' << '(' << ')' << '[' << ']' << '{' << '}'
<< '=' << '!' << '<' << '>' << '\'' << '\"' << '$' << ',' << ';' << ':' << '5' << '!'
<< '&' << '?' << '_' << '#' << '#'
<< 0x08 << 0x09 << 0x0B << 0x0C << 0x0D;
ShowMessage(L"TMyCodeInsightManager::TMyCodeInsightManager");
}
//---------------------------------------------------------------------------
__fastcall TMyCodeInsightManager::~TMyCodeInsightManager()
{
ShowMessage(L"TMyCodeInsightManager::~TMyCodeInsightManager");
}
//---------------------------------------------------------------------------
String __fastcall TMyCodeInsightManager::GetName()
{
ShowMessage(L"TMyCodeInsightManager::GetName");
return L"MyCodeInsightLanguage";
}
//----------------------------------------------------------------------------
String __fastcall TMyCodeInsightManager::GetIDString()
{
ShowMessage(L"TMyCodeInsightManager::GetIDString");
return L"My.CodeInsight";
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::GetEnabled()
{
ShowMessage(L"TMyCodeInsightManager::GetEnabled");
return true;
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::SetEnabled(bool AValue)
{
ShowMessage(L"TMyCodeInsightManager::SetEnabled");
}
//----------------------------------------------------------------------------
TSysCharSet __fastcall TMyCodeInsightManager::EditorTokenValidChars(bool APreValidating)
{
ShowMessage(L"TMyCodeInsightManager::EditorTokenValidChars");
return FSysCharSet;
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::AllowCodeInsight(bool& AAllow, const WideChar AKey)
{
ShowMessage(L"TMyCodeInsightManager::AllowCodeInsight");
AAllow = true;
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::PreValidateCodeInsight(const String AStr)
{
ShowMessage(L"TMyCodeInsightManager::PreValidateCodeInsight");
return true;
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::IsViewerBrowsable(int AIndex)
{
ShowMessage(L"TMyCodeInsightManager::IsViewerBrowsable");
return true; // # TO DO #
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::GetMultiSelect()
{
ShowMessage(L"TMyCodeInsightManager::GetMultiSelect");
return false;
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::GetSymbolList(_di_IOTACodeInsightSymbolList& ASymbolList)
{
ASymbolList = FSymbolList.get();
ShowMessage(L"TMyCodeInsightManager::GetSymbolList");
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::OnEditorKey(WideChar AKey, bool& ACloseViewer, bool& AAccept)
{
ACloseViewer = true;
AAccept = false;
ShowMessage(L"TMyCodeInsightManager::OnEditorKey");
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::HandlesFile(const String AFileName)
{
ShowMessage(L"TMyCodeInsightManager::HandlesFile");
String FileExt = ExtractFileExt(AFileName);
if ( (FileExt == L".c")
|| (FileExt == L".cpp")
|| (FileExt == L".h")
|| (FileExt == L".hpp")
|| (FileExt == L".cc")
|| (FileExt == L".cp")
|| (FileExt == L".cxx") )
{
return true;
}
else
{
return false;
}
}
//----------------------------------------------------------------------------
String __fastcall TMyCodeInsightManager::GetLongestItem()
{
ShowMessage(L"TMyCodeInsightManager::GetLongestItem");
return String(L"dddddddddddddddddddddd");
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::GetParameterList(_di_IOTACodeInsightParameterList& AParameterList)
{
AParameterList = NULL;
ShowMessage(L"TMyCodeInsightManager::GetParameterList");
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::GetCodeInsightType(WideChar AChar, int AElement, TOTACodeInsightType& ACodeInsightType, TOTAInvokeType& AInvokeType)
{
AInvokeType = itManual;
if ( (AElement != atString) && (AChar != 0x0001) && (AElement == atComment) )
{
switch (AChar)
{
case 0x0000:
ACodeInsightType = citCodeInsight;
break;
case 0x0001:
ACodeInsightType = citParameterCodeInsight;
break;
case 0x0002:
ACodeInsightType = citBrowseCodeInsight;
break;
case 0x0003:
ACodeInsightType = citHintCodeInsight;
break;
case L'.':
ACodeInsightType = citCodeInsight;
AInvokeType = itTimer;
break;
case L'(':
ACodeInsightType = citParameterCodeInsight;
AInvokeType = itTimer;
break;
default:
ACodeInsightType = citNone;
}
}
ShowMessage(L"TMyCodeInsightManager::GetCodeInsightType");
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::InvokeCodeCompletion(TOTAInvokeType AHowInvoked, String& AStr)
{
switch (AHowInvoked)
{
case itAuto:
break;
case itManual:
break;
case itTimer:
break;
}
AStr = L"IAmASymbolText";
return true;
}
//----------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::InvokeParameterCodeInsight(TOTAInvokeType AHowInvoked, int& ASelectedIndex)
{
switch (AHowInvoked)
{
case itAuto:
break;
case itManual:
break;
case itTimer:
break;
}
ShowMessage(L"TMyCodeInsightManager::OnvokeParameterCodeInsight");
return true; // # TO DO #
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::ParameterCodeInsightAnchorPos(TOTAEditPos& AEdPos)
{
ShowMessage(L"TMyCodeInsightManager::ParameterCodeInsightAnchorPos");
}
//----------------------------------------------------------------------------
int __fastcall TMyCodeInsightManager::ParameterCodeInsightParamIndex(const TOTAEditPos& AEdPos)
{
ShowMessage(L"TMyCodeInsightManager::ParameterCodeInsightParamIndex");
return 0;
}
//----------------------------------------------------------------------------
String __fastcall TMyCodeInsightManager::GetHintText(int AHintLine, int AHintCol)
{
ShowMessage(L"TMyCodeInsightManager::GetHintText");
return L"NoHint";
}
//----------------------------------------------------------------------------
String __fastcall TMyCodeInsightManager::GetOptionSetName()
{
ShowMessage(L"TMyCodeInsightManager::GetOptionSetName");
return L"MyCodeInsight";
}
//---------------------------------------------------------------------------
bool __fastcall TMyCodeInsightManager::GotoDefinition(String &AFileName, int& ALineNum, int AIndex)
{
ShowMessage(L"TMyCodeInsightManager::GotoDefinition");
return true;
}
//----------------------------------------------------------------------------
void __fastcall TMyCodeInsightManager::Done(bool AAccepted, bool& ADisplayParams)
{
ShowMessage(L"TMyCodeInsightManager::Done");
}
//----------------------------------------------------------------------------
my_codeinsight_symbollist.h
#ifndef my_codeinsight_symbollistH
#define my_codeinsight_symbollistH
//---------------------------------------------------------------------------
#include <vector>
#include <algorithm>
#include <System.SysUtils.hpp>
#include <ToolsAPI.hpp>
//---------------------------------------------------------------------------
class TMySymbolList
{
public:
TMySymbolList(const String AText=L"", const String AType=L"", const String AClass=L"", const bool AIsReadWrite=false, const bool AIsAbstract=false, const TOTAViewerSymbolFlags AFlag=vsfUnknown, const TOTAViewerVisibilityFlags AVisibilityFlag=vvfPrivate, TOTAProcDispatchFlags AProcDispatchFlag=pdfNone)
: FText(AText),
FType(AType),
FClass(AClass),
FFlag(AFlag),
FVisibilityFlag(AVisibilityFlag),
FProcDispatchFlag(AProcDispatchFlag)
{}
__property String Text = {read=FText, write=FText}; // i.e. 'Form1'
__property String Type = {read=FType, write=FType}; // i.e. 'TForm1'
__property String Class = {read=FClass, write=FClass}; // i.e. 'var', 'function', 'type', etc.
__property bool IsReadWrite = {read=FIsReadWrite, write=FIsReadWrite};
__property bool IsAbstract = {read=FIsAbstract, write=FIsAbstract};
__property TOTAViewerSymbolFlags Flag = {read=FFlag, write=FFlag};
__property TOTAViewerVisibilityFlags VisibilityFlag = {read=FVisibilityFlag, write=FVisibilityFlag};
__property TOTAProcDispatchFlags ProcDispatchFlag = {read=FProcDispatchFlag, write=FProcDispatchFlag};
private:
String FText;
String FType;
String FClass;
bool FIsReadWrite;
bool FIsAbstract;
TOTAViewerSymbolFlags FFlag;
TOTAViewerVisibilityFlags FVisibilityFlag;
TOTAProcDispatchFlags FProcDispatchFlag;
};
//---------------------------------------------------------------------------
class TMyCodeInsightSymbolList : public TCppInterfacedObject<IOTACodeInsightSymbolList>
{
public:
TMyCodeInsightSymbolList();
virtual __fastcall ~TMyCodeInsightSymbolList();
void __fastcall Clear(void);
int __fastcall GetCount(void);
bool __fastcall GetSymbolIsReadWrite(int AIndex);
bool __fastcall GetSymbolIsAbstract(int AIndex);
TOTAViewerSymbolFlags __fastcall GetViewerSymbolFlags(int AIndex);
int __fastcall GetViewerVisibilityFlags(int AIndex);
TOTAProcDispatchFlags __fastcall GetProcDispatchFlags(int AIndex);
void __fastcall SetSortOrder(const TOTASortOrder AValue);
TOTASortOrder __fastcall GetSortOrder(void);
int __fastcall FindIdent(const String AIdent);
bool __fastcall FindSymIndex(const String AIdent, int& AIndex);
void __fastcall SetFilter(const String AFilterText);
String __fastcall GetSymbolText(int AIndex);
String __fastcall GetSymbolTypeText(int AIndex);
String __fastcall GetSymbolClassText(int AIndex);
__property String SymbolClassText[int Index] = {read=GetSymbolClassText};
__property String SymbolTypeText[int Index] = {read=GetSymbolTypeText};
__property String SymbolText[int Index] = {read=GetSymbolText};
__property TOTAViewerSymbolFlags SymbolFlags[int i] = {read=GetViewerSymbolFlags};
__property int SymbolVisibility[int Index] = {read=GetViewerVisibilityFlags};
__property bool SymbolIsAbstract[int Index] = {read=GetSymbolIsAbstract};
__property bool SymbolIsReadWrite[int Index] = {read=GetSymbolIsReadWrite};
__property TOTAProcDispatchFlags FuncDispatchFlags[int Index] = {read=GetProcDispatchFlags};
__property TOTASortOrder SortOrder = {read=GetSortOrder, write=SetSortOrder};
__property int Count = {read=GetCount};
private:
static bool SymbolTextCompare(const TMySymbolList& AX, const TMySymbolList& AY);
std::vector<TMySymbolList> FSymbols;
TOTASortOrder FSortOrder;
};
//---------------------------------------------------------------------------
#endif
my_codeinsight_symbollist.cpp
#include <vcl.h>
#pragma hdrstop
#include "my_codeinsight_symbollist.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
// Constructor
TMyCodeInsightSymbolList::TMyCodeInsightSymbolList()
: FSortOrder(soAlpha)
{
TMySymbol S;
S.Text = L"IAmASymbolText";
S.Type = L"IAmASymbolType";
S.Class = L"IAmASymbolClass";
S.Flag = vsfFunction;
S.VisibilityFlag = vvfPublic;
FSymbols.push_back(S);
FSymbols.push_back(S);
FSymbols.push_back(S);
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::TMyCodeInsightSymbolList");
#endif
}
//---------------------------------------------------------------------------
// Destructor
__fastcall TMyCodeInsightSymbolList::~TMyCodeInsightSymbolList()
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::~TMyCodeInsightSymbolList");
#endif
}
//---------------------------------------------------------------------------
// Implementor should clear its symbol list
void __fastcall TMyCodeInsightSymbolList::Clear(void)
{
FSymbols.clear();
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::Clear");
#endif
}
//----------------------------------------------------------------------------
// Returns the count of the symbols in the list - may be modified by setting a filter
int __fastcall TMyCodeInsightSymbolList::GetCount(void)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetCount");
#endif
return static_cast<int>(FSymbols.size());
}
//----------------------------------------------------------------------------
// Returns whether the symbol is able to be read from and written to
bool __fastcall TMyCodeInsightSymbolList::GetSymbolIsReadWrite(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetSymbolIsReadWrite");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].IsReadWrite;
else
return false;
}
//----------------------------------------------------------------------------
// Returns whether the symbols is abstract. Viewer draws these in the 'need to implement' color
bool __fastcall TMyCodeInsightSymbolList::GetSymbolIsAbstract(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetSymbolIsAbstract");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].IsAbstract;
else
return false;
}
//----------------------------------------------------------------------------
// Return the symbol flags for the item at index 'AIndex'. AIndex is the index in the filtered list
TOTAViewerSymbolFlags __fastcall TMyCodeInsightSymbolList::GetViewerSymbolFlags(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetViewerSymbolFlags");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].Flag;
else
return vsfUnknown;
}
//----------------------------------------------------------------------------
// Return the visibility flags for the item at index 'AIndex'. AIndex is the index in the filtered list
int __fastcall TMyCodeInsightSymbolList::GetViewerVisibilityFlags(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetViewerVisibilityFlags");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].VisibilityFlag;
else
return vvfPrivate; // # TO DO #
}
//----------------------------------------------------------------------------
// Return the procedure flags for the item at index 'AIndex'. AIndex is the index in the filtered list
TOTAProcDispatchFlags __fastcall TMyCodeInsightSymbolList::GetProcDispatchFlags(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetProcDispatchFlags");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].ProcDispatchFlag;
else
return pdfNone;
}
//----------------------------------------------------------------------------
// The list was requested to be sorted by 'AValue'
void __fastcall TMyCodeInsightSymbolList::SetSortOrder(const TOTASortOrder AValue)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::SetSortOrder");
#endif
FSortOrder = AValue;
// Sort order is alphabetically
if (FSortOrder == soAlpha)
{
// Sort Symbol vector alphabetically
std::sort(FSymbols.begin(), FSymbols.end(), SymbolTextCompare);
}
// Sort order is by scope
else if (FSortOrder == soScope)
{
// Sort Symbol vector by scope
// # TO DO #
}
}
//----------------------------------------------------------------------------
// Returns the sort order of the list
TOTASortOrder __fastcall TMyCodeInsightSymbolList::GetSortOrder(void)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetSortOrder");
#endif
return FSortOrder;
}
//----------------------------------------------------------------------------
// Given an identifier, return the index of the closest partial match
int __fastcall TMyCodeInsightSymbolList::FindIdent(const String AIdent)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::FindIdent");
#endif
return 0; // # TO DO # We're not searching at the moment
}
//----------------------------------------------------------------------------
// Given an identifier, find the 'Index' of an exact match in the list and return true. Otherwise return false
bool __fastcall TMyCodeInsightSymbolList::FindSymIndex(const String AIdent, int& AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::FindSymIndex");
#endif
return false; // # TO DO # We aren't matching at the moment
}
//----------------------------------------------------------------------------
// Set the lists filter to 'FilterText'. It is up to the implementor to determine how to filter or if they even want to filter
void __fastcall TMyCodeInsightSymbolList::SetFilter(const String AFilterText)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::SetFilter");
#endif
// # TO DO # : We don't filter at the moment
}
//----------------------------------------------------------------------------
// Return the symbol text for item 'AIndex'. i.e. Form1
String __fastcall TMyCodeInsightSymbolList::GetSymbolText(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetSymbolText");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].Text;
else
return L"";
}
//----------------------------------------------------------------------------
// Return the symbol type text for item 'AIndex'. i.e. TForm1
String __fastcall TMyCodeInsightSymbolList::GetSymbolTypeText(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetSymbolTypeText");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].Type;
else
return L"";
}
//----------------------------------------------------------------------------
// Return the symbol class text for item 'AIndex'. i.e. 'var', 'function', 'type', etc
String __fastcall TMyCodeInsightSymbolList::GetSymbolClassText(int AIndex)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::GetSymbolClassText");
#endif
if (AIndex < static_cast<int>(FSymbols.size()))
return FSymbols[AIndex].Class;
else
return L"";
}
//----------------------------------------------------------------------------
// Returns true, if AX.Text's position is alphabetically before AY.Text's
bool TMyCodeInsightSymbolList::SymbolTextCompare(const TMySymbol& AX, const TMySymbol& AY)
{
#ifdef _DEBUG
ShowMessage(L"TMyCodeInsightSymbolList::SymbolTextCompare");
#endif
return (AnsiCompareStr(AX.Text, AY.Text) == -1);
}
//---------------------------------------------------------------------------