/*
 *
 * Copyright (c) 1995
 * Knowledge Science Institute, University of Calgary
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  The Knowledge Science Institute makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

#ifdef __BCPLUSPLUS__ //---Borland C++
#include <owl\owlpch.h>
#pragma hdrstop
#endif

#include "graphic.h"
#include <stdio.h>
#include <algo.h>
#include <values.h>

#if defined(QUICKWIN)
#include <iostream.h>
#endif

#include <MLexer.h>

/******************************************************************************
************************** class GraphicContainter ****************************
******************************************************************************/

GraphicContainer::GraphicContainer()
  {
  MTRACE(GraphicContainter,GraphicContainer)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(GraphicContainer);
  NextID = 1;
  ContainerFlags = 0;
  CaptureGraphic = NULL;
  MEXIT_CODE(GraphicContainter,GraphicContainer)
  }

GraphicContainer::GraphicContainer(const GraphicContainer& c)
  {
  MTRACE(GraphicContainter,GraphicContainer)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(GraphicContainer);
  GraphicList::const_iterator i;
  NextID = 1;
  for (i = c.Graphics.begin(); i != c.Graphics.end(); i++) {
    Graphic* g = (*i)->clone();
    if (g->getParent()) g->setParent((GraphicContainer*)this);
    }
  ContainerFlags = 0;
  CaptureGraphic = NULL;
  MEXIT_CODE(GraphicContainter,GraphicContainer)
  }

GraphicContainer::~GraphicContainer()
  {
  MTRACE(GraphicContainer,~GraphicContainer);
  ContainerFlags |= destruct;

  flush();
  CaptureGraphic = NULL;
  MASSERT(Graphics.empty());

  MDESTRUCTOR_IMP_CODE_VIRTUAL(GraphicContainer);
  MTRACEOUT(GraphicContainer,~GraphicContainer);
  }

void GraphicContainer::classInvarient(char*, int) const {
  }

ostream& GraphicContainer::printOn(ostream& o) const
  {
  MENTRY_CODE(GraphicContainer,printOn)
  GraphicList::const_iterator j;

  //WARNING: this algorithm only works if Node objects and Maplet objects are
  //mutually exclusive and also cover the list!!!

  //o << NextID << endl;
  Lexer::writeUnsigned(o,NextID);
  Lexer::writeDelim(o);
  o << endl;

  for (j=Graphics.begin(); j!=Graphics.end(); j++) {
    Node* n;
    if (n=dynamic_cast<Node*>(*j)) {
      //o << typeid(*n).name() << ',' << *n << endl;
      Lexer::writeString(o,typeid(*n).name());
      Lexer::writeDelim(o);
      o << *n << endl;
      }
    }
  //o << ';' << endl;
  Lexer::writeDelim(o,';');
  o << endl;

  for (j=Graphics.begin(); j!=Graphics.end(); j++) {
    Maplet* m;
    if (m=dynamic_cast<Maplet*>(*j)) {
      //o << typeid(*m).name() << ',' << *m << endl;
      Lexer::writeString(o,typeid(*m).name());
      Lexer::writeDelim(o);
      o << *m << endl;
      }
    }
  //o << ';' << endl;
  Lexer::writeDelim(o,';');
  o << endl;

  MEXIT_CODE(GraphicContainer,printOn)
  return o;
  }

istream& GraphicContainer::readFrom(istream& i, Version*)
  {
  MENTRY_CODE(GraphicContainer,readFrom)
  GraphicsFactory* gf = GraphicsFactory::getInstance();
  MASSERT(gf);

  //i >> NextID;
  Lexer::readUnsigned(i,NextID);
  Lexer::readDelim(i);

  char c;
  Node* n;
  while (isspace(c=i.get()) && !i.eof()); //scan past any white space
  i.putback(c);
  while (i.peek()!=';') { //don't forget to force termination
    n = gf->instantiateNode(i,(GraphicContainer*)this);
    Lexer::scanPastDelim(i,'\n');
    while (isspace(c=i.get()) && !i.eof()); //scan past any white space
    i.putback(c);
    if (i.eof()) break;
    }

  if (i.peek()==';') {
    i.get();
    Maplet* m;
    while (isspace(c=i.get()) && !i.eof()); //scan past any white space
    i.putback(c);
    while (i.peek()!=';') { //don't forget to force termination
      m = gf->instantiateMaplet(i,(GraphicContainer*)this);
      Lexer::scanPastDelim(i,'\n');
      while (isspace(c=i.get()) && !i.eof()); //scan past any white space
      i.putback(c);
      if (i.eof()) break;
      }
    }

  if (i.peek()==';') {
    i.get();
    }

  MEXIT_CODE(GraphicContainer,readFrom)
  return i;
  }

void GraphicContainer::flush()
  {
  MTRACE(GraphicContainer,flush); //may be called during destructor
  CaptureGraphic = NULL;
  if (!Graphics.empty()) {
    GraphicList::iterator i;
    for (i=Graphics.begin(); i!=Graphics.end(); i++) delete *i;
    Graphics.erase(Graphics.begin(),Graphics.end());
    }
  MASSERT(Graphics.empty());
  MTRACEOUT(GraphicContainer,flush);
  }

ID_type GraphicContainer::registerGraphic(Graphic* g)
  {
  //MENTRY_CODE(GraphicContainer,registerGraphic);
  MPRECONDITION(g);
  ID_type ret = primitiveRegisterGraphic(g);
  //MEXIT_CODE(GraphicContainer,registerGraphic);
  return ret;
  }

ID_type GraphicContainer::primitiveRegisterGraphic(Graphic* g)
  {
  //MENTRY_CODE(GraphicContainer,primitiveRegisterGraphic);
  MPRECONDITION(g);
  ID_type ret;
  Graphics.push_back(g);
  if (g->id()) {
    NextID = max(NextID,g->id()+1);
    ret = g->id();
    }
  else {
    g->setID(NextID);
    ret = NextID++;
    }
  //MEXIT_CODE(GraphicContainer,primitiveRegisterGraphic);
  return ret;
  }

void GraphicContainer::unregisterGraphic(Graphic* g)
  {
  //MENTRY_CODE(GraphicContainer,unregisterGraphic);
  MPRECONDITION(g);
  if (!destructing()) {
    if (((void*)(Graphic*)g)==((void*)CaptureGraphic)) CaptureGraphic = NULL;
    Graphics.remove(g);
    }
  //MEXIT_CODE(GraphicContainer,unregisterGraphic);
  }

int GraphicContainer::popToTop(Graphic* g)
  {
  MENTRY_CODE(GraphicContainer,popToFront);
  MPRECONDITION(g);
  MASSERT(g);
  int ret = -1;
  GraphicList::const_iterator i;
  i = find(Graphics.begin(),Graphics.end(),g);
  if (i==Graphics.end()) error(0,'E',"GraphicContainer::popToFront: can't find graphic");
  else {
    Graphics.remove(g);
    Graphics.push_back(g);
    ret = 0;
    }
  MEXIT_CODE(GraphicContainer,popToFront);
  return ret;
  }

Graphic* GraphicContainer::operator[](unsigned long index)
  {
  MENTRY_CODE(GraphicContainer,operator[]);
  GraphicList::iterator i;
  for (i = Graphics.begin(); i != Graphics.end(); i++)
    if ((*i)->id() == index) {
      MEXIT_CODE(GraphicContainer,operator[]);
      return *i;
      }
  char buf[50];
  sprintf(buf,"operator[]: Index %lu not found",index);
  MEXIT_CODE(GraphicContainer_exceptionExit,operator[]);
  throw Graphic::Exception(buf);
  }

int GraphicContainer::paint(DEVICE dev,RECTANGLE* r)
  {
  MENTRY_CODE(GraphicContainer,paint)
  GraphicList::iterator i;
  for (i = Graphics.begin(); i != Graphics.end(); i++)
    (*i)->paint(dev,r);
  MEXIT_CODE(GraphicContainer,paint)
  return 0;

  }

SensitiveGraphic* GraphicContainer::getHit(POINT& p)
  {
  MENTRY_CODE(GraphicContainer,getHit)
  SensitiveGraphic *sg, *ret=NULL;
  if (CaptureGraphic) ret = CaptureGraphic;
  else {
    GraphicList::reverse_iterator i;
    for (i = Graphics.rbegin(); i != Graphics.rend(); i++) {
      if ((sg = dynamic_cast<SensitiveGraphic*>((Graphic*)*i)) && sg->contains(p)) {
	ret = sg;
	break;
	}
      }
    }
  MEXIT_CODE(GraphicContainer,getHit)
  return ret;

  }

int GraphicContainer::handleCommand(Command* c)
  {
  MENTRY_CODE(GraphicContainer,handleCommand);
  MASSERT(c);
  int ret = c->execute();
  delete c;
  MEXIT_CODE(GraphicContainer,handleCommand)
  return ret;

  }

int GraphicContainer::executeOnBehalf(Command*)
  {
  MENTRY_CODE(GraphicContainer,executeOnBehalf);
  MENTRY_CODE(GraphicContainer,executeOnBehalf);
  return -1;
  }

int GraphicContainer::undoOnBehalf(Command* c)
  {
  MENTRY_CODE(GraphicContainer,undoOnBehalf);
  int ret = -1;
  switch (c->id()) {
    case CMD_DELETE: {
      CommandPtr1<SensitiveGraphic>* rc = dynamic_cast<CommandPtr1<SensitiveGraphic>*>(c);
      if (rc && rc->getOriginalValue()) {
	SensitiveGraphic* sg = dynamic_cast<SensitiveGraphic*>(rc->getOriginalValue());
	MASSERT(sg);
	sg->resetParent((GraphicContainer*)this);
	//sg->queueForPaint(sg->getRect());
	rc->setOriginalValue(NULL); //must prevent the destruction of the command from destroying this
	queueForPaint(sg->getBoundingRect());
	}
      else error(0,'E',"GraphicContainer::undoOnBehalf: Bad DELETE command, type = %s",typeid(c).name());
      }
      break;
    default:
      ret = -1;
      break;
    }
  MENTRY_CODE(GraphicContainer,undoOnBehalf);
  return ret;
  }

void GraphicContainer::notifyChanged(ID_type id)
  {
  MENTRY_CODE(GraphicContainer,notifyChanged);
  MENTRY_CODE(GraphicContainer,notifyChanged);
  }

/******************************************************************************
************************** class GraphicObjectLocator ****************************
******************************************************************************/

GraphicObjectLocator::GraphicObjectLocator(Graphic* g)
  {
  MTRACE(GraphicObjectLocator,GraphicObjectLocator)
  MCONSTRUCTOR_IMP_CODE(GraphicObjectLocator);
  MPRECONDITION(g);
  unsigned int i=1;
  Graphic* g2=g;
  GraphicContainer* c;
  for (c=g2->getParent(); (g2=dynamic_cast<Graphic*>(c)) && g2->getParent(); c=g2->getParent()) i++;
  Path = new vector<ID_type>(i,0);
  (*Path)[0] = g->id();
  for (c=g->getParent(),i=1; (g2=dynamic_cast<Graphic*>(c)) && g2->getParent(); c=g2->getParent(),i++) {
    (*Path)[i] = g2->id();
    }
  Root = c;
  if (!Root) Root = dynamic_cast<GraphicContainer*>(g);
  MEXIT_CODE(GraphicObjectLocator,GraphicObjectLocator)
  }

GraphicObjectLocator::GraphicObjectLocator(const GraphicObjectLocator& g)
  {
  MTRACE(GraphicObjectLocator,GraphicObjectLocator)
  MCONSTRUCTOR_IMP_CODE(GraphicObjectLocator);
  Path = new vector<ID_type>(*g.Path);
  Root = g.Root;
  MEXIT_CODE(GraphicObjectLocator,GraphicObjectLocator)
  }

GraphicObjectLocator::~GraphicObjectLocator()
  {
  MENTRY_CODE(GraphicObjectLocator,~GraphicObjectLocator)
  delete Path;
  MDESTRUCTOR_IMP_CODE(GraphicObjectLocator);
  MTRACEOUT(GraphicObjectLocator,~GraphicObjectLocator)
  }

void GraphicObjectLocator::classInvarient(char* file, int line) const
  {
  MCLASSINVTEST(Root);
  MCLASSINVTEST(Path);
  }

GraphicObjectLocator& GraphicObjectLocator::operator=(const GraphicObjectLocator& g)
  {
  MENTRY_CODE(GraphicObjectLocator,operator=)
  delete Path;
  Path = new vector<ID_type>(*g.Path);
  Root = g.Root;
  MEXIT_CODE(GraphicObjectLocator,operator=)
  return *this;
  }

CommandReceiver* GraphicObjectLocator::getObject() const
  {
  MENTRY_CODE(GraphicObjectLocator,getObject)
  unsigned int i;
  SensitiveGraphic* g;
  GraphicContainer* c2 = Root;
  try {
    for (i=Path->size(); i; i--) {
      MASSERT(c2);
      g = dynamic_cast<SensitiveGraphic*>((*c2)[(*Path)[i-1]]);
      MASSERT(g);
      c2 = dynamic_cast<GraphicContainer*>(g);
      }
    }
  catch(...) {g=NULL;}
  MEXIT_CODE(GraphicObjectLocator,getObject)
  return g;
  }

CommandReceiverContainer* GraphicObjectLocator::getSuper() const
  {
  MENTRY_CODE(GraphicObjectLocator,getObject)
  unsigned int i;
  SensitiveGraphic* g;
  GraphicContainer* c2 = Root;
  try {
    for (i=Path->size(); i; i--) {
      MASSERT(c2);
      g = dynamic_cast<SensitiveGraphic*>((*c2)[(*Path)[i-1]]);
      MASSERT(g);
      c2 = dynamic_cast<GraphicContainer*>(g);
      }
    }
  catch(...) {}
  MEXIT_CODE(GraphicObjectLocator,getObject)
  return c2?c2:Root;
  }

/******************************************************************************
************************** class Graphic **************************************
******************************************************************************/

Graphic::Graphic(GraphicContainer* parent)
  {
  MTRACE(Graphic,Graphic)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(Graphic);
  Parent = parent;
  ID = 0;
  if (Parent) {
    //error(0,'D',"Parent type = %s", typeid(*Parent).name());
    ID = Parent->registerGraphic((Graphic*)this);
    }
  MEXIT_CODE(Graphic,Graphic)
  }

Graphic::Graphic(const Graphic& g, GraphicContainer* parent)
  {
  MTRACE(Graphic,Graphic)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(Graphic);
  ID = 0;
  Parent = (parent?parent:g.Parent);
  if (Parent) {
    //error(0,'D',"Parent type = %s", typeid(*Parent).name());
    ID = Parent->registerGraphic((Graphic*)this);
    }
  else ID = g.ID;
  MEXIT_CODE(Graphic,Graphic)
  }

Graphic::~Graphic()
  {
  MTRACE(Graphic,~Graphic)
  MDESTRUCTOR_IMP_CODE_VIRTUAL(Graphic);
  if (Parent && !Parent->destructing()) {
    //error(0,'D',"Parent type = %s", typeid(*Parent).name());
    Parent->unregisterGraphic((Graphic*)this);
    }
  Parent = NULL;
  MTRACEOUT(Graphic,~Graphic)
  }

void Graphic::classInvarient(char*, int) const {
  //ObjectCounter::classInvarient(file,line);
  //MCLASSINVTEST(Parent);
  }

int Graphic::operator<(const Graphic &g) const
  {
  MENTRY_CODE(Graphic,operator<)
  int ret = (getLayer() < g.getLayer());
  MEXIT_CODE(Graphic,operator<)
  return ret;
  }

int Graphic::operator==(const Graphic &g) const
  {
  MENTRY_CODE(Graphic,operator==)
  int ret = (ID == g.ID);
  MEXIT_CODE(Graphic,operator==)
  return ret;
  }

ostream& Graphic::printOn(ostream& o) const
  {
  MENTRY_CODE(Graphic,printOn)
  //o << ID;
  Lexer::writeUnsigned(o,ID);
  MEXIT_CODE(Graphic,printOn)
  return o;
  }

istream& Graphic::readFrom(istream& i, Version*)
  {
  MENTRY_CODE(Graphic,readFrom)
  //i >> ID;
  Lexer::readUnsigned(i,ID);
  MEXIT_CODE(Graphic,readFrom)
  return i;
  }

void Graphic::setParent(GraphicContainer* parent)
  {
  MTRACE(Graphic,setParent)
  if (Parent != parent) {
    if (Parent) Parent->unregisterGraphic((Graphic*)this);
    Parent = parent;
    if (Parent) {
      ID = 0;
      ID = Parent->registerGraphic((Graphic*)this);
      }
    //else ID = 0; //not here because we maintain an ID for a NULL parent (for undo lists, etc)
    }
  MTRACEOUT(Graphic,setParent)
  }

void Graphic::resetParent(GraphicContainer* parent)
  {
  MTRACE(Graphic,resetParent)
  MASSERT(!Parent);
  if (parent) {
    Parent = parent;
    ID_type newID = Parent->registerGraphic((Graphic*)this);
    MASSERT(ID==newID);
    }
  MTRACEOUT(Graphic,resetParent)
  }

void Graphic::moveTo(POINT &p)
  {
  MENTRY_CODE(Graphic,moveTo);
  RECTANGLE r = getRect();
  r.right += p.x-r.left;
  r.bottom += p.y-r.top;
  r.left = p.x;
  r.top = p.y;
  queueForPaint(); //to erase the old position
  setRect(r);
  queueForPaint(); //to draw the new position
  MEXIT_CODE(Graphic,moveTo);
  }

int Graphic::contains(POINT& p)
  {
  MENTRY_CODE(Graphic,contains);
  int ret;
  RECTANGLE r = getRect();
  ret = (p.x >= r.left) && (p.x <= r.right) && (p.y >= r.top) && (p.y <= r.bottom);
  MEXIT_CODE(Graphic,contains);
  return ret;
  }

int Graphic::intersects(RECTANGLE& r)
  {
  MENTRY_CODE(Graphic,intersects);
  int ret;
  RECTANGLE s = getRect();
  ret = !((r.right<s.left)||(r.left>s.right)||(r.bottom<s.top)||(r.top>s.bottom));
  MEXIT_CODE(Graphic,intersects);
  return ret;
  }

void Graphic::queueForPaint(void)
  {
  MENTRY_CODE(Graphic,queueForPaint);
  if (getParent()) getParent()->queueForPaint(getBoundingRect());
  MEXIT_CODE(Graphic,queueForPaint);
  }

RECTANGLE Graphic::getBoundingRect() const
  {
  MENTRY_CODE(Graphic,getBoundingRect);
  RECTANGLE r = getRect();
  r.left   -= 3;
  r.top    -= 3;
  r.right  += 3;
  r.bottom += 3;
  MEXIT_CODE(Graphic,getBoundingRect);
  return r;
  }

/******************************************************************************
************************** class VisualGraphic **************************************
******************************************************************************/

VisualGraphic::VisualGraphic(GraphicContainer* parent) : Graphic(parent)
  {
  MTRACE(VisualGraphic,VisualGraphic)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(VisualGraphic);
  MEXIT_CODE(VisualGraphic,VisualGraphic)
  }

VisualGraphic::VisualGraphic(const VisualGraphic& g, GraphicContainer* parent)
	: Graphic(g,parent)
  {
  MTRACE(VisualGraphic,VisualGraphic)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(VisualGraphic);
  MEXIT_CODE(VisualGraphic,VisualGraphic)
  }

VisualGraphic::~VisualGraphic()
  {
  MTRACE(VisualGraphic,~VisualGraphic)
  MDESTRUCTOR_IMP_CODE_VIRTUAL(VisualGraphic);
  MTRACEOUT(VisualGraphic,~VisualGraphic)
  }

void VisualGraphic::classInvarient(char* file, int line) const {
  Graphic::classInvarient(file,line);
  }

ostream& VisualGraphic::printOn(ostream& o) const
  {
  MENTRY_CODE(VisualGraphic,printOn)
  Graphic::printOn(o);
  //o << ',' << Layer;
  Lexer::writeDelim(o);
  Lexer::writeLong(o,Layer);
  MEXIT_CODE(VisualGraphic,printOn)
  return o;
  }

istream& VisualGraphic::readFrom(istream& i, Version* version)
  {
  MENTRY_CODE(VisualGraphic,readFrom)
  Graphic::readFrom(i,version);
  //i.ignore(MAXINT,',');
  Lexer::readDelim(i);
  //i >> Layer;
  long l;
  if (!Lexer::readLong(i,l)) Layer = l;
  MEXIT_CODE(VisualGraphic,readFrom)
  return i;
  }

/******************************************************************************
************************** class BehaviouralGraphic ***************************
******************************************************************************/

BehaviouralGraphic::BehaviouralGraphic(GraphicContainer* parent, char* visualClassName) : Graphic(parent)
  {
  MTRACE(BehaviouralGraphic,BehaviouralGraphic)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(BehaviouralGraphic);
  Visual = NULL;
  VisualClassName = strdup(visualClassName);
  MEXIT_CODE(BehaviouralGraphic,BehaviouralGraphic)
  }

BehaviouralGraphic::BehaviouralGraphic(const BehaviouralGraphic& g, GraphicContainer* parent)
	: Graphic(g,parent), GraphicContainer(g)
  {
  MTRACE(BehaviouralGraphic,BehaviouralGraphic)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(BehaviouralGraphic);

  //nned to set Visual to the corresponding element of the list in the container
  Visual = dynamic_cast<VisualGraphic*>(Graphics.front());
  VisualClassName = strdup(g.VisualClassName);

  MEXIT_CODE(BehaviouralGraphic,BehaviouralGraphic)
  }

BehaviouralGraphic::~BehaviouralGraphic()
  {
  MTRACE(BehaviouralGraphic,~BehaviouralGraphic)
  MDESTRUCTOR_IMP_CODE_VIRTUAL(BehaviouralGraphic);
  //delete Visual; //this not needed because Visual is deleted by virtue of
		   //being contained by the GraphicContainter ancestor
  Visual = NULL;
  delete VisualClassName;
  MTRACEOUT(BehaviouralGraphic,~BehaviouralGraphic)
  }

void BehaviouralGraphic::classInvarient(char* file, int line) const
  {
  Graphic::classInvarient(file,line);
  MCLASSINVTEST(Visual || VisualClassName);
  MCLASSINVTEST((!Visual) || (Visual->getParent()==(BehaviouralGraphic*)this));
  }

ostream& BehaviouralGraphic::printOn(ostream& o) const
  {
  MENTRY_CODE(BehaviouralGraphic,printOn)
  Graphic::printOn(o);
  //o << ',' << VisualClassName;
  Lexer::writeDelim(o);
  Lexer::writeQuotedString(o,VisualClassName);
  MEXIT_CODE(BehaviouralGraphic,printOn)
  return o;
  }

istream& BehaviouralGraphic::readFrom(istream& i, Version* version)
  {
  MENTRY_CODE(BehaviouralGraphic,readFrom)
  Graphic::readFrom(i,version);
  //i.ignore(MAXINT,',');
  //i >> VisualClassName;
  Lexer::readDelim(i);
  string str;
  if (!Lexer::readQuotedString(i,str)) {
    if (VisualClassName) delete VisualClassName;
    VisualClassName = strdup(str.c_str());
    }
  MEXIT_CODE(BehaviouralGraphic,readFrom)
  return i;
  }

int BehaviouralGraphic::paint(DEVICE d,RECTANGLE* r)
  {
  MENTRY_CODE(BehaviouralGraphic,paint)
  int ret = getVisual()->paint(d,r);
  MEXIT_CODE(BehaviouralGraphic,paint)
  return ret;
  }

void BehaviouralGraphic::unregisterGraphic(Graphic* g)
  {
  MENTRY_CODE(BehaviouralGraphic,unregisterGraphic)
  GraphicContainer::unregisterGraphic(g);
  if (g==Visual) Visual = NULL;
  MEXIT_CODE(BehaviouralGraphic,unregisterGraphic)
  }

void BehaviouralGraphic::queueForPaint(RECTANGLE& r)
  {
  MENTRY_CODE(BehaviouralGraphic,queueForPaint);
  if (getParent()) getParent()->queueForPaint(r);
  MEXIT_CODE(BehaviouralGraphic,queueForPaint);
  }

int BehaviouralGraphic::dispatch(Command* command)
  {
  MENTRY_CODE(BehaviouralGraphic,dispatch);
  int ret = -245;
  if (command) {
    switch (command->id()) {
      case CMD_MOVETO: { //throw away any spurious MOVETOs
	Command1<POINT>* pc = dynamic_cast<Command1<POINT>*>(command);
	if (pc) {
	  if ((abs(pc->getOriginalValue().x-pc->getValue().x)<3) && (abs(pc->getOriginalValue().y-pc->getValue().y)<3)) {
	    delete command;
	    command = NULL;
	    }
	  }
	else error(0,'E',"SensitiveGraphic::dispatch: Bad MOVE TO command, type = %s",typeid(command).name());
	}
	break;
      default:
	break;
      }
    }

  CommandHandler* ch;
  if (command) {
    if (getParent())
      ret = getParent()->handleCommand(command);
    else if (ch=dynamic_cast<CommandHandler*>((BehaviouralGraphic*)this))
      ret = ch->handleCommand(command);
    else {
      ret = execute(command);
      delete command;
      }
    }
  MTRACEOUT(BehaviouralGraphic,dispatch); //may have deleted this object
  return ret;
  }

/******************************************************************************
************************** class GraphicFactory *******************************
******************************************************************************/

GraphicsFactory* GraphicsFactory::Instance = NULL;

GraphicsFactory::GraphicsFactory()
  {
  MTRACE(GraphicsFactory,GraphicsFactory)
  MCONSTRUCTOR_IMP_CODE(GraphicsFactory);
  registerShape("default",RectangleShape());
  registerLine("default",Line());
  registerConnector("default",Connector());
  MEXIT_CODE(GraphicsFactory,GraphicsFactory)
  }

GraphicsFactory::GraphicsFactory(GraphicsFactory&)
  {
  MTRACE(GraphicsFactory,GraphicsFactory)
  MCONSTRUCTOR_IMP_CODE(GraphicsFactory);
  MEXIT_CODE(GraphicsFactory,GraphicsFactory)
  }

GraphicsFactory::~GraphicsFactory()
  {
  MTRACE(GraphicsFactory,~GraphicsFactory)
  MDESTRUCTOR_IMP_CODE(GraphicsFactory);
  MTRACEOUT(GraphicsFactory,~GraphicsFactory)
  }

void GraphicsFactory::classInvarient(char*, int) const {
  }

Node* GraphicsFactory::instantiateNode(istream& i, GraphicContainer* parent)
  {
  MENTRY_CODE(Node,instantiateNode);
  Node* ret = NULL;

  string type;
  if (!Lexer::readString(i,type)) {
    Lexer::readDelim(i);
    if (type=="Node") ret = new Node(parent);
    if (ret) {
      ret->readFrom(i);
      }
    }

  MEXIT_CODE(Node,instantiateNode);
  return ret;
  }

Maplet* GraphicsFactory::instantiateMaplet(istream& i, GraphicContainer* parent)
  {
  MENTRY_CODE(Node,instantiateMaplet);
  Maplet* ret = NULL;

  string type;
  if (!Lexer::readString(i,type)) {
    Lexer::readDelim(i);
    if		(type=="Maplet")	ret = new Maplet(parent);
    else if	(type=="SMaplet")	ret = new SMaplet(parent);
    if (ret) {
      ret->readFrom(i);
      }
    }

  MEXIT_CODE(Node,instantiateMaplet);
  return ret;
  }

list<string>* GraphicsFactory::makeShapeNameList()
  {
  MENTRY_CODE(Node,makeShapeNameList);
  list<string>* ret = new list<string>;
  GraphicsLibrary<Shape>::iterator i;
  for (i=ShapeLibrary.begin(); i!=ShapeLibrary.end(); i++) {
    ret->push_front((*i).first);
    }
  MEXIT_CODE(Node,makeShapeNameList);
  return ret;
  }

list<string>* GraphicsFactory::makeLineNameList()
  {
  MENTRY_CODE(Node,makeLineNameList);
  list<string>* ret = new list<string>;
  GraphicsLibrary<Line>::iterator i;
  for (i=LineLibrary.begin(); i!=LineLibrary.end(); i++) {
    ret->push_front((*i).first);
    }
  MEXIT_CODE(Node,makeLineNameList);
  return ret;
  }

list<string>* GraphicsFactory::makeConnectorNameList()
  {
  MENTRY_CODE(Node,makeConnectorNameList);
  list<string>* ret = new list<string>;
  GraphicsLibrary<Connector>::iterator i;
  for (i=ConnectorLibrary.begin(); i!=ConnectorLibrary.end(); i++) {
    ret->push_front((*i).first);
    }
  MEXIT_CODE(Node,makeConnectorNameList);
  return ret;
  }

/******************************************************************************
************************** class XXX ******************************************
******************************************************************************/
/*
XXX::XXX(GraphicContainer* parent) : Graphic(parent)
  {
  MTRACE(XXX,XXX)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(XXX);
  MEXIT_CODE(XXX,XXX)
  }

XXX::XXX(const XXX& g) : Graphic(parent,id)
  {
  MTRACE(XXX,XXX)
  MCONSTRUCTOR_IMP_CODE_VIRTUAL(XXX);
  MEXIT_CODE(XXX,XXX)
  }

XXX::~XXX()
  {
  MTRACE(XXX,~XXX)
  MDESTRUCTOR_IMP_CODE_VIRTUAL(XXX);
  MTRACEOUT(XXX,~XXX)
  }

void XXX::classInvarient(char* file, int line) const {
  Graphic::classInvarient(file,line);
  }
*/