Source: chemdoc/kekule.attachedMarkers.js

  1. /**
  2.  * @fileoverview
  3.  * Implementation of property markers (e.g. charge mark, lone pair, etc.) binding to the chem object.
  4.  * @author Partridge Jiang
  5.  */
  7. /*
  8.  * requires /lan/classes.js
  9.  * requires /core/kekule.common.js
  10.  * requires /core/kekule.structures.js
  11.  * requires /core/kekule.chemUtils.js
  12.  */
  14. (function(){
  15. "use strict";
  17. var AU = Kekule.ArrayUtils;
  19. /**
  20.  * A recommended namespace for all attach marker classes
  21.  * @namespace
  22.  */
  23. Kekule.ChemMarker = {};
  25. // extend chemObject, enable associate descriptive glyphs to it
  26. /** @ignore */
  27. ClassEx.extend(Kekule.ChemObject,
  28. /** @lends Kekule.ChemObject# */
  29. {
  30. 	/**
  31. 	 * Returns whether current object is an attachedMarker of parent object.
  32. 	 * @returns {Bool}
  33. 	 */
  34. 	isAttachedMarker: function()
  35. 	{
  36. 		var p = this.getParent();
  37. 		return (p && p.hasMarker(this));
  38. 	},
  39. 	/**
  40. 	 * Notify {@link Kekule.ChemObject#attachedMarkers} property has been changed
  41. 	 * @private
  42. 	 */
  43. 	notifyAttachedMarkersChanged: function()
  44. 	{
  45. 		this.notifyPropSet('attachedMarkers', this.getPropStoreFieldValue('attachedMarkers'));
  46. 	},
  47. 	/** @private */
  48. 	_attachedMarkerAdded: function(marker)
  49. 	{
  50. 		// do nothing here
  51. 	},
  52. 	/** @private */
  53. 	_attachedMarkerRemoved: function(marker)
  54. 	{
  55. 		// do nothing here
  56. 	},
  58. 	/**
  59. 	 * Return count of attached markers.
  60. 	 * @returns {Int}
  61. 	 */
  62. 	getMarkerCount: function()
  63. 	{
  64. 		var markers = this.getPropStoreFieldValue('attachedMarkers');
  65. 		return markers? markers.length: 0;
  66. 	},
  67. 	/**
  68. 	 * Get attached marker at index.
  69. 	 * @param {Int} index
  70. 	 * @returns {Kekule.ChemObject}
  71. 	 */
  72. 	getMarkerAt: function(index)
  73. 	{
  74. 		var markers = this.getPropStoreFieldValue('attachedMarkers');
  75. 		return markers? markers[index]: null;
  76. 	},
  77. 	/**
  78. 	 * Returns the first child marker of a specified class type.
  79. 	 * @param {Class} classType
  80. 	 * @param {Bool} exactMatch If true, only marker of classType (not its descendants) should be returned.
  81. 	 * @returns {Kekule.ChemObject}
  82. 	 */
  83. 	getMarkerOfType: function(classType, exactMatch)
  84. 	{
  85. 		for (var i = 0, l = this.getMarkerCount(); i < l; ++i)
  86. 		{
  87. 			var marker = this.getMarkerAt(i);
  88. 			if ((exactMatch && marker.getClass() === classType) || (marker instanceof classType))
  89. 				return marker;
  90. 		}
  91. 		return null;
  92. 	},
  93. 	/**
  94. 	 * Returns all child markers of a specified class type.
  95. 	 * @param {Class} classType
  96. 	 * @param {Bool} exactMatch If true, only markers of classType (not its descendants) should be returned.
  97. 	 * @returns {Array}
  98. 	 */
  99. 	getMarkersOfType: function(classType, exactMatch)
  100. 	{
  101. 		var result = [];
  102. 		for (var i = 0, l = this.getMarkerCount(); i < l; ++i)
  103. 		{
  104. 			var marker = this.getMarkerAt(i);
  105. 			if ((exactMatch && marker.getClass() === classType) || (marker instanceof classType))
  106. 				result.push(marker);
  107. 		}
  108. 		return result;
  109. 	},
  110. 	/**
  111. 	 * Get attached marker of classType. If no such a marker currently and canCreate is true, a new marker will be created.
  112. 	 * @param {Class} classType
  113. 	 * @param {Bool} canCreate
  114. 	 * @param {Bool} exactMatch If true, only marker of classType (not its descendants) should be returned.
  115. 	 * @param {Hash} defProps If create a new marker, those prop values will be applied.
  116. 	 * @returns {Kekule.ChemObject}
  117. 	 */
  118. 	fetchMarkerOfType: function(classType, canCreate, exactMatch, defProps)
  119. 	{
  120. 		var result = this.getMarkerOfType(classType, exactMatch);
  121. 		if (!result && canCreate)
  122. 		{
  123. 			result = new classType();
  124. 			result.beginUpdate();
  125. 			try
  126. 			{
  127. 				if (defProps)
  128. 				{
  129. 					result.setPropValues(defProps);
  130. 				}
  131. 				//console.log('fetch create on', this.getId());
  132. 				this.appendMarker(result);
  133. 			}
  134. 			finally
  135. 			{
  136. 				result.endUpdate();
  137. 			}
  138. 		}
  139. 		return result;
  140. 	},
  141. 	/**
  142. 	 * Returns markers that has no coord on coordMode
  143. 	 * @param {Int} coordMode
  144. 	 * @return {Array}
  145. 	 */
  146. 	getUnplacedMarkers: function(coordMode)
  147. 	{
  148. 		var result = [];
  149. 		for (var i = 0, l = this.getMarkerCount(); i < l; ++i)
  150. 		{
  151. 			var marker = this.getMarkerAt(i);
  152. 			if (!marker.getCoordOfMode(coordMode))
  153. 				result.push(marker);
  154. 		}
  155. 		return result;
  156. 	},
  157. 	/**
  158. 	 * Get index of attached marker in marker array.
  159. 	 * @param {Kekule.ChemObject} marker
  160. 	 * @returns {Int}
  161. 	 */
  162. 	indexOfMarker: function(marker)
  163. 	{
  164. 		var markers = this.getPropStoreFieldValue('attachedMarkers');
  165. 		return markers? markers.indexOf(marker): -1;
  166. 	},
  167. 	/**
  168. 	 * Check if a marker has been attached to this object.
  169. 	 * @param {Kekule.ChemObject} marker
  170. 	 * @returns {Bool}
  171. 	 */
  172. 	hasMarker: function(marker)
  173. 	{
  174. 		return this.indexOfMarker(marker) >= 0;
  175. 	},
  176. 	/**
  177. 	 * Returns whether there exists child markers of a specified class type.
  178. 	 * @param {Class} classType
  179. 	 * @param {Bool} exactMatch If true, only markers of classType (not its descendants) should be considered.
  180. 	 * @returns {Bool}
  181. 	 */
  182. 	hasMarkerOfType: function(classType, exactMatch)
  183. 	{
  184. 		return !!this.getMarkerOfType(classType, exactMatch);
  185. 	},
  186. 	/**
  187. 	 * Attach a marker to this object. If marker already exists, nothing will be done.
  188. 	 * @param {Kekule.ChemObject} marker
  189. 	 */
  190. 	appendMarker: function(marker)
  191. 	{
  192. 		var index = this.indexOfMarker(marker);
  193. 		if (index >= 0) // already exists
  194. 			return index;// do nothing
  195. 		else
  196. 		{
  197. 			var result = this.getAttachedMarkers(true).push(marker);
  198. 			marker.beginUpdate();
  199. 			try
  200. 			{
  201. 				if (marker.setOwner)
  202. 					marker.setOwner(this.getOwner());
  203. 				if (marker.setParent)
  204. 					marker.setParent(this);
  205. 				this._attachedMarkerAdded(marker);
  206. 			}
  207. 			finally
  208. 			{
  209. 				marker.endUpdate();
  210. 			}
  211. 			this.notifyAttachedMarkersChanged();
  212. 			return result;
  213. 		}
  214. 	},
  215. 	/**
  216. 	 * Insert marker before refMarker in marker list. If refMarker is null or does not exists, marker will be append to tail of list.
  217. 	 * @param {Kekule.ChemObject} marker
  218. 	 * @param {Kekule.ChemObject} refMarker
  219. 	 * @return {Int} Index of obj after inserting.
  220. 	 */
  221. 	insertMarkerBefore: function(marker, refMarker)
  222. 	{
  223. 		var refIndex = this.indexOfMarker(refMarker);
  224. 		return this.insertMarkerAt(marker, refIndex);
  225. 	},
  226. 	/**
  227. 	 * Insert marker to index. If index is not set, marker will be inserted to the tail of the marker array.
  228. 	 * @param {Kekule.ChemObject} marker
  229. 	 * @param {Int} index
  230. 	 */
  231. 	insertMarkerAt: function(marker, index)
  232. 	{
  233. 		var i = this.indexOfMarker(marker);
  234. 		var markers = this.getAttachedMarkers(true);
  235. 		if (Kekule.ObjUtils.isUnset(index) || (index < 0))
  236. 			index = markers.length;
  237. 		if (i >= 0)  // already inside, adjust position
  238. 		{
  239. 			markers.splice(i, 1);
  240. 			markers.splice(index, 0, marker);
  241. 		}
  242. 		else // new one
  243. 		{
  244. 			markers.splice(index, 0, marker);
  245. 			if (marker.setOwner)
  246. 				marker.setOwner(this.getOwner());
  247. 			if (marker.setParent)
  248. 				marker.setParent(this);
  249. 			this._attachedMarkerAdded(marker);
  250. 		}
  251. 		this.notifyAttachedMarkersChanged();
  252. 		return index;
  253. 	},
  254. 	/**
  255. 	 * Change index of marker.
  256. 	 * @param {Kekule.ChemObject} marker
  257. 	 * @param {Int} index
  258. 	 */
  259. 	setMarkerIndex: function(marker, index)
  260. 	{
  261. 		var i = this.indexOfMarker(marker);
  262. 		if (i >= 0)  // already inside, adjust position
  263. 		{
  264. 			var markers = this.getPropStoreFieldValue('attachedMarkers'); // this.getAttachedMarkers();
  265. 			markers.splice(i, 1);
  266. 			markers.splice(index, 0, marker);
  267. 		}
  268. 	},
  269. 	/**
  270. 	 * Remove marker at index in attached marker list.
  271. 	 * @param {Int} index
  272. 	 */
  273. 	removeMarkerAt: function(index)
  274. 	{
  275. 		var marker = this.getMarkerAt(index);
  276. 		if (marker)
  277. 		{
  278. 			var result = this.getAttachedMarkers(true).splice(index, 1);
  279. 			if (marker.setOwner)
  280. 				marker.setOwner(null);
  281. 			if (marker.setParent)
  282. 				marker.setParent(null);
  283. 			this._attachedMarkerRemoved(marker);
  284. 			this.notifyAttachedMarkersChanged();
  285. 			return result;
  286. 		}
  287. 	},
  288. 	/**
  289. 	 * Remove an attached marker.
  290. 	 * @param {Kekule.ChemObject} marker
  291. 	 */
  292. 	removeMarker: function(marker)
  293. 	{
  294. 		var index = this.indexOfMarker(marker);
  295. 		if (index >= 0)
  296. 			return this.removeMarkerAt(index);
  297. 	},
  298. 	/**
  299. 	 * Replace oldMarker with new one.
  300. 	 * @param {Kekule.ChemObject} oldMarker
  301. 	 * @param {Kekule.ChemObject} newMarker
  302. 	 */
  303. 	replaceMarker: function(oldMarker, newMarker)
  304. 	{
  305. 		var oldIndex = this.indexOfMarker(oldMarker);
  306. 		if (oldIndex < 0)  // old marker not exists
  307. 		{
  308. 			return this;
  309. 		}
  310. 		else
  311. 		{
  312. 			this.removeMarkerAt(oldIndex);
  313. 			this.insertMarkerAt(newMarker, oldIndex);
  314. 			return this;
  315. 		}
  316. 	},
  317. 	/**
  318. 	 * Remove all attached markers.
  319. 	 */
  320. 	clearMarkers: function()
  321. 	{
  322. 		//var oldMarkers = AU.clone(this.getAttachedMarkers());
  323. 		var oldMarkers = this.getPropStoreFieldValue('attachedMarkers');
  324. 		if (oldMarkers)
  325. 			oldMarkers = AU.clone(oldMarkers);
  327. 		this.setPropStoreFieldValue('attachedMarkers', null);
  329. 		if (oldMarkers)
  330. 		{
  331. 			for (var i = 0, l = oldMarkers.length; i < l; ++i)
  332. 			{
  333. 				var marker = oldMarkers[i];
  334. 				if (marker.setOwner)
  335. 					marker.setOwner(null);
  336. 				if (marker.setParent)
  337. 					marker.setParent(null);
  338. 				this._attachedMarkerRemoved(marker);
  339. 			}
  340. 		}
  342. 		this.notifyAttachedMarkersChanged();
  343. 		return this;
  344. 	},
  346. 	autoSetMarker2DPos: function(marker, offset, allowCoordBorrow, avoidDirectionAngles)
  347. 	{
  348. 		if (this.hasMarker(marker))
  349. 		{
  350. 			var angle = Kekule.ChemStructureUtils.getMostEmptyDirection2DAngleOfObj(this, [marker], allowCoordBorrow, true, false, avoidDirectionAngles);
  351. 			var coord = {'x': offset * Math.cos(angle), 'y': offset * Math.sin(angle)};
  352. 			//console.log('angle2', coord);
  353. 			marker.setCoord2D(coord);
  354. 		}
  355. 	},
  357. 	/** @private */
  358. 	_updateAttachedMarkersOwner: function(owner)
  359. 	{
  360. 		if (!owner)
  361. 			owner = this.getOwner();
  362. 		for (var i = 0, l = this.getMarkerCount(); i < l; ++i)
  363. 		{
  364. 			var marker = this.getMarkerAt(i);
  365. 			if (marker.setOwner)
  366. 				marker.setOwner(owner);
  367. 		}
  368. 	},
  369. 	/** @private */
  370. 	_updateAttachedMarkersParent: function(parent)
  371. 	{
  372. 		if (!parent)
  373. 			parent = this;
  374. 		/*
  375. 		if (this.getMarkerCount() > 0)
  376. 			console.log('set parent', parent.getClassName());
  377.     */
  378. 		for (var i = 0, l = this.getMarkerCount(); i < l; ++i)
  379. 		{
  380. 			var marker = this.getMarkerAt(i);
  381. 			if (marker.setParent)
  382. 				marker.setParent(parent);
  383. 		}
  384. 	}
  385. });
  386. ClassEx.extendMethod(Kekule.ChemObject, 'ownerChanged', function($origin, newOwner){
  387. 	$origin(newOwner);
  388. 	this._updateAttachedMarkersOwner(newOwner);
  389. });
  390. ClassEx.extendMethod(Kekule.ChemObject, 'removeChild', function($origin, child){
  391. 	//console.log('remove child', child.getClassName(), child.getId());
  392. 	var result = $origin(child);
  393. 	if (!result)
  394. 		result = this.removeMarker(child) || $origin(child);
  395. 	return result;
  396. });
  397. ClassEx.extendMethod(Kekule.ChemObject, 'insertBefore', function($origin, child, refChild){
  398. 	var result = $origin(child, refChild);
  399. 	if (result < 0)
  400. 	{
  401. 		if (refChild && this.hasMarker(refChild) || child instanceof Kekule.ChemMarker.BaseMarker)
  402. 			result = this.insertMarkerBefore(child, refChild);
  403. 	}
  404. 	return result;
  405. });
  407. ClassEx.defineProp(Kekule.ChemObject, 'attachedMarkers',
  408. {
  409. 	'dataType': DataType.ARRAY, 'scope':  Class.PropertyScope.PUBLISHED,
  410. 	'getter': function(autoCreate)
  411. 	{
  412. 		var result = this.getPropStoreFieldValue('attachedMarkers');
  413. 		if (!result && autoCreate)
  414. 		{
  415. 			result = [];
  416. 			this.setPropStoreFieldValue('attachedMarkers', result);
  417. 		}
  418. 		return result;
  419. 	},
  420. 	'setter': function(value)
  421. 	{
  422. 		//console.log('set markers', value, this.getClassName());
  423. 		this.clearMarkers();
  424. 		this.setPropStoreFieldValue('attachedMarkers', value);
  425. 		this._updateAttachedMarkersOwner();
  426. 		this._updateAttachedMarkersParent();
  427. 		//console.log('after set', this.getAttachedMarkers());
  428. 	}
  429. });
  430. /*
  431. // if true, position of newly added marker will be set automatically
  432. ClassEx.defineProp(Kekule.ChemObject, 'autoSetAttachedMarkerPos',
  433. {
  434. 	'dataType': DataType.BOOL, 'scope':  Class.PropertyScope.PUBLISHED
  435. });
  436. */
  439. })();