home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / Spinner.java < prev    next >
Text File  |  1998-02-26  |  11KB  |  426 lines
  1. /*
  2.  * @(#)Spinner.java    1.18 02/02/98
  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 java.awt.event.*;
  25. import java.io.*;
  26. import com.sun.java.swing.*;
  27. import com.sun.java.swing.border.*;
  28. import com.sun.java.swing.plaf.*;
  29.  
  30.  
  31. /**
  32.  * A typein field for an integer.
  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.  * @author James Gosling
  42.  */
  43. public class Spinner extends JComponent implements Adjustable, AdjustmentListener, 
  44.                                                    FocusListener, KeyListener, MouseListener
  45. {
  46.   protected String txt;
  47.   protected Dimension d;
  48.   protected int ascent;
  49.   protected int value;
  50.   protected boolean haveFocus = false;
  51.   protected int minValue = 0;
  52.   protected int maxValue = 0x7FFFFF;
  53.   protected FontMetrics fm;
  54.   protected int nDigits = 4;
  55.   protected int digitsTyped = 0;
  56.   protected boolean wraps = false;
  57.   protected boolean borderPainted = false;
  58.   protected Color backgroundColor = Color.white;
  59.   protected int leadingPad = -1;
  60.   
  61.   public boolean wrapped= false;
  62.  
  63.   public Spinner(int startValue, String t) {
  64. //     txt = t;
  65. //     value = init;
  66. //     enableEvents(AWTEvent.FOCUS_EVENT_MASK
  67. //          |AWTEvent.KEY_EVENT_MASK|AWTEvent.MOUSE_EVENT_MASK);
  68. //     updateUI();
  69.     init(startValue,t);
  70.   }
  71.   public Spinner(int startValue) {
  72. //     value = init;
  73. //     enableEvents(AWTEvent.FOCUS_EVENT_MASK
  74. //          |AWTEvent.KEY_EVENT_MASK|AWTEvent.MOUSE_EVENT_MASK);
  75. //     updateUI();
  76.     init(startValue,null);
  77.   }
  78.  
  79.   private void init(int startValue, String t)
  80.   {
  81.     txt = t;
  82.     value = startValue;
  83.     addFocusListener(this);
  84.     addMouseListener(this);
  85.     addKeyListener(this);
  86.     updateUI();
  87.   }
  88.   
  89.   
  90.   /**
  91.    * Gets the current value of the Spinner object.
  92.    */
  93.   public int getValue() { return value; }
  94.   
  95.   /**
  96.    * Sets the current value of the Spinner. This
  97.    * value must be within the range defined by the minimum and
  98.    * maximum values for this object.
  99.    * @param v the current value
  100.    */
  101.   public void setValue(int v) {
  102.     if(wraps)
  103.       {
  104.     if((v<minValue) || (v>maxValue)) wrapped = true;
  105.     else wrapped = false;
  106.       }
  107.     while (v < minValue)
  108.       if(wraps) v = maxValue+1-minValue+v;
  109.       else v = minValue;
  110.     while (v > maxValue)
  111.       if(wraps) v = minValue-1+v-maxValue;
  112.       else v = maxValue;
  113.     if (value!=v){
  114.       value = v;
  115.       if (isShowing()) repaint(20);
  116.       fireAdjustmentValueChanged(new AdjustmentEvent
  117.                       (this, 0, AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED, v));
  118.     }
  119.   }
  120.   /** A Spinner for which wrapping is true wraps around to the minimum
  121.     value when the maximum value is exceeded, and vice versa.
  122.     @param w true if wrapping is to be enabled, false if the
  123.     value is to be clamped. */
  124.   public void setWrap(boolean w) { wraps = w; }
  125.   public boolean getWrap() { return wraps; }
  126.   /** A Spinner can have a string associated with it, which is placed
  127.     at the right of the number
  128.     @param s the new text value */
  129.   public void setText(String s) { txt = s; if(isShowing()) repaint(20); }
  130.   public String getText() { return txt; }
  131.   public void setFont(Font f) {
  132.     if (f != getFont()) {
  133.       super.setFont(f);
  134.       d = null;
  135.       invalidate();
  136.     }
  137.   }
  138.   public void setDigits(int n) { nDigits = n; }
  139.   public int getDigits() { return nDigits; }
  140.   public void setLeadingPad(int newPad) {leadingPad = newPad;}
  141.   public int getLeadingPad() {return leadingPad;}
  142.   public void setBackgroundColor(Color newColor) {backgroundColor = newColor;}
  143.   public Color getBackgroundColor() {return backgroundColor;}
  144.   
  145. //   protected void processFocusEvent(FocusEvent e){
  146. //     if ((e.getID()==e.FOCUS_GAINED)!=haveFocus) {
  147. //       haveFocus = !haveFocus;
  148. //       if(haveFocus)
  149. //     {
  150. //       digitsTyped = 0;
  151. //     }
  152. //       repaint();
  153. //     }
  154. //   }
  155. //   protected void  processKeyEvent(KeyEvent e){
  156. //     if (e.getID() != e.KEY_PRESSED) return;
  157. //     if (e.isActionKey())
  158. //       switch(e.getKeyCode()) {
  159. //       case e.VK_DOWN:    setValue(value-1); break;
  160. //       case e.VK_UP:      setValue(value+1); break;
  161. //       }
  162. //     else {
  163. //       int c = e.getKeyChar();
  164. //       if ('0'<=c && c<='9') {
  165.     
  166. //     if(digitsTyped < nDigits)
  167. //       {
  168. //         if (digitsTyped == 0)
  169. //           {
  170. //         value = 0;
  171. //           }
  172. //         int nv = value*10+c-'0';
  173. //         if ((nv<=maxValue) && (nv>=minValue))
  174. //           {
  175. //         // int M = 10;
  176. //         //           int Mn = 0;
  177. //         //           while ((Mn=M*10)<nv && Mn>M) M = Mn;
  178. //         //           nv = nv%M;
  179. //         setValue(nv);
  180. //         digitsTyped++;
  181. //           }
  182. //       }
  183. //       }
  184. //       else switch(c) {
  185. //       case 0177:
  186. //       case '\b': 
  187. //     if((value/10) >= 1)
  188. //       {
  189. //         setValue(value/10);
  190. //         digitsTyped--;
  191. //       }
  192. //     break;
  193. //       case '-': setValue(-value); break;
  194. //     //case '\t': transferFocus(); break;
  195. //       }
  196. //     }
  197. //     return;
  198. //   }
  199. //   protected void processMouseEvent(MouseEvent e){
  200. //     if (e.getID()==e.MOUSE_PRESSED) requestFocus();
  201. //     return;
  202. //   }
  203.   
  204.  
  205.   public boolean isFocusTraversable() { return true; }
  206.  
  207.   public boolean hasFocus() {return haveFocus;}
  208.  
  209.   public boolean isBorderPainted() {return borderPainted;}
  210.  
  211.   public void setBorderPainted(boolean b) 
  212.   {
  213.     borderPainted = b;
  214.     invalidate();
  215.   }
  216.  
  217.     /**
  218.      * Paint the spinner's border if BorderPainted property is true.
  219.      * 
  220.      * @see #paint
  221.      * @see #setBorder
  222.      */
  223.     protected void paintBorder(Graphics g) {    
  224.         if (isBorderPainted()) {
  225.             super.paintBorder(g);
  226.         }
  227.     }
  228.  
  229.   /** Spinners can both send and recieve AdjustmentEvents -- they
  230.    * can be cascaded together for situations where there are multiple
  231.    * ways to enter the same value (popup menu or typin number) */
  232.   public void adjustmentValueChanged(AdjustmentEvent e) {
  233.     setValue(e.getValue());
  234.   }
  235.   
  236.   /**
  237.    * Sets the minimum value of the Spinner.
  238.    * @param min the minimum value
  239.    */
  240.   public void setMinimum(int min){minValue=min;setValue(value);}
  241.   
  242.   /**
  243.    * Gets the minimum value of the Spinner.
  244.    */
  245.   public int getMinimum(){return minValue;}
  246.   
  247.   /**
  248.    * Sets the maximum value of the Spinner.
  249.    * @param max the maximum value
  250.    */
  251.   public void setMaximum(int max){maxValue=max;setValue(value);}
  252.   
  253.   /**
  254.    * Gets the maximum value of the Spinner.
  255.    */
  256.   public int getMaximum(){return maxValue;}
  257.   
  258.   /**
  259.    * Add a listener to recieve adjustment events when the value of
  260.    * the Spinner changes.
  261.    * @param l the listener to recieve events
  262.    * @see AdjustmentEvent
  263.    */
  264.   public void addAdjustmentListener(AdjustmentListener l){
  265.       listenerList.add(AdjustmentListener.class, l);
  266.   }
  267.   
  268.   /**
  269.    * Removes an adjustment listener.
  270.    * @param l the listener being removed
  271.    * @see AdjustmentEvent
  272.    */
  273.   public void removeAdjustmentListener(AdjustmentListener l){
  274.       listenerList.remove(AdjustmentListener.class, l);
  275.   }
  276.   
  277.     /*
  278.      * Notify all listeners that have registered interest for
  279.      * notification on this event type.  The event instance 
  280.      * is lazily created using the parameters passed into 
  281.      * the fire method.
  282.      * @see EventListenerList
  283.      */
  284.     protected void fireAdjustmentValueChanged(AdjustmentEvent e) {
  285.     // Guaranteed to return a non-null array
  286.     Object[] listeners = listenerList.getListenerList();
  287.     // Process the listeners last to first, notifying
  288.     // those that are interested in this event
  289.     for (int i = listeners.length-2; i>=0; i-=2) {
  290.         if (listeners[i]==AdjustmentListener.class) {
  291.         // Lazily create the event:
  292.         // if (e == null)
  293.         // e = new WindowEvent(this.popup, event.getID());
  294.         ((AdjustmentListener)listeners[i+1]).adjustmentValueChanged(e);
  295.         }           
  296.     }
  297.     }    
  298.  
  299.   /**
  300.    * Does nothing -- part of the Adjustable interface.
  301.    * @param u the unit increment
  302.    */
  303.   public void setUnitIncrement(int u){};
  304.   
  305.   /**
  306.    * Does nothing -- part of the Adjustable interface.
  307.    */
  308.   public int getUnitIncrement(){return 1;};
  309.   
  310.   /**
  311.    * Does nothing -- part of the Adjustable interface.
  312.    * @param b the block increment
  313.    */
  314.   public void setBlockIncrement(int b){};
  315.   
  316.   /**
  317.    * Does nothing -- part of the Adjustable interface.
  318.    */
  319.   public int getBlockIncrement(){return 1;}
  320.   
  321.   /**
  322.    * Does nothing -- part of the Adjustable interface.
  323.    * @param v the length of the indicator
  324.    */
  325.   public void setVisibleAmount(int v){};
  326.   
  327.   /**
  328.    * Does nothing -- part of the Adjustable interface.
  329.    */
  330.   public int getVisibleAmount(){return 1;}
  331.   
  332.   /**
  333.    * Does nothing -- part of the Adjustable interface.
  334.    */
  335.   public int getOrientation(){return HORIZONTAL;};
  336.  
  337.   public void keyTyped(KeyEvent e) {}
  338.   public void keyPressed(KeyEvent e)
  339.   {
  340.     if (e.isActionKey())
  341.       switch(e.getKeyCode()) {
  342.       case e.VK_DOWN:    setValue(value-1); break;
  343.       case e.VK_UP:      setValue(value+1); break;
  344.       }
  345.     else {
  346.       int c = e.getKeyChar();
  347.       if ('0'<=c && c<='9') {
  348.     
  349.     if(digitsTyped < nDigits)
  350.       {
  351.         if (digitsTyped == 0)
  352.           {
  353.         value = 0;
  354.           }
  355.         int nv = value*10+c-'0';
  356.         if ((nv<=maxValue) && (nv>=minValue))
  357.           {
  358.         // int M = 10;
  359.         //           int Mn = 0;
  360.         //           while ((Mn=M*10)<nv && Mn>M) M = Mn;
  361.         //           nv = nv%M;
  362.         setValue(nv);
  363.         digitsTyped++;
  364.           }
  365.       }
  366.       }
  367.       else switch(c) {
  368.       case 0177:
  369.       case '\b': 
  370.     setValue(value/10);
  371.     digitsTyped--;
  372.     break;
  373.       case '-': setValue(-value); break;
  374.     //case '\t': transferFocus(); break;
  375.       }
  376.     }
  377.     return;
  378.   }
  379.   public void keyReleased(KeyEvent e){}
  380.   public void mouseClicked(MouseEvent e) {}
  381.   public void mousePressed(MouseEvent e) 
  382.   {
  383.     requestFocus();
  384.     return;
  385.   }
  386.   public void mouseReleased(MouseEvent e) {}
  387.   public void mouseEntered(MouseEvent e) {}
  388.   public void mouseExited(MouseEvent e) {}
  389.   public void focusGained(FocusEvent e) 
  390.   {
  391.     haveFocus = true;
  392.     digitsTyped = 0;
  393.     repaint();
  394.   }
  395.   public void focusLost(FocusEvent e)
  396.   {
  397.     haveFocus = false;
  398.     repaint();
  399.   }
  400.  
  401.  
  402.  
  403.     
  404.   public SpinnerUI getUI() {
  405.     return (SpinnerUI)ui;
  406.   }
  407.      
  408.   public void setUI(SpinnerUI ui) {
  409.     super.setUI(ui);
  410.   }
  411.  
  412.   public void updateUI() 
  413.   {
  414.     setUI((SpinnerUI)UIManager.getUI(this));
  415.   }
  416.  
  417.     /**
  418.      * @return "SpinnerUI"
  419.      * @see JComponent#getUIClassID
  420.      * @see UIDefaults#getUI
  421.      */
  422.     public String getUIClassID() {
  423.     return "SpinnerUI";
  424.     }
  425. }
  426.