Source: core/kekule.root.js

  1. /**
  2.  * Defines root namespace of Kekule.js.
  3.  */
  5. /**
  6.  * @namespace
  7.  * @description Root namespace of Kekule library.
  8.  */
  9. var Kekule = {
  10. 	LIBNAME: 'Kekule.js',
  11. 	LIBNAME_CORE: 'Kekule',
  12. 	VERSION: '0.8.1.18112300',
  13. 	/**
  14. 	 * A flag that indicate whether all essential Kekule modules are loaded into document.
  15. 	 * @ignore
  16. 	 */
  17. 	LOADED: false,
  18. 	/**
  19. 	 * An array of functions that need be called after load all Kekule modules.
  20. 	 * @private
  21. 	 */
  22. 	_afterLoadSysProcedures: [],
  23. 	/**
  24. 	 * An array of user functions that need be called after load all Kekule modules.
  25. 	 * @private
  26. 	 */
  27. 	_afterLoadUserProcedures: [],
  28. 	// Whether auto find title and description text for object property
  29. 	/** @ignore */
  30. 	PROP_AUTO_TITLE: true
  31. };
  33. /**
  34.  * Called when all essential modules is loaded.
  35.  * User should not call this function directly.
  36.  * @private
  37.  */
  38. Kekule._loaded = function()
  39. {
  40. 	if (Kekule.LOADED)
  41. 		return;
  42. 	Kekule.LOADED = true;
  43. 	var procs = Kekule._afterLoadSysProcedures;
  44. 	while (procs.length)
  45. 	{
  46. 		var proc = procs.shift();
  47. 		if (proc)
  48. 			proc();
  49. 	}
  51. 	var procs = Kekule._afterLoadUserProcedures;
  52. 	while (procs.length)
  53. 	{
  54. 		var proc = procs.shift();
  55. 		if (proc)
  56. 			proc();
  57. 	}
  59. 	// at last try fire a custom event
  60. 	var doc = Kekule.$jsRoot && Kekule.$jsRoot.document;
  61. 	if (doc && doc.createEvent && doc.body && doc.body.dispatchEvent)
  62. 	{
  63. 		var event = doc.createEvent('Event');
  64. 		event.initEvent('kekuleload', true, true);
  65. 		doc.body.dispatchEvent(event);
  66. 	}
  67. };
  68. /**
  69.  * Return whether the whole lib is loaded.
  70.  * @returns {boolean}
  71.  * @private
  72.  */
  73. Kekule._isLoaded = function()
  74. {
  75. 	return Kekule.LOADED;
  76. };
  77. /**
  78.  * Register system procedure that need to be called after all modules are loaded.
  79.  * User should not call this method directly.
  80.  * @param {Func} proc
  81.  * @private
  82.  */
  83. Kekule._registerAfterLoadSysProc = function(proc)
  84. {
  85. 	if (proc)
  86. 	{
  87. 		if (Kekule.LOADED)
  88. 			proc();
  89. 		else
  90. 			Kekule._afterLoadSysProcedures.push(proc);
  91. 	}
  92. };
  93. /**
  94.  * Register procedure that need to be called after all modules are loaded and all initial operations has been done.
  95.  * @param {Func} proc
  96.  * @private
  97.  */
  98. Kekule._ready = function(proc)
  99. {
  100. 	if (proc)
  101. 	{
  102. 		if (Kekule.LOADED)
  103. 			proc();
  104. 		else
  105. 			Kekule._afterLoadUserProcedures.push(proc);
  106. 	}
  107. };
  108. Kekule._registerAfterLoadProc = Kekule._ready;  // for backward
  110. /**
  111.  * Root object of JavaScript environment, usually window.
  112.  */
  113. Kekule.$jsRoot = this;
  114. /**
  115.  * Root document of JavaScript environment.
  116.  * Can be null in Node.js.
  117.  */
  118. Kekule.$document = this.document || null;
  120. Kekule.scriptSrcInfo = Kekule.$jsRoot['__$kekule_load_info__'];
  121. if (Kekule.scriptSrcInfo && Kekule.scriptSrcInfo.language)  // force Language
  122. {
  123. 	Kekule.language = Kekule.scriptSrcInfo.language;
  124. }
  125. if (!Kekule.scriptSrcInfo && Kekule.$jsRoot.document)  // script info not found, may be use Kekule.min.js directly
  126. {
  127. 	Kekule.scriptSrcInfo = (function ()
  128. 	{
  129. 		var entranceSrc = /^(.*\/?)kekule\..*\.js(\?.*)?$/;
  130. 		var scriptElems = document.getElementsByTagName('script');
  131. 		var loc;
  132. 		for (var i = scriptElems.length - 1; i >= 0; --i)
  133. 		{
  134. 			var elem = scriptElems[i];
  135. 			if (elem.src)
  136. 			{
  137. 				var matchResult = elem.src.match(entranceSrc);
  138. 				if (matchResult)
  139. 				{
  140. 					var pstr = matchResult[2];
  141. 					if (pstr)
  142. 						pstr = pstr.substr(1);  // eliminate starting '?'
  143. 					var result = {
  144. 						'src': elem.src,
  145. 						'path': matchResult[1],
  146. 						'paramStr': pstr,
  147. 						'useMinFile': true
  148. 					};
  149. 					return result;
  150. 				}
  151. 			}
  152. 		}
  153. 		return null;
  154. 	})();
  155. }
  157. Kekule.getScriptPath = function()
  158. {
  159. 	return Kekule.scriptSrcInfo.path;
  160. };
  161. Kekule.getScriptSrc = function()
  162. {
  163. 	return Kekule.scriptSrcInfo.src;
  164. };
  165. Kekule.getStyleSheetPath = function()
  166. {
  167. 	//var cssFileName = 'themes/default/kekule.css';
  168. 	var cssPath;
  169. 	var scriptInfo = Kekule.scriptSrcInfo;
  170. 	if (scriptInfo.useMinFile)
  171. 		cssPath = scriptInfo.path;
  172. 	else
  173. 		cssPath = scriptInfo.path + 'widgets/';
  174. 	return cssPath;
  175. };
  176. Kekule.getStyleSheetUrl = function()
  177. {
  178. 	var path = Kekule.getStyleSheetPath();
  179. 	return path + 'themes/default/kekule.css';
  180. };
  182. if (Kekule.$jsRoot && Kekule.$jsRoot.addEventListener && Kekule.$jsRoot.postMessage)
  183. {
  184. 	// response to special message, returns Kekule sys info.
  185. 	// This query is usually requested by browser addon to check
  186. 	// if Kekule lib is loaded into a web page
  187. 	Kekule.$jsRoot.addEventListener('message', function(event)
  188. 	{
  189. 		if (event.data === 'kekule-sys-info-query')
  190. 		{
  191. 			Kekule.$jsRoot.postMessage({
  192. 				'msg': 'kekule-sys-info-result',
  193. 				'libName': Kekule.LIBNAME,
  194. 				'version': Kekule.VERSION
  195. 				//'scriptSrcInfo': Kekule.scriptSrcInfo
  196. 			}, '*');
  197. 		}
  198. 	}, false);
  199. }