home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / javax / swing / GroupLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  13.0 KB  |  600 lines
  1. package javax.swing;
  2.  
  3. import java.awt.Component;
  4. import java.awt.Container;
  5. import java.awt.Dimension;
  6. import java.awt.Insets;
  7. import java.awt.LayoutManager2;
  8. import java.util.ArrayList;
  9. import java.util.HashMap;
  10. import java.util.HashSet;
  11. import java.util.List;
  12. import java.util.Map;
  13. import java.util.Set;
  14.  
  15. public class GroupLayout implements LayoutManager2 {
  16.    private static final int MIN_SIZE = 0;
  17.    private static final int PREF_SIZE = 1;
  18.    private static final int MAX_SIZE = 2;
  19.    private static final int SPECIFIC_SIZE = 3;
  20.    private static final int UNSET = Integer.MIN_VALUE;
  21.    public static final int DEFAULT_SIZE = -1;
  22.    public static final int PREFERRED_SIZE = -2;
  23.    private boolean autocreatePadding;
  24.    private boolean autocreateContainerPadding;
  25.    private Group horizontalGroup;
  26.    private Group verticalGroup;
  27.    private Map<Component, ComponentInfo> componentInfos;
  28.    private Container host;
  29.    private Set<Spring> tmpParallelSet;
  30.    private boolean springsChanged;
  31.    private boolean isValid;
  32.    private boolean hasPreferredPaddingSprings;
  33.    private LayoutStyle layoutStyle;
  34.    private boolean honorsVisibility;
  35.  
  36.    private static void checkSize(int var0, int var1, int var2, boolean var3) {
  37.       checkResizeType(var0, var3);
  38.       if (!var3 && var1 < 0) {
  39.          throw new IllegalArgumentException("Pref must be >= 0");
  40.       } else {
  41.          if (var3) {
  42.             checkResizeType(var1, true);
  43.          }
  44.  
  45.          checkResizeType(var2, var3);
  46.          checkLessThan(var0, var1);
  47.          checkLessThan(var1, var2);
  48.       }
  49.    }
  50.  
  51.    private static void checkResizeType(int var0, boolean var1) {
  52.       if (var0 < 0 && (var1 && var0 != -1 && var0 != -2 || !var1 && var0 != -2)) {
  53.          throw new IllegalArgumentException("Invalid size");
  54.       }
  55.    }
  56.  
  57.    private static void checkLessThan(int var0, int var1) {
  58.       if (var0 >= 0 && var1 >= 0 && var0 > var1) {
  59.          throw new IllegalArgumentException("Following is not met: min<=pref<=max");
  60.       }
  61.    }
  62.  
  63.    public GroupLayout(Container var1) {
  64.       if (var1 == null) {
  65.          throw new IllegalArgumentException("Container must be non-null");
  66.       } else {
  67.          this.honorsVisibility = true;
  68.          this.host = var1;
  69.          this.setHorizontalGroup(this.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, true));
  70.          this.setVerticalGroup(this.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, true));
  71.          this.componentInfos = new HashMap();
  72.          this.tmpParallelSet = new HashSet();
  73.       }
  74.    }
  75.  
  76.    public void setHonorsVisibility(boolean var1) {
  77.       if (this.honorsVisibility != var1) {
  78.          this.honorsVisibility = var1;
  79.          this.springsChanged = true;
  80.          this.isValid = false;
  81.          this.invalidateHost();
  82.       }
  83.  
  84.    }
  85.  
  86.    public boolean getHonorsVisibility() {
  87.       return this.honorsVisibility;
  88.    }
  89.  
  90.    public void setHonorsVisibility(Component var1, Boolean var2) {
  91.       if (var1 == null) {
  92.          throw new IllegalArgumentException("Component must be non-null");
  93.       } else {
  94.          this.getComponentInfo(var1).setHonorsVisibility(var2);
  95.          this.springsChanged = true;
  96.          this.isValid = false;
  97.          this.invalidateHost();
  98.       }
  99.    }
  100.  
  101.    public void setAutoCreateGaps(boolean var1) {
  102.       if (this.autocreatePadding != var1) {
  103.          this.autocreatePadding = var1;
  104.          this.invalidateHost();
  105.       }
  106.  
  107.    }
  108.  
  109.    public boolean getAutoCreateGaps() {
  110.       return this.autocreatePadding;
  111.    }
  112.  
  113.    public void setAutoCreateContainerGaps(boolean var1) {
  114.       if (this.autocreateContainerPadding != var1) {
  115.          this.autocreateContainerPadding = var1;
  116.          this.horizontalGroup = this.createTopLevelGroup(this.getHorizontalGroup());
  117.          this.verticalGroup = this.createTopLevelGroup(this.getVerticalGroup());
  118.          this.invalidateHost();
  119.       }
  120.  
  121.    }
  122.  
  123.    public boolean getAutoCreateContainerGaps() {
  124.       return this.autocreateContainerPadding;
  125.    }
  126.  
  127.    public void setHorizontalGroup(Group var1) {
  128.       if (var1 == null) {
  129.          throw new IllegalArgumentException("Group must be non-null");
  130.       } else {
  131.          this.horizontalGroup = this.createTopLevelGroup(var1);
  132.          this.invalidateHost();
  133.       }
  134.    }
  135.  
  136.    private Group getHorizontalGroup() {
  137.       byte var1 = 0;
  138.       if (this.horizontalGroup.springs.size() > 1) {
  139.          var1 = 1;
  140.       }
  141.  
  142.       return (Group)this.horizontalGroup.springs.get(var1);
  143.    }
  144.  
  145.    public void setVerticalGroup(Group var1) {
  146.       if (var1 == null) {
  147.          throw new IllegalArgumentException("Group must be non-null");
  148.       } else {
  149.          this.verticalGroup = this.createTopLevelGroup(var1);
  150.          this.invalidateHost();
  151.       }
  152.    }
  153.  
  154.    private Group getVerticalGroup() {
  155.       byte var1 = 0;
  156.       if (this.verticalGroup.springs.size() > 1) {
  157.          var1 = 1;
  158.       }
  159.  
  160.       return (Group)this.verticalGroup.springs.get(var1);
  161.    }
  162.  
  163.    private Group createTopLevelGroup(Group var1) {
  164.       SequentialGroup var2 = this.createSequentialGroup();
  165.       if (this.getAutoCreateContainerGaps()) {
  166.          var2.addSpring(new ContainerAutoPreferredGapSpring(this));
  167.          var2.addGroup(var1);
  168.          var2.addSpring(new ContainerAutoPreferredGapSpring(this));
  169.       } else {
  170.          var2.addGroup(var1);
  171.       }
  172.  
  173.       return var2;
  174.    }
  175.  
  176.    public SequentialGroup createSequentialGroup() {
  177.       return new SequentialGroup(this);
  178.    }
  179.  
  180.    public ParallelGroup createParallelGroup() {
  181.       return this.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING);
  182.    }
  183.  
  184.    public ParallelGroup createParallelGroup(Alignment var1) {
  185.       return this.createParallelGroup(var1, true);
  186.    }
  187.  
  188.    public ParallelGroup createParallelGroup(Alignment var1, boolean var2) {
  189.       return (ParallelGroup)(var1 == javax.swing.GroupLayout.Alignment.BASELINE ? new BaselineGroup(this, var2) : new ParallelGroup(this, var1, var2));
  190.    }
  191.  
  192.    public ParallelGroup createBaselineGroup(boolean var1, boolean var2) {
  193.       return new BaselineGroup(this, var1, var2);
  194.    }
  195.  
  196.    public void linkSize(Component... var1) {
  197.       this.linkSize(0, var1);
  198.       this.linkSize(1, var1);
  199.    }
  200.  
  201.    public void linkSize(int var1, Component... var2) {
  202.       if (var2 == null) {
  203.          throw new IllegalArgumentException("Components must be non-null");
  204.       } else {
  205.          for(int var3 = var2.length - 1; var3 >= 0; --var3) {
  206.             Component var4 = var2[var3];
  207.             if (var2[var3] == null) {
  208.                throw new IllegalArgumentException("Components must be non-null");
  209.             }
  210.  
  211.             this.getComponentInfo(var4);
  212.          }
  213.  
  214.          byte var6;
  215.          if (var1 == 0) {
  216.             var6 = 0;
  217.          } else {
  218.             if (var1 != 1) {
  219.                throw new IllegalArgumentException("Axis must be one of SwingConstants.HORIZONTAL or SwingConstants.VERTICAL");
  220.             }
  221.  
  222.             var6 = 1;
  223.          }
  224.  
  225.          LinkInfo var7 = this.getComponentInfo(var2[var2.length - 1]).getLinkInfo(var6);
  226.  
  227.          for(int var5 = var2.length - 2; var5 >= 0; --var5) {
  228.             var7.add(this.getComponentInfo(var2[var5]));
  229.          }
  230.  
  231.          this.invalidateHost();
  232.       }
  233.    }
  234.  
  235.    public void replace(Component var1, Component var2) {
  236.       if (var1 != null && var2 != null) {
  237.          if (this.springsChanged) {
  238.             this.registerComponents(this.horizontalGroup, 0);
  239.             this.registerComponents(this.verticalGroup, 1);
  240.          }
  241.  
  242.          ComponentInfo var3 = (ComponentInfo)this.componentInfos.remove(var1);
  243.          if (var3 == null) {
  244.             throw new IllegalArgumentException("Component must already exist");
  245.          } else {
  246.             this.host.remove(var1);
  247.             if (var2.getParent() != this.host) {
  248.                this.host.add(var2);
  249.             }
  250.  
  251.             var3.setComponent(var2);
  252.             this.componentInfos.put(var2, var3);
  253.             this.invalidateHost();
  254.          }
  255.       } else {
  256.          throw new IllegalArgumentException("Components must be non-null");
  257.       }
  258.    }
  259.  
  260.    public void setLayoutStyle(LayoutStyle var1) {
  261.       this.layoutStyle = var1;
  262.       this.invalidateHost();
  263.    }
  264.  
  265.    public LayoutStyle getLayoutStyle() {
  266.       return this.layoutStyle;
  267.    }
  268.  
  269.    private LayoutStyle getLayoutStyle0() {
  270.       LayoutStyle var1 = this.getLayoutStyle();
  271.       if (var1 == null) {
  272.          var1 = LayoutStyle.getInstance();
  273.       }
  274.  
  275.       return var1;
  276.    }
  277.  
  278.    private void invalidateHost() {
  279.       if (this.host instanceof JComponent) {
  280.          ((JComponent)this.host).revalidate();
  281.       } else {
  282.          this.host.invalidate();
  283.       }
  284.  
  285.       this.host.repaint();
  286.    }
  287.  
  288.    public void addLayoutComponent(String var1, Component var2) {
  289.    }
  290.  
  291.    public void removeLayoutComponent(Component var1) {
  292.       ComponentInfo var2 = (ComponentInfo)this.componentInfos.remove(var1);
  293.       if (var2 != null) {
  294.          var2.dispose();
  295.          this.springsChanged = true;
  296.          this.isValid = false;
  297.       }
  298.  
  299.    }
  300.  
  301.    public Dimension preferredLayoutSize(Container var1) {
  302.       this.checkParent(var1);
  303.       this.prepare(1);
  304.       return this.adjustSize(this.horizontalGroup.getPreferredSize(0), this.verticalGroup.getPreferredSize(1));
  305.    }
  306.  
  307.    public Dimension minimumLayoutSize(Container var1) {
  308.       this.checkParent(var1);
  309.       this.prepare(0);
  310.       return this.adjustSize(this.horizontalGroup.getMinimumSize(0), this.verticalGroup.getMinimumSize(1));
  311.    }
  312.  
  313.    public void layoutContainer(Container var1) {
  314.       this.prepare(3);
  315.       Insets var2 = var1.getInsets();
  316.       int var3 = var1.getWidth() - var2.left - var2.right;
  317.       int var4 = var1.getHeight() - var2.top - var2.bottom;
  318.       boolean var5 = this.isLeftToRight();
  319.       if (this.getAutoCreateGaps() || this.getAutoCreateContainerGaps() || this.hasPreferredPaddingSprings) {
  320.          this.calculateAutopadding(this.horizontalGroup, 0, 3, 0, var3);
  321.          this.calculateAutopadding(this.verticalGroup, 1, 3, 0, var4);
  322.       }
  323.  
  324.       this.horizontalGroup.setSize(0, 0, var3);
  325.       this.verticalGroup.setSize(1, 0, var4);
  326.  
  327.       for(ComponentInfo var7 : this.componentInfos.values()) {
  328.          var7.setBounds(var2, var3, var5);
  329.       }
  330.  
  331.    }
  332.  
  333.    public void addLayoutComponent(Component var1, Object var2) {
  334.    }
  335.  
  336.    public Dimension maximumLayoutSize(Container var1) {
  337.       this.checkParent(var1);
  338.       this.prepare(2);
  339.       return this.adjustSize(this.horizontalGroup.getMaximumSize(0), this.verticalGroup.getMaximumSize(1));
  340.    }
  341.  
  342.    public float getLayoutAlignmentX(Container var1) {
  343.       this.checkParent(var1);
  344.       return 0.5F;
  345.    }
  346.  
  347.    public float getLayoutAlignmentY(Container var1) {
  348.       this.checkParent(var1);
  349.       return 0.5F;
  350.    }
  351.  
  352.    public void invalidateLayout(Container var1) {
  353.       this.checkParent(var1);
  354.       synchronized(var1.getTreeLock()) {
  355.          this.isValid = false;
  356.       }
  357.    }
  358.  
  359.    private void prepare(int var1) {
  360.       boolean var2 = false;
  361.       if (!this.isValid) {
  362.          this.isValid = true;
  363.          this.horizontalGroup.setSize(0, Integer.MIN_VALUE, Integer.MIN_VALUE);
  364.          this.verticalGroup.setSize(1, Integer.MIN_VALUE, Integer.MIN_VALUE);
  365.  
  366.          for(ComponentInfo var4 : this.componentInfos.values()) {
  367.             if (var4.updateVisibility()) {
  368.                var2 = true;
  369.             }
  370.  
  371.             var4.clearCachedSize();
  372.          }
  373.       }
  374.  
  375.       if (this.springsChanged) {
  376.          this.registerComponents(this.horizontalGroup, 0);
  377.          this.registerComponents(this.verticalGroup, 1);
  378.       }
  379.  
  380.       if (this.springsChanged || var2) {
  381.          this.checkComponents();
  382.          this.horizontalGroup.removeAutopadding();
  383.          this.verticalGroup.removeAutopadding();
  384.          if (this.getAutoCreateGaps()) {
  385.             this.insertAutopadding(true);
  386.          } else if (this.hasPreferredPaddingSprings || this.getAutoCreateContainerGaps()) {
  387.             this.insertAutopadding(false);
  388.          }
  389.  
  390.          this.springsChanged = false;
  391.       }
  392.  
  393.       if (var1 != 3 && (this.getAutoCreateGaps() || this.getAutoCreateContainerGaps() || this.hasPreferredPaddingSprings)) {
  394.          this.calculateAutopadding(this.horizontalGroup, 0, var1, 0, 0);
  395.          this.calculateAutopadding(this.verticalGroup, 1, var1, 0, 0);
  396.       }
  397.  
  398.    }
  399.  
  400.    private void calculateAutopadding(Group var1, int var2, int var3, int var4, int var5) {
  401.       var1.unsetAutopadding();
  402.       switch (var3) {
  403.          case 0:
  404.             var5 = var1.getMinimumSize(var2);
  405.             break;
  406.          case 1:
  407.             var5 = var1.getPreferredSize(var2);
  408.             break;
  409.          case 2:
  410.             var5 = var1.getMaximumSize(var2);
  411.       }
  412.  
  413.       var1.setSize(var2, var4, var5);
  414.       var1.calculateAutopadding(var2);
  415.    }
  416.  
  417.    private void checkComponents() {
  418.       for(ComponentInfo var2 : this.componentInfos.values()) {
  419.          if (var2.horizontalSpring == null) {
  420.             throw new IllegalStateException(javax.swing.GroupLayout.ComponentInfo.access$000(var2) + " is not attached to a horizontal group");
  421.          }
  422.  
  423.          if (var2.verticalSpring == null) {
  424.             throw new IllegalStateException(javax.swing.GroupLayout.ComponentInfo.access$000(var2) + " is not attached to a vertical group");
  425.          }
  426.       }
  427.  
  428.    }
  429.  
  430.    private void registerComponents(Group var1, int var2) {
  431.       List var3 = var1.springs;
  432.  
  433.       for(int var4 = var3.size() - 1; var4 >= 0; --var4) {
  434.          Spring var5 = (Spring)var3.get(var4);
  435.          if (var5 instanceof ComponentSpring) {
  436.             ((ComponentSpring)var5).installIfNecessary(var2);
  437.          } else if (var5 instanceof Group) {
  438.             this.registerComponents((Group)var5, var2);
  439.          }
  440.       }
  441.  
  442.    }
  443.  
  444.    private Dimension adjustSize(int var1, int var2) {
  445.       Insets var3 = this.host.getInsets();
  446.       return new Dimension(var1 + var3.left + var3.right, var2 + var3.top + var3.bottom);
  447.    }
  448.  
  449.    private void checkParent(Container var1) {
  450.       if (var1 != this.host) {
  451.          throw new IllegalArgumentException("GroupLayout can only be used with one Container at a time");
  452.       }
  453.    }
  454.  
  455.    private ComponentInfo getComponentInfo(Component var1) {
  456.       ComponentInfo var2 = (ComponentInfo)this.componentInfos.get(var1);
  457.       if (var2 == null) {
  458.          var2 = new ComponentInfo(this, var1);
  459.          this.componentInfos.put(var1, var2);
  460.          if (var1.getParent() != this.host) {
  461.             this.host.add(var1);
  462.          }
  463.       }
  464.  
  465.       return var2;
  466.    }
  467.  
  468.    private void insertAutopadding(boolean var1) {
  469.       this.horizontalGroup.insertAutopadding(0, new ArrayList(1), new ArrayList(1), new ArrayList(1), new ArrayList(1), var1);
  470.       this.verticalGroup.insertAutopadding(1, new ArrayList(1), new ArrayList(1), new ArrayList(1), new ArrayList(1), var1);
  471.    }
  472.  
  473.    private boolean areParallelSiblings(Component var1, Component var2, int var3) {
  474.       ComponentInfo var4 = this.getComponentInfo(var1);
  475.       ComponentInfo var5 = this.getComponentInfo(var2);
  476.       ComponentSpring var6;
  477.       ComponentSpring var7;
  478.       if (var3 == 0) {
  479.          var6 = var4.horizontalSpring;
  480.          var7 = var5.horizontalSpring;
  481.       } else {
  482.          var6 = var4.verticalSpring;
  483.          var7 = var5.verticalSpring;
  484.       }
  485.  
  486.       Set var8 = this.tmpParallelSet;
  487.       var8.clear();
  488.  
  489.       for(Spring var9 = ((Spring)var6).getParent(); var9 != null; var9 = var9.getParent()) {
  490.          var8.add(var9);
  491.       }
  492.  
  493.       for(Spring var10 = ((Spring)var7).getParent(); var10 != null; var10 = var10.getParent()) {
  494.          if (var8.contains(var10)) {
  495.             var8.clear();
  496.  
  497.             while(var10 != null) {
  498.                if (var10 instanceof ParallelGroup) {
  499.                   return true;
  500.                }
  501.  
  502.                var10 = var10.getParent();
  503.             }
  504.  
  505.             return false;
  506.          }
  507.       }
  508.  
  509.       var8.clear();
  510.       return false;
  511.    }
  512.  
  513.    private boolean isLeftToRight() {
  514.       return this.host.getComponentOrientation().isLeftToRight();
  515.    }
  516.  
  517.    public String toString() {
  518.       if (this.springsChanged) {
  519.          this.registerComponents(this.horizontalGroup, 0);
  520.          this.registerComponents(this.verticalGroup, 1);
  521.       }
  522.  
  523.       StringBuffer var1 = new StringBuffer();
  524.       var1.append("HORIZONTAL\n");
  525.       this.createSpringDescription(var1, this.horizontalGroup, "  ", 0);
  526.       var1.append("\nVERTICAL\n");
  527.       this.createSpringDescription(var1, this.verticalGroup, "  ", 1);
  528.       return var1.toString();
  529.    }
  530.  
  531.    private void createSpringDescription(StringBuffer var1, Spring var2, String var3, int var4) {
  532.       String var5 = "";
  533.       String var6 = "";
  534.       if (var2 instanceof ComponentSpring) {
  535.          ComponentSpring var7 = (ComponentSpring)var2;
  536.          var5 = Integer.toString(var7.getOrigin()) + " ";
  537.          String var8 = var7.getComponent().getName();
  538.          if (var8 != null) {
  539.             var5 = "name=" + var8 + ", ";
  540.          }
  541.       }
  542.  
  543.       if (var2 instanceof AutoPreferredGapSpring) {
  544.          AutoPreferredGapSpring var10 = (AutoPreferredGapSpring)var2;
  545.          var6 = ", userCreated=" + var10.getUserCreated() + ", matches=" + var10.getMatchDescription();
  546.       }
  547.  
  548.       var1.append(var3 + var2.getClass().getName() + " " + Integer.toHexString(var2.hashCode()) + " " + var5 + ", size=" + var2.getSize() + ", alignment=" + var2.getAlignment() + " prefs=[" + var2.getMinimumSize(var4) + " " + var2.getPreferredSize(var4) + " " + var2.getMaximumSize(var4) + var6 + "]\n");
  549.       if (var2 instanceof Group) {
  550.          List var11 = ((Group)var2).springs;
  551.          var3 = var3 + "  ";
  552.  
  553.          for(int var12 = 0; var12 < var11.size(); ++var12) {
  554.             this.createSpringDescription(var1, (Spring)var11.get(var12), var3, var4);
  555.          }
  556.       }
  557.  
  558.    }
  559.  
  560.    // $FF: synthetic method
  561.    static boolean access$202(GroupLayout var0, boolean var1) {
  562.       return var0.springsChanged = var1;
  563.    }
  564.  
  565.    // $FF: synthetic method
  566.    static boolean access$302(GroupLayout var0, boolean var1) {
  567.       return var0.hasPreferredPaddingSprings = var1;
  568.    }
  569.  
  570.    // $FF: synthetic method
  571.    static void access$500(int var0, int var1, int var2, boolean var3) {
  572.       checkSize(var0, var1, var2, var3);
  573.    }
  574.  
  575.    // $FF: synthetic method
  576.    static ComponentInfo access$600(GroupLayout var0, Component var1) {
  577.       return var0.getComponentInfo(var1);
  578.    }
  579.  
  580.    // $FF: synthetic method
  581.    static Container access$700(GroupLayout var0) {
  582.       return var0.host;
  583.    }
  584.  
  585.    // $FF: synthetic method
  586.    static LayoutStyle access$800(GroupLayout var0) {
  587.       return var0.getLayoutStyle0();
  588.    }
  589.  
  590.    // $FF: synthetic method
  591.    static boolean access$900(GroupLayout var0) {
  592.       return var0.isLeftToRight();
  593.    }
  594.  
  595.    // $FF: synthetic method
  596.    static boolean access$1000(GroupLayout var0, Component var1, Component var2, int var3) {
  597.       return var0.areParallelSiblings(var1, var2, var3);
  598.    }
  599. }
  600.