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 / AlignBox.h < prev    next >
C/C++ Source or Header  |  1998-11-23  |  6KB  |  288 lines
  1. // $Id: AlignBox.h,v 1.12 1998/11/23 15:00:14 zeller Exp $
  2. // Box alignments
  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_AlignBox_h
  30. #define _DDD_AlignBox_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36.  
  37. // An AlignBox is a container for an alignment of boxes.
  38.  
  39. // A HAlignBox is a horizontal alignment (in VSL: &)
  40. // A VAlignbox is a vertical alignment (in VSL: |),
  41. // A UAlignBox places its members at the same place (in VSL: ^) 
  42. // A TAlignBox aligns its members like text blocks, from left to right
  43. // (in VSL: ~)
  44.  
  45.  
  46. #include "assert.h"
  47. #include "CompositeB.h"
  48. #include "Widget.h"
  49.  
  50.  
  51. // AlignBox
  52.  
  53. class AlignBox: public CompositeBox {
  54. public:
  55.     DECLARE_TYPE_INFO
  56.  
  57. protected:
  58.     BoxSize _corner; // Space in lower right corner
  59.  
  60.     AlignBox(const AlignBox& box):
  61.     CompositeBox(box), _corner(box._corner)
  62.     {}
  63.  
  64.     // Take size from B
  65.     void setSize(Box *b)
  66.     {
  67.     thesize()   = b->size();
  68.     theextend() = b->extend();
  69.     _corner     = b->corner();
  70.     }
  71.  
  72.     // Add a new size
  73.     virtual void addSize(Box *b) = 0;
  74.  
  75.     // Recompute size
  76.     Box *resize();
  77.  
  78.     // Add B as child
  79.     void addChild(Box *b)
  80.     {
  81.     // Add child
  82.     CompositeBox::addChild(b);
  83.  
  84.     // Set or add size
  85.     if (nchildren() == 1)
  86.         setSize(b);     // 1st child: set size
  87.     else
  88.         addSize(b);     // later child: add size
  89.     }
  90.  
  91.     // Draw it
  92.     void drawAlign(Widget w, 
  93.            const BoxRegion& r, 
  94.            const BoxRegion& exposed,
  95.            GC gc, 
  96.            bool context_selected, 
  97.            BoxDimension dimen) const;
  98.  
  99. public:
  100.     AlignBox(unsigned initialSize = 2, 
  101.     char *t = "AlignBox"):
  102.     CompositeBox(initialSize, t), _corner(0,0)
  103.     {}
  104.  
  105.     BoxSize corner() const { return _corner; }
  106.  
  107.     AlignBox& operator += (Box *b)
  108.     {
  109.     addChild(b);
  110.     return *this;
  111.     }
  112. };
  113.  
  114.  
  115. // HAlignBox
  116.  
  117. class HAlignBox: public AlignBox {
  118. public:
  119.     DECLARE_TYPE_INFO
  120.  
  121. protected:
  122.     HAlignBox(const HAlignBox& box):
  123.     AlignBox(box)
  124.     {}
  125.  
  126.     void dump(ostream& s) const { dumpComposite(s, " & "); }
  127.  
  128.     virtual void _draw(Widget w, 
  129.                const BoxRegion& r, 
  130.                const BoxRegion& exposed,
  131.                GC gc, bool context_selected) const
  132.     { 
  133.     drawAlign(w, r, exposed, gc, context_selected, X); 
  134.     }
  135.  
  136. public:
  137.     HAlignBox(unsigned initialSize = 2, char *t = "HAlignBox"):
  138.     AlignBox(initialSize, t) 
  139.     {}
  140.  
  141.     Box *dup() const  { return new HAlignBox(*this); }
  142.     Box *dup0() const { return new HAlignBox; }
  143.  
  144.     void addSize(Box *b);
  145.  
  146.     virtual void _print(ostream& os, 
  147.             const BoxRegion& region, 
  148.             const PrintGC& gc) const;
  149.  
  150.     HAlignBox& operator &= (Box *b)
  151.     {
  152.     addChild(b);
  153.     return *this;
  154.     }
  155. };
  156.  
  157.  
  158. // VAlignBox
  159.  
  160. class VAlignBox: public AlignBox {
  161. public:
  162.     DECLARE_TYPE_INFO
  163.  
  164. private:
  165.     void _draw(Widget w, 
  166.            const BoxRegion& r, 
  167.            const BoxRegion& exposed,
  168.            GC gc, 
  169.            bool context_selected) const
  170.     { 
  171.     drawAlign(w, r, exposed, gc, context_selected, Y); 
  172.     }
  173.  
  174. protected:
  175.     VAlignBox(const VAlignBox& box):
  176.     AlignBox(box)
  177.     {}
  178.  
  179.     void dump(ostream& s) const { dumpComposite(s, " | "); }
  180.  
  181. public:
  182.     VAlignBox(unsigned initialSize = 2, char *t = "VAlignBox"):
  183.         AlignBox(initialSize, t)
  184.     {}
  185.  
  186.     Box *dup() const  { return new VAlignBox(*this); }
  187.     Box *dup0() const { return new VAlignBox; }
  188.  
  189.     void addSize(Box *b);
  190.  
  191.     virtual void _print(ostream& os, 
  192.             const BoxRegion& region, 
  193.             const PrintGC& gc) const;
  194.  
  195.     VAlignBox& operator |= (Box *b)
  196.     {
  197.     addChild(b);
  198.     return *this;
  199.     }
  200. };
  201.  
  202.  
  203. // UAlignBox
  204.  
  205. class UAlignBox: public AlignBox {
  206. public:
  207.     DECLARE_TYPE_INFO
  208.  
  209. private:
  210.     void _draw(Widget w, 
  211.            const BoxRegion& region, 
  212.            const BoxRegion& exposed,
  213.            GC gc, 
  214.            bool context_selected) const;
  215.  
  216. protected:
  217.     UAlignBox(const UAlignBox& box):
  218.     AlignBox(box)
  219.     {}
  220.  
  221.     void dump(ostream& s) const { dumpComposite(s, " ^ "); }
  222.  
  223. public:
  224.     UAlignBox(unsigned initialSize = 2, char *t = "UAlignBox"):
  225.     AlignBox(initialSize, t)
  226.     {}
  227.  
  228.     Box *dup() const  { return new UAlignBox(*this); }
  229.     Box *dup0() const { return new UAlignBox; }
  230.  
  231.     void addSize(Box *b);
  232.  
  233.     virtual void _print(ostream& os, 
  234.             const BoxRegion& region, 
  235.             const PrintGC& gc) const;
  236.  
  237.     UAlignBox& operator ^= (Box *b)
  238.     {
  239.     addChild(b);
  240.     return *this;
  241.     }
  242. };
  243.  
  244.  
  245. // TAlignBox
  246.  
  247. class TAlignBox: public AlignBox {
  248. public:
  249.     DECLARE_TYPE_INFO
  250.  
  251. private:
  252.     void _draw(Widget w, 
  253.            const BoxRegion& region, 
  254.            const BoxRegion& exposed,
  255.            GC gc, 
  256.            bool context_selected) const;
  257.  
  258. protected:
  259.     TAlignBox(const TAlignBox& box):
  260.     AlignBox(box)
  261.     {}
  262.  
  263.     void dump(ostream& s) const { dumpComposite(s, " ~ "); }
  264.  
  265. public:
  266.     TAlignBox(unsigned initialSize = 2, char *t = "TAlignBox"):
  267.     AlignBox(initialSize, t)
  268.     {}
  269.  
  270.     Box *dup() const  { return new TAlignBox(*this); }
  271.     Box *dup0() const { return new TAlignBox; }
  272.  
  273.     void addSize(Box *b);
  274.  
  275.     virtual void _print(ostream& os, 
  276.             const BoxRegion& region, 
  277.             const PrintGC& gc) const;
  278.  
  279.     TAlignBox& operator &= (Box *b)
  280.     {
  281.     addChild(b);
  282.     return *this;
  283.     }
  284. };
  285.  
  286.  
  287. #endif
  288.