CD/PC Actual Thematic 7: Programming/CDAT7.iso/demos/VisualAge for Java 2.0 Entry/setup/data1.cab/ide-e/IDE/cache/ZNH1CU

Java Class File | 1998-09-16 | 3.6 KB | 129 lines

package com.sun.java.swing;

import java.io.Serializable;

public class SizeRequirements implements Serializable {
   public int minimum;
   public int preferred;
   public int maximum;
   public float alignment;

   public SizeRequirements() {
      this.minimum = 0;
      this.preferred = 0;
      this.maximum = 0;
      this.alignment = 0.5F;
   }

   public SizeRequirements(int min, int pref, int max, float a) {
      this.minimum = min;
      this.preferred = pref;
      this.maximum = max;
      this.alignment = a > 1.0F ? 1.0F : (a < 0.0F ? 0.0F : a);
   }

   public static void calculateAlignedPositions(int allocated, SizeRequirements total, SizeRequirements[] children, int[] offsets, int[] spans) {
      int totalAscent = (int)((float)allocated * total.alignment);
      int totalDescent = allocated - totalAscent;

      for(int i = 0; i < children.length; ++i) {
         SizeRequirements req = children[i];
         int maxAscent = (int)((float)req.maximum * req.alignment);
         int maxDescent = req.maximum - maxAscent;
         int ascent = Math.min(totalAscent, maxAscent);
         int descent = Math.min(totalDescent, maxDescent);
         offsets[i] = totalAscent - ascent;
         spans[i] = (int)Math.min((long)ascent + (long)descent, 2147483647L);
      }

   }

   public static void calculateTiledPositions(int allocated, SizeRequirements total, SizeRequirements[] children, int[] offsets, int[] spans) {
      if (allocated > total.preferred) {
         expandedTile(allocated, total, children, offsets, spans);
      } else {
         compressedTile(allocated, total, children, offsets, spans);
      }

   }

   private static void compressedTile(int allocated, SizeRequirements total, SizeRequirements[] request, int[] offsets, int[] spans) {
      int totalPlay = Math.min(total.preferred - allocated, total.preferred - total.minimum);
      float factor = total.preferred - total.minimum == 0 ? 0.0F : (float)totalPlay / (float)(total.preferred - total.minimum);
      int totalOffset = 0;

      for(int i = 0; i < spans.length; ++i) {
         offsets[i] = totalOffset;
         SizeRequirements req = request[i];
         int play = (int)(factor * (float)(req.preferred - req.minimum));
         spans[i] = req.preferred - play;
         totalOffset = (int)Math.min((long)totalOffset + (long)spans[i], 2147483647L);
      }

   }

   private static void expandedTile(int allocated, SizeRequirements total, SizeRequirements[] request, int[] offsets, int[] spans) {
      int totalPlay = Math.min(allocated - total.preferred, total.maximum - total.preferred);
      float factor = total.maximum - total.preferred == 0 ? 0.0F : (float)totalPlay / (float)(total.maximum - total.preferred);
      int totalOffset = 0;

      for(int i = 0; i < spans.length; ++i) {
         offsets[i] = totalOffset;
         SizeRequirements req = request[i];
         int play = (int)(factor * (float)(req.maximum - req.preferred));
         spans[i] = (int)Math.min((long)req.preferred + (long)play, 2147483647L);
         totalOffset = (int)Math.min((long)totalOffset + (long)spans[i], 2147483647L);
      }

   }

   public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] children) {
      SizeRequirements totalAscent = new SizeRequirements();
      SizeRequirements totalDescent = new SizeRequirements();

      for(int i = 0; i < children.length; ++i) {
         SizeRequirements req = children[i];
         int ascent = (int)(req.alignment * (float)req.minimum);
         int descent = req.minimum - ascent;
         totalAscent.minimum = Math.max(ascent, totalAscent.minimum);
         totalDescent.minimum = Math.max(descent, totalDescent.minimum);
         ascent = (int)(req.alignment * (float)req.preferred);
         descent = req.preferred - ascent;
         totalAscent.preferred = Math.max(ascent, totalAscent.preferred);
         totalDescent.preferred = Math.max(descent, totalDescent.preferred);
         ascent = (int)(req.alignment * (float)req.maximum);
         descent = req.maximum - ascent;
         totalAscent.maximum = Math.max(ascent, totalAscent.maximum);
         totalDescent.maximum = Math.max(descent, totalDescent.maximum);
      }

      int min = (int)Math.min((long)totalAscent.minimum + (long)totalDescent.minimum, 2147483647L);
      int pref = (int)Math.min((long)totalAscent.preferred + (long)totalDescent.preferred, 2147483647L);
      int max = (int)Math.min((long)totalAscent.maximum + (long)totalDescent.maximum, 2147483647L);
      float alignment = 0.0F;
      if (min > 0) {
         alignment = (float)totalAscent.minimum / (float)min;
         alignment = alignment > 1.0F ? 1.0F : (alignment < 0.0F ? 0.0F : alignment);
      }

      return new SizeRequirements(min, pref, max, alignment);
   }

   public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] children) {
      SizeRequirements total = new SizeRequirements();

      for(int i = 0; i < children.length; ++i) {
         SizeRequirements req = children[i];
         total.minimum = (int)Math.min((long)total.minimum + (long)req.minimum, 2147483647L);
         total.preferred = (int)Math.min((long)total.preferred + (long)req.preferred, 2147483647L);
         total.maximum = (int)Math.min((long)total.maximum + (long)req.maximum, 2147483647L);
      }

      return total;
   }

   public String toString() {
      return "[" + this.minimum + "," + this.preferred + "," + this.maximum + "]@" + this.alignment;
   }
}