home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / GraphNodeI.h < prev    next >
C/C++ Source or Header  |  1998-03-25  |  5KB  |  185 lines
  1. // $Id: GraphNodeI.h,v 1.19 1998/03/25 12:43:23 zeller Exp $
  2. // GraphNode class structure
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _DDD_GraphNodeI_h
  30. #define _DDD_GraphNodeI_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36.  
  37. #include "UniqueId.h"
  38. #include "Box.h"
  39. #include "bool.h"
  40. #include "GraphGC.h"
  41. #include <strstream.h>
  42.  
  43. class GraphNode {
  44. public:
  45.     DECLARE_TYPE_INFO
  46.  
  47.     friend class Graph;
  48.     friend class GraphEdge;
  49.  
  50. private:
  51.     UniqueId _id;        // Id
  52.     bool _selected;        // Flag: selected by user?
  53.     bool _hidden;        // Flag: not shown?
  54.     bool _redraw;        // Flag: needs redrawing
  55.  
  56.     // maintained by GraphEdge
  57.     GraphEdge *_firstFrom;    // first Edge e with e->from() == this
  58.     GraphEdge *_firstTo;    // first Edge e with e->to()   == this
  59.  
  60.     // maintained by Graph
  61.     GraphNode *next;        // For collectors
  62.     GraphNode *prev;        // For collectors
  63.     Graph *graph;        // For collectors
  64.  
  65.     GraphNode& operator = (const GraphNode&) { assert(0); return *this; }
  66.  
  67. protected:
  68.     // Copy Constructor
  69.     GraphNode(const GraphNode& node):
  70.     _id(),
  71.     _selected(node._selected),
  72.     _hidden(node._hidden),
  73.     _redraw(node._redraw),
  74.     _firstFrom(0),
  75.     _firstTo(0),
  76.     next(0),
  77.     prev(0),
  78.     graph(0),
  79.     count(0)
  80.     {}
  81.  
  82. public:
  83.     int count;            // #predecessors (used in layout algorithms)
  84.  
  85.     // Constructor
  86.     GraphNode():
  87.     _id(), _selected(false), _hidden(false), _redraw(false),
  88.     _firstFrom(0), _firstTo(0), next(0), prev(0), graph(0), count(0)
  89.     {}
  90.  
  91.     // Destructor
  92.     virtual ~GraphNode() {}
  93.  
  94.     // Duplication
  95.     virtual GraphNode *dup() const = 0;
  96.  
  97.     // Resources
  98.     unsigned long id() const { return _id; }
  99.     bool& selected()      { return _selected; }
  100.     bool selected() const { return _selected; }
  101.     bool& hidden()        { return _hidden; }
  102.     bool hidden() const   { return _hidden; }
  103.     bool& redraw()        { return _redraw; }
  104.     bool redraw() const   { return _redraw; }
  105.  
  106.     // Iteration on all edges starting here
  107.     GraphEdge *firstFrom() const { return _firstFrom; }
  108.     GraphEdge *nextFrom(GraphEdge *ref) const;
  109.  
  110.     // Iteration on all edges ending here
  111.     GraphEdge *firstTo() const { return _firstTo; }
  112.     GraphEdge *nextTo(GraphEdge *ref) const;
  113.  
  114.     // Resources
  115.     virtual const BoxPoint&  pos() const                              = 0;
  116.     virtual const BoxRegion& region(const GraphGC& gc) const          = 0;
  117.     virtual const BoxRegion& highlightRegion(const GraphGC& gc) const = 0;
  118.     virtual const BoxRegion& sensitiveRegion(const GraphGC& gc) const = 0;
  119.     virtual string str() const 
  120.     { 
  121.     ostrstream os;
  122.     os << id();
  123.     return string(os);
  124.     }
  125.  
  126.     // Shortcuts
  127.     const BoxPoint& origin(const GraphGC& gc) const
  128.     {
  129.     return region(gc).origin();
  130.     }
  131.     const BoxSize& space(const GraphGC& gc) const
  132.     {
  133.     return region(gc).space();
  134.     }
  135.  
  136.     // Types
  137.     virtual bool isHint() const { return false; }
  138.  
  139.     // Move
  140.     virtual void moveTo(const BoxPoint& newPos) = 0;
  141.  
  142.     // Compute position for ORIGIN
  143.     virtual BoxPoint originToPos(const BoxPoint& origin, const GraphGC&) const
  144.     {
  145.     return origin;
  146.     }
  147.  
  148.     // Draw
  149.     virtual void draw(Widget, 
  150.               const BoxRegion&, 
  151.               const GraphGC&) const
  152.     {
  153.     // Default: do nothing
  154.     }
  155.  
  156.     // Custom drawing functions
  157.     void draw(Widget w, const BoxRegion& exposed) const
  158.     {
  159.     draw(w, exposed, GraphGC());
  160.     }
  161.  
  162.     void draw(Widget w) const
  163.     {
  164.     draw(w, BoxRegion(BoxPoint(0, 0), BoxSize(INT_MAX, INT_MAX)),
  165.         GraphGC());
  166.     }
  167.  
  168.     // Printing
  169.     virtual void _print(ostream&, const GraphGC&) const
  170.     {
  171.     // Default: do nothing
  172.     }
  173.  
  174.     // Representation invariant
  175.     virtual bool OK() const;
  176. };
  177.  
  178. inline ostream& operator << (ostream& s, GraphNode& node)
  179. {
  180.     return s << node.str();
  181. }
  182.  
  183. #endif // _DDD_GraphNodeI_h
  184. // DON'T ADD ANYTHING BEHIND THIS #endif
  185.