home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / inprise / JSAMPLES.Z / SortItem.java < prev    next >
Text File  |  1998-05-08  |  6KB  |  245 lines
  1. /*
  2.  * @(#)SortItem.java    1.4 96/12/06
  3.  *
  4.  * Copyright (c) 1994-1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
  7.  * modify and redistribute this software in source and binary code form,
  8.  * provided that i) this copyright notice and license appear on all copies of
  9.  * the software; and ii) Licensee does not utilize the software in a manner
  10.  * which is disparaging to Sun.
  11.  *
  12.  * This software is provided "AS IS," without a warranty of any kind. ALL
  13.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  14.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  15.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  16.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  17.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  18.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  19.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  20.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  21.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  22.  * POSSIBILITY OF SUCH DAMAGES.
  23.  *
  24.  * This software is not designed or intended for use in on-line control of
  25.  * aircraft, air traffic, aircraft navigation or aircraft communications; or in
  26.  * the design, construction, operation or maintenance of any nuclear
  27.  * facility. Licensee represents and warrants that it will not use or
  28.  * redistribute the Software for such purposes.
  29.  */
  30.  
  31. import java.awt.*;
  32. import java.io.InputStream;
  33. import java.util.Hashtable;
  34. import java.net.*;
  35.  
  36. /**
  37.  * A simple applet class to demonstrate a sort algorithm.
  38.  * You can specify a sorting algorithm using the "alg"
  39.  * attribyte. When you click on the applet, a thread is
  40.  * forked which animates the sorting algorithm.
  41.  *
  42.  * @author James Gosling
  43.  * @version     1.17f, 10 Apr 1995
  44.  */
  45. public class SortItem extends java.applet.Applet implements Runnable {
  46.     /**
  47.      * The thread that is sorting (or null).
  48.      */
  49.     private Thread kicker;
  50.  
  51.     /**
  52.      * The array that is being sorted.
  53.      */
  54.     int arr[];
  55.  
  56.     /**
  57.      * The high water mark.
  58.      */
  59.     int h1 = -1;
  60.  
  61.     /**
  62.      * The low water mark.
  63.      */
  64.     int h2 = -1;
  65.  
  66.     /**
  67.      * The name of the algorithm.
  68.      */
  69.     String algName;
  70.  
  71.     /**
  72.      * The sorting algorithm (or null).
  73.      */
  74.     SortAlgorithm algorithm;
  75.  
  76.     /**
  77.      * Fill the array with random numbers from 0..n-1.
  78.      */
  79.     void scramble() {
  80.     int a[] = new int[size().height / 2];
  81.     double f = size().width / (double) a.length;
  82.     for (int i = a.length; --i >= 0;) {
  83.         a[i] = (int)(i * f);
  84.     }
  85.     for (int i = a.length; --i >= 0;) {
  86.         int j = (int)(i * Math.random());
  87.         int t = a[i];
  88.         a[i] = a[j];
  89.         a[j] = t;
  90.     }
  91.     arr = a;
  92.     }
  93.  
  94.     /**
  95.      * Pause a while.
  96.      * @see SortAlgorithm
  97.      */
  98.     void pause() {
  99.     pause(-1, -1);
  100.     }
  101.  
  102.     /**
  103.      * Pause a while, and draw the high water mark.
  104.      * @see SortAlgorithm
  105.      */
  106.     void pause(int H1) {
  107.     pause(H1, -1);
  108.     }
  109.  
  110.     /**
  111.      * Pause a while, and draw the low&high water marks.
  112.      * @see SortAlgorithm
  113.      */
  114.     void pause(int H1, int H2) {
  115.     h1 = H1;
  116.     h2 = H2;
  117.     if (kicker != null) {
  118.         repaint();
  119.     }
  120.     try {Thread.sleep(20);} catch (InterruptedException e){}
  121.     }
  122.  
  123.     /**
  124.      * Initialize the applet.
  125.      */
  126.     public void init() {
  127.     String at = getParameter("alg");
  128.     if (at == null) {
  129.         at = "BubbleSort";
  130.     }
  131.  
  132.     algName = at + "Algorithm";
  133.     scramble();
  134.  
  135.     resize(100, 100);
  136.     }
  137.  
  138.     /**
  139.      * Paint the array of numbers as a list
  140.      * of horizontal lines of varying lenghts.
  141.      */
  142.     public void paint(Graphics g) {
  143.     int a[] = arr;
  144.     int y = size().height - 1;
  145.  
  146.     // Erase old lines
  147.     g.setColor(getBackground());
  148.     for (int i = a.length; --i >= 0; y -= 2) {
  149.         g.drawLine(arr[i], y, size().width, y);
  150.     }
  151.  
  152.     // Draw new lines
  153.     g.setColor(Color.black);
  154.     y = size().height - 1;
  155.     for (int i = a.length; --i >= 0; y -= 2) {
  156.         g.drawLine(0, y, arr[i], y);
  157.     }
  158.  
  159.     if (h1 >= 0) {
  160.         g.setColor(Color.red);
  161.         y = h1 * 2 + 1;
  162.         g.drawLine(0, y, size().width, y);
  163.     }
  164.     if (h2 >= 0) {
  165.         g.setColor(Color.blue);
  166.         y = h2 * 2 + 1;
  167.         g.drawLine(0, y, size().width, y);
  168.     }
  169.     }
  170.  
  171.     /**
  172.      * Update without erasing the background.
  173.      */
  174.     public void update(Graphics g) {
  175.     paint(g);
  176.     }
  177.  
  178.     /**
  179.      * Run the sorting algorithm. This method is
  180.      * called by class Thread once the sorting algorithm
  181.      * is started.
  182.      * @see java.lang.Thread#run
  183.      * @see SortItem#mouseUp
  184.      */
  185.     public void run() {
  186.     try {
  187.         if (algorithm == null) {
  188.         algorithm = (SortAlgorithm)Class.forName(algName).newInstance();
  189.         algorithm.setParent(this);
  190.         }
  191.         algorithm.init();
  192.         algorithm.sort(arr);
  193.     } catch(Exception e) {
  194.     }
  195.     }
  196.  
  197.     /**
  198.      * Stop the applet. Kill any sorting algorithm that
  199.      * is still sorting.
  200.      */
  201.     public synchronized void stop() {
  202.     if (kicker != null) {
  203.             try {
  204.         kicker.stop();
  205.             } catch (IllegalThreadStateException e) {
  206.                 // ignore this exception
  207.             }
  208.         kicker = null;
  209.     }
  210.     if (algorithm != null){
  211.             try {
  212.         algorithm.stop();
  213.             } catch (IllegalThreadStateException e) {
  214.                 // ignore this exception
  215.             }
  216.     }
  217.     }
  218.  
  219.  
  220.     /**
  221.      * For a Thread to actually do the sorting. This routine makes
  222.      * sure we do not simultaneously start several sorts if the user
  223.      * repeatedly clicks on the sort item.  It needs to be
  224.      * synchronoized with the stop() method because they both
  225.      * manipulate the common kicker variable.
  226.      */
  227.     private synchronized void startSort() {
  228.     if (kicker == null || !kicker.isAlive()) {
  229.         scramble();
  230.         repaint();
  231.         kicker = new Thread(this);
  232.         kicker.start();
  233.     }
  234.     }
  235.  
  236.  
  237.     /**
  238.      * The user clicked in the applet. Start the clock!
  239.      */
  240.     public boolean mouseUp(java.awt.Event evt, int x, int y) {
  241.     startSort();
  242.     return true;
  243.     }
  244. }
  245.