#ifndef OBJ_STORE_H
#define OBJ_STORE_H

#include <iostream.h>
#include <string.h>
#include "xcddraw.h"

class GraphicsObjectList;
class ObjectStore;
class VertexObject;
class EdgeObject;
class EdgeLabelObject;
class ParameterEdge;
class ParameterAssignmentStore;
class ParameterAssignment;
class TemplateInstStore;
class ClassNameObject;

struct order_t;

typedef struct args_t {
    Widget w;
    struct order_t *order;
    int i;  /* old possition */
    int j;  /* new position */
} args_t;

typedef struct order_t {
   args_t *args;
   int cur_i;
   int len;
} order_t;


typedef struct setargs_struct {
  ParameterAssignmentStore* store;
  int *changed;
} setargs_struct;

class Comments {
 private:
  char *comments;

 public:
  Comments() { comments = NULL; }
  ~Comments() { if (comments) free(comments); }

  char *get_comments() { return comments; }
  void set_comments(char *nv) { comments = nv; }
  char *rset_comments(char *nv) { char *t = comments; comments = nv; return t; }
};

class GraphicsObject {

 private:
  int max_x;
  int max_y;
  int min_x;
  int min_y;

  draw_kind  kind;

  selectflag_t selected_flag;

  long id;

 public:
  GraphicsObject( ) 
      { max_x = max_y = min_x = min_y = 0; selected_flag = NOT_SELECTED;
      }
  virtual ~GraphicsObject() {  }

  long get_id() { return id; }
  void set_id(long v) { id = v; }

  selectflag_t get_selected_flag()       { return selected_flag; }
  void set_selected_flag(selectflag_t nv) { selected_flag = nv; }

  draw_kind get_kind() { return kind; }
  void      set_kind(draw_kind nk) { kind = nk; }

  int get_max_x() { return max_x; }
  int get_max_y() { return max_y; }
  int get_min_x() { return min_x; }
  int get_min_y() { return min_y; }

  void set_max_x(int nx) { max_x = nx; }
  void set_max_y(int ny) { max_y = ny; }
  void set_min_x(int nx) { min_x = nx; }
  void set_min_y(int ny) { min_y = ny; }

  int rset_max_x(int nx) { int t = max_x;
					 max_x = nx;
				         return t; }
  int rset_max_y(int ny) { int t = max_y;
					 max_y = ny;
				         return t; }
  int rset_min_x(int nx) { int t = min_x;
					 min_x = nx;
				         return t; }
  int rset_min_y(int ny) { int t = min_y;
					 min_y = ny;
				         return t; }

  virtual void xor_draw() = 0;
  virtual void draw() = 0;
  virtual void drawRelated() = 0;
  virtual void set_xy(int,int) = 0;
  virtual void get_xy(int&,int&) = 0;
  virtual void set_name(char *,int,int) = 0;

  virtual void draw_select();
  virtual void drawSelected(selectflag_t selectedflag) = 0;
  virtual void unSelect() {  this->drawSelected(this->get_selected_flag());
                             selected_flag = NOT_SELECTED; }

  virtual void select_box(
       int &,int &,int ,int ,VertexObject*&) = 0;

  virtual void add_parassign_to_inst(ParameterEdge *npe) { }

  virtual void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag) = 0;
  virtual void append_parassign(ParameterEdge *npe);
  virtual int vertexInUse();

  virtual void no_duplicate_target(int &ret,draw_kind k,char *n);
  virtual void no_duplicate_edge(int &ret,char *n);
  virtual void doubleClickPopup() = 0;
  virtual int has_rep_edge() { return 0; }
  virtual void disableFields(ParameterAssignmentStore *tstore)
    { assert( this->get_kind() == PAR_INST_EDGE ); }
  virtual void propagateChanges(ParameterAssignmentStore *tstore)
    { assert( this->get_kind() == PAR_INST_EDGE ); }
  virtual void reorder_args();
  virtual void assign_parts(Widget f,int i);
  virtual void notIntroConflict(char *n,int &r) { }
  virtual void addBreakPoint(int,int);
  virtual void deleteObject(int &);
  virtual void deleteAssignments(GraphicsObject* obj);
  virtual void helpPopupMenu(XEvent* e,int x,int y);
  virtual void printCons(FILE *fp);
  virtual void printAlt(FILE *fp,int&);
  virtual void printAltEdge(FILE *fp,int&);
  virtual void printRep(FILE *fp,int &hasRep);
  virtual void printRepEdge(FILE *fp,int &hasRep);
  virtual void move_vertex_name(int, int) { }
  virtual void move_vertex(int, int) { }
  virtual void move_edge_name(int , int) { }
  virtual void moveStartPoint(int dx,int dy);
  virtual void moveEndPoint(int dx,int dy);

  virtual void move_start_point(int x,int y);
  virtual void move_end_point(int x,int y);
  virtual void move_inner_point(int x,int y);
  virtual void draw_last_seg();
  virtual void draw_first_seg();
  virtual void printPrimaryVertex(FILE *fp);
  virtual void printSVertex(FILE *fp);
  virtual void printIVertex(FILE *fp);
  virtual void printNameInsenVertices(FILE*);
  virtual void printConsEdges(FILE*fp);
  virtual void printAIRIEdges(FILE *fp);
  virtual void fillinPE(ParameterEdge *e);
  virtual void freeStore();
  virtual void printInheritExt(FILE *fp);
  virtual void printEachInheritExt(FILE *fp);
};

class GraphicsObjectList {

 private:

     GraphicsObject       *elm;
     GraphicsObjectList  *prev;
     GraphicsObjectList   *next;

   public:
     GraphicsObjectList() { elm = NULL; prev = next = NULL; }
     ~GraphicsObjectList() { if (next) delete next; }



     GraphicsObject *get_elm()        { return elm; }
     GraphicsObjectList  *get_prev()  { return prev; }
     GraphicsObjectList  *get_next()  { return next; }
     
     void set_elm(GraphicsObject *nf)       { elm = nf; }
     void set_prev(GraphicsObjectList *nr)  { prev  = nr; }
     void set_next(GraphicsObjectList *nr)  { next  = nr; }
     
     GraphicsObject *rset_elm(GraphicsObject *nf)
                   { GraphicsObject * t = elm;
                     elm = nf;
                     return t; }
     GraphicsObjectList *rset_prev(GraphicsObjectList  *nr)
                  { GraphicsObjectList *t = prev;
                    prev  = nr;
                    return t; }

     GraphicsObjectList *rset_next(GraphicsObjectList *nr)
                  { GraphicsObjectList  *t = next;
                    next  = nr;
                    return t; }


     void append(GraphicsObject *);
     void draw();

     void select_box(int &,int &,int ,int ,VertexObject*&);

     int vertexInUse();

     void add_parassign_to_inst(ParameterEdge *npe);
     void clicked_obj(GraphicsObject *&ret,
               int clicked_x,int clicked_y,selectflag_t selectflag);
     void append_parassign(ParameterEdge *npe);
     void deleteGO(GraphicsObject *go);
     void no_duplicate_target(int &ret,draw_kind k,char *n);
     void no_duplicate_edge(int &ret,char *n);
     int  has_rep_edge();
     void disableFields(ParameterAssignmentStore *tstore);
     void propagateChanges(ParameterAssignmentStore *tstore);
     void reorder_args();
     void assign_parts(Widget f,int i);
     void length(int &l) { l++; if (next) next->length(l); }
     void reorder_parts(GraphicsObjectList **tbl,int i);
     void notIntroConflict(char *n,int &r);
     void deleteElm(GraphicsObject*);
     void deleteAssignments(GraphicsObject* obj);
     void printCons(FILE *fp);
     void printAlt(FILE *fp,int&);
     void printAltEdge(FILE *fp,int&);
     void printRep(FILE *fp,int &hasRep);
     void printRepEdge(FILE *fp,int &hasRep);
     void moveStartPoint(int dx,int dy);
     void moveEndPoint(int dx,int dy);
     void draw_last_seg();
     void draw_first_seg();
     void printSVertices(FILE *fp);
     void printIVertices(FILE *fp);
     void printNameInsenVertices(FILE*);
     void printConsEdges(FILE*fp);
     void printAIRIEdges(FILE *fp);
     void getEndVertex(long tid,VertexObject *&rv);
     void fillinPE(ParameterEdge *e);
     void freeStore();
     void printInheritExt(FILE *fp);
     void printEachInheritExt(FILE *fp);
};

class ObjectStore {

  private:
     int max_x;
     int max_y;
     int min_x;
     int min_y;

     GraphicsObjectList *objects;

   public:

     ObjectStore() { objects = NULL;
                     max_x = max_y = min_x = min_y = 0;
                   }
     ~ObjectStore() { }

     int get_max_x() { return max_x; }
     int get_max_y() { return max_y; }
     int get_min_x() { return min_x; }
     int get_min_y() { return min_y; }

     void set_max_x(int nx) { max_x = nx; }
     void set_max_y(int ny) { max_y = ny; }
     void set_min_x(int nx) { min_x = nx; }
     void set_min_y(int ny) { min_y = ny; }

     int rset_max_x(int nx) { int t = max_x;max_x = nx;return t; }
     int rset_max_y(int ny) { int t = max_y;max_y = ny;return t; }
     int rset_min_x(int nx) { int t = min_x;min_x = nx;return t; }
     int rset_min_y(int ny) { int t = min_y;min_y = ny;return t; }

     GraphicsObjectList *get_objects() { return objects; }
     void set_objects(GraphicsObjectList *nv) { objects = nv; }
     void draw();
     void append(GraphicsObject *);
     void append_edge(EdgeObject *);
     void select_box(int &,int &,int ,int ,VertexObject*&);
     int empty() { return objects == NULL; }

     int vertexInUse();
     int length() { int l = 0; if (objects) objects->length(l); return l; }
     void add_parassign_to_inst(ParameterEdge *npe);

     void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
     void append_parassign(ParameterEdge *npe);
     void deleteGO(GraphicsObject *);
     void no_duplicate_target(int &ret,draw_kind k,char *n);
     void no_duplicate_edge(int &ret,char *n);
     int has_rep_edge();
     void disableFields(ParameterAssignmentStore *tstore);
     void propagateChanges(ParameterAssignmentStore *tstore);
     void reorder_args();
     void assign_parts(Widget f);
     void reorder_parts();
     int notIntroConflict(char *n);
     void deleteElm(GraphicsObject*);
     void deleteAssignments(GraphicsObject* obj);
     void printCons(FILE *fp);
     void printAlt(FILE *fp,int&);
     void printAltEdge(FILE *fp,int&);
     void printRep(FILE *fp,int &hasRep);
     void printRepEdge(FILE *fp,int &hasRep);
     void moveStartPoint(int dx,int dy);
     void moveEndPoint(int dx,int dy);
     void draw_last_seg();
     void draw_first_seg();
     void printCPEdges(FILE *fp);
     void printAIRIEdges(FILE *fp);
     void printSVertices(FILE *fp);  /* print secondary vertices */
     void printIVertices(FILE *fp);  /* print instance vertices */
     void printNameInsenVertices(FILE*);
     void printConsEdges(FILE*fp);
     VertexObject *getEndVertex(long tid,token_kind tk);
     void fillinPE(ParameterEdge *e);
     void freeStore();
     void printInheritExt(FILE *fp);
     void printEachInheritExt(FILE *fp);
};

class TemplateInstStore {
 private:
  ObjectStore *instances;
 public:
  TemplateInstStore()  { instances = new ObjectStore(); }
  ~TemplateInstStore() { if (instances) delete instances; }

  ObjectStore *get_instances() { return instances; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void append_parassign(ParameterEdge *npe);
  void reorder_args();
  void remove(VertexObject *obj);
  void printIVertices(FILE *fp);
  VertexObject* getEndVertex(long tid,token_kind tk);
  void fillinPE(ParameterEdge *e);
  void freeStore();
};


class NameSensitiveVertex {
 private:
   ClassNameObject *vertex_name;  /* control all  the instance */
   VertexObject *primary;
   ObjectStore  *vertices;
   TemplateInstStore   *tempinststore;

   char *before;
   char *after;
   Comments *comments;

   ObjectStore *outgoing_consedge_store;
   ObjectStore *outgoing_paredge_store;
 public:
   NameSensitiveVertex();

   ~NameSensitiveVertex();

  Comments *get_comments() { return comments; }

  ObjectStore *get_outgoing_consedge_store()
              { return outgoing_consedge_store; }

  ObjectStore *get_outgoing_paredge_store()
              { return outgoing_paredge_store; }

  void set_outgoing_consedge_store(ObjectStore *ns)
              { outgoing_consedge_store = ns; }

  void set_outgoing_paredge_store(ObjectStore *ns)
              { outgoing_paredge_store = ns; }

  char *get_before() { return before; }
  char *get_after()  { return after; }


  void set_before(char *nv)   { before = nv; }
  void set_after(char *nv)    { after = nv; }

  char *rset_before(char *nv)   { char *t = before;  before = nv; return t; }
  char *rset_after(char *nv)    { char *t = after;    after = nv; return t; }


  TemplateInstStore        *get_tempinststore() { return tempinststore; }

   ClassNameObject  *get_vertex_name() { return vertex_name; }
   VertexObject     *get_primary()     { return primary;     }
   ObjectStore      *get_vertices()    { return vertices;    }

   void set_vertex_name(ClassNameObject *nn)      { vertex_name = nn; }
   void set_primary(VertexObject *nv)  { primary     = nv; }
   void set_vertices(ObjectStore  *nv) { vertices    = nv; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void append_parassign(ParameterEdge *npe);
  void select_box(int &,int &,int ,int ,VertexObject*&);
  int vertexInUse();
  void no_duplicate_target(int &,draw_kind,char *);
  int has_rep_edge();
  void reorder_args();
  void assign_classes(Widget f,int i);
  void IsNotUsedLocalName(char *n, draw_kind k,int &r);
  void remove(VertexObject *obj);
  void genCd(FILE *fp);
  void printVertices(FILE *fp);
  void printCPEdges(FILE *fp);
  void getEndVertex(long tid,token_kind tk,VertexObject*&);
  void fillinPE(ParameterEdge *e);
  void freeStore();
};

class NameSensitiveVertexList {
 private:
   NameSensitiveVertex     *elm;
   NameSensitiveVertexList *prev;
   NameSensitiveVertexList *next;
 public:

   ~NameSensitiveVertexList() {
       if (elm) delete elm;
       if (next) delete next;
   }

   NameSensitiveVertexList() {
       elm = NULL; prev = next = NULL;
   }

   NameSensitiveVertex     *get_elm()  { return elm; }
   NameSensitiveVertexList *get_prev() { return prev; }
   NameSensitiveVertexList *get_next() { return next; }

   void set_elm(NameSensitiveVertex *nv)      { elm  = nv; }
   void set_prev(NameSensitiveVertexList *nv) { prev = nv; }
   void set_next(NameSensitiveVertexList *nv) { next = nv; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void append(NameSensitiveVertex *nv);
  int length() { int l = 1;  if (next) next->length(l); return l; }
  void length(int &l) {  l++;  if (next) next->length(l); }
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void assign_classes(Widget f,int i);
  void reorder_classes(NameSensitiveVertexList **tbl,int i);
  void IsNotUsedLocalName(char *n, draw_kind k,int &r);
  void remove(VertexObject *obj);
  void genCd(FILE *fp);
  void deleteElm(NameSensitiveVertex *obj);
  void printVertices(FILE *fp);
  void printCPEdges(FILE *fp);
  void getEndVertex(long tid,token_kind tk,VertexObject*&);
  void freeStore();
};

class NameSensitiveVertexStore {
 private:
   NameSensitiveVertexList *vertices;
 public:
   NameSensitiveVertexStore()  { vertices = NULL; }
   ~NameSensitiveVertexStore() { if (vertices) delete vertices; }

   NameSensitiveVertexList *get_vertices() { return vertices; }
   void set_vertices(NameSensitiveVertexList *nv) { vertices = nv; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void append(NameSensitiveVertex *nv);
  int length() { if (vertices) return vertices->length(); else return 0; }
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void assign_classes(Widget f);
  void reorder_classes();
  void IsNotUsedLocalName(char *n, draw_kind k,int &r);
  void remove(VertexObject *);
  void deleteElm(NameSensitiveVertex *);
  void genCd(FILE *fp);
  void printVertices(FILE *fp);
  void printCPEdges(FILE *fp);
  VertexObject * getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class NameInsensitiveVertexStore {
 private:
  ObjectStore *vertices;
 public:
  NameInsensitiveVertexStore()  { vertices = new ObjectStore(); }
  ~NameInsensitiveVertexStore() { delete vertices; }

  ObjectStore *get_vertices() { return vertices; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void remove_from_unbound(VertexObject *v);
  void printVertices(FILE *fp);
  void printNameInsenVertices(FILE*);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class ConstructionVertexStore {
 private:
  NameSensitiveVertexStore *tempstore;
 public:
  ConstructionVertexStore()
    { tempstore = new NameSensitiveVertexStore();
    }

  ~ConstructionVertexStore()
    { delete tempstore;
    }

  NameSensitiveVertexStore *get_tempstore()     { return tempstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void IsNotUsedLocalName(char *n, draw_kind k,int &r);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class AlternationVertexStore {
 private:
  NameSensitiveVertexStore *tempstore;
 public:
  AlternationVertexStore()
    { tempstore = new NameSensitiveVertexStore();
    }
  ~AlternationVertexStore()
    { delete tempstore;
    }

  NameSensitiveVertexStore *get_tempstore()     { return tempstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void IsNotUsedLocalName(char *n, draw_kind k,int &r);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class RepetitionVertexStore {
 private:
  NameSensitiveVertexStore *tempstore;
 public:
  RepetitionVertexStore()
    { tempstore = new NameSensitiveVertexStore();
    }

  ~RepetitionVertexStore()
    { delete tempstore;
    }

  NameSensitiveVertexStore *get_tempstore()     { return tempstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void IsNotUsedLocalName(char *n, draw_kind k,int &r);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class UnboundVertexStore {
 private:
  NameInsensitiveVertexStore *vstore;
 public:
  UnboundVertexStore()
    { vstore = new NameInsensitiveVertexStore(); }

  ~UnboundVertexStore()
    { delete vstore; }

  NameInsensitiveVertexStore *get_vstore()     { return vstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void remove_from_unbound(VertexObject *v);
  void printVertices(FILE *fp);
  void freeStore();
};

class TerminalVertexStore {
 private:
  NameInsensitiveVertexStore *vstore;
 public:
  TerminalVertexStore()
    { vstore = new NameInsensitiveVertexStore(); }

  ~TerminalVertexStore()
    { delete vstore; }

  NameInsensitiveVertexStore *get_vstore()     { return vstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void printVertices(FILE *fp);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class ParameterVertexStore {
 private:
   NameInsensitiveVertexStore *vstore;
 public:
   ParameterVertexStore()
     { vstore = new NameInsensitiveVertexStore(); }

   ~ParameterVertexStore()
     { delete vstore; }

   NameInsensitiveVertexStore *get_vstore() { return vstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void printVertices(FILE *fp);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class ExternalVertexStore {
 private:
  NameSensitiveVertexStore *tempstore;
 public:
  ExternalVertexStore()
    { tempstore = new NameSensitiveVertexStore();
    }
  ~ExternalVertexStore()
    { delete tempstore;
    }

  NameSensitiveVertexStore *get_tempstore()     { return tempstore; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *nv);
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void IsNotUsedExtName(char *n, draw_kind k,int);
  void printVertices(FILE *fp);
  void printCPEdges(FILE *fp);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class VertexStore {
   private:

      NameSensitiveVertexStore *localvertices;

      ConstructionVertexStore *consvstore;
      AlternationVertexStore  *altvstore;
      RepetitionVertexStore   *repvstore;
      TerminalVertexStore     *termvstore;
      ParameterVertexStore    *paravstore;
      ExternalVertexStore     *extvstore;
      UnboundVertexStore      *ubvstore;

      int max_x;
      int max_y;
      int min_x;
      int min_y;

    public:

      VertexStore() {   localvertices = new NameSensitiveVertexStore();
                        consvstore = new ConstructionVertexStore();
                        altvstore  = new AlternationVertexStore;
                        repvstore  = new RepetitionVertexStore;
                        termvstore = new TerminalVertexStore;
                        paravstore = new ParameterVertexStore;
                        extvstore  = new ExternalVertexStore;
                        ubvstore   = new UnboundVertexStore;
                        max_x = min_x = max_y = min_y = 0;
                    }
      ~VertexStore() { delete localvertices;
		       delete consvstore;
                       delete altvstore;
                       delete repvstore;
                       delete termvstore;
                       delete paravstore;
                       delete extvstore;
                       delete ubvstore;
                     }


  int get_max_x() { return max_x; }
  int get_max_y() { return max_y; }
  int get_min_x() { return min_x; }
  int get_min_y() { return min_y; }

  void set_max_x(int nx) { max_x = nx; }
  void set_max_y(int ny) { max_y = ny; }
  void set_min_x(int nx) { min_x = nx; }
  void set_min_y(int ny) { min_y = ny; }

  int rset_max_x(int nx) { int t = max_x;
					 max_x = nx;
				         return t; }
  int rset_max_y(int ny) { int t = max_y;
					 max_y = ny;
				         return t; }
  int rset_min_x(int nx) { int t = min_x;
					 min_x = nx;
				         return t; }
  int rset_min_y(int ny) { int t = min_y;
					 min_y = ny;
				         return t; }

      NameSensitiveVertexStore *get_localvertices() { return localvertices; }

      ConstructionVertexStore *get_consvstore() { return consvstore; }
      AlternationVertexStore  *get_altvstore()  { return altvstore; }
      RepetitionVertexStore   *get_repvstore()  { return repvstore; }
      TerminalVertexStore     *get_termvstore() { return termvstore; }
      ParameterVertexStore    *get_paravstore() { return paravstore; }
      ExternalVertexStore     *get_extvstore()  { return extvstore; }
      UnboundVertexStore      *get_ubvstore()  { return  ubvstore; }


      void set_consvstore(ConstructionVertexStore *nv) { consvstore = nv; }
      void set_altvstore(AlternationVertexStore  *nv)  { altvstore = nv; }
      void set_repvstore(RepetitionVertexStore   *nv)  { repvstore = nv; }
      void set_termvstore(TerminalVertexStore     *nv) { termvstore = nv; }
      void set_paravstore(ParameterVertexStore    *nv) { paravstore = nv; }
      void set_extvstore(ExternalVertexStore     *nv)  { extvstore = nv; }

  void clicked_obj(GraphicsObject *&ret,int clicked_x,int clicked_y,selectflag_t selectflag);
  void draw();
  void select_box(int &,int &,int ,int ,VertexObject*&);
  void append(VertexObject *);
  void check_conflict_name(char *tn,int &legal,draw_kind kind);
  void remove_from_unbound(VertexObject *v);
  int IsNotUsedLocalName(char *n, draw_kind k);
  int IsNotUsedExtName(char *n, draw_kind k);
  void deleteElm(int &done, VertexObject* obj);
  void genCd(FILE *fp);
  void printVertices(FILE *fp);
  void printCPEdges(FILE *fp);
  VertexObject *getEndVertex(long tid,token_kind tk);
  void freeStore();
};

class PointObject {
 private:
   int x,y;


  selectflag_t selected_flag;

 public:
  PointObject()  { x = y = 0; }
  ~PointObject() { }


  selectflag_t get_selected_flag()       { return selected_flag; }
  void set_selected_flag(selectflag_t nv) { selected_flag = nv; }

  int get_x()   { return x;   }
  int get_y()   { return y;   }

  void  set_x(int nv)   { x = nv;   }
  void  set_y(int nv)   { y = nv;   }

  int rset_x(int nv)   { int t = x;
				    x = nv;
				    return t;   }
  int rset_y(int nv)   { int t = y;
				    y = nv;
				    return t;   }

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);
  void drawSelected();
};


class PointObjectList {

 private:
   PointObject       *elm;
   PointObjectList   *prev;
   PointObjectList   *next;

   int max_x;
   int max_y;
   int min_x;
   int min_y;

 public:
     PointObjectList()
        { elm = NULL;
          prev = next = NULL;
          max_x = max_y = min_x = min_y = 0;
        }
     ~PointObjectList() {  delete elm; if (next) delete next; }


  int get_max_x() { return max_x; }
  int get_max_y() { return max_y; }
  int get_min_x() { return min_x; }
  int get_min_y() { return min_y; }

  void set_max_x(int nx) { max_x = nx; }
  void set_max_y(int ny) { max_y = ny; }
  void set_min_x(int nx) { min_x = nx; }
  void set_min_y(int ny) { min_y = ny; }

  int rset_max_x(int nx) { int t = max_x;
					 max_x = nx;
				         return t; }
  int rset_max_y(int ny) { int t = max_y;
					 max_y = ny;
				         return t; }
  int rset_min_x(int nx) { int t = min_x;
					 min_x = nx;
				         return t; }
  int rset_min_y(int ny) { int t = min_y;
					 min_y = ny;
				         return t; }


     PointObject      *get_elm() { return elm; }
     PointObjectList  *get_prev()  { return prev; }
     PointObjectList  *get_next()  { return next; }
     
     void set_elm (PointObject *nf)      { elm = nf; }
     void set_prev(PointObjectList *nr)  { prev  = nr; }
     void set_next(PointObjectList *nr)  { next  = nr; }
     
     PointObject *rset_elm(PointObject *nf)
                   { PointObject * t = elm;
                     elm = nf;
                     return t; }
     PointObjectList *rset_prev(PointObjectList  *nr)
                  { PointObjectList *t = prev;
                    prev  = nr;
                    return t; }

     PointObjectList *rset_next(PointObjectList *nr)
                  { PointObjectList  *t = next;
                    next  = nr;
                    return t; }


     void append(PointObject *);
     void set_xy(int x,int y);
     void xor_draw();
     void xor_draw_last_segment();
     void draw(selectflag_t,draw_kind kind,XPoint *,int,int,VertexObject*,VertexObject*);
     void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);
     int length() { int l = 1; if (next)  next->length(l); return l; }
     void length(int &l) { l++; if (next)  next->length(l); }
     void drawSelected(selectflag_t selectedflag);
     void unSelect();
     void addBreakPoint(int,int);
     void deleteInnerPoint();
     void moveStartPoint(int dx,int dy);
     void moveEndPoint(int dx,int dy);
     void moveConsStartPoint(int dx,int dy,EdgeLabelObject *);
     void moveConsEndPoint(int dx,int dy,EdgeLabelObject *);
     void move_inner_point(int dx,int dy);
     void move_inner_point(int dx,int dy, EdgeLabelObject *el);
     void get_lastxy(int &lx,int &ly);
     void move_end_point(int rx,int ry);
     void draw_first_seg(draw_kind);
     void draw_last_seg(draw_kind);
     void draw_inner(draw_kind kind,int cur_p, int exp_p);
     int  selected_points_position(int );
     void genCDArray(FILE *fp);
     void genPSArray(FILE *fp);
     void genArrow(FILE *fp,draw_kind);
};


class TextObject {

 private:
  char *val;
  int x;
  int y;
  int text_width;

  int max_x;
  int max_y;
  int min_x;
  int min_y;

 public:
  TextObject()
     { val = NULL;
       max_x = max_y = min_x = min_y = 0;
      }
  virtual ~TextObject() { if (val) free(val); }


  int get_max_x() { return max_x; }
  int get_max_y() { return max_y; }
  int get_min_x() { return min_x; }
  int get_min_y() { return min_y; }

  void set_max_x(int nx) { max_x = nx; }
  void set_max_y(int ny) { max_y = ny; }
  void set_min_x(int nx) { min_x = nx; }
  void set_min_y(int ny) { min_y = ny; }

  int rset_max_x(int nx) { int t = max_x;
					 max_x = nx;
				         return t; }
  int rset_max_y(int ny) { int t = max_y;
					 max_y = ny;
				         return t; }
  int rset_min_x(int nx) { int t = min_x;
					 min_x = nx;
				         return t; }
  int rset_min_y(int ny) { int t = min_y;
					 min_y = ny;
				         return t; }

  char *    get_val() { return val; }
  int get_x()   { return x;   }
  int get_y()   { return y;   }
  int get_text_width() { return text_width; }

  void  set_val(char *nv)     { val = nv; }
  void  set_x(int nv)   { x = nv;   }
  void  set_y(int nv)   { y = nv;   }
  void  set_text_width(int nv)   { text_width = nv;   }

  char *    rset_val(char *nv)     { char *t = val;
                                    val = nv;
                                    return t; }
  int rset_x(int nv)   { int t = x;
				    x = nv;
				    return t;   }
  int rset_y(int nv)   { int t = y;
				    y = nv;
				    return t;   }

  virtual void xor_draw() = 0;
  virtual void draw() { }
  virtual void undraw()     = 0;
  virtual void set_name(char *n,int bx,int by) = 0;

  void select_box(int &rx,int &ry,
                  int mx, int my, VertexObject *&)
       { printf("select_box:: cannot reach here\n"); }
  void createToggleButtons(Widget,Widget,rwflag_t flag, ParameterAssignment *, char *);
  void concat_name(char *);

  virtual void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag) = 0;

};

class ClassNameObject : public TextObject {

 public:
   ClassNameObject() { }
   ~ClassNameObject() { }

  int  isTemplateInst() { return this->get_val() == NULL || strlen(this->get_val()) == 0; }
  void xor_draw();
  void draw() { };
  void undraw(int ,int);
  void undraw() { }
  void set_name(char *n,int bx,int by);
  void get_parameterized_name(ParameterAssignmentStore *,char *);
  void draw(int name_x, int name_y);
  char * get_vertex_name() { return this->get_val(); }
  void set_vertex_name(char *nn) { this->set_val(nn); }
  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag) { }

};


class EdgeLabelObject : public TextObject {

 public:
   EdgeLabelObject() { }
   ~EdgeLabelObject() { }

  void xor_draw();
  void draw(GC);
  void undraw();
  void set_name(char *n,int bx,int by);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
  void move_edge_name(int dx, int dy)
          { this->set_x(dx + this->get_x());
            this->set_y(dy + this->get_y());
           }
};

class BoxObject {

 private:
  int x1;
  int y1;
  int x2;
  int y2;

 public:
  BoxObject() { x1 = y1 = x2 = y2 = 0; }
  ~BoxObject() { }


  int get_x1() { return x1; }
  int get_y1() { return y1; }
  int get_x2() { return x2; }
  int get_y2() { return y2; }

  void set_x1(int nv) { x1 = nv; }
  void set_y1(int nv) { y1 = nv; }
  void set_x2(int nv) { x2 = nv; }
  void set_y2(int nv) { y2 = nv; }

  int rset_x1(int nv) { int tv = x1; x1 = nv; return tv; }
  int rset_y1(int nv) { int tv = y1; y1 = nv; return tv; }
  int rset_x2(int nv) { int tv = x2; x2 = nv; return tv; }
  int rset_y2(int nv) { int tv = y2; y2 = nv; return tv; }

  virtual void xor_draw() = 0;

  virtual void draw(primary_flag_t,GC cur_gc,GC) = 0;

  virtual void select_box(int &,int &,
                  int,int, VertexObject*&,VertexObject *) = 0;

  virtual void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag) = 0;

  virtual void drawSelected(selectflag_t selectedflag) = 0;
};


class Rectangle : public  BoxObject {

 public:
  Rectangle() {  }
  ~Rectangle() { }


  void xor_draw();
  void draw(primary_flag_t,GC cur_gc,GC);

  void select_box(int &,int &,
                 int ,int ,VertexObject*&,VertexObject *);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
};


class Circle : public  BoxObject {

 public:
  Circle() {  }
  ~Circle() { }


  void xor_draw();
  void draw(primary_flag_t,GC cur_gc,GC);

  void select_box(int &rx,int &ry,
                  int mx,int my, VertexObject*&,VertexObject *vobj);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
};


class TRectangle : public  BoxObject {

 public:
  TRectangle() {  }
  ~TRectangle() { }


  void xor_draw();
  void draw(primary_flag_t,GC cur_gc,GC);

  void select_box(int &rx,int &ry,
                  int mx,int my, VertexObject*&,VertexObject *vobj);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
};


class ERectangle : public  BoxObject {

 public:
  ERectangle() {  }
  ~ERectangle() { }


  void xor_draw();
  void draw(primary_flag_t,GC cur_gc,GC);

  void select_box(int &rx,int &ry,
                  int mx,int my, VertexObject*&,VertexObject *vobj);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
};


class Hexagon : public  BoxObject {

 public:
  Hexagon() {  }
  ~Hexagon() { }


  void xor_draw();
  void draw(primary_flag_t,GC cur_gc,GC);

  void select_box(int &rx,int &ry,
                  int mx,int my, VertexObject*&,VertexObject *vobj);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);

};


class HexagonRect : public  BoxObject {

 public:
  HexagonRect() {  }
  ~HexagonRect() { }


  void xor_draw();
  void draw(primary_flag_t,GC cur_gc,GC);

  void select_box(int &rx,int &ry,
                  int mx,int my, VertexObject*&,VertexObject *vobj);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
};

class ParameterAssignment {
 private:
   ParameterEdge *formaledge;
   char          *actual_val;
   enum rwflag_t   flag;
   Widget        w;
   Widget        tb;
                    /* fill in text widget */
 public:
   ParameterAssignment() {
                           formaledge = NULL;
                           actual_val = NULL;
                           flag = READONLY;  /* locally allocated */
                           w = tb = NULL;
                         } 

   ~ParameterAssignment()
             {
              if (flag == READONLY)
                    free(actual_val);
              } 

   ParameterEdge *get_formaledge() { return formaledge; }
   char *get_actual_val() { return actual_val; }

   Widget get_w() { return w; }
   void   set_w(Widget nw) { w = nw; }

   Widget get_tb() { return tb; }
   void   set_tb(Widget nw) { tb = nw; }

   rwflag_t  get_flag() { return flag; }
   void    set_flag(rwflag_t nf) { flag = nf; }

   void set_formaledge(ParameterEdge *nv) { formaledge = nv; }
   void set_actual_val(char *nv) { actual_val = nv; }


   ParameterEdge *rset_formaledge(ParameterEdge *nv)
            { ParameterEdge * t = formaledge;
              formaledge = nv;
              return t; }
   char *rset_actual_val(char *nv)
            { char *t = actual_val;
              actual_val = nv;
              return t; }

   int no_formal_parameters();
   void createToggleButtons(Widget,Widget);
   void update_fillin(setargs_struct *setargs_inst);
   void concat_name(char *);
   void disableEachField(ParameterAssignment *a);
   void propagateEachChange(ParameterAssignment *a);
   void assign_args(Widget f,int);
   void notIntroConflict(char *n,int &r);
   void printParEdges(FILE *fp);
   void printAssignmentPS(FILE *fp);
};

class ParameterAssignmentList {


 private:

     ParameterAssignment       *elm;
     ParameterAssignmentList   *prev;
     ParameterAssignmentList   *next;

   public:
     ParameterAssignmentList() { elm = NULL; prev = next = NULL; }
     ~ParameterAssignmentList() { delete elm; if (next) delete next; }



     ParameterAssignment *get_elm()        { return elm; }
     ParameterAssignmentList  *get_prev()  { return prev; }
     ParameterAssignmentList  *get_next()  { return next; }
     
     void set_elm(ParameterAssignment *nf)       { elm = nf; }
     void set_prev(ParameterAssignmentList *nr)  { prev  = nr; }
     void set_next(ParameterAssignmentList *nr)  { next  = nr; }
     
     ParameterAssignment *rset_elm(ParameterAssignment *nf)
                   { ParameterAssignment * t = elm;
                     elm = nf;
                     return t; }
     ParameterAssignmentList *rset_prev(ParameterAssignmentList  *nr)
                  { ParameterAssignmentList *t = prev;
                    prev  = nr;
                    return t; }

     ParameterAssignmentList *rset_next(ParameterAssignmentList *nr)
                  { ParameterAssignmentList  *t = next;
                    next  = nr;
                    return t; }

     void append_parassign(ParameterEdge *npe);
     void append_parassign(ParameterAssignment *na);
     int no_formal_parameters();
     void duplicate_parassign(ParameterAssignmentStore *,int);
     void length(int &l) { l++; if (next) next->length(l); }

     void createToggleButtons(Widget,Widget);
     void update_fillin(setargs_struct *setargs_inst);
     void concat_name(char *);
     void add_parassign_to_inst(ParameterEdge *npe);
     void disableEachField(ParameterAssignmentList *ta);
     void propagateEachChange(ParameterAssignmentList *ta);
     void assign_args(Widget f,int);
     void reorder_args(ParameterAssignmentList **,int i);
     void notIntroConflict(char *n,int &r);
     void deleteAssignments(GraphicsObject* obj);
     void printParEdges(FILE *fp);
     void printAssignmentPS(FILE *fp);
     void fillinPE(ParameterEdge *e);
};

class ParameterAssignmentStore {
 private:
      ParameterAssignmentList *assignments;
 public:
      ParameterAssignmentStore() { assignments = NULL; }
      ~ParameterAssignmentStore() { if (assignments) delete assignments; }

      ParameterAssignmentList *get_assignments() { return assignments; }
      void set_assignments(ParameterAssignmentList * nv)
                 { assignments = nv; }
      ParameterAssignmentList *rset_assignments(ParameterAssignmentList * nv)
              { ParameterAssignmentList *t = assignments;
                assignments = nv;
                return t; }

      int no_formal_parameters();
      int no_parameters();
      void append_parassign(ParameterEdge *npe);
      void append_parassign(ParameterAssignment *na);
      void duplicate_parassign(ParameterAssignmentStore *,int);

      int empty() { return assignments == NULL; }
      int length() { int l = 0;
                     if (assignments)
                         assignments->length(l);
                     return l;
                   }
      void createToggleButtons(Widget,Widget);
      void update_fillin(setargs_struct *setargs_inst);
      void concat_name(char *);
      void add_parassign_to_inst(ParameterEdge *npe);
      void disableEachField(ParameterAssignmentStore *tstore);
      void propagateEachChange(ParameterAssignmentStore *tstore);
      void assign_args(Widget f);
      void reorder_args();
      void notIntroConflict(char *n,int &r);
      void deleteAssignments(GraphicsObject* obj);
      void printParEdges(FILE *fp);
      void printAssignmentPS(FILE *fp);
      void fillinPE(ParameterEdge *e);
};

class VertexObject : public GraphicsObject {

 private:
  ClassNameObject *name;   /* shared with primary at the NameSensitiveVertex */
  ClassNameObject *template_name;  /* shared with primary */
  int name_x, name_y;

  ObjectStore *home;
  NameSensitiveVertex *subhome;

  primary_flag_t primary_flag;

  int is_template;

  BoxObject  *box;


  ParameterAssignmentStore *parassignstore;  /* shared with the primary */



  ObjectStore *incoming_consedge_store;
  ObjectStore *incoming_repedge_store;
  ObjectStore *incoming_altedge_store;
  ObjectStore *incoming_inhedge_store;
  ObjectStore *incoming_paredge_store;
  ObjectStore *incoming_parinstedge_store;

  ObjectStore *outgoing_consedge_store;
  ObjectStore *outgoing_repedge_store;
  ObjectStore *outgoing_altedge_store;
  ObjectStore *outgoing_inhedge_store;
  ObjectStore *outgoing_paredge_store;
  ObjectStore *outgoing_parinstedge_store;

 public:
  VertexObject()  { home = NULL;
		    subhome = NULL;
                    name = NULL; box = NULL;
                    template_name = NULL; /* shared */
		    primary_flag = UNKNOWN;
                    name_x = 0;
                    name_y = 0;
                    is_template = 1;
                    parassignstore          = new ParameterAssignmentStore();
                    incoming_consedge_store = new ObjectStore();
                    incoming_repedge_store = new ObjectStore();
                    incoming_altedge_store = new ObjectStore();
                    incoming_inhedge_store = new ObjectStore();
                    incoming_paredge_store = new ObjectStore();
                    incoming_parinstedge_store = new ObjectStore();

                    outgoing_consedge_store = new ObjectStore();
                    outgoing_repedge_store = new ObjectStore();
                    outgoing_altedge_store = new ObjectStore();
                    outgoing_inhedge_store = new ObjectStore();
                    outgoing_paredge_store = new ObjectStore();
                    outgoing_parinstedge_store = new ObjectStore();
                  }
  ~VertexObject() {
       if (parassignstore && (primary_flag == PRIMARY_OF || primary_flag == PRIMARY))
          delete parassignstore;
       if (box)  delete box;
       if (incoming_consedge_store) delete incoming_consedge_store;
       if (incoming_repedge_store) delete incoming_repedge_store;
       if (incoming_altedge_store) delete incoming_altedge_store;
       if (incoming_inhedge_store) delete incoming_inhedge_store;
       if (incoming_paredge_store) delete incoming_paredge_store;
       if (incoming_parinstedge_store) delete incoming_parinstedge_store;

       if (outgoing_consedge_store) delete outgoing_consedge_store;
       if (outgoing_repedge_store) delete outgoing_repedge_store;
       if (outgoing_altedge_store) delete outgoing_altedge_store;
       if (outgoing_inhedge_store) delete outgoing_inhedge_store;
       if (outgoing_paredge_store) delete outgoing_paredge_store;
       if (outgoing_parinstedge_store) delete outgoing_parinstedge_store;
		  }
  int  get_is_template()       { return is_template; }
  void set_is_template(int nv) { is_template = nv; }
   
  ObjectStore *get_incoming_consedge_store()
              { return incoming_consedge_store; }
  ObjectStore *get_incoming_repedge_store()
              { return incoming_repedge_store;  }
  ObjectStore *get_incoming_altedge_store()
              { return incoming_altedge_store; }
  ObjectStore *get_incoming_inhedge_store()
              { return incoming_inhedge_store; }
  ObjectStore *get_incoming_paredge_store()
              { return incoming_paredge_store; }
  ObjectStore *get_incoming_parinstedge_store()
              { return incoming_parinstedge_store; }


   
  void set_incoming_consedge_store(ObjectStore *ns)
              { incoming_consedge_store = ns; }
  void set_incoming_repedge_store(ObjectStore *ns)
              { incoming_repedge_store = ns;  }
  void set_incoming_altedge_store(ObjectStore *ns)
              { incoming_altedge_store = ns; }
  void set_incoming_inhedge_store(ObjectStore *ns)
              { incoming_inhedge_store = ns; }
  void set_incoming_paredge_store(ObjectStore *ns)
              { incoming_paredge_store = ns; }
  void set_incoming_parinstedge_store(ObjectStore *ns)
              { incoming_parinstedge_store = ns; }


   
  ObjectStore *get_outgoing_consedge_store()
              { return outgoing_consedge_store; }
  ObjectStore *get_outgoing_repedge_store()
              { return outgoing_repedge_store;  }
  ObjectStore *get_outgoing_altedge_store()
              { return outgoing_altedge_store; }
  ObjectStore *get_outgoing_inhedge_store()
              { return outgoing_inhedge_store; }
  ObjectStore *get_outgoing_paredge_store()
              { return outgoing_paredge_store; }
  ObjectStore *get_outgoing_parinstedge_store()
              { return outgoing_parinstedge_store; }


   
  void set_outgoing_consedge_store(ObjectStore *ns)
              { outgoing_consedge_store = ns; }
  void set_outgoing_repedge_store(ObjectStore *ns)
              { outgoing_repedge_store = ns;  }
  void set_outgoing_altedge_store(ObjectStore *ns)
              { outgoing_altedge_store = ns; }
  void set_outgoing_inhedge_store(ObjectStore *ns)
              { outgoing_inhedge_store = ns; }
  void set_outgoing_paredge_store(ObjectStore *ns)
              { outgoing_paredge_store = ns; }
  void set_outgoing_parinstedge_store(ObjectStore *ns)
              { outgoing_parinstedge_store = ns; }

  primary_flag_t get_primary_flag() { return primary_flag; }
  void set_primary_flag(primary_flag_t nv) { primary_flag =nv; }

  ClassNameObject *get_name() { return name; }
  ClassNameObject *get_template_name() { return template_name; }
  BoxObject *get_box() { return box; }
  ParameterAssignmentStore *get_parassignstore() { return parassignstore; }

  void set_name( ClassNameObject * nt) { name = nt; }
  void set_template_name( ClassNameObject * nt) { template_name = nt; }
  void set_box(BoxObject *nf) { box = nf; }
  void set_parassignstore(ParameterAssignmentStore * nv) { parassignstore=nv;}

  ParameterAssignmentStore *rset_parassignstore(ParameterAssignmentStore * nv)
          { ParameterAssignmentStore *t = parassignstore;
            parassignstore = nv;
            return t; }

  ClassNameObject *rset_name( ClassNameObject *nt) {  ClassNameObject *t = name;
                                          name = nt;
                                          return t; }


  ClassNameObject *rset_template_name( ClassNameObject *nt)
         {  ClassNameObject *t = template_name;
           template_name = nt;
           return t; }

  BoxObject *rset_box(BoxObject *nf) { BoxObject * t = box; 
                                             box = nf;
                                             return t; }



  ObjectStore         *get_home()    { return home; }
  NameSensitiveVertex *get_subhome() { return subhome; }

  void set_home(ObjectStore *nv)            { home = nv; }
  void set_subhome(NameSensitiveVertex *nv) { subhome = nv; }

  int get_name_x() { return name_x; }
  int get_name_y() { return name_y; }

  void set_name_x(int nv) { name_x = nv; }
  void set_name_y(int nv) { name_y = nv; }

  void set_xy(int x,int y);
  void get_xy(int&x,int&y);

  void xor_draw();
  void draw();
/*  void redraw(); */
  void set_name(char *n, int bx, int by) { name_x = bx; name_y = by; name->set_name(n,bx,by); }

  int isTemplateInst() { return is_template != 1; }
  void select_box(int &rx,int &ry,
           int mx,int my, VertexObject*&);

  int no_formal_parameters()
           { return (parassignstore->no_formal_parameters()); }

  int no_parameters()
           { return (parassignstore->no_parameters()); }

  void append_parassign(ParameterEdge *npe);

  void duplicate_parassign(ParameterAssignmentStore *,int);
  void createToggleButtons(Widget,Widget,rwflag_t, ParameterAssignment *, char *);
  void concat_name(char *);

  char *get_vertex_name();
  void set_vertex_name(char *nn) { name->set_vertex_name(nn); }
  int vertexInUse();

  void add_parassign_to_inst(ParameterEdge *npe);

  void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
  void append_parassign_to_primary(ParameterEdge *npe);
  virtual void no_duplicate_target(int &ret,draw_kind k,char *n);
  virtual void doubleClickPopup() = 0;
  void disableEachField(ParameterAssignmentStore *tstore);
  void propagateEachChange(ParameterAssignmentStore *tstore);
  void reorder_args();
  void deleteObject(int &done);
  void deleteAssignments(GraphicsObject* obj);
  virtual void helpPopupMenu(XEvent* e,int x,int y);
  void move_vertex_name(int dx,int dy)
       { name_x += dx; name_y += dy; }
  void move_vertex(int, int);
  void drawRelated();
  virtual void printPrimaryVertex(FILE *fp);
  void printParEdges(FILE*fp);
  void fillinPE(ParameterEdge *e);
  void freeStore();
  virtual void printInheritExt(FILE *fp);
  virtual void VertexObject::printEachInheritExt(FILE *fp);
};

class ConstructionVertex : public VertexObject {
 public:
  ConstructionVertex()
       { this->set_kind(CONS_VERTEX);
       }
  ~ConstructionVertex() { }

  void doubleClickPopup();
  void helpPopupMenu(XEvent* e,int x,int y);
  void printPrimaryVertex(FILE *fp);
  void printSVertex(FILE *fp);
  void printIVertex(FILE *fp);
  void printNameInsenVertices(FILE *fp);
  void freeStore();
};

class AlternationVertex : public VertexObject {
 public:
   AlternationVertex()
       {  this->set_kind(ALT_VERTEX);
       }
   ~AlternationVertex() {  }

  void doubleClickPopup();
  void helpPopupMenu(XEvent* e,int x,int y);
  void printAlt(FILE *fp,int &hasAlt);
  void printPrimaryVertex(FILE *fp);
  void printSVertex(FILE *fp);
  void printIVertex(FILE *fp);
  void printNameInsenVertices(FILE *fp);
};

class RepetitionVertex : public VertexObject {

 public:
   RepetitionVertex() {
         this->set_kind(REP_VERTEX);
       }
   ~RepetitionVertex() { }

  void doubleClickPopup();
  int has_rep_edge();
  void printRep(FILE *fp,int &hasAlt);
  void printPrimaryVertex(FILE *fp);
  void printSVertex(FILE *fp);
  void printIVertex(FILE *fp);
  void printNameInsenVertices(FILE *fp);
};

class ExternalVertex : public VertexObject {

 public:
   ExternalVertex() { this->set_kind(EXT_VERTEX); }
   ~ExternalVertex() { }
   void doubleClickPopup();
  void printPrimaryVertex(FILE *fp);
  void printSVertex(FILE *fp);
  void printIVertex(FILE *fp);
  void printNameInsenVertices(FILE *fp);
  void printEachInheritExt(FILE *fp);
};

class TerminalVertex : public VertexObject {
 private:
   Comments *comments;
 public:
  TerminalVertex() {  comments = new Comments(); this->set_kind(TERM_VERTEX); }
  ~TerminalVertex() { delete comments; }

  Comments *get_comments() { return comments; }
  void doubleClickPopup();
  void printNameInsenVertices(FILE *fp);
  void freeStore();
};


class ParameterVertex : public VertexObject {
 private:
   Comments *comments;
 public:
  ParameterVertex() { comments = new Comments(); this->set_kind(PARAM_VERTEX); }
  ~ParameterVertex() {delete comments; }

  Comments *get_comments() { return comments; }
  void doubleClickPopup();
  int notIntroConflicts(char *n);
  void printVertex(FILE *fp);
  void printNameInsenVertices(FILE *fp);
  void freeStore();
};

/* Edges */

class EdgeObject : public GraphicsObject {

 private:
     int max_x;
     int max_y;
     int min_x;
     int min_y;

     VertexObject *from_vertex;
     VertexObject *to_vertex;

     PointObjectList *points;
     Comments *comments;
 public:

  EdgeObject() { points = NULL; from_vertex = to_vertex =  NULL;
                 comments = new Comments(); max_x = max_y = min_x = min_y = 0;
               }
  virtual ~EdgeObject() { if (points) delete points; if (comments) delete comments; }

  Comments *get_comments() { return comments; }

  VertexObject * get_from_vertex() { return from_vertex; }
  VertexObject * get_to_vertex()   { return to_vertex; }

  VertexObject * rset_from_vertex(VertexObject *nv)
                            { VertexObject * t= from_vertex;
                              from_vertex = nv;
                              return t; }
  VertexObject * rset_to_vertex(VertexObject *nv)
                            { VertexObject * t= from_vertex;
                              to_vertex = nv;
                              return t; }

  void set_from_vertex(VertexObject *nv)  { from_vertex = nv; }
  void set_to_vertex(VertexObject *nv)    { to_vertex = nv; }


  PointObjectList * get_points() {  return points; }
  void set_points(PointObjectList * nv) {  points = nv; }
  PointObjectList * rset_points(PointObjectList * nv)
           {  PointObjectList * t = points;
              points = t;
              return t; }

  int get_max_x() { return max_x; }
  int get_max_y() { return max_y; }
  int get_min_x() { return min_x; }
  int get_min_y() { return min_y; }

  void set_max_x(int nx) { max_x = nx; }
  void set_max_y(int ny) { max_y = ny; }
  void set_min_x(int nx) { min_x = nx; }
  void set_min_y(int ny) { min_y = ny; }

  int get_max_x(int nx) { int t = max_x;
					 max_x = nx;
				         return t; }
  int get_max_y(int ny) { int t = max_y;
					 max_y = ny;
				         return t; }
  int get_min_x(int nx) { int t = min_x;
					 min_x = nx;
				         return t; }
  int get_min_y(int ny) { int t = min_y;
					 min_y = ny;
				         return t; }

  virtual void xor_draw() { points->xor_draw();}
  virtual void xor_draw_last_segment() { points->xor_draw_last_segment();}
  void draw();
  virtual void set_xy(int x,int y)   { points ->set_xy(x,y); }
  virtual void get_xy(int&,int&) { }
  virtual void set_name(char *,int,int) { }

  void append(PointObject *);


  void select_box(int &rx,int &ry,
          int mx,int my, VertexObject*&)
     { printf("select_box: cannot reach here.\n"); }
  int vertexInUse();

  virtual void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);
  virtual void drawSelected(selectflag_t selectedflag);
  void unSelect();
  void no_duplicate_edge(int &ret,char *n);
  virtual void doubleClickPopup() = 0;
  void addBreakPoint(int , int);
  void deleteObject(int &);
  void helpPopupMenu(XEvent* e,int x,int y);
  virtual void move_edge_name(int, int) { }
  virtual void moveStartPoint(int dx,int dy);
  virtual void moveEndPoint(int dx,int dy);
  void drawRelated();
  virtual void move_start_point(int x,int y);
  virtual void move_end_point(int x,int y);
  virtual void move_inner_point(int x,int y);
  virtual void draw_last_seg();
  virtual void draw_first_seg();
  virtual void draw_inner_segs();
};


class UndeterminedEdge : public EdgeObject {

 public:
   UndeterminedEdge()  { }
   ~UndeterminedEdge() { }

  void doubleClickPopup();
};


class ConstructionEdge : public EdgeObject {

 private:
  EdgeLabelObject *edge_label;
 public:

  ConstructionEdge() { edge_label = new EdgeLabelObject(); }
  virtual ~ConstructionEdge() {  delete edge_label; }

  EdgeLabelObject *get_edge_label() { return edge_label; }

  virtual void set_edge_label(EdgeLabelObject * nt) { edge_label = nt; }

  EdgeLabelObject *rset_edge_label(EdgeLabelObject *nt) { EdgeLabelObject *t = edge_label;
                                          edge_label = nt;
                                          return t; }
  void draw();
  void initial_set_label(char *name);
  virtual void clicked_obj(GraphicsObject *&ret,GraphicsObject *,int clicked_x,int clicked_y,selectflag_t selectflag);

  void drawSelected(selectflag_t selectedflag);
  virtual void doubleClickPopup() = 0;
  virtual void assign_parts(Widget f,int i);
  void move_edge_name(int x, int y) { edge_label->move_edge_name(x,y); }
  void moveStartPoint(int dx,int dy);
  void moveEndPoint(int dx,int dy);
  void move_start_point(int x,int y);
  void move_end_point(int x,int y);
  void move_inner_point(int x,int y);
  void draw_last_seg();
  void draw_first_seg();
  void draw_inner_segs();
};

class ReqConstructionEdge : public ConstructionEdge {
 private:
   char *before;
   char *after;

 public:
  ReqConstructionEdge()
       { this->set_kind(REQ_C_EDGE);
         before = after  = NULL;
       }
  ~ReqConstructionEdge()
        { if (before) free(before);
          if (after)  free(after);
        }


  char *get_before() { return before; }
  char *get_after()  { return after; }


  void set_before(char *nv)   { before = nv; }
  void set_after(char *nv)    { after = nv; }


  char *rset_before(char *nv)   { char *t = before;  before = nv; return t; }
  char *rset_after(char *nv)    { char *t = after;    after = nv; return t; }
  void doubleClickPopup();
  void printCons(FILE *fp);
  void printConsEdges(FILE*fp);
};

class OptConstructionEdge : public ConstructionEdge {
 private:
   char *before;
   char *after;

   char *inbefore;
   char *inafter;

 public:
  OptConstructionEdge()
          { this->set_kind(OPT_C_EDGE);
            before = after = inbefore = inafter = NULL;
           }
  ~OptConstructionEdge()
          { if (before)   free(before);
            if (after)    free(after);
            if (inafter)  free(inafter);
            if (inbefore) free(inbefore);
         }


  char *get_before() { return before; }
  char *get_after()  { return after; }
  char *get_inbefore() { return inbefore; }
  char *get_inafter()  { return inafter; }


  void set_before(char *nv)   { before = nv; }
  void set_after(char *nv)    { after = nv; }
  void set_inbefore(char *nv)   { inbefore = nv; }
  void set_inafter(char *nv)    { inafter = nv; }


  char *rset_before(char *nv)   { char *t = before;  before = nv; return t; }
  char *rset_after(char *nv)    { char *t = after;    after = nv; return t; }
  char *rset_inafter(char *nv)    { char *t = inafter;    inafter = nv; return t; }
  char *rset_inbefore(char *nv)   { char *t = inbefore;  inbefore = nv; return t; }

  void printCons(FILE *fp);
  void doubleClickPopup();
  void printConsEdges(FILE*fp);
};

class ReqRepetitionEdge : public EdgeObject {
 private:
   char *outbefore;
   char *before;
   char *after;
 public:
  ReqRepetitionEdge()  { outbefore = before = after = NULL; this->set_kind(REQ_R_EDGE); }
  ~ReqRepetitionEdge() { if (outbefore) free(outbefore);
                         if (before)    free(before);
                         if (after)     free(after);
                       }


  char *get_before() { return before; }
  char *get_outbefore() { return before; }
  char *get_after()  { return after; }


  void set_before(char *nv)   { before = nv; }
  void set_outbefore(char *nv)   { outbefore = nv; }
  void set_after(char *nv)    { after = nv; }


  char *rset_outbefore(char *nv)   { char *t = outbefore;  outbefore = nv; return t; }
  char *rset_before(char *nv)   { char *t = before;  before = nv; return t; }
  char *rset_after(char *nv)    { char *t = after;    after = nv; return t; }
  void doubleClickPopup();
  void printRepEdge(FILE *fp,int &hasAlt);
  void printAIRIEdges(FILE *fp);
};

class OptRepetitionEdge : public EdgeObject {
 private:
   char *before;
   char *after;
 public:

  OptRepetitionEdge()  { before = after = NULL; this->set_kind(OPT_R_EDGE); }
  ~OptRepetitionEdge() { if (before) free(before);
                         if (after)  free(after);
                       }


  char *get_before() { return before; }
  char *get_after()  { return after; }


  void set_before(char *nv)   { before = nv; }
  void set_after(char *nv)    { after = nv; }


  char *rset_before(char *nv)   { char *t = before;  before = nv; return t; }
  char *rset_after(char *nv)    { char *t = after;    after = nv; return t; }
  void doubleClickPopup();
  void printRepEdge(FILE *fp,int &hasAlt);
  void printAIRIEdges(FILE *fp);
};


class AlternationEdge : public EdgeObject {

 public:
  AlternationEdge()  { this->set_kind(ALT_EDGE); }
  ~AlternationEdge() { }
  void doubleClickPopup();
  void printAltEdge(FILE *fp,int &hasAlt); /* for text */
  void printAIRIEdges(FILE *fp);           /* for ps */
};

class InheritanceEdge : public EdgeObject {

 public:
  InheritanceEdge()  { this->set_kind(INH_EDGE); }
  ~InheritanceEdge() { }
  void doubleClickPopup();
  void printAIRIEdges(FILE *fp);
  void printEachInheritExt(FILE *fp);
};


class ParameterEdge : public EdgeObject {

 public:
  ParameterEdge()  { this->set_kind(PAR_EDGE); }
  ~ParameterEdge() { }
  void createToggleButtons(Widget,Widget, rwflag_t flag, ParameterAssignment *, char*);
  void doubleClickPopup();
  void notIntroConflict(char *n,int &r);
  void printParEdges(FILE *fp);
};


class ParameterInstEdge : public EdgeObject {

 public:
  ParameterInstEdge()  { this->set_kind(PAR_INST_EDGE); }
  ~ParameterInstEdge() { }
  void add_parassign_to_inst(ParameterEdge *npe);
  void doubleClickPopup();
  void disableFields(ParameterAssignmentStore *tstore);
  void propagateChanges(ParameterAssignmentStore *tstore);
  void deleteAssignments(GraphicsObject* obj);
  void printAIRIEdges(FILE *fp);
};

#endif /* OBJ_STORE_H */