--- /dev/null
+// j2sjmol.js \r
+\r
+// latest author: Bob Hanson, St. Olaf College, hansonr@stolaf.edu\r
+ \r
+// Requires JSmolCore.js and (for now; probably) JSmol.js\r
+// This version of j2slib requires jQuery and works in both Chrome and MSIE locally,\r
+// though Chrome cannot read local data files, and MSIE cannot read local binary data files.\r
+\r
+// Java programming notes by Bob Hanson:\r
+// \r
+// There are a few motifs to avoid when optimizing Java code to work smoothly\r
+// with the J2S compiler:\r
+// \r
+// arrays: \r
+// \r
+// 1. an array with null elements cannot be typed and must be avoided.\r
+// 2. instances of Java "instance of" involving arrays must be found and convered to calls to Clazz.isA...\r
+// 3. new int[n][] must not be used. Use instead JU.AU.newInt2(n);\r
+// 4. new int[] { 1, 2, 3 } has problems because it creates simply [ ] and not IntArray32\r
+// \r
+// numbers:\r
+// \r
+// 1. Remember that EVERY number in JavaScript is a double -- doesn't matter if it is in IntArray32 or not. \r
+// 2. You cannot reliably use Java long, because doubles consume bits for the exponent which cannot be tested.\r
+// 3. Bit 31 of an integer is unreliable, since (int) -1 is now , not just 0zFFFFFFFF, and \r
+// FFFFFFFF + 1 = 100000000, not 0. In JavaScript, 0xFFFFFFFF is 4294967295, not -1.\r
+// This means that writeInt(b) will fail if b is negative. What you need is instead\r
+// writeInt((int)(b & 0xFFFFFFFFl) so that JavaScript knocks off the high bits explicitly. \r
+//\r
+// general:\r
+//\r
+// 1. j2sRequireImport xxxx is needed if xxxx is a method used in a static function\r
+// 2. URL.getContent() is not supported. Use other means based on URL.toString()\r
+// 3. It is critical for performance to avoid any significant amount of function overloading.\r
+// In particular, methods such as xxx(int a, int b) and xxx(float a, int b) MUST be renamed,\r
+// because JavaScript only has Number, and there is absolutely no way to tell these apart.\r
+// It's probably bad Java programming, anyway.\r
+// 4. Calls to super(...) can almost always be avoided. These trigger the SAEM\r
+// (searchAndExecuteMethod) call, and it is very destructive to performance.\r
+// Just find another way to do it. \r
+\r
+ // NOTES by Bob Hanson: \r
+ \r
+ // J2S class changes:\r
+\r
+ // BH 7/24/2015 6:48:50 AM adding optional ?j2sdebug flag on page URL\r
+ // -- switches to using j2s/core/corexxx.js, not j2s/core/corexxx.z.js \r
+ // -- adds ";//# sourceURL="+file in eval(js)\r
+ // -- enables DebugJS.$(msg) call to debugger;\r
+ // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger\r
+ // see https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources\r
+ // BH 7/23/2015 6:45:55 PM added sourceURL in each js class eval(), allowing full \r
+ // breakpoint debugging and code checking in Firefox and Chrome\r
+ // BH 7/19/2015 6:18:17 PM added os.name, line.separator, etc. to System.getProperty()\r
+ // BH 7/19/2015 5:39:10 PM added java.lang.System = System\r
+ // BH 7/19/2015 10:33:10 AM fix for SAEM equating "null" with number or boolean\r
+ // BH 7/18/2015 6:08:05 PM for Jmol I was able to remove the $private/$fx business, but now\r
+ // I see that in general that cannot be done. Thinking about a strategy...\r
+ // BH 7/18/2015 4:43:38 PM better handling of TypeError and InternalError for e.getMessage() and e.getStackTrace()\r
+ // BH 7/17/2015 11:51:15 AM adds class.getResource(name) and class.getResourceAsStream(name) \r
+ // BH 7/16/2015 7:56:49 PM general instantiation using any constructor (in Java here):\r
+ // BH x = class.forName("my.class.name").newInstance()\r
+ // BH or\r
+ // BH x = class.forName("my.class.name").getConstructor(String.class,String.class).newInstance(new Object[] {"test", "now"})\r
+ // BH 7/15/2015 11:34:58 PM adding System.lineSeparator()\r
+ // BH 7/15/2015 7:32:41 AM adding class.getCanonicalName == getName\r
+ // BH 5/31/2015 5:38:14 PM NPEExceptionPredicate fix\r
+ // BH 4/25/2015 9:16:12 AM SAEM misrepresnting Number as Object in parameters and Integer as Number \r
+ // BH 4/24/2015 7:32:54 AM Object.hashCode() and System.getIdentityHashCode() fail. changed to: return this._$hashcode || (this._$hashcode = ++Clazz._hashCode)\r
+ // BH 4/23/2015 9:08:59 AM Clazz.instanceOf(a, b) needs to check for a == b. \r
+ // BH 4/23/2015 9:08:59 AM xx.getContentType() is nonfunctional. Array.newInstance now defines a wrapper for .getClass().getComponentType() that works \r
+ // BH 4/12/2015 11:48:03 AM added Clazz.getStackTrace(-n) -- reports actual parameter values for n levels\r
+ // BH 4/10/2015 8:23:05 AM adding Int32Array.prototype.clone and Float64.prototype.clone\r
+ // BH 4/5/2015 8:12:57 AM refactoring j2slib (this file) to make private functions really private using var\r
+ // BH 4/3/2015 6:14:34 AM adding anonymous local "ClazzLoader" (Clazz._Loader) --> "_Loader"\r
+ // BH 4/3/2015 6:14:34 AM adding Clazz._Loader._classPending, Clazz._Loader._classCount\r
+ // BH 4/3/2015 6:14:34 AM adding Clazz._Loader._checkLoad \r
+ // -- forces asynchronous class loading\r
+ // -- builds Clazz._Loader._classPending and Clazz._classCount\r
+ // -- allows reporting \r
+ \r
+ // BH 3/24/2015 4:11:26 AM better file load failure message in _Loader.evaluate \r
+ // BH 2/28/2015 7:30:25 AM corrects newIntArray32() and newArray() for pre-defined arrays \r
+ // int[] a = new int[] {1,2,3,343};\r
+ // int[][] b = new int[][] {new int[]{4,5},new int[]{5,6}}; \r
+\r
+ // BH 9/29/2014 11:34:19 PM removing support for getClass().isArray() \r
+ // BH 8/29/2014 9:15:57 AM total reworking of Java2Script in preparation for all-asynchronous loading\r
+ // (currently sync loading is only for \r
+ // LOAD command and load() function without ASYNC\r
+ // getInterface() \r
+ // see JSmol.js and Jmol._isAsync flag\r
+ // BH 5/11/2015 5:58:42 AM adding __signatures for debugging SAEM issues \r
+ // BH 3/29/2015 8:12:44 PM System.getProperty(x, "") does not return ""\r
+ // BH 8/23/2014 10:04:19 AM cleaning up a few general methods; Clazz.removeArrayItem\r
+ // BH 6/1/2014 10:58:46 AM fix for Clazz.isAP() not working\r
+ // BH 5/26/2014 5:19:29 PM removing superConstructor call in creating Enum constants\r
+ // BH 4/1/2014 7:55:54 PM removing all $fz references and instances where sub/super classes have same private function names\r
+ // BH 4/1/2014 4:47:30 PM all $_X removed; this is taken care of by Google Closure Compiler\r
+ // BH 4/1/2014 6:40:08 AM removing ClassLoader -- equals Clazz._Loader\r
+ // BH 4/1/2014 6:40:08 AM removing ClassLoaderProgressMonitor -- equals _LoaderProgressMonitor\r
+ // BH 4/1/2014 6:17:21 AM removing Class -- only used for "Class.forName" in Jmol, which ANT will now change to "Clazz._4Name"\r
+ // BH 3/7/2014 9:05:06 AM Array.prototype.toString should not be aliased. -- http://sourceforge.net/p/jmol/bugs/560/ with Google Visualization\r
+\r
+ // BH 1/30/2014 12:54:22 PM gave all field variables prefix underscore. This allows Google Closure Compiler to skip them. \r
+ // BH 12/3/2013 3:39:57 PM window["j2s.lib"].base implemented\r
+ // BH 12/1/2013 5:34:21 AM removed _LoaderProgressMonitor.initialize and all Clazz.event business; handled by Jmol.clearVars()\r
+ // BH 11/30/2013 12:43:58 PM adding Clazz.arrayIs() -- avoids Number.constructor.toString() infinite recursion\r
+ // BH 11/29/2013 6:33:51 AM adding Clazz._profiler -- reports use of SAEM\r
+ // BH 11/10/2013 9:02:20 AM fixing fading in MSIE \r
+ // BH 11/3/2013 7:21:39 AM additional wrapping functions for better compressibility\r
+ // BH 10/30/2013 8:10:58 AM added getClass().getResource() -- returning a relative string, not a URL\r
+ // BH 10/30/2013 6:43:00 AM removed second System def and added System.$props and default System.property "line.separator" \r
+ // BH 6/15/2013 8:02:07 AM corrections to Class.isAS to return true if first element is null\r
+ // BH 6/14/2013 4:41:09 PM corrections to Clazz.isAI and related methods to include check for null object\r
+ // BH 3/17/2013 11:54:28 AM adds stackTrace for ERROR \r
+\r
+ // BH 3/13/2013 6:58:26 PM adds Clazz.clone(me) for BS clone \r
+ // BH 3/12/2013 6:30:53 AM fixes Clazz.exceptionOf for ERROR condition trapping\r
+ // BH 3/2/2013 9:09:53 AM delete globals c$ and $fz\r
+ // BH 3/2/2013 9:10:45 AM optimizing defineMethod using "look no further" "@" parameter designation (see "\\@" below -- removed 3/23/13)\r
+ // BH 2/27/2013 optimizing Clazz.getParamsType for common cases () and (Number)\r
+ // BH 2/27/2013 optimizing SAEM delegation for hashCode and equals -- disallows overloading of equals(Object)\r
+ \r
+ // BH 2/23/2013 found String.replaceAll does not work -- solution was to never call it.\r
+ // BH 2/9/2013 9:18:03 PM Int32Array/Float64Array fixed for MSIE9\r
+ // BH 1/25/2013 1:55:31 AM moved package.js from j2s/java to j2s/core \r
+ // BH 1/17/2013 4:37:17 PM String.compareTo() added\r
+ // BH 1/17/2013 4:52:22 PM Int32Array and Float64Array may not have .prototype.sort method\r
+ // BH 1/16/2013 6:20:34 PM Float64Array not available in Safari 5.1\r
+ // BH 1/14/2013 11:28:58 PM Going to all doubles in JavaScript (Float64Array, not Float32Array)\r
+ // so that (new float[] {13.48f})[0] == 13.48f, effectively\r
+\r
+ // BH 1/14/2013 12:53:41 AM Fix for Opera 10 not loading any files\r
+ // BH 1/13/2013 11:50:11 PM Fix for MSIE not loading (nonbinary) files locally\r
+ \r
+ // BH 12/1/2012 9:52:26 AM Compiler note: Thread.start() cannot be executed within the constructor;\r
+ \r
+ // BH 11/24/2012 11:08:39 AM removed unneeded sections\r
+ // BH 11/24/2012 10:23:22 AM all XHR uses sync loading (_Loader.setLoadingMode)\r
+ // BH 11/21/2012 7:30:06 PM if (base) map["@" + pkg] = base; critical for multiple applets\r
+\r
+ // BH 10/8/2012 3:27:41 PM if (clazzName.indexOf("Array") >= 0) return "Array"; in Clazz.getClassName for function\r
+ // BH removed Clazz.ie$plit = "\\2".split (/\\/).length == 1; unnecessary; using RegEx slows process significantly in all browsers\r
+ // BH 10/6/12 added Int32Array, Float32Array, newArrayBH, upgraded java.lang and java.io\r
+ // BH added Integer.bitCount in core.z.js\r
+ // BH changed alert to Clazz.alert in java.lang.Class.js *.ClassLoader.js, java.lang.thread.js\r
+ // BH removed toString from innerFunctionNames due to infinite recursion\r
+ // BH note: Logger.error(null, e) does not work -- get no constructor for (String) (TypeError)\r
+ // BH added j2s.lib.console\r
+ // BH allowed for alias="."\r
+ // BH removed alert def --> Clazz.alert\r
+ // BH added wrapper at line 2856 \r
+ // BH newArray fix at line 2205\r
+ // BH System.getProperty fix at line 6693\r
+ // BH added Enum .value() method at line 2183\r
+ // BH added System.getSecurityManager() at end\r
+ // BH added String.contains() at end\r
+ // BH added System.gc() at end\r
+ // BH added Clazz.exceptionOf = updated\r
+ // BH added String.getBytes() at end\r
+ \r
+\r
+LoadClazz = function() {\r
+\r
+// BH This is the ONLY global used in J2S now. I do not think it is necessary,\r
+// but it is created by the compiler, and I have not found a work-around.\r
+// it is used as a local variable in class definitions to point to the \r
+// current method. See Clazz.p0p and Clazz.pu$h\r
+\r
+c$ = null;\r
+\r
+if (!window["j2s.clazzloaded"])\r
+ window["j2s.clazzloaded"] = false;\r
+\r
+if (window["j2s.clazzloaded"])return;\r
+\r
+window["j2s.clazzloaded"] = true;\r
+\r
+window["j2s.object.native"] = true;\r
+\r
+ // Clazz changes:\r
+\r
+ /* http://j2s.sf.net/ *//******************************************************************************\r
+ * Copyright (c) 2007 java2script.org and others.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * Zhou Renjian - initial API and implementation\r
+ *****************************************************************************/\r
+/*******\r
+ * @author zhou renjian\r
+ * @create Nov 5, 2005\r
+ *******/\r
+ \r
+\r
+/**\r
+ * Class Clazz. All the methods are static in this class.\r
+ */\r
+/* static */\r
+/*Class = */ Clazz = {\r
+ _isQuiet: false,\r
+ _debugging: false\r
+};\r
+\r
+;(function(Clazz, Jmol) {\r
+\r
+\r
+try {\r
+Clazz._debugging = (document.location.href.indexOf("j2sdebug") >= 0);\r
+} catch (e) {\r
+}\r
+var __debuggingBH = false;\r
+var _globals = ["j2s.clazzloaded", "j2s.object.native"];\r
+Clazz.setGlobal = function(a, v) {\r
+ _globals.push(a);\r
+ window[a] = v;\r
+}\r
+\r
+Clazz.getGlobals = function() {\r
+ return _globals.sort().join("\n");\r
+}\r
+\r
+Clazz.setConsoleDiv = function(d) {\r
+ window["j2s.lib"] && (window["j2s.lib"].console = d);\r
+};\r
+\r
+// BH Clazz.getProfile monitors exactly what is being delegated with SAEM,\r
+// which could be a bottle-neck for function calling.\r
+// This is critical for performance optimization.\r
+\r
+// Jmol.getProfile()\r
+\r
+var _profile = (window["j2s.doProfile"] && self.JSON ? {} : null);\r
+\r
+NullObject = function () {};\r
+\r
+/* protected */\r
+Clazz._supportsNativeObject = window["j2s.object.native"];\r
+\r
+if (Clazz._supportsNativeObject) {\r
+ Clazz._O = function () {};\r
+ Clazz._O.__CLASS_NAME__ = "Object";\r
+ Clazz._O["getClass"] = function () { return Clazz._O; }; \r
+} else {\r
+ Clazz._O = Object;\r
+}\r
+\r
+Clazz.Console = {};\r
+Clazz.dateToString = Date.prototype.toString;\r
+Clazz._hashCode = 0;\r
+\r
+var addProto = function(proto, name, func) {\r
+ return proto[name] = func;\r
+};\r
+\r
+;(function(proto) {\r
+ addProto(proto, "equals", function (obj) {\r
+ return this == obj;\r
+ });\r
+\r
+ addProto(proto, "hashCode", function () {\r
+ \r
+ return this._$hashcode || (this._$hashcode = ++Clazz._hashCode)\r
+\r
+ \r
+ try {\r
+ return this.toString ().hashCode ();\r
+ } catch (e) {\r
+ var str = ":";\r
+ for (var s in this) {\r
+ str += s + ":"\r
+ }\r
+ return str.hashCode ();\r
+ }\r
+ });\r
+\r
+ addProto(proto, "getClass", function () { return Clazz.getClass (this); });\r
+\r
+ addProto(proto, "clone", function () { return Clazz.clone(this); });\r
+\r
+ Clazz.clone = function(me) {\r
+ // BH allows @j2sNative access without super constructor\r
+ var o = new me.constructor();\r
+ for (var i in me) {\r
+ o[i] = me[i];\r
+ }\r
+ return o;\r
+ }\r
+/*\r
+ * Methods for thread in Object\r
+ */\r
+ addProto(proto, "finalize", function () {});\r
+ addProto(proto, "notify", function () {});\r
+ addProto(proto, "notifyAll", function () {});\r
+ addProto(proto, "wait", function () {});\r
+ addProto(proto, "to$tring", Object.prototype.toString);\r
+ addProto(proto, "toString", function () { return (this.__CLASS_NAME__ ? "[" + this.__CLASS_NAME__ + " object]" : this.to$tring.apply(this, arguments)); });\r
+ Clazz._extendedObjectMethods = [ "equals", "hashCode", "getClass", "clone", "finalize", "notify", "notifyAll", "wait", "to$tring", "toString" ];\r
+\r
+})(Clazz._O.prototype);\r
+\r
+Clazz.extendJO = function(c, name) { \r
+ if (name)\r
+ c.__CLASS_NAME__ = c.prototype.__CLASS_NAME__ = name;\r
+ if (Clazz._supportsNativeObject) {\r
+ for (var i = 0; i < Clazz._extendedObjectMethods.length; i++) {\r
+ var p = Clazz._extendedObjectMethods[i];\r
+ addProto(c.prototype, p, Clazz._O.prototype[p]);\r
+ }\r
+ }\r
+};\r
+\r
+/**\r
+ * Try to fix bug on Safari\r
+ */\r
+//InternalFunction = Object;\r
+\r
+Clazz.extractClassName = function(clazzStr) {\r
+ // [object Int32Array]\r
+ var clazzName = clazzStr.substring (1, clazzStr.length - 1);\r
+ return (clazzName.indexOf("Array") >= 0 ? "Array" // BH -- for Float64Array and Int32Array\r
+ : clazzName.indexOf ("object ") >= 0 ? clazzName.substring (7) // IE\r
+ : clazzName);\r
+}\r
+/**\r
+ * Return the class name of the given class or object.\r
+ *\r
+ * @param clazzHost given class or object\r
+ * @return class name\r
+ */\r
+/* public */\r
+Clazz.getClassName = function (obj) {\r
+ if (obj == null)\r
+ return "NullObject";\r
+ if (obj instanceof Clazz.CastedNull)\r
+ return obj.clazzName;\r
+ switch(typeof obj) {\r
+ case "number":\r
+ return "n";\r
+ case "boolean":\r
+ return "b";\r
+ case "string":\r
+ // Always treat the constant string as String object.\r
+ // This will be compatiable with Java String instance.\r
+ return "String";\r
+ case "function":\r
+ if (obj.__CLASS_NAME__)\r
+ return (arguments[1] ? obj.__CLASS_NAME__ : "Class"); /* user defined class name */\r
+ var s = obj.toString();\r
+ var idx0 = s.indexOf("function");\r
+ if (idx0 < 0)\r
+ return (s.charAt(0) == '[' ? Clazz.extractClassName(s) : s.replace(/[^a-zA-Z0-9]/g, ''));\r
+ var idx1 = idx0 + 8;\r
+ var idx2 = s.indexOf ("(", idx1);\r
+ if (idx2 < 0)\r
+ return "Object";\r
+ s = s.substring (idx1, idx2);\r
+ if (s.indexOf("Array") >= 0)\r
+ return "Array"; \r
+ s = s.replace (/^\s+/, "").replace (/\s+$/, "");\r
+ return (s == "anonymous" || s == "" ? "Function" : s);\r
+ case "object":\r
+ if (obj.__CLASS_NAME__) // user defined class name\r
+ return obj.__CLASS_NAME__;\r
+ if (!obj.constructor)\r
+ return "Object"; // For HTML Element in IE\r
+ if (!obj.constructor.__CLASS_NAME__) {\r
+ if (obj instanceof Number)\r
+ return "Number";\r
+ if (obj instanceof Boolean)\r
+ return "Boolean";\r
+ if (obj instanceof Array)\r
+ return "Array";\r
+ var s = obj.toString();\r
+ // "[object Int32Array]"\r
+ if (s.charAt(0) == '[')\r
+ return Clazz.extractClassName(s);\r
+ }\r
+ return Clazz.getClassName (obj.constructor, true);\r
+ }\r
+ // some new, unidentified class\r
+ return "Object";\r
+};\r
+/**\r
+ * Return the class of the given class or object.\r
+ *\r
+ * @param clazzHost given class or object\r
+ * @return class name\r
+ */\r
+/* public */\r
+Clazz.getClass = function (clazzHost) {\r
+ if (!clazzHost)\r
+ return Clazz._O; // null/undefined is always treated as Object\r
+ if (typeof clazzHost == "function")\r
+ return clazzHost;\r
+ var clazzName;\r
+ if (clazzHost instanceof Clazz.CastedNull) {\r
+ clazzName = clazzHost.clazzName;\r
+ } else {\r
+ switch (typeof clazzHost) {\r
+ case "string":\r
+ return String;\r
+ case "object":\r
+ if (!clazzHost.__CLASS_NAME__)\r
+ return (clazzHost.constructor || Clazz._O);\r
+ clazzName = clazzHost.__CLASS_NAME__;\r
+ break;\r
+ default:\r
+ return clazzHost.constructor;\r
+ }\r
+ }\r
+ return Clazz.evalType(clazzName, true);\r
+};\r
+\r
+\r
+/* private */\r
+var checkInnerFunction = function (hostSuper, funName) {\r
+ for (var k = 0; k < Clazz.innerFunctionNames.length; k++)\r
+ if (funName == Clazz.innerFunctionNames[k] && \r
+ Clazz._innerFunctions[funName] === hostSuper[funName])\r
+ return true;\r
+ return false;\r
+};\r
+\r
+var args4InheritClass = function () {};\r
+\r
+Clazz.inheritArgs = new args4InheritClass ();\r
+\r
+/**\r
+ * Inherit class with "extends" keyword and also copy those static members. \r
+ * Example, as in Java, if NAME is a static member of ClassA, and ClassB \r
+ * extends ClassA then ClassB.NAME can be accessed in some ways.\r
+ *\r
+ * @param clazzThis child class to be extended\r
+ * @param clazzSuper super class which is inherited from\r
+ * @param objSuper super class instance\r
+ */\r
+/* protected */\r
+Clazz.inheritClass = function (clazzThis, clazzSuper, objSuper) {\r
+ //var thisClassName = Clazz.getClassName (clazzThis);\r
+ for (var o in clazzSuper) {\r
+ if (o != "b$" && o != "prototype" && o != "superClazz"\r
+ && o != "__CLASS_NAME__" && o != "implementz"\r
+ && !checkInnerFunction (clazzSuper, o)) {\r
+ clazzThis[o] = clazzSuper[o];\r
+ }\r
+ }\r
+ if (Clazz.unloadedClasses[Clazz.getClassName(clazzThis, true)]) {\r
+ // Don't change clazzThis.protoype! Keep it!\r
+ } else if (objSuper) {\r
+ // ! Unsafe reference prototype to an instance!\r
+ // Feb 19, 2006 --josson\r
+ // OK for this reference to an instance, as this is anonymous instance,\r
+ // which is not referenced elsewhere.\r
+ // March 13, 2006\r
+ clazzThis.prototype = objSuper; \r
+ } else if (clazzSuper !== Number) {\r
+ clazzThis.prototype = new clazzSuper (Clazz.inheritArgs);\r
+ } else { // Number\r
+ clazzThis.prototype = new Number ();\r
+ }\r
+ clazzThis.superClazz = clazzSuper;\r
+ /*\r
+ * Is it necessary to reassign the class name?\r
+ * Mar 10, 2006 --josson\r
+ */\r
+ //clazzThis.__CLASS_NAME__ = thisClassName;\r
+ clazzThis.prototype.__CLASS_NAME__ = clazzThis.__CLASS_NAME__;\r
+};\r
+\r
+/**\r
+ * Implementation of Java's keyword "implements".\r
+ * As in JavaScript there are on "implements" keyword implemented, a property\r
+ * of "implementz" is added to the class to record the interfaces the class\r
+ * is implemented.\r
+ * \r
+ * @param clazzThis the class to implement\r
+ * @param interfacez Array of interfaces\r
+ */\r
+/* public */\r
+Clazz.implementOf = function (clazzThis, interfacez) {\r
+ if (arguments.length >= 2) {\r
+ if (!clazzThis.implementz)\r
+ clazzThis.implementz = [];\r
+ var impls = clazzThis.implementz;\r
+ if (arguments.length == 2) {\r
+ if (typeof interfacez == "function") {\r
+ impls.push(interfacez);\r
+ copyProperties(clazzThis, interfacez);\r
+ } else if (interfacez instanceof Array) {\r
+ for (var i = 0; i < interfacez.length; i++) {\r
+ impls.push(interfacez[i]);\r
+ copyProperties(clazzThis, interfacez[i]);\r
+ }\r
+ }\r
+ } else {\r
+ for (var i = 1; i < arguments.length; i++) {\r
+ impls.push(arguments[i]);\r
+ copyProperties(clazzThis, arguments[i]);\r
+ }\r
+ }\r
+ }\r
+};\r
+\r
+/*\r
+ * Copy members of interface\r
+ */\r
+/* private */\r
+var copyProperties = function(clazzThis, clazzSuper) {\r
+ for (var o in clazzSuper)\r
+ if (o != "b$" \r
+ && o != "prototype" && o != "superClazz"\r
+ && o != "__CLASS_NAME__" && o != "implementz"\r
+ && (typeof clazzSuper[o] != "function" || !checkInnerFunction(clazzSuper, o)))\r
+ clazzThis[o] = clazzThis.prototype[o] = clazzSuper[o];\r
+};\r
+\r
+/**\r
+ * TODO: More should be done for interface's inheritance\r
+ */\r
+/* public */\r
+Clazz.extendInterface = Clazz.implementOf;\r
+\r
+/* protected */\r
+Clazz.equalsOrExtendsLevel = function (clazzThis, clazzAncestor) {\r
+ if (clazzThis === clazzAncestor)\r
+ return 0;\r
+ if (clazzThis.implementz) {\r
+ var impls = clazzThis.implementz;\r
+ for (var i = 0; i < impls.length; i++) {\r
+ var level = Clazz.equalsOrExtendsLevel (impls[i], clazzAncestor);\r
+ if (level >= 0)\r
+ return level + 1;\r
+ }\r
+ }\r
+ return -1;\r
+};\r
+\r
+/* protected */\r
+Clazz.getInheritedLevel = function (clazzTarget, clazzBase) {\r
+ if (clazzTarget === clazzBase)\r
+ return 0;\r
+ var isTgtStr = (typeof clazzTarget == "string");\r
+ if (isTgtStr && ("void" == clazzTarget || "unknown" == clazzTarget))\r
+ return -1;\r
+ var isBaseStr = (typeof clazzBase == "string");\r
+ if (isBaseStr && ("void" == clazzBase || "unknown" == clazzBase))\r
+ return -1;\r
+ if (clazzTarget === (isTgtStr ? "NullObject" : NullObject)) {\r
+ switch (clazzBase) {\r
+ case "n":\r
+ case "b":\r
+ return -1;\r
+ case Number:\r
+ case Boolean:\r
+ case NullObject:\r
+ break;\r
+ default:\r
+ return 0;\r
+ }\r
+ }\r
+ if (isTgtStr)\r
+ clazzTarget = Clazz.evalType(clazzTarget);\r
+ if (isBaseStr)\r
+ clazzBase = Clazz.evalType(clazzBase);\r
+ if (!clazzBase || !clazzTarget)\r
+ return -1;\r
+ var level = 0;\r
+ var zzalc = clazzTarget; // zzalc <--> clazz\r
+ while (zzalc !== clazzBase && level < 10) {\r
+ /* maybe clazzBase is interface */\r
+ if (zzalc.implementz) {\r
+ var impls = zzalc.implementz;\r
+ for (var i = 0; i < impls.length; i++) {\r
+ var implsLevel = Clazz.equalsOrExtendsLevel (impls[i], clazzBase);\r
+ if (implsLevel >= 0)\r
+ return level + implsLevel + 1;\r
+ }\r
+ }\r
+ zzalc = zzalc.superClazz;\r
+ if (!zzalc)\r
+ return (clazzBase === Object || clazzBase === Clazz._O ? \r
+ // getInheritedLevel(String, CharSequence) == 1\r
+ // getInheritedLevel(String, Object) == 1.5\r
+ // So if both #test(CharSequence) and #test(Object) existed,\r
+ // #test("hello") will correctly call #test(CharSequence)\r
+ // instead of #test(Object).\r
+ level + 1.5 // 1.5! Special!\r
+ : -1);\r
+ level++;\r
+ }\r
+ return level;\r
+};\r
+\r
+\r
+/**\r
+ * Implements Java's keyword "instanceof" in JavaScript's way.\r
+ * As in JavaScript part of the object inheritance is implemented in only-\r
+ * JavaScript way.\r
+ *\r
+ * @param obj the object to be tested\r
+ * @param clazz the class to be checked\r
+ * @return whether the object is an instance of the class\r
+ */\r
+/* public */\r
+Clazz.instanceOf = function (obj, clazz) {\r
+ // allows obj to be a class already, from arrayX.getClass().isInstance(y)\r
+ return (obj != null && clazz && (obj == clazz || obj instanceof clazz || Clazz.getInheritedLevel(Clazz.getClassName(obj), clazz) >= 0));\r
+};\r
+\r
+/**\r
+ * Call super method of the class. \r
+ * The same effect as Java's expression:\r
+ * <code> super.* () </code>\r
+ * \r
+ * @param objThis host object\r
+ * @param clazzThis class of declaring method scope. It's hard to determine \r
+ * which super class is right class for "super.*()" call when it's in runtime\r
+ * environment. For example,\r
+ * 1. ClasssA has method #run()\r
+ * 2. ClassB extends ClassA overriding method #run() with "super.run()" call\r
+ * 3. ClassC extends ClassB\r
+ * 4. objC is an instance of ClassC\r
+ * Now we have to decide which super #run() method is to be invoked. Without\r
+ * explicit clazzThis parameter, we only know that objC.getClass() is ClassC \r
+ * and current method scope is #run(). We do not known we are in scope \r
+ * ClassA#run() or scope of ClassB#run(). if ClassB is given, Clazz can search\r
+ * all super methods that are before ClassB and get the correct super method.\r
+ * This is the reason why there must be an extra clazzThis parameter.\r
+ * @param funName method name to be called\r
+ * @param funParams Array of method parameters\r
+ */\r
+/* public */\r
+Clazz.superCall = function (objThis, clazzThis, funName, funParams) {\r
+ var fx = null;\r
+ var i = -1;\r
+ var clazzFun = objThis[funName];\r
+ if (clazzFun) {\r
+ if (clazzFun.claxxOwner) { \r
+ // claxxOwner is a mark for methods that is single.\r
+ if (clazzFun.claxxOwner !== clazzThis) {\r
+ // This is a single method, call directly!\r
+ fx = clazzFun;\r
+ \r
+ }\r
+ } else if (!clazzFun.stacks && !(clazzFun.lastClaxxRef\r
+ && clazzFun.lastClaxxRef.prototype[funName]\r
+ && clazzFun.lastClaxxRef.prototype[funName].stacks)) { // super.toString\r
+ fx = clazzFun;\r
+ } else { // normal wrapped method\r
+ var stacks = clazzFun.stacks;\r
+ if (!stacks)\r
+ stacks = clazzFun.lastClaxxRef.prototype[funName].stacks;\r
+ for (i = stacks.length; --i >= 0;) {\r
+ /*\r
+ * Once super call is computed precisely, there are no need \r
+ * to calculate the inherited level but just an equals\r
+ * comparision\r
+ */\r
+ //var level = Clazz.getInheritedLevel (clazzThis, stacks[i]);\r
+ if (clazzThis === stacks[i]) { // level == 0\r
+ if (i > 0) {\r
+ fx = stacks[--i].prototype[funName];\r
+ } else {\r
+ /*\r
+ * Will this case be reachable?\r
+ * March 4, 2006\r
+ * Should never reach here if all things are converted\r
+ * by Java2Script\r
+ */\r
+ fx = stacks[0].prototype[funName]["\\unknown"];\r
+ }\r
+ break;\r
+ } else if (Clazz.getInheritedLevel (clazzThis, stacks[i]) > 0) {\r
+ fx = stacks[i].prototype[funName];\r
+ break;\r
+ }\r
+ } // end of for loop\r
+ } // end of normal wrapped method\r
+ } // end of clazzFun\r
+ if (!fx) {\r
+ if (funName != "construct") {\r
+ Clazz.alert (["j2slib","no class found",(funParams).typeString])\r
+ newMethodNotFoundException(objThis, clazzThis, funName, \r
+ Clazz.getParamsType(funParams).typeString); \r
+ }\r
+ /* there are members which are initialized out of the constructor */\r
+ /* No super constructor! */\r
+ return;\r
+ }\r
+ /* there are members which are initialized out of the constructor */\r
+ if (i == 0 && funName == "construct") {\r
+ var ss = clazzFun.stacks;\r
+ if (ss && !ss[0].superClazz && ss[0].con$truct)\r
+ ss[0].con$truct.apply (objThis, []);\r
+ }\r
+ /*# {$no.debug.support} >>x #*/\r
+ /* not used in Jmol\r
+ if (Clazz.tracingCalling) {\r
+ var caller = arguments.callee.caller;\r
+ if (caller === Clazz.superConstructor) {\r
+ caller = caller.arguments.callee.caller;\r
+ }\r
+ Clazz._callingStackTraces.push(new Clazz.callingStack (caller, clazzThis));\r
+ var ret = fx.apply (objThis, (funParams == null) ? [] : funParams);\r
+ Clazz._callingStackTraces.pop();\r
+ return ret;\r
+ }\r
+ */\r
+ /*# x<< #*/\r
+ return fx.apply (objThis, funParams || []);\r
+};\r
+\r
+/**\r
+ * Call super constructor of the class. \r
+ * The same effect as Java's expression: \r
+ * <code> super () </code>\r
+ */\r
+/* public */\r
+Clazz.superConstructor = function (objThis, clazzThis, funParams) {\r
+ Clazz.superCall (objThis, clazzThis, "construct", funParams);\r
+ /* If there are members which are initialized out of the constructor */\r
+ if (clazzThis.con$truct) {\r
+ clazzThis.con$truct.apply (objThis, []);\r
+ }\r
+};\r
+\r
+/**\r
+ * Class for null with a given class as to be casted.\r
+ * This class will be used as an implementation of Java's casting way.\r
+ * For example,\r
+ * <code> this.call ((String) null); </code>\r
+ */\r
+/* public */\r
+Clazz.CastedNull = function (asClazz) {\r
+ if (asClazz) {\r
+ if (asClazz instanceof String) {\r
+ this.clazzName = asClazz;\r
+ } else if (asClazz instanceof Function) {\r
+ this.clazzName = Clazz.getClassName (asClazz, true);\r
+ } else {\r
+ this.clazzName = "" + asClazz;\r
+ }\r
+ } else {\r
+ this.clazzName = "Object";\r
+ }\r
+ this.toString = function () {\r
+ return null;\r
+ };\r
+ this.valueOf = function () {\r
+ return null;\r
+ };\r
+};\r
+\r
+/**\r
+ * API for Java's casting null.\r
+ * @see Clazz.CastedNull\r
+ *\r
+ * @param asClazz given class\r
+ * @return an instance of class Clazz.CastedNull\r
+ */\r
+/* public */\r
+Clazz.castNullAs = function (asClazz) {\r
+ return new Clazz.CastedNull (asClazz);\r
+};\r
+\r
+/////////////////////////// Exception handling ////////////////////////////\r
+\r
+/*\r
+ * Use to mark that the Throwable instance is created or not.\r
+ * \r
+ * Called from java.lang.Throwable, as defined in JSmolJavaExt.js\r
+ * \r
+ * The underscore is important - it tells the JSmol ANT task to NOT \r
+ * turn this into Clazz_initializingException, because coreBottom2.js does \r
+ * not include that call, and so Google Closure Compiler does not minify it.\r
+ * \r
+ */\r
+/* public */\r
+Clazz._initializingException = false;\r
+\r
+/**\r
+ * BH: used in Throwable\r
+ * \r
+ */ \r
+/* public */\r
+Clazz._callingStackTraces = [];\r
+\r
+/** \r
+ * MethodException will be used as a signal to notify that the method is\r
+ * not found in the current clazz hierarchy.\r
+ */\r
+/* private */\r
+var MethodException = function () {\r
+ this.toString = function () {\r
+ return "J2S MethodException";\r
+ };\r
+};\r
+/* private */\r
+//var MethodNotFoundException = function () {\r
+// this.toString = function () {\r
+// return "J2S MethodNotFoundException";\r
+// };\r
+//};\r
+\r
+ var _isNPEExceptionPredicate;\r
+\r
+/* super private */\r
+;(function() { \r
+ /* sgurin: native exception detection mechanism. Only NullPointerException detected and wrapped to java excepions */\r
+ /** private utility method for creating a general regexp that can be used later \r
+ * for detecting a certain kind of native exceptions. use with error messages like "blabla IDENTIFIER blabla"\r
+ * @param msg String - the error message\r
+ * @param spliterName String, must be contained once in msg\r
+ * spliterRegex String, a string with the regexp literal for identifying the spitter in exception further error messages.\r
+ */\r
+ // reproduce NullPointerException for knowing how to detect them, and create detector function Clazz._isNPEExceptionPredicate\r
+ var $$o$$ = null;\r
+ \r
+ try {\r
+ $$o$$.hello();\r
+ } catch (e) {\r
+ var _ex_reg = function(msg, spliterName, spliterRegex) {\r
+ if(!spliterRegex) \r
+ spliterRegex="[^\\s]+"; \r
+ var idx = msg.indexOf (spliterName), \r
+ str = msg.substring (0, idx) + spliterRegex + msg.substring(idx + spliterName.length), \r
+ regexp = new RegExp("^"+str+"$");\r
+ return regexp;\r
+ };\r
+ if(/Opera[\/\s](\d+\.\d+)/.test(navigator.userAgent)) {// opera throws an exception with fixed messages like "Statement on line 23: Cannot convert undefined or null to Object Backtrace: Line....long text... " \r
+ var idx1 = e.message.indexOf(":"), idx2 = e.message.indexOf(":", idx1+2);\r
+ var _NPEMsgFragment = e.message.substr(idx1+1, idx2-idx1-20);\r
+ _isNPEExceptionPredicate = function(e) { return e.message.indexOf(_NPEMsgFragment)!=-1; };\r
+ } else if(navigator.userAgent.toLowerCase().indexOf("webkit")!=-1) { //webkit, google chrome prints the property name accessed. \r
+ var _exceptionNPERegExp = _ex_reg(e.message, "hello");\r
+ _isNPEExceptionPredicate = function(e) { return _exceptionNPERegExp.test(e.message); };\r
+ } else {// ie, firefox and others print the name of the object accessed: \r
+ var _exceptionNPERegExp = _ex_reg(e.message, "$$o$$");\r
+ _isNPEExceptionPredicate = function(e) { return _exceptionNPERegExp.test(e.message); };\r
+ } \r
+ };\r
+})();\r
+\r
+/**sgurin\r
+ * Implements Java's keyword "instanceof" in JavaScript's way **for exception objects**.\r
+ * \r
+ * calls Clazz.instanceOf if e is a Java exception. If not, try to detect known native \r
+ * exceptions, like native NullPointerExceptions and wrap it into a Java exception and \r
+ * call Clazz.instanceOf again. if the native exception can't be wrapped, false is returned.\r
+ * \r
+ * @param obj the object to be tested\r
+ * @param clazz the class to be checked\r
+ * @return whether the object is an instance of the class\r
+ * @author: sgurin\r
+ */\r
+Clazz.exceptionOf = function(e, clazz) {\r
+ if(e.__CLASS_NAME__)\r
+ return Clazz.instanceOf(e, clazz);\r
+ if (!e.getMessage) {\r
+ e.getMessage = function() {return "" + this};\r
+ }\r
+ if (!e.printStackTrace) {\r
+ e.printStackTrace = function(){};\r
+ alert(e + " try/catch path:" + Clazz.getStackTrace(-10));\r
+ }\r
+ if(clazz == Error) {\r
+ if (("" + e).indexOf("Error") < 0)\r
+ return false;\r
+ System.out.println (Clazz.getStackTrace());\r
+ return true;\r
+ // everything here is a Java Exception, not a Java Error\r
+ }\r
+ return (clazz == Exception || clazz == Throwable\r
+ || clazz == NullPointerException && _isNPEExceptionPredicate(e));\r
+};\r
+\r
+/**\r
+ * BH need to limit this, as JavaScript call stack may be recursive\r
+ */ \r
+Clazz.getStackTrace = function(n) {\r
+ n || (n = 25);\r
+ // updateNode and updateParents cause infinite loop here\r
+ var s = "\n";\r
+ var c = arguments.callee;\r
+ var showParams = (n < 0);\r
+ if (showParams)\r
+ n = -n;\r
+ for (var i = 0; i < n; i++) {\r
+ if (!(c = c.caller))\r
+ break;\r
+ var sig = (c.toString ? c.toString().substring(0, c.toString().indexOf("{")) : "<native method>");\r
+ s += i + " " + (c.exName ? (c.claxxOwner ? c.claxxOwner.__CLASS_NAME__ + "." : "") + c.exName + sig.replace(/function /,""): sig) + "\n";\r
+ if (c == c.caller) {\r
+ s += "<recursing>\n";\r
+ break;\r
+ }\r
+ if (showParams) {\r
+ var args = c.arguments;\r
+ for (var j = 0; j < args.length; j++) {\r
+ var sa = "" + args[j];\r
+ if (sa.length > 60)\r
+ sa = sa.substring(0, 60) + "...";\r
+ s += " args[" + j + "]=" + sa.replace(/\s+/g," ") + "\n";\r
+ }\r
+ }\r
+ }\r
+ return s;\r
+}\r
+\r
+///////////////////// method creation ////////////////////////////////\r
+\r
+/**\r
+ * Make constructor for the class with the given function body and parameters\r
+ * signature.\r
+ * \r
+ * @param clazzThis host class\r
+ * @param funBody constructor body\r
+ * @param funParams constructor parameters signature\r
+ */\r
+/* public */\r
+Clazz.makeConstructor = function (clazzThis, funBody, funParams) {\r
+ Clazz.defineMethod (clazzThis, "construct", funBody, funParams);\r
+ if (clazzThis.con$truct) {\r
+ clazzThis.con$truct.index = clazzThis.con$truct.stacks.length;\r
+ }\r
+ //clazzThis.con$truct = clazzThis.prototype.con$truct = null;\r
+};\r
+\r
+/**\r
+ * Override constructor for the class with the given function body and\r
+ * parameters signature.\r
+ * \r
+ * @param clazzThis host class\r
+ * @param funBody constructor body\r
+ * @param funParams constructor parameters signature\r
+ */\r
+/* public */\r
+Clazz.overrideConstructor = function (clazzThis, funBody, funParams) {\r
+ Clazz.overrideMethod (clazzThis, "construct", funBody, funParams);\r
+ if (clazzThis.con$truct) {\r
+ clazzThis.con$truct.index = clazzThis.con$truct.stacks.length;\r
+ }\r
+ //clazzThis.con$truct = clazzThis.prototype.con$truct = null;\r
+};\r
+\r
+\r
+/*\r
+ * Define method for the class with the given method name and method\r
+ * body and method parameter signature.\r
+ *\r
+ * @param clazzThis host class in which the method to be defined\r
+ * @param funName method name\r
+ * @param funBody function object, e.g function () { ... }\r
+ * @param funParams paramether signature, e.g ["string", "number"]\r
+ * @return method of the given name. The method may be funBody or a wrapper\r
+ * of the given funBody.\r
+ */\r
+/* public */\r
+Clazz.defineMethod = function (clazzThis, funName, funBody, funParams) {\r
+ if (Clazz.assureInnerClass) \r
+ Clazz.assureInnerClass(clazzThis, funBody);\r
+ funBody.exName = funName;\r
+ var fpName = formatParameters(funParams);\r
+ var proto = clazzThis.prototype;\r
+ var f$ = proto[funName];\r
+ if (Clazz._Loader._checkLoad)\r
+ checkDuplicate(clazzThis, funName, fpName);\r
+ if (!f$ || (f$.claxxOwner === clazzThis && f$.funParams == fpName)) {\r
+ // property "funParams" will be used as a mark of only-one method\r
+ funBody.funParams = fpName; \r
+ funBody.claxxOwner = clazzThis;\r
+ funBody.exClazz = clazzThis; // make it traceable\r
+ return addProto(proto, funName, funBody);\r
+ }\r
+ // we have found a duplicate\r
+ var oldFun = null;\r
+ var oldStacks = f$.stacks;\r
+ if (!oldStacks) {\r
+ /* method is not defined by Clazz.defineMethod () */\r
+ oldStacks = [];\r
+ oldFun = f$;\r
+ if (f$.claxxOwner) {\r
+ oldStacks[0] = oldFun.claxxOwner;\r
+ }\r
+ }\r
+ /*\r
+ * Method that is already defined in super class will be overridden\r
+ * with a new proxy method with class hierarchy stored in a stack.\r
+ * That is to say, the super methods are lost in this class' proxy\r
+ * method. \r
+ * When method are being called, methods defined in the new proxy \r
+ * method will be searched through first. And if no method fitted,\r
+ * it will then try to search method in the super class stacks.\r
+ */\r
+ if (!f$.stacks || f$.claxxReference !== clazzThis) {\r
+ //Generate a new delegating method for the class \r
+ var id = ++SAEMid;\r
+ var delegate = function () {\r
+ return searchAndExecuteMethod(id, this, arguments.callee.claxxReference, arguments.callee.methodName, arguments);\r
+ };\r
+ delegate.methodName = funName;\r
+ delegate.claxxReference = clazzThis;\r
+ f$ = addProto(proto, funName, delegate); \r
+ // Keep the class inheritance stacks\r
+ var arr = [];\r
+ for (var i = 0; i < oldStacks.length; i++)\r
+ arr[i] = oldStacks[i];\r
+ f$.stacks = arr;\r
+ }\r
+ var ss = f$.stacks;\r
+ if (findArrayItem(ss, clazzThis) < 0) ss.push(clazzThis);\r
+\r
+ if (oldFun) {\r
+ if (oldFun.claxxOwner === clazzThis) {\r
+ f$[oldFun.funParams] = oldFun;\r
+ oldFun.claxxOwner = null;\r
+ // property "funParams" will be used as a mark of only-one method\r
+ oldFun.funParams = null; // null ? safe ? // safe for != null\r
+ } else if (!oldFun.claxxOwner) {\r
+ /*\r
+ * The function is not defined Clazz.defineMethod ().\r
+ * Try to fixup the method ...\r
+ * As a matter of lost method information, I just suppose\r
+ * the method to be fixed is with void parameter!\r
+ */\r
+ f$["\\unknown"] = oldFun;\r
+ }\r
+ }\r
+ funBody.exClazz = clazzThis; // make it traceable\r
+ f$[fpName] = funBody;\r
+ return f$;\r
+}; \r
+\r
+duplicatedMethods = {};\r
+\r
+var checkDuplicate = function(clazzThis, funName, fpName) {\r
+ var proto = clazzThis.prototype;\r
+ var f$ = proto[funName];\r
+ if (f$ && (f$.claxxOwner || f$.claxxReference) === clazzThis) {\r
+ key = clazzThis.__CLASS_NAME__ + "." + funName + fpName;\r
+ var m = duplicatedMethods[key];\r
+ if (m) {\r
+ var s = "Warning! Duplicate method found for " + key;\r
+ System.out.println(s);\r
+ Clazz.alert(s);\r
+ duplicatedMethods[key] = m + 1; \r
+ } else {\r
+ duplicatedMethods[key] = 1;\r
+ }\r
+ }\r
+}\r
+\r
+Clazz.showDuplicates = function(quiet) {\r
+ var s = "";\r
+ var a = duplicatedMethods;\r
+ var n = 0;\r
+ for (var key in a)\r
+ if (a[key] > 1) {\r
+ s += a[key] + "\t" + key + "\n";\r
+ n++;\r
+ }\r
+ s = "Duplicates: " + n + "\n\n" + s;\r
+ System.out.println(s);\r
+ if (!quiet)\r
+ alert(s);\r
+}\r
+\r
+var findArrayItem = function(arr, item) {\r
+ if (arr && item)\r
+ for (var i = arr.length; --i >= 0;)\r
+ if (arr[i] === item)\r
+ return i;\r
+ return -1;\r
+}\r
+\r
+var removeArrayItem = function(arr, item) {\r
+ var i = findArrayItem(arr, item);\r
+ if (i >= 0) {\r
+ var n = arr.length - 1;\r
+ for (; i < n; i++)\r
+ arr[i] = arr[i + 1];\r
+ arr.length--;\r
+ return true;\r
+ }\r
+}\r
+\r
+/*\r
+ * Other developers may need to extend this formatParameters method\r
+ * to deal complicated situation.\r
+ */\r
+/* protected */\r
+var formatParameters = function (funParams) {\r
+ return (funParams ? funParams.replace (/~([NABSO])/g, \r
+ function ($0, $1) {\r
+ switch ($1) {\r
+ case 'N':\r
+ return "n";\r
+ case 'B':\r
+ return "b";\r
+ case 'S':\r
+ return "String";\r
+ case 'O':\r
+ return "Object";\r
+ case 'A':\r
+ return "Array";\r
+ }\r
+ return "Unknown";\r
+ }).replace (/\s+/g, "").replace (/^|,/g, "\\").replace (/\$/g, "org.eclipse.s") : "\\void");\r
+};\r
+\r
+/*\r
+ * Override the existed methods which are in the same name.\r
+ * Overriding methods is provided for the purpose that the JavaScript\r
+ * does not need to search the whole hierarchied methods to find the\r
+ * correct method to execute.\r
+ * Be cautious about this method. Incorrectly using this method may\r
+ * break the inheritance system.\r
+ *\r
+ * @param clazzThis host class in which the method to be defined\r
+ * @param funName method name\r
+ * @param funBody function object, e.g function () { ... }\r
+ * @param funParams paramether signature, e.g ["string", "number"]\r
+ */\r
+/* public */\r
+Clazz.overrideMethod = function(clazzThis, funName, funBody, funParams) {\r
+ if (Clazz.assureInnerClass) Clazz.assureInnerClass (clazzThis, funBody);\r
+ funBody.exName = funName;\r
+ var fpName = formatParameters(funParams);\r
+ if (Clazz._Loader._checkLoad)\r
+ checkDuplicate(clazzThis, funName, fpName);\r
+ /*\r
+ * Replace old methods with new method. No super methods are kept.\r
+ */\r
+ funBody.funParams = fpName; \r
+ funBody.claxxOwner = clazzThis;\r
+ return addProto(clazzThis.prototype, funName, funBody);\r
+};\r
+\r
+////////////// Overridden and Overloaded Java Method Handling //////////////////\r
+// SAEM (SearchAndExecuteMethod)\r
+// adapted by BH\r
+//\r
+\r
+/*\r
+ * BH Clazz.getProfile monitors exactly what is being delegated with SAEM,\r
+ * which could be a bottle-neck for function calling.\r
+ * This is critical for performance optimization.\r
+ */ \r
+\r
+ var __signatures = ""; \r
+\r
+Clazz.getProfile = function() {\r
+ var s = "";\r
+ if (_profile) {\r
+ var l = [];\r
+ for (var i in _profile) {\r
+ var n = "" + _profile[i];\r
+ l.push(" ".substring(n.length) + n + "\t" + i);\r
+ }\r
+ s = l.sort().reverse().join("\r\n");\r
+ _profile = {};\r
+ }\r
+ return s + __signatures;\r
+}\r
+\r
+var addProfile = function(c, f, p, id) {\r
+ var s = id + " " + c.__CLASS_NAME__ + " " + f + " ";// + JSON.stringify(p);\r
+ if (__signatures.indexOf(s) < 0)\r
+ __signatures += s + "\n"; \r
+ _profile[s] || (_profile[s] = 0);\r
+ _profile[s]++;\r
+}\r
+\r
+/**\r
+ * Called also by Throwable\r
+ * \r
+/* public */\r
+Clazz.getParamsType = function (funParams) {\r
+ // bh: optimization here for very common cases\r
+ var n = funParams.length;\r
+ switch (n) {\r
+ case 0:\r
+ var params = ["void"];\r
+ params.typeString = "\\void";\r
+ return params;\r
+ case 1:\r
+ // BH just so common\r
+ switch (typeof obj) {\r
+ case "number":\r
+ var params = ["n"];\r
+ params.typeString = "\\n";\r
+ return params;\r
+ case "boolean":\r
+ var params = ["b"];\r
+ params.typeString = "\\b";\r
+ return params;\r
+ }\r
+ }\r
+\r
+ var params = [];\r
+ params.hasCastedNull = false;\r
+ if (funParams) {\r
+ for (var i = 0; i < n; i++) {\r
+ params[i] = Clazz.getClassName (funParams[i]);\r
+ if (funParams[i] instanceof Clazz.CastedNull) {\r
+ params.hasCastedNull = true;\r
+ }\r
+ }\r
+ }\r
+ params.typeString = "\\" + params.join ('\\');\r
+ return params;\r
+};\r
+\r
+var SAEMid = 0;\r
+xxxSAEMlist = "";\r
+\r
+//var SAEMarray = [];\r
+/**\r
+ * BH: OK, this was an idea that doesn't work. The idea was to tag SAEM calls\r
+ * and then refer back to an array. But the id number cannot be put in the right place.\r
+ * \r
+ * Say we have this:\r
+ * \r
+ * StringBuffer sb = new StringBuffer(); \r
+ * sb.append("").append(1);\r
+ * \r
+ * Here we have two different append methods to call. They are saved under two\r
+ * names: StringBuffer.prototype.append["\\String"] \r
+ * and StringBuffer.prototype.append["\\Number"]\r
+ * \r
+ * The job of generateDelegatingMethod is to discriminate between those two. We can do\r
+ * that, but the real issue is that we have to do that EVERY time a call is made.\r
+ * This is a problem that must be handled at compile time. There is no way to \r
+ * make .append("") to go one way the first time and another way the second time. \r
+ * What we need at run time is something like this:\r
+ * \r
+ * Clazz.delegate(sb.append,1,[""]) and Clazz.delegate(sb.append,2,[1])\r
+ * The we would be able to log those numbers at run time and refer to them.\r
+ * \r
+ * The only real way to avoid SAEM is: \r
+ * \r
+ * 1) to never call super() -- always call a differently named function in a superclass.\r
+ * 2) don't overload functions \r
+ * \r
+ */ \r
+\r
+\r
+/**\r
+ * Search the given class prototype, find the method with the same\r
+ * method name and the same parameter signatures by the given \r
+ * parameters, and then run the method with the given parameters.\r
+ *\r
+ * @param objThis the current host object\r
+ * @param claxxRef the current host object's class\r
+ * @param fxName the method name\r
+ * @param funParams the given arguments\r
+ * @return the result of the specified method of the host object,\r
+ * the return maybe void.\r
+ * @throws MethodNotFoundException if no matched method is found\r
+ */\r
+/* protected */\r
+var searchAndExecuteMethod = function (id, objThis, claxxRef, fxName, args, _saem) {\r
+\r
+// var fx = SAEMarray[id];\r
+// if (fx) {\r
+// return fx.apply(objThis, args);\r
+// }\r
+\r
+\r
+ fx = objThis[fxName];\r
+ var params = Clazz.getParamsType(args);\r
+\r
+\r
+var s = "SAEM " + claxxRef.__CLASS_NAME__ + "." + fxName + "(" + params+ ")\n";\r
+if (xxxSAEMlist.length > 300)xxxSAEMlist = "";\r
+xxxSAEMlist += s;\r
+ \r
+\r
+ if (!fx) \r
+ try {System.out.println(Clazz.getStackTrace(5))} catch (e){}\r
+ _profile && addProfile(claxxRef, fxName, params, id);\r
+ // Cache last matched method\r
+ if (fx.lastParams == params.typeString && fx.lastClaxxRef === claxxRef) {\r
+ var methodParams;\r
+ if (params.hasCastedNull) {\r
+ methodParams = [];\r
+ // For Clazz.CastedNull instances, the type name is\r
+ // already used to indentified the method in searchMethod.\r
+ for (var k = 0; k < args.length; k++)\r
+ methodParams[k] = (args[k] instanceof Clazz.CastedNull ? null : args[k]);\r
+ } else {\r
+// if (fx.lastMethod) SAEMarray[id] = fx.lastMethod;\r
+ methodParams = args;\r
+ }\r
+ return (fx.lastMethod ? fx.lastMethod.apply(objThis, methodParams) : null);\r
+ }\r
+ fx.lastParams = params.typeString;\r
+ fx.lastClaxxRef = claxxRef;\r
+\r
+ var stacks = fx.stacks;\r
+ if (!stacks)\r
+ stacks = claxxRef.prototype[fxName].stacks;\r
+ var length = stacks.length;\r
+\r
+ /*\r
+ * Search the inheritance stacks to get the given class' function\r
+ */\r
+ var began = false; // began to search its super classes\r
+ for (var i = length; --i >= 0;) {\r
+ if (began || stacks[i] === claxxRef) {\r
+ /*\r
+ * First try to search method within the same class scope\r
+ * with stacks[i] === claxxRef\r
+ */\r
+ var clazzFun = stacks[i].prototype[fxName];\r
+ var ret = tryToSearchAndExecute(id, fxName, objThis, clazzFun, params,\r
+ args, fx);\r
+ if (!(ret instanceof MethodException)) {\r
+ return ret;\r
+ }\r
+ /*\r
+ * As there are no such methods in current class, Clazz will try \r
+ * to search its super class stacks. Here variable began indicates\r
+ * that super searchi is began, and there is no need checking\r
+ * <code>stacks[i] === claxxRef</code>\r
+ */\r
+ began = true; \r
+ } // end of if\r
+ } // end of for\r
+ if ("construct" == fxName) {\r
+ /*\r
+ * For non existed constructors, just return without throwing\r
+ * exceptions. In Java codes, extending Object can call super\r
+ * default Object#constructor, which is not defined in JS.\r
+ */\r
+ return;\r
+ }\r
+ newMethodNotFoundException(objThis, claxxRef, \r
+ fxName, params.typeString);\r
+};\r
+\r
+\r
+/* private */\r
+var tryToSearchAndExecute = function(id, fxName, objThis, clazzFun, params, args, fx, _ttsaem) {\r
+ var method = [];\r
+ var generic = true;\r
+ for (var fn in clazzFun) {\r
+ if (fn.charCodeAt(0) == 92) { // 92 == '\\'.charCodeAt (0)\r
+ var ps = fn.substring(1).split("\\");\r
+ (ps.length == params.length) && method.push(ps);\r
+ generic = false;\r
+ continue;\r
+ }\r
+ /*\r
+ * When there is only one method in the class, use the args\r
+ * to identify the parameter type.\r
+ *\r
+ * AbstractCollection.remove (Object)\r
+ * AbstractList.remove (int)\r
+ * ArrayList.remove (int)\r
+ *\r
+ * Then calling #remove (Object) method on ArrayList instance will \r
+ * need to search up to the AbstractCollection.remove (Object),\r
+ * which contains only one method.\r
+ */\r
+ /*\r
+ * See Clazz#defineMethod --Mar 10, 2006, josson\r
+ */\r
+ if (generic && fn == "funParams" && clazzFun.funParams) {\r
+ fn = clazzFun.funParams;\r
+ var ps = fn.substring(1).split ("\\");\r
+ (ps.length == params.length) && (method[0] = ps);\r
+ break;\r
+ }\r
+ }\r
+ var debug = false;//(method.length > 1 && method.join().indexOf("Listen")< 0 && params.join().indexOf("Null") >= 0)\r
+ if (debug)alert(fxName + " -- " + method.join("|") + " -- searching for method with " + params)\r
+ if (method.length == 0 || !(method = searchMethod(method, params, debug)))\r
+ return new MethodException();\r
+ if (debug) alert("OK: \\" + method)\r
+ var f = (generic ? clazzFun : clazzFun["\\" + method]);\r
+ //if (generic) \r
+ //{ /* Use the generic method */\r
+ /*\r
+ * Will this case be reachable?\r
+ * March 4, 2006 josson\r
+ * \r
+ * Reachable for calling #remove (Object) method on \r
+ * ArrayList instance\r
+ * May 5, 2006 josson\r
+ */\r
+ var methodParams = null;\r
+ if (params.hasCastedNull) {\r
+ methodParams = [];\r
+ for (var k = 0; k < args.length; k++) {\r
+ if (args[k] instanceof Clazz.CastedNull) {\r
+ /*\r
+ * For Clazz.CastedNull instances, the type name is\r
+ * already used to indentify the method in searchMethod.\r
+ */\r
+ methodParams[k] = null;\r
+ } else {\r
+ methodParams[k] = args[k];\r
+ }\r
+ }\r
+ } else {\r
+ methodParams = args;\r
+ }\r
+ fx.lastMethod = f;\r
+ //if (!params.hasCastedNull) SAEMarray[id] = f;\r
+ return f.apply(objThis, methodParams);\r
+};\r
+\r
+/**\r
+ * Search the existed polymorphic methods to get the matched method with\r
+ * the given parameter types.\r
+ *\r
+ * @param existedMethods Array of string which contains method parameters\r
+ * @param paramTypes Array of string that is parameter type.\r
+ * @return string of method parameters seperated by "\\"\r
+ */\r
+/* private */\r
+var searchMethod = function(roundOne, paramTypes, debug) {\r
+\r
+// Filter out all the fitted methods for the given parameters\r
+ var roundTwo = [];\r
+ var len = roundOne.length;\r
+ for (var i = 0; i < len; i++) {\r
+ var fittedLevel = [];\r
+ var isFitted = true;\r
+ var len2 = roundOne[i].length;\r
+ for (var j = 0; j < len2; j++) {\r
+ \r
+ fittedLevel[j] = Clazz.getInheritedLevel (paramTypes[j], \r
+ roundOne[i][j]);\r
+ //if (debug)alert([paramTypes[j],fittedLevel[j],roundOne[i][j]]) \r
+ if (fittedLevel[j] < 0) {\r
+ isFitted = false;\r
+ break;\r
+ }\r
+ }\r
+ if (isFitted) {\r
+ fittedLevel[paramTypes.length] = i; // Keep index for later use\r
+ roundTwo.push(fittedLevel);\r
+ }\r
+ }\r
+ if (roundTwo.length == 0)\r
+ return null;\r
+ // Find out the best method according to the inheritance.\r
+ var resultTwo = roundTwo;\r
+ var min = resultTwo[0];\r
+ for (var i = 1; i < resultTwo.length; i++) {\r
+ var isVectorLesser = true;\r
+ for (var j = 0; j < paramTypes.length; j++) {\r
+ if (min[j] < resultTwo[i][j]) {\r
+ isVectorLesser = false;;\r
+ break;\r
+ }\r
+ }\r
+ if (isVectorLesser)\r
+ min = resultTwo[i];\r
+ }\r
+ var index = min[paramTypes.length]; // Get the previously stored index\r
+ /*\r
+ * Return the method parameters' type string as indentifier of the\r
+ * choosen method.\r
+ */\r
+ return roundOne[index].join ('\\');\r
+};\r
+\r
+////////////////////////////////// package loading ///////////////////////\r
+\r
+/*\r
+ * all root packages. e.g. java.*, org.*, com.*\r
+ */\r
+/* protected */\r
+Clazz.allPackage = {};\r
+\r
+/**\r
+ * Will be used to keep value of whether the class is defined or not.\r
+ */\r
+/* protected */\r
+Clazz.allClasses = {};\r
+\r
+Clazz.lastPackageName = null;\r
+Clazz.lastPackage = null;\r
+\r
+/* protected */\r
+Clazz.unloadedClasses = [];\r
+\r
+/* public */\r
+Clazz.declarePackage = function (pkgName) {\r
+ if (Clazz.lastPackageName == pkgName)\r
+ return Clazz.lastPackage;\r
+ if (pkgName && pkgName.length) {\r
+ var pkgFrags = pkgName.split (/\./);\r
+ var pkg = Clazz.allPackage;\r
+ for (var i = 0; i < pkgFrags.length; i++) {\r
+ if (!pkg[pkgFrags[i]]) {\r
+ pkg[pkgFrags[i]] = { \r
+ __PKG_NAME__ : (pkg.__PKG_NAME__ ? \r
+ pkg.__PKG_NAME__ + "." + pkgFrags[i] : pkgFrags[i])\r
+ }; \r
+ // pkg[pkgFrags[i]] = {};\r
+ if (i == 0) {\r
+ // eval ...\r
+ Clazz.setGlobal(pkgFrags[i], pkg[pkgFrags[i]]);\r
+ }\r
+ }\r
+ pkg = pkg[pkgFrags[i]]\r
+ }\r
+ Clazz.lastPackageName = pkgName;\r
+ Clazz.lastPackage = pkg;\r
+ return pkg;\r
+ }\r
+};\r
+\r
+/* protected */\r
+Clazz.evalType = function (typeStr, isQualified) {\r
+ var idx = typeStr.lastIndexOf(".");\r
+ if (idx != -1) {\r
+ var pkgName = typeStr.substring (0, idx);\r
+ var pkg = Clazz.declarePackage (pkgName);\r
+ var clazzName = typeStr.substring (idx + 1);\r
+ return pkg[clazzName];\r
+ } \r
+ if (isQualified)\r
+ return window[typeStr];\r
+ switch (typeStr) {\r
+ case "string":\r
+ return String;\r
+ case "number":\r
+ return Number;\r
+ case "object":\r
+ return Clazz._O;\r
+ case "boolean":\r
+ return Boolean;\r
+ case "function":\r
+ return Function;\r
+ case "void":\r
+ case "undefined":\r
+ case "unknown":\r
+ return typeStr;\r
+ case "NullObject":\r
+ return NullObject;\r
+ default:\r
+ return window[typeStr];\r
+ }\r
+};\r
+\r
+/**\r
+ * Define a class or interface.\r
+ *\r
+ * @param qClazzName String presents the qualified name of the class\r
+ * @param clazzFun Function of the body\r
+ * @param clazzParent Clazz to inherit from, may be null\r
+ * @param interfacez Clazz may implement one or many interfaces\r
+ * interfacez can be Clazz object or Array of Clazz objects.\r
+ * @return Ruturn the modified Clazz object\r
+ */\r
+/* public */\r
+Clazz.defineType = function (qClazzName, clazzFun, clazzParent, interfacez) {\r
+ var cf = Clazz.unloadedClasses[qClazzName];\r
+ if (cf) {\r
+ clazzFun = cf;\r
+ }\r
+ var idx = qClazzName.lastIndexOf (".");\r
+ if (idx != -1) {\r
+ var pkgName = qClazzName.substring (0, idx);\r
+ var pkg = Clazz.declarePackage (pkgName);\r
+ var clazzName = qClazzName.substring (idx + 1);\r
+ if (pkg[clazzName]) {\r
+ // already defined! Should throw exception!\r
+ return pkg[clazzName];\r
+ }\r
+ pkg[clazzName] = clazzFun;\r
+ } else {\r
+ if (window[qClazzName]) {\r
+ // already defined! Should throw exception!\r
+ return window[qClazzName];\r
+ }\r
+ Clazz.setGlobal(qClazzName, clazzFun);\r
+ }\r
+ Clazz.decorateAsType(clazzFun, qClazzName, clazzParent, interfacez);\r
+ /*# {$no.javascript.support} >>x #*/\r
+ var iFun = Clazz._innerFunctions;\r
+ clazzFun.defineMethod = iFun.defineMethod;\r
+ clazzFun.defineStaticMethod = iFun.defineStaticMethod;\r
+ clazzFun.makeConstructor = iFun.makeConstructor;\r
+ /*# x<< #*/\r
+ return clazzFun;\r
+};\r
+\r
+var isSafari = (navigator.userAgent.indexOf ("Safari") != -1);\r
+var isSafari4Plus = false;\r
+if (isSafari) {\r
+ var ua = navigator.userAgent;\r
+ var verIdx = ua.indexOf("Version/");\r
+ if (verIdx != -1) {\r
+ var verStr = ua.substring(verIdx + 8);\r
+ var verNumber = parseFloat(verStr);\r
+ isSafari4Plus = verNumber >= 4.0;\r
+ }\r
+}\r
+\r
+/* public */\r
+Clazz.instantialize = function (objThis, args) {\r
+\r
+\r
+ if (args && args.length == 1 && args[0] \r
+ && args[0] instanceof args4InheritClass) {\r
+ return;\r
+ }\r
+ if (objThis instanceof Number) {\r
+ objThis.valueOf = function () {\r
+ return this;\r
+ };\r
+ }\r
+ if (isSafari4Plus) { // Fix bug of Safari 4.0+'s over-optimization\r
+ var argsClone = [];\r
+ for (var k = 0; k < args.length; k++) {\r
+ argsClone[k] = args[k];\r
+ }\r
+ args = argsClone;\r
+ }\r
+\r
+ var c = objThis.construct;\r
+ if (c) {\r
+ if (!objThis.con$truct) { // no need to init fields\r
+ c.apply (objThis, args);\r
+ } else if (!objThis.getClass ().superClazz) { // the base class\r
+ objThis.con$truct.apply (objThis, []);\r
+ c.apply (objThis, args);\r
+ } else if ((c.claxxOwner \r
+ && c.claxxOwner === objThis.getClass ())\r
+ || (c.stacks \r
+ && c.stacks[c.stacks.length - 1] == objThis.getClass ())) {\r
+ /*\r
+ * This #construct is defined by this class itself.\r
+ * #construct will call Clazz.superConstructor, which will\r
+ * call #con$truct back\r
+ */\r
+ c.apply (objThis, args);\r
+ } else { // constructor is a super constructor\r
+ if (c.claxxOwner && !c.claxxOwner.superClazz \r
+ && c.claxxOwner.con$truct) {\r
+ c.claxxOwner.con$truct.apply (objThis, []);\r
+ } else if (c.stacks && c.stacks.length == 1\r
+ && !c.stacks[0].superClazz) {\r
+ c.stacks[0].con$truct.apply (objThis, []);\r
+ }\r
+ c.apply (objThis, args);\r
+ objThis.con$truct.apply (objThis, []);\r
+ }\r
+ } else if (objThis.con$truct) {\r
+ objThis.con$truct.apply (objThis, []);\r
+ }\r
+};\r
+\r
+/**\r
+ * Once there are other methods registered to the Function.prototype, \r
+ * those method names should be add to the following Array.\r
+ */\r
+/*\r
+ * static final member of interface may be a class, which may\r
+ * be function.\r
+ */\r
+/* protected */\r
+Clazz.innerFunctionNames = [\r
+ "isInstance", "equals", "hashCode", /*"toString",*/ "getName", "getCanonicalName", "getClassLoader", "getResource", "getResourceAsStream" /*# {$no.javascript.support} >>x #*/, "defineMethod", "defineStaticMethod",\r
+ "makeConstructor" /*# x<< #*/\r
+];\r
+\r
+/*\r
+ * Static methods\r
+ */\r
+Clazz._innerFunctions = {\r
+ /*\r
+ * Similar to Object#equals\r
+ */\r
+ \r
+ isInstance: function(c) {\r
+ return Clazz.instanceOf(c, this);\r
+ },\r
+ \r
+ equals : function (aFun) {\r
+ return this === aFun;\r
+ },\r
+\r
+ hashCode : function () {\r
+ return this.getName ().hashCode ();\r
+ },\r
+\r
+ toString : function () {\r
+ return "class " + this.getName ();\r
+ },\r
+\r
+ /*\r
+ * Similar to Class#getName\r
+ */\r
+ getName : function () {\r
+ return Clazz.getClassName (this, true);\r
+ },\r
+ getCanonicalName : function () {\r
+ return this.__CLASS_NAME__;\r
+ },\r
+ getClassLoader : function () {\r
+ var clazzName = this.__CLASS_NAME__;\r
+ var baseFolder = Clazz._Loader.getClasspathFor(clazzName);\r
+ var x = baseFolder.lastIndexOf (clazzName.replace (/\./g, "/"));\r
+ if (x != -1) {\r
+ baseFolder = baseFolder.substring (0, x);\r
+ } else {\r
+ baseFolder = Clazz._Loader.getClasspathFor(clazzName, true);\r
+ }\r
+ var loader = Clazz._Loader.requireLoaderByBase(baseFolder);\r
+ loader.getResourceAsStream = Clazz._innerFunctions.getResourceAsStream;\r
+ loader.getResource = Clazz._innerFunctions.getResource; // BH\r
+ return loader;\r
+ },\r
+\r
+ getResource : function(name) {\r
+ var stream = this.getResourceAsStream(name);\r
+ return (stream ? stream.url : null);\r
+ },\r
+\r
+ getResourceAsStream : function (name) {\r
+ if (!name)\r
+ return null;\r
+ name = name.replace (/\\/g, '/');\r
+ var baseFolder = null;\r
+ var fname = name;\r
+ var clazzName = this.__CLASS_NAME__;\r
+ if (arguments.length == 2 && name.indexOf ('/') != 0) { // additional argument\r
+ name = "/" + name;\r
+ }\r
+ if (name.indexOf ('/') == 0) {\r
+ //is.url = name.substring (1);\r
+ if (arguments.length == 2) { // additional argument\r
+ baseFolder = arguments[1];\r
+ if (!baseFolder)\r
+ baseFolder = Clazz.binaryFolders[0];\r
+ } else if (Clazz._Loader) {\r
+ baseFolder = Clazz._Loader.getClasspathFor(clazzName, true);\r
+ }\r
+ if (!baseFolder) {\r
+ fname = name.substring (1);\r
+ } else {\r
+ baseFolder = baseFolder.replace (/\\/g, '/');\r
+ var length = baseFolder.length;\r
+ var lastChar = baseFolder.charAt (length - 1);\r
+ if (lastChar != '/') {\r
+ baseFolder += "/";\r
+ }\r
+ fname = baseFolder + name.substring (1);\r
+ }\r
+ } else {\r
+ if (this.base) {\r
+ baseFolder = this.base;\r
+ } else if (Clazz._Loader) {\r
+ baseFolder = Clazz._Loader.getClasspathFor(clazzName);\r
+ var x = baseFolder.lastIndexOf (clazzName.replace (/\./g, "/"));\r
+ if (x != -1) {\r
+ baseFolder = baseFolder.substring (0, x);\r
+ } else {\r
+ //baseFolder = null;\r
+ var y = -1;\r
+ if (baseFolder.indexOf (".z.js") == baseFolder.length - 5\r
+ && (y = baseFolder.lastIndexOf ("/")) != -1) {\r
+ baseFolder = baseFolder.substring (0, y + 1);\r
+ var pkgs = clazzName.split (/\./);\r
+ for (var k = 1; k < pkgs.length; k++) {\r
+ var pkgURL = "/";\r
+ for (var j = 0; j < k; j++) {\r
+ pkgURL += pkgs[j] + "/";\r
+ }\r
+ if (pkgURL.length > baseFolder.length) {\r
+ break;\r
+ }\r
+ if (baseFolder.indexOf (pkgURL) == baseFolder.length - pkgURL.length) {\r
+ baseFolder = baseFolder.substring (0, baseFolder.length - pkgURL.length + 1);\r
+ break;\r
+ }\r
+ }\r
+ } else {\r
+ baseFolder = Clazz._Loader.getClasspathFor(clazzName, true);\r
+ }\r
+ }\r
+ } else {\r
+ var bins = Clazz.binaryFolders;\r
+ if (bins && bins.length) {\r
+ baseFolder = bins[0];\r
+ }\r
+ }\r
+ if (!baseFolder)\r
+ baseFolder = "j2s/";\r
+ baseFolder = baseFolder.replace (/\\/g, '/');\r
+ var length = baseFolder.length;\r
+ var lastChar = baseFolder.charAt (length - 1);\r
+ if (lastChar != '/') {\r
+ baseFolder += "/";\r
+ }\r
+ if (this.base) {\r
+ fname = baseFolder + name;\r
+ } else {\r
+ var idx = clazzName.lastIndexOf ('.');\r
+ if (idx == -1 || this.base) {\r
+ fname = baseFolder + name;\r
+ } else {\r
+ fname = baseFolder + clazzName.substring (0, idx)\r
+ .replace (/\./g, '/') + "/" + name;\r
+ }\r
+ } \r
+ }\r
+ var url = null;\r
+ try {\r
+ if (fname.indexOf(":/") < 0) {\r
+ var d = document.location.href.split("?")[0].split("/");\r
+ d[d.length - 1] = fname;\r
+ fname = d.join("/");\r
+ }\r
+ url = new java.net.URL(fname);\r
+ } catch (e) {\r
+ }\r
+ var data = (url == null ? null : Jmol._getFileData(fname.toString()));\r
+ if (!data || data == "error" || data.indexOf("[Exception") == 0)\r
+ return null;\r
+ var bytes = new java.lang.String(data).getBytes(); \r
+ var is = new java.io.BufferedInputStream ( new java.io.ByteArrayInputStream (bytes)); \r
+ is.url = url;\r
+ return is;\r
+ }/*# {$no.javascript.support} >>x #*/,\r
+\r
+ /*\r
+ * For JavaScript programmers\r
+ */\r
+ defineMethod : function (methodName, funBody, paramTypes) {\r
+ Clazz.defineMethod (this, methodName, funBody, paramTypes);\r
+ },\r
+\r
+ /*\r
+ * For JavaScript programmers\r
+ */\r
+ defineStaticMethod : function (methodName, funBody, paramTypes) {\r
+ Clazz.defineMethod (this, methodName, funBody, paramTypes);\r
+ this[methodName] = this.prototype[methodName];\r
+ },\r
+\r
+ /*\r
+ * For JavaScript programmers\r
+ */\r
+ makeConstructor : function (funBody, paramTypes) {\r
+ Clazz.makeConstructor (this, funBody, paramTypes);\r
+ }\r
+ /*# x<< #*/\r
+};\r
+\r
+\r
+var cStack = [];\r
+\r
+/**\r
+ * BH: I would like to be able to remove "self.c$" here, but that is tricky.\r
+ */\r
+ \r
+Clazz.pu$h = function (c) {\r
+ c || (c = self.c$); // old style\r
+ c && cStack.push(c);\r
+};\r
+\r
+Clazz.p0p = function () {\r
+ return cStack.pop();\r
+};\r
+\r
+/* protected */\r
+Clazz.decorateAsClass = function (clazzFun, prefix, name, clazzParent, \r
+ interfacez, parentClazzInstance, _decorateAsClass) {\r
+ \r
+ var prefixName = null;\r
+ if (prefix) {\r
+ prefixName = prefix.__PKG_NAME__;\r
+ if (!prefixName)\r
+ prefixName = prefix.__CLASS_NAME__; \r
+ }\r
+ var qName = (prefixName ? prefixName + "." : "") + name;\r
+ \r
+ if (Clazz._Loader._classPending[qName]) {\r
+ delete Clazz._Loader._classPending[qName];\r
+ Clazz._Loader._classCountOK++;\r
+ Clazz._Loader._classCountPending--;\r
+ }\r
+ if (Clazz._Loader && Clazz._Loader._checkLoad) {\r
+ System.out.println("decorating class " + prefixName + "." + name);\r
+ }\r
+ var cf = Clazz.unloadedClasses[qName];\r
+ if (cf) {\r
+ clazzFun = cf;\r
+ }\r
+ var qName = null;\r
+ decorateFunction(clazzFun, prefix, name);\r
+ if (parentClazzInstance) {\r
+ Clazz.inheritClass (clazzFun, clazzParent, parentClazzInstance);\r
+ } else if (clazzParent) {\r
+ Clazz.inheritClass (clazzFun, clazzParent);\r
+ }\r
+ if (interfacez) {\r
+ Clazz.implementOf (clazzFun, interfacez);\r
+ }\r
+ return clazzFun;\r
+};\r
+\r
+/* private */\r
+var decorateFunction = function (clazzFun, prefix, name, _decorateFunction) {\r
+ var qName;\r
+ if (!prefix) {\r
+ // e.g. Clazz.declareInterface (null, "ICorePlugin", org.eclipse.ui.IPlugin);\r
+ qName = name;\r
+ Clazz.setGlobal(name, clazzFun);\r
+ } else if (prefix.__PKG_NAME__) {\r
+ // e.g. Clazz.declareInterface (org.eclipse.ui, "ICorePlugin", org.eclipse.ui.IPlugin);\r
+ qName = prefix.__PKG_NAME__ + "." + name;\r
+ prefix[name] = clazzFun;\r
+ if (prefix === java.lang)\r
+ Clazz.setGlobal(name, clazzFun);\r
+ } else {\r
+ // e.g. Clazz.declareInterface (org.eclipse.ui.Plugin, "ICorePlugin", org.eclipse.ui.IPlugin);\r
+ qName = prefix.__CLASS_NAME__ + "." + name;\r
+ prefix[name] = clazzFun;\r
+ }\r
+ Clazz.extendJO(clazzFun, qName);\r
+ var inF = Clazz.innerFunctionNames;\r
+ for (var i = 0; i < inF.length; i++) {\r
+ clazzFun[inF[i]] = Clazz._innerFunctions[inF[i]];\r
+ }\r
+\r
+ if (Clazz._Loader) \r
+ Clazz._Loader.updateNodeForFunctionDecoration(qName);\r
+};\r
+\r
+/* protected */\r
+Clazz.declareInterface = function (prefix, name, interfacez, _declareInterface) {\r
+ var clazzFun = function () {};\r
+ decorateFunction(clazzFun, prefix, name);\r
+ if (interfacez) {\r
+ Clazz.implementOf (clazzFun, interfacez);\r
+ }\r
+ return clazzFun;\r
+};\r
+\r
+/* public */\r
+Clazz.declareType = function (prefix, name, clazzParent, interfacez, \r
+ parentClazzInstance, _declareType) {\r
+ var f = function () {\r
+ Clazz.instantialize (this, arguments);\r
+ };\r
+ return Clazz.decorateAsClass (f, prefix, name, clazzParent, interfacez, \r
+ parentClazzInstance);\r
+};\r
+\r
+/* public */\r
+Clazz.declareAnonymous = function (prefix, name, clazzParent, interfacez, \r
+ parentClazzInstance, _declareAnonymous) {\r
+ var f = function () {\r
+ Clazz.prepareCallback(this, arguments);\r
+ Clazz.instantialize (this, arguments);\r
+ };\r
+ return Clazz.decorateAsClass (f, prefix, name, clazzParent, interfacez, \r
+ parentClazzInstance);\r
+};\r
+\r
+/* public */\r
+Clazz.decorateAsType = function (clazzFun, qClazzName, clazzParent, \r
+ interfacez, parentClazzInstance, inheritClazzFuns, _decorateAsType) {\r
+ Clazz.extendJO(clazzFun, qClazzName);\r
+ clazzFun.equals = Clazz._innerFunctions.equals;\r
+ clazzFun.getName = Clazz._innerFunctions.getName;\r
+ if (inheritClazzFuns) {\r
+ for (var i = 0; i < Clazz.innerFunctionNames.length; i++) {\r
+ var methodName = Clazz.innerFunctionNames[i];\r
+ clazzFun[methodName] = Clazz._innerFunctions[methodName];\r
+ }\r
+ }\r
+ if (parentClazzInstance) {\r
+ Clazz.inheritClass (clazzFun, clazzParent, parentClazzInstance);\r
+ } else if (clazzParent) {\r
+ Clazz.inheritClass (clazzFun, clazzParent);\r
+ }\r
+ if (interfacez) {\r
+ Clazz.implementOf (clazzFun, interfacez);\r
+ }\r
+ return clazzFun;\r
+};\r
+\r
+\r
+////////////////////////// default package declarations ////////////////////////\r
+\r
+/* sgurin: preserve Number.prototype.toString */\r
+Number.prototype._numberToString=Number.prototype.toString;\r
+\r
+\r
+Clazz.declarePackage ("java.io");\r
+//Clazz.declarePackage ("java.lang");\r
+Clazz.declarePackage ("java.lang.annotation"); // java.lang\r
+Clazz.declarePackage ("java.lang.instrument"); // java.lang\r
+Clazz.declarePackage ("java.lang.management"); // java.lang\r
+Clazz.declarePackage ("java.lang.reflect"); // java.lang\r
+Clazz.declarePackage ("java.lang.ref"); // java.lang.ref\r
+java.lang.ref.reflect = java.lang.reflect;\r
+Clazz.declarePackage ("java.util");\r
+//var reflect = Clazz.declarePackage ("java.lang.reflect");\r
+Clazz.declarePackage ("java.security");\r
+\r
+\r
+/*\r
+ * Consider these interfaces are basic!\r
+ */\r
+Clazz.declareInterface (java.io,"Closeable");\r
+Clazz.declareInterface (java.io,"DataInput");\r
+Clazz.declareInterface (java.io,"DataOutput");\r
+Clazz.declareInterface (java.io,"Externalizable");\r
+Clazz.declareInterface (java.io,"Flushable");\r
+Clazz.declareInterface (java.io,"Serializable");\r
+Clazz.declareInterface (java.lang,"Iterable");\r
+Clazz.declareInterface (java.lang,"CharSequence");\r
+Clazz.declareInterface (java.lang,"Cloneable");\r
+Clazz.declareInterface (java.lang,"Appendable");\r
+Clazz.declareInterface (java.lang,"Comparable");\r
+Clazz.declareInterface (java.lang,"Runnable");\r
+Clazz.declareInterface (java.util,"Comparator");\r
+\r
+java.lang.ClassLoader = {\r
+ __CLASS_NAME__ : "ClassLoader"\r
+};\r
+\r
+/******************************************************************************\r
+ * Copyright (c) 2007 java2script.org and others.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * Zhou Renjian - initial API and implementation\r
+ *****************************************************************************/\r
+/*******\r
+ * @author zhou renjian\r
+ * @create March 10, 2006\r
+ *******/\r
+\r
+/**\r
+ * Once ClassExt.js is part of Class.js.\r
+ * In order to make the Class.js as small as possible, part of its content\r
+ * is moved into this ClassExt.js.\r
+ *\r
+ * See also http://j2s.sourceforge.net/j2sclazz/\r
+ */\r
+ \r
+/**\r
+ * Clazz.MethodNotFoundException is used to notify the developer about calling\r
+ * methods with incorrect parameters.\r
+ */\r
+/* protected */\r
+// Override the Clazz.MethodNotFoundException in Class.js to give details\r
+var newMethodNotFoundException = function (obj, clazz, method, params) {\r
+ var paramStr = "";\r
+ if (params) {\r
+ paramStr = params.substring (1).replace (/\\/g, ",");\r
+ }\r
+ var leadingStr = "";\r
+ if (method && method != "construct") {\r
+ leadingStr = "Method";\r
+ } else {\r
+ leadingStr = "Constructor";\r
+ }\r
+ var message = leadingStr + " " + Clazz.getClassName (clazz, true) + "." \r
+ + method + "(" + paramStr + ") is not found!";\r
+ throw new java.lang.NoSuchMethodException(message); \r
+};\r
+\r
+/**\r
+ * Prepare "callback" for instance of anonymous Class.\r
+ * For example for the callback:\r
+ * this.callbacks.MyEditor.sayHello();\r
+ * \r
+ * This is specifically for inner classes that are referring to \r
+ * outer class methods and fields. \r
+ *\r
+ * @param objThis the host object for callback\r
+ * @param args arguments object. args[0] will be classThisObj -- the "this"\r
+ * object to be hooked\r
+ * \r
+ * Attention: parameters should not be null!\r
+ */\r
+/* protected */\r
+Clazz.prepareCallback = function (innerObj, args) {\r
+ var outerObj = args[0];\r
+ var cbName = "b$"; // "callbacks";\r
+ if (innerObj && outerObj && outerObj !== window) {\r
+ var className = Clazz.getClassName(outerObj, true); \r
+ var obs = {};\r
+ if (innerObj[cbName]) // must make a copy!\r
+ for (var s in innerObj[cbName])\r
+ obs[s] = innerObj[cbName][s];\r
+ innerObj[cbName] = obs;\r
+ \r
+ /*\r
+ * TODO: the following line is SWT-specific! Try to move it out!\r
+ */\r
+ // obs[className.replace (/org\.eclipse\.swt\./, "$wt.")] = outerObj;\r
+\r
+ // all references to outer class and its superclass objects must be here as well\r
+ obs[className] = outerObj;\r
+ var clazz = Clazz.getClass(outerObj);\r
+ while (clazz.superClazz) {\r
+ clazz = clazz.superClazz;\r
+ /*\r
+ * TODO: the following line is SWT-specific! Try to move it out!\r
+ */\r
+ // obs[Clazz.getClassName (clazz, true)\r
+ // .replace (/org\.eclipse\.swt\./, "$wt.")] = outerObj;\r
+ obs[Clazz.getClassName(clazz, true)] = outerObj;\r
+ }\r
+ var cbs = outerObj[cbName];\r
+ if (cbs)\r
+ for (var s in cbs)\r
+ obs[s] = cbs[s];\r
+ }\r
+ // remove "this" argument\r
+ // note that args is an instance of arguments -- NOT an array; does not have the .shift() method!\r
+ for (var i = 0; i < args.length - 1; i++)\r
+ args[i] = args[i + 1];\r
+ args.length--;\r
+};\r
+\r
+/**\r
+ * Construct instance of the given inner class.\r
+ *\r
+ * @param classInner given inner class, alway with name like "*$*"\r
+ * @param innerObj this instance which can be used to call back.\r
+ * @param finalVars final variables which the inner class may use\r
+ * @return the constructed object\r
+ *\r
+ * @see Clazz#cloneFinals\r
+ */\r
+/* public */\r
+Clazz.innerTypeInstance = function (clazzInner, innerObj, finalVars) {\r
+ if (!clazzInner)\r
+ clazzInner = arguments.callee.caller;\r
+ var obj;\r
+ if (finalVars || innerObj.$finals) {\r
+ obj = new clazzInner(innerObj, Clazz.inheritArgs);\r
+ // f$ is short for the once choosen "$finals"\r
+ if (finalVars) {\r
+ if (innerObj.f$) {\r
+ var o = {};\r
+ for (var attr in innerObj.f$)\r
+ o[attr] = innerObj.f$[attr];\r
+ for (var attr in finalVars)\r
+ o[attr] = finalVars[attr];\r
+ obj.f$ = o;\r
+ } else {\r
+ obj.f$ = finalVars;\r
+ }\r
+ } else if (innerObj.f$) {\r
+ obj.f$ = innerObj.f$;\r
+ }\r
+ } else {\r
+ switch (arguments.length) {\r
+ case 3:\r
+ return new clazzInner(innerObj);\r
+ case 4:\r
+ return (innerObj.__CLASS_NAME__ == clazzInner.__CLASS_NAME__\r
+ && arguments[3] === Clazz.inheritArgs ? innerObj : new clazzInner(innerObj, arguments[3]));\r
+ case 5:\r
+ return new clazzInner(innerObj, arguments[3], arguments[4]);\r
+ case 6:\r
+ return new clazzInner(innerObj, arguments[3], arguments[4], \r
+ arguments[5]);\r
+ case 7:\r
+ return new clazzInner(innerObj, arguments[3], arguments[4], \r
+ arguments[5], arguments[6]);\r
+ case 8:\r
+ return new clazzInner(innerObj, arguments[3], arguments[4], \r
+ arguments[5], arguments[6], arguments[7]);\r
+ case 9:\r
+ return new clazzInner(innerObj, arguments[3], arguments[4], \r
+ arguments[5], arguments[6], arguments[7], arguments[8]);\r
+ case 10:\r
+ return new clazzInner(innerObj, arguments[3], arguments[4], \r
+ arguments[5], arguments[6], arguments[7], arguments[8],\r
+ arguments[9]);\r
+ default:\r
+ //Should construct instance manually.\r
+ obj = new clazzInner(innerObj, Clazz.inheritArgs);\r
+ break;\r
+ }\r
+ }\r
+ var n = arguments.length - 3;\r
+ var args = new Array(n);\r
+ for (var i = n; --i >= 0;)\r
+ args[i] = arguments[i + 3];\r
+ Clazz.instantialize(obj, args);\r
+ return obj;\r
+};\r
+\r
+/**\r
+ * Clone variables whose modifier is "final".\r
+ * Usage: var o = Clazz.cloneFinals ("name", name, "age", age);\r
+ *\r
+ * @return Object with all final variables\r
+ */\r
+/* public */\r
+Clazz.cloneFinals = function () {\r
+ var o = {};\r
+ var len = arguments.length / 2;\r
+ for (var i = len; --i >= 0;)\r
+ o[arguments[i + i]] = arguments[i + i + 1];\r
+ return o;\r
+};\r
+\r
+/* public */\r
+Clazz.isClassDefined = Clazz.isDefinedClass = function(clazzName) {\r
+ if (!clazzName) \r
+ return false; /* consider null or empty name as non-defined class */\r
+ if (Clazz.allClasses[clazzName])\r
+ return true;\r
+ var pkgFrags = clazzName.split (/\./);\r
+ var pkg = null;\r
+ for (var i = 0; i < pkgFrags.length; i++)\r
+ if (!(pkg = (pkg ? pkg[pkgFrags[i]] : Clazz.allPackage[pkgFrags[0]]))) {\r
+ return false;\r
+ }\r
+ return (pkg && (Clazz.allClasses[clazzName] = true));\r
+};\r
+/**\r
+ * Define the enum constant.\r
+ * @param classEnum enum type\r
+ * @param enumName enum constant\r
+ * @param enumOrdinal enum ordinal\r
+ * @param initialParams enum constant constructor parameters\r
+ * @return return defined enum constant\r
+ */\r
+/* public */\r
+Clazz.defineEnumConstant = function (clazzEnum, enumName, enumOrdinal, initialParams, clazzEnumExt) {\r
+ var o = (clazzEnumExt ? new clazzEnumExt() : new clazzEnum());\r
+ // BH avoids unnecessary calls to SAEM\r
+ o.$name = enumName;\r
+ o.$ordinal = enumOrdinal;\r
+ //Clazz.superConstructor (o, clazzEnum, [enumName, enumOrdinal]);\r
+ if (initialParams && initialParams.length)\r
+ o.construct.apply (o, initialParams);\r
+ clazzEnum[enumName] = o;\r
+ clazzEnum.prototype[enumName] = o;\r
+ if (!clazzEnum["$ values"]) { // BH added\r
+ clazzEnum["$ values"] = [] // BH added\r
+ clazzEnum.values = function() { // BH added\r
+ return this["$ values"]; // BH added\r
+ }; // BH added\r
+ }\r
+ clazzEnum["$ values"].push(o);\r
+ return o;\r
+};\r
+\r
+//////// (int) conversions //////////\r
+\r
+Clazz.floatToInt = function (x) {\r
+ return x < 0 ? Math.ceil(x) : Math.floor(x);\r
+};\r
+\r
+Clazz.floatToByte = Clazz.floatToShort = Clazz.floatToLong = Clazz.floatToInt;\r
+Clazz.doubleToByte = Clazz.doubleToShort = Clazz.doubleToLong = Clazz.doubleToInt = Clazz.floatToInt;\r
+\r
+Clazz.floatToChar = function (x) {\r
+ return String.fromCharCode (x < 0 ? Math.ceil(x) : Math.floor(x));\r
+};\r
+\r
+Clazz.doubleToChar = Clazz.floatToChar;\r
+\r
+\r
+\r
+///////////////////////////////// Array additions //////////////////////////////\r
+//\r
+// BH: these are necessary for integer processing, especially\r
+//\r
+//\r
+\r
+var getArrayClone = function(nbits) {\r
+ return function() {\r
+ var me = this;\r
+ var n = me.length;\r
+ var a = (nbits == 32 ? new Int32Array(n) : new Float64Array(n));\r
+ for (var i = n; --i >= 0;)\r
+ a[i] = me[i];\r
+ return a; \r
+ }\r
+}\r
+\r
+if (self.Int32Array && self.Int32Array != Array) {\r
+ Clazz.haveInt32 = true;\r
+ if (!Int32Array.prototype.sort)\r
+ Int32Array.prototype.sort = Array.prototype.sort\r
+ if (!Int32Array.prototype.clone)\r
+ Int32Array.prototype.clone = getArrayClone(32);\r
+} else {\r
+ Int32Array = function(n) {\r
+ if (!n) n = 0;\r
+ var b = new Array(n);\r
+ b.toString = function(){return "[object Int32Array]"}\r
+ for (var i = 0; i < n; i++)b[i] = 0\r
+ return b;\r
+ }\r
+ Clazz.haveInt32 = false;\r
+ Int32Array.prototype.sort = Array.prototype.sort\r
+ Int32Array.prototype.clone = getArrayClone(32);\r
+ Int32Array.prototype.int32Fake = function(){};\r
+}\r
+\r
+if (self.Float64Array && self.Float64Array != Array) {\r
+ Clazz.haveFloat64 = true;\r
+ if (!Float64Array.prototype.sort)\r
+ Float64Array.prototype.sort = Array.prototype.sort\r
+ if (!Float64Array.prototype.clone)\r
+ Float64Array.prototype.clone = getArrayClone(64);\r
+} else {\r
+ Clazz.haveFloat64 = false;\r
+ Float64Array = function(n) {\r
+ if (!n) n = 0;\r
+ var b = new Array(n);\r
+ for (var i = 0; i < n; i++)b[i] = 0.0\r
+ return b;\r
+ };\r
+ Float64Array.prototype.sort = Array.prototype.sort\r
+ Float64Array.prototype.clone = getArrayClone(64);\r
+ Float64Array.prototype.float64Fake = function() {}; // "present"\r
+ Float64Array.prototype.toString = function() {return "[object Float64Array]"};\r
+// Darn! Mozilla makes this a double, not a float. It's 64-bit.\r
+// and Safari 5.1 doesn't have Float64Array \r
+}\r
+\r
+/**\r
+ * Make arrays.\r
+ *\r
+ * @return the created Array object\r
+ */\r
+/* public */\r
+Clazz.newArray = function () {\r
+ if (arguments[0] instanceof Array) {\r
+ // recursive, from newArray(n,m,value)\r
+ // as newArray([m, value], newInt32Array)\r
+ var args = arguments[0];\r
+ var f = arguments[1];\r
+ } else {\r
+ var args = arguments;\r
+ var f = Array;\r
+ }\r
+ var dim = args[0];\r
+ if (typeof dim == "string") {\r
+ dim = dim.charCodeAt (0); // char\r
+ }\r
+ var len = args.length - 1;\r
+ var val = args[len];\r
+ switch (args.length) {\r
+ case 0: // never\r
+ case 1:\r
+ return []; // maybe never?\r
+ case 2:\r
+ if (val == null)\r
+ return new Array(dim);\r
+ if (f === true && Clazz.haveInt32) return new Int32Array(dim);\r
+ if (f === false && Clazz.haveFloat64) return new Float64Array(dim);\r
+ var arr = (f === true ? new Int32Array() : f === false ? new Float64Array() : dim < 0 ? val : new Array(dim));\r
+ for (var i = dim; --i >= 0;)\r
+ arr[i] = val;\r
+ return arr;\r
+ default:\r
+ var xargs = new Array (len);\r
+ for (var i = 0; i < len; i++) {\r
+ xargs[i] = args[i + 1];\r
+ }\r
+ var arr = new Array (dim);\r
+ if (val == null || val >= 0 || len > 2)\r
+ for (var i = 0; i < dim; i++) {\r
+ // Call recursively!\r
+ arr[i] = Clazz.newArray (xargs, f);\r
+ }\r
+ return arr;\r
+ }\r
+};\r
+\r
+Clazz.newArray32 = function(args, isInt32) {\r
+ var dim = args[0];\r
+ if (typeof dim == "string")\r
+ dim = dim.charCodeAt (0); // char\r
+ var len = args.length - 1;\r
+ var val = args[len];\r
+ switch (args.length) {\r
+ case 0:\r
+ case 1: \r
+ alert ("ERROR IN newArray32 -- args.length < 2");\r
+ return new Array(0);\r
+ case 2:\r
+ var isDefined = (dim < 0);\r
+ if (isDefined)\r
+ dim = val.length;\r
+ var a = (val < 0 ? new Array(dim) : isInt32 ? new Int32Array(dim) : new Float64Array(dim));\r
+ if (isDefined)\r
+ for (var i = dim; --i >= 0;)\r
+ a[i] = val[i];\r
+ return a;\r
+ }\r
+ var xargs = new Array(len);\r
+ for (var i = len; --i >= 0;) {\r
+ xargs[i] = args[i + 1];\r
+ }\r
+ var arr = new Array (dim);\r
+ for (var i = 0; i < dim; i++) {\r
+ // Call newArray referencing this array type\r
+ // only for the final iteration, and only if val === 0\r
+ arr[i] = Clazz.newArray (xargs, isInt32);\r
+ }\r
+ return arr;\r
+};\r
+\r
+\r
+/**\r
+ * Make arrays.\r
+ *\r
+ * @return the created Array object\r
+ */\r
+/* public */\r
+Clazz.newInt32Array = function () {\r
+ return Clazz.newArray32(arguments, true);\r
+}\r
+\r
+/**\r
+ * Make arrays.\r
+ *\r
+ * @return the created Array object\r
+ */\r
+/* public */\r
+Clazz.newFloat64Array = function () {\r
+ return Clazz.newArray32(arguments, false);\r
+}\r
+\r
+Clazz.newFloatArray = Clazz.newDoubleArray = Clazz.newFloat64Array;\r
+Clazz.newIntArray = Clazz.newLongArray = Clazz.newShortArray = Clazz.newByteArray = Clazz.newInt32Array;\r
+Clazz.newCharArray = Clazz.newBooleanArray = Clazz.newArray;\r
+\r
+//$_AI=Clazz.newIntArray;\r
+//$_AF=Clazz.newFloatArray;\r
+//$_AD=Clazz.newDoubleArray;\r
+//$_AL=Clazz.newLongArray;\r
+//$_AS=Clazz.newShortArray;\r
+//$_AB=Clazz.newByteArray;\r
+//$_AC=Clazz.newCharArray;\r
+//$_Ab=Clazz.newBooleanArray;\r
+\r
+\r
+var arrayIs = function(a, what) {\r
+ // for some reason, Number.constructor.toString() now gives "too much recursion"\r
+ return a.constructor && a.constructor != Number && a.constructor.toString().indexOf(what) >= 0\r
+}\r
+\r
+Clazz.isAS = function(a) { // just checking first parameter\r
+ return (a && typeof a == "object" && arrayIs(a, " Array") && (typeof a[0] == "string" || typeof a[0] == "undefined"));\r
+}\r
+\r
+Clazz.isASS = function(a) {\r
+ return (a && typeof a == "object" && Clazz.isAS(a[0]));\r
+}\r
+\r
+Clazz.isAP = function(a) {\r
+ return (a && Clazz.getClassName(a[0]) == "JU.P3");\r
+}\r
+\r
+Clazz.isAI = function(a) {\r
+ return (a && typeof a == "object" && (Clazz.haveInt32 ? arrayIs(a, "Int32Array") : a.int32Fake ? true : false));\r
+}\r
+\r
+Clazz.isAII = function(a) { // assumes non-null a[0]\r
+ return (a && typeof a == "object" && Clazz.isAI(a[0]));\r
+}\r
+\r
+Clazz.isAF = function(a) {\r
+ return (a && typeof a == "object" && (Clazz.haveFloat64 ? arrayIs(a, "Float64Array") : a.float64Fake ? true : false));\r
+}\r
+\r
+Clazz.isAFF = function(a) { // assumes non-null a[0]\r
+ return (a && typeof a == "object" && Clazz.isAF(a[0]));\r
+}\r
+\r
+Clazz.isAFFF = function(a) { // assumes non-null a[0]\r
+ return (a && typeof a == "object" && Clazz.isAFF(a[0]));\r
+}\r
+\r
+Clazz.isAFloat = function(a) { // just checking first parameter\r
+ return (a && typeof a == "object" && arrayIs(a, " Array") && Clazz.instanceOf(a[0], Float));\r
+}\r
+\r
+\r
+/**\r
+ * Make the RunnableCompatiability instance as a JavaScript function.\r
+ *\r
+ * @param jsr Instance of RunnableCompatiability\r
+ * @return JavaScript function instance represents the method run of jsr.\r
+ */\r
+/* public */\r
+/*\r
+Clazz.makeFunction = function (jsr) {\r
+// never used in Jmol -- called by Enum, but not accessible to it -- part of SWT\r
+ return function(e) {\r
+ if (!e)\r
+ e = window.event;\r
+ if (jsr.setEvent)\r
+ jsr.setEvent(e);\r
+ jsr.run();\r
+ switch (jsr.returnSet) {\r
+ case 1: \r
+ return jsr.returnNumber;\r
+ case 2:\r
+ return jsr.returnBoolean;\r
+ case 3:\r
+ return jsr.returnObject;\r
+ }\r
+ };\r
+};\r
+*/\r
+\r
+/* protected */\r
+Clazz.defineStatics = function (clazz) {\r
+ for (var j = arguments.length, i = (j - 1) / 2; --i >= 0;) {\r
+ var val = arguments[--j]\r
+ var name = arguments[--j];\r
+ clazz[name] = clazz.prototype[name] = val;\r
+ }\r
+};\r
+\r
+/* public */\r
+Clazz.prepareFields = function (clazz, fieldsFun) {\r
+ var stacks = [];\r
+ if (clazz.con$truct) {\r
+ var ss = clazz.con$truct.stacks;\r
+ var idx = 0;//clazz.con$truct.index;\r
+ for (var i = idx; i < ss.length; i++) {\r
+ stacks[i] = ss[i];\r
+ }\r
+ }\r
+ addProto(clazz.prototype, "con$truct", clazz.con$truct = function () {\r
+ var stacks = arguments.callee.stacks;\r
+ if (stacks) {\r
+ for (var i = 0; i < stacks.length; i++) {\r
+ stacks[i].apply (this, []);\r
+ }\r
+ }\r
+ });\r
+ stacks.push(fieldsFun);\r
+ clazz.con$truct.stacks = stacks;\r
+ clazz.con$truct.index = 0;\r
+};\r
+\r
+/*\r
+ * Serialize those public or protected fields in class \r
+ * net.sf.j2s.ajax.SimpleSerializable.\r
+ */\r
+/* protected */\r
+/*\r
+Clazz.registerSerializableFields = function (clazz) {\r
+ var args = arguments;\r
+ var length = args.length;\r
+ var newArr = [];\r
+ if (clazz.declared$Fields) {\r
+ for (var i = 0; i < clazz.declared$Fields.length; i++) {\r
+ newArr[i] = clazz.declared$Fields[i];\r
+ }\r
+ }\r
+ clazz.declared$Fields = newArr;\r
+\r
+ if (length > 0 && length % 2 == 1) {\r
+ var fs = clazz.declared$Fields;\r
+ var n = (length - 1) / 2;\r
+ for (var i = 1; i <= n; i++) {\r
+ var o = { name : args[i + i - 1], type : args[i + i] };\r
+ var existed = false;\r
+ for (var j = 0; j < fs.length; j++) {\r
+ if (fs[j].name == o.name) { // reloaded classes\r
+ fs[j].type = o.type; // update type\r
+ existed = true;\r
+ break;\r
+ }\r
+ }\r
+ if (!existed)\r
+ fs.push(o);\r
+ }\r
+ }\r
+};\r
+*/\r
+/*\r
+ * Get the caller method for those methods that are wrapped by \r
+ * Clazz.searchAndExecuteMethod.\r
+ *\r
+ * @param args caller method's arguments\r
+ * @return caller method, null if there is not wrapped by \r
+ * Clazz.searchAndExecuteMethod or is called directly.\r
+ */\r
+/* protected */\r
+/*\r
+Clazz.getMixedCallerMethod = function (args) {\r
+ var o = {};\r
+ var argc = args.callee.caller; // tryToSearchAndExecute\r
+ if (argc && argc !== tryToSearchAndExecute) // inherited method's apply\r
+ argc = argc.arguments.callee.caller;\r
+ if (argc !== tryToSearchAndExecute\r
+ || (argc = argc.arguments.callee.caller) !== Clazz.searchAndExecuteMethod)\r
+ return null;\r
+ o.claxxRef = argc.arguments[1];\r
+ o.fxName = argc.arguments[2];\r
+ o.paramTypes = Clazz.getParamsType(argc.arguments[3]); \r
+ argc = argc.arguments.callee.caller // Clazz.generateDelegatingMethod \r
+ && argc.arguments.callee.caller; // the private method's caller\r
+ if (!argc)\r
+ return null;\r
+ o.caller = argc;\r
+ return o;\r
+};\r
+*/\r
+/* BH -- The issue here is a subclass calling its private method FOO when\r
+ * there is also a private method of the same name in its super class.\r
+ * This can ALWAYS be avoided and, one could argue, is bad \r
+ * program design anyway. In Jmol, the presence of this possibility\r
+ * creates over 8000 references to the global $fx, which was only\r
+ * checked in a few rare cases. We can then also remove $fz references.\r
+ * \r
+ */\r
+\r
+/*\r
+ * Check and return super private method.\r
+ * In order make private methods be executed correctly, some extra javascript\r
+ * must be inserted into the beggining of the method body of the non-private \r
+ * methods that with the same method signature as following:\r
+ * <code>\r
+ * var $private = Clazz.checkPrivateMethod (arguments);\r
+ * if ($private) {\r
+ * return $private.apply (this, arguments);\r
+ * }\r
+ * </code>\r
+ * Be cautious about this. The above codes should be insert by Java2Script\r
+ * compiler or with double checks to make sure things work correctly.\r
+ *\r
+ * @param args caller method's arguments\r
+ * @return private method if there are private method fitted for the current \r
+ * calling environment\r
+ */\r
+/* public */\r
+\r
+Clazz.checkPrivateMethod = function () {\r
+ // get both this one and the one calling it\r
+ me = arguments.callee.caller;\r
+ caller = arguments.callee.caller.caller;\r
+ var stack = me.stacks;\r
+ // if their classes are the same, no issue\r
+ var mySig = "\\" + Clazz.getParamsType(arguments[0]).join("\\")\r
+ if (!me.privateNote) {\r
+ me.privateNote = "You are seeing this note because the method " \r
+ + me.exName + mySig + " in class " \r
+ + me.exClazz.__CLASS_NAME__\r
+ + " has a superclass method by the same name (possibly with the same parameters) that is private and "\r
+ + " therefore might be called improperly from this class. If your "\r
+ + " code does not run properly, or you want to make it run faster, change the name of this method to something else."\r
+ System.out.println(me.privateNote);\r
+ alert(me.privateNote);\r
+ }\r
+ /*\r
+ alert([me.exClazz.__CLASS_NAME__, me.exName,\r
+ caller.exClazz.__CLASS_NAME__, caller.exName,stack,mySig])\r
+ if (stack == null || caller.exClazz == me.exClazz)\r
+ return null;\r
+ // I am being called by a different class...\r
+ \r
+ for (var i = stack.length; --i >= 0;) {\r
+ if (stacks[i] != caller.claxxRef)\r
+ continue;\r
+ // and it is on MY class stack\r
+// if (\r
+ \r
+ }\r
+ */\r
+ \r
+/* var m = Clazz.getMixedCallerMethod (args);\r
+ if (m == null) return null;\r
+ var callerFx = m.claxxRef.prototype[m.caller.exName];\r
+ if (callerFx == null) return null; // may not be in the class hierarchies\r
+ var ppFun = null;\r
+ if (callerFx.claxxOwner ) {\r
+ ppFun = callerFx.claxxOwner.prototype[m.fxName];\r
+ } else {\r
+ var stacks = callerFx.stacks;\r
+ for (var i = stacks.length - 1; i >= 0; i--) {\r
+ var fx = stacks[i].prototype[m.caller.exName];\r
+ if (fx === m.caller) {\r
+ ppFun = stacks[i].prototype[m.fxName];\r
+ } else if (fx ) {\r
+ for (var fn in fx) {\r
+ if (fn.indexOf ('\\') == 0 && fx[fn] === m.caller) {\r
+ ppFun = stacks[i].prototype[m.fxName];\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ if (ppFun) {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ if (ppFun && ppFun.claxxOwner == null) {\r
+ ppFun = ppFun["\\" + m.paramTypes];\r
+ }\r
+ if (ppFun && ppFun.isPrivate && ppFun !== args.callee) {\r
+ return ppFun;\r
+ }\r
+*/ \r
+ return null;\r
+};\r
+\r
+\r
+//$fz = null; // for private method declaration\r
+\r
+\r
+// /*# {$no.debug.support} >>x #*/\r
+// /*\r
+// * Option to switch on/off of stack traces.\r
+// */\r
+// /* protect */\r
+//Clazz.tracingCalling = false;\r
+\r
+// /* private */\r
+// Clazz.callingStack = function (caller, owner) {\r
+// this.caller = caller;\r
+// this.owner = owner;\r
+// };\r
+\r
+/*# x<< #*/\r
+\r
+/**\r
+ * The first folder is considered as the primary folder.\r
+ * And try to be compatiable with _Loader system.\r
+ */\r
+/* private */\r
+\r
+\r
+/*** not used in Jmol\r
+ * *\r
+if (window["_Loader"] && _Loader.binaryFolders) {\r
+ Clazz.binaryFolders = _Loader.binaryFolders;\r
+} else {\r
+ Clazz.binaryFolders = ["j2s/", "", "j2slib/"];\r
+}\r
+\r
+Clazz.addBinaryFolder = function (bin) {\r
+ if (bin) {\r
+ var bins = Clazz.binaryFolders;\r
+ for (var i = 0; i < bins.length; i++) {\r
+ if (bins[i] == bin) {\r
+ return ;\r
+ }\r
+ }\r
+ bins[bins.length] = bin;\r
+ }\r
+};\r
+Clazz.removeBinaryFolder = function (bin) {\r
+ if (bin) {\r
+ var bins = Clazz.binaryFolders;\r
+ for (var i = 0; i < bins.length; i++) {\r
+ if (bins[i] == bin) {\r
+ for (var j = i; j < bins.length - 1; j++) {\r
+ bins[j] = bins[j + 1];\r
+ }\r
+ bins.length--;\r
+ return bin;\r
+ }\r
+ }\r
+ }\r
+ return null;\r
+};\r
+Clazz.setPrimaryFolder = function (bin) {\r
+ if (bin) {\r
+ Clazz.removeBinaryFolder (bin);\r
+ var bins = Clazz.binaryFolders;\r
+ for (var i = bins.length - 1; i >= 0; i--) {\r
+ bins[i + 1] = bins[i];\r
+ }\r
+ bins[0] = bin;\r
+ }\r
+};\r
+\r
+***/\r
+\r
+\r
+///////////////// special definitions of standard Java class methods ///////////\r
+\r
+/**\r
+ * This is a simple implementation for Clazz#load. It just ignore dependencies\r
+ * of the class. This will be fine for jar *.z.js file.\r
+ * It will be overriden by _Loader#load.\r
+ * For more details, see _Loader.js\r
+ */\r
+/* protected */\r
+/*\r
+Clazz.load = function (musts, clazz, optionals, declaration) {\r
+ // not used in Jmol\r
+ if (declaration)\r
+ declaration ();\r
+};\r
+*/\r
+\r
+/*\r
+ * Invade the Object prototype!\r
+ * TODO: make sure that invading Object prototype does not affect other\r
+ * existed library, such as Dojo, YUI, Prototype, ...\r
+ */\r
+java.lang.Object = Clazz._O;\r
+\r
+Clazz._O.getName = Clazz._innerFunctions.getName;\r
+\r
+\r
+java.lang.System = System = {\r
+ props : null, //new java.util.Properties (),\r
+ $props : {},\r
+ arraycopy : function (src, srcPos, dest, destPos, length) {\r
+ if (src !== dest) {\r
+ for (var i = 0; i < length; i++) {\r
+ dest[destPos + i] = src[srcPos + i];\r
+ }\r
+ } else {\r
+ var swap = [];\r
+ for (var i = 0; i < length; i++) {\r
+ swap[i] = src[srcPos + i];\r
+ }\r
+ for (var i = 0; i < length; i++) {\r
+ dest[destPos + i] = swap[i];\r
+ }\r
+ }\r
+ },\r
+ currentTimeMillis : function () {\r
+ return new Date ().getTime ();\r
+ },\r
+ gc : function() {}, // bh\r
+ getProperties : function () {\r
+ return System.props;\r
+ },\r
+ getProperty : function (key, def) {\r
+ if (System.props)\r
+ return System.props.getProperty (key, def);\r
+ var v = System.$props[key];\r
+ if (typeof v != "undefined")\r
+ return v;\r
+ if (key.indexOf(".") > 0) {\r
+ v = null; \r
+ switch (key) {\r
+ case "java.version":\r
+ v = "1.6";\r
+ case "file.separator":\r
+ case "path.separator":\r
+ v = "/";\r
+ break; \r
+ case "line.separator":\r
+ v = (navigator.userAgent.indexOf("Windows") >= 0 ? "\r\n" : "\n");\r
+ break;\r
+ case "os.name":\r
+ case "os.version":\r
+ v = navigator.userAgent;\r
+ break;\r
+ }\r
+ if (v)\r
+ return System.$props[key] = v;\r
+ }\r
+ return (arguments.length == 1 ? null : def == null ? key : def); // BH\r
+ },\r
+ getSecurityManager : function() { return null }, // bh\r
+ setProperties : function (props) {\r
+ System.props = props;\r
+ },\r
+ lineSeparator : function() { return '\n' }, // bh\r
+ setProperty : function (key, val) {\r
+ if (!System.props)\r
+ return System.$props[key] = val; // BH\r
+ System.props.setProperty (key, val);\r
+ }\r
+};\r
+\r
+System.identityHashCode=function(obj){\r
+ if(obj==null)\r
+ return 0;\r
+ \r
+ return obj._$hashcode || (obj._$hashcode = ++Clazz._hashCode)\r
+\r
+/* \r
+ try{\r
+ return obj.toString().hashCode();\r
+ }catch(e){\r
+ var str=":";\r
+ for(var s in obj){\r
+ str+=s+":"\r
+ }\r
+ return str.hashCode();\r
+ }\r
+*/ \r
+}\r
+\r
+System.out = new Clazz._O ();\r
+System.out.__CLASS_NAME__ = "java.io.PrintStream";\r
+System.out.print = function () {};\r
+System.out.printf = function () {};\r
+System.out.println = function () {};\r
+System.out.write = function () {};\r
+\r
+System.err = new Clazz._O ();\r
+System.err.__CLASS_NAME__ = "java.io.PrintStream";\r
+System.err.print = function () {};\r
+System.err.printf = function () {};\r
+System.err.println = function () {};\r
+System.err.write = function () {};\r
+\r
+Clazz.popup = Clazz.assert = Clazz.log = Clazz.error = window.alert;\r
+\r
+Thread = function () {};\r
+Thread.J2S_THREAD = Thread.prototype.J2S_THREAD = new Thread ();\r
+Thread.currentThread = Thread.prototype.currentThread = function () {\r
+ return this.J2S_THREAD;\r
+};\r
+\r
+/* not used in Jmol\r
+Clazz.intCast = function (n) { // 32bit\r
+ var b1 = (n & 0xff000000) >> 24;\r
+ var b2 = (n & 0xff0000) >> 16;\r
+ var b3 = (n & 0xff00) >> 8;\r
+ var b4 = n & 0xff;\r
+ if ((b1 & 0x80) != 0) {\r
+ return -(((b1 & 0x7f) << 24) + (b2 << 16) + (b3 << 8) + b4 + 1);\r
+ } else {\r
+ return (b1 << 24) + (b2 << 16) + (b3 << 8) + b4;\r
+ }\r
+};\r
+Clazz.shortCast = function (s) { // 16bit\r
+ var b1 = (n & 0xff00) >> 8;\r
+ var b2 = n & 0xff;\r
+ if ((b1 & 0x80) != 0) {\r
+ return -(((b1 & 0x7f) << 8) + b2 + 1);\r
+ } else {\r
+ return (b1 << 8) + b4;\r
+ }\r
+};\r
+\r
+Clazz.byteCast = function (b) { // 8bit\r
+ if ((b & 0x80) != 0) {\r
+ return -((b & 0x7f) + 1);\r
+ } else {\r
+ return b & 0xff;\r
+ }\r
+};\r
+\r
+Clazz.charCast = function (c) { // 8bit\r
+ return String.fromCharCode (c & 0xff).charAt (0);\r
+};\r
+\r
+Clazz.floatCast = function (f) { // 32bit\r
+ return f;\r
+};\r
+\r
+*/\r
+\r
+\r
+/*\r
+ * Try to fix JavaScript's shift operator defects on long type numbers.\r
+ */\r
+\r
+/* not used in Jmol\r
+\r
+Clazz.longMasks = [];\r
+\r
+Clazz.longReverseMasks = [];\r
+\r
+Clazz.longBits = [];\r
+\r
+;(function () {\r
+ var arr = [1];\r
+ for (var i = 1; i < 53; i++) {\r
+ arr[i] = arr[i - 1] + arr[i - 1]; // * 2 or << 1\r
+ }\r
+ Clazz.longBits = arr;\r
+ Clazz.longMasks[52] = arr[52];\r
+ for (var i = 51; i >= 0; i--) {\r
+ Clazz.longMasks[i] = Clazz.longMasks[i + 1] + arr[i];\r
+ }\r
+ Clazz.longReverseMasks[0] = arr[0];\r
+ for (var i = 1; i < 52; i++) {\r
+ Clazz.longReverseMasks[i] = Clazz.longReverseMasks[i - 1] + arr[i];\r
+ }\r
+}) ();\r
+\r
+\r
+Clazz.longLeftShift = function (l, o) { // 64bit\r
+ if (o == 0) return l;\r
+ if (o >= 64) return 0;\r
+ if (o > 52) {\r
+ error ("[Java2Script] Error : JavaScript does not support long shift!");\r
+ return l;\r
+ }\r
+ if ((l & Clazz.longMasks[o - 1]) != 0) {\r
+ error ("[Java2Script] Error : Such shift operator results in wrong calculation!");\r
+ return l;\r
+ }\r
+ var high = l & Clazz.longMasks[52 - 32 + o];\r
+ if (high != 0) {\r
+ return high * Clazz.longBits[o] + (l & Clazz.longReverseMasks[32 - o]) << 0;\r
+ } else {\r
+ return l << o;\r
+ }\r
+};\r
+\r
+Clazz.intLeftShift = function (n, o) { // 32bit\r
+ return (n << o) & 0xffffffff;\r
+};\r
+\r
+Clazz.longRightShift = function (l, o) { // 64bit\r
+ if ((l & Clazz.longMasks[52 - 32]) != 0) {\r
+ return Math.round((l & Clazz.longMasks[52 - 32]) / Clazz.longBits[32 - o]) + (l & Clazz.longReverseMasks[o]) >> o;\r
+ } else {\r
+ return l >> o;\r
+ }\r
+};\r
+\r
+Clazz.intRightShift = function (n, o) { // 32bit\r
+ return n >> o; // no needs for this shifting wrapper\r
+};\r
+\r
+Clazz.long0RightShift = function (l, o) { // 64bit\r
+ return l >>> o;\r
+};\r
+\r
+Clazz.int0RightShift = function (n, o) { // 64bit\r
+ return n >>> o; // no needs for this shifting wrapper\r
+};\r
+\r
+*/\r
+// Compress the common public API method in shorter name\r
+//$_L=Clazz.load;\r
+//$_W=Clazz.declareAnonymous;$_T=Clazz.declareType;\r
+//$_J=Clazz.declarePackage;$_C=Clazz.decorateAsClass;\r
+//$_Z=Clazz.instantialize;$_I=Clazz.declareInterface;$_D=Clazz.isClassDefined;\r
+//$_H=Clazz.pu$h;$_P=Clazz.p0p;$_B=Clazz.prepareCallback;\r
+//$_N=Clazz.innerTypeInstance;$_K=Clazz.makeConstructor;$_U=Clazz.superCall;$_R=Clazz.superConstructor;\r
+//$_M=Clazz.defineMethod;$_V=Clazz.overrideMethod;$_S=Clazz.defineStatics;\r
+//$_E=Clazz.defineEnumConstant;\r
+//$_F=Clazz.cloneFinals;\r
+//$_Y=Clazz.prepareFields;$_A=Clazz.newArray;$_O=Clazz.instanceOf;\r
+//$_G=Clazz.inheritArgs;$_X=Clazz.checkPrivateMethod;$_Q=Clazz.makeFunction;\r
+//$_s=Clazz.registerSerializableFields;\r
+//$_k=Clazz.overrideConstructor;\r
+\r
+\r
+/////////////////////// inner function support /////////////////////////////////\r
+\r
+/* public */\r
+Clazz.innerFunctionNames = Clazz.innerFunctionNames.concat ([\r
+ "getSuperclass", "isAssignableFrom", \r
+ "getConstructor", \r
+ "getDeclaredMethod", "getDeclaredMethods",\r
+ "getMethod", "getMethods", \r
+ "getModifiers", /*"isArray",*/ "newInstance"]);\r
+\r
+/* public */\r
+Clazz._innerFunctions.getSuperclass = function () {\r
+ return this.superClazz; \r
+};\r
+\r
+/* public */\r
+Clazz._innerFunctions.isAssignableFrom = function (clazz) {\r
+ return Clazz.getInheritedLevel (clazz, this) >= 0; \r
+};\r
+\r
+/* public */\r
+Clazz._innerFunctions.getConstructor = function () {\r
+ return new java.lang.reflect.Constructor (this, [], [], \r
+ java.lang.reflect.Modifier.PUBLIC);\r
+};\r
+/**\r
+ * TODO: fix bug for polymorphic methods!\r
+ */\r
+/* public */\r
+Clazz._innerFunctions.getDeclaredMethods = Clazz._innerFunctions.getMethods = function () {\r
+ var ms = [];\r
+ var p = this.prototype;\r
+ for (var attr in p) {\r
+ if (typeof p[attr] == "function" && !p[attr].__CLASS_NAME__) {\r
+ /* there are polynormical methods. */\r
+ ms.push(new java.lang.reflect.Method (this, attr,\r
+ [], java.lang.Void, [], java.lang.reflect.Modifier.PUBLIC));\r
+ }\r
+ }\r
+ p = this;\r
+ for (var attr in p) {\r
+ if (typeof p[attr] == "function" && !p[attr].__CLASS_NAME__) {\r
+ ms.push(new java.lang.reflect.Method (this, attr,\r
+ [], java.lang.Void, [], java.lang.reflect.Modifier.PUBLIC\r
+ | java.lang.reflect.Modifier.STATIC));\r
+ }\r
+ }\r
+ return ms;\r
+};\r
+/* public */\r
+Clazz._innerFunctions.getDeclaredMethod = Clazz._innerFunctions.getMethod = function (name, clazzes) {\r
+ var p = this.prototype;\r
+ for (var attr in p) {\r
+ if (name == attr && typeof p[attr] == "function" \r
+ && !p[attr].__CLASS_NAME__) {\r
+ /* there are polynormical methods. */\r
+ return new java.lang.reflect.Method (this, attr,\r
+ [], java.lang.Void, [], java.lang.reflect.Modifier.PUBLIC);\r
+ }\r
+ }\r
+ p = this;\r
+ for (var attr in p) {\r
+ if (name == attr && typeof p[attr] == "function" \r
+ && !p[attr].__CLASS_NAME__) {\r
+ return new java.lang.reflect.Method (this, attr,\r
+ [], java.lang.Void, [], java.lang.reflect.Modifier.PUBLIC\r
+ | java.lang.reflect.Modifier.STATIC);\r
+ }\r
+ }\r
+ return null;\r
+};\r
+/* public */\r
+Clazz._innerFunctions.getModifiers = function () {\r
+ return java.lang.reflect.Modifier.PUBLIC;\r
+};\r
+\r
+Clazz._innerFunctions.newInstance = function (a) {\r
+ var clz = this;\r
+ switch(a == null ? 0 : a.length) {\r
+ case 0:\r
+ return new clz();\r
+ case 1:\r
+ return new clz(a[0]);\r
+ case 2:\r
+ return new clz(a[0], a[1]);\r
+ case 3:\r
+ return new clz(a[0], a[1], a[2]);\r
+ case 4:\r
+ return new clz(a[0], a[1], a[2], a[3]);\r
+ default:\r
+ var x = "new " + clz.__CLASS_NAME__ + "(";\r
+ for (var i = 0; i < a.length; i++)\r
+ x += (i == 0 ? "" : ",") + "a[" + i + "]";\r
+ x += ")";\r
+ return eval(x);\r
+ }\r
+};\r
+\r
+//Object.newInstance = Clazz._innerFunctions.newInstance;\r
+;(function(){ // BH added wrapper here\r
+ var inF = Clazz.innerFunctionNames;\r
+ for (var i = 0; i < inF.length; i++) {\r
+ Clazz._O[inF[i]] = Clazz._innerFunctions[inF[i]];\r
+ Array[inF[i]] = Clazz._innerFunctions[inF[i]];\r
+ }\r
+ //Array["isArray"] = function () {\r
+ // return true;\r
+ //};\r
+})();\r
+\r
+//////////////////////////// hotspot and unloading /////////////////////////////\r
+/* For hotspot and unloading */\r
+\r
+if (window["Clazz"] && !window["Clazz"].unloadClass) {\r
+\r
+/* public */\r
+Clazz.unloadClass = function (qClazzName) {\r
+ var cc = Clazz.evalType (qClazzName);\r
+ if (cc) {\r
+ Clazz.unloadedClasses[qClazzName] = cc;\r
+ var clazzName = qClazzName;\r
+ var pkgFrags = clazzName.split (/\./);\r
+ var pkg = null;\r
+ for (var i = 0; i < pkgFrags.length - 1; i++)\r
+ pkg = (pkg ? pkg[pkgFrags[i]] : Clazz.allPackage[pkgFrags[0]]);\r
+ if (!pkg) {\r
+ Clazz.allPackage[pkgFrags[0]] = null;\r
+ window[pkgFrags[0]] = null;\r
+ // also try to unload inner or anonymous classes\r
+ for (var c in window) {\r
+ if (c.indexOf (qClazzName + "$") == 0) {\r
+ Clazz.unloadClass (c);\r
+ window[c] = null;\r
+ }\r
+ }\r
+ } else {\r
+ pkg[pkgFrags[pkgFrags.length - 1]] = null;\r
+ // also try to unload inner or anonymous classes\r
+ for (var c in pkg) {\r
+ if (c.indexOf (pkgFrags[pkgFrags.length - 1] + "$") == 0) {\r
+ Clazz.unloadClass (pkg.__PKG_NAME__ + "." + c);\r
+ pkg[c] = null;\r
+ }\r
+ }\r
+ }\r
+\r
+ if (Clazz.allClasses[qClazzName]) {\r
+ Clazz.allClasses[qClazzName] = false;\r
+ // also try to unload inner or anonymous classes\r
+ for (var c in Clazz.allClasses) {\r
+ if (c.indexOf (qClazzName + "$") == 0) {\r
+ Clazz.allClasses[c] = false;\r
+ }\r
+ }\r
+ }\r
+\r
+ for (var m in cc) {\r
+ cleanDelegateMethod (cc[m]);\r
+ }\r
+ for (var m in cc.prototype) {\r
+ cleanDelegateMethod (cc.prototype[m]);\r
+ }\r
+\r
+ if (Clazz._Loader) {\r
+ Clazz._Loader.unloadClassExt(qClazzName);\r
+ }\r
+\r
+ return true;\r
+ }\r
+ return false;\r
+};\r
+\r
+/* private */\r
+var cleanDelegateMethod = function (m) {\r
+ if (!m) \r
+ return;\r
+ if (typeof m == "function" && m.lastMethod\r
+ && m.lastParams && m.lastClaxxRef) {\r
+ m.lastMethod = null;\r
+ m.lastParams = null;\r
+ m.lastClaxxRef = null;\r
+ }\r
+};\r
+\r
+} // if (window["Clazz"] && !window["Clazz"].unloadClass)\r
+\r
+/******************************************************************************\r
+ * Copyright (c) 2007 java2script.org and others.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * Zhou Renjian - initial API and implementation\r
+ *****************************************************************************/\r
+/*******\r
+ * @author zhou renjian\r
+ * @create July 10, 2006\r
+ *******/\r
+\r
+//if (window["ClazzNode"] == null) {\r
+/**\r
+ * TODO:\r
+ * Make optimization over class dependency tree.\r
+ */\r
+\r
+/*\r
+ * ClassLoader Summary\r
+ * \r
+ * ClassLoader creates SCRIPT elements and setup class path and onload \r
+ * callback to continue class loading.\r
+ *\r
+ * In the onload callbacks, _Loader will try to calculate the next-to-be-\r
+ * load *.js and load it. In *.js, it will contains some codes like\r
+ * Clazz.load (..., "$wt.widgets.Control", ...);\r
+ * to provide information to build up the class dependency tree.\r
+ *\r
+ * Some known problems of different browsers:\r
+ * 1. In IE, loading *.js through SCRIPT will first triggers onreadstatechange \r
+ * event, and then executes inner *.js source.\r
+ * 2. In Firefox, loading *.js will first executes *.js source and then \r
+ * triggers onload event.\r
+ * 3. In Opera, similar to IE, but trigger onload event. (TODO: More details \r
+ * should be studied. Currently, Opera supports no multiple-thread-loading)\r
+ * \r
+ * For class dependency tree, actually, it is not a tree. It is a reference\r
+ * net with nodes have n parents and n children. There is a root, which \r
+ * ClassLoader knows where to start searching and loading classes, for such\r
+ * a net. Each node is a class. Each class may require a set of must-classes, \r
+ * which must be loaded before itself getting initialized, and also need a set\r
+ * of optional classes, which also be loaded before being called.\r
+ *\r
+ * The class loading status will be in 6 stages.\r
+ * 1. Unknown, the class is newly introduced by other class.\r
+ * 2. Known, the class is already mentioned by other class.\r
+ * 3. Loaded, *.js source is in memory, but may not be initialized yet. It \r
+ * requires all its must-classes be intiailized, which is in the next stage.\r
+ * 4. Musts loaded, all must classes is already loaded and declared.\r
+ * 5. Delcared, the class is already declared (_Loader#isClassDefined).\r
+ * 6. Optionals loaded, all optional classes is loaded and declared.\r
+ *\r
+ * The ClassLoader tries to load all necessary classes in order, and intialize\r
+ * them in order. For such job, it will traverse the dependency tree, and try \r
+ * to next class to-be-loaded. Sometime, the class dependencies may be in one\r
+ * or more cycles, which must be broken down so classes is loaded in correct\r
+ * order.\r
+ *\r
+ * Loading order and intializing order is very important for the ClassLoader.\r
+ * The following technical options are considered:\r
+ * 1. SCRIPT is loading asynchronously, which means controling order must use\r
+ * callback methods to continue.\r
+ * 2. Multiple loading threads are later introduced, which requires the \r
+ * ClassLoader should use variables to record the class status.\r
+ * 3. Different browsers have different loading orders, which means extra tests\r
+ * should be tested to make sure loading order won't be broken.\r
+ * 4. Java2Script simulator itself have some loading orders that must be \r
+ * honored, which means it should be integrated seamlessly to Clazz system.\r
+ * 5. Packed *.z.js is introduced to avoid lots of small *.js which requires \r
+ * lots of HTTP connections, which means that packed *.z.js should be treated\r
+ * specially (There will be mappings for such packed classes).\r
+ * 6. *.js or *.css loading may fail according to network status, which means\r
+ * another loading try should be performed, so _Loader is more robust.\r
+ * 7. SWT lazy loading is later introduced, which means that class loading\r
+ * process may be paused and should be resumed later.\r
+ *\r
+ * Some known bugs:\r
+ * <code>$_L(["$wt.graphics.Drawable","$wt.widgets.Widget"],\r
+ * "$wt.widgets.Control", ...</code>\r
+ * has errors while must classes in different order such as\r
+ * <code>$_L(["$wt.widgets.Widget", "$wt.graphics.Drawable"],\r
+ * "$wt.widgets.Control", ...</code>\r
+ * has no error.\r
+ * \r
+ * Other maybe bug scenarios:\r
+ * 1. In <code>_Loader.maxLoadingThreads = 1;</code> single loading thread \r
+ * mode, there are no errors, but in default multiple thread loading mode, \r
+ * there are errors.\r
+ * 2. No errors in one browser, but has errors on other browsers (Browser \r
+ * script loading order differences).\r
+ * 3. First time loading has errors, but reloading it gets no errors (Maybe \r
+ * HTTP connections timeout, but should not accur in local file system, or it\r
+ * is a loading bug by using JavaScript timeout thread).\r
+ */\r
+\r
+/*\r
+ * The following comments with "#" are special configurations for a much\r
+ * smaller *.js file size.\r
+ *\r
+ * @see net.sf.j2s.lib/src/net/sf/j2s/lib/build/SmartJSCompressor.java\r
+ */\r
+/**\r
+ * Static class loader class\r
+ */\r
+Clazz._Loader = Clazz.ClazzLoader = function () {};\r
+\r
+/**\r
+ * Class dependency tree node\r
+ */\r
+/* private */\r
+var Node = function () {\r
+ this.parents = [];\r
+ this.musts = [];\r
+ this.optionals = [];\r
+ this.declaration = null;\r
+ this.name = null; // id\r
+ this.path = null;\r
+// this.requires = null;\r
+// this.requiresMap = null;\r
+ this.onLoaded = null;\r
+ this.status = 0;\r
+ this.random = 0.13412;\r
+};\r
+\r
+\r
+;(function(Clazz, _Loader) {\r
+\r
+_Loader._checkLoad = Jmol._checkLoad;\r
+ \r
+_Loader.updateNodeForFunctionDecoration = function(qName) {\r
+ var node = findNode(qName);\r
+ if (node && node.status == Node.STATUS_KNOWN) {\r
+ window.setTimeout((function(nnn) {\r
+ return function() {\r
+ updateNode(nnn);\r
+ };\r
+ })(node), 1);\r
+ }\r
+}\r
+\r
+Node.prototype.toString = function() {\r
+ return this.name || this.path || "ClazzNode";\r
+}\r
+\r
+Node.STATUS_UNKNOWN = 0;\r
+Node.STATUS_KNOWN = 1;\r
+Node.STATUS_CONTENT_LOADED = 2;\r
+Node.STATUS_MUSTS_LOADED = 3;\r
+Node.STATUS_DECLARED = 4;\r
+Node.STATUS_LOAD_COMPLETE = 5;\r
+\r
+ \r
+var loaders = [];\r
+\r
+/* public */\r
+_Loader.requireLoaderByBase = function (base) {\r
+ for (var i = 0; i < loaders.length; i++) {\r
+ if (loaders[i].base == base) {\r
+ return loaders[i];\r
+ }\r
+ }\r
+ var loader = new _Loader ();\r
+ loader.base = base; \r
+ loaders.push(loader);\r
+ return loader;\r
+};\r
+\r
+/**\r
+ * Class dependency tree\r
+ */\r
+var clazzTreeRoot = new Node();\r
+\r
+/**\r
+ * Used to keep the status whether a given *.js path is loaded or not.\r
+ */\r
+/* private */\r
+var loadedScripts = {};\r
+\r
+/**\r
+ * Multiple threads are used to speed up *.js loading.\r
+ */\r
+/* private */\r
+var inLoadingThreads = 0;\r
+\r
+/**\r
+ * Maximum of loading threads\r
+ */\r
+/* private */\r
+var maxLoadingThreads = 6;\r
+\r
+var userAgent = navigator.userAgent.toLowerCase ();\r
+var isOpera = (userAgent.indexOf ("opera") != -1);\r
+var isIE = (userAgent.indexOf ("msie") != -1) && !isOpera;\r
+var isGecko = (userAgent.indexOf ("gecko") != -1);\r
+\r
+/*\r
+ * Opera has different loading order which will result in performance degrade!\r
+ * So just return to single thread loading in Opera!\r
+ *\r
+ * FIXME: This different loading order also causes bugs in single thread!\r
+ */\r
+if (isOpera) {\r
+ maxLoadingThreads = 1;\r
+ var index = userAgent.indexOf ("opera/");\r
+ if (index != -1) {\r
+ var verNumber = 9.0;\r
+ try {\r
+ verNumber = parseFloat(userAgent.subString (index + 6));\r
+ } catch (e) {}\r
+ if (verNumber >= 9.6) {\r
+ maxLoadingThreads = 6;\r
+ }\r
+ } \r
+}\r
+\r
+/**\r
+ * Try to be compatiable with Clazz system.\r
+ * In original design _Loader and Clazz are independent!\r
+ * -- zhourenjian @ December 23, 2006\r
+ */\r
+var isClassdefined;\r
+var definedClasses;\r
+\r
+if (self.Clazz && Clazz.isClassDefined) {\r
+ isClassDefined = Clazz.isClassDefined;\r
+} else {\r
+ definedClasses = {};\r
+ isClassDefined = function (clazzName) {\r
+ return definedClasses[clazzName] == true;\r
+ };\r
+}\r
+\r
+/**\r
+ * Expand the shortened list of class names.\r
+ * For example:\r
+ * JU.Log, $.Display, $.Decorations\r
+ * will be expanded to \r
+ * JU.Log, JU.Display, JU.Decorations\r
+ * where "$." stands for the previous class name's package.\r
+ *\r
+ * This method will be used to unwrap the required/optional classes list and \r
+ * the ignored classes list.\r
+ */\r
+/* private */\r
+var unwrapArray = function (arr) {\r
+ if (!arr || arr.length == 0)\r
+ return [];\r
+ var last = null;\r
+ for (var i = 0; i < arr.length; i++) {\r
+ if (!arr[i])\r
+ continue;\r
+ if (arr[i].charAt (0) == '$') {\r
+ if (arr[i].charAt (1) == '.') {\r
+ if (!last)\r
+ continue;\r
+ var idx = last.lastIndexOf (".");\r
+ if (idx != -1) {\r
+ var prefix = last.substring (0, idx);\r
+ arr[i] = prefix + arr[i].substring (1);\r
+ }\r
+ } else {\r
+ arr[i] = "org.eclipse.s" + arr[i].substring (1);\r
+ }\r
+ }\r
+ last = arr[i];\r
+ }\r
+ return arr;\r
+};\r
+\r
+/**\r
+ * Used to keep to-be-loaded classes.\r
+ */\r
+/* private */\r
+var classQueue = [];\r
+\r
+/* private */\r
+var classpathMap = {};\r
+\r
+/* private */\r
+var pkgRefCount = 0;\r
+\r
+/* public */\r
+_Loader.loadPackageClasspath = function (pkg, base, isIndex, fSuccess, mode, pt) {\r
+ var map = classpathMap;\r
+ mode || (mode = 0);\r
+ fSuccess || (fSuccess = null);\r
+ pt || (pt = 0);\r
+\r
+ /*\r
+ * In some situation, maybe,\r
+ * _Loader.packageClasspath ("java", ..., true);\r
+ * is called after other _Loader#packageClasspath, e.g.\r
+ * <code>\r
+ * _Loader.packageClasspath ("org.eclipse.swt", "...", true);\r
+ * _Loader.packageClasspath ("java", "...", true);\r
+ * </code>\r
+ * which is not recommended. But _Loader should try to adjust orders\r
+ * which requires "java" to be declared before normal _Loader\r
+ * #packageClasspath call before that line! And later that line\r
+ * should never initialize "java/package.js" again!\r
+ */\r
+ var isPkgDeclared = (isIndex && map["@" + pkg]);\r
+ if (mode == 0 && isIndex && !map["@java"] && pkg.indexOf ("java") != 0 && needPackage("java")) {\r
+ _Loader.loadPackage("java", fSuccess ? function(_package){_Loader.loadPackageClasspath(pkg, base, isIndex, fSuccess, 1)} : null);\r
+ if (fSuccess)\r
+ return;\r
+ }\r
+ if (pkg instanceof Array) {\r
+ unwrapArray(pkg);\r
+ if (fSuccess) {\r
+ if (pt < pkg.length)\r
+ _Loader.loadPackageClasspath(pkg[pt], base, isIndex, function(_loadPackageClassPath){_Loader.loadPackageClasspath(pkg, base, isIndex, fSuccess, 1, pt + 1)}, 1);\r
+ else\r
+ fSuccess();\r
+ } else {\r
+ for (var i = 0; i < pkg.length; i++)\r
+ _Loader.loadPackageClasspath(pkg[i], base, isIndex, null);\r
+ }\r
+ return;\r
+ }\r
+ switch (pkg) {\r
+ case "java.*":\r
+ pkg = "java";\r
+ // fall through\r
+ case "java":\r
+ if (base) {\r
+ // support ajax for default\r
+ var key = "@net.sf.j2s.ajax";\r
+ if (!map[key])\r
+ map[key] = base;\r
+ key = "@net.sf.j2s";\r
+ if (!map[key])\r
+ map[key] = base;\r
+ } \r
+ break;\r
+ case "swt":\r
+ pkg = "org.eclipse.swt";\r
+ break;\r
+ case "ajax":\r
+ pkg = "net.sf.j2s.ajax";\r
+ break;\r
+ case "j2s":\r
+ pkg = "net.sf.j2s";\r
+ break;\r
+ default:\r
+ if (pkg.lastIndexOf(".*") == pkg.length - 2)\r
+ pkg = pkg.substring(0, pkg.length - 2);\r
+ break;\r
+ }\r
+ if (base) // critical for multiple applets\r
+ map["@" + pkg] = base;\r
+ if (isIndex && !isPkgDeclared && !window[pkg + ".registered"]) {\r
+ pkgRefCount++;\r
+ if (pkg == "java")\r
+ pkg = "core" // JSmol -- moves java/package.js to core/package.js\r
+ _Loader.loadClass(pkg + ".package", function () {\r
+ if (--pkgRefCount == 0)\r
+ runtimeLoaded();\r
+ //fSuccess && fSuccess();\r
+ }, true, true, 1);\r
+ return;\r
+ }\r
+ fSuccess && fSuccess();\r
+};\r
+\r
+/**\r
+ * BH: allows user/developer to load classes even though wrapping and Google\r
+ * Closure Compiler has not been run on the class.\r
+ * \r
+ */\r
+Clazz.loadClass = function (name, onLoaded, async) {\r
+ if (!self.Class) {\r
+ Class = Clazz;\r
+ Class.forName = Clazz._4Name;\r
+ JavaObject = Clazz._O;\r
+ // maybe more here\r
+ }\r
+ return (name && _Loader.loadClass(name, onLoaded, true, async, 1));\r
+}\r
+\r
+/**\r
+ * Load the given class ant its related classes.\r
+ */\r
+/* public */\r
+_Loader.loadClass = function (name, onLoaded, forced, async, mode) {\r
+\r
+ mode || (mode = 0); // BH: not implemented\r
+ (async == null) && (async = false);\r
+ \r
+ if (typeof onLoaded == "boolean")\r
+ return Clazz.evalType(name);\r
+\r
+ System.out.println("loadClass " + name)\r
+\r
+ // Make sure that packageClasspath ("java", base, true); \r
+ // is called before any _Loader#loadClass is called.\r
+\r
+ if (needPackage("java"))\r
+ _Loader.loadPackage("java");\r
+ if (needPackage("core"))\r
+ _Loader.loadPackage("core"); \r
+\r
+// var swtPkg = "org.eclipse.swt";\r
+// if (name.indexOf (swtPkg) == 0 || name.indexOf ("$wt") == 0) {\r
+// _Loader.assurePackageClasspath (swtPkg);\r
+// }\r
+// if (name.indexOf ("junit") == 0) {\r
+// _Loader.assurePackageClasspath ("junit");\r
+// }\r
+\r
+ // Any _Loader#loadClass calls will be queued until java.* core classes are loaded.\r
+\r
+ _Loader.keepOnLoading = true;\r
+ \r
+ if (!forced && (pkgRefCount && name.lastIndexOf(".package") != name.length - 8\r
+ || name.indexOf("java.") != 0 && !isClassDefined(runtimeKeyClass)\r
+ )) { \r
+ queueBe4KeyClazz.push([name, onLoaded]);\r
+ \r
+ \r
+ System.out.println("loadclass-queuing" + name+ runtimeKeyClass + " "+ isClassDefined(runtimeKeyClass))\r
+\r
+ return; \r
+ }\r
+ var b;\r
+ if ((b = isClassDefined(name)) || isClassExcluded(name)) {\r
+ if (b && onLoaded) {\r
+ var nn = findNode(name);\r
+ if (!nn || nn.status >= Node.STATUS_LOAD_COMPLETE) {\r
+ if (async) {\r
+ window.setTimeout(onLoaded, 25);\r
+ } else {\r
+ onLoaded();\r
+ }\r
+ }\r
+ }\r
+ return;\r
+ }\r
+ var path = _Loader.getClasspathFor(name);\r
+ var existed = loadedScripts[path];\r
+ var qq = classQueue;\r
+ if (!existed)\r
+ for (var i = qq.length; --i >= 0;)\r
+ if (qq[i].path == path || qq[i].name == name) {\r
+ existed = true;\r
+ break;\r
+ }\r
+ if (existed) {\r
+ if (onLoaded) {\r
+ var n = findNode(name);\r
+ if (n) {\r
+ if (!n.onLoaded) {\r
+ n.onLoaded = onLoaded;\r
+ } else if (onLoaded != n.onLoaded) {\r
+ n.onLoaded = (function (nF, oF) { return function () { nF(); oF() }; }) (n.onLoaded, onLoaded);\r
+ }\r
+ }\r
+ }\r
+ return;\r
+ }\r
+\r
+ var n = (Clazz.unloadedClasses[name] && findNode(name) || new Node());\r
+ n.name = name;\r
+ n.path = path;\r
+ n.isPackage = (path.lastIndexOf("package.js") == path.length - 10);\r
+ mappingPathNameNode(path, name, n);\r
+ n.onLoaded = onLoaded;\r
+ n.status = Node.STATUS_KNOWN;\r
+ var needBeingQueued = false;\r
+ for (var i = qq.length; --i >= 0;) {\r
+ if (qq[i].status != Node.STATUS_LOAD_COMPLETE) {\r
+ needBeingQueued = true;\r
+ break;\r
+ }\r
+ }\r
+ \r
+ if (n.isPackage) {//forced\r
+ // push class to queue\r
+ var pt = qq.length;\r
+ for (; --pt >= 0;) {\r
+ if (qq[pt].isPackage) \r
+ break;\r
+ qq[pt + 1] = qq[pt];\r
+ }\r
+ qq[++pt] = n;\r
+ } else if (needBeingQueued) {\r
+ qq.push(n);\r
+ }\r
+ if (!needBeingQueued) { // can be loaded directly\r
+ var bSave = false;\r
+ if (onLoaded) { \r
+ bSave = isLoadingEntryClass;\r
+ isLoadingEntryClass = true;\r
+ }\r
+ if (forced)onLoaded = null;\r
+ addChildClassNode(clazzTreeRoot, n, true);\r
+ loadScript(n, n.path, n.requiredBy, false, onLoaded ? function(_loadClass){ isLoadingEntryClass = bSave; onLoaded()}: null);\r
+ }\r
+};\r
+\r
+/*\r
+ * Check whether given package's classpath is setup or not.\r
+ * Only "java" and "org.eclipse.swt" are accepted in argument.\r
+ */\r
+/* private */\r
+var needPackage = function(pkg) {\r
+ // note that false != null and true != null\r
+ return (window[pkg + ".registered"] != null && !classpathMap["@" + pkg]);\r
+}\r
+\r
+/* private */\r
+_Loader.loadPackage = function(pkg, fSuccess) {\r
+ fSuccess || (fSuccess = null);\r
+ window[pkg + ".registered"] = false;\r
+ _Loader.loadPackageClasspath(pkg, \r
+ (_Loader.J2SLibBase || (_Loader.J2SLibBase = (_Loader.getJ2SLibBase() || "j2s/"))), \r
+ true, fSuccess);\r
+};\r
+\r
+/**\r
+ * Register classes to a given *.z.js path, so only a single *.z.js is loaded\r
+ * for all those classes.\r
+ */\r
+/* public */\r
+_Loader.jarClasspath = function (jar, clazzes) {\r
+ if (!(clazzes instanceof Array))\r
+ clazzes = [classes];\r
+ unwrapArray(clazzes);\r
+ for (var i = clazzes.length; --i >= 0;)\r
+ classpathMap["#" + clazzes[i]] = jar;\r
+ classpathMap["$" + jar] = clazzes;\r
+};\r
+\r
+/**\r
+ * Usually be used in .../package.js. All given packages will be registered\r
+ * to the same classpath of given prefix package.\r
+ */\r
+/* public */\r
+_Loader.registerPackages = function (prefix, pkgs) {\r
+ //_Loader.checkInteractive ();\r
+ var base = _Loader.getClasspathFor (prefix + ".*", true);\r
+ for (var i = 0; i < pkgs.length; i++) {\r
+ if (window["Clazz"]) {\r
+ Clazz.declarePackage (prefix + "." + pkgs[i]);\r
+ }\r
+ _Loader.loadPackageClasspath (prefix + "." + pkgs[i], base);\r
+ }\r
+};\r
+\r
+/**\r
+ * Using multiple sites to load *.js in multiple threads. Using multiple\r
+ * sites may avoid 2 HTTP 1.1 connections recommendation limit.\r
+ * Here is a default implementation for http://archive.java2script.org.\r
+ * In site archive.java2script.org, there are 6 sites:\r
+ * 1. http://archive.java2script.org or http://a.java2script.org\r
+ * 2. http://erchive.java2script.org or http://e.java2script.org\r
+ * 3. http://irchive.java2script.org or http://i.java2script.org\r
+ * 4. http://orchive.java2script.org or http://o.java2script.org\r
+ * 5. http://urchive.java2script.org or http://u.java2script.org\r
+ * 6. http://yrchive.java2script.org or http://y.java2script.org\r
+ */\r
+/* protected */\r
+ /*\r
+_Loader.multipleSites = function (path) {\r
+ var deltas = window["j2s.update.delta"];\r
+ if (deltas && deltas instanceof Array && deltas.length >= 3) {\r
+ var lastOldVersion = null;\r
+ var lastNewVersion = null;\r
+ for (var i = 0; i < deltas.length / 3; i++) {\r
+ var oldVersion = deltas[i + i + i];\r
+ if (oldVersion != "$") {\r
+ lastOldVersion = oldVersion;\r
+ }\r
+ var newVersion = deltas[i + i + i + 1];\r
+ if (newVersion != "$") {\r
+ lastNewVersion = newVersion;\r
+ }\r
+ var relativePath = deltas[i + i + i + 2];\r
+ var key = lastOldVersion + "/" + relativePath;\r
+ var idx = path.indexOf (key);\r
+ if (idx != -1 && idx == path.length - key.length) {\r
+ path = path.substring (0, idx) + lastNewVersion + "/" + relativePath;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ var length = path.length;\r
+ if (maxLoadingThreads > 1 \r
+ && ((length > 15 && path.substring (0, 15) == "http://archive.")\r
+ || (length > 9 && path.substring (0, 9) == "http://a."))) {\r
+ var index = path.lastIndexOf("/");\r
+ if (index < length - 3) {\r
+ var arr = ['a', 'e', 'i', 'o', 'u', 'y'];\r
+ var c1 = path.charCodeAt (index + 1);\r
+ var c2 = path.charCodeAt (index + 2);\r
+ var idx = (length - index) * 3 + c1 * 5 + c2 * 7; // Hash\r
+ return path.substring (0, 7) + arr[idx % 6] + path.substring (8);\r
+ }\r
+ }\r
+ return path;\r
+};\r
+ */\r
+\r
+/**\r
+ * Return the *.js path of the given class. Maybe the class is contained\r
+ * in a *.z.js jar file.\r
+ * @param clazz Given class that the path is to be calculated for. May\r
+ * be java.package, or java.lang.String\r
+ * @param forRoot Optional argument, if true, the return path will be root\r
+ * of the given classs' package root path.\r
+ * @param ext Optional argument, if given, it will replace the default ".js"\r
+ * extension.\r
+ */\r
+/* public */\r
+_Loader.getClasspathFor = function (clazz, forRoot, ext) {\r
+ var path = classpathMap["#" + clazz];\r
+ if (!path || forRoot || ext) {\r
+ var base;\r
+ var idx;\r
+ if (path) {\r
+ clazz = clazz.replace(/\./g, "/"); \r
+ if ((idx = path.lastIndexOf(clazz)) >= 0 \r
+ || (idx = clazz.lastIndexOf("/")) >= 0 \r
+ && (idx = path.lastIndexOf(clazz.substring(0, idx))) >= 0)\r
+ base = path.substring(0, idx);\r
+ } else {\r
+ idx = clazz.length + 2;\r
+ while ((idx = clazz.lastIndexOf(".", idx - 2)) >= 0)\r
+ if ((base = classpathMap["@" + clazz.substring(0, idx)]))\r
+ break;\r
+ if (!forRoot)\r
+ clazz = clazz.replace (/\./g, "/"); \r
+ }\r
+ if (base == null) {\r
+ var bins = "binaryFolders";\r
+ base = (window["Clazz"] && Clazz[bins] && Clazz[bins].length ? Clazz[bins][0] \r
+ : _Loader[bins] && _Loader[bins].length ? _Loader[bins][0]\r
+ : "j2s");\r
+ }\r
+ path = (base.lastIndexOf("/") == base.length - 1 ? base : base + "/") + (forRoot ? ""\r
+ : clazz.lastIndexOf("/*") == clazz.length - 2 ? clazz.substring(0, idx + 1)\r
+ : clazz + (!ext ? ".js" : ext.charAt(0) != '.' ? "." + ext : ext));\r
+ } \r
+ return path;//_Loader.multipleSites(path);\r
+};\r
+\r
+/**\r
+ * To ignore some classes.\r
+ */\r
+/* public */\r
+_Loader.ignore = function () {\r
+ var clazzes = (arguments.length == 1 && arguments[0] instanceof Array ?\r
+ clazzes = arguments[0] : null);\r
+ var n = (clazzes ? clazzes.length : arguments.length);\r
+ if (!clazzes) {\r
+ clazzes = new Array(n);\r
+ for (var i = 0; i < n; i++)\r
+ clazzes[i] = arguments[i];\r
+ }\r
+ unwrapArray(clazzes);\r
+ for (var i = 0; i < n; i++)\r
+ excludeClassMap["@" + clazzes[i]] = 1;\r
+};\r
+\r
+/**\r
+ * The following *.script* can be overriden to indicate the \r
+ * status of classes loading.\r
+ *\r
+ * TODO: There should be a Java interface with name like INativeLoaderStatus\r
+ */\r
+/* public */\r
+_Loader.onScriptLoading = function (file){};\r
+\r
+/* public */\r
+_Loader.onScriptLoaded = function (file, isError){};\r
+\r
+/* public */\r
+_Loader.onScriptInitialized = function (file){};\r
+\r
+/* public */\r
+_Loader.onScriptCompleted = function (file){};\r
+\r
+/* public */\r
+_Loader.onClassUnloaded = function (clazz){};\r
+\r
+/**\r
+ * After all the classes are loaded, this method will be called.\r
+ * Should be overriden to run *.main([]).\r
+ */\r
+/* public */\r
+_Loader.onGlobalLoaded = function () {};\r
+\r
+/* public */\r
+_Loader.keepOnLoading = true; // never set false in this code\r
+\r
+\r
+/* private */\r
+var mapPath2ClassNode = {};\r
+\r
+/* private */\r
+var isClassExcluded = function (clazz) {\r
+ return excludeClassMap["@" + clazz];\r
+};\r
+\r
+/* Used to keep ignored classes */\r
+/* private */\r
+var excludeClassMap = {};\r
+\r
+/* private */\r
+var evaluate = function(file, file0, js) {\r
+ try {\r
+ eval(js + ";//# sourceURL="+file);\r
+ } catch (e) { \r
+ if (Clazz._isQuiet) \r
+ return;\r
+ var s = "[Java2Script] The required class file \n\n" + file + (js.indexOf("[Exception") == 0 && js.indexOf("data: no") ? \r
+ "\nwas not found.\n"\r
+ : "\ncould not be loaded. Script error: " + e.message + " \n\ndata:\n\n" + js) + "\n\n" + Clazz.getStackTrace();\r
+ alert(s)\r
+ Clazz.alert(s);\r
+ throw e;\r
+ }\r
+ _Loader.onScriptLoaded(file, false);\r
+ tryToLoadNext(file0);\r
+}\r
+\r
+/* private */\r
+var failedHandles = {};\r
+\r
+/* private */\r
+var generateRemovingFunction = function (node) {\r
+ return function () {\r
+ if (node.readyState != "interactive") {\r
+ try {\r
+ if (node.parentNode)\r
+ node.parentNode.removeChild (node);\r
+ } catch (e) { }\r
+ node = null;\r
+ }\r
+ };\r
+};\r
+\r
+/* private */\r
+var removeScriptNode = function (n) {\r
+ if (window["j2s.script.debugging"]) {\r
+ return;\r
+ }\r
+ // lazily remove script nodes.\r
+ window.setTimeout (generateRemovingFunction (n), 1);\r
+};\r
+\r
+/* public */\r
+Clazz._4Name = function(clazzName, applet, state) {\r
+ if (Clazz.isClassDefined(clazzName))\r
+ return Clazz.evalType(clazzName);\r
+ var f = (Jmol._isAsync && applet ? applet._restoreState(clazzName, state) : null);\r
+ if (f == 1)\r
+ return null; // must be already being created\r
+ if (_Loader.setLoadingMode(f ? _Loader.MODE_SCRIPT : "xhr.sync")) {\r
+ _Loader.loadClass(clazzName, f, false, true, 1);\r
+ return null; // this will surely throw an error, but that is OK\r
+ }\r
+ //alert ("Using Java reflection: " + clazzName + " for " + applet._id + " \n"+ Clazz.getStackTrace());\r
+ _Loader.loadClass(clazzName);\r
+ return Clazz.evalType(clazzName);\r
+};\r
+\r
+/**\r
+ * BH: possibly useful for debugging\r
+ */ \r
+Clazz.currentPath= "";\r
+\r
+/**\r
+ * Load *.js by adding script elements into head. Hook the onload event to\r
+ * load the next class in dependency tree.\r
+ */\r
+/* private */\r
+var loadScript = function (node, file, why, ignoreOnload, fSuccess, _loadScript) {\r
+\r
+ Clazz.currentPath = file;\r
+ if (ignoreOnload)alert("WHY>>")\r
+//BH removed // maybe some scripts are to be loaded without needs to know onload event.\r
+// if (!ignoreOnload && loadedScripts[file]) {\r
+// _Loader.tryToLoadNext(file);\r
+// return;\r
+// }\r
+ loadedScripts[file] = true;\r
+ // also remove from queue\r
+ removeArrayItem(classQueue, file);\r
+\r
+ // forces not-found message\r
+ isUsingXMLHttpRequest = true;\r
+ isAsynchronousLoading = false;\r
+ if (_Loader._checkLoad) {\r
+ System.out.println("\t" + file + (why ? "\n -- required by " + why : "") + " ajax=" + isUsingXMLHttpRequest + " async=" + isAsynchronousLoading)\r
+ }\r
+\r
+ var file0 = file;\r
+ if (Clazz._debugging) {\r
+ file = file.replace(/\.z\.js/,".js");\r
+ }\r
+\r
+ _Loader.onScriptLoading(file);\r
+ if (isUsingXMLHttpRequest && !isAsynchronousLoading) {\r
+ // alert("\t" + file + (why ? "\n -- required by " + why : "") + " ajax=" + isUsingXMLHttpRequest + " async=" + isAsynchronousLoading + " " + Clazz.getStackTrace())\r
+ // synchronous loading\r
+ // works in MSIE locally unless a binary file :)\r
+ // from Jmol.api.Interface only\r
+ var data = Jmol._getFileData(file);\r
+ try{\r
+ evaluate(file, file0, data);\r
+ }catch(e) {\r
+ alert(e + " loading file " + file + " " + node.name + " " + Clazz.getStackTrace());\r
+ }\r
+ if (fSuccess) {\r
+// System.out.println("firing in loadScript " + file + " " + (fSuccess && fSuccess.toString()))\r
+ fSuccess(); \r
+ }\r
+ return;\r
+ }\r
+ \r
+ \r
+System.out.println("for file " + file +" fSuccess = " + (fSuccess ? fSuccess.toString() : ""))\r
+ var info = {\r
+ dataType:"script",\r
+ async:true, \r
+ type:"GET", \r
+ url:file,\r
+ success:W3CScriptOnCallback(file, false, fSuccess),\r
+ error:W3CScriptOnCallback(file, true, fSuccess)\r
+ };\r
+ inLoadingThreads++;\r
+ Jmol.$ajax(info);\r
+};\r
+\r
+/* private */\r
+var W3CScriptOnCallback = function (path, forError, fSuccess) {\r
+ var s = Clazz.getStackTrace();\r
+ // if (!fSuccess)alert("why no fSuccess?" + s)\r
+ return function () {\r
+ //System.out.println("returning " + (fSuccess ? fSuccess.toString() : "no function ") + s) \r
+ if (forError && __debuggingBH)Clazz.alert ("############ forError=" + forError + " path=" + path + " ####" + (forError ? "NOT" : "") + "LOADED###");\r
+ if (isGecko && this.timeoutHandle)\r
+ window.clearTimeout(this.timeoutHandle), this.timeoutHandle = null;\r
+ if (inLoadingThreads > 0)\r
+ inLoadingThreads--;\r
+ //System.out.println("w3ccalback for " + path + " " + inLoadingThreads + " threads")\r
+ this.onload = null;\r
+ this.onerror = null;\r
+ if (forError) \r
+ alert ("There was a problem loading " + path);\r
+ _Loader.onScriptLoaded(path, true);\r
+ var node = this; \r
+ var f;\r
+ if (fSuccess)\r
+ f = function(_W3scriptFS){removeScriptNode(node);tryToLoadNext(path, fSuccess); };\r
+ else\r
+ f = function(_W3script){removeScriptNode(node);tryToLoadNext(path)};\r
+ if (loadingTimeLag >= 0)\r
+ window.setTimeout(function() { tryToLoadNext(path, f); }, loadingTimeLag);\r
+ else\r
+ tryToLoadNext(path, f);\r
+ };\r
+};\r
+\r
+/* private */\r
+var isLoadingEntryClass = true;\r
+\r
+/* private */\r
+var besidesJavaPackage = false;\r
+\r
+/**\r
+ * After class is loaded, this method will be executed to check whether there\r
+ * are classes in the dependency tree that need to be loaded.\r
+ */\r
+/* private */\r
+var tryToLoadNext = function (file, fSuccess) {\r
+ var node = mapPath2ClassNode["@" + file];\r
+ if (!node) // maybe class tree root\r
+ return;\r
+ var n;\r
+ // check for content loaded\r
+ var clazzes = classpathMap["$" + file];\r
+ if (clazzes) {\r
+ for (var i = 0; i < clazzes.length; i++) {\r
+ var name = clazzes[i];\r
+ if (name != node.name && (n = findNode(name))) {\r
+ if (n.status < Node.STATUS_CONTENT_LOADED) {\r
+ n.status = Node.STATUS_CONTENT_LOADED;\r
+ updateNode(n);\r
+ }\r
+ } else {\r
+ n = new Node();\r
+ n.name = name;\r
+ var pp = classpathMap["#" + name];\r
+ if (!pp) {\r
+ alert (name + " J2S error in tryToLoadNext");\r
+ error("Java2Script implementation error! Please report this bug!");\r
+ }\r
+ n.path = pp;\r
+ mappingPathNameNode (n.path, name, n);\r
+ n.status = Node.STATUS_CONTENT_LOADED;\r
+ addChildClassNode(clazzTreeRoot, n, false);\r
+ updateNode(n);\r
+ }\r
+ }\r
+ }\r
+ if (node instanceof Array) {\r
+ for (var i = 0; i < node.length; i++) {\r
+ if (node[i].status < Node.STATUS_CONTENT_LOADED) {\r
+ node[i].status = Node.STATUS_CONTENT_LOADED;\r
+ updateNode(node[i]);\r
+ }\r
+ }\r
+ } else if (node.status < Node.STATUS_CONTENT_LOADED) {\r
+ var stillLoading = false;\r
+ var ss = document.getElementsByTagName ("SCRIPT");\r
+ for (var i = 0; i < ss.length; i++) {\r
+ if (isIE) {\r
+ if (ss[i].onreadystatechange && ss[i].onreadystatechange.path == node.path\r
+ && ss[i].readyState == "interactive") {\r
+ stillLoading = true;\r
+ break;\r
+ }\r
+ } else if (ss[i].onload && ss[i].onload.path == node.path) {\r
+ stillLoading = true;\r
+ break;\r
+ }\r
+ }\r
+ if (!stillLoading) {\r
+ node.status = Node.STATUS_CONTENT_LOADED;\r
+ updateNode(node);\r
+ }\r
+ }\r
+ /*\r
+ * Maybe in #optinalLoaded inside above _Loader#updateNode calls, \r
+ * _Loader.keepOnLoading is set false (Already loaded the wanted\r
+ * classes), so here check to stop.\r
+ */\r
+ \r
+ if (!_Loader.keepOnLoading) // set externally\r
+ return;\r
+\r
+ // check for a "must" class that has content and load it\r
+ var cq;\r
+ var working = true;\r
+ if ((n = findNextMustClass(Node.STATUS_KNOWN))) {\r
+ loadClassNode(n);\r
+ while (inLoadingThreads < maxLoadingThreads) {\r
+ if (!(n = findNextMustClass(Node.STATUS_KNOWN)))\r
+ break;\r
+ loadClassNode(n); // will increase inLoadingThreads!\r
+ }\r
+ } else if ((cq = classQueue).length != 0) { \r
+ /* queue must be loaded in order! */\r
+ n = cq.shift();\r
+ if (!loadedScripts[n.path] \r
+ || cq.length != 0 \r
+ || !isLoadingEntryClass\r
+ || n.musts.length\r
+ || n.optionals.length) {\r
+ addChildClassNode(clazzTreeRoot, n, true);\r
+ loadScript(n, n.path, n.requiredBy, false);\r
+ } else if (isLoadingEntryClass) {\r
+ /*\r
+ * The first time reaching here is the time when ClassLoader\r
+ * is trying to load entry class. Class with #main method and\r
+ * is to be executed is called Entry Class.\r
+ *\r
+ * Here when loading entry class, ClassLoader should not call\r
+ * the next following loading script. This is because, those\r
+ * scripts will try to mark the class as loaded directly and\r
+ * then continue to call #onLoaded callback method,\r
+ * which results in an script error!\r
+ */\r
+ isLoadingEntryClass = false;\r
+ }\r
+ } else if ((n = findNextRequiredClass(Node.STATUS_KNOWN))) {\r
+ loadClassNode(n);\r
+ while (inLoadingThreads < maxLoadingThreads) {\r
+ if (!(n = findNextRequiredClass(Node.STATUS_KNOWN)))\r
+ break;\r
+ loadClassNode(n); // will increase inLoadingThreads!\r
+ }\r
+ } else {\r
+ working = false;\r
+ }\r
+ if (working || inLoadingThreads > 0)\r
+ return;\r
+ // \r
+ // now check all classes that MUST be loaded prior to initialization \r
+ // of some other class (static calls, extends, implements)\r
+ // and all classes REQUIRED somewhere in that class, possibly by the constructor\r
+ // (that is, "new xxxx()" called somewhere in code) and update them\r
+ // that have content but are not declared already \r
+ var f = [findNextMustClass,findNextRequiredClass];\r
+ var lastNode = null;\r
+ for (var i = 0; i < 2; i++)\r
+ while ((n = f[i](Node.STATUS_CONTENT_LOADED))) {\r
+ if (i == 1 && lastNode === n) // Already existed cycle ?\r
+ n.status = Node.STATUS_LOAD_COMPLETE;\r
+ updateNode(n);\r
+ lastNode = n;\r
+ }\r
+ \r
+ // check for load cycles\r
+ \r
+ while (true) {\r
+ tracks = [];\r
+ if (!checkCycle(clazzTreeRoot, file))\r
+ break;\r
+ }\r
+ \r
+ // and update all MUST and REQUIRED classes that are declared already \r
+ \r
+ for (var i = 0; i < 2; i++) {\r
+ lastNode = null;\r
+ while ((n = f[i](Node.STATUS_DECLARED))) {\r
+ if (lastNode === n) \r
+ break;\r
+ updateNode(lastNode = n);\r
+ }\r
+ }\r
+ var done = [];\r
+ for (var i = 0; i < 2; i++) \r
+ while ((n = f[i](Node.STATUS_DECLARED)))\r
+ done.push(n), n.status = Node.STATUS_LOAD_COMPLETE;\r
+ if (done.length) {\r
+ for (var i = 0; i < done.length; i++)\r
+ destroyClassNode(done[i]);\r
+ for (var i = 0; i < done.length; i++)\r
+ if ((f = done[i].onLoaded))\r
+ done[i].onLoaded = null, f();\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ \r
+ \r
+ \r
+ //System.out.println(node.name + " loaded completely" + _Loader.onGlobalLoaded + "\n\n")\r
+ if (fSuccess) {\r
+ //System.out.println("tryToLoadNext firing " + _Loader._classCountOK + "/" + _Loader._classCountPending + " " + fSuccess.toString() + " " + Clazz.getStackTrace())\r
+ fSuccess();\r
+ } else if (_Loader._classCountPending) {\r
+ for (var name in _Loader._classPending) {\r
+ var n = findNode(name);\r
+ System.out.println("class left pending " + name + " " + n);\r
+ if (n) {\r
+ updateNode(n);\r
+ break;\r
+ }\r
+ }\r
+ } else {\r
+ \r
+ // System.out.println("I think I'm done " \r
+ // + _Loader._classCountOK + "/" + _Loader._classCountPending + " " \r
+ //+ _Loader.onGlobalLoaded.toString() + " " + Clazz.getStackTrace()\r
+ // )\r
+ if (_Loader._checkLoad) {\r
+ System.out.println("I think I'm done: SAEM call count: " + SAEMid);\r
+ Clazz.showDuplicates(true);\r
+ }\r
+ }\r
+ _Loader.onGlobalLoaded();\r
+};\r
+\r
+\r
+var tracks = [];\r
+\r
+/*\r
+ * There are classes reference cycles. Try to detect and break those cycles.\r
+ */\r
+/* private */\r
+var checkCycle = function (node, file) {\r
+ var ts = tracks;\r
+ var len = ts.length;\r
+ // add this node to tracks\r
+ ts.push(node);\r
+ var i = len;\r
+ for (; --i >= 0;)\r
+ if (ts[i] === node && ts[i].status >= Node.STATUS_DECLARED) \r
+ break;\r
+ if (i >= 0) {\r
+ // this node is already in tracks, and it has been declared already\r
+ // for each node in tracks, set its status to "LOAD_COMPLETE"\r
+ // update all parents, remove all parents, and fire its onLoaded function\r
+ // then clear tracks and return true (keep checking) \r
+ if (_Loader._checkLoad) {\r
+ var msg = "cycle found loading " + file + " for " + node;\r
+ System.out.println(msg)\r
+ } \r
+ for (; i < len; i++) {\r
+ var n = ts[i];\r
+ n.status = Node.STATUS_LOAD_COMPLETE;\r
+ destroyClassNode(n); // Same as above\r
+ for (var k = 0; k < n.parents.length; k++)\r
+ updateNode(n.parents[k]);\r
+ n.parents = [];\r
+ var f = n.onLoaded;\r
+ if (_Loader._checkLoad) {\r
+ var msg = "cycle setting status to LOAD_COMPLETE for " + n.name + (f ? " firing " + f.toString() : "");\r
+ System.out.println(msg)\r
+ } \r
+ if (f)\r
+ n.onLoaded = null, f();\r
+ }\r
+ ts.length = 0;\r
+ return true;\r
+ }\r
+ var a = [node.musts, node.optionals];\r
+ for (var j = 0; j < 2; j++)\r
+ for (var r = a[j], i = r.length; --i >= 0;)\r
+ if (r[i].status == Node.STATUS_DECLARED && checkCycle(r[i], file)) \r
+ return true;\r
+ // reset _tracks to its original length \r
+ ts.length = len;\r
+ return false; // done \r
+};\r
+\r
+\r
+_Loader._classCountPending = 0;\r
+_Loader._classCountOK = 0;\r
+_Loader._classPending = {};\r
+\r
+_Loader.showPending = function() {\r
+ var a = [];\r
+ for (var name in _Loader._classPending) {\r
+ var n = findNode(name);\r
+ if (!n) {\r
+ alert("No node for " + name);\r
+ continue;\r
+ }\r
+ a.push(n);\r
+ System.out.println(showNode("", "", n, "", 0)); \r
+ } \r
+ return a;\r
+}\r
+\r
+var showNode = function(s, names, node, inset, level) {\r
+ names += "--" + node.name;\r
+ s += names + "\n";\r
+ if (level > 5) {\r
+ s += inset + " ...\n";\r
+ return s;\r
+ }\r
+ inset += "\t";\r
+ s += inset + "status: " + node.status + "\n";\r
+ if (node.parents && node.parents.length && node.parents[0] && node.parents[0].name) {\r
+ s += inset + "parents: " + node.parents.length + "\n";\r
+ for (var i = 0; i < node.parents.length; i++) {\r
+ s = showNode(s, names, node.parents[i], inset + "\t", level+1);\r
+ }\r
+ s += "\n";\r
+ }\r
+// if (node.requiredBy) {\r
+// s += inset + "requiredBy:\n";\r
+// s = showNode(s, names, node.requiredBy, inset + "\t", level+1);\r
+// s += "\n";\r
+// }\r
+ return s; \r
+} \r
+\r
+/**\r
+ * Update the dependency tree nodes recursively.\r
+ */\r
+/* private */\r
+updateNode = function(node, _updateNode) {\r
+ if (!node.name || node.status >= Node.STATUS_LOAD_COMPLETE) {\r
+ destroyClassNode(node);\r
+ return;\r
+ }\r
+ var ready = true;\r
+ // check for declared and also having MUSTS\r
+ if (node.musts.length && node.declaration) {\r
+ for (var mustLength = node.musts.length, i = mustLength; --i >= 0;) {\r
+ var n = node.musts[i];\r
+ n.requiredBy = node;\r
+ if (n.status < Node.STATUS_DECLARED && isClassDefined (n.name)) {\r
+ var nns = []; // a stack for onLoaded events\r
+ n.status = Node.STATUS_LOAD_COMPLETE;\r
+ destroyClassNode(n); // Same as above\r
+ if (n.declaration && n.declaration.clazzList) {\r
+ // For those classes within one *.js file, update them synchronously.\r
+ for (var j = 0, list = n.declaration.clazzList, l = list.length; j < l; j++) {\r
+ var nn = findNode (list[j]);\r
+ if (nn && nn.status != Node.STATUS_LOAD_COMPLETE\r
+ && nn !== n) {\r
+ nn.status = n.status;\r
+ nn.declaration = null;\r
+ destroyClassNode(nn);\r
+ nn.onLoaded && nns.push(nn);\r
+ }\r
+ }\r
+ n.declaration = null;\r
+ }\r
+ // fire all onLoaded events\r
+ if (n.onLoaded)\r
+ nns.push(n);\r
+ for (var j = 0; j < nns.length; j++) {\r
+ var onLoaded = nns[j].onLoaded;\r
+ if (onLoaded) {\r
+ nns[j].onLoaded = null;\r
+ onLoaded();\r
+ }\r
+ }\r
+ } else {\r
+ (n.status == Node.STATUS_CONTENT_LOADED) && updateNode(n); // musts may be changed\r
+ if (n.status < Node.STATUS_DECLARED)\r
+ ready = false;\r
+ }\r
+ if (node.musts.length != mustLength) {\r
+ // length changed -- restart!\r
+ i = mustLength = node.musts.length;\r
+ ready = true;\r
+ }\r
+ }\r
+ }\r
+ if (!ready)\r
+ return;\r
+ if (node.status < Node.STATUS_DECLARED) {\r
+ var decl = node.declaration;\r
+ if (decl)\r
+ decl(), decl.executed = true;\r
+ if(_Loader._checkLoad) {\r
+ if (_Loader._classPending[node.name]) {\r
+ delete _Loader._classPending[node.name];\r
+ _Loader._classCountOK;\r
+ _Loader._classCountPending--;\r
+// System.out.println("OK " + (_Loader._classCountOK) + " FOR " + node.name)\r
+ }\r
+ }\r
+ node.status = Node.STATUS_DECLARED;\r
+ if (definedClasses)\r
+ definedClasses[node.name] = true;\r
+ _Loader.onScriptInitialized(node.path);\r
+ if (node.declaration && node.declaration.clazzList) {\r
+ // For those classes within one *.js file, update them synchronously.\r
+ for (var j = 0, list = node.declaration.clazzList, l = list.length; j < l; j++) {\r
+ var nn = findNode(list[j]);\r
+ if (nn && nn.status != Node.STATUS_DECLARED\r
+ && nn !== node) {\r
+ nn.status = Node.STATUS_DECLARED;\r
+ if (definedClasses)\r
+ definedClasses[nn.name] = true;\r
+ _Loader.onScriptInitialized(nn.path);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ var level = Node.STATUS_DECLARED;\r
+ if (node.optionals.length == 0 && node.musts.length == 0\r
+ || node.status > Node.STATUS_KNOWN && !node.declaration\r
+ || checkStatusIs(node.musts, Node.STATUS_LOAD_COMPLETE)\r
+ && checkStatusIs(node.optionals, Node.STATUS_LOAD_COMPLETE)) { \r
+ level = Node.STATUS_LOAD_COMPLETE;\r
+ if (!doneLoading(node, level))\r
+ return false;\r
+ // For those classes within one *.js file, update them synchronously.\r
+ if (node.declaration && node.declaration.clazzList) {\r
+ for (var j = 0, list = node.declaration.clazzList, l = list.length; j < l; j++) {\r
+ var nn = findNode(list[j]);\r
+ if (nn && nn.status != level && nn !== node) {\r
+ nn.declaration = null;\r
+ if (!doneLoading(nn, level))\r
+ return false;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ // _Loader.updateParents = function (node, level, _updateParents)\r
+ if (node.parents && node.parents.length) {\r
+ for (var i = 0; i < node.parents.length; i++) {\r
+ var p = node.parents[i];\r
+ if (p.status < level) \r
+ updateNode(p, p.name);\r
+ }\r
+ if (level == Node.STATUS_LOAD_COMPLETE)\r
+ node.parents = [];\r
+ }\r
+};\r
+\r
+/* private */\r
+var checkStatusIs = function(arr, status){\r
+ for (var i = arr.length; --i >= 0;)\r
+ if (arr[i].status < status)\r
+ return false;\r
+ return true;\r
+}\r
+/* private */\r
+var doneLoading = function(node, level, _doneLoading) {\r
+ node.status = level;\r
+ _Loader.onScriptCompleted(node.path);\r
+ \r
+ var onLoaded = node.onLoaded;\r
+ if (onLoaded) {\r
+ node.onLoaded = null;\r
+ onLoaded();\r
+ if (!_Loader.keepOnLoading)\r
+ return false;\r
+ }\r
+ \r
+ destroyClassNode(node);\r
+ return true;\r
+}\r
+\r
+/*\r
+ * Be used to record already used random numbers. And next new random\r
+ * number should not be in the property set.\r
+ */\r
+/* private */\r
+var usedRandoms = {\r
+ "r0.13412" : 1\r
+};\r
+\r
+/* private */\r
+var getRnd = function() {\r
+ while (true) { // get a unique random number\r
+ var rnd = Math.random();\r
+ var s = "r" + rnd;\r
+ if (!usedRandoms[s])\r
+ return (usedRandoms[s] = 1, clazzTreeRoot.random = rnd);\r
+ }\r
+}\r
+\r
+/* protected */\r
+var findNode = function(clazzName) {\r
+ getRnd();\r
+ return findNodeUnderNode(clazzName, clazzTreeRoot);\r
+};\r
+\r
+/* private */\r
+var findNextRequiredClass = function(status) {\r
+ getRnd();\r
+ return findNextRequiredNode(clazzTreeRoot, status);\r
+};\r
+\r
+/* private */\r
+var findNextMustClass = function(status) {\r
+ return findNextMustNode(clazzTreeRoot, status);\r
+};\r
+\r
+/* private */\r
+var findNodeUnderNode = function(clazzName, node) {\r
+ var n;\r
+ // node, then musts then optionals\r
+ return (node.name == clazzName ? node \r
+ : (n = findNodeWithin(clazzName, node.musts))\r
+ || (n = findNodeWithin(clazzName, node.optionals)) \r
+ ? n : null);\r
+};\r
+\r
+/* private */\r
+var findNodeWithin = function(name, arr) {\r
+ var rnd = clazzTreeRoot.random;\r
+ for (var i = arr.length; --i >= 0;) {\r
+ var n = arr[i];\r
+ if (n.name == name)\r
+ return n;\r
+ if (n.random != rnd) {\r
+ n.random = rnd;\r
+ if ((n = findNodeUnderNode(name, n)))\r
+ return n;\r
+ }\r
+ }\r
+ return null;\r
+}\r
+\r
+/* private */\r
+var checkStatus = function(n, status) {\r
+ return (n.status == status \r
+ && (status != Node.STATUS_KNOWN || !loadedScripts[n.path])\r
+ && (status == Node.STATUS_DECLARED || !isClassDefined (n.name)));\r
+}\r
+\r
+/* private */\r
+var findNextMustNode = function(node, status) {\r
+ for (var i = node.musts.length; --i >= 0;) {\r
+ var n = node.musts[i];\r
+ if (checkStatus(n, status) || (n = findNextMustNode(n, status)))\r
+ return n; \r
+ }\r
+ return (checkStatus(node, status) ? node : null); \r
+};\r
+\r
+/* private */\r
+var findNextRequiredNode = function (node, status) {\r
+ // search musts first\r
+ // search optionals second\r
+ // search itself last\r
+ var n;\r
+ return ((n = searchClassArray(node.musts, status))\r
+ || (n = searchClassArray(node.optionals, status))\r
+ || checkStatus(n = node, status) ? n : null);\r
+};\r
+\r
+/* private */\r
+var searchClassArray = function (arr, status) {\r
+ if (arr) {\r
+ var rnd = clazzTreeRoot.random;\r
+ for (var i = 0; i < arr.length; i++) {\r
+ var n = arr[i];\r
+ if (checkStatus(n, status))\r
+ return n;\r
+ if (n.random != rnd) {\r
+ n.random = rnd; // mark as visited!\r
+ if ((n = findNextRequiredNode(n, status)))\r
+ return n;\r
+ }\r
+ }\r
+ }\r
+ return null;\r
+};\r
+\r
+/**\r
+ * This map variable is used to mark that *.js is correctly loaded.\r
+ * In IE, _Loader has defects to detect whether a *.js is correctly\r
+ * loaded or not, so inner loading mark is used for detecting.\r
+ */\r
+/* private */\r
+var innerLoadedScripts = {};\r
+\r
+/**\r
+ * This method will be called in almost every *.js generated by Java2Script\r
+ * compiler.\r
+ */\r
+/* public */\r
+var load = function (musts, name, optionals, declaration) {\r
+ // called as name.load in Jmol\r
+ if (name instanceof Array) {\r
+ unwrapArray(name);\r
+ for (var i = 0; i < name.length; i++)\r
+ load(musts, name[i], optionals, declaration, name);\r
+ return;\r
+ } \r
+\r
+ if (_Loader._checkLoad) {\r
+ if (_Loader._classPending[name]) {\r
+ //alert("duplicate load for " + name)\r
+ } else {\r
+ _Loader._classPending[name] = 1;\r
+ if (_Loader._classCountPending++ == 0)\r
+ _Loader._classCountOK = 0;\r
+ System.out.println("Loading class " + name);\r
+ }\r
+ }\r
+\r
+// if (clazz.charAt (0) == '$')\r
+// clazz = "org.eclipse.s" + clazz.substring (1);\r
+ var node = mapPath2ClassNode["#" + name];\r
+ if (!node) { // load called inside *.z.js?\r
+ var n = findNode(name);\r
+ node = (n ? n : new Node());\r
+ node.name = name;\r
+ node.path = classpathMap["#" + name] || "unknown";\r
+ mappingPathNameNode(node.path, name, node);\r
+ node.status = Node.STATUS_KNOWN;\r
+ addChildClassNode(clazzTreeRoot, node, false);\r
+ }\r
+ processRequired(node, musts, true);\r
+ if (arguments.length == 5 && declaration) {\r
+ declaration.status = node.status;\r
+ declaration.clazzList = arguments[4];\r
+ }\r
+ node.declaration = declaration;\r
+ if (declaration) \r
+ node.status = Node.STATUS_CONTENT_LOADED;\r
+ processRequired(node, optionals, false);\r
+};\r
+\r
+/* private */\r
+var processRequired = function(node, arr, isMust) {\r
+ if (arr && arr.length) {\r
+ unwrapArray(arr);\r
+ for (var i = 0; i < arr.length; i++) {\r
+ var name = arr[i];\r
+ if (!name)\r
+ continue;\r
+ if (isClassDefined(name)\r
+ || isClassExcluded(name))\r
+ continue;\r
+ var n = findNode(name);\r
+ if (!n) {\r
+ n = new Node();\r
+ n.name = name;\r
+ n.status = Node.STATUS_KNOWN;\r
+ }\r
+ n.requiredBy = node;\r
+ addChildClassNode(node, n, isMust);\r
+ }\r
+ }\r
+}\r
+\r
+/*\r
+ * Try to be compatiable of Clazz\r
+ */\r
+if (window["Clazz"]) {\r
+ Clazz.load = load;\r
+} else {\r
+ _Loader.load = load;\r
+} \r
+/**\r
+ * Map different class to the same path! Many classes may be packed into\r
+ * a *.z.js already.\r
+ *\r
+ * @path *.js path\r
+ * @name class name\r
+ * @node Node object\r
+ */\r
+/* private */\r
+var mappingPathNameNode = function (path, name, node) {\r
+ var map = mapPath2ClassNode;\r
+ var keyPath = "@" + path;\r
+ var v = map[keyPath];\r
+ if (v) {\r
+ if (v instanceof Array) {\r
+ var existed = false;\r
+ for (var i = 0; i < v.length; i++) {\r
+ if (v[i].name == name) {\r
+ existed = true;\r
+ break;\r
+ }\r
+ }\r
+ if (!existed)\r
+ v.push(node);\r
+ } else {\r
+ map[keyPath] = [v, node];\r
+ }\r
+ } else {\r
+ map[keyPath] = node;\r
+ }\r
+ map["#" + name] = node;\r
+};\r
+\r
+/* protected */\r
+var loadClassNode = function (node) {\r
+ var name = node.name;\r
+ if (!isClassDefined (name) \r
+ && !isClassExcluded (name)) {\r
+ var path = _Loader.getClasspathFor (name/*, true*/);\r
+ node.path = path;\r
+ mappingPathNameNode (path, name, node);\r
+ if (!loadedScripts[path]) {\r
+ loadScript(node, path, node.requiredBy, false);\r
+ return true;\r
+ }\r
+ }\r
+ return false;\r
+};\r
+\r
+\r
+/**\r
+ * Used in package\r
+/* public */\r
+var runtimeKeyClass = _Loader.runtimeKeyClass = "java.lang.String";\r
+\r
+/**\r
+ * Queue used to store classes before key class is loaded.\r
+ */\r
+/* private */\r
+var queueBe4KeyClazz = [];\r
+\r
+/* private */\r
+var J2sLibBase;\r
+\r
+/**\r
+ * Return J2SLib base path from existed SCRIPT src attribute.\r
+ */\r
+/* public */\r
+_Loader.getJ2SLibBase = function () {\r
+ var o = window["j2s.lib"];\r
+ return (o ? o.base + (o.alias == "." ? "" : (o.alias ? o.alias : (o.version ? o.version : "1.0.0")) + "/") : null);\r
+};\r
+\r
+/**\r
+ * Indicate whether _Loader is loading script synchronously or \r
+ * asynchronously.\r
+ */\r
+/* private */\r
+var isAsynchronousLoading = true;\r
+\r
+/* private */\r
+var isUsingXMLHttpRequest = false;\r
+\r
+/* private */\r
+var loadingTimeLag = -1;\r
+\r
+_Loader.MODE_SCRIPT = 4;\r
+_Loader.MODE_XHR = 2;\r
+_Loader.MODE_SYNC = 1;\r
+\r
+/**\r
+ * String mode:\r
+ * asynchronous modes:\r
+ * async(...).script, async(...).xhr, async(...).xmlhttprequest,\r
+ * script.async(...), xhr.async(...), xmlhttprequest.async(...),\r
+ * script\r
+ * \r
+ * synchronous modes:\r
+ * sync(...).xhr, sync(...).xmlhttprequest,\r
+ * xhr.sync(...), xmlhttprequest.sync(...),\r
+ * xmlhttprequest, xhr\r
+ * \r
+ * Integer mode:\r
+ * Script 4; XHR 2; SYNC bit 1; \r
+ */\r
+/* public */\r
+_Loader.setLoadingMode = function (mode, timeLag) {\r
+ var async = true;\r
+ var ajax = true;\r
+ if (typeof mode == "string") {\r
+ mode = mode.toLowerCase();\r
+ if (mode.indexOf("script") >= 0)\r
+ ajax = false;\r
+ else\r
+ async = (mode.indexOf("async") >=0);\r
+ async = false; // BH\r
+ } else {\r
+ if (mode & _Loader.MODE_SCRIPT)\r
+ ajax = false;\r
+ else\r
+ async = !(mode & _Loader.MODE_SYNC);\r
+ }\r
+ isUsingXMLHttpRequest = ajax;\r
+ isAsynchronousLoading = async;\r
+ loadingTimeLag = (async && timeLag >= 0 ? timeLag: -1);\r
+ return async;\r
+};\r
+\r
+/* private */\r
+var runtimeLoaded = function () {\r
+ if (pkgRefCount || !isClassDefined(runtimeKeyClass))\r
+ return;\r
+ var qbs = queueBe4KeyClazz;\r
+ for (var i = 0; i < qbs.length; i++)\r
+ _Loader.loadClass(qbs[i][0], qbs[i][1]);\r
+ queueBe4KeyClazz = [];\r
+};\r
+\r
+/*\r
+ * Load those key *.z.js. This *.z.js will be surely loaded before other \r
+ * queued *.js.\r
+ */\r
+/* public */\r
+_Loader.loadZJar = function (zjarPath, keyClass) {\r
+// used only by package.js for core.z.js\r
+ var f = null;\r
+ var isArr = (keyClass instanceof Array);\r
+ if (isArr)\r
+ keyClass = keyClass[keyClass.length - 1];\r
+ else\r
+ f = (keyClass == runtimeKeyClass ? runtimeLoaded : null); \r
+ _Loader.jarClasspath(zjarPath, isArr ? keyClass : [keyClass]);\r
+ // BH note: runtimeKeyClass is java.lang.String \r
+ _Loader.loadClass(keyClass, f, true);\r
+};\r
+\r
+var NodeMap = {};\r
+var _allNodes = [];\r
+\r
+/**\r
+ * The method help constructing the multiple-binary class dependency tree.\r
+ */\r
+/* private */\r
+var addChildClassNode = function (parent, child, isMust) {\r
+ var existed = false;\r
+ var arr;\r
+ if (isMust) {\r
+ arr = parent.musts;\r
+ if (!child.requiredBy)\r
+ child.requiredBy = parent;\r
+// if (!parent.requiresMap){\r
+// parent.requires = [];\r
+// parent.requiresMap = {};\r
+// }\r
+// if (!parent.requiresMap[child.name]) {\r
+// parent.requiresMap[child.name] = 1;\r
+// parent.requires.push[child];\r
+// }\r
+ } else {\r
+ arr = parent.optionals;\r
+ }\r
+ if (!NodeMap[child.name]) {\r
+ _allNodes.push(child)\r
+ NodeMap[child.name]=child\r
+ }\r
+ for (var i = 0; i < arr.length; i++) {\r
+ if (arr[i].name == child.name) {\r
+ existed = true;\r
+ break;\r
+ }\r
+ }\r
+ if (!existed) {\r
+ arr.push(child);\r
+ if (isLoadingEntryClass \r
+ && child.name.indexOf("java") != 0 \r
+ && child.name.indexOf("net.sf.j2s.ajax") != 0) {\r
+ if (besidesJavaPackage)\r
+ isLoadingEntryClass = false;\r
+ besidesJavaPackage = true;\r
+// } else if (child.name.indexOf("org.eclipse.swt") == 0 \r
+// || child.name.indexOf("$wt") == 0) {\r
+// window["swt.lazy.loading.callback"] = swtLazyLoading;\r
+// if (needPackage("org.eclipse.swt"))\r
+// return _Loader.loadPackage("org.eclipse.swt", function() {addParentClassNode(child, parent)});\r
+ }\r
+ }\r
+ addParentClassNode(child, parent);\r
+};\r
+\r
+/* private */\r
+var addParentClassNode = function(child, parent) {\r
+ if (parent.name && parent != clazzTreeRoot && parent != child)\r
+ for (var i = 0; i < child.parents.length; i++)\r
+ if (child.parents[i].name == parent.name)\r
+ return;\r
+ child.parents.push(parent);\r
+}\r
+\r
+/* private */\r
+var destroyClassNode = function (node) {\r
+ var parents = node.parents;\r
+ if (parents)\r
+ for (var k = parents.length; --k >= 0;)\r
+ removeArrayItem(parents[k].musts, node) || removeArrayItem(parents[k].optionals, node);\r
+};\r
+\r
+/* public */\r
+_Loader.unloadClassExt = function (qClazzName) {\r
+ if (definedClasses)\r
+ definedClasses[qClazzName] = false;\r
+ if (classpathMap["#" + qClazzName]) {\r
+ var pp = classpathMap["#" + qClazzName];\r
+ classpathMap["#" + qClazzName] = null;\r
+ var arr = classpathMap["$" + pp];\r
+ removeArrayItem(arr, qClazzName) && (classpathMap["$" + pp] = arr);\r
+ }\r
+ var n = findNode(qClazzName);\r
+ if (n) {\r
+ n.status = Node.STATUS_KNOWN;\r
+ loadedScripts[n.path] = false;\r
+ }\r
+ var path = _Loader.getClasspathFor (qClazzName);\r
+ loadedScripts[path] = false;\r
+ innerLoadedScripts[path] && (innerLoadedScripts[path] = false);\r
+ _Loader.onClassUnloaded(qClazzName);\r
+};\r
+\r
+/* private */\r
+var assureInnerClass = function (clzz, fun) {\r
+ clzz = clzz.__CLASS_NAME__;\r
+ if (Clazz.unloadedClasses[clzz]) {\r
+ if (clzz.indexOf("$") >= 0)\r
+ return;\r
+ var list = [];\r
+ var key = clzz + "$";\r
+ for (var s in Clazz.unloadedClasses)\r
+ if (Clazz.unloadedClasses[s] && s.indexOf(key) == 0)\r
+ list.push(s);\r
+ if (!list.length) \r
+ return;\r
+ fun = "" + fun;\r
+ var idx1, idx2;\r
+ if ((idx1 = fun.indexOf(key)) < 0 || (idx2 = fun.indexOf("\"", idx1 + key.length)) < 0) \r
+ return;\r
+ clzz = fun.substring(idx1, idx2);\r
+ if (!Clazz.unloadedClasses[clzz] || (idx1 = fun.indexOf("{", idx2) + 1) == 0)\r
+ return;\r
+ if ((idx2 = fun.indexOf("(" + clzz + ",", idx1 + 3)) < 0\r
+ || (idx2 = fun.lastIndexOf("}", idx2 - 1)) < 0)\r
+ return;\r
+ eval(fun.substring(idx1, idx2));\r
+ Clazz.unloadedClasses[clzz] = null;\r
+ }\r
+};\r
+\r
+Clazz.binaryFolders = _Loader.binaryFolders = [ _Loader.getJ2SLibBase() ];\r
+\r
+})(Clazz, Clazz._Loader);\r
+\r
+//}\r
+/******************************************************************************\r
+ * Copyright (c) 2007 java2script.org and others.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * Zhou Renjian - initial API and implementation\r
+ *****************************************************************************/\r
+/*******\r
+ * @author zhou renjian\r
+ * @create Jan 11, 2007\r
+ *******/\r
+\r
+Clazz._LoaderProgressMonitor = {};\r
+\r
+;(function(CLPM, Jmol) {\r
+\r
+var fadeOutTimer = null;\r
+var fadeAlpha = 0;\r
+var monitorEl = null;\r
+var lastScrollTop = 0;\r
+var bindingParent = null;\r
+\r
+CLPM.DEFAULT_OPACITY = (Jmol && Jmol._j2sLoadMonitorOpacity ? Jmol._j2sLoadMonitorOpacity : 55);\r
+\r
+/* public */\r
+/*CLPM.initialize = function (parent) {\r
+ bindingParent = parent;\r
+ if (parent && !attached) {\r
+ attached = true;\r
+ //Clazz.addEvent (window, "unload", cleanup);\r
+ // window.attachEvent ("onunload", cleanup);\r
+ }\r
+};\r
+*/\r
+\r
+/* public */\r
+CLPM.hideMonitor = function () {\r
+ monitorEl.style.display = "none";\r
+}\r
+\r
+/* public */\r
+CLPM.showStatus = function (msg, fading) {\r
+ if (!monitorEl) {\r
+ createHandle ();\r
+ if (!attached) {\r
+ attached = true;\r
+ //Clazz.addEvent (window, "unload", cleanup);\r
+ // window.attachEvent ("onunload", cleanup);\r
+ }\r
+ }\r
+ clearChildren(monitorEl);\r
+ if (msg == null) {\r
+ if (fading) {\r
+ fadeOut();\r
+ } else {\r
+ CLPM.hideMonitor();\r
+ }\r
+ return;\r
+ }\r
+ \r
+ monitorEl.appendChild(document.createTextNode ("" + msg));\r
+ if (monitorEl.style.display == "none") {\r
+ monitorEl.style.display = "";\r
+ }\r
+ setAlpha(CLPM.DEFAULT_OPACITY);\r
+ var offTop = getFixedOffsetTop();\r
+ if (lastScrollTop != offTop) {\r
+ lastScrollTop = offTop;\r
+ monitorEl.style.bottom = (lastScrollTop + 4) + "px";\r
+ }\r
+ if (fading) {\r
+ fadeOut();\r
+ }\r
+};\r
+\r
+/* private static */ \r
+var clearChildren = function (el) {\r
+ if (!el)\r
+ return;\r
+ for (var i = el.childNodes.length; --i >= 0;) {\r
+ var child = el.childNodes[i];\r
+ if (!child)\r
+ continue;\r
+ if (child.childNodes && child.childNodes.length)\r
+ clearChildren (child);\r
+ try {\r
+ el.removeChild (child);\r
+ } catch (e) {};\r
+ }\r
+};\r
+/* private */ \r
+var setAlpha = function (alpha) {\r
+ if (fadeOutTimer && alpha == CLPM.DEFAULT_OPACITY) {\r
+ window.clearTimeout (fadeOutTimer);\r
+ fadeOutTimer = null;\r
+ }\r
+ fadeAlpha = alpha;\r
+ var ua = navigator.userAgent.toLowerCase();\r
+ monitorEl.style.filter = "Alpha(Opacity=" + alpha + ")";\r
+ monitorEl.style.opacity = alpha / 100.0;\r
+};\r
+/* private */ \r
+var hidingOnMouseOver = function () {\r
+ CLPM.hideMonitor();\r
+};\r
+\r
+/* private */ \r
+var attached = false;\r
+/* private */ \r
+var cleanup = function () {\r
+ //if (monitorEl) {\r
+ // monitorEl.onmouseover = null;\r
+ //}\r
+ monitorEl = null;\r
+ bindingParent = null;\r
+ //Clazz.removeEvent (window, "unload", cleanup);\r
+ //window.detachEvent ("onunload", cleanup);\r
+ attached = false;\r
+};\r
+/* private */ \r
+var createHandle = function () {\r
+ var div = document.createElement ("DIV");\r
+ div.id = "_Loader-status";\r
+ div.style.cssText = "position:absolute;bottom:4px;left:4px;padding:2px 8px;"\r
+ + "z-index:" + (window["j2s.lib"].monitorZIndex || 10000) + ";background-color:#8e0000;color:yellow;" \r
+ + "font-family:Arial, sans-serif;font-size:10pt;white-space:nowrap;";\r
+ div.onmouseover = hidingOnMouseOver;\r
+ monitorEl = div;\r
+ if (bindingParent) {\r
+ bindingParent.appendChild(div);\r
+ } else {\r
+ document.body.appendChild(div);\r
+ }\r
+ return div;\r
+};\r
+/* private */ \r
+\r
+var fadeOut = function () {\r
+ if (monitorEl.style.display == "none") return;\r
+ if (fadeAlpha == CLPM.DEFAULT_OPACITY) {\r
+ fadeOutTimer = window.setTimeout(function () {\r
+ fadeOut();\r
+ }, 750);\r
+ fadeAlpha -= 5;\r
+ } else if (fadeAlpha - 10 >= 0) {\r
+ setAlpha(fadeAlpha - 10);\r
+ fadeOutTimer = window.setTimeout(function () {\r
+ fadeOut();\r
+ }, 40);\r
+ } else {\r
+ monitorEl.style.display = "none";\r
+ }\r
+};\r
+/* private */\r
+var getFixedOffsetTop = function (){\r
+ if (bindingParent) {\r
+ var b = bindingParent;\r
+ return b.scrollTop;\r
+ }\r
+ var dua = navigator.userAgent;\r
+ var b = document.body;\r
+ var p = b.parentNode;\r
+ var pcHeight = p.clientHeight;\r
+ var bcScrollTop = b.scrollTop + b.offsetTop;\r
+ var pcScrollTop = p.scrollTop + p.offsetTop;\r
+ return (dua.indexOf("Opera") < 0 && document.all ? (pcHeight == 0 ? bcScrollTop : pcScrollTop)\r
+ : dua.indexOf("Gecko") < 0 ? (pcHeight == p.offsetHeight \r
+ && pcHeight == p.scrollHeight ? bcScrollTop : pcScrollTop) : bcScrollTop);\r
+};\r
+\r
+/* not used in Jmol\r
+if (window["ClazzLoader"]) {\r
+ _Loader.onScriptLoading = function(file) {\r
+ CLPM.showStatus("Loading " + file + "...");\r
+ };\r
+ _Loader.onScriptLoaded = function(file, isError) {\r
+ CLPM.showStatus(file + (isError ? " loading failed." : " loaded."), true);\r
+ };\r
+ _Loader.onGlobalLoaded = function(file) {\r
+ CLPM.showStatus("Application loaded.", true);\r
+ };\r
+ _Loader.onClassUnloaded = function(clazz) {\r
+ CLPM.showStatus("Class " + clazz + " is unloaded.", true);\r
+ };\r
+}\r
+*/\r
+\r
+})(Clazz._LoaderProgressMonitor, Jmol);\r
+\r
+//}\r
+/******************************************************************************\r
+ * Copyright (c) 2007 java2script.org and others.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * Zhou Renjian - initial API and implementation\r
+ *****************************************************************************/\r
+/*******\r
+ * @author zhou renjian\r
+ * @create Nov 5, 2005\r
+ *******/\r
+\r
+;(function(Con, Sys) {\r
+/**\r
+ * Setting maxTotalLines to -1 will not limit the console result\r
+ */\r
+/* protected */\r
+Con.maxTotalLines = 10000;\r
+\r
+/* protected */\r
+Con.setMaxTotalLines = function (lines) {\r
+ Con.maxTotalLines = (lines > 0 ? lines : 999999);\r
+}\r
+\r
+/* protected */\r
+Con.maxLatency = 40;\r
+\r
+/* protected */\r
+Con.setMaxLatency = function (latency) {\r
+ Con.maxLatency = (latency > 0 ? latency : 40);\r
+};\r
+\r
+/* protected */\r
+Con.pinning = false;\r
+\r
+/* protected */\r
+Con.enablePinning = function (enabled) {\r
+ Con.pinning = enabled;\r
+};\r
+\r
+/* private */\r
+Con.linesCount = 0;\r
+\r
+/* private */\r
+Con.metLineBreak = false;\r
+\r
+\r
+/*\r
+ * Give an extension point so external script can create and bind the console\r
+ * themself.\r
+ *\r
+ * TODO: provide more template of binding console window to browser.\r
+ */\r
+/* protected */\r
+Con.createConsoleWindow = function (parentEl) {\r
+ var console = document.createElement ("DIV");\r
+ console.style.cssText = "font-family:monospace, Arial, sans-serif;";\r
+ document.body.appendChild (console);\r
+ return console;\r
+};\r
+\r
+var c160 = String.fromCharCode(160); //nbsp;\r
+c160 += c160+c160+c160;\r
+\r
+/* protected */\r
+Con.consoleOutput = function (s, color) {\r
+ var o = window["j2s.lib"];\r
+ var console = (o && o.console);\r
+ if (console && typeof console == "string")\r
+ console = document.getElementById(console)\r
+ if (!console)\r
+ return false; // BH this just means we have turned off all console action\r
+ if (Con.linesCount > Con.maxTotalLines) {\r
+ for (var i = 0; i < Con.linesCount - Con.maxTotalLines; i++) {\r
+ if (console && console.childNodes.length > 0) {\r
+ console.removeChild (console.childNodes[0]);\r
+ }\r
+ }\r
+ Con.linesCount = Con.maxTotalLines;\r
+ }\r
+\r
+ var willMeetLineBreak = false;\r
+ s = (typeof s == "undefined" ? "" : s == null ? "null" : "" + s);\r
+ s = s.replace (/\t/g, c160);\r
+ if (s.length > 0)\r
+ switch (s.charAt(s.length - 1)) {\r
+ case '\n':\r
+ case '\r':\r
+ s = (s.length > 1 ? s.substring (0, s.length - (s.charAt (s.length - 2) == '\r' ? 2 : 1)) : "");\r
+ willMeetLineBreak = true;\r
+ break;\r
+ }\r
+\r
+ var lines = null;\r
+ s = s.replace (/\t/g, c160);\r
+ lines = s.split(/\r\n|\r|\n/g);\r
+ for (var i = 0, last = lines.length - 1; i <= last; i++) {\r
+ var lastLineEl = null;\r
+ if (Con.metLineBreak || Con.linesCount == 0 \r
+ || console.childNodes.length < 1) {\r
+ lastLineEl = document.createElement ("DIV");\r
+ console.appendChild (lastLineEl);\r
+ lastLineEl.style.whiteSpace = "nowrap";\r
+ Con.linesCount++;\r
+ } else {\r
+ try {\r
+ lastLineEl = console.childNodes[console.childNodes.length - 1];\r
+ } catch (e) {\r
+ lastLineEl = document.createElement ("DIV");\r
+ console.appendChild (lastLineEl);\r
+ lastLineEl.style.whiteSpace = "nowrap";\r
+ Con.linesCount++;\r
+ }\r
+ }\r
+ var el = document.createElement ("SPAN");\r
+ lastLineEl.appendChild (el);\r
+ el.style.whiteSpace = "nowrap";\r
+ if (color)\r
+ el.style.color = color;\r
+ var l = lines[i]\r
+ if (l.length == 0)\r
+ l = c160;\r
+ el.appendChild(document.createTextNode(l));\r
+ if (!Con.pinning)\r
+ console.scrollTop += 100;\r
+ Con.metLineBreak = (i != last || willMeetLineBreak);\r
+ }\r
+\r
+ var cssClazzName = console.parentNode.className;\r
+ if (!Con.pinning && cssClazzName\r
+ && cssClazzName.indexOf ("composite") != -1) {\r
+ console.parentNode.scrollTop = console.parentNode.scrollHeight;\r
+ }\r
+ Con.lastOutputTime = new Date ().getTime ();\r
+};\r
+\r
+/*\r
+ * Clear all contents inside the console.\r
+ */\r
+/* public */\r
+Con.clear = function () {\r
+ try {\r
+ Con.metLineBreak = true;\r
+ var o = window["j2s.lib"];\r
+ var console = o && o.console;\r
+ if (!console || !(console = document.getElementById (console)))\r
+ return;\r
+ var childNodes = console.childNodes;\r
+ for (var i = childNodes.length; --i >= 0;)\r
+ console.removeChild (childNodes[i]);\r
+ Con.linesCount = 0;\r
+ } catch(e){};\r
+};\r
+\r
+/* public */\r
+Clazz.alert = function (s) {\r
+ Con.consoleOutput (s + "\r\n");\r
+};\r
+\r
+\r
+/* public */\r
+Sys.out.print = function (s) { \r
+ Con.consoleOutput (s);\r
+};\r
+/* public */\r
+Sys.out.println = function(s) { \r
+ Con.consoleOutput(typeof s == "undefined" ? "\r\n" : s == null ? s = "null\r\n" : s + "\r\n");\r
+};\r
+\r
+Sys.out.write = function (buf, offset, len) {\r
+ Sys.out.print(String.instantialize(buf).substring(offset, offset+len));\r
+};\r
+\r
+/* public */\r
+Sys.err.__CLASS_NAME__ = "java.io.PrintStream";\r
+\r
+/* public */\r
+Sys.err.print = function (s) { \r
+ Con.consoleOutput (s, "red");\r
+};\r
+\r
+/* public */\r
+Sys.err.println = function (s) {\r
+ Con.consoleOutput (typeof s == "undefined" ? "\r\n" : s == null ? s = "null\r\n" : s + "\r\n", "red");\r
+};\r
+\r
+Sys.err.write = function (buf, offset, len) {\r
+ Sys.err.print(String.instantialize(buf).substring(offset, offset+len));\r
+};\r
+\r
+})(Clazz.Console, System);\r
+\r
+})(Clazz, Jmol); // requires JSmolCore.js\r
+\r
+}; // called by external application \r
git://source.jalview.org / jalviewjs.git / blobdiff