AddFunctionsImpDlg::AddFunctionsImpDlg(wxWindow* parent, const TagEntryPtrVector_t &tags, const wxString &targetFile)
: AddFunctionsImplBaseDlg(parent)
{
unsigned int colCount = m_dataviewModel->GetColCount();
m_dataviewModel = new MyAddFunctionsModel();
m_dataviewModel->SetColCount( colCount );
m_dataview->AssociateModel( m_dataviewModel.get() );
m_tags.insert(m_tags.end(), tags.begin(), tags.end());
for(size_t i=0; i<m_tags.size(); ++i) {
wxVector<wxVariant> cols;
cols.push_back(true);
cols.push_back( m_tags.at(i)->GetDisplayName() );
// keep the implementation as the client data
wxString body;
TagEntryPtr tag = m_tags.at(i);
tag->SetSignature( TagsManagerST::Get()->NormalizeFunctionSig( tag->GetSignature(), Normalize_Func_Name ) );
body << TagsManagerST::Get()->FormatFunction(tag, FunctionFormat_Impl);
body << wxT("\n");
m_dataviewModel->AppendItem( wxDataViewItem(0), cols, new wxStringClientData(body) );
}
m_filePicker->SetPath( targetFile );
WindowAttrManager::Load(this, "AddFunctionsImpDlg", NULL);
}
void TestClassDlg::DoRefreshFunctions(bool repportError)
{
std::vector<TagEntryPtr> matches;
// search m_tags for suitable name
for(size_t i = 0; i < m_tags.size(); i++) {
TagEntryPtr tag = m_tags.at(i);
if(tag->GetName() == m_textCtrlClassName->GetValue()) {
matches.push_back(tag);
}
}
if(matches.empty()) {
if(repportError) {
wxMessageBox(_("Could not find match for class '") + m_textCtrlClassName->GetValue() + wxT("'"),
_("CodeLite"),
wxICON_WARNING | wxOK);
}
return;
}
wxString theClass;
if(matches.size() == 1) {
// single match we are good
theClass = matches.at(0)->GetPath();
} else {
// suggest the user a multiple choice
wxArrayString choices;
for(size_t i = 0; i < matches.size(); i++) {
wxString option;
TagEntryPtr t = matches.at(i);
choices.Add(t->GetPath());
}
theClass = wxGetSingleChoice(_("Select class:"), _("Select class:"), choices, this);
}
if(theClass.empty()) { // user clicked 'Cancel'
return;
}
// get list of methods for the given path
matches.clear();
m_manager->GetTagsManager()->TagsByScope(theClass, wxT("prototype"), matches, false, true);
// populate the list control
wxArrayString methods;
for(size_t i = 0; i < matches.size(); i++) {
TagEntryPtr t = matches.at(i);
methods.Add(t->GetName() + t->GetSignature());
}
m_checkListMethods->Clear();
m_checkListMethods->Append(methods);
// check all items
for(unsigned int idx = 0; idx < m_checkListMethods->GetCount(); idx++) {
m_checkListMethods->Check(idx, true);
}
}
void OpenResourceDialog::DoPopulateTags()
{
bool gotExactMatch(false);
// Next, add the tags
TagEntryPtrVector_t tags;
if(m_userFilters.IsEmpty()) return;
m_manager->GetTagsManager()->GetTagsByPartialName(m_userFilters.Item(0), tags);
for(size_t i = 0; i < tags.size(); i++) {
TagEntryPtr tag = tags.at(i);
// Filter out non relevanting entries
if(!m_filters.IsEmpty() && m_filters.Index(tag->GetKind()) == wxNOT_FOUND) continue;
if(!MatchesFilter(tag->GetName())) continue;
wxString name(tag->GetName());
// keep the fullpath
wxDataViewItem item;
wxString fullname;
if(tag->GetKind() == wxT("function") || tag->GetKind() == wxT("prototype")) {
fullname = wxString::Format(
wxT("%s::%s%s"), tag->GetScope().c_str(), tag->GetName().c_str(), tag->GetSignature().c_str());
item = DoAppendLine(tag->GetName(),
fullname,
(tag->GetKind() == wxT("function")),
new OpenResourceDialogItemData(
tag->GetFile(), tag->GetLine(), tag->GetPattern(), tag->GetName(), tag->GetScope()),
DoGetTagImg(tag));
} else {
fullname = wxString::Format(wxT("%s::%s"), tag->GetScope().c_str(), tag->GetName().c_str());
item = DoAppendLine(tag->GetName(),
fullname,
false,
new OpenResourceDialogItemData(
tag->GetFile(), tag->GetLine(), tag->GetPattern(), tag->GetName(), tag->GetScope()),
DoGetTagImg(tag));
}
if((m_userFilters.GetCount() == 1) && (m_userFilters.Item(0).CmpNoCase(name) == 0) && !gotExactMatch) {
gotExactMatch = true;
DoSelectItem(item);
}
}
}
TagEntryPtr RefactoringEngine::SyncSignature(const wxFileName& fn,
int line,
int pos,
const wxString &word,
const wxString &text,
const wxString &expr)
{
TagEntryPtr func = TagsManagerST::Get()->FunctionFromFileLine(fn, line);
if(!func)
return NULL;
bool bIsImpl = (func->GetKind() == wxT("function"));
// Found the counterpart
std::vector<TagEntryPtr> tags;
TagsManagerST::Get()->FindImplDecl(fn, line, expr, word, text, tags, !bIsImpl);
if(tags.size() != 1)
return NULL;
TagEntryPtr tag = tags.at(0);
if(tag->IsMethod() == false)
return NULL;
wxString signature;
if (bIsImpl) {
// The "source" is an implementaion, which means that we need to prepare declaration signature
// this could be tricky since we might lose the "default" values
signature = TagsManagerST::Get()->NormalizeFunctionSig(func->GetSignature(), Normalize_Func_Default_value|Normalize_Func_Name|Normalize_Func_Reverse_Macro);
} else {
// Prepare an "implementation" signature
signature = TagsManagerST::Get()->NormalizeFunctionSig(func->GetSignature(), Normalize_Func_Name|Normalize_Func_Reverse_Macro);
}
tag->SetSignature(signature);
return tag;
}
void OpenResourceDialog::DoPopulateTags()
{
if (m_tags.empty())
return;
bool gotExactMatch(false);
wxArrayString tmpArr;
wxString curSel = m_textCtrlResourceName->GetValue();
wxString curSelNoStar;
if (!curSel.Trim().Trim(false).IsEmpty()) {
curSel = curSel.MakeLower().Trim().Trim(false);
curSelNoStar = curSel.c_str();
for (size_t i=0; i<m_tags.size(); i++) {
TagEntryPtr tag = m_tags.at(i);
wxString name(tag->GetName());
name.MakeLower();
//append wildcard at the end
if (!curSel.EndsWith(wxT("*"))) {
curSel << wxT("*");
}
// FR# [2008133]
if (m_checkBoxUsePartialMatching->IsChecked() && !curSel.StartsWith(wxT("*"))) {
curSel.Prepend(wxT("*"));
}
if (wxMatchWild(curSel, name)) {
// keep the fullpath
int index(0);
if(tag->GetKind() == wxT("function") || tag->GetKind() == wxT("prototype"))
index = DoAppendLine(tag->GetName(),
tag->GetSignature(),
tag->GetScope(),
tag->GetKind() == wxT("function"),
new OpenResourceDialogItemData(tag->GetFile(), tag->GetLine(), tag->GetPattern(), m_type, tag->GetName(), tag->GetScope()));
else
index = DoAppendLine(tag->GetName(),
tag->GetScope(),
wxT(""),
false,
new OpenResourceDialogItemData(tag->GetFile(), tag->GetLine(), tag->GetPattern(), m_type, tag->GetName(), tag->GetScope()));
if (curSelNoStar == name && !gotExactMatch) {
gotExactMatch = true;
DoSelectItem(index);
}
}
}
}
if (m_listOptions->GetItemCount() == 150) {
m_staticTextErrorMessage->SetLabel(wxT("Too many matches, please narrow down your search"));
}
if (!gotExactMatch && m_listOptions->GetItemCount()) {
DoSelectItem(0);
}
}
CxxTemplateFunction::CxxTemplateFunction(TagEntryPtr tag)
{
m_scanner = ::LexerNew(tag->GetPatternClean(), kLexerOpt_None);
m_sigScanner = ::LexerNew(tag->GetSignature(), kLexerOpt_None);
}
void clCallTip::Initialize(const std::vector<TagEntryPtr> &tips)
{
std::map<wxString, tagCallTipInfo> mymap;
for (size_t i=0; i< tips.size(); i++) {
tagCallTipInfo cti;
TagEntryPtr t = tips.at(i);
if ( t->IsMethod() ) {
wxString raw_sig ( t->GetSignature().Trim().Trim(false) );
// evaluate the return value of the tag
cti.retValue = TagsManagerST::Get()->GetFunctionReturnValueFromPattern(t);
bool hasDefaultValues = (raw_sig.Find(wxT("=")) != wxNOT_FOUND);
// the key for unique entries is the function prototype without the variables names and
// any default values
wxString key = TagsManagerST::Get()->NormalizeFunctionSig(raw_sig, Normalize_Func_Reverse_Macro);
// the signature that we want to keep is one with name & default values, so try and get the maximum out of the
// function signature
wxString full_signature = TagsManagerST::Get()->NormalizeFunctionSig(raw_sig, Normalize_Func_Name | Normalize_Func_Default_value | Normalize_Func_Reverse_Macro, &cti.paramLen);
cti.sig = full_signature;
if (hasDefaultValues) {
// incase default values exist in this prototype,
// update/insert this signature
mymap[key] = cti;
}
// make sure we dont add duplicates
if ( mymap.find(key) == mymap.end() ) {
// add it
mymap[key] = cti;
}
} else {
// macro
wxString macroName = t->GetName();
wxString pattern = t->GetPattern();
int where = pattern.Find(macroName);
if (where != wxNOT_FOUND) {
//remove the #define <name> from the pattern
pattern = pattern.Mid(where + macroName.Length());
pattern = pattern.Trim().Trim(false);
if (pattern.StartsWith(wxT("("))) {
//this macro has the form of a function
pattern = pattern.BeforeFirst(wxT(')'));
pattern.Append(wxT(')'));
cti.sig = pattern.Trim().Trim(false);
mymap[cti.sig] = cti;
}
}
}
}
std::map<wxString, tagCallTipInfo>::iterator iter = mymap.begin();
m_tips.clear();
for (; iter != mymap.end(); iter++) {
wxString tip;
if ( iter->second.retValue.empty() == false ) {
tip << iter->second.retValue.Trim(false).Trim() << wxT(" : ");
}
tip << iter->second.sig;
clTipInfo ti;
ti.paramLen = iter->second.paramLen;
ti.str = tip;
m_tips.push_back(ti);
}
}
