home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 May / PCW596.iso / wtest / clico / sunsoft / java / solaris.taz / solaris / hotjava / classsrc / browser / AppletDisplayItem.java < prev    next >
Encoding:
Java Source  |  1995-05-15  |  14.9 KB  |  645 lines
  1. /*
  2.  * @(#)AppletDisplayItem.java    1.26 95/05/11 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package browser;
  21.  
  22. import awt.*;
  23. import net.www.html.*;
  24. import java.io.InputStream;
  25.  
  26. /**
  27.  * Class AppletDisplayItem is created as a place holder for all
  28.  * applets that appear in hotjava-aware html documents.
  29.  *
  30.  * @version 1.26, 11 May 1995
  31.  * @author Arthur van Hoff
  32.  */
  33.  
  34. public
  35. class AppletDisplayItem extends DisplayItem implements Alignable {
  36.     static public final int CREATED    = 0;
  37.     static public final int LOADING    = 1;
  38.     static public final int LOADED    = 2;
  39.     static public final int INITIALIZING= 3;
  40.     static public final int STARTED    = 4;
  41.     static public final int STOPPED    = 5;
  42.     static public final int DESTROYED    = 6;
  43.     static public final int ERROR    = 7;
  44.  
  45.     /** Thickness of the load-status icon border. */
  46.     static public final int BORDER = 2;
  47.  
  48.     /** Total thickness of the icon border. */
  49.     static final int FULL_BORDER = BORDER * 2;    
  50.  
  51.     /** Size of status icons + border. */
  52.     static public final int DEFAULT_SIZE= 38 + FULL_BORDER;
  53.  
  54.     /**
  55.      * "Applet Delayed" icon.
  56.      */
  57.     static public Image appletDelayedImage = null;
  58.  
  59.     /**
  60.      * "Applet Failed" icon.
  61.      */
  62.     static public Image appletFailedImage = null;
  63.  
  64.     /**
  65.      * "Applet Loading" icon.
  66.      */
  67.     static public Image appletLoadingImage = null;
  68.  
  69.     /**
  70.      * True, once an attempt has been made to load
  71.      * the applet.
  72.      */
  73.     private int status;
  74.     
  75.     /**
  76.      * The applet displayed in this item.
  77.      */
  78.     private Applet applet;
  79.  
  80.     /**
  81.      * The message that is displayed after an error or
  82.      * during loading...
  83.      */
  84.     private String msg;
  85.  
  86.     /**
  87.      * The applet alignment
  88.      */
  89.     private int align;
  90.  
  91.     /**
  92.      * The document URL.
  93.      */
  94.     private URL documentURL;
  95.  
  96.     /**
  97.      * The applet URL.
  98.      */
  99.     private URL appletURL;
  100.  
  101.     /**
  102.      * The Tag.
  103.      */
  104.     private TagRef tag;
  105.  
  106.     /**
  107.      * The class name.
  108.      */
  109.     private String className;
  110.  
  111.     /**
  112.      * Get the status of the applet.
  113.      */
  114.     public final int getStatus() {
  115.     return status;
  116.     }
  117.  
  118.     /**
  119.      * Get alignment for formatting.
  120.      */
  121.     public int getAlign() {
  122.     return align;
  123.     }
  124.  
  125.     static private Image getLoadIcon(Window w, String name) {
  126.     URL imgURL = new URL(null, name);
  127.     InputStream iStream = imgURL.openStream();
  128.     GifImage gif = new GifImage(iStream, null);
  129.     return w.createImage(gif);
  130.     }
  131.     
  132.     /**
  133.      * Initialize the load status icons.
  134.      */
  135.     static private void maybeInitLoadIcons(Window w) {
  136.     if (appletDelayedImage == null) {
  137.         final String base = "doc:demo/images/";
  138.         
  139.         appletDelayedImage = getLoadIcon(w, base+"applet-delayed.gif");
  140.         appletFailedImage = getLoadIcon(w, base+"applet-failed.gif");
  141.         appletLoadingImage = getLoadIcon(w, base+"applet-loading.gif");
  142.     }
  143.     }
  144.     
  145.     /**
  146.      * Creates an applet display item, if possible use the width/height
  147.      * attributes to resize to the proper initial size.
  148.      */
  149.     public AppletDisplayItem(DisplayItemWindow parent, URL documentURL, TagRef tag) {
  150.     this.documentURL = documentURL;
  151.     this.tag = tag;
  152.     
  153.     int w = DEFAULT_SIZE;
  154.     int h = DEFAULT_SIZE;
  155.  
  156.     align = WRImageItem.convertAlign(tag.getAttribute("align"));
  157.  
  158.     String    attr;
  159.     if ((attr = tag.getAttribute("width")) != null) {
  160.         try {
  161.         w = Integer.parseInt(attr);
  162.         } catch (NumberFormatException ee) {
  163.         }
  164.     }
  165.     if ((attr = tag.getAttribute("height")) != null) {
  166.         try {
  167.         h = Integer.parseInt(attr);
  168.         } catch (NumberFormatException ee) {
  169.         }
  170.     }
  171.     resize(w, h);
  172.  
  173.     // Get the class name
  174.     className = tag.getAttribute("class");
  175.  
  176.     // Determine the applet URL
  177.     String src = tag.getAttribute("src");
  178.     appletURL = (src != null) ? new URL(documentURL, src) : documentURL;
  179.  
  180.     if (className != null) {
  181.         msg = "Applet " + className + " from " + appletURL.toExternalForm();
  182.     } else {
  183.         status = ERROR;
  184.         className = "<no name>";
  185.         msg = "No class name for this applet.";
  186.     }
  187.  
  188.     if (!WRWindow.delayAppletLoading) {
  189.         setParent(parent);
  190.         load();
  191.         init();
  192.         setParent(null);
  193.     }
  194.  
  195.     maybeInitLoadIcons(parent);
  196.     }
  197.  
  198.     public void requestUpdate() {
  199.     if (status == STARTED) {
  200.         if (parent != null) {
  201.         parent.paintChild(this, false);
  202.         }
  203.     }
  204.     }
  205.  
  206.     /**
  207.      * Load the applet
  208.      */
  209.     public void load() {
  210.     // Don't bother if the applet was already loaded.
  211.     if (status == CREATED) {
  212.         status = LOADING;
  213.  
  214.         // Try loading the applet locally
  215.         try {
  216.         applet = (Applet)appletURL.New(className);
  217.         } catch (Exception ex) {
  218.         msg = "Applet " + className + " from " + appletURL.toExternalForm() + " not loaded.";
  219.         status = ERROR;
  220.         System.err.println(msg);
  221.         }
  222.         if (applet != null) {
  223.         applet.item = this;
  224.         applet.documentURL = documentURL;
  225.         applet.appletURL = appletURL;
  226.         applet.tag = tag;    
  227.         status = LOADED;
  228.         }
  229.     }
  230.     }
  231.  
  232.     /**
  233.      * Initialize the applet. This should be called after
  234.      * the parent of the display item is set. The font will
  235.      * be the default font of the applet.
  236.      */
  237.     public void init() {
  238.     if (status == LOADED) {
  239.         status = INITIALIZING;
  240.         applet.width = width;
  241.         applet.height = height;
  242.         applet.font = parent.wServer.fonts.getFont("TimesRoman", Font.PLAIN, 14);
  243.         parent.getFontMetrics(applet.font);
  244.         applet.fgColor = Color.black;
  245.         applet.bgColor = parent.background;
  246.  
  247.         try {
  248.         applet.init();
  249.         status = STOPPED;
  250.         } catch (ThreadDeath e) {
  251.         throw e;
  252.         } catch (Exception ex) {
  253.         ex.printStackTrace();
  254.         msg = "Failed to intialize: " + ex;
  255.         System.err.println(msg);
  256.         status = ERROR;
  257.         } catch (Object o) {
  258.         msg = "Failed to intialize: " + o;
  259.         System.err.println(msg);
  260.         status = ERROR;
  261.         }
  262.     }
  263.     }
  264.  
  265.     /**
  266.      * Start the applet
  267.      */
  268.     public void start() {
  269.     if (status == STOPPED) {
  270.         status = STARTED;
  271.         try {
  272.         applet.start();
  273.         } catch (ThreadDeath e) {
  274.         throw e;
  275.         } catch (Exception ex) {
  276.         ex.printStackTrace();
  277.         System.err.println(msg);
  278.         msg = "Failed to start: " + ex;
  279.         } catch (Object o) {
  280.         msg = "Failed to start: " + o;
  281.         System.err.println(msg);
  282.         }
  283.  
  284.  
  285.     }
  286.     }
  287.  
  288.     /**
  289.      * Stop the applet
  290.      */
  291.     public void stop() {
  292.     if (status == STARTED) {
  293.         try {
  294.         applet.stop();
  295.         } catch (ThreadDeath e) {
  296.         throw e;
  297.         } catch (Exception ex) {
  298.         ex.printStackTrace();
  299.         msg = "Failed to stop: " + ex;
  300.         System.err.println(msg);
  301.         } catch (Object o) {
  302.         msg = "Failed to stop: " + o;
  303.         System.err.println(msg);
  304.         }
  305.         status = STOPPED;
  306.     }
  307.     }
  308.  
  309.     /**
  310.      * Destroy the applet
  311.      */
  312.     public void destroy() {
  313.     if (status != STOPPED) {
  314.         stop();
  315.     }
  316.     if (status == STOPPED) {
  317.         try {
  318.         applet.destroy();
  319.         } catch (ThreadDeath e) {
  320.         throw e;
  321.         } catch (Exception ex) {
  322.         ex.printStackTrace();
  323.         msg = "Failed to stop: " + ex;
  324.         System.err.println(msg);
  325.         } catch (Object o) {
  326.         msg = "Failed to stop: " + o;
  327.         System.err.println(msg);
  328.         }
  329.         applet = null;
  330.         status = DESTROYED;
  331.     }
  332.     }
  333.  
  334.     /**
  335.      * Paint the applet, after damage.
  336.      */
  337.     public void paint(Window w, int x, int y) {
  338.     Graphics g = w.graphics.createChild(x, y, 1, 1);
  339.     try {
  340.         paint(g);
  341.     } finally {
  342.         g.dispose();
  343.     }
  344.     }
  345.  
  346.     /**
  347.      * Paint the applet, after damage.
  348.      */
  349.     public void update(Window w, int x, int y) {
  350.     Graphics g = w.graphics.createChild(x, y, 1, 1);
  351.     try {
  352.         update(g);
  353.     } finally {
  354.         g.dispose();
  355.     }
  356.     }
  357.  
  358.     private void safeDrawImage(Graphics g, Image i, int x, int y,
  359.                    int inWidth, int inHeight) {
  360.     if (i != null && (i.width / 2) < inWidth && (i.height / 2) < inHeight) {
  361.         g.clipRect(BORDER, BORDER, inWidth, inHeight);
  362.         g.drawImage(i, x, y);
  363.     }
  364.     }
  365.  
  366.     /**    
  367.      * Paint the applet, given a graphics context.
  368.      */
  369.     public void paint(Graphics g) {
  370.     g.clipRect(0, 0, width, height);
  371.     switch (status) {
  372.       case STOPPED:
  373.       case STARTED:
  374.         g.setFont(applet.font);
  375.         g.setForeground(applet.fgColor);
  376.         try {
  377.         applet.paint(g);
  378.         } catch (ThreadDeath e) {
  379.         throw e;
  380.         } catch (Exception ex) {
  381.         ex.printStackTrace();
  382.         msg = "Failed to paint: " + ex;
  383.         System.err.println(msg);
  384.         } catch (Object o) {
  385.         msg = "Failed to paint: " + o;
  386.         System.err.println(msg);
  387.         }
  388.         break;
  389.       case LOADING:
  390.         g.setForeground(Color.yellow);
  391.         g.paint3DRect(0, 0, width, height, true, true);
  392.         safeDrawImage(g, appletLoadingImage, BORDER, BORDER,
  393.               width - FULL_BORDER, height - FULL_BORDER);
  394.         break;
  395.       case ERROR:
  396.         g.setForeground(Color.red);
  397.         g.paint3DRect(0, 0, width, height, true, true);
  398.         safeDrawImage(g, appletFailedImage, BORDER, BORDER,
  399.               width - FULL_BORDER, height - FULL_BORDER);
  400.         break;
  401.       default:
  402.         if (((WRWindow)parent).delayAppletLoading) {
  403.         g.setForeground(Color.yellow);
  404.         g.paint3DRect(0, 0, width, height, true, true);
  405.         safeDrawImage(g, appletDelayedImage, BORDER, BORDER,
  406.                   width - FULL_BORDER, height - FULL_BORDER);
  407.         } else {
  408.         g.paint3DRect(0, 0, width, height, false, true);
  409.         safeDrawImage(g, appletLoadingImage, BORDER, BORDER,
  410.                   width - FULL_BORDER, height - FULL_BORDER);
  411.         }
  412.         break;
  413.     }
  414.     }
  415.  
  416.     /**    
  417.      * Paint the applet, given a graphics context.
  418.      */
  419.     public void update(Graphics g) {
  420.     g.clipRect(0, 0, width, height);
  421.     switch (status) {
  422.       case STOPPED:
  423.       case STARTED:
  424.         g.setFont(applet.font);
  425.         g.setForeground(applet.fgColor);
  426.         try {
  427.         applet.update(g);
  428.         } catch (ThreadDeath e) {
  429.         throw e;
  430.         } catch (Exception ex) {
  431.         ex.printStackTrace();
  432.         msg = "Failed to update: " + ex;
  433.         System.err.println(msg);
  434.         } catch (Object o) {
  435.         msg = "Failed to update: " + o;
  436.         System.err.println(msg);
  437.         }
  438.         break;
  439.       case LOADING:
  440.         g.setForeground(Color.yellow);
  441.         g.paint3DRect(0, 0, width, height, true, true);
  442.         safeDrawImage(g, appletLoadingImage, BORDER, BORDER,
  443.               width - FULL_BORDER, height - FULL_BORDER);
  444.         break;
  445.       case ERROR:
  446.         g.setForeground(Color.red);
  447.         g.paint3DRect(0, 0, width, height, true, true);
  448.         safeDrawImage(g, appletFailedImage, BORDER, BORDER,
  449.               width - FULL_BORDER, height - FULL_BORDER);
  450.         break;
  451.       default:
  452.         if (((WRWindow)parent).delayAppletLoading) {
  453.         g.setForeground(Color.yellow);
  454.         g.paint3DRect(0, 0, width, height, true, true);
  455.         safeDrawImage(g, appletDelayedImage, BORDER, BORDER,
  456.                   width - FULL_BORDER, height - FULL_BORDER);
  457.         } else {
  458.         g.paint3DRect(0, 0, width, height, false, true);
  459.         safeDrawImage(g, appletLoadingImage, BORDER, BORDER,
  460.                   width - FULL_BORDER, height - FULL_BORDER);
  461.         }
  462.         break;
  463.     }
  464.     }
  465.  
  466.     /**
  467.      * Mouse down
  468.      */
  469.     public void trackStart(Event e) {
  470.     if (status == STARTED) {
  471.         try {
  472.         applet.mouseDown(e.x, e.y);
  473.         } catch (ThreadDeath td) {
  474.         throw td;
  475.         } catch (Exception ex) {
  476.         ex.printStackTrace();
  477.         msg = "Failed to trackStart: " + ex;
  478.         System.err.println(msg);
  479.         } catch (Object o) {
  480.         msg = "Failed to trackStart: " + o;
  481.         System.err.println(msg);
  482.         }
  483.     }
  484.     }
  485.  
  486.     /**
  487.      * Mouse move
  488.      */
  489.     public void trackMotion(Event e) {
  490.     if (status == STARTED) {
  491.         try {
  492.         if (e.id == Event.MOUSE_MOTION) {
  493.             applet.mouseMove(e.x, e.y);
  494.         } else {
  495.             applet.mouseDrag(e.x, e.y);
  496.         }
  497.         } catch (ThreadDeath td) {
  498.         throw td;
  499.         } catch (Exception ex) {
  500.         ex.printStackTrace();
  501.         msg = "Failed to mouse"
  502.               + (e.id == Event.MOUSE_MOTION ? "Move " : "Drag ") 
  503.               + ex; 
  504.         System.err.println(msg);
  505.         } catch (Object o) {
  506.         msg = "Failed to mouse"
  507.               + (e.id == Event.MOUSE_MOTION ? "Move " : "Drag ")
  508.               + o;
  509.         System.err.println(msg);
  510.         }
  511.     }
  512.     }
  513.  
  514.     /**
  515.      * Mouse up
  516.      */
  517.     public void trackStop(Event e) {
  518.     if (status == STARTED) {
  519.         try {
  520.         applet.mouseUp(e.x, e.y);
  521.         } catch (ThreadDeath td) {
  522.         throw td;
  523.         } catch (Exception ex) {
  524.         ex.printStackTrace();
  525.         msg = "Failed to trackStop " + ex;
  526.         System.err.println(msg);
  527.         } catch (Object o) {
  528.         msg = "Failed to trackStop " + o;
  529.         System.err.println(msg);
  530.         }
  531.     } else if ((status == CREATED) && ((WRWindow)parent).delayAppletLoading) {
  532.         ((WRWindow)parent).status("Loading applet " + className + " from " + documentURL.toExternalForm() + "...");
  533.         load();
  534.         init();
  535.         ((WRWindow)parent).relayout();
  536.         start();
  537.         ((WRWindow)parent).status("Applet " + className + " loaded!");
  538.     }
  539.     }
  540.  
  541.     /**
  542.      * Mouse enter
  543.      */
  544.     public void trackEnter(Event e) {
  545.     if (status == STARTED) {
  546.         try {
  547.         applet.mouseEnter();
  548.         } catch (ThreadDeath td) {
  549.         throw td;
  550.         } catch (Exception ex) {
  551.         ex.printStackTrace();
  552.         msg = "Failed to trackEnter " + ex;
  553.         System.err.println(msg);
  554.         } catch (Object o) {
  555.         msg = "Failed to trackEnter " + o;
  556.         System.err.println(msg);
  557.         }
  558.     } else if (msg != null) {
  559.         ((WRWindow)parent).status(msg);
  560.     }
  561.     }
  562.  
  563.     /**
  564.      * Mouse exit
  565.      */
  566.     public void trackExit(Event e) {
  567.     if (status == STARTED) {
  568.         try {
  569.         applet.mouseExit();
  570.         } catch (ThreadDeath td) {
  571.         throw td;
  572.         } catch (Exception ex) {
  573.         ex.printStackTrace();
  574.         msg = "Failed to trackExit " + ex;
  575.         System.err.println(msg);
  576.         } catch (Object o) {
  577.         msg = "Failed to trackExit " + o;
  578.         System.err.println(msg);
  579.         }
  580.     } else if (msg != null) {
  581.         ((WRWindow)parent).status("");
  582.     }
  583.     }
  584.  
  585.     /**
  586.      * Got focus
  587.      */
  588.     public void gotFocus() {
  589.     if (status == STARTED) {
  590.         try {
  591.         applet.gotFocus();
  592.         } catch (ThreadDeath e) {
  593.         throw e;
  594.         } catch (Exception ex) {
  595.         ex.printStackTrace();
  596.         msg = "Failed to gotFocus " + ex;
  597.         System.err.println(msg);
  598.         } catch (Object o) {
  599.         msg = "Failed to gotFocus " + o;
  600.         System.err.println(msg);
  601.         }
  602.     }
  603.     }
  604.  
  605.     /**
  606.      * Lost focus
  607.      */
  608.     public void lostFocus() {
  609.     if (status == STARTED) {
  610.         try {
  611.         applet.lostFocus();
  612.         } catch (ThreadDeath e) {
  613.         throw e;
  614.         } catch (Exception ex) {
  615.         ex.printStackTrace();
  616.         msg = "Failed to lostFocus " + ex;
  617.         System.err.println(msg);
  618.         } catch (Object o) {
  619.         msg = "Failed to lostFocus " + o;
  620.         System.err.println(msg);
  621.         }
  622.     }
  623.     }
  624.  
  625.     /**
  626.      * KeyPressed
  627.      */
  628.     public void keyPressed(int key) {
  629.     if (status == STARTED) {
  630.         try {
  631.         applet.keyDown(key);
  632.         } catch (ThreadDeath e) {
  633.         throw e;
  634.         } catch (Exception ex) {
  635.         ex.printStackTrace();
  636.         msg = "Failed to keyDown " + ex;
  637.         System.err.println(msg);
  638.         } catch (Object o) {
  639.         msg = "Failed to dkeyDowngotFocus " + o;
  640.         System.err.println(msg);
  641.         }
  642.     }
  643.     }
  644. }
  645.