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 / Box.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-11-23  |  7.0 KB  |  262 lines
  1. // $Id: Box.h,v 1.17 1998/11/23 15:00:17 zeller Exp $
  2. // Box class
  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_Box_h
  30. #define _DDD_Box_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36.  
  37. // A Box is the base class for all graphical objects. It essentially
  38. // consists of a rectangle with a certain size and a certain
  39. // extensibility. The contents of the box are determined by the
  40. // drawing function _draw().
  41.  
  42. #include "assert.h"
  43. #include <string.h>
  44. #include "strclass.h"
  45.  
  46. #include "BoxPoint.h"
  47. #include "BoxSize.h"
  48. #include "BoxD.h"
  49. #include "BoxC.h"
  50. #include "BoxWeight.h"
  51. #include "BoxRegion.h"
  52. #include "BoxExtend.h"
  53. #include "PrintGC.h"
  54. #include "Widget.h"
  55. #include "bool.h"
  56. #include "UniqueId.h"
  57. #include "DataLink.h"
  58. #include "TypeInfo.h"
  59.  
  60. class TagBox;
  61.  
  62. // Box class
  63. class Box {
  64. public:
  65.     DECLARE_TYPE_INFO
  66.  
  67.     friend class BoxMemInit;
  68.  
  69. private:
  70.     UniqueId _id;        // Identifier
  71.     BoxSize _size;        // Size
  72.     BoxExtend _extend;        // Extensibility
  73.     char *_type;        // type
  74.  
  75.     static void epsHeader (ostream& os, 
  76.                const BoxRegion& region, 
  77.                const PostScriptPrintGC& gc);
  78.  
  79.     Box& operator = (const Box&) { assert(0); return *this; }
  80.  
  81. protected:
  82.     int _links;            // #references (>= 1)
  83.  
  84.     BoxSize& thesize()     { return _size; }
  85.     BoxExtend& theextend() { return _extend; }
  86.     const BoxSize& thesize() const     { return _size; }
  87.     const BoxExtend& theextend() const { return _extend; }
  88.  
  89.     // Copy constructor
  90.     Box(const Box& box):
  91.     _id(), _size(box._size), _extend(box._extend), 
  92.     _type(box._type), _links(1)
  93.     {}
  94.     
  95.     // Equality
  96.     virtual bool matches(const Box& b, const Box *callbackArg = 0) const;
  97.  
  98.     // Draw box
  99.     virtual void _draw(Widget w, 
  100.                const BoxRegion& region, 
  101.                const BoxRegion& exposed, 
  102.                GC gc, bool context_selected) const = 0;
  103.  
  104. public:
  105.     // Save box to stream
  106.     virtual void dump(ostream& s) const = 0;
  107.  
  108.     // Constructor
  109.     Box(BoxSize s = BoxSize(0, 0), BoxExtend e = BoxExtend(0, 0), 
  110.     char *t = "Box"):
  111.     _id(), _size(s), _extend(e), _type(t), _links(1)
  112.     {}
  113.  
  114.     // Destructor
  115.     virtual ~Box()
  116.     {
  117.     assert (_links == 0);
  118.     _type = 0;
  119.     }
  120.  
  121.     // Create new reference
  122.     virtual Box* link()
  123.     {
  124.     assert(_links > 0);
  125.     _links++;
  126.     return this;
  127.     }
  128.  
  129.     // Copy box
  130.     virtual Box *dup() const = 0;
  131.  
  132.     // Same, but only one level deep (if possible)
  133.     virtual Box *dup0() const { return dup(); }
  134.  
  135.     // Kill reference
  136.     void unlink()
  137.     {
  138.     assert(_links > 0);
  139.     if (--_links == 0)
  140.         delete this;
  141.     }
  142.  
  143.     // Resources
  144.     unsigned long id() const                   { return (unsigned long)_id; }
  145.     const char *type() const                   { return _type; }
  146.     BoxExtend extend() const                   { return _extend; }
  147.     BoxSize size() const                       { return _size; }
  148.  
  149.     BoxWeight extend(BoxDimension dimension) const
  150.     { 
  151.     return _extend[dimension]; 
  152.     }
  153.     BoxCoordinate size(BoxDimension dimension) const 
  154.     { 
  155.     return _size[dimension]; 
  156.     }
  157.  
  158.     // Build string from string components
  159.     virtual string str() const { return ""; }
  160.  
  161.     // Return free space in lower right corner
  162.     virtual BoxSize corner() const
  163.     {
  164.     // Default: space of zero width on the right of box
  165.     return BoxSize(0, _size[Y]);
  166.     }
  167.  
  168.     // Re-calculate box size
  169.     virtual Box* resize() { return this; }
  170.  
  171.     // Propagate new font
  172.     virtual void newFont(const string&) { resize(); }
  173.  
  174.     // Draw
  175.     void draw(Widget w, 
  176.           const BoxRegion& region, 
  177.           const BoxRegion& exposed = BoxRegion(BoxPoint(0,0),
  178.                            BoxSize(INT_MAX, INT_MAX)), 
  179.           GC gc = 0, 
  180.           bool context_selected = false) const;
  181.  
  182.     // Print box; Header/trailer must be pre-/postfixed
  183.     virtual void _print(ostream& os, 
  184.             const BoxRegion& region, 
  185.             const PrintGC& gc) const = 0;
  186.  
  187.     // Print Header/trailer
  188.     static void _printHeader(ostream& os, 
  189.                  const BoxRegion& region, 
  190.                  const PrintGC& gc);
  191.     static void _printTrailer(ostream& os, 
  192.                   const BoxRegion& region, 
  193.                   const PrintGC& gc);
  194.  
  195.     // Custom function: print box with header and trailer
  196.     void print(ostream& os = cout,
  197.            BoxRegion region = 
  198.                BoxRegion(BoxPoint(0,0), BoxSize(0,0)),
  199.            const PrintGC& gc = PostScriptPrintGC()) const
  200.     {
  201.     region.space(X) = max(region.space(X), size(X));
  202.     region.space(Y) = max(region.space(Y), size(Y));
  203.  
  204.     _printHeader(os, region, gc);
  205.     _print(os, region, gc);
  206.     _printTrailer(os, region, gc);
  207.     }
  208.  
  209.     // Check for equality
  210.     bool operator == (const Box& b) const;
  211.     bool operator != (const Box& b) const { return !(operator == (b)); }
  212.  
  213.     // Check class
  214.     virtual bool isStringBox() const  { return false; }
  215.     virtual bool isListBox() const    { return false; }
  216.     virtual bool isDummyBox() const   { return false; }
  217.  
  218.     // Tag a node
  219.     // Usage: box = box->tag(...)
  220.     virtual Box *tag(Data *data, DataLink *dl = 0);
  221.  
  222.     // Return tag attributes for a point (No point: outermost)
  223.     BoxRegion region(BoxPoint p = BoxPoint(-1,-1)) const;   // current region
  224.     Data *data(BoxPoint p = BoxPoint(-1,-1)) const;         // current data
  225.     string name(BoxPoint p = BoxPoint(-1,-1)) const;        // current name
  226.     bool selected(BoxPoint p = BoxPoint(-1,-1)) const;      // Flag: selected?
  227.     string info(BoxPoint p = BoxPoint(-1,-1)) const;        // Debugging info
  228.  
  229.     // Return the box that is to be matched
  230.     virtual const Box& matchMe() const { return *this; }
  231.  
  232.     // Search functions
  233.  
  234.     // Count MatchBoxes
  235.     virtual void countMatchBoxes(int[]) const {}
  236.  
  237.     // Return TagBox for a point (No Punkt: outermost)
  238.     virtual const TagBox *findTag(const BoxPoint&) const 
  239.     { 
  240.     return 0;
  241.     }
  242.     const TagBox *findTag() const
  243.     {
  244.     return findTag(BoxPoint(-1, -1));
  245.     }
  246.  
  247.     // Debugging
  248.     // Send box to stream
  249.     friend ostream& operator << (ostream& s, const Box& b);
  250.  
  251.     // Invariant check
  252.     virtual bool OK() const
  253.     {
  254.     assert (_links > 0);
  255.     assert (_type != 0);
  256.     return true;
  257.     }
  258. };
  259.  
  260. #endif // _DDD_Box_h
  261. // DON'T ADD ANYTHING BEHIND THIS #endif
  262.