|
/**
/* Copyright (c) 2003by Marco Welti
/*
/* This document is bound by the QT Public License
/* (http://www.trolltech.com/licenses/qpl.html).
/* See License.txt for more information.
/*
/*
/*
/* ALL RIGHTS RESERVED.
/*
/* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
/* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
/* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
/* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
/* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
/* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
/* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
/* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/*
/***********************************************************************/
#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/MetaModel/MetaModel.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(MetaObject *s)
{
mSelection = s;
}
void OutlineBrowser::tagSelectionChanged(MetaObject *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<MetaObject*> &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<MetaObject> > OutlineBrowser::getChildrenOf(MetaObject *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 !!";
}
message_box(ss.str());
}
struct KindSorter : public std::binary_function<smart_ptr<MetaObject>,smart_ptr<MetaObject>,bool>
{
bool operator()(const first_argument_type &lhs, const second_argument_type &rhs)
{
MetaObjectType lhsType = getType(lhs);
MetaObjectType 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:
MetaObjectType getType(const first_argument_type &tag)
{
MetaObjectTyper typer;
tag->acceptVisitor(&typer);
return typer.getType();
}
bool isVariable(MetaObjectType type)
{ return type == eVariable || type == eField; }
bool isFunction(MetaObjectType type)
{ return type == eFunction || type == eMethod; }
bool isType(MetaObjectType type)
{ return !isFunction(type) && !isVariable(type); }
};
bool OutlineFilter::isFiltered(const MetaObject &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<MetaObject> > OutlineFilter::apply(const std::list<smart_ptr<MetaObject> > &elements)
{
std::list<smart_ptr<MetaObject> > result;
for(std::list<smart_ptr<MetaObject> >::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<MetaObject> > fields = selectTags(result, eField | eVariable);
std::list<smart_ptr<MetaObject> > methods = selectTags(result, eMethod | eFunction);;
std::list<smart_ptr<MetaObject> > types = selectTags(result, eNamespace | eClass | eStruct | eUnion | eEnum | eTypedef);
if(sortByName) {
NameSorter<MetaObject> sorter;
fields.sort(sorter);
methods.sort(sorter);
types.sort(sorter);
} else {
AccessSorter<MetaObject> 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<MetaObject> > OutlineFilter::selectTags(const std::list<smart_ptr<MetaObject> >& tags, size_t type) const
{
MetaObjectTyper tagTyper;
std::list<smart_ptr<MetaObject> > result;
typedef std::list<smart_ptr<MetaObject> > 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(MetaObject *tag)
{
mIsFiltered = isFiltered(*tag);
}
namespace Browsers { namespace Outline { extern const std::string SHOW_NAMESPACES; } }
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.