src/jalview/javascript/JSFunctionExec.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.javascript;
  22
  23 import jalview.bin.JalviewLite;
  24
  25 import java.net.URL;
  26 import java.util.Vector;
  27
  28 import netscape.javascript.JSObject;
  29
  30 public class JSFunctionExec implements Runnable
  31 {
  32   public JalviewLite jvlite;
  33
  34   public JSFunctionExec(JalviewLite applet)
  35   {
  36     jvlite = applet;
  37
  38     jsExecQueue = jvlite.getJsExecQueue();
  39     jvlite.setExecutor(this);
  40   }
  41
  42   public void finalize()
  43   {
  44     jvlite = null;
  45     executor = null;
  46     if (jsExecQueue != null)
  47     {
  48       jsExecQueue.clear();
  49     }
  50     jsExecQueue = null;
  51   }
  52
  53   private Vector jsExecQueue;
  54
  55   private Thread executor = null;
  56
  57   public void stopQueue()
  58   {
  59     if (jsExecQueue != null)
  60     {
  61       Vector<JSFunctionExec> q = null;
  62       synchronized (jsExecQueue)
  63       {
  64         q = jsExecQueue;
  65         jsExecQueue = null;
  66       }
  67       if (q != null)
  68       {
  69         for (JSFunctionExec jx : q)
  70         {
  71           jx.jvlite = null;
  72
  73         }
  74         q.removeAllElements();
  75         synchronized (q)
  76         {
  77           q.notifyAll();
  78         }
  79       }
  80     }
  81     jvlite = null;
  82     executor = null;
  83   }
  84
  85   public void run()
  86   {
  87     while (jsExecQueue != null)
  88     {
  89       if (jsExecQueue.size() > 0)
  90       {
  91         Runnable r = (Runnable) jsExecQueue.elementAt(0);
  92         jsExecQueue.removeElementAt(0);
  93         try
  94         {
  95           r.run();
  96         } catch (Exception ex)
  97         {
  98           ex.printStackTrace();
  99         } catch (Error ex)
 100         {
 101           ex.printStackTrace();
 102         }
 103       }
 104       else
 105       {
 106         try
 107         {
 108           synchronized (jsExecQueue)
 109           {
 110             jsExecQueue.wait(1000);
 111           }
 112         } catch (Exception ex)
 113         {
 114         }
 115         ;
 116       }
 117     }
 118
 119   }
 120
 121   /**
 122    * execute a javascript callback synchronously
 123    *
 124    * @param _listener
 125    * @param objects
 126    * @throws Exception
 127    */
 128   public void executeJavascriptFunction(final String _listener,
 129           final Object[] objects) throws Exception
 130   {
 131     executeJavascriptFunction(false, _listener, objects);
 132   }
 133
 134   /**
 135    * execute a javascript callback synchronously or asynchronously
 136    *
 137    * @param async
 138    *          - true to execute asynchronously (do this for gui events)
 139    * @param _listener
 140    *          - javascript function
 141    * @param objects
 142    *          - arguments
 143    * @throws Exception
 144    *           - only if call is synchronous
 145    */
 146   public void executeJavascriptFunction(final boolean async,
 147           final String _listener, Object[] arguments) throws Exception
 148   {
 149
 150     executeJavascriptFunction(async, _listener, arguments, null);
 151
 152   }
 153
 154   public void executeJavascriptFunction(final boolean async,
 155           final String _listener, Object[] arguments, final String dbgMsg)
 156           throws Exception
 157   {
 158     final Object[] objects = new Object[arguments != null ? arguments.length
 159             : 0];
 160     if (arguments != null)
 161     {
 162       System.arraycopy(arguments, 0, objects, 0, arguments.length);
 163     }
 164     final Exception[] jsex = new Exception[1];
 165     Runnable exec = new Runnable()
 166     {
 167       public void run()
 168       {
 169         try
 170         {
 171           JSObject scriptObject = null;
 172           try
 173           {
 174             scriptObject = JSObject.getWindow(jvlite);
 175           } catch (Exception ex)
 176           {
 177           }
 178           ;
 179           if (scriptObject != null)
 180           {
 181             if (jvlite.debug && dbgMsg != null)
 182             {
 183               System.err.println(dbgMsg);
 184             }
 185             scriptObject.call(_listener, objects);
 186           }
 187         } catch (Exception jex)
 188         {
 189           // squash any malformedURLExceptions thrown by windows/safari
 190           if (!(jex instanceof java.net.MalformedURLException))
 191           {
 192             if (jvlite.debug)
 193             {
 194               System.err.println(jex);
 195             }
 196             if (jex instanceof netscape.javascript.JSException
 197                     && jvlite.jsfallbackEnabled)
 198             {
 199               jsex[0] = (netscape.javascript.JSException) jex;
 200               if (jvlite.debug)
 201               {
 202                 System.err.println("Falling back to javascript: url call");
 203               }
 204               StringBuffer sb = new StringBuffer("javascript:" + _listener
 205                       + "(");
 206               for (int i = 0; objects != null && i < objects.length; i++)
 207               {
 208                 if (i > 0)
 209                 {
 210                   sb.append(",");
 211                 }
 212                 sb.append("\"");
 213                 // strip out nulls and complex objects that we can't pass this
 214                 // way.
 215                 if (objects[i] != null
 216                         && !(objects[i].getClass().getName()
 217                                 .indexOf("jalview") == 0))
 218                 {
 219                   sb.append(objects[i].toString());
 220                 }
 221                 sb.append("\"");
 222               }
 223               sb.append(")");
 224               if (jvlite.debug)
 225               {
 226                 System.err.println(sb.toString());
 227               }
 228               // alternate
 229               URL url = null;
 230               try
 231               {
 232                 url = new URL(sb.toString());
 233                 jvlite.getAppletContext().showDocument(url);
 234                 jex = null;
 235               } catch (Exception uex)
 236               {
 237                 jex = uex;
 238               }
 239             }
 240             if (jex != null)
 241             {
 242               if (async)
 243               {
 244                 jex.printStackTrace();
 245               }
 246               else
 247               {
 248                 jsex[0] = jex;
 249               }
 250             }
 251             ;
 252           }
 253
 254         }
 255       }
 256     };
 257     if (async)
 258     {
 259       if (executor == null)
 260       {
 261         executor = new Thread(new JSFunctionExec(jvlite));
 262         executor.start();
 263       }
 264       synchronized (jsExecQueue)
 265       {
 266         jsExecQueue.addElement(exec);
 267         jsExecQueue.notify();
 268       }
 269     }
 270     else
 271     {
 272       // wat for executor to notify us if it's running.
 273       exec.run();
 274       if (jsex[0] != null)
 275       {
 276         throw (jsex[0]);
 277       }
 278     }
 279   }
 280
 281 }