home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / BasicProgressBarUI.java < prev    next >
Text File  |  1998-02-26  |  8KB  |  288 lines
  1. /*
  2.  * @(#)BasicProgressBarUI.java    1.32 98/02/02
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing.plaf.basic;
  22.  
  23. import java.awt.*;
  24. import com.sun.java.swing.*;
  25. import com.sun.java.swing.event.*;
  26. import com.sun.java.swing.plaf.*;
  27. import java.io.Serializable;
  28.  
  29.  
  30. /**
  31.  * A Basic L&F implementation of ProgressBarUI.  This implementation 
  32.  * is both the view and the controller.
  33.  * <p>
  34.  * Warning: serialized objects of this class will not be compatible with
  35.  * future swing releases.  The current serialization support is appropriate
  36.  * for short term storage or RMI between Swing1.0 applications.  It will
  37.  * not be possible to load serialized Swing1.0 objects with future releases
  38.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  39.  * baseline for the serialized form of Swing objects.
  40.  *
  41.  * @version 1.32 02/02/98
  42.  * @author Rob Davis
  43.  */
  44. public class BasicProgressBarUI extends ProgressBarUI
  45.     implements ChangeListener, Serializable
  46. {
  47.     int cachedPercent;
  48.  
  49.     static final Dimension PREFERRED_INNER_HORIZONTAL = new Dimension(146, 12);
  50.     static final Dimension PREFERRED_INNER_VERTICAL = new Dimension(12, 146);
  51.  
  52.  
  53.     public static ComponentUI createUI(JComponent x) {
  54.     return new BasicProgressBarUI();
  55.     }
  56.  
  57.     public void installUI(JComponent c) {
  58.     installDefaults(c);
  59.     installListeners(c);
  60.     }
  61.  
  62.     public void uninstallUI(JComponent c) {
  63.     uninstallListeners(c);
  64.     }
  65.   
  66.     protected void installDefaults(JComponent c) {
  67.     c.setOpaque(true);
  68.     LookAndFeel.installColorsAndFont(c, "ProgressBar.background",
  69.                      "ProgressBar.foreground",
  70.                      "ProgressBar.font");
  71.     }
  72.     
  73.     protected void installListeners(JComponent c) {
  74.     ((JProgressBar)c).addChangeListener(this);
  75.     }    
  76.  
  77.     protected void uninstallListeners(JComponent c) {
  78.     ((JProgressBar)c).removeChangeListener(this);
  79.     }
  80.     
  81.     protected void uninstallDefaults(JComponent c) {
  82.     }
  83.  
  84.     public Dimension getPreferredInnerHorizontal() {
  85.     return PREFERRED_INNER_HORIZONTAL;
  86.     }
  87.  
  88.     public Dimension getPreferredInnerVertical() {
  89.     return PREFERRED_INNER_VERTICAL;
  90.     }
  91.  
  92.  
  93.     public int getCachedPercent() {
  94.     return cachedPercent;
  95.     }
  96.  
  97.     public void setCachedPercent(int cachedPercent) {
  98.     this.cachedPercent = cachedPercent;
  99.     }
  100.  
  101.     public int getBorderBuffer() {
  102.     return 0;
  103.     }
  104.  
  105.     public int getCellLength() {
  106.     return 1;
  107.     }
  108.  
  109.     public int getCellSpacing() {
  110.     return 0;
  111.     }
  112.  
  113.     public void paint(Graphics g, JComponent c) {
  114.     Dimension size = c.getSize();
  115.     Dimension innerSize;
  116.     int x, y;
  117.     JProgressBar progressBar = (JProgressBar)c;
  118.     BoundedRangeModel model = progressBar.getModel();
  119.     Insets b = getBorderInsets(c);
  120.  
  121.     x = b.left;
  122.     y = b.top;
  123.     innerSize = new Dimension(size.width - (b.left + b.right),
  124.                   size.height - (b.top + b.bottom));
  125.  
  126.     g.setColor(c.getForeground());
  127.     if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
  128.         long span = model.getMaximum() - model.getMinimum();
  129.         int length = 0;
  130.         if (span != 0) {
  131.             double bigWidth = innerSize.width;
  132.             double bigValue = model.getValue();
  133.             double fractionComplete = bigValue / span;
  134.             length = (int)(bigWidth * fractionComplete);
  135.         }
  136.         int max = (x + length) - getCellLength();
  137.         int current;
  138.         int increment = getCellLength() + getCellSpacing();
  139.  
  140.         for (current = x; current < max; current += increment) {
  141.         g.fillRect(current, y, getCellLength(), innerSize.height);
  142.         }
  143.  
  144.         if (length == innerSize.width && current < (innerSize.width + x)) {
  145.         g.fillRect(current, y, (innerSize.width + x) - current,
  146.                innerSize.height);
  147.         }
  148.     } else {
  149.         int span = model.getMaximum() - model.getMinimum();
  150.         int length = 0;
  151.         if (span != 0) {
  152.             double bigHeight = innerSize.height;
  153.             double bigValue = model.getValue();
  154.             double fractionComplete = bigValue / span;
  155.             length = (int)(bigHeight * fractionComplete);
  156.         }
  157.  
  158.         int min = ((innerSize.height - 1) + y) - length;
  159.         int current;
  160.         int increment = getCellLength() + getCellSpacing();
  161.  
  162.         for (current = (innerSize.height - 1) + (y - getCellLength());
  163.          current > min; current -= increment)
  164.         {
  165.         g.fillRect(x, current, innerSize.width, getCellLength());
  166.         }
  167.  
  168.         if (length == innerSize.height) {
  169.         g.fillRect(x, y, innerSize.width, (current + getCellLength()) - y);
  170.         }
  171.     }
  172.  
  173.     if (progressBar.isBorderPainted()) {
  174.         BasicGraphicsUtils.drawEtchedRect(g, 0,0, size.width, size.height);
  175.     }
  176.     }
  177.  
  178.     public Dimension getPreferredSize(JComponent c) {
  179.     Dimension    size;
  180.     JProgressBar    progressBar = (JProgressBar)c;
  181.     Insets        border = getBorderInsets(c);
  182.  
  183.     if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
  184.         size = new Dimension(getPreferredInnerHorizontal());
  185.     } else {
  186.         size = new Dimension(getPreferredInnerVertical());
  187.     }
  188.  
  189.     size.width += border.left + border.right;
  190.     size.height += border.top + border.bottom;
  191.     return size;
  192.     }
  193.  
  194.     public Dimension getMinimumSize(JComponent c) {
  195.     Dimension pref = getPreferredSize(c);
  196.     JProgressBar progressBar = (JProgressBar)c;
  197.     if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
  198.         pref.width = 0;
  199.     } else {
  200.         pref.height = 0;
  201.     }
  202.     return pref;
  203.     }
  204.  
  205.     public Dimension getMaximumSize(JComponent c) {
  206.     Dimension pref = getPreferredSize(c);
  207.     JProgressBar progressBar = (JProgressBar)c;
  208.     if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
  209.         pref.width = Short.MAX_VALUE;
  210.     } else {
  211.         pref.height = Short.MAX_VALUE;
  212.     }
  213.     return pref;
  214.     }
  215.  
  216.     public Insets getInsets(JComponent c) {
  217.     return getBorderInsets(c);
  218.     }
  219.  
  220.     public Insets getBorderInsets(JComponent c) {
  221.     JProgressBar bar = (JProgressBar)c;
  222.  
  223.     if (bar.isBorderPainted()) {
  224.         Insets retval;
  225.         retval = (Insets)BasicGraphicsUtils.getEtchedInsets().clone();
  226.         retval.left += getBorderBuffer();
  227.         retval.right += getBorderBuffer();
  228.         retval.top += getBorderBuffer();
  229.         retval.bottom += getBorderBuffer();
  230.  
  231.         return retval;
  232.     } else {
  233.         return new Insets(0, 0, 0, 0);
  234.     }
  235.     }
  236.  
  237.  
  238.     //
  239.     // Change Events
  240.     //
  241.  
  242.     public void stateChanged(ChangeEvent e) {
  243.     JProgressBar        bar = (JProgressBar)e.getSource();
  244.     BoundedRangeModel    model = bar.getModel();
  245.     int newRange = model.getMaximum() - model.getMinimum();
  246.     int newPercent = (newRange > 0) ? ((100 * model.getValue()) / newRange) : 0;
  247.  
  248.     if (newPercent != getCachedPercent()) {
  249.         int minPercent = Math.min(newPercent, getCachedPercent());
  250.         int maxPercent = Math.max(newPercent, getCachedPercent());
  251.  
  252.         Insets border = getBorderInsets(bar);
  253.         Dimension size = bar.getSize();
  254.  
  255.         if (bar.getOrientation() == JProgressBar.HORIZONTAL) {
  256.         int length = (size.width - (border.right + border.left));
  257.         int x1 = (minPercent * length) / 100;
  258.         int x2 = (maxPercent * length) / 100;
  259.         int cell = getCellLength() + getCellSpacing();
  260.  
  261.         x1 = ((x1 / cell) * cell) + border.left;
  262.         x2 = (((x2 / cell) + 1) * cell) + border.left;
  263.  
  264.                 // Pending(arnaud). Jeff, something is wrong with
  265.                 // that code. (x2 - x1) might be too small.
  266.                 // calling repaint() for now
  267.                 bar.repaint();
  268.                 //bar.repaint(x1-1, border.top, (x2 - x1) + 2,
  269.                 //size.height - (border.top + border.bottom));
  270.         } else {
  271.         int length = size.height - (border.bottom + border.top);
  272.         int y1 = (maxPercent * length) / 100;
  273.         int y2 = (minPercent * length) / 100;
  274.         int cell = getCellLength() + getCellSpacing();
  275.  
  276.         y1 = (length - (((y1 / cell) + 1) * cell)) + border.top;
  277.         y2 = (length - ((y2 / cell) * cell)) + border.top;
  278.  
  279.         bar.repaint(border.left, y1-1,
  280.                 size.width - (border.left + border.right),
  281.                 (y2 - y1)+2);
  282.         }
  283.  
  284.         setCachedPercent(newPercent);
  285.     }
  286.     }
  287. }
  288.