home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Sample.bin / ReportLayout.java < prev    next >
Text File  |  1998-11-05  |  8KB  |  202 lines
  1. // Copyright (c) 1997, 1998 Symantec, Inc. All Rights Reserved.
  2.  
  3. import java.awt.LayoutManager;
  4. import java.awt.Component;
  5. import java.awt.Container;
  6. import java.awt.Dimension;
  7. import java.awt.Insets;
  8. import java.util.Vector;
  9. import java.util.Enumeration;
  10.  
  11. /*
  12. This class implements a simple LayoutManager.
  13. It is used to lay out the report elements in the ReportViewFrame.
  14. There are three component placement strings:
  15. PLACE_SAME          - Place the component in the same spot as the previous component.
  16.                       Used for the first component to lay out, too.
  17. PLACE_NEW_LINE      - Place the component on the next line with regular line spacing.
  18. PLACE_NEW_LINE_BREAK- Place the component on the next line with little or no spacing.
  19. Note: Often layout managers call the component's getPreferredSize() method to
  20. get the size of the component, but here we just use the size as originally 
  21. laid out by the user.
  22. */
  23. public class ReportLayout implements LayoutManager {
  24.     // Add types
  25.     public static final String PLACE_NEW_LINE = "New";
  26.     public static final String PLACE_NEW_LINE_BREAK = "Break";
  27.     public static final String PLACE_SAME = "Spot";
  28.     // Tuning consts
  29.     static final int SPACE_BETWEEN_LINES = 10;
  30.     static final int SPACE_BETWEEN_LINE_BREAKS = 0;
  31.  
  32.     Container container;    // the Container being laid out
  33.     int insetH;             // amount to inset the components by, Horz
  34.     int insetV;             // amount to inset the components by, Vert
  35.     Vector components;      // (of ComponentRecord) the components to lay out
  36.  
  37.     /*
  38.     Constructs a ReportLayout object for the given container with the 
  39.     specified component insets.
  40.     */
  41.     public ReportLayout(Container container, int insetHorz, int insetVert) {
  42.         this.container = container;
  43.         insetH = insetHorz;
  44.         insetV = insetVert;
  45.         components = new Vector();
  46.             //{{INIT_CONTROLS
  47.         //}}
  48. }
  49.  
  50.     // Standard LayoutManger Inteface Method
  51.     public void addLayoutComponent( String placement,   // PLACE_
  52.                                     Component comp) {
  53.         // maintain my list of components to lay out
  54.         components.addElement(new ComponentRecord(comp, placement));
  55.     }
  56.  
  57.     // Standard LayoutManger Inteface Method
  58.     public void removeLayoutComponent(Component comp) {
  59.         // find the ComponentRecord with the given component...
  60.         for(Enumeration e = components.elements(); e.hasMoreElements();) {
  61.             ComponentRecord c = (ComponentRecord)e.nextElement();
  62.             if(c.comp == comp) {
  63.                 // ...and remove it
  64.                 components.removeElement(this);
  65.                 return;
  66.             }
  67.         }
  68.     }
  69.  
  70.     // Standard LayoutManger Inteface Method
  71.     public void layoutContainer(Container parent) {
  72.         // determine position of managed components
  73.         Dimension dim = determineLayout(parent);
  74.         // loop through managed components, laying them out
  75.         for(Enumeration e = components.elements(); e.hasMoreElements();) {
  76.             ComponentRecord c = (ComponentRecord)e.nextElement();
  77.             // only handle visible ones
  78.             if(c.comp.isVisible()) {
  79.                 // move to previously determined position
  80.                 c.setBounds();
  81.             }
  82.         }
  83.         // resize the parent container, as needed
  84.         Dimension curDim = parent.getSize();
  85.         if(true || dim.height != curDim.height || dim.width != curDim.width) {
  86.             parent.setSize(dim.width, dim.height);
  87.         }
  88.     }
  89.  
  90.     // Standard LayoutManger Inteface Method
  91.     public Dimension minimumLayoutSize(Container parent) {
  92.         // determine position of managed components
  93.         return determineLayout(parent);
  94.     }
  95.  
  96.     // Standard LayoutManger Inteface Method
  97.     public Dimension preferredLayoutSize(Container parent) {
  98.         // determine position of managed components
  99.         return determineLayout(parent);
  100.     }
  101.  
  102.     // Determines position of managed components
  103.     private Dimension determineLayout(Container parent) {
  104.         Insets insets = parent.getInsets();
  105.         int lineX = insetH + insets.left;
  106.         int lineY = insetV + insets.top;
  107.         int lineWidth = 0;
  108.         int lineHeight = 0;
  109.         int maxWidth = lineX;       // max width required to contain components
  110.         int maxHeight = lineY;      // max height required to contain components
  111.         ComponentRecord c = null;   // component currently being laid out
  112.         // loop through managed components, determining where each should be
  113.         for(Enumeration e = components.elements(); e.hasMoreElements();) {
  114.             c = (ComponentRecord)e.nextElement();
  115.             // if this component is invisible, skip and move to next one
  116.             if(c.comp.isVisible() == false) {
  117.                 continue;
  118.             }
  119.             // size the component
  120.             c.determineSize();
  121.  
  122.             // lay out the component
  123.             if(c.placement.equalsIgnoreCase(PLACE_SAME)) {
  124.                 // Placement: Same Position
  125.                 c.x = lineX;
  126.                 if(c.width > lineWidth) {
  127.                     lineWidth = c.width;
  128.                 }
  129.                 c.y = lineY;
  130.                 if(c.height > lineHeight) {
  131.                     lineHeight = c.height;
  132.                 }
  133.             } else {
  134.                 if(c.placement.equalsIgnoreCase(PLACE_NEW_LINE_BREAK)) {
  135.                     // Placement: Line Break
  136.                     lineY += lineHeight + SPACE_BETWEEN_LINE_BREAKS;
  137.                 } else {
  138.                     // Placement: New Line (also default action if unrecognized placement)
  139.                     lineY += lineHeight + SPACE_BETWEEN_LINES;
  140.                 }
  141.                 c.y = lineY;
  142.                 c.x = lineX;
  143.                 lineWidth = c.width;
  144.                 lineHeight = c.height;
  145.             } 
  146.  
  147.             // maintain maxWidth and maxHeight
  148.             maxWidth = Math.max(maxWidth, lineX + lineWidth);
  149.             maxHeight = Math.max(maxHeight, lineY + lineHeight);
  150.         }
  151.         // calc final container size, accounting for layout inset and container inset
  152.         maxWidth += insetH + insets.right;
  153.         maxHeight += insetV + insets.bottom;
  154.         // return with required container size
  155.         return new Dimension(maxWidth, maxHeight);
  156.     }
  157.  
  158.     /*
  159.     This class tracks the folling info on one component:
  160.     1) The component
  161.     2) The component's placement
  162.     3) The component's position and size
  163.     */
  164.     class ComponentRecord {
  165.         Component comp;     // the component
  166.         String placement;   // the component's placement
  167.         int x = 0;          // the component's position, X
  168.         int y = 0;          // the component's position, Y
  169.         int width = 0;      // the component's size, width
  170.         int height = 0;     // the component's size, height
  171.         /*
  172.         Constructs a ComponentRecord for the given component with the 
  173.         given placement.
  174.         */
  175.         public ComponentRecord(Component comp, String placement) {
  176.             this.comp = comp;
  177.             this.placement = placement;
  178.         }
  179.         /*
  180.         Determines the recommended size of this component.
  181.         Often layout managers call the component's getPreferredSize() method,
  182.         but here we just use the size as originally laid out by the user.
  183.         */
  184.         public void determineSize() {
  185.             // This layout manager just uses the actual sizes of the components
  186.             // doesn't call the components getPreferredSize, etc routine
  187.             Dimension dim = comp.getSize();
  188.             width = dim.width;
  189.             height = dim.height;
  190.         }
  191.         /*
  192.         Sets the component's bounds to those specified in this class.
  193.         */
  194.         public void setBounds() {
  195.             comp.setBounds(x, y, width, height);
  196.         }
  197.     }
  198.  
  199.     //{{DECLARE_CONTROLS
  200.     //}}
  201. }
  202.