Be Sweet - a set of visual source code browsers

/**
/*   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);
}