|
#include "stdafx.h"
#include "Resource.h"
#include <Utilities/StringTokenizer.h>
#include <Utilities/Properties.h>
#include <Controller/ESBServer.h>
#include <Controller/Browsers/OutlineBrowser.h>
#include <Renderer/MFC/Browsers/OutlineBrowserRenderer.h>
#include <Renderer/MFC/Properties/OutlinePropertyPanel.h>
#include <Model/CppTagModel.h>
using namespace std;
OutlineBrowser::OutlineBrowser()
: mSelection(NULL), mESBServer(mESBServer)
{
mRenderer = smart_ptr<OutlineBrowserRenderer>(new OutlineBrowserRenderer(this));
}
OutlineBrowser::~OutlineBrowser()
{
}
std::string OutlineBrowser::makeCaption(const std::string &name)
{
size_t pos;
string caption;
if((pos = name.rfind("\\")) != string::npos) {
caption = name.substr(pos+1, string::npos);
} else {
caption = name;
}
return caption;
}
void OutlineBrowser::setModel(const FileOutlineLoader::TagList &model, const std::string &fn)
{
mModel = model;
mOutlineName = fn;
setSelection(NULL);
getRenderer().render();
getRenderer().setCaption(makeCaption(mOutlineName));
}
void OutlineBrowser::show()
{
getRenderer().render();
getRenderer().setCaption(makeCaption(getModelName()));
getRenderer().show();
}
void OutlineBrowser::moveToForeground()
{
getRenderer().moveToForeground();
}
void OutlineBrowser::setSelection(CppTag *s)
{
mSelection = s;
}
void OutlineBrowser::tagSelectionChanged(CppTag *tag, const MouseEvent &e)
{
if(tag) {
setSelection(tag);
if(e.getMouseModifiers() == 0 && e.getButton() == MouseEvent::eMiddleButton) {
getRenderer().showPopupMenu(getSelection(), e.getPoint().first, e.getPoint().second);
}
typedef std::list<smart_ptr<SelectionListener> >::iterator Iterator;
for(Iterator listener = mSelectionListeners.begin(); listener != mSelectionListeners.end(); ++listener) {
(*listener)->selectionChanged(*tag, e);
}
}
}
void OutlineBrowser::tagSelectionChanged(const std::list<CppTag*> &selection)
{
typedef std::list<smart_ptr<SelectionListener> >::iterator Iterator;
for(Iterator listener = mSelectionListeners.begin(); listener != mSelectionListeners.end(); ++listener) {
(*listener)->selectionChanged(selection);
}
}
void OutlineBrowser::sortOrderChanged(bool byName)
{
getFilter().sortByName = byName;
getRenderer().render();
}
void OutlineBrowser::publicMemberFilterChanged(bool publicOnly)
{
getFilter().publicMembersOnly = publicOnly;
getRenderer().render();
}
void OutlineBrowser::staticMemberFilterChanged(bool noStatic)
{
getFilter().noStaticMembers = noStatic;
getRenderer().render();
}
void OutlineBrowser::fieldFilterChanged(bool noFields)
{
getFilter().noFields = noFields;
getRenderer().render();
}
std::list<smart_ptr<CppTag> > OutlineBrowser::getChildrenOf(CppTag *tag)
{
return getFilter().apply(tag == NULL ? getModel() : tag->getInnerTags());
}
void OutlineBrowser::gotoHeader()
{
//gotoFile(getSelection()->getDeclaration());
}
void OutlineBrowser::gotoSource()
{
//gotoFile(getSelection()->getDefinition());
}
void OutlineBrowser::gotoHierarchy()
{
getESBServer()->showHierarchy(*dynamic_cast<Inheritable*>(getSelection()));
}
void OutlineBrowser::inspect()
{
stringstream ss;
if(getSelection()) {
ss << getSelection()->getFQN() << endl
<< getSelection()->getDeclaration().getFile() << ":" << getSelection()->getDeclaration().getLine() << endl
<< getSelection()->getDefinition().getFile() << ":" << getSelection()->getDefinition().getLine();
} else {
ss << "no tag selected !!";
}
AfxMessageBox(ss.str().c_str());
}
struct KindSorter : public std::binary_function<smart_ptr<CppTag>,smart_ptr<CppTag>,bool>
{
bool operator()(const first_argument_type &lhs, const second_argument_type &rhs)
{
CppTagType lhsType = getType(lhs);
CppTagType rhsType = getType(rhs);
if(isVariable(rhsType)) {
return false;
} else if(isFunction(rhsType)) {
return isVariable(lhsType);
} else if(isType(rhsType)) {
return !isType(lhsType);
}
return false;
}
private:
CppTagType getType(const first_argument_type &tag)
{
TagTyper typer;
tag->acceptVisitor(&typer);
return typer.getType();
}
bool isVariable(CppTagType type)
{ return type == eVariable || type == eField; }
bool isFunction(CppTagType type)
{ return type == eFunction || type == eMethod; }
bool isType(CppTagType type)
{ return !isFunction(type) && !isVariable(type); }
};
bool OutlineFilter::isFiltered(const CppTag &tag)
{
return !tag.isPublic() && publicMembersOnly;
}
bool OutlineFilter::isFiltered(const Field &field)
{
return (noFields) ||
(field.isStatic() && noStaticMembers) ||
(!field.isPublic() && publicMembersOnly);
}
bool OutlineFilter::isFiltered(const Method &method)
{
return (method.isStatic() && noStaticMembers) ||
(!method.isPublic() && publicMembersOnly);
}
std::list<smart_ptr<CppTag> > OutlineFilter::apply(const std::list<smart_ptr<CppTag> > &elements)
{
std::list<smart_ptr<CppTag> > result;
for(std::list<smart_ptr<CppTag> >::const_iterator element = elements.begin(); element != elements.end(); ++element) {
mChildrenVisible = false;
(*element)->acceptVisitor(this);
if(!isFiltered()) {
result.push_back(*element);
} else if(mChildrenVisible) {
result.splice(result.end(), apply((*element)->getInnerTags()));
}
}
std::list<smart_ptr<CppTag> > fields = selectTags(result, eField | eVariable);
std::list<smart_ptr<CppTag> > methods = selectTags(result, eMethod | eFunction);;
std::list<smart_ptr<CppTag> > types = selectTags(result, eNamespace | eClass | eStruct | eUnion | eEnum | eTypedef);
if(sortByName) {
NameSorter<CppTag> sorter;
fields.sort(sorter);
methods.sort(sorter);
types.sort(sorter);
} else {
AccessSorter<CppTag> sorter;
fields.sort(sorter);
methods.sort(sorter);
types.sort(sorter);
}
result.assign(fields.begin(), fields.end());
result.splice(result.end(), methods);
result.splice(result.end(), types);
return result;
}
std::list<smart_ptr<CppTag> > OutlineFilter::selectTags(const std::list<smart_ptr<CppTag> >& tags, size_t type) const
{
TagTyper tagTyper;
std::list<smart_ptr<CppTag> > result;
typedef std::list<smart_ptr<CppTag> > TagList;
for(TagList::const_iterator tag = tags.begin(); tag != tags.end(); tag++) {
(*tag)->acceptVisitor(&tagTyper);
if(tagTyper.getType() & type) {
result.push_back(*tag);
}
}
return result;
}
void OutlineFilter::visitTag(CppTag *tag)
{
mIsFiltered = isFiltered(*tag);
}
void OutlineFilter::visitNamespace(Namespace *nspace)
{
mIsFiltered = PropertiesManager::instance().getProperty(Browsers::Outline::SHOW_NAMESPACES, "") != "1";
mChildrenVisible = true;
}
void OutlineFilter::visitField(Field *field)
{
mIsFiltered = isFiltered(*field);
}
void OutlineFilter::visitMethod(Method *method)
{
mIsFiltered = isFiltered(*method);
}
|
By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.
If a file you wish to view isn't highlighted, and is a text file (not binary), please
let us know and we'll add colourisation support for it.
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.
A list of licenses authors might use can be found here
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.