home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / JFC.bin / MoneyChooser.java < prev    next >
Encoding:
Java Source  |  1998-06-30  |  23.0 KB  |  906 lines
  1. package com.sun.java.swing;
  2.  
  3. import com.sun.java.swing.border.*;
  4. import com.sun.java.swing.basic.*;
  5.  
  6. import java.awt.*;
  7. import java.awt.event.*;
  8. import java.io.*;
  9. import java.util.*;
  10. import java.text.*;
  11. import com.sun.java.swing.plaf.*;
  12.  
  13. public class MoneyChooser extends Container implements ActionListener
  14. {
  15.   protected JButton calc;
  16.   protected JPopupMenu popup;
  17.   protected Locale myLocale;
  18.   protected NumberFormat myFormat;
  19.   protected Calculator calculator;
  20.   //  protected MoneyField moneyfield;
  21.   protected SpinnerHolder inputfield;
  22.   protected double totalCash = 0;
  23.   
  24.   
  25.   protected GridBagLayout layout = new GridBagLayout();
  26.   protected GridBagConstraints cons = new GridBagConstraints();
  27.   
  28.   public MoneyChooser()
  29.   {
  30.     intialize(4,Locale.getDefault());
  31.   }
  32.   public MoneyChooser(int digits)
  33.   {
  34.     intialize(digits,Locale.getDefault());
  35.     
  36.   }
  37.   public MoneyChooser(int digits, Locale aLocale)
  38.   {
  39.     intialize(digits,aLocale);
  40.   }
  41.  
  42.   private void intialize(int digits, Locale aLocale)
  43.   {
  44.     if((digits >15) || (digits < 0))
  45.       {
  46.     throw new IllegalArgumentException("int argument must be in the range 0<int<16");
  47.       }
  48.     myLocale = aLocale;
  49.     myFormat = NumberFormat.getCurrencyInstance(myLocale);
  50.     
  51. //     cons.gridx = 0;
  52. //     cons.gridy = 0;
  53. //     cons.weightx = 1;
  54. //     cons.weighty = 1;
  55. //     cons.insets = new Insets(10,10,10,10);
  56. //     setLayout(layout);
  57.  
  58. //     GridBagConstraints cons = this.cons;
  59. //     cons.insets = new Insets(0,0,0,0);
  60. //     cons.gridx = GridBagConstraints.RELATIVE;
  61.  
  62.     calc = new JButton("Calc");
  63.     calc.addActionListener(this);
  64.  
  65.     setLayout(new FlowLayout());
  66.     //moneyfield = new MoneyField(digits); 
  67.     //add(moneyfield);
  68.     inputfield = new SpinnerHolder(digits);
  69.     add(inputfield);
  70.     add(calc);
  71.   }
  72.  
  73.   //  public void getCalculatorInfo()
  74.   //{
  75.  //    int pounds;
  76. //     int pennies;
  77. //     //totalCash = ((Calculator)(popup.getComponent(0))).convertOutput();
  78. //     Float floater = new Float(totalCash*100);
  79. //     pounds = floater.intValue()/100;
  80. //     pennies = floater.intValue()%100;
  81. //     dollars.setValue(pounds);
  82. //     if(cents != null)
  83. //       {
  84. //     cents.setValue(pennies);
  85. //       }
  86.   // }
  87.  
  88.   public void setCalculatorEnable(boolean enable)
  89.   {
  90.     if(enable)
  91.       {
  92.     if(calc == null)
  93.       {
  94.         calc = new JButton("Calc");
  95.         calc.addActionListener(this);
  96.         add(calc,cons);
  97.       }
  98.       }
  99.     else
  100.       {
  101.     if(calc != null)
  102.       {
  103.         remove(calc);
  104.         calc = null;
  105.       }
  106.     popup = null;
  107.       }
  108.   }
  109.   public void setValue(double newValue)
  110.   {
  111.     totalCash = newValue;
  112.     inputfield.setNewInput(totalCash);
  113.   }
  114.   public double getValue() {return totalCash;}
  115.   public void actionPerformed(ActionEvent e) 
  116.   {
  117.     if(e.getActionCommand().equals("Calc"))
  118.       {
  119.     if(popup == null)
  120.       {
  121.         popup = new JPopupMenu();
  122.         calculator = new Calculator();
  123.         calculator.getOKButton().addActionListener(this);
  124.         popup.add(calculator);
  125.         
  126.         //Point p = calc.getLocationOnScreen();
  127.         //popup.setLocation(p.x,p.y);
  128.         //popup.setVisible(true);
  129.       }
  130.     popup.show(calc,0,0);
  131.       }
  132.     else if(e.getSource() == calculator.getOKButton())
  133.       {
  134.     popup.setVisible(false);
  135.     totalCash = calculator.convertOutput();
  136.     inputfield.setNewInput(totalCash);
  137.       }
  138.   }
  139. //   class MoneyField extends Component
  140. //   {
  141. //     private int digits;
  142. //     private int digitsTyped = 0;
  143. //     private double maxValue;
  144. //     private int ascent;
  145. //     private Dimension d;
  146. //     private FontMetrics fm;
  147. //     private boolean haveFocus= false;
  148. //     private int[][] splitArray;
  149. //     private int splitArrayLength = 0;
  150. //     private int currentRegion = -1;
  151. //     private int tempRegion = -1;
  152. //     private int maxChars = 0;
  153. //     private char splitter = '.';
  154.     
  155.  
  156. //     public MoneyField(int digits)
  157. //     {
  158. //       this.digits = digits;
  159. //       enableEvents(AWTEvent.FOCUS_EVENT_MASK|AWTEvent.KEY_EVENT_MASK
  160. //            |AWTEvent.MOUSE_EVENT_MASK|AWTEvent.MOUSE_MOTION_EVENT_MASK);
  161. //     }
  162.  
  163. //     public Dimension getPreferredSize() 
  164. //     {
  165. //       return getMinimumSize();
  166. //     }
  167. //     public Dimension getMinimumSize() 
  168. //     {
  169. //       if (d == null) 
  170. //     {
  171. //       fm = getFontMetrics(getFont());
  172. //       int w = 0;
  173. //       maxValue = Math.pow(10,digits)-.01;
  174.       
  175. //       //totalCash = 987654.32;
  176. //       String s = myFormat.format(maxValue);
  177. //       w= fm.stringWidth(s);      
  178. //       d = new Dimension(w+8, fm.getHeight()+8);
  179. //       ascent = fm.getAscent();
  180. //       maxChars = s.length();
  181.  
  182. //       int tempArray[][] = new int[s.length()][2];
  183. //       int i,j;
  184. //       j = 0;
  185. //       for(i=0; i<s.length(); i++)
  186. //         {
  187. //           if('0'>s.charAt(i) || s.charAt(i)>'9')
  188. //         {
  189. //           i++;
  190. //           if(i<s.length())
  191. //             {
  192. //               while('0'>s.charAt(i) || s.charAt(i)>'9') 
  193. //             {
  194. //               i++;
  195. //               if(i>=s.length()) {break;}
  196. //             }
  197. //             }
  198. //           i--;
  199. //           tempArray[j][0] = 4+fm.stringWidth(s.substring(0,i+1));
  200. //           tempArray[j][1] = i;
  201. //           j++;
  202. //         }
  203. //           else if(j == 0)
  204. //         {
  205. //           //System.out.println("set pre-split");
  206. //           tempArray[0][0] = 4;
  207. //           tempArray[0][1] = -1;
  208. //           j++;
  209. //         }
  210. //           else if(s.charAt(i) == '4') 
  211. //         {
  212. //           if(i+1 <s.length()) {splitter = s.charAt(i+1);}
  213. //         }
  214. //         }
  215. //       splitArray = new int[j][2];
  216. //       for(i=0; i<j; i++)
  217. //         {
  218. //           splitArray[i][0] = tempArray[i][0];
  219. //           splitArray[i][1] = tempArray[i][1];
  220. //         }
  221. //       splitArrayLength = j;
  222. //     }
  223. //       return d;
  224. //     }
  225. //     public void paint(Graphics g) 
  226. //     {
  227. //       if (d == null) getMinimumSize(); //Force computation of ascent
  228.       
  229. //       g.setColor(Color.white);
  230. //       g.drawRect(0,0,d.width-1,d.height-1);
  231. //       g.setColor(Color.black);
  232. //       g.drawLine(0,0,0,d.height-1);
  233. //       g.drawLine(1,0,1,d.height-3); 
  234. //       g.drawLine(1,0,d.width,0);
  235. //       g.drawLine(1,1,d.width-2,1);
  236. //       g.setColor(Color.white);
  237. //       g.fillRect(3,3,d.width-5,d.height-5);
  238. //       g.setColor(Color.black);
  239.       
  240.       
  241. //       String s = myFormat.format(totalCash);
  242. //       g.drawString(s, getSize().width-fm.stringWidth(s) - 4, ascent + 4);
  243.  
  244. //       if (haveFocus) 
  245. //     {
  246. //       g.setColor(new Color(0,0,150));
  247. //       if(currentRegion > -1)
  248. //         {
  249.           
  250.           
  251. //           int startPointX = splitArray[currentRegion][0];
  252. //           int stopPointX = 0;
  253. //           int startIndex = splitArray[currentRegion][1];
  254. //           int offset = maxChars - s.length();
  255. //           if(startIndex > -1)
  256. //         {
  257. //           while(startIndex-offset < 0 ) 
  258. //             {
  259. //               startIndex++;
  260. //               startPointX = startPointX + fm.charWidth('0');
  261. //             }
  262. //         }
  263. //           int stopIndex = 0;
  264. //           if(currentRegion == splitArrayLength -1)
  265. //         {
  266. //           stopPointX = d.width-4;
  267. //           stopIndex = maxChars-1;
  268. //         }
  269. //           else
  270. //         {
  271. //           stopPointX = splitArray[currentRegion+1][0];
  272. //           stopIndex = splitArray[currentRegion+1][1];
  273. //         }
  274. //           if(stopIndex-offset+1 > 0)
  275. //         {
  276. //           while(startIndex-offset+1 < 0) 
  277. //             {
  278. //               startIndex++;
  279. //               startPointX = startPointX + fm.charWidth('0');
  280. //             }
  281. //           g.fillRect(startPointX,4, stopPointX-startPointX,d.height-7);
  282. //           g.setColor(Color.white);
  283. //           g.drawString(s.substring(startIndex-offset+1,
  284. //                        stopIndex-offset+1),startPointX,ascent+4);
  285. //         }          
  286. //         }
  287. //       else
  288. //         {
  289. //           g.fillRect(4,4, d.width-7,d.height-7);
  290. //           g.setColor(Color.white);
  291. //           g.drawString(s,getSize().width-fm.stringWidth(s) - 4,ascent+4);          
  292. //         }
  293. //       g.setColor(Color.black);
  294. //     }
  295. //     } 
  296. //     public void update(Graphics g) {
  297. //       paint(g);
  298. //     }
  299. //     protected void processFocusEvent(FocusEvent e)
  300. //     {
  301. //       if ((e.getID()==e.FOCUS_GAINED)!=haveFocus) {
  302. //     haveFocus = !haveFocus;
  303. //     if(haveFocus)
  304. //       {
  305. //         digitsTyped = 0;
  306. //         currentRegion = -1;
  307. //       }
  308. //     repaint();
  309. //       }
  310. //     }
  311. //     protected void  processKeyEvent(KeyEvent e)
  312. //     {
  313. //       int c = 0;
  314. //       if (e.getID() != e.KEY_PRESSED) return;
  315. //       if (e.isActionKey())
  316. //     switch(e.getKeyCode()) {
  317. //     case e.VK_DOWN:
  318. //       totalCash = totalCash - Math.pow(10,getWeight(firstIntIndex(maxValue)));
  319. //       repaint();
  320. //       break;
  321. //     case e.VK_LEFT:
  322. //       digitsTyped = 0;
  323. //       if(currentRegion >0)
  324. //         {
  325. //           currentRegion--;
  326. //           repaint();
  327. //         }
  328. //       else
  329. //         {
  330. //           if(splitArray[splitArrayLength-1][1] != maxChars-1) {c = 1;}
  331. //           else {c = 2;}
  332. //           currentRegion = splitArrayLength-c;
  333. //           repaint();
  334. //         }
  335. //       break;
  336. //     case e.VK_UP:
  337. //       totalCash = totalCash + Math.pow(10,getWeight(firstIntIndex(maxValue)));
  338. //       repaint();
  339. //       break;
  340. //     case e.VK_RIGHT:
  341.       
  342. //       if(splitArray[splitArrayLength-1][1] != maxChars-1) {c = 1;}
  343. //       else {c = 2;}
  344. //       if(currentRegion == splitArrayLength-c)
  345. //         {
  346. //           currentRegion = 0;
  347. //         }
  348. //       else {currentRegion ++;}
  349. //       digitsTyped = 0;
  350. //       repaint();
  351. //       break;
  352. //     }
  353. //       else {
  354. //     c = e.getKeyChar();
  355. //     if ('0'<=c && c<='9') {
  356. //       //System.out.println(digitsTyped);
  357. //       //System.out.println(intsInRegion(maxValue));
  358. //       if(digitsTyped < intsInRegion(maxValue))
  359. //         {
  360. //           int i;
  361. //           if (digitsTyped == 0)
  362. //         {
  363. //           if(currentRegion >-1)
  364. //             {
  365. //               int index = firstIntIndex(totalCash);
  366. //               int weightIndex = firstIntIndex(maxValue);
  367. //               int len = intsInRegion(totalCash);
  368. //               String s = myFormat.format(totalCash);
  369. //               //System.out.println(s);
  370. //               for(i=0; i<len; i++)
  371. //             {
  372. //               //System.out.println((double)(s.charAt(index)-'0'));
  373. //               totalCash = totalCash - ((double)(s.charAt(index)-'0'))*Math.pow(10,getWeight(weightIndex));
  374. //               //System.out.println(myFormat.format(totalCash));
  375. //               index--;
  376. //               weightIndex--;
  377. //             }
  378. //             }
  379. //           else {totalCash = 0.00;}
  380.   
  381. //         }
  382. //           double nv = getThisRegion();
  383. //           nv = totalCash -nv + nv*10;
  384. //           nv = nv +(((double)(c-'0'))*Math.pow(10,getWeight(firstIntIndex(maxValue))));
  385. //           if ((nv<=maxValue) && (nv>=0))
  386. //         {
  387. //           totalCash = nv;
  388. //           digitsTyped++;
  389. //           repaint();
  390. //         }
  391. //         }
  392. //     }
  393. //     else switch(c) {
  394. //     case 0177:
  395. //     case '\b': 
  396. //       //totalCash = totalCash/10; 
  397. //       //repaint();
  398. //       break;
  399. //     case '-': //setValue(-value); break;
  400. //       //case '\t': transferFocus(); break;
  401. //     }
  402. //       }
  403. //       return;
  404. //     }
  405. //     protected void processMouseEvent(MouseEvent e)
  406. //     {
  407. //       if (e.getID()==e.MOUSE_PRESSED) requestFocus();
  408. //       return;
  409. //     }
  410. //     protected void processMouseMotionEvent(MouseEvent e)
  411. //     {
  412. //       if(haveFocus)
  413. //     {
  414. //       int i = findSelectedRegion(e.getX());
  415. //       if (currentRegion < 0) {if(tempRegion <0) {tempRegion = i;}}
  416. //       else {tempRegion = currentRegion;}
  417. //       if(i != tempRegion)
  418. //         {
  419. //           currentRegion = i;
  420. //           digitsTyped = 0;
  421. //           repaint();
  422. //         }
  423. //     }
  424. //       return;
  425. //     }
  426.  
  427. //     private int findSelectedRegion(int x)
  428. //     {
  429. //       int i;
  430. //       for(i=1; i<splitArrayLength; i++)
  431. //     {
  432. //       if(x <= splitArray[i][0])
  433. //         {
  434. //           return i-1;
  435. //         }
  436. //     }
  437. //       return splitArrayLength-1;
  438. //     }
  439. //     private int getWeight(int index)
  440. //     {
  441. //       String s = myFormat.format(maxValue);
  442. //       int i,j, len;
  443. //       char ch;
  444. //       j = index;
  445. //       String stripped = "";
  446. //       len = s.length();
  447. //       for(i=0; i<len; i++)
  448. //     {
  449. //       ch = s.charAt(i);
  450. //       if(('0'>ch || ch>'9') && (ch != splitter))
  451. //         {
  452. //           if(i< index){j--;}
  453. //         }
  454. //       else
  455. //         {
  456. //           stripped = stripped + s.substring(i,i+1);
  457. //         }
  458. //     }
  459. //       i = stripped.indexOf(splitter);
  460. //       if(i>-1)
  461. //     {
  462. //       if(i-j > 0) {return i-j-1;}
  463. //       return  i-j;
  464. //     }
  465. //       return stripped.length() - j - 1;
  466.       
  467. //     }
  468. //     private int firstIntIndex(double value)
  469. //     {
  470. //       String s = myFormat.format(value);
  471. //       char ch;
  472. //       int index;
  473. //       if(currentRegion > -1)
  474. //     {
  475. //       if(currentRegion == splitArrayLength -1) {return s.length()-1;}
  476. //       index = splitArray[currentRegion+1][1] - (myFormat.format(maxValue).length()-s.length());
  477.       
  478.       
  479. //     }
  480. //       else {index = s.length() -1;}
  481. //       if(index<0) {return -1;}
  482. //       ch = s.charAt(index);
  483. //       while('0'>ch || ch>'9')
  484. //     {
  485. //       index--;
  486. //       if(index<0) {return -1;}
  487. //       ch = s.charAt(index);
  488. //     }
  489. //       return index;
  490. //     }
  491. //     private int intsInRegion(double value)
  492. //     {
  493. //       if(currentRegion > -1)
  494. //     {
  495. //       String s =  myFormat.format(value);
  496. //       char ch;
  497. //       int total = 0;
  498. //       int index = firstIntIndex(value);
  499.       
  500. //       if(index<0) {return 0;}
  501. //       ch = s.charAt(index);
  502. //       while('0'<=ch && ch<='9' && index>=0)
  503. //         {
  504. //           total++;
  505. //           index--;
  506. //           if(index>=0) {ch = s.charAt(index);}
  507. //         }
  508. //       return total;
  509. //     }
  510. //       return this.digits+2;
  511. //     }
  512. //     private double getThisRegion()
  513. //     {
  514. //       if(currentRegion >-1)
  515. //     {
  516. //       String s =  myFormat.format(totalCash);
  517. //       char ch;
  518. //       double total = 0.00;
  519. //       int index = firstIntIndex(totalCash);
  520. //       int weightIndex = firstIntIndex(maxValue);
  521. //       int i, len;
  522. //       len = intsInRegion(totalCash);
  523. //       for(i=0; i<len; i++)
  524. //         {
  525. //           ch = s.charAt(index);
  526. //           if('0'<=ch && ch<='9') 
  527. //         {
  528. //           total= total +((double)(ch-'0'))*Math.pow(10,getWeight(weightIndex));
  529. //           index--;
  530. //           weightIndex--;
  531. //         }
  532. //         }
  533. //       return total;
  534. //     }
  535. //       return totalCash;
  536. //     }
  537. //     public void setNewInput()
  538. //     {
  539. //       digitsTyped = 0;
  540. //       haveFocus= true;
  541. //       requestFocus();
  542. //       currentRegion = -1;
  543. //       tempRegion = -1;
  544. //       repaint();
  545. //     }
  546. //   }
  547.   protected JPanel createJPanel()
  548.   {
  549.     JPanel bp = new JPanel();
  550.     bp.setLayout(new FlowLayout(FlowLayout.CENTER,0,0));
  551.     bp.setBorder(BorderFactory.createEtchedBorder());
  552.     return bp;
  553.   }
  554.  
  555.   class SpinnerHolder extends JPanel
  556.   {
  557.     int digits;
  558.     boolean stringFirst;
  559.     MoneySpinner[] mySpinners;
  560.     TextBlock[] myStrings;
  561.     
  562.     public SpinnerHolder(int nDigits)
  563.     {
  564.       //this = createJPanel();  
  565.       super();
  566.       setLayout(new FlowLayout(FlowLayout.CENTER,0,0));
  567.       setBorder(BorderFactory.createEtchedBorder());
  568.       this.digits = nDigits;
  569.       ParseCM();
  570.       LayTheBattery();
  571.     }
  572.     public boolean isDigit(char ch)
  573.     {
  574.       if('0'<=ch && ch<='9') {return true;}
  575.       return false;
  576.     }
  577.     public void ParseCM()
  578.     {
  579.       int numSpinners=0;
  580.       int numStrings=0;
  581.       int counter,i,j,weight;
  582.       String s = myFormat.format(Math.pow(10,digits)-.01);
  583.       if(isDigit(s.charAt(0))) {stringFirst = false;}
  584.       else {stringFirst=true;}
  585.       counter=-1;
  586.       j=s.length();
  587.       for(i=0; i<j; i++)
  588.     {
  589.       if(isDigit(s.charAt(i)))
  590.         {
  591.           if(counter != 0) {numSpinners++;}
  592.           counter=0;
  593.         }
  594.       else
  595.         {
  596.           if(counter !=1) {numStrings++;}
  597.           counter=1;
  598.         }
  599.     }
  600.       mySpinners = new MoneySpinner[numSpinners];
  601.       myStrings = new TextBlock[numStrings];
  602.       numSpinners=0;
  603.       numStrings=0;
  604.       weight=digits;
  605.       
  606.       for(i=0; i<j; i++)
  607.     {
  608.       if(isDigit(s.charAt(i)))
  609.         {
  610.           counter=0;
  611.           while((i<j) && (isDigit(s.charAt(i))))
  612.         {
  613.           counter++;
  614.           i++;
  615.         }
  616.           i--;
  617.           weight=weight-counter;
  618.           mySpinners[numSpinners]=new MoneySpinner();
  619.           mySpinners[numSpinners].setDigits(counter);
  620.           mySpinners[numSpinners].setMaximum((int)(Math.pow(10,counter)-1));
  621.           mySpinners[numSpinners].setBorder(new EmptyBorder(0,0,0,0));
  622.           mySpinners[numSpinners].setWrap(true);
  623.           mySpinners[numSpinners].setWeight(weight);
  624.           mySpinners[numSpinners].setIndex(numSpinners);
  625.           if(weight < 0) {mySpinners[numSpinners].setLeadingPad(0);}
  626.           numSpinners++;
  627.         }
  628.       else
  629.         {
  630.           counter=0;
  631.           while((i+counter<j) && !(isDigit(s.charAt(i+counter))))
  632.         {
  633.           counter++;
  634.         }
  635.           myStrings[numStrings]=new TextBlock(s.substring(i,i+counter),numStrings);
  636.           i=i+counter-1;
  637.           numStrings++;
  638.         }
  639.     }
  640.       if(numSpinners > 1)
  641.     {
  642.       ChainLinker cl = new ChainLinker(mySpinners[0], mySpinners[numSpinners-1], mySpinners[1]);
  643.       cl = new ChainLinker(mySpinners[numSpinners-1], mySpinners[numSpinners-2], mySpinners[0]);
  644.       for(i=1; i<numSpinners-1; i++)
  645.       {
  646.           cl = new ChainLinker(mySpinners[i], mySpinners[i-1], mySpinners[i+1]);
  647.       }
  648.     }
  649.     }
  650.     public void LayTheBattery()
  651.     {
  652.       int stringsIndex=0;
  653.       int spinnersIndex=0;
  654.       if(stringFirst) {add(myStrings[0]); stringsIndex++;}
  655.       while((stringsIndex<myStrings.length) || (spinnersIndex<mySpinners.length))
  656.       while(spinnersIndex<mySpinners.length)
  657.     {
  658.       if(spinnersIndex<mySpinners.length) {add(mySpinners[spinnersIndex]); spinnersIndex++;}
  659.       if(stringsIndex<myStrings.length) {add(myStrings[stringsIndex]); stringsIndex++;}
  660.     }
  661.     }
  662.     public void setNewInput(double newValue)
  663.     {
  664.       int valWeight = digits;
  665.       while(newValue/Math.pow(10,valWeight) < 1) {valWeight--;}
  666.       if(valWeight == digits) {throw new IllegalArgumentException("Value is too large");}
  667.       if(valWeight < mySpinners[mySpinners.length-1].getWeight())
  668.     {
  669.       throw new IllegalArgumentException("Value is too small"); 
  670.     }
  671.       int i=0;
  672.       while(mySpinners[i].getWeight() > valWeight) 
  673.     {
  674.       mySpinners[i].setValue(0);
  675.       i++;
  676.     }
  677.       valWeight=i;
  678.       for(i=i; i<mySpinners.length; i++)
  679.     {
  680.       mySpinners[i].setValue((int)(newValue/Math.pow(10,mySpinners[i].getWeight())));
  681.       newValue = newValue%Math.pow(10,mySpinners[i].getWeight());
  682.     }
  683.       mySpinners[valWeight].requestFocus();
  684.     }
  685.         
  686.       
  687.     //public FontMetrics getUIFontMetrics() {return (new MoneySpinnerUI()).getUIFontMetrics();}
  688.     class MoneySpinner extends Spinner
  689.     {
  690.       int weight;
  691.       int index;
  692.       public MoneySpinner()
  693.       {
  694.     super(0,"");
  695.     setUI(new MoneySpinnerUI());
  696.       }
  697.       public void setWeight(int newWeight) {weight=newWeight;}
  698.       public int getWeight() {return weight;}
  699.       public void setIndex(int newIndex) {index=newIndex;}
  700.       public int getIndex() {return index;}
  701.       public int getDigitsTyped() {return digitsTyped;}
  702.     }
  703.  
  704.     class MoneySpinnerUI extends BasicSpinnerUI
  705.     {
  706.       public void paint(Graphics g, JComponent c)
  707.       {
  708.     MoneySpinner spinner = ((MoneySpinner)(c));    
  709.     getMinimumSize(c); //Force computation of dimension
  710.     Insets bi = spinner.getBorder().getBorderInsets(spinner);
  711.     g.setColor(spinner.getBackgroundColor());
  712.     g.fillRect(bi.left,bi.top,d.width-(bi.left+bi.right),d.height-(bi.top+bi.bottom));
  713. //     if(spinner.getBorder() != null) 
  714. //       {
  715. //         spinner.getBorder().paintBorder(g,0,0,d.width-1,d.height-1);
  716. //       } 
  717.     if((spinner.getIndex()>0) && (spinner.getWeight() >-1))
  718.       {
  719.         if((mySpinners[spinner.getIndex()-1].getValue()>0) || 
  720.            (mySpinners[spinner.getIndex()-1].getLeadingPad()==0) ||
  721.            (mySpinners[spinner.getIndex()-1].hasFocus()))
  722.           {
  723.         spinner.setLeadingPad(0);
  724.           }
  725.         else 
  726.           {
  727.         spinner.setLeadingPad(-1);
  728.           }
  729.       }
  730.     if (spinner.hasFocus()) 
  731.       {
  732.         g.setColor(new Color(0,0,150));
  733.         g.fillRect(bi.left+2, bi.top+2, d.width-(bi.left+bi.right+4), d.height-(bi.top+bi.bottom+4));
  734.         g.setColor(Color.white);
  735.       }
  736.     else
  737.       {
  738.         g.setColor(Color.black);
  739.       }
  740.     String s;
  741.     s = Integer.toString(spinner.getValue());
  742.     if(spinner.getLeadingPad() != -1)
  743.       {
  744.         int j = spinner.getDigits()-s.length();
  745.         String lp = Integer.toString(spinner.getLeadingPad());
  746.         for(int i=0; i<j; i++) { s = lp +s;}
  747.       }
  748.     
  749.     if((spinner.getWeight()  < 1) || (spinner.getValue()>0) || (spinner.hasFocus()) ||
  750.        (spinner.getLeadingPad()==0))
  751.       {
  752.         g.drawString(s, d.width-fm.stringWidth(s) - bi.right-2, ascent + bi.bottom+2);    
  753.       }
  754.       }
  755.     }
  756.     class TextBlock extends JComponent
  757.     {
  758.       //frosty man, frosty
  759.       String myString;
  760.       Dimension d = new Dimension(0,0);
  761.       FontMetrics fm;
  762.       int textIndex;
  763.  
  764.       public TextBlock(String s, int ind)
  765.       {
  766.     myString = s;
  767.     textIndex = ind;
  768.       }
  769.       public Dimension getPreferredSize()
  770.       {
  771.     return getMinimumSize();
  772.       }
  773.       public Dimension getMinimumSize()
  774.       {
  775.     if(fm == null) {fm = getFontMetrics(getFont());}
  776.     d.width = fm.stringWidth(myString) + 2;
  777.     d.height = fm.getHeight()+4;
  778.     return d;
  779.       }
  780.       public void paint(Graphics g)
  781.       {
  782.     if(d==null) {getMinimumSize();}
  783.     g.setColor(mySpinners[0].getBackgroundColor());
  784.     g.fillRect(0,0,d.width,d.height);
  785.     g.setColor(Color.black);
  786.  
  787.     int offset=0;
  788.     boolean showString= false;
  789.     if(stringFirst) {offset=1;}
  790.     if((stringFirst) && (textIndex==0)) {showString = true;}
  791.     if(!showString)
  792.       {
  793.         if((mySpinners[textIndex-offset].getValue()>0) || (mySpinners[textIndex-offset].getLeadingPad()>=0) 
  794.           || (mySpinners[textIndex-offset].hasFocus()) || (mySpinners[textIndex-offset].getWeight()<2)) 
  795.           {showString=true;}
  796.       }
  797.     if(showString) {g.drawString(myString,1,fm.getAscent()+2);}
  798.       }
  799.       public void setFont(Font f) 
  800.       {
  801.     if (f != getFont()) 
  802.       {
  803.         super.setFont(f);
  804.         d = null;
  805.         invalidate();
  806.       }
  807.       }
  808.       public int getIndex() {return textIndex;}
  809.     }
  810.     class ChainLinker implements KeyListener, FocusListener
  811.     {
  812.       MoneySpinner watcher;
  813.       MoneySpinner previous;
  814.       MoneySpinner next;
  815.       int digitsTyped=0;
  816.       int maxTyped=0;
  817.  
  818.       public ChainLinker(MoneySpinner toWatch, MoneySpinner prev, MoneySpinner nex)
  819.       {
  820.     watcher = toWatch;
  821.     previous = prev;
  822.     next = nex;
  823.     watcher.addKeyListener(this);
  824.     watcher.addFocusListener(this);
  825.       }
  826.       public void keyTyped(KeyEvent e){}
  827.       public void keyPressed(KeyEvent e)
  828.       {
  829.     if (e.isActionKey())
  830.       switch(e.getKeyCode()) 
  831.         {
  832.         case e.VK_LEFT:    
  833.           previous.requestFocus();
  834.           break;
  835.         case e.VK_RIGHT:   
  836.           next.requestFocus();
  837.           break;
  838.         }
  839.     else if(isDigit(e.getKeyChar()))
  840.       {
  841.         digitsTyped++;
  842.         int ind = watcher.getIndex();
  843.         if((digitsTyped > watcher.getDigits()) && (ind !=0) && (digitsTyped<=maxTyped))
  844.            {
  845.          int k,l;         
  846.          l = e.getKeyChar()-'0';
  847.          
  848.          while(ind>0)
  849.            {
  850.              k = mySpinners[ind].getValue()/((int)(Math.pow(10,mySpinners[ind].getDigits()-1))); 
  851.              mySpinners[ind].setValue((mySpinners[ind].getValue()-k*
  852.                            ((int)(Math.pow(10,mySpinners[ind].getDigits()-1))))*10+l);
  853.              if(mySpinners[ind-1].getValue()*10+k <= mySpinners[ind-1].getMaximum()) 
  854.                {
  855.              mySpinners[ind-1].setValue(mySpinners[ind-1].getValue()*10+k);
  856.              ind = 0;
  857.                }
  858.              l=k;
  859.              ind--;
  860.            }
  861.            }
  862.       }
  863.       }
  864.       public void keyReleased(KeyEvent e){}
  865.  
  866.       public void focusGained(FocusEvent e) 
  867.       {
  868.     digitsTyped = 0;
  869.     maxTyped = watcher.getDigits();
  870.     for(int i=watcher.getIndex()-1; i>=0; i--)
  871.       {
  872.         if(mySpinners[i].getValue() == 0)
  873.           {
  874.         maxTyped = maxTyped+mySpinners[i].getDigits();
  875.           }
  876.         else
  877.           {
  878.         maxTyped = watcher.getDigits();
  879.         i = -1;
  880.           }
  881.       }
  882.     //int k = ((MoneySpinner)(e.getSource())).getIndex()+1;
  883.     int j = mySpinners.length;
  884.     //if(k==j) {k=0;}
  885.     for(int i=0; i<j; i++)
  886.       {
  887.         mySpinners[i].paint(mySpinners[i].getGraphics()); 
  888.       }
  889.       }
  890.       public void focusLost(FocusEvent e){}
  891.  
  892. //       public void adjustmentValueChanged(AdjustmentEvent e)
  893. //       {
  894.  
  895. //     j= myStrings.length;
  896. //     if(!stringFirst) {k--;}
  897. //     for(int i=k; i<j; i++)
  898. //       {
  899. //         myStrings[i].repaint();
  900. //       }
  901. //      }
  902.     }
  903.   }
  904. }
  905.  
  906.