home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / StringSpinner.java < prev    next >
Text File  |  1998-02-26  |  6KB  |  201 lines

  1. /*
  2.  * @(#)StringSpinner.java    1.12 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.  
  27.  
  28. /**
  29.  * A typein field for an integer, where the integers are named.
  30.  * <p>
  31.  * Warning: serialized objects of this class will not be compatible with
  32.  * future swing releases.  The current serialization support is appropriate
  33.  * for short term storage or RMI between Swing1.0 applications.  It will
  34.  * not be possible to load serialized Swing1.0 objects with future releases
  35.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  36.  * baseline for the serialized form of Swing objects.
  37.  *
  38.  * @author James Gosling
  39.  */
  40. public class StringSpinner extends Spinner {
  41.     private String names[];
  42.     private String typed = null;
  43.  
  44.     public StringSpinner(int init, String t, String[] names) {
  45.         super(init, t);
  46.         this.names = names;
  47.         setMinimum(0);
  48.         setMaximum(names.length-1);
  49.         setWrap(true);
  50.     updateUI();
  51.     }
  52.  
  53. //     public Dimension getMinimumSize() {
  54. //         if (d == null) {
  55. //             fm = getFontMetrics(getFont());
  56. //             int w = 0;
  57. //             for (int i = names.length; --i>=0; ) {
  58. //                 int tw = fm.stringWidth(names[i]);
  59. //                 if (tw>w) w = tw;
  60. //             }
  61. //             if (txt!=null) w+=fm.stringWidth(txt);
  62. //             d = new Dimension(w+8, fm.getHeight()+8);
  63. //             ascent = fm.getAscent();
  64. //         }
  65. //         return d;
  66. //     }
  67.     public String[] getNameArray() {return names;}
  68.  
  69.     public String getValueName() {return names[value];}
  70.  
  71.     public String getTypedString() {return typed;}
  72.  
  73.  
  74. //     protected void  processKeyEvent(KeyEvent e){
  75. //         if (e.getID() != e.KEY_PRESSED) return;
  76. //         if (e.isActionKey())
  77. //             switch(e.getKeyCode()) {
  78. //             case e.VK_DOWN:    setValue(value-1); break;
  79. //                 case e.VK_UP:      setValue(value+1); break;
  80. //             }
  81. //         else {
  82. //             int c = e.getKeyChar();
  83. //             if (040<c && c<0177) {
  84. //                 typed = typed != null ? typed + (char) c
  85. //                     : String.valueOf((char)c);
  86. //                 resynctyped();
  87. //             }
  88. //             else switch(c) {
  89. //                 case 0177:
  90. //                 case '\b':
  91. //                     if (typed!=null)
  92. //                         if (typed.length()<=0) typed = null;
  93. //                         else typed = typed.substring(0,typed.length()-1);
  94. //                     resynctyped();
  95. //                     break;
  96. //             }
  97. //         }
  98. //         return;
  99. //     }
  100.     private void resynctyped() {
  101.         if (typed==null) {
  102.       //setValue(0);
  103.       //repaint();
  104.         } else {
  105.             int len = typed.length();
  106.             for(int i = 0; i<names.length; i++)
  107.                 if (typed.regionMatches(true,0,names[i],0,len)) {
  108.                     setValue(i);
  109.                     repaint();
  110.                     return;
  111.                 }
  112.             if (len>1) typed = typed.substring(0,len-1);
  113.             else typed = null;
  114.             resynctyped();
  115.         }
  116.     }
  117. //     public void paint(Graphics g) {
  118. //         if (d == null) getMinimumSize(); //Force computation of ascent
  119.  
  120. //     g.setColor(Color.white);
  121. //     g.drawRect(0,0,d.width-1,d.height-1);
  122. //     g.setColor(Color.black);
  123. //     g.drawLine(0,0,0,d.height-1);
  124. //     g.drawLine(1,0,1,d.height-3); 
  125. //     g.drawLine(1,0,d.width,0);
  126. //     g.drawLine(1,1,d.width-2,1);
  127. //     g.setColor(Color.white);
  128. //     g.fillRect(3,3,d.width-5,d.height-5);
  129.  
  130.  
  131. //     if (haveFocus) 
  132. //       {
  133. //         g.setColor(new Color(0,0,150));
  134. //         g.fillRect(4, 4, d.width-7, d.height-7);
  135. //         g.setColor(Color.white);
  136. //       }
  137. //     else
  138. //       {
  139. //         g.setColor(Color.black);
  140. //       }
  141. //     String s = names[value];
  142. //     if (txt != null) s += txt;
  143. //         if (typed==null)
  144. //       {
  145. //         g.drawString(s, 4, ascent + 4);
  146. //       }
  147. //     else 
  148. //       {
  149. //             g.setColor(Color.lightGray);
  150. //             g.drawString(s, 4, ascent+4);
  151. //             g.setColor(Color.white);
  152. //             g.drawString(s.substring(0,typed.length()), 4, ascent+4);
  153. //       }
  154. //     }
  155.  
  156. //     protected void processFocusEvent(FocusEvent e){
  157. //         typed = null;
  158. //         super.processFocusEvent(e);
  159. //     }
  160.  
  161.   public void keyPressed(KeyEvent e)
  162.   {
  163.     if (e.isActionKey())
  164.       switch(e.getKeyCode()) {
  165.       case e.VK_DOWN:    setValue(value-1); break;
  166.       case e.VK_UP:      setValue(value+1); break;
  167.       }
  168.     else {
  169.       int c = e.getKeyChar();
  170.       if (040<c && c<0177) {
  171.     typed = typed != null ? typed + (char) c
  172.       : String.valueOf((char)c);
  173.     resynctyped();
  174.       }
  175.       else switch(c) {
  176.       case 0177:
  177.       case '\b':
  178.     if (typed!=null)
  179.       if (typed.length()<=0) typed = null;
  180.       else typed = typed.substring(0,typed.length()-1);
  181.     resynctyped();
  182.     break;
  183.       }
  184.     }
  185.     return;
  186.   }
  187.  
  188.   public void focusGained(FocusEvent e) 
  189.   {
  190.     typed = null;
  191.     repaint();
  192.     super.focusGained(e);
  193.   }
  194.   public void focusLost(FocusEvent e)
  195.   {
  196.     typed = null;
  197.     repaint();
  198.     super.focusLost(e);
  199.   }
  200. }
  201.