Source: widgets/chem/editor/kekule.chemEditor.operations.js

  1. /**
  2.  * @fileoverview
  3.  * Operations need to implement an editor.
  4.  * @author Partridge Jiang
  5.  */
  7. /*
  8.  * requires /lan/classes.js
  9.  * requires /utils/kekule.utils.js
  10.  * requires /widgets/operation/kekule.operations.js
  11.  * requires /core/kekule.structures.js
  12.  * requires /widgets/chem/editor/kekule.chemEditor.baseEditors.js
  13.  * requires /localization/
  14.  */
  16. (function(){
  17. "use strict";
  19. /**
  20.  * A namespace for operation about normal ChemObject instance.
  21.  * @namespace
  22.  */
  23. Kekule.ChemObjOperation = {};
  25. /**
  26.  * Base operation for ChemObject instance.
  27.  * @class
  28.  * @augments Kekule.Operation
  29.  *
  30.  * @param {Kekule.ChemObject} chemObject Target chem object.
  31.  *
  32.  * @property {Kekule.ChemObject} target Target chem object.
  33.  * @property {Bool} allowCoordBorrow Whether allow borrowing between 2D and 3D when manipulating coords.
  34.  * @property {Kekule.Editor.BaseEditor} The editor object associated.
  35.  */
  36. Kekule.ChemObjOperation.Base = Class.create(Kekule.Operation,
  37. /** @lends Kekule.ChemObjOperation.Base# */
  38. {
  39. 	/** @private */
  40. 	CLASS_NAME: 'Kekule.ChemObjOperation.Base',
  41. 	/** @constructs */
  42. 	initialize: function($super, chemObj, editor)
  43. 	{
  44. 		$super();
  45. 		this.setTarget(chemObj);
  46. 		if (editor)
  47. 			this.setEditor(editor);
  48. 	},
  49. 	/** @private */
  50. 	initProperties: function()
  51. 	{
  52. 		this.defineProp('target', {'dataType': 'Kekule.ChemObject', 'serializable': false});
  53. 		this.defineProp('allowCoordBorrow', {'dataType': DataType.BOOL});
  54. 		this.defineProp('editor', {'dataType': 'Kekule.Editor.BaseEditor', 'serializable': false});
  55. 	},
  56. 	// A series of notification method to target object
  57. 	/** @private */
  58. 	notifyBeforeAddingByEditor: function(obj, parent, refSibling)
  59. 	{
  60. 		if (obj.beforeAddingByEditor)  // if this special notification method exists, call it first
  61. 			obj.beforeAddingByEditor(parent, refSibling);
  62. 	},
  63. 	/** @private */
  64. 	notifyBeforeRemovingByEditor: function(obj, parent)
  65. 	{
  66. 		if (obj.beforeRemovingByEditor)  // if this special notification method exists, call it first
  67. 			obj.beforeRemovingByEditor(parent);
  68. 	},
  69. 	/** @private */
  70. 	notifyBeforeModifyingByEditor: function(obj, propValues)
  71. 	{
  72. 		if (obj.beforeModifyingByEditor)  // if this special notification method exists, call it first
  73. 			obj.beforeModifyingByEditor(propValues);
  74. 	},
  75. 	/** @private */
  76. 	notifyAfterAddingByEditor: function(obj, parent, refSibling)
  77. 	{
  78. 		if (obj.afterAddingByEditor)  // if this special notification method exists, call it first
  79. 			obj.afterAddingByEditor(parent, refSibling);
  80. 	},
  81. 	/** @private */
  82. 	notifyAfterRemovingByEditor: function(obj, parent)
  83. 	{
  84. 		if (obj.afterRemovingByEditor)  // if this special notification method exists, call it first
  85. 			obj.afterRemovingByEditor(parent);
  86. 	},
  87. 	/** @private */
  88. 	notifyAfterModifyingByEditor: function(obj, propValues)
  89. 	{
  90. 		if (obj.afterModifyingByEditor)  // if this special notification method exists, call it first
  91. 			obj.afterModifyingByEditor(propValues);
  92. 	}
  93. });
  95. /**
  96.  * Operation of changing a chemObject's properties.
  97.  * @class
  98.  * @augments Kekule.ChemObjOperation.Base
  99.  *
  100.  * @param {Kekule.ChemObject} chemObject Target chem object.
  101.  * @param {Hash} newPropValues A hash of new prop-value map.
  102.  *
  103.  * @property {Hash} newPropValues A hash of new prop-value map.
  104.  */
  105. Kekule.ChemObjOperation.Modify = Class.create(Kekule.ChemObjOperation.Base,
  106. /** @lends Kekule.ChemObjOperation.Modify# */
  107. {
  108. 	/** @private */
  109. 	CLASS_NAME: 'Kekule.ChemObjOperation.Modify',
  110. 	/** @constructs */
  111. 	initialize: function($super, chemObj, newPropValues, editor)
  112. 	{
  113. 		$super(chemObj, editor);
  114. 		if (newPropValues)
  115. 			this.setNewPropValues(newPropValues);
  116. 	},
  117. 	/** @private */
  118. 	initProperties: function()
  119. 	{
  120. 		this.defineProp('newPropValues', {'dataType': DataType.HASH});
  121. 		this.defineProp('oldPropValues', {'dataType': DataType.HASH});  // private
  122. 	},
  123. 	/** @private */
  124. 	doExecute: function()
  125. 	{
  126. 		var oldValues = {};
  127. 		var map = this.getNewPropValues();
  128. 		var obj = this.getTarget();
  129. 		obj.beginUpdate();
  130. 		try
  131. 		{
  132. 			this.notifyBeforeModifyingByEditor(obj, map);
  133. 			for (var prop in map)
  134. 			{
  135. 				var value = map[prop];
  136. 				// store old value first
  137. 				oldValues[prop] = obj.getPropValue(prop);
  138. 				// set new value
  139. 				obj.setPropValue(prop, value);
  140. 			}
  141. 			this.notifyAfterModifyingByEditor(obj, map);
  142. 		}
  143. 		finally
  144. 		{
  145. 			obj.endUpdate();
  146. 		}
  147. 		this.setOldPropValues(oldValues);
  148. 	},
  149. 	/** @private */
  150. 	doReverse: function()
  151. 	{
  152. 		var map = this.getOldPropValues();
  153. 		var obj = this.getTarget();
  154. 		obj.beginUpdate();
  155. 		try
  156. 		{
  157. 			this.notifyBeforeModifyingByEditor(obj, map);
  158. 			for (var prop in map)
  159. 			{
  160. 				var value = map[prop];
  161. 				// restore old value
  162. 				obj.setPropValue(prop, value);
  163. 			}
  164. 			this.notifyAfterModifyingByEditor(obj, map);
  165. 		}
  166. 		finally
  167. 		{
  168. 			obj.endUpdate();
  169. 		}
  170. 	}
  171. });
  173. /**
  174.  * Operation of changing a chemObject's coord.
  175.  * @class
  176.  * @augments Kekule.ChemObjOperation.Base
  177.  *
  178.  * @param {Kekule.ChemObject} chemObject Target chem object.
  179.  * @param {Hash} newCoord
  180.  * @param {Int} coordMode
  181.  * @param {Bool} useAbsBaseCoord
  182.  *
  183.  * @property {Hash} newCoord
  184.  * @property {Hash} oldCoord If old coord is not set, this property will be automatically calculated when execute the operation.
  185.  * @property {Int} coordMode
  186.  * @property {Bool} useAbsBaseCoord
  187.  */
  188. Kekule.ChemObjOperation.MoveTo = Class.create(Kekule.ChemObjOperation.Base,
  189. /** @lends Kekule.ChemObjOperation.MoveTo# */
  190. {
  191. 	/** @private */
  192. 	CLASS_NAME: 'Kekule.ChemObjOperation.MoveTo',
  193. 	/** @constructs */
  194. 	initialize: function($super, chemObj, newCoord, coordMode, useAbsBaseCoord, editor)
  195. 	{
  196. 		$super(chemObj, editor);
  197. 		if (newCoord)
  198. 			this.setNewCoord(newCoord);
  199. 		this.setCoordMode(coordMode || Kekule.CoordMode.COORD2D);
  200. 		this.setUseAbsBaseCoord(!!useAbsBaseCoord);
  201. 	},
  202. 	/** @private */
  203. 	initProperties: function()
  204. 	{
  205. 		this.defineProp('newCoord', {'dataType': DataType.HASH});
  206. 		this.defineProp('oldCoord', {'dataType': DataType.HASH});
  207. 		this.defineProp('coordMode', {'dataType': DataType.INT});
  208. 		this.defineProp('useAbsBaseCoord', {'dataType': DataType.BOOL});
  209. 	},
  210. 	/** @private */
  211. 	setObjCoord: function(obj, coord, coordMode)
  212. 	{
  213. 		if (obj && coord && coordMode)
  214. 		{
  215. 			var success = false;
  216. 			if (this.getUseAbsBaseCoord())
  217. 			{
  218. 				/*
  219. 				if (obj.setAbsCoordOfMode)
  220. 				{
  221. 					obj.setAbsCoordOfMode(coord, coordMode);
  222. 					success = true;
  223. 				}
  224. 				*/
  225. 				if (obj.setAbsBaseCoord)
  226. 				{
  227. 					obj.setAbsBaseCoord(coord, coordMode, this.getAllowCoordBorrow());
  228. 					success = true;
  229. 				}
  230. 			}
  231. 			else
  232. 			{
  233. 				if (obj.setCoordOfMode)
  234. 				{
  235. 					obj.setCoordOfMode(coord, coordMode);
  236. 					success = true;
  237. 				}
  238. 			}
  239. 			if (!success)
  240. 			{
  241. 				var className = obj.getClassName? obj.getClassName(): (typeof obj);
  242. 				Kekule.warn(/*Kekule.ErrorMsg.CAN_NOT_SET_COORD_OF_CLASS*/Kekule.$L('ErrorMsg.CAN_NOT_SET_COORD_OF_CLASS').format(className));
  243. 			}
  244. 		}
  245. 	},
  246. 	/** @private */
  247. 	getObjCoord: function(obj, coordMode)
  248. 	{
  249. 		if (this.getUseAbsBaseCoord())
  250. 		{
  251. 			/*
  252. 			if (obj.getAbsCoordOfMode)
  253. 				return obj.getAbsCoordOfMode(coordMode, this.getAllowCoordBorrow());
  254. 			*/
  255. 			if (obj.getAbsBaseCoord)
  256. 				return obj.getAbsBaseCoord(coordMode, this.getAllowCoordBorrow());
  257. 		}
  258. 		else
  259. 		{
  260. 			if (obj.getCoordOfMode)
  261. 				return obj.getCoordOfMode(coordMode, this.getAllowCoordBorrow());
  262. 		}
  264. 		return null;
  265. 	},
  266. 	/** @private */
  267. 	doExecute: function()
  268. 	{
  269. 		var obj = this.getTarget();
  270. 		if (!this.getOldCoord())
  271. 			this.setOldCoord(this.getObjCoord(obj, this.getCoordMode()));
  272. 		if (this.getNewCoord())
  273. 			this.setObjCoord(this.getTarget(), this.getNewCoord(), this.getCoordMode());
  274. 	},
  275. 	/** @private */
  276. 	doReverse: function()
  277. 	{
  278. 		if (this.getOldCoord())
  279. 		{
  280. 			this.setObjCoord(this.getTarget(), this.getOldCoord(), this.getCoordMode());
  281. 		}
  282. 	}
  283. });
  285. /**
  286.  * Operation of changing a chem object's size and coord.
  287.  * @class
  288.  * @augments Kekule.ChemObjOperation.MoveTo
  289.  *
  290.  * @param {Kekule.ChemObject} chemObject Target chem object.
  291.  * @param {Hash} newDimension {width, height}
  292.  * @param {Hash} newCoord
  293.  * @param {Int} coordMode
  294.  * @param {Bool} useAbsCoord
  295.  *
  296.  * @property {Hash} newDimension
  297.  * @property {Hash} oldDimension If old dimension is not set, this property will be automatically calculated when execute the operation.
  298.  */
  299. Kekule.ChemObjOperation.MoveAndResize = Class.create(Kekule.ChemObjOperation.MoveTo,
  300. /** @lends Kekule.ChemObjOperation.MoveAndResize# */
  301. {
  302. 	/** @private */
  303. 	CLASS_NAME: 'Kekule.ChemObjOperation.MoveAndResize',
  304. 	/** @constructs */
  305. 	initialize: function($super, chemObj, newDimension, newCoord, coordMode, useAbsCoord, editor)
  306. 	{
  307. 		$super(chemObj, newCoord, coordMode, useAbsCoord, editor);
  308. 	},
  309. 	/** @private */
  310. 	initProperties: function()
  311. 	{
  312. 		this.defineProp('newDimension', {'dataType': DataType.HASH});
  313. 		this.defineProp('oldDimension', {'dataType': DataType.HASH});
  314. 	},
  315. 	/** @private */
  316. 	setObjSize: function(obj, dimension, coordMode)
  317. 	{
  318. 		if (obj && dimension)
  319. 		{
  320. 			if (obj.setSizeOfMode)
  321. 			{
  322. 				obj.setSizeOfMode(dimension, coordMode);
  323. 			}
  324. 			else
  325. 			{
  326. 				var className = obj.getClassName? obj.getClassName(): (typeof obj);
  327. 				Kekule.warn(/*Kekule.ErrorMsg.CAN_NOT_SET_DIMENSION_OF_CLASS*/Kekule.$L('ErrorMsg.CAN_NOT_SET_DIMENSION_OF_CLASS').format(className));
  328. 			}
  329. 		}
  330. 	},
  331. 	/** @private */
  332. 	getObjSize: function(obj, coordMode)
  333. 	{
  334. 		if (obj.getSizeOfMode)
  335. 			return obj.getSizeOfMode(coordMode, this.getAllowCoordBorrow());
  336. 		else
  337. 			return null;
  338. 	},
  339. 	/** @private */
  340. 	doExecute: function($super)
  341. 	{
  342. 		$super();
  343. 		var obj = this.getTarget();
  344. 		if (!this.getOldDimension())
  345. 		{
  346. 			this.setOldDimension(this.getObjSize(obj, this.getCoordMode()));
  347. 		}
  348. 		if (this.getNewDimension())
  349. 			this.setObjSize(this.getTarget(), this.getNewDimension(), this.getCoordMode());
  350. 	},
  351. 	/** @private */
  352. 	doReverse: function($super)
  353. 	{
  354. 		if (this.getOldDimension())
  355. 			this.setObjSize(this.getTarget(), this.getOldDimension(), this.getCoordMode());
  356. 		$super();
  357. 	}
  358. });
  360. /**
  361.  * Operation of adding a chem object to parent.
  362.  * @class
  363.  * @augments Kekule.ChemObjOperation.Base
  364.  *
  365.  * @param {Kekule.ChemObject} chemObject Target chem object.
  366.  * @param {Kekule.ChemObject} parentObj Object should be added to.
  367.  * @param {Kekule.ChemObject} refSibling If this property is set, chem object will be inserted before this sibling.
  368.  *
  369.  * @property {Kekule.ChemObject} parentObj Object should be added to.
  370.  * @property {Kekule.ChemObject} refSibling If this property is set, chem object will be inserted before this sibling.
  371.  */
  372. Kekule.ChemObjOperation.Add = Class.create(Kekule.ChemObjOperation.Base,
  373. /** @lends Kekule.ChemObjOperation.Add# */
  374. {
  375. 	/** @private */
  376. 	CLASS_NAME: 'Kekule.ChemObjOperation.Add',
  377. 	/** @constructs */
  378. 	initialize: function($super, chemObj, parentObj, refSibling, editor)
  379. 	{
  380. 		$super(chemObj, editor);
  381. 		this.setParentObj(parentObj);
  382. 		this.setRefSibling(refSibling);
  383. 	},
  384. 	/** @private */
  385. 	initProperties: function()
  386. 	{
  387. 		this.defineProp('parentObj', {'dataType': 'Kekule.ChemObject', 'serializable': false});
  388. 		this.defineProp('refSibling', {'dataType': 'Kekule.ChemObject', 'serializable': false});
  389. 	},
  390. 	/** @private */
  391. 	doExecute: function()
  392. 	{
  393. 		var parent = this.getParentObj();
  394. 		var obj = this.getTarget();
  395. 		if (parent && obj)
  396. 		{
  397. 			var sibling = this.getRefSibling() || null;
  398. 			this.notifyBeforeAddingByEditor(obj, parent, sibling);
  399. 			parent.insertBefore(obj, sibling);
  400. 			this.notifyAfterAddingByEditor(obj, parent, sibling);
  401. 		}
  402. 	},
  403. 	/** @private */
  404. 	doReverse: function()
  405. 	{
  406. 		var obj = this.getTarget();
  407. 		/*
  408. 		var parent = obj.getParent? obj.getParent(): null;
  409. 		if (!parent)
  410. 			parent = this.getParentObj();
  411. 		if (parent !== this.getParentObj())
  412. 			console.log('[abnormal!!!!!!!]', parent.getId(), this.getParentObj().getId());
  413. 		*/
  414. 		var parent = this.getParentObj();
  415. 		if (parent && obj)
  416. 		{
  417. 			var sibling = this.getRefSibling();
  418. 			if (!sibling)  // auto calc
  419. 			{
  420. 				sibling = obj.getNextSibling();
  421. 				this.setRefSibling(sibling);
  422. 			}
  423. 			this.notifyBeforeRemovingByEditor(obj, parent);
  424. 			parent.removeChild(obj);
  425. 			this.notifyAfterRemovingByEditor(obj, parent);
  426. 		}
  427. 	}
  428. });
  430. /**
  431.  * Operation of removing a chem object from its parent.
  432.  * @class
  433.  * @augments Kekule.ChemObjOperation.Base
  434.  *
  435.  * @param {Kekule.ChemObject} chemObject Target chem object.
  436.  * @param {Kekule.ChemObject} parentObj Object should be added to.
  437.  * @param {Kekule.ChemObject} refSibling Sibling after target object before removing.
  438.  *
  439.  * @property {Kekule.ChemObject} parentObj Object should be added to.
  440.  * @property {Kekule.ChemObject} refSibling Sibling after target object before removing.
  441.  *   This property is used in reversing the operation. If not set, it will be calculated automatically in execution.
  442.  */
  443. Kekule.ChemObjOperation.Remove = Class.create(Kekule.ChemObjOperation.Base,
  444. /** @lends Kekule.ChemObjOperation.Remove# */
  445. {
  446. 	/** @private */
  447. 	CLASS_NAME: 'Kekule.ChemObjOperation.Remove',
  448. 	/** @constructs */
  449. 	initialize: function($super, chemObj, parentObj, refSibling, editor)
  450. 	{
  451. 		$super(chemObj, editor);
  452. 		this.setParentObj(parentObj);
  453. 		this.setRefSibling(refSibling);
  454. 	},
  455. 	/** @private */
  456. 	initProperties: function()
  457. 	{
  458. 		this.defineProp('parentObj', {'dataType': 'Kekule.ChemObject', 'serializable': false});
  459. 		this.defineProp('ownerObj', {'dataType': 'Kekule.ChemObject', 'serializable': false});
  460. 		this.defineProp('refSibling', {'dataType': 'Kekule.ChemObject', 'serializable': false});
  461. 	},
  463. 	/** @private */
  464. 	_isInEditorSelection: function(obj)
  465. 	{
  466. 		var editor = this.getEditor();
  467. 		return ((editor && editor.getSelection && editor.getSelection()) || []).indexOf(obj) >= 0;
  468. 	},
  470. 	/** @private */
  471. 	doExecute: function()
  472. 	{
  473. 		var obj = this.getTarget();
  474. 		var parent = this.getParentObj();
  475. 		var owner = this.getOwnerObj();
  476. 		if (!parent && obj.getParent)
  477. 		{
  478. 			parent = obj.getParent();
  479. 			this.setParentObj(parent);
  480. 		}
  481. 		if (!owner && obj.getOwner)
  482. 		{
  483. 			owner = obj.getOwner();
  484. 			this.setOwnerObj(owner);
  485. 		}
  487. 		if (parent && obj)
  488. 		{
  489. 			if (!this.getRefSibling())
  490. 			{
  491. 				var sibling = obj.getNextSibling? obj.getNextSibling(): null;
  492. 				this.setRefSibling(sibling);
  493. 			}
  495. 			//console.log('remove', obj.getId());
  496. 			// ensure obj is also removed from editor's selection
  497. 			var editor = this.getEditor();
  498. 			var needModifySelection = this._isInEditorSelection(obj);
  499. 			if (needModifySelection)
  500. 				editor.beginUpdateSelection();
  502. 			//console.log('remove child', parent.getClassName(), obj.getClassName());
  503. 			this.notifyBeforeRemovingByEditor(obj, parent);
  504. 			parent.removeChild(obj);
  505. 			this.notifyAfterRemovingByEditor(obj, parent);
  507. 			if (needModifySelection)
  508. 			{
  509. 				//console.log('remove from selection', obj.getId());
  510. 				editor.removeFromSelection(obj);
  511. 				editor.endUpdateSelection();
  512. 			}
  513. 		}
  514. 	},
  515. 	/** @private */
  516. 	doReverse: function()
  517. 	{
  518. 		var parent = this.getParentObj();
  519. 		var owner = this.getOwnerObj();
  520. 		var obj = this.getTarget();
  521. 		if (parent && obj)
  522. 		{
  523. 			var sibling = this.getRefSibling();
  524. 			if (owner)
  525. 				obj.setOwner(owner);
  526. 			this.notifyBeforeAddingByEditor(obj, parent, sibling);
  527. 			parent.insertBefore(obj, sibling);
  528. 			this.notifyAfterAddingByEditor(obj, parent, sibling);
  529. 		}
  530. 	}
  531. });
  533. /**
  534.  * A namespace for operation about Chem Structure instance.
  535.  * @namespace
  536.  */
  537. Kekule.ChemStructOperation = {};
  539. /**
  540.  * Operation of adding a chem node to a structure fragment / molecule.
  541.  * @class
  542.  * @augments Kekule.ChemObjOperation.Add
  543.  */
  544. Kekule.ChemStructOperation.AddNode = Class.create(Kekule.ChemObjOperation.Add,
  545. /** @lends Kekule.ChemStructOperation.AddNode# */
  546. {
  547. 	/** @private */
  548. 	CLASS_NAME: 'Kekule.ChemStructOperation.AddNode'
  549. });
  551. /**
  552.  * Operation of removing a chem node from a structure fragment / molecule.
  553.  * @class
  554.  * @augments Kekule.ChemObjOperation.Remove
  555.  *
  556.  * @property {Array} linkedConnectors
  557.  */
  558. Kekule.ChemStructOperation.RemoveNode = Class.create(Kekule.ChemObjOperation.Remove,
  559. /** @lends Kekule.ChemStructOperation.RemoveNode# */
  560. {
  561. 	/** @private */
  562. 	CLASS_NAME: 'Kekule.ChemStructOperation.RemoveNode',
  563. 	/** @private */
  564. 	initProperties: function()
  565. 	{
  566. 		this.defineProp('linkedConnectors', {'dataType': DataType.ARRAY, 'serializable': false});
  567. 	},
  568. 	/** @private */
  569. 	doExecute: function($super)
  570. 	{
  571. 		if (!this.getLinkedConnectors())
  572. 		{
  573. 			this.setLinkedConnectors(Kekule.ArrayUtils.clone(this.getTarget().getLinkedConnectors()));
  574. 		}
  575. 		$super()
  576. 	},
  577. 	/** @private */
  578. 	doReverse: function($super)
  579. 	{
  580. 		$super();
  581. 		var linkedConnectors = this.getLinkedConnectors();
  583. 		//console.log('reverse node', this.getTarget().getId());
  584. 		if (linkedConnectors && linkedConnectors.length)
  585. 		{
  586. 			//this.getTarget().setLinkedConnectors(linkedConnectors);
  587. 			var target = this.getTarget();
  588. 			//console.log('reverse append connector', linkedConnectors.length);
  589. 			for (var i = 0, l = linkedConnectors.length; i < l; ++i)
  590. 			{
  591. 				//linkedConnectors[i].appendConnectedObj(target);
  592. 				target.appendLinkedConnector(linkedConnectors[i]);
  593. 			}
  594. 		}
  595. 	}
  596. });
  598. /**
  599.  * Operation of replace a chem node with another one.
  600.  * @class
  601.  * @augments Kekule.Operation
  602.  */
  603. Kekule.ChemStructOperation.ReplaceNode = Class.create(Kekule.Operation,
  604. /** @lends Kekule.ChemStructOperation.ReplaceNode# */
  605. {
  606. 	/** @private */
  607. 	CLASS_NAME: 'Kekule.ChemStructOperation.ReplaceNode',
  608. 	/** @constructs */
  609. 	initialize: function($super, oldNode, newNode, parentObj, editor)
  610. 	{
  611. 		$super();
  612. 		this.setOldNode(oldNode);
  613. 		this.setNewNode(newNode);
  614. 		this.setParentObj(parentObj);
  615. 		this.setEditor(editor);
  616. 	},
  617. 	/** @private */
  618. 	initProperties: function()
  619. 	{
  620. 		this.defineProp('oldNode', {'dataType': 'Kekule.ChemStructureNode', 'serializable': false});
  621. 		this.defineProp('newNode', {'dataType': 'Kekule.ChemStructureNode', 'serializable': false});
  622. 		this.defineProp('parentObj', {'dataType': 'Kekule.ChemStructureFragment', 'serializable': false});
  623. 		this.defineProp('editor', {'dataType': 'Kekule.Editor.BaseEditor', 'serializable': false});
  624. 	},
  625. 	/** @private */
  626. 	_isInEditorSelection: function(node)
  627. 	{
  628. 		var editor = this.getEditor();
  629. 		return ((editor && editor.getSelection && editor.getSelection()) || []).indexOf(node) >= 0;
  630. 	},
  631. 	/** @private */
  632. 	doExecute: function()
  633. 	{
  634. 		var oldNode = this.getOldNode();
  635. 		var newNode = this.getNewNode();
  636. 		if (oldNode && newNode)
  637. 		{
  638. 			var parent = this.getParentObj();
  639. 			if (!parent)
  640. 			{
  641. 				parent = oldNode.getParent();
  642. 				this.setParentObj(parent);
  643. 			}
  644. 			if (parent.replaceNode)
  645. 			{
  646. 				var editor = this.getEditor();
  647. 				var needModifySelection = this._isInEditorSelection(oldNode);
  648. 				if (needModifySelection)
  649. 					editor.beginUpdateSelection();
  650. 				parent.replaceNode(oldNode, newNode);
  651. 				if (needModifySelection)
  652. 				{
  653. 					editor.removeFromSelection(oldNode);
  654. 					editor.addObjToSelection(newNode);
  655. 					editor.endUpdateSelection();
  656. 				}
  657. 			}
  658. 		}
  659. 	},
  660. 	/** @private */
  661. 	doReverse: function()
  662. 	{
  663. 		var oldNode = this.getOldNode();
  664. 		var newNode = this.getNewNode();
  665. 		if (oldNode && newNode)
  666. 		{
  667. 			var parent = this.getParentObj() || newNode.getParent();
  668. 			if (parent.replaceNode)
  669. 			{
  670. 				//console.log('reverse!');
  671. 				var editor = this.getEditor();
  672. 				var needModifySelection = this._isInEditorSelection(newNode);
  673. 				if (needModifySelection)
  674. 					editor.beginUpdateSelection();
  675. 				parent.replaceNode(newNode, oldNode);
  676. 				if (needModifySelection)
  677. 				{
  678. 					editor.removeFromSelection(newNode)
  679. 					editor.addObjToSelection(oldNode);
  680. 					editor.endUpdateSelection();
  681. 				}
  682. 			}
  683. 		}
  684. 	}
  685. });
  687. /**
  688.  * Operation of adding a chem connector to a structure fragment / molecule.
  689.  * @class
  690.  * @augments Kekule.ChemObjOperation.Add
  691.  *
  692.  * @param {Kekule.ChemObject} chemObject Target chem object.
  693.  * @param {Kekule.ChemObject} parentObj Object should be added to.
  694.  * @param {Kekule.ChemObject} refSibling If this property is set, chem object will be inserted before this sibling.
  695.  * @param {Array} connectedObjs Objects that connected by this connector.
  696.  *
  697.  * @property {Array} connectedObjs Objects that connected by this connector.
  698.  */
  699. Kekule.ChemStructOperation.AddConnector = Class.create(Kekule.ChemObjOperation.Add,
  700. /** @lends Kekule.ChemStructOperation.AddConnector# */
  701. {
  702. 	/** @private */
  703. 	CLASS_NAME: 'Kekule.ChemStructOperation.AddConnector',
  704. 	/** @constructs */
  705. 	initialize: function($super, chemObj, parentObj, refSibling, connectedObjs, editor)
  706. 	{
  707. 		$super(chemObj, parentObj, refSibling, editor);
  708. 		//this.setParentObj(parentObj);
  709. 		//this.setRefSibling(refSibling);
  710. 		this.setConnectedObjs(connectedObjs);
  711. 	},
  712. 	/** @private */
  713. 	initProperties: function()
  714. 	{
  715. 		this.defineProp('connectedObjs', {'dataType': DataType.ARRAY, 'serializable': false});
  716. 	},
  717. 	/** @private */
  718. 	doExecute: function($super)
  719. 	{
  720. 		$super();
  721. 		var connObjs = Kekule.ArrayUtils.clone(this.getConnectedObjs());
  722. 		if (connObjs && connObjs.length)
  723. 		{
  724. 			this.getTarget().setConnectedObjs(connObjs);
  725. 		}
  726. 	},
  727. 	/** @private */
  728. 	doReverse: function($super)
  729. 	{
  730. 		$super();
  731. 	}
  732. });
  734. /**
  735.  * Operation of removing a chem connector from a structure fragment / molecule.
  736.  * @class
  737.  * @augments Kekule.ChemObjOperation.Remove
  738.  *
  739.  * @property {Array} connectedObjs Objects that connected by this connector.
  740.  *   This property is used in operation reversing. If not set, value will be automatically calculated in operation executing.
  741.  */
  742. Kekule.ChemStructOperation.RemoveConnector = Class.create(Kekule.ChemObjOperation.Remove,
  743. /** @lends Kekule.ChemStructOperation.RemoveConnector# */
  744. {
  745. 	/** @private */
  746. 	CLASS_NAME: 'Kekule.ChemStructOperation.RemoveConnector',
  747. 	/** @private */
  748. 	initProperties: function()
  749. 	{
  750. 		this.defineProp('connectedObjs', {'dataType': DataType.ARRAY, 'serializable': false});
  751. 	},
  752. 	/** @private */
  753. 	doExecute: function($super)
  754. 	{
  755. 		if (!this.getConnectedObjs())
  756. 		{
  757. 			this.setConnectedObjs(Kekule.ArrayUtils.clone(this.getTarget().getConnectedObjs()));
  758. 		}
  759. 		$super()
  760. 	},
  761. 	/** @private */
  762. 	doReverse: function($super)
  763. 	{
  764. 		$super();
  765. 		var connObjs = this.getConnectedObjs();
  766. 		if (connObjs && connObjs.length)
  767. 		{
  768. 			this.getTarget().setConnectedObjs(connObjs);
  769. 		}
  770. 	}
  771. });
  773. /**
  774.  * The base operation of merging two nodes as one, acts as the parent class of MergeNodes and MergeNodesPreview.
  775.  * @class
  776.  * @augments Kekule.ChemObjOperation.Base
  777.  *
  778.  * @param {Kekule.ChemStructureNode} target Source node, all connectors to this node will be connected to toNode.
  779.  * @param {Kekule.ChemStructureNode} dest Destination node.
  780.  * @param {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging nodes between different molecule.
  781.  *
  782.  * @property {Kekule.ChemStructureNode} target Source node, all connectors to this node will be connected to toNode.
  783.  * @property {Kekule.ChemStructureNode} dest Destination node.
  784.  * @property {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging nodes between different molecule.
  785.  */
  786. Kekule.ChemStructOperation.MergeNodesBase = Class.create(Kekule.ChemObjOperation.Base,
  787. /** @lends Kekule.ChemStructOperation.MergeNodesBase# */
  788. {
  789. 	/** @private */
  790. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeNodesBase',
  791. 	/** @constructs */
  792. 	initialize: function($super, target, dest, enableStructFragmentMerge, editor)
  793. 	{
  794. 		$super(target, editor);
  795. 		this.setDest(dest);
  796. 		this.setEnableStructFragmentMerge(enableStructFragmentMerge || false);
  797. 		this._refSibling = null;
  798. 		this._nodeParent = null;
  799. 	},
  800. 	/** @private */
  801. 	initProperties: function()
  802. 	{
  803. 		this.defineProp('dest', {'dataType': 'Kekule.ChemStructureNode', 'serializable': false});
  804. 		this.defineProp('enableStructFragmentMerge', {'dataType': DataType.BOOL});
  805. 	},
  806. 	/**
  807. 	 * Returns nodes connected with both node1 and node2.
  808. 	 * @param {Kekule.ChemStructureNode} node1
  809. 	 * @param {Kekule.ChemStructureNode} node2
  810. 	 * @returns {Array}
  811. 	 */
  812. 	getCommonSiblings: function(node1, node2)
  813. 	{
  814. 		var siblings1 = node1.getLinkedObjs();
  815. 		var siblings2 = node2.getLinkedObjs();
  816. 		return Kekule.ArrayUtils.intersect(siblings1, siblings2);
  817. 	},
  818. 	/** @private */
  819. 	doExecute: function()
  820. 	{
  821. 		// do nothing, descendants should override
  822. 	},
  823. 	/** @private */
  824. 	doReverse: function()
  825. 	{
  826. 		// do nothing, descendants should override
  827. 	}
  828. });
  830. /**
  831.  * Operation of merging two nodes as one.
  832.  * @class
  833.  * @augments Kekule.ChemStructOperation.MergeNodesBase
  834.  *
  835.  * @param {Kekule.ChemStructureNode} target Source node, all connectors to this node will be connected to toNode.
  836.  * @param {Kekule.ChemStructureNode} dest Destination node.
  837.  * @param {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging nodes between different molecule.
  838.  *
  839.  * @property {Array} changedConnectors Connectors modified during merge.
  840.  * @property {Array} removedConnectors Connectors removed during merge.
  841.  */
  842. Kekule.ChemStructOperation.MergeNodes = Class.create(Kekule.ChemStructOperation.MergeNodesBase,
  843. /** @lends Kekule.ChemStructOperation.MergeNodes# */
  844. {
  845. 	/** @private */
  846. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeNodes',
  847. 	/** @constructs */
  848. 	initialize: function($super, target, dest, enableStructFragmentMerge, editor)
  849. 	{
  850. 		$super(target, dest, enableStructFragmentMerge, editor);
  851. 		this._refSibling = null;
  852. 		this._nodeParent = null;
  853. 		this._structFragmentMergeOperation = null;
  854. 		this._removeConnectorOperations = [];
  855. 		this._removeNodeOperation = null;
  856. 	},
  857. 	/** @private */
  858. 	initProperties: function()
  859. 	{
  860. 		this.defineProp('changedConnectors', {'dataType': DataType.ARRAY, 'serializable': false});
  861. 		this.defineProp('removedConnectors', {'dataType': DataType.ARRAY, 'serializable': false});
  862. 		//this.defineProp('enableStructFragmentMerge', {'dataType': DataType.BOOL});
  863. 	},
  864. 	/** @ignore */
  865. 	doExecute: function()
  866. 	{
  867. 		var fromNode = this.getTarget();
  868. 		var toNode = this.getDest();
  869. 		var structFragment = fromNode.getParentFragment();
  870. 		var destFragment = toNode.getParentFragment();
  871. 		if (structFragment !== destFragment)  // from different molecule
  872. 		{
  873. 			//console.log('need merge mol');
  874. 			if (this.getEnableStructFragmentMerge())
  875. 			{
  876. 				this._structFragmentMergeOperation = new Kekule.ChemStructOperation.MergeStructFragment(structFragment, destFragment, this.getEditor());
  877. 				//this._structFragmentMergeOperation = new Kekule.ChemStructOperation.MergeStructFragment(destFragment, structFragment);
  878. 				this._structFragmentMergeOperation.execute();
  879. 				structFragment = destFragment;
  880. 			}
  881. 			else
  882. 				return null;
  883. 		}
  884. 		this._nodeParent = structFragment;
  886. 		structFragment.beginUpdate();
  887. 		try
  888. 		{
  889. 			var editor = this.getEditor();
  890. 			var removedConnectors = this.getRemovedConnectors();
  891. 			if (!removedConnectors)  // auto calc
  892. 			{
  893. 				var commonSiblings = this.getCommonSiblings(fromNode, toNode);
  894. 				var removedConnectors = [];
  895. 				if (commonSiblings.length)  // has common sibling between from/toNode, bypass bond between fromNode and sibling
  896. 				{
  897. 					for (var i = 0, l = commonSiblings.length; i < l; ++i)
  898. 					{
  899. 						var sibling = commonSiblings[i];
  900. 						var connector = fromNode.getConnectorTo(sibling);
  901. 						if (connector && (connector.getConnectedObjCount() == 2))
  902. 							removedConnectors.push(connector);
  903. 					}
  904. 				}
  905. 				var directConnector = fromNode.getConnectorTo(toNode);
  906. 				if (directConnector)
  907. 					removedConnectors.push(directConnector);
  908. 				this.setRemovedConnectors(removedConnectors);
  909. 			}
  911. 			var connectors = this.getChangedConnectors();
  912. 			if (!connectors)  // auto calc
  913. 			{
  914. 				var connectors = Kekule.ArrayUtils.clone(fromNode.getLinkedConnectors()) || [];
  915. 				connectors = Kekule.ArrayUtils.exclude(connectors, removedConnectors);
  916. 				this.setChangedConnectors(connectors);
  917. 			}
  919. 			// save fromNode's information
  920. 			this._refSibling = fromNode.getNextSibling();
  922. 			for (var i = 0, l = connectors.length; i < l; ++i)
  923. 			{
  924. 				var connector = connectors[i];
  925. 				var index = connector.indexOfConnectedObj(fromNode);
  926. 				connector.removeConnectedObj(fromNode);
  927. 				connector.insertConnectedObjAt(toNode, index);  // keep the index is important, wedge bond direction is related with node sequence
  928. 			}
  930. 			this._removeConnectorOperations = [];
  931. 			for (var i = 0, l = removedConnectors.length; i < l; ++i)
  932. 			{
  933. 				var connector = removedConnectors[i];
  934. 				var oper = new Kekule.ChemStructOperation.RemoveConnector(connector, null, null, editor);
  935. 				oper.execute();
  936. 				this._removeConnectorOperations.push(oper);
  937. 			}
  939. 			//structFragment.removeNode(fromNode);
  940. 			this._removeNodeOperation = new Kekule.ChemStructOperation.RemoveNode(fromNode, null, null, editor);
  941. 			this._removeNodeOperation.execute();
  942. 		}
  943. 		finally
  944. 		{
  945. 			structFragment.endUpdate();
  946. 		}
  947. 	},
  948. 	/** @ignore */
  949. 	doReverse: function()
  950. 	{
  951. 		var fromNode = this.getTarget();
  952. 		var toNode = this.getDest();
  953. 		//var structFragment = fromNode.getParent();
  954. 		//var structFragment = toNode.getParent();
  955. 		var structFragment = this._nodeParent;
  957. 		structFragment.beginUpdate();
  958. 		try
  959. 		{
  960. 			/*
  961. 			 console.log(fromNode.getParent(), fromNode.getParent() === structFragment,
  962. 			 toNode.getParent(), toNode.getParent() === structFragment);
  963. 			 */
  964. 			//structFragment.insertBefore(fromNode, this._refSibling);
  965. 			this._removeNodeOperation.reverse();
  967. 			if (this._removeConnectorOperations.length)
  968. 			{
  969. 				for (var i = this._removeConnectorOperations.length - 1; i >= 0; --i)
  970. 				{
  971. 					var oper = this._removeConnectorOperations[i];
  972. 					oper.reverse();
  973. 				}
  974. 			}
  975. 			this._removeConnectorOperations = [];
  977. 			var connectors = this.getChangedConnectors();
  979. 			//console.log('reverse node merge2', toNode, toNode.getParent());
  981. 			for (var i = 0, l = connectors.length; i < l; ++i)
  982. 			{
  983. 				var connector = connectors[i];
  984. 				var index = connector.indexOfConnectedObj(toNode);
  985. 				connector.removeConnectedObj(toNode);
  986. 				connector.insertConnectedObjAt(fromNode, index);
  987. 			}
  988. 		}
  989. 		finally
  990. 		{
  991. 			structFragment.endUpdate();
  992. 		}
  994. 		//console.log('reverse node merge', toNode, toNode.getParent());
  996. 		if (this._structFragmentMergeOperation)
  997. 		{
  998. 			this._structFragmentMergeOperation.reverse();
  999. 		}
  1000. 	}
  1001. });
  1002. /**
  1003.  * A class method to check if two connectors can be merged
  1004.  * @param {Kekule.ChemStructureNode} target
  1005.  * @param {Kekule.ChemStructureNode} dest
  1006.  * @param {Bool} canMergeStructFragment
  1007.  * @returns {Bool}
  1008.  */
  1009. Kekule.ChemStructOperation.MergeNodes.canMerge = function(target, dest, canMergeStructFragment, canMergeNeighborNodes)
  1010. {
  1011. 	// never allow merge to another molecule point (e.g. formula molecule) or subgroup
  1012. 	if ((target instanceof Kekule.StructureFragment) || (dest instanceof Kekule.StructureFragment))
  1013. 		return false;
  1014. 	if (!((target instanceof Kekule.ChemStructureNode) && (dest instanceof Kekule.ChemStructureNode)))
  1015. 		return false;
  1016. 	var targetFragment = target.getParent();
  1017. 	var destFragment = dest.getParent();
  1018. 	var result = (targetFragment === destFragment) || canMergeStructFragment;
  1019. 	if (!canMergeNeighborNodes)
  1020. 		result = result && (!target.getConnectorTo(dest));
  1021. 	return result;
  1022. };
  1024. /**
  1025.  * Preview operation of merging two nodes as one.
  1026.  * This operation just set the same position of merging nodes, but do not do the actual merge.
  1027.  * @class
  1028.  * @augments Kekule.ChemStructOperation.MergeNodesBase
  1029.  *
  1030.  * @param {Kekule.ChemStructureNode} target Source node, all connectors to this node will be connected to toNode.
  1031.  * @param {Kekule.ChemStructureNode} dest Destination node.
  1032.  * @param {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging nodes between different molecule.
  1033.  */
  1034. Kekule.ChemStructOperation.MergeNodesPreview = Class.create(Kekule.ChemStructOperation.MergeNodesBase,
  1035. /** @lends Kekule.ChemStructOperation.MergeNodesPreview# */
  1036. {
  1037. 	/** @private */
  1038. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeNodesPreview',
  1039. 	/** @constructs */
  1040. 	initialize: function($super, target, dest, enableStructFragmentMerge, editor)
  1041. 	{
  1042. 		$super(target, dest, enableStructFragmentMerge, editor);
  1043. 		this._nodeParent = null;
  1044. 	},
  1045. 	/** @ignore */
  1046. 	doExecute: function()
  1047. 	{
  1048. 		this._moveNodeOperations = [];
  1049. 		var fromNode = this.getTarget();
  1050. 		var toNode = this.getDest();
  1051. 		var structFragment = fromNode.getParentFragment();
  1052. 		/*
  1053. 		if (!structFragment)
  1054. 			console.log('merge from', fromNode.getId(), 'to', toNode.getId());
  1055. 		*/
  1056. 		var CM = Kekule.CoordMode;
  1057. 		var coordModes = [CM.COORD2D, CM.COORD3D];
  1058. 		if (structFragment)
  1059. 			structFragment.beginUpdate();
  1060. 		try
  1061. 		{
  1062. 			for (var i = 0, l = coordModes.length; i < l; ++i)
  1063. 			{
  1064. 				var toCoord = toNode.getAbsBaseCoord(coordModes[i], false);
  1065. 				var oper = new Kekule.ChemObjOperation.MoveTo(fromNode, toCoord, coordModes[i], true, this.getEditor());
  1066. 				oper.execute();
  1067. 				this._moveNodeOperations.push(oper);
  1068. 			}
  1069. 			this._nodeParent = structFragment;
  1070. 		}
  1071. 		finally
  1072. 		{
  1073. 			if (structFragment)
  1074. 				structFragment.endUpdate();
  1075. 		}
  1076. 	},
  1077. 	/** @ignore */
  1078. 	doReverse: function()
  1079. 	{
  1080. 		var structFragment = this._nodeParent;
  1081. 		if (structFragment)
  1082. 			structFragment.beginUpdate();
  1083. 		try
  1084. 		{
  1085. 			var opers = this._moveNodeOperations;
  1086. 			for (var i = opers.length - 1; i >= 0; --i)
  1087. 			{
  1088. 				opers[i].reverse();
  1089. 			}
  1090. 		}
  1091. 		finally
  1092. 		{
  1093. 			if (structFragment)
  1094. 				structFragment.endUpdate();
  1095. 		}
  1096. 		this._moveNodeOperations = null;
  1097. 	}
  1098. });
  1099. Kekule.ChemStructOperation.MergeNodesPreview.canMerge = Kekule.ChemStructOperation.MergeNodes.canMerge;
  1101. /**
  1102.  * Operation of merging two connectors as one.
  1103.  * @class
  1104.  * @augments Kekule.ChemObjOperation.Base
  1105.  *
  1106.  * @param {Kekule.ChemStructureConnector} target Source connector.
  1107.  * @param {Kekule.ChemStructureConnector} dest Destination connector.
  1108.  * @param {Int} coordMode Coord mode of current editor.
  1109.  * @param {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging connectors between different molecule.
  1110.  *
  1111.  * @property {Kekule.ChemStructureConnector} target Source connector.
  1112.  * @property {Kekule.ChemStructureConnector} dest Destination connector.
  1113.  * @property {Int} coordMode Coord mode of current editor.
  1114.  * @property {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging connectors between different molecule.
  1115.  */
  1116. Kekule.ChemStructOperation.MergeConnectorsBase = Class.create(Kekule.ChemObjOperation.Base,
  1117. /** @lends Kekule.ChemStructOperation.MergeConnectorsBase# */
  1118. {
  1119. 	/** @private */
  1120. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeConnectorsBase',
  1121. 	/** @constructs */
  1122. 	initialize: function($super, target, dest, coordMode, enableStructFragmentMerge, editor)
  1123. 	{
  1124. 		$super(target, editor);
  1125. 		this.setDest(dest);
  1126. 		this.setCoordMode(coordMode || Kekule.CoordMode.COORD2D);
  1127. 		this.setEnableStructFragmentMerge(enableStructFragmentMerge || false);
  1128. 		this._refSibling = null;
  1129. 		this._nodeParent = null;
  1130. 		//this._structFragmentMergeOperation = null;
  1131. 		this._nodeMergeOperations = [];
  1132. 	},
  1133. 	/** @private */
  1134. 	initProperties: function()
  1135. 	{
  1136. 		this.defineProp('dest', {'dataType': 'Kekule.ChemStructureConnector', 'serializable': false});
  1137. 		this.defineProp('enableStructFragmentMerge', {'dataType': DataType.BOOL});
  1138. 		this.defineProp('coordMode', {'dataType': DataType.INT});
  1139. 	},
  1140. 	/**
  1141. 	 * Returns the concrete node merge operation, descendants should override this method.
  1142. 	 */
  1143. 	getMergeNodeOperationClass: function()
  1144. 	{
  1145. 		// do nothing here
  1146. 	},
  1147. 	/** @private */
  1148. 	doExecute: function()
  1149. 	{
  1150. 		var canMerge = Kekule.ChemStructOperation.MergeConnectors.canMerge(this.getTarget(), this.getDest(), this.getEnableStructFragmentMerge());
  1152. 		if (!canMerge)
  1153. 			Kekule.error(Kekule.$L('ErrorMsg.CAN_NOT_MERGE_CONNECTORS'));
  1155. 		// sort targetNodes and destNodes via coord
  1156. 		var coordMode = this.getCoordMode();
  1157. 		var connectors = [this.getTarget(), this.getDest()];
  1158. 		var AU = Kekule.ArrayUtils;
  1159. 		var targetNodes = AU.clone(this.getTarget().getConnectedObjs());
  1160. 		var destNodes = AU.clone(this.getDest().getConnectedObjs());
  1161. 		var allowCoordBorrow = this.getAllowCoordBorrow();
  1163. 		for (var i = 0, l = connectors.length; i < l; ++i)
  1164. 		{
  1165. 			var connector = connectors[i];
  1166. 			var coord1 = connector.getConnectedObjAt(0).getAbsCoordOfMode(coordMode, allowCoordBorrow);
  1167. 			var coord2 = connector.getConnectedObjAt(1).getAbsCoordOfMode(coordMode, allowCoordBorrow);
  1168. 			var coordDelta = Kekule.CoordUtils.substract(coord1, coord2);
  1169. 			var dominateDirection = Math.abs(coordDelta.x) > Math.abs(coordDelta.y)? 'x': 'y';
  1170. 			if (Kekule.ObjUtils.notUnset(coord1.z))
  1171. 			{
  1172. 				if (Math.abs(coordDelta.z) > Math.abs(coordDelta.x))
  1173. 					dominateDirection = 'z';
  1174. 			}
  1175. 			var nodes = (i === 0)? targetNodes: destNodes;
  1176. 			nodes.sort(function(a, b)
  1177. 				{
  1178. 					var coord1 = a.getAbsCoordOfMode(coordMode, allowCoordBorrow);
  1179. 					var coord2 = b.getAbsCoordOfMode(coordMode, allowCoordBorrow);
  1180. 					return (coord1[dominateDirection] - coord2[dominateDirection]) || 0;
  1181. 				}
  1182. 			);
  1183. 		}
  1185. 		var commonNodes = AU.intersect(targetNodes, destNodes);
  1186. 		targetNodes = AU.exclude(targetNodes, commonNodes);
  1187. 		destNodes = AU.exclude(destNodes, commonNodes);
  1189. 		this._nodeMergeOperations = [];
  1190. 		var nodeMergeOperClass = this.getMergeNodeOperationClass();
  1191. 		for (var i = 0, l = targetNodes.length; i < l; ++i)
  1192. 		{
  1193. 			if (targetNodes[i] !== destNodes[i])
  1194. 			{
  1195. 				//var oper = new Kekule.ChemStructOperation.MergeNodes(targetNodes[i], destNodes[i], this.getEnableStructFragmentMerge());
  1196. 				var oper = new nodeMergeOperClass(targetNodes[i], destNodes[i], this.getEnableStructFragmentMerge());
  1197. 				oper.execute();
  1198. 			}
  1199. 			this._nodeMergeOperations.push(oper);
  1200. 		}
  1201. 	},
  1202. 	/** @private */
  1203. 	doReverse: function()
  1204. 	{
  1205. 		for (var i = this._nodeMergeOperations.length - 1; i >= 0; --i)
  1206. 		{
  1207. 			var oper = this._nodeMergeOperations[i];
  1208. 			oper.reverse();
  1209. 		}
  1210. 		this._nodeMergeOperations = [];
  1211. 	}
  1212. });
  1213. /**
  1214.  * Operation of merging two connectors as one.
  1215.  * @class
  1216.  * @augments Kekule.ChemStructOperation.MergeConnectorsBase
  1217.  *
  1218.  * @param {Kekule.ChemStructureConnector} target Source connector.
  1219.  * @param {Kekule.ChemStructureConnector} dest Destination connector.
  1220.  * @param {Int} coordMode Coord mode of current editor.
  1221.  * @param {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging connectors between different molecule.
  1222.  */
  1223. Kekule.ChemStructOperation.MergeConnectors = Class.create(Kekule.ChemStructOperation.MergeConnectorsBase,
  1224. /** @lends Kekule.ChemStructOperation.MergeConnectors# */
  1225. {
  1226. 	/** @private */
  1227. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeConnectors',
  1228. 	/** @ignore */
  1229. 	getMergeNodeOperationClass: function()
  1230. 	{
  1231. 		return Kekule.ChemStructOperation.MergeNodes;
  1232. 	}
  1233. });
  1234. /**
  1235.  * A class method to check if two connectors can be merged
  1236.  * @param {Kekule.ChemStructureConnector} target
  1237.  * @param {Kekule.ChemStructureConnector} dest
  1238.  * @param {Bool} canMergeStructFragment
  1239.  * @returns {Bool}
  1240.  */
  1241. Kekule.ChemStructOperation.MergeConnectors.canMerge = function(target, dest, canMergeStructFragment)
  1242. {
  1243. 	if (!canMergeStructFragment && (target.getParent() !== dest.getParent()))
  1244. 		return false;
  1245. 	if (target.isConnectingConnector() || dest.isConnectingConnector())
  1246. 	{
  1247. 		return false;
  1248. 	}
  1249. 	var targetNodes = target.getConnectedExposedObjs();
  1250. 	var destNodes = dest.getConnectedObjs();
  1251. 	if (targetNodes.length !== destNodes.length)
  1252. 	{
  1253. 		return false;
  1254. 	}
  1255. 	if (targetNodes.length !== 2)  // currently can only handle connector with 2 connected objects
  1256. 	{
  1257. 		return false;
  1258. 	}
  1259. 	if (Kekule.ArrayUtils.intersect(targetNodes, destNodes).length >= 1)
  1260. 	{
  1261. 		return false;
  1262. 	}
  1263. 	return true;
  1264. };
  1265. /**
  1266.  * Operation of merging two connectors as one.
  1267.  * @class
  1268.  * @augments Kekule.ChemStructOperation.MergeConnectorsBase
  1269.  *
  1270.  * @param {Kekule.ChemStructureConnector} target Source connector.
  1271.  * @param {Kekule.ChemStructureConnector} dest Destination connector.
  1272.  * @param {Int} coordMode Coord mode of current editor.
  1273.  * @param {Bool} enableStructFragmentMerge If true, molecule will be also merged when merging connectors between different molecule.
  1274.  */
  1275. Kekule.ChemStructOperation.MergeConnectorsPreview = Class.create(Kekule.ChemStructOperation.MergeConnectorsBase,
  1276. /** @lends Kekule.ChemStructOperation.MergeConnectors# */
  1277. {
  1278. 	/** @private */
  1279. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeConnectors',
  1280. 	/** @ignore */
  1281. 	getMergeNodeOperationClass: function()
  1282. 	{
  1283. 		return Kekule.ChemStructOperation.MergeNodesPreview;
  1284. 	}
  1285. });
  1286. Kekule.ChemStructOperation.MergeConnectorsPreview.canMerge = Kekule.ChemStructOperation.MergeConnectors.canMerge;
  1288. /**
  1289.  * Operation of merging two structure fragment as one.
  1290.  * @class
  1291.  * @augments Kekule.ChemObjOperation.Base
  1292.  *
  1293.  * @param {Kekule.StructureFragment} target Source fragment.
  1294.  * @param {Kekule.StructureFragment} dest Destination fragment.
  1295.  *
  1296.  * @property {Kekule.StructureFragment} target Source fragment, all connectors and nodes will be moved to dest fragment.
  1297.  * @property {Kekule.StructureFragment} dest Destination fragment.
  1298.  * @property {Array} mergedNodes Nodes moved from target to dest during merging.
  1299.  * @property {Array} mergedConnectors Connectors moved from target to dest during merging.
  1300.  */
  1301. Kekule.ChemStructOperation.MergeStructFragment = Class.create(Kekule.ChemObjOperation.Base,
  1302. /** @lends Kekule.ChemStructOperation.MergeStructFragment# */
  1303. {
  1304. 	/** @private */
  1305. 	CLASS_NAME: 'Kekule.ChemStructOperation.MergeStructFragment',
  1306. 	/** @constructs */
  1307. 	initialize: function($super, target, dest, editor)
  1308. 	{
  1309. 		$super(target, editor);
  1310. 		this.setDest(dest);
  1311. 		this._removeOperation = null;
  1312. 	},
  1313. 	/** @private */
  1314. 	initProperties: function()
  1315. 	{
  1316. 		this.defineProp('dest', {'dataType': 'Kekule.StructureFragment', 'serializable': false});
  1317. 		this.defineProp('mergedNodes', {'dataType': DataType.ARRAY, 'serializable': false});
  1318. 		this.defineProp('mergedConnectors', {'dataType': DataType.ARRAY, 'serializable': false});
  1319. 	},
  1320. 	/** @private */
  1321. 	moveChildBetweenStructFragment: function(target, dest, nodes, connectors)
  1322. 	{
  1323. 		Kekule.ChemStructureUtils.moveChildBetweenStructFragment(target, dest, nodes, connectors);
  1324. 	},
  1325. 	/** @private */
  1326. 	doExecute: function()
  1327. 	{
  1328. 		var target = this.getTarget();
  1329. 		var dest = this.getDest();
  1330. 		if (target && dest)
  1331. 		{
  1332. 			var nodes = Kekule.ArrayUtils.clone(target.getNodes());
  1333. 			this.setMergedNodes(nodes);
  1334. 			var connectors = Kekule.ArrayUtils.clone(target.getConnectors());
  1335. 			this.setMergedConnectors(connectors);
  1337. 			this.moveChildBetweenStructFragment(target, dest, nodes, connectors);
  1338. 			var parent = target.getParent();
  1339. 			if (parent)  // remove target from parent
  1340. 			{
  1341. 				this._removeOperation = new Kekule.ChemObjOperation.Remove(target, parent, null, this.getEditor());
  1342. 				this._removeOperation.execute();
  1343. 			}
  1344. 		}
  1345. 	},
  1346. 	/** @private */
  1347. 	doReverse: function()
  1348. 	{
  1349. 		var target = this.getTarget();
  1350. 		var dest = this.getDest();
  1351. 		if (target && dest)
  1352. 		{
  1353. 			if (this._removeOperation)
  1354. 			{
  1355. 				this._removeOperation.reverse();
  1356. 				this._removeOperation = null;
  1357. 			}
  1358. 			var nodes = this.getMergedNodes();
  1359. 			var connectors = this.getMergedConnectors();
  1361. 			/*
  1362. 			console.log('before mol merge reverse dest', dest.getNodeCount(), dest.getConnectorCount());
  1363. 			console.log('before mol merge reverse target', target.getNodeCount(), target.getConnectorCount());
  1365. 			console.log('reverse mol merge', nodes.length, connectors.length);
  1366. 			*/
  1367. 			this.moveChildBetweenStructFragment(dest, target, nodes, connectors);
  1368. 			/*
  1369. 			console.log('after mol merge reverse dest', dest.getNodeCount(), dest.getConnectorCount());
  1370. 			console.log('after mol merge reverse target', target.getNodeCount(), target.getConnectorCount());
  1371. 			*/
  1372. 		}
  1373. 	}
  1374. });
  1376. /**
  1377.  * Operation of split one unconnected structure fragment into multiple connected ones.
  1378.  * @class
  1379.  * @augments Kekule.ChemObjOperation.Base
  1380.  *
  1381.  * @param {Kekule.StructureFragment} target.
  1382.  *
  1383.  * @property {Kekule.StructureFragment} target Source fragment, all connectors and nodes will be moved to dest fragment.
  1384.  * @property {Array} splittedFragments Fragment splitted, this property will be automatically calculated in execution of operation.
  1385.  */
  1386. Kekule.ChemStructOperation.SplitStructFragment = Class.create(Kekule.ChemObjOperation.Base,
  1387. /** @lends Kekule.ChemStructOperation.SplitStructFragment# */
  1388. {
  1389. 	/** @private */
  1390. 	CLASS_NAME: 'Kekule.ChemStructOperation.SplitStructFragment',
  1391. 	/** @constructs */
  1392. 	initialize: function($super, target, editor)
  1393. 	{
  1394. 		$super(target, editor);
  1395. 	},
  1396. 	/** @private */
  1397. 	initProperties: function()
  1398. 	{
  1399. 		this.defineProp('splittedFragments', {'dataType': DataType.ARRAY, 'serializable': false, 'setter': null});
  1400. 	},
  1401. 	/** @private */
  1402. 	doExecute: function()
  1403. 	{
  1404. 		var splitted = Kekule.ChemStructureUtils.splitStructFragment(this.getTarget());
  1405. 		if (splitted.length > 1)  // do really split
  1406. 		{
  1407. 			this.setPropStoreFieldValue('splittedFragments', splitted);
  1408. 			var parent = this.getTarget().getParent();
  1409. 			var ref = this.getTarget().getNextSibling();
  1410. 			parent.beginUpdate();
  1411. 			try
  1412. 			{
  1413. 				if (parent)  // insert newly splitted fragments
  1414. 				{
  1415. 					for (var i = 1, l = splitted.length; i < l; ++i)
  1416. 					{
  1417. 						var frag = splitted[i];
  1418. 						parent.insertBefore(frag, ref);
  1419. 					}
  1420. 				}
  1421. 			}
  1422. 			finally
  1423. 			{
  1424. 				parent.endUpdate();
  1425. 			}
  1426. 		}
  1427. 		else // no real split actions done
  1428. 		{
  1429. 			this.setPropStoreFieldValue('splittedFragments', null);
  1430. 		}
  1431. 	},
  1432. 	/** @private */
  1433. 	doReverse: function()
  1434. 	{
  1435. 		var fragments = this.getSplittedFragments();
  1436. 		if (fragments && fragments.length)
  1437. 		{
  1438. 			var target = this.getTarget();
  1439. 			for (var i = 0, l = fragments.length; i < l; ++i)
  1440. 			{
  1441. 				var frag = fragments[i];
  1442. 				if (frag !== target)
  1443. 				{
  1444. 					Kekule.ChemStructureUtils.moveChildBetweenStructFragment(frag, target, Kekule.ArrayUtils.clone(frag.getNodes()), Kekule.ArrayUtils.clone(frag.getConnectors()));
  1445. 					var p = frag.getParent();
  1446. 					if (p)
  1447. 						p.removeChild(frag);
  1448. 					frag.finalize();
  1449. 				}
  1450. 			}
  1451. 		}
  1452. 		//console.log('split reverse done', target.getNodeCount(), target.getConnectorCount());
  1453. 	}
  1454. });
  1456. /**
  1457.  * Split one unconnected structure fragment into multiple connected ones, or remove the fragment
  1458.  * if the fragment contains no node.
  1459.  * @class
  1460.  * @augments Kekule.ChemObjOperation.Base
  1461.  *
  1462.  * @param {Kekule.StructureFragment} target.
  1463.  *
  1464.  * @property {Kekule.StructureFragment} target Source fragment.
  1465.  * @property {Bool} enableRemove Whether allow remove empty structure fragment. Default is true.
  1466.  * @property {Bool} enableSplit Whether allow splitting structure fragment. Default is true.
  1467.  */
  1468. Kekule.ChemStructOperation.StandardizeStructFragment = Class.create(Kekule.ChemObjOperation.Base,
  1469. /** @lends Kekule.ChemStructOperation.StandardizeStructFragment# */
  1470. {
  1471. 	/** @private */
  1472. 	CLASS_NAME: 'Kekule.ChemStructOperation.StandardizeStructFragment',
  1473. 	/** @constructs */
  1474. 	initialize: function($super, target, editor)
  1475. 	{
  1476. 		$super(target, editor);
  1477. 		this.setEnableSplit(true);
  1478. 		this.setEnableRemove(true);
  1479. 		this._concreteOper = null;  // private
  1480. 	},
  1481. 	/** @private */
  1482. 	initProperties: function()
  1483. 	{
  1484. 		this.defineProp('enableRemove', {'dataType': DataType.BOOL});
  1485. 		this.defineProp('enableSplit', {'dataType': DataType.BOOL});
  1486. 	},
  1487. 	/** @private */
  1488. 	doExecute: function()
  1489. 	{
  1490. 		var target = this.getTarget();
  1491. 		var nodeCount = target.getNodeCount();
  1492. 		this._concreteOper = null;
  1493. 		var editor = this.getEditor();
  1494. 		if (nodeCount <= 0)
  1495. 		{
  1496. 			if (this.getEnableRemove())
  1497. 				this._concreteOper = new Kekule.ChemObjOperation.Remove(target, null, null, editor);
  1498. 		}
  1499. 		else
  1500. 		{
  1501. 			if (this.getEnableSplit())
  1502. 				this._concreteOper = new Kekule.ChemStructOperation.SplitStructFragment(target, editor);
  1503. 		}
  1504. 		if (this._concreteOper)
  1505. 			return this._concreteOper.execute();
  1506. 		else
  1507. 			return null;
  1508. 	},
  1509. 	/** @private */
  1510. 	doReverse: function()
  1511. 	{
  1512. 		return this._concreteOper? this._concreteOper.reverse(): null;
  1513. 	}
  1514. });
  1516. 	})();