Source: render/kekule.render.base.js

  1. /**
  2.  * @fileoverview
  3.  * Base (abstract) class of 2D or 3D molecule renderers.
  4.  * @author Partridge Jiang
  5.  */
  7. /*
  8.  * requires /lan/classes.js
  9.  * requires /core/kekule.common.js
  10.  * requires /render/kekule.render.utils.js
  11.  */
  13. "use strict";
  15. /**
  16.  * Namespace for renderer system.
  17.  * @namespace
  18.  */
  19. Kekule.Render = {};
  21. /**
  22.  * Enumeration of coord systems (chemObject, context or screen).
  23.  * @class
  24.  */
  25. Kekule.Render.CoordSystem = {
  26. 	/** ChemObject system, used to mark the inner structure of chem objects. 2D or 3D. */
  27. 	CHEM: 0,
  28. 	/** Context system, used for draw bridges. 2D or 3D. */
  29. 	CONTEXT: 1,
  30. 	/** Screen system, 2D, usually in pixel. */
  31. 	SCREEN: 2
  32. };
  34. /*
  35.  * Enumeration of interaction states of chem object (node or connector).
  36.  * @class
  37.  * @deprecated
  38.  */
  39. //Kekule.Render.InteractState = {
  40. 	/** Normal state. */
  41. 	//NORMAL: 'normal',
  42. 	/** Mouse hover above. */
  43. 	//HOVER: 'hover',
  44. 	/** Object is selected. */
  45. 	//ACTIVE: 'active'
  46. //};
  48. /**
  49.  * Enumeration of renderer types: 2D or 3D.
  50.  * @enum
  51.  */
  52. Kekule.Render.RendererType = {
  53. 	/** 2D renderer. */
  54. 	R2D: 2,
  55. 	/** 3D renderer. */
  56. 	R3D: 3
  57. };
  59. /**
  60.  * The position of coord point in object box.
  61.  * @enum
  62.  */
  63. Kekule.Render.CoordPos = {
  64. 	/** Center point of object. */
  65. 	CENTER: 0,
  66. 	/** Top left point of object, usually used in blocks of 2D context. */
  67. 	CORNER_TL: 21,
  68. 	/** Default value, same as CENTER. */
  69. 	DEFAULT: 0
  70. };
  72. /**
  73.  * C is the most common element in organic molecule. So the label of C will be ignored in bond-line formula.
  74.  * @constant
  75.  */
  76. Kekule.Render.DEF_ATOM_ATOMIC_NUM = 6;
  78. /**
  79.  * Enumeration of molecule display type, condensed formula or bond-line formula.
  80.  * @enum
  81.  */
  82. Kekule.Render.MoleculeDisplayType = {
  83. 	/** bond-line formula */
  84. 	SKELETAL: 1,
  85. 	/** Condensed formula */
  86. 	CONDENSED: 2,
  87. 	DEFAULT: 1
  88. };
  89. Kekule.Render.Molecule2DDisplayType = Kekule.Render.MoleculeDisplayType;
  91. /**
  92.  * Enumeration of node label (usually atom label) display mode (especially in 2D renderer).
  93.  * @enum
  94.  */
  95. Kekule.Render.NodeLabelDisplayMode = {
  96. 	/** Label is hidden */
  97. 	HIDDEN: -1,
  98. 	/** Label should be shown */
  99. 	SHOWN: 1,
  100. 	/** Whether show label is decided by the display type of molecule */
  101. 	SMART: 0,
  102. 	/** Default is SMART */
  103. 	DEFAULT: 0
  104. }
  106. /**
  107.  * Enumeration of hydrongen display strategy (espcially in 2D renderer).
  108.  * @enum
  109.  */
  110. Kekule.Render.HydrogenDisplayLevel = {
  111. 	/** No hydrongen is displayed */
  112. 	NONE: 0,
  113. 	/** Only display explicit hydrogens. */
  114. 	EXPLICIT: 1,
  115. 	/** Display explicit hydrogens only when the count is not the same as implicit. */
  116. 	UNMATCHED_EXPLICIT: 2,
  117. 	/** Display all hydrogens, whether explicit or implicit ones. */
  118. 	ALL: 10,
  119. 	/** Default is EXPLICIT. */
  120. 	DEFAULT: 1
  121. };
  124. /**
  125.  * Enumeration of direction of text (especially rich text label).
  126.  * @enum
  127.  */
  128. Kekule.Render.TextDirection = {
  129. 	/** @ignore */
  130. 	DEFAULT: 0,
  131. 	/** Left to right. */
  132. 	LTR: 1,
  133. 	/** Right to left. */
  134. 	RTL: 3,
  135. 	/** Top to bottom. */
  136. 	TTB: 2,
  137. 	/** Bottom to top */
  138. 	BTT: 4,
  139. 	/** Inherit from parent setting */
  140. 	INHERIT: 10
  141. 	/* Decide the direction by environment around. Useful when draw label in ctab. */
  142. 	/*SMART: 20*/
  143. };
  146. /**
  147.  * Enumeration of horizontal / vertical alignment of text.
  148.  * @enum
  149.  */
  150. Kekule.Render.TextAlign = {
  151. 	/*BASELINE: 0,  //??????*/
  152. 	DEFAULT: 0,
  153. 	LEFT: 1,
  154. 	RIGHT: 2,
  155. 	TOP: 3,
  156. 	BOTTOM: 4,
  157. 	CENTER: 5,
  158. 	LEADING: 10,
  159. 	TRAILING: 11,
  161. 	/**
  162. 	 * LEADING and TRAILING are related align mode, related to text direction.
  163. 	 * This function returns absolute align value due to textDirection.
  164. 	 * @returns {Int}
  165. 	 */
  166. 	getAbsAlign: function(textAlign, textDirection)
  167. 	{
  168. 		var result = textAlign;
  169. 		var TA = Kekule.Render.TextAlign;
  170. 		var TD = Kekule.Render.TextDirection;
  171. 		if ((textAlign === TA.LEADING) || (textAlign === TA.TRAILING))
  172. 		{
  173. 			var isLeading = textAlign == TA.LEADING;
  174. 			switch (textDirection)
  175. 			{
  176. 				case TD.RTL: result = isLeading? TA.RIGHT: TA.LEFT; break;
  177. 				case TD.TTB: result = isLeading? TA.TOP: TA.BOTTOM; break;
  178. 				case TD.BTT: result = isLeading? TA.BOTTOM: TA.TOP; break;
  179. 				case TD.LTR:
  180. 				default:
  181. 					result = isLeading? TA.LEFT: TA.RIGHT; break;
  182. 			}
  183. 		}
  184. 		return result;
  185. 	}
  186. };
  188. /**
  189.  * Enumeration of alignment types of box in horizontal direction.
  190.  * @enum
  191.  */
  192. Kekule.Render.BoxXAlignment = {
  193. 	LEFT: 0,
  194. 	RIGHT: 1,
  195. 	CENTER: 2
  196. };
  197. /**
  198.  * Enumeration of alignment types of box in vertical direction.
  199.  * @enum
  200.  */
  201. Kekule.Render.BoxYAlignment = {
  202. 	TOP: 0,
  203. 	BOTTOM: 1,
  204. 	CENTER: 2
  205. };
  207. /**
  208.  * Enumeration of alignment mode of a rich text box.
  209.  * @enum
  210.  */
  211. Kekule.Render.TextBoxAlignmentMode = {
  212. 	/** Alignment based on the whole text box */
  213. 	BOX: 0,
  214. 	/** Alignment based on the childmost anchor item of rich text */
  215. 	ANCHOR: 1
  216. };
  218. /**
  219.  * Enumeration of types of rendering a bond line.
  220.  * @enum
  221.  */
  222. Kekule.Render.BondRenderType = {
  223. 	/** Usual single bond, draw in a thin line */
  224. 	SINGLE: 0,
  225. 	/** Usual double bond, draw in thin double line */
  226. 	DOUBLE: 1,
  227. 	/** Usual triple bond, draw in thin triple line */
  228. 	TRIPLE: 2,
  229. 	/* Usual quad bond, draw in thin quad line */
  230. 	QUAD: 3,
  231. 	/** Dashed bond line */
  232. 	DASHED: 4,
  233. 	/** Dashed double line */
  234. 	DASHED_DOUBLE: 5,
  235. 	/** Dashed triple line */
  236. 	DASHED_TRIPLE: 6,
  237. 	/** A sold and a dashed line, usually used for aromatic bond */
  238. 	SOLID_DASH: 7,
  239. 	/** A line with a arrow in the end, usually for coordinate-bond */
  240. 	ARROWED: 8,
  241. 	/** A line with a arrow in the head, usually for coordinate-bond */
  242. 	ARROWED_INV: 9,
  243. 	/** A hashed line */
  244. 	HASHED: 10,
  245. 	/** A bold line, usually for bond above paper */
  246. 	BOLD: 11,
  247. 	/** A bold and a normal line, usually for double bond above paper */
  248. 	BOLD_DOUBLE: 12,
  249. 	/** A bold and two normal line, usually for triple bond above paper */
  250. 	BOLD_TRIPLE: 13,
  251. 	/* A bold and three normal line, usually for quad bond above paper */
  252. 	BOLD_QUAD: 14,
  253. 	/** A bold and a dash line, usually for aromatic bond above paper */
  254. 	BOLD_DASH: 16,
  255. 	/** A solid wedge triangle from atom 1 to atom 2, usually for wedge up bond */
  256. 	WEDGED_SOLID: 20,
  257. 	/** A solid wedge triangle from atom 2 to atom 1, usually for wedge up bond */
  258. 	WEDGED_SOLID_INV: 21,
  259. 	/** A hollow wedge triangle from atom 1 to atom 2,  usually for wedge up bond */
  260. 	WEDGED_HOLLOW: 22,
  261. 	/** A hollow wedge triangle from atom 2 to atom 1, usually for wedge up bond */
  262. 	WEDGED_HOLLOW_INV: 23,
  263. 	/** A hased wedge triangle from atom 1 to atom 2, usually for wedge down bond */
  264. 	WEDGED_HASHED: 24,
  265. 	/** A hased wedge triangle from atom 2 to atom 1, usually for wedge down bond */
  266. 	WEDGED_HASHED_INV: 25,
  267. 	/** A bold rectangle, indicating a bond near the observer. Usually connected with wedged bonds. */
  268. 	WEDGED_SOLID_BOTH: 26,
  269. 	/** A bold hollow rectangle, indicating a bond near the observer. Usually connected with wedged bonds. */
  270. 	WEDGED_HOLLOW_BOTH: 27,
  271. 	/** A wavy line, usually used for bond with uncertain stereo */
  272. 	WAVY: 30,
  273. 	/** A cross double bond, means an uncertain E or Z stereo */
  274. 	SCISSORS_DOUBLE: 40
  275. };
  278. /**
  279.  * Enumeration of types to render a charge on atom.
  280.  * @enum
  281.  */
  282. Kekule.Render.ChargeMarkRenderType = {
  283. 	/** Number + symbol, such as 2+, 3- */
  284. 	NUM_WITH_SYMBOL: 1,
  285. 	DEFAULT: 1,
  286. 	/** Only symbol, such as ++, = */
  287. 	//SYMBOL_ONLY: 2,
  288. 	/** Surrond with a circle to emphasis, the circle will only be draw when charge = +1/-1 */
  289. 	CIRCLE_AROUND: 3
  290. };
  292. /**
  293.  * Enumeration of graphic quality levels to render objects in 3D.
  294.  * @enum
  295.  */
  296. Kekule.Render.Render3DGraphicQuality = {
  297. 	EXTREME_LOW: 1,
  298. 	LOW: 2,
  299. 	MEDIUM: 3,
  300. 	HIGH: 4,
  301. 	EXTREME_HIGH: 5
  302. };
  304. /**
  305.  * Enumeration of types to render a molecule in 3D.
  306.  * @enum
  307.  */
  308. Kekule.Render.Molecule3DDisplayType = {
  309. 	/** Wire frame */
  310. 	WIRE: 31,
  311. 	/** Sticks */
  312. 	STICKS: 32,
  313. 	/** Ball and stick */
  314. 	BALL_STICK: 33,
  315. 	/** Space fill */
  316. 	SPACE_FILL: 34,
  317. 	/** Default is ball and stick */
  318. 	DEFAULT: 33
  319. };
  321. /**
  322.  * Enumeration of types to render a bond in 3D.
  323.  * @enum
  324.  */
  325. Kekule.Render.Bond3DRenderMode = {
  326. 	/** do not render bond. */
  327. 	NONE: 0,
  328. 	/** One wire is used to represent one bond (multiple or not). */
  329. 	WIRE: 1,
  330. 	/** Multiple wires are used for multiple bond. */
  331. 	MULTI_WIRE: 2,
  332. 	/** One cylinder is used to represent one bond (multiple or not). */
  333. 	CYLINDER: 3,
  334. 	/** Use multiple cylinders for multiple bond. */
  335. 	MULTI_CYLINDER: 4,
  336. 	/**
  337. 	 * Check if connector / bond should be draw in lines.
  338. 	 * @param {Int} mode
  339. 	 * @returns {Bool}
  340. 	 */
  341. 	isWireMode: function(mode)
  342. 	{
  343. 		var M = Kekule.Render.Bond3DRenderMode;
  344. 		return (mode === M.WIRE) || (mode === M.MULTI_WIRE);
  345. 	},
  346. 	/**
  347. 	 * Check if connector / bond should be draw in cylinders.
  348. 	 * @param {Int} mode
  349. 	 * @returns {Bool}
  350. 	 */
  351. 	isCylinderMode: function(mode)
  352. 	{
  353. 		var M = Kekule.Render.Bond3DRenderMode;
  354. 		return (mode === M.CYLINDER) || (mode === M.MULTI_CYLINDER);
  355. 	}
  356. };
  358. /**
  359.  * Enumeration of types to decide how a bond is splitted in 3D render.
  360.  * @enum
  361.  */
  362. Kekule.Render.Bond3DSpliceMode = {
  363. 	/** Bond draw as a whole, not split. */
  364. 	UNSPLIT: 1,
  365. 	/** Split from the middle, as two line with the same length. */
  366. 	MID_SPLIT: 2,
  367. 	/** Split, a biger atom gains biger part of bond */
  368. 	WEIGHTING_SPLIT: 3
  369. };
  371. /**
  372.  * Enumeration of types to draw a connector (bond) in 3D render.
  373.  * @enum
  374.  */
  375. Kekule.Render.Bond3DRenderType = {
  376. 	/** Just one line or cylinder, used for most bonds. */
  377. 	SINGLE: 1,
  378. 	/** Double lines or cylinders, used for double bond. */
  379. 	DOUBLE: 2,
  380. 	/** Triple lines or cylinders, used for triple bond. */
  381. 	TRIPLE: 3,
  382. 	/** Dash line or cylinder, usually used for H-bond. */
  383. 	DASH: -1,
  384. 	/** One solid and a dash line or cylinder, used for aromatic bond. */
  385. 	SOLID_DASH: -2
  386. };
  389. /**
  390.  * Enumeration of types to draw a node (atom) in 3D render.
  391.  * @enum
  392.  */
  393. Kekule.Render.Node3DRenderMode = {
  394. 	/** Do not render explicit atom, used in WIRE display mode. */
  395. 	NONE: 0,
  396. 	/** Render atom as ball, used in BALL_STICK display mode. */
  397. 	BALL: 1,
  398. 	/** Render atom as a huge ball, according to Vdw radius, used in SPACE_FILL display mode. */
  399. 	SPACE: 2
  400. 	///** Render as small ball at the end of bond, used in STICKS display mode */
  401. 	//SMALL_CAP: 3
  402. };
  404. /**
  405.  * Enumeration of shape types to describle meta shape info.
  406.  * @enum
  407.  */
  408. Kekule.Render.MetaShapeType = {
  409. 	// 2D shapes
  410. 	/** A single point on context. Can be determinated by a single coord ({[coord]}). */
  411. 	POINT: 0,
  412. 	/** A circle on context. Can be determinated by a single coord and a radius. ({[coord], radius}) */
  413. 	CIRCLE: 1,
  414. 	/** A line on context, determinated by two coords and a width property ({[coord1, coord2], width). */
  415. 	LINE: 2,
  416. 	/** A rectangle on context, determinated by two coords ({[coord1, coord2]}). */
  417. 	RECT: 3,
  418. 	/** An arc  on context, determinated by a single coord and radius, startAngle, endAngle, anticlockwise. */
  419. 	ARC: 5,
  420. 	/** Unclosed polyline, determinated by a set of coords ({[coord1, coord2, coord3, ... }). */
  421. 	POLYLINE: 11,
  422. 	/** Polygon, determinated by a set of coords ({[coord1, coord2, coord3, ... }). */
  423. 	POLYGON: 10,
  424. 	// 3D shapes
  425. 	/** A shpere on 3D context. Can be determinated by a single coord and a radius. ({[coord], radius}) */
  426. 	SPHERE: 101,
  427. 	/** Cylinder in 3D context. Can be determinated by two coords and a radius. ({[coord1, coord2], radius}) */
  428. 	CYLINDER: 102,
  429. 	/**
  430. 	 * A complex shape composited of a series of child shapes.
  431. 	 * In implementation, an array of meta shapes will map to this type.
  432. 	 */
  433. 	COMPOSITE: -1
  434. };
  435. // Alias of MetaShapeType
  436. Kekule.Render.BoundShapeType = Kekule.Render.MetaShapeType;
  438. /**
  439.  * Enumeration of types of updating a object.
  440.  * @enum
  441.  */
  442. Kekule.Render.ObjectUpdateType = {
  443. 	/** Modify a existing object. */
  444. 	MODIFY: 0,
  445. 	/** Add a new object. */
  446. 	ADD: 1,
  447. 	/** Remove a existing object. */
  448. 	REMOVE: 2,
  449. 	/** Clear whole object. */
  450. 	CLEAR: 3
  451. };
  453. /**
  454.  * Base class for different types of concrete renderers.
  455.  * @class
  456.  * @augments ObjectEx
  457.  * @param {Kekule.ChemObject} chemObj Object to be drawn.
  458.  * @param {Object} drawBridge Concrete draw bridge to do the actual draw job.
  459.  * //@param {Object} renderConfigs Configuration for rendering.
  460.  * //  This property should be an instance of {@link Kekule.Render.Render2DConfigs} or {@link Kekule.Render.Render3DConfigs}.
  461.  * @param {Kekule.ObjectEx} parent Parent object of this renderer, usually another renderer or an instance of {@link Kekule.Render.ChemObjPainter}, or null.
  462.  *
  463.  * @property {Kekule.ChemObject} chemObj Object to be drawn, read only.
  464.  * @property {Object} drawBridge Concrete draw bridge to do the actual draw job.
  465.  * //@property {Object} renderConfigs Configuration for rendering.
  466.  * //  This property should be an instance of {@link Kekule.Render.Render2DConfigs} or {@link Kekule.Render.Render3DConfigs}
  467.  * //@property {Object} renderCache Stores params (center coord, options, matrix...) on last draw process.
  468.  * @property {Kekule.ObjectEx} parent Parent object of this renderer, usually another renderer or an instance of {@link Kekule.Render.ChemObjPainter}.
  469.  * @property {Kekule.Render.AbstractRenderer} parentRenderer Parent renderer that calls this one.
  470.  *
  471.  * @property {Bool} canModifyTargetObj If set to true, renderer may change the rendered object (e.g., add charge markers, change block sizes...).
  472.  *   This property can inherit value from parent.
  473.  * @property {Object} redirectContext If this property is set, renderer will draw on this one instead if the context in drawXXX methods.
  474.  *   This property is used by editor. User should utilize this property with caution.
  475.  */
  476. /**
  477.  * Invoked when a basic object (node, connector, glyph...) is drawn, updated or removed.
  478.  *   event param of it has fields: {obj, parentObj, boundInfo, updateType}
  479.  *   where boundInfo provides the bound box information of this object on context. It has the following fields:
  480.  *   {
  481.  *     context: drawing context object
  482.  *     obj: drawn object
  483.  *     parentObj: parent of drawn object
  484.  *     boundInfo: a hash containing info of bound, including fields:
  485.  *     {
  486. 	 *     shapeType: value from {@link Kekule.Render.MetaShapeType} or {@link Kekule.Render.Meta3DShapeType}.
  487. 	 *     coords: [Array of coords]
  488. 	 *   }
  489.  *     updateType: add, modify or remove
  490.  *   }
  491.  *   boundInfo may also be a array for complex situation (such as multicenter bond): [boundInfo1, boundInfo2, boundInfo3...].
  492.  *   Note that in removed event, boundInfo may be null.
  493.  * @name Kekule.Render.AbstractRenderer#updateBasicDrawObject
  494.  * @event
  495.  */
  496. /**
  497.  * Invoked when whole chem object (molecule, reaction...) is prepared to be drawn in context.
  498.  *   event param of it has two fields: {context, obj}
  499.  * @name Kekule.Render.AbstractRenderer#prepareDrawing
  500.  * @event
  501.  */
  502. /**
  503.  * Invoked when whole chem object (molecule, reaction...) is drawn in context.
  504.  *   event param of it has two fields: {context, obj}
  505.  * @name Kekule.Render.AbstractRenderer#draw
  506.  * @event
  507.  */
  508. /**
  509.  * Invoked when whole chem object (molecule, reaction...) is cleared from context.
  510.  *   event param of it has two fields: {context, obj}
  511.  * NOTE: this event is not well implemented and may be buggy.
  512.  * @name Kekule.Render.AbstractRenderer#clear
  513.  * @event
  514.  */
  515. Kekule.Render.AbstractRenderer = Class.create(ObjectEx,
  516. /** @lends Kekule.Render.AbstractRenderer# */
  517. {
  518. 	/** @private */
  519. 	CLASS_NAME: 'Kekule.Render.AbstractRenderer',
  520. 	/** @private */
  521. 	RENDER_CACHE_FIELD: '__$renderCache$__',
  522. 	/** @constructs */
  523. 	initialize: function($super, chemObj, drawBridge, /*renderConfigs,*/ parent)
  524. 	{
  525. 		$super();
  526. 		this.setPropValue('chemObj', chemObj, true); // since we have no setChemObj method, use this instead
  527. 		/*
  528. 		if (renderConfigs)
  529. 			this.setRenderConfigs(renderConfigs);
  530. 		*/
  531. 		if (parent)
  532. 			this.setParent(parent);
  533. 		this.setDrawBridge(drawBridge);
  535. 		this.setBubbleEvent(true);  // allow event bubble
  537. 		this._suspendUpdateStatus = 0;  // used internal
  538. 		this._suspendUpdateInfos = [];
  539. 	},
  540. 	finalize: function($super)
  541. 	{
  542. 		//console.log('release renderer', this.getClassName());
  543. 		this.setPropValue('chemObj', null, true);
  544. 		this.setDrawBridge(null);
  545. 		$super();
  546. 	},
  547. 	/** @private */
  548. 	initProperties: function()
  549. 	{
  550. 		this.defineProp('chemObj', {'dataType': 'Kekule.ChemObject', 'serializable': false, 'setter': null});  // readonly
  551. 		/*
  552. 		this.defineProp('baseCoord', {'dataType': DataType.HASH, 'serializable': false,
  553. 			'getter': function()
  554. 			{
  555. 				var result = this.getPropStoreFieldValue('baseCoord');
  556. 				if (!result)
  557. 					result = this.getAutoBaseCoord();
  558. 				return result;
  559. 			}
  560. 		});
  561. 		*/
  562. 		this.defineProp('drawBridge', {'dataType': DataType.OBJECT, 'serializable': false});
  563. 		//this.defineProp('renderConfigs', {'dataType': DataType.OBJECT, 'serializable': false});
  564. 		//this.defineProp('renderCache', {'dataType': DataType.OBJECT, 'serializable': false});
  565. 		this.defineProp('parent', {'dateType': DataType.OBJECT, 'serializable': false});
  566. 		this.defineProp('parentRenderer',
  567. 			{
  568. 				'dateType': 'Kekule.Render.AbstractRenderer', 'serializable': false,
  569. 				'getter': function()
  570. 					{
  571. 						var p = this.getParent();
  572. 						return (p instanceof Kekule.Render.AbstractRenderer)? p: null;
  573. 					},
  574. 				'setter': function(value)
  575. 					{
  576. 						this.setParent(value);
  577. 					}
  578. 			});
  580. 		this.defineProp('redirectContext', {'dataType': DataType.OBJECT, 'serializable': false});
  581. 		this.defineProp('canModifyTargetObj', {'dataType': DataType.BOOL, 'serializable': false,
  582. 			'getter': function()
  583. 			{
  584. 				var result = this.getPropStoreFieldValue('canModifyTargetObj');
  585. 				if (Kekule.ObjUtils.isUnset(result))
  586. 				{
  587. 					var p = this.getParent();
  588. 					if (p && p.getCanModifyTargetObj)
  589. 						result = p.getCanModifyTargetObj();
  590. 				}
  591. 				return result;
  592. 			}
  593. 		});
  595. 		this.defineEvent('clear');
  596. 		this.defineEvent('updateBasicDrawObject');
  597. 	},
  599. 	/**
  600. 	 * Check if current renderer is the topmost one (without parent renderer, but maybe has parent painter).
  601. 	 */
  602. 	isRootRenderer: function()
  603. 	{
  604. 		return !this.getParentRenderer();
  605. 	},
  607. 	/** @private */
  608. 	getHigherLevelObj: function()
  609. 	{
  610. 		return this.getParent();
  611. 	},
  613. 	/**
  614. 	 * Report the type (2D or 3D) of this renderer.
  615. 	 * @returns {Int} Value from {@link Kekule.Render.RendererType}.
  616. 	 */
  617. 	getRendererType: function()
  618. 	{
  619. 		return Kekule.Render.RendererType.R2D;  // default is 2D renderer
  620. 	},
  621. 	/**
  622. 	 * Report coord mode of this renderer.
  623. 	 * @returns {Int} Value from {@link Kekule.CoordMode}.
  624. 	 */
  625. 	getCoordMode: function()
  626. 	{
  627. 		var rType = this.getRendererType();
  628. 		return (rType === Kekule.Render.RendererType.R3D)? Kekule.CoordMode.COORD3D: Kekule.CoordMode.COORD2D;
  629. 	},
  631. 	/**
  632. 	 * Returns draw params (center coord, options, matrix...) on last draw process on context.
  633. 	 * @returns {Hash}
  634. 	 */
  635. 	getRenderCache: function(context)
  636. 	{
  637. 		var result = this.getExtraProp(context, this.RENDER_CACHE_FIELD);
  638. 		if (!result)
  639. 		{
  640. 			result = {};
  641. 			this.setExtraProp(context, this.RENDER_CACHE_FIELD, result);
  642. 		}
  643. 		return result;
  644. 		/*
  645. 		var result = this._cache; //[this.RENDER_CACHE_FIELD];
  646. 		if (!result)
  647. 		{
  648. 			this._cache = {'field': 'value'};
  649. 			result = this._cache;
  650. 			console.log('initial render cache', this.getClassName());
  651. 		}
  652. 		return result;
  653. 		*/
  654. 	},
  656. 	/**
  657. 	 * A method that will be called before draw().
  658. 	 * Some preparation job can be done here.
  659. 	 * Note that only the root renderer will call this method.
  660. 	 * @private
  661. 	 */
  662. 	beginDraw: function(context, baseCoord, options)
  663. 	{
  664. 		var b = this.getDrawBridge();
  665. 		if (b.prepareContext)
  666. 			b.prepareContext(context);
  667. 	},
  668. 	/**
  669. 	 * A method that will be called after draw().
  670. 	 * Note that only the root renderer will call this method.
  671. 	 * @private
  672. 	 */
  673. 	endDraw: function(context, baseCoord, options)
  674. 	{
  675. 		// some draw bridge (such as Three.js need to call render method to do actual draw job.
  676. 		var b = this.getDrawBridge();
  677. 		if (b.renderContext)
  678. 			b.renderContext(context);
  679. 	},
  681. 	/** @private */
  682. 	updateDrawInfoInCache: function(chemObj, context, baseCoord, options, realDrawOptions)
  683. 	{
  684. 		var p = this.getRenderCache(context);
  685. 		if (context)
  686. 			p.context = context;
  687. 		if (baseCoord)
  688. 			p.baseCoord = baseCoord;
  689. 		if (chemObj)
  690. 			p.chemObj = chemObj;
  691. 		if (options)
  692. 			p.options = options;
  693. 		if (realDrawOptions)
  694. 			p.realDrawOptions = realDrawOptions;
  695. 	},
  697. 	/** @private */
  698. 	_isCurrChemObjNeedToBeDrawn: function(partialDrawObjs, context)
  699. 	{
  700. 		var selfObj = this.getChemObj();
  701. 		for (var i = 0, l = partialDrawObjs.length; i < l; ++i)
  702. 		{
  703. 			var obj = partialDrawObjs[i];
  704. 			if ((obj === selfObj) || (obj.isChildOf(selfObj)))
  705. 				return true;
  706. 		}
  707. 		return false;
  708. 	},
  710. 	/**
  711. 	 * Auto calculate draw context coord by coord of chem obj. When no baseCoord is provided in draw method,
  712. 	 * this result may be used instead.
  713. 	 * @param {Hash} drawOptions
  714. 	 * @returns {Hash}
  715. 	 */
  716. 	getAutoBaseCoord: function(drawOptions)
  717. 	{
  718. 		return this.doGetAutoBaseCoord(drawOptions);
  719. 	},
  720. 	/**
  721. 	 * Do actual work of getAutoBaseCoord.
  722. 	 * Descendants need to override this method.
  723. 	 * @param {Hash} drawOptions
  724. 	 * @returns {Hash}
  725. 	 * @private
  726. 	 */
  727. 	doGetAutoBaseCoord: function(drawOptions)
  728. 	{
  729. 		return null;
  730. 	},
  732. 	/** @ignore */
  733. 	getCachedDrawOptions: function(context)
  734. 	{
  735. 		return this.getRenderCache(context).options;
  736. 	},
  737. 	/** @ignore */
  738. 	getCachedDrawnElem: function(context)
  739. 	{
  740. 		return this.getRenderCache(context).drawnElem;
  741. 	},
  743. 	/**
  744. 	 * Draw an instance of ChemObject to context.
  745. 	 * The actual job is done in doDraw method. Descendants should override doDraw.
  746. 	 * @param {Object} context Context to be drawn, such as Canvas, SVG, VML and so on.
  747. 	 * @param {Hash} baseCoord Base coord to draw this object, can be null to use coord of chemObj itself.
  748. 	 *   This coord is based on context.
  749. 	 * @param {Hash} options Draw options, such as draw rectangle, draw style, zoom and so on.
  750. 	 *   Different renderer may requires different option params.
  751. 	 *   In options hash object, there may be one special array field: partialDrawObjs. If this field is set,
  752. 	 *   then only chem objects in this array will be actually drawn.
  753. 	 * @returns {Object} Drawn element on context (such as SVG) or null on direct context (such as canvas).
  754. 	 */
  755. 	draw: function(context, baseCoord, options)
  756. 	{
  757. 		//console.log('[Draw]', this.getClassName(), this.getChemObj().getId? this.getChemObj().getId(): null);
  758. 		/*
  759. 		var p = this.getRenderCache(context);
  760. 		p.context = context;
  761. 		p.baseCoord = baseCoord;
  762. 		p.chemObj = this.getChemObj();
  763. 		*/
  765. 		//console.log('baseDraw', baseCoord, p);
  766. 		//this.updateDrawInfoInCache(this.getChemObj(), context, baseCoord, options);
  767. 		try
  768. 		{
  769. 			this.__isDrawing = true;  // flag avoid duplicated draw
  770. 			var ops = {};
  771. 			// actual draw options should also inherited from parent renderer
  772. 			var parentOps;
  773. 			var parent = this.getParentRenderer();
  774. 			if (parent)
  775. 			{
  776. 				var parentOps = parent.getRenderCache().options;
  777. 				//console.log('parent', this.getClassName(), parentOps);
  778. 				/*
  779. 				 if (parentOps)
  780. 				 ops = Object.create(parentOps);
  781. 				 */
  782. 			}
  783. 			if (parentOps)
  784. 			{
  785. 				ops = Object.create(parentOps);
  786. 				ops = Object.extend(ops, options);  // self options should override parent one
  787. 			}
  788. 			else
  789. 				ops = Object.create(options || null);
  791. 			var chemObj = this.getChemObj();
  793. 			var partialDrawObjs = ops.partialDrawObjs;
  795. 			/*
  796. 			 if ((this instanceof Kekule.Render.Ctab2DRenderer))
  797. 			 console.log(this.getClassName(), partialDrawObjs, !partialDrawObjs || this._isCurrChemObjNeedToBeDrawn(partialDrawObjs, context));
  798. 			 */
  800. 			if (partialDrawObjs && (!this._isCurrChemObjNeedToBeDrawn(partialDrawObjs, context)))
  801. 			{
  802. 				//console.log('no need partial draw', this.getClassName(), chemObj, partialDrawObjs);
  803. 				return null;
  804. 			}
  805. 			/*
  806. 			 else if (partialDrawObjs)
  807. 			 console.log('partial draw objects', this.getClassName(), partialDrawObjs);
  808. 			 */
  809. 			//p.options = ops;
  811. 			var renderOptionsGetter = (this.getRendererType() === Kekule.Render.RendererType.R3D) ?
  812. 					'getRender3DOptions' : 'getRenderOptions';
  813. 			var localOps = chemObj[renderOptionsGetter] ? chemObj[renderOptionsGetter]() : null;
  815. 			renderOptionsGetter = (this.getRendererType() === Kekule.Render.RendererType.R3D) ?
  816. 					'getOverriddenRender3DOptions' : 'getOverriddenRenderOptions';
  817. 			var localOverrideOps = chemObj[renderOptionsGetter] ? chemObj[renderOptionsGetter]() : null;
  819. 			ops = Kekule.Render.RenderOptionUtils.mergeRenderOptions(localOps || {}, ops);
  820. 			this.getRenderCache().options = ops;
  821. 			ops = Kekule.Render.RenderOptionUtils.mergeRenderOptions(localOverrideOps || {}, ops);
  822. 			//console.log('draw ops', this.getClassName(), localOps, ops);
  824. 			this.updateDrawInfoInCache(this.getChemObj(), context, baseCoord, options, ops);
  826. 			var isRoot = this.isRootRenderer();
  828. 			this.invokeEvent('prepareDrawing', {'context': context, 'obj': this.getChemObj()});
  830. 			//console.log('DRAW', isRoot);
  831. 			if (isRoot)
  832. 				this.beginDraw(context, baseCoord, ops);
  834. 			var result = this.doDraw(context, baseCoord, ops);
  835. 			this.getRenderCache(context).drawnElem = result;
  836. 			if (isRoot)
  837. 				this.endDraw(context, baseCoord, ops);
  839. 			this.invokeEvent('draw', {'context': context, 'obj': this.getChemObj()});
  840. 		}
  841. 		finally
  842. 		{
  843. 			this.__isDrawing = false;
  844. 		}
  846. 		return result;
  847. 	},
  848. 	/**
  849. 	 * Do actual work of {@link Kekule.Render.AbstractRenderer.draw}.
  850. 	 * @param {Object} context Context to be drawn, such as Canvas, SVG, VML and so on.
  851. 	 * @param {Hash} baseCoord Coord on context to draw the center of chemObj.
  852. 	 * @param {Hash} options Actual draw options, such as draw rectangle, draw style and so on.
  853. 	 * @returns {Object} Drawn element on context (such as SVG) or null on direct context (such as canvas).
  854. 	 * @private
  855. 	 */
  856. 	doDraw: function(context, baseCoord, options)
  857. 	{
  858. 		// do nothing here
  859. 		return this.doDrawSelf(context, baseCoord, options);
  860. 	},
  861. 	/**
  862. 	 * Do actual work of draw self object (without children).
  863. 	 * @param {Object} context Context to be drawn, such as Canvas, SVG, VML and so on.
  864. 	 * @param {Hash} baseCoord Coord on context to draw the center of chemObj.
  865. 	 * @param {Hash} options Actual draw options, such as draw rectangle, draw style and so on.
  866. 	 * @returns {Object} Drawn element on context (such as SVG) or null on direct context (such as canvas).
  867. 	 * @private
  868. 	 */
  869. 	doDrawSelf: function(context, baseCoord, options)
  870. 	{
  871. 		// do nothing here
  872. 		return null;
  873. 	},
  874. 	/**
  875. 	 * Redraw previous object on context with same draw options. Should not be called before draw.
  876. 	 * @param {Object} context
  877. 	 */
  878. 	redraw: function(context)
  879. 	{
  880. 		var isRoot = this.isRootRenderer();
  882. 		//console.log('[Redraw]', isRoot, this.getClassName(), this.getChemObj().getId? this.getChemObj().getId(): null);
  883. 		//console.log('REDRAW', this.getClassName(), isRoot);
  884. 		if (isRoot)
  885. 		{
  886. 			var cache = this.getRenderCache(context) || {};
  887. 			this.beginDraw(context, cache.baseCoord, cache.options);
  888. 		}
  889. 		var result = this.doRedraw(context);
  890. 		this.getRenderCache(context).drawnElem = result;
  891. 		if (isRoot)
  892. 			this.endDraw(context, cache.baseCoord, cache.options);
  893. 		return result;
  894. 	},
  895. 	/**
  896. 	 * Do actual work of {@link Kekule.Render.AbstractRenderer.redraw}. Descendants may override this method.
  897. 	 * @param {Object} context
  898. 	 * @private
  899. 	 */
  900. 	doRedraw: function(context)
  901. 	{
  902. 		// A default implementation. Descendants can override this to provide a more efficient one.
  903. 		var p = this.getRenderCache(context);
  904. 		//this.clear(context);
  905. 		//return this.doDraw(context, p.baseCoord, p.realDrawOptions);
  906. 		return this.draw(context, p.baseCoord, p.options);
  907. 	},
  909. 	/**
  910. 	 * Whether current renderer can modify elements drawn on context.
  911. 	 * @param {Object} context
  912. 	 * @returns {Bool}
  913. 	 */
  914. 	canModifyGraphic: function(context)
  915. 	{
  916. 		var b = this.getDrawBridge();
  917. 		return b.canModifyGraphic? b.canModifyGraphic(context): false;
  918. 	},
  920. 	/**
  921. 	 * Call this method before a series of rendered element updating job (for instance, call update method)
  922. 	 * to avoid unnecessary redraw.
  923. 	 */
  924. 	beginUpdateRenderer: function()
  925. 	{
  926. 		++this._suspendUpdateStatus;
  927. 	},
  928. 	/**
  929. 	 * Call this method after a series of rendered element updateing job,
  930. 	 * notify the renderer to redraw the context.
  931. 	 */
  932. 	endUpdateRenderer: function()
  933. 	{
  934. 		--this._suspendUpdateStatus;
  935. 		if (this._suspendUpdateStatus <= 0)
  936. 			this._suspendUpdateStatus = 0;
  937. 		if (!this.isUpdatingRenderer())
  938. 		{
  939. 			this.doEndUpdateRenderer();
  940. 		}
  941. 	},
  942. 	/** @private */
  943. 	doEndUpdateRenderer: function()
  944. 	{
  945. 		this.updateEx(this._suspendUpdateInfos);
  946. 		this._suspendUpdateInfos = [];
  947. 	},
  948. 	/**
  949. 	 * Check if beginUpdateRenderer is called and endUpdateRenderer is not called yet.
  950. 	 * @returns {Bool}
  951. 	 */
  952. 	isUpdatingRenderer: function()
  953. 	{
  954. 		return this._suspendUpdateStatus > 0;
  955. 	},
  957. 	/**
  958. 	 * Do a update job according to info provided by updateItems. Must be called after draw.
  959. 	 * @param {Array} updateInfos Each item has format: {context, items: [{updateType, updatedObjDetails: [{obj, propNames}]}]}
  960. 	 * @returns {Bool}
  961. 	 */
  962. 	updateEx: function(updateInfos)
  963. 	{
  964. 		var canModify;
  965. 		var result = true;
  966. 		if (!this.isUpdatingRenderer())
  967. 		{
  968. 			canModify = this.canModifyGraphic(context);
  969. 			if (canModify)
  970. 			{
  971. 				//result = this.doUpdate(context, updatedObjs, updateType);
  972. 				for (var i = 0, l = updateInfos.length; i < l; ++i)
  973. 				{
  974. 					var info = updateInfos[i];
  975. 					var context = info.context;
  976. 					for (var j = 0, k = info.items.length; j < k; ++j)
  977. 					{
  978. 						var item = info.items[j];
  979. 						result = result && this.doUpdate(context, item.updatedObjDetails, item.updateType);
  980. 						if (!result)  // update individual failed
  981. 							break;
  982. 					}
  983. 					if (!result)
  984. 						break;
  985. 				}
  986. 			}
  987. 			//if (!result)  // can not update by self, call parent or repaint the whole context
  988. 			else  // can not modify graphic, call parent to update the whole context
  989. 			{
  990. 				var isRoot = this.isRootRenderer();
  991. 				if (isRoot)
  992. 				{
  993. 					//console.log('update root', this.getClassName());
  994. 					var contexts = [];
  995. 					for (var i = 0, l = updateInfos.length; i < l; ++i)
  996. 					{
  997. 						var info = updateInfos[i];
  998. 						var context = info.context;
  999. 						Kekule.ArrayUtils.pushUnique(contexts, context);
  1000. 					}
  1001. 					for (var i = 0, l = contexts.length; i < l; ++i)
  1002. 					{
  1003. 						this.getDrawBridge().clearContext(context);
  1004. 						var cache = this.getRenderCache(context);
  1005. 						//console.log('draw root once', this.getClassName());
  1006. 						this.draw(context, cache.baseCoord, cache.options);
  1007. 					}
  1008. 					return true;
  1009. 				}
  1010. 				else
  1011. 				{
  1012. 					var p = this.getParentRenderer();
  1013. 					return p.updateEx(updateInfos);
  1014. 				}
  1015. 			}
  1016. 			return result;
  1017. 		}
  1018. 		else // updating, suspend
  1019. 		{
  1020. 			if (!this._suspendUpdateInfos)
  1021. 				this._suspendUpdateInfos = [];
  1022. 			this._mergeRendererUpdateInfo(this._suspendUpdateInfos, updateInfos);
  1023. 			return true;
  1024. 		}
  1025. 	},
  1026. 	/**
  1027. 	 * Merge src into dest
  1028. 	 * @private
  1029. 	 */
  1030. 	_mergeRendererUpdateInfo: function(dest, src)
  1031. 	{
  1032. 		for (var i = 0, l = src.length; i < l; ++i)
  1033. 		{
  1034. 			var info = src[i];
  1035. 			var index = this._indexOfContextInRendererUpdateInfos(info.context, dest);
  1036. 			if (index < 0)
  1037. 				dest.push(info);
  1038. 			else
  1039. 			{
  1040. 				var old = dest[index];
  1041. 				// TODO: updateType not yet merged
  1042. 				old.items = old.items.concat(info.items);
  1043. 			}
  1044. 		}
  1045. 		return dest;
  1046. 	},
  1047. 	/** @private */
  1048. 	_indexOfContextInRendererUpdateInfos: function(context, infos)
  1049. 	{
  1050. 		for (var i = 0, l = infos.length; i < l; ++i)
  1051. 		{
  1052. 			var info = infos[i];
  1053. 			if (info.context === context)
  1054. 				return i;
  1055. 		}
  1056. 		return -1;
  1057. 	},
  1059. 	/**
  1060. 	 * Update a child object inside chemObj. Must be called after draw.
  1061. 	 * @param {Object} context
  1062. 	 * @param {Variant} updatedObjDetails Object detail containing field {obj, propNames} or array of details.
  1063. 	 * @param {Int} updateType Value from {@link Kekule.Render.ObjectUpdateType}
  1064. 	 * @returns {Bool}
  1065. 	 */
  1066. 	update: function(context, updatedObjDetails, updateType)
  1067. 	{
  1068. 		/*
  1069. 		var result = false;
  1070. 		if (this.canModifyGraphic(context))
  1071. 		{
  1072. 			result = this.doUpdate(context, updatedObjs, updateType);
  1073. 		}
  1074. 		if (!result)  // can not update by self, call parent or repaint the whole context
  1075. 		{
  1076. 			if (this.isRootRenderer())
  1077. 			{
  1078. 				this.getDrawBridge().clearContext(context);
  1079. 				var cache = this.getRenderCache(context);
  1080. 				this.draw(context, cache.baseCoord, cache.options);
  1081. 				return true;
  1082. 			}
  1083. 			else
  1084. 			{
  1085. 				var p = this.getParentRenderer();
  1086. 				return p.update(context, updatedObjs, updateType);
  1087. 			}
  1088. 		}
  1089. 		return result;
  1090. 		*/
  1091. 		var objDetails = [];
  1092. 		for (var i = 0, l = updatedObjDetails.length; i < l; ++i)
  1093. 		{
  1094. 			var obj = updatedObjDetails[i].obj;
  1095. 			if (this.isChemObjRenderedBySelf(context, obj))
  1096. 				objDetails.push(updatedObjDetails[i]);
  1097. 		}
  1098. 		if (objDetails.length)
  1099. 			return this.updateEx([{'context': context, items: [{'updateType': updateType, 'updatedObjDetails': objDetails/*updatedObjs*/}]}]);
  1100. 		else
  1101. 			return true;
  1102. 	},
  1103. 	/**
  1104. 	 * Do actual work of update. Descendants may override this.
  1105. 	 * @param {Object} context
  1106. 	 * @param {Array} updatedObjDetails  Object detail containing field {obj, propNames} or array of details.
  1107. 	 * @param {Int} updateType Value from {@link Kekule.Render.ObjectUpdateType}
  1108. 	 * @returns {Bool}
  1109. 	 * @private
  1110. 	 */
  1111. 	doUpdate: function(context, updateObjDetails, updateType)
  1112. 	{
  1113. 		//console.log('do update', this.getClassName(), updateObjDetails);
  1114. 		return this.doUpdateSelf(context, updateObjDetails, updateType);
  1115. 	},
  1116. 	/**
  1117. 	 * Do actual work of update self (without children). Descendants should override this.
  1118. 	 * @param {Object} context
  1119. 	 * @param {Array} updatedObjDetails  Object detail containing field {obj, propNames} or array of details.
  1120. 	 * @param {Int} updateType Value from {@link Kekule.Render.ObjectUpdateType}
  1121. 	 * @returns {Bool}
  1122. 	 * @private
  1123. 	 */
  1124. 	doUpdateSelf: function(context, updatedObjDetails, updateType)
  1125. 	{
  1126. 		//console.log('[doUpdateSelf]', this.getClassName(), updatedObjDetails);
  1127. 		var r = false;
  1128. 		if (this.canModifyGraphic(context))
  1129. 		{
  1130. 			/*  // TODO: now has bugs, disable it
  1131. 			    // work well now? 2014-06-06
  1132. 			 */
  1133. 			/*
  1134. 			if (updatedObjs.indexOf(this.getChemObj()))
  1135. 			{
  1136. 				if (updateType === Kekule.Render.ObjectUpdateType.CLEAR)
  1137. 					return this.doClear(context);
  1138. 				else
  1139. 				{
  1140. 					//console.log('update by redraw', this.getClassName(), updatedObjs);
  1141. 					// simpliest method to update is to redraw the whole chemObj
  1142. 					this.doClear(context);
  1143. 					var p = this.getRenderCache(context);
  1144. 					return this.draw(context, p.baseCoord, p.options);
  1145. 				}
  1146. 			}
  1147. 			*/
  1148. 			var redrawSelf = false;
  1149. 			var chemObj = this.getChemObj();
  1150. 			for (var i = 0, l = updatedObjDetails.length; i < l; ++i)
  1151. 			{
  1152. 				var detail = updatedObjDetails[i];
  1153. 				if (detail.obj === chemObj)
  1154. 				{
  1155. 					//console.log('update self detail', this.getClassName(), detail.obj.getId());
  1156. 					redrawSelf = true;
  1157. 					break;
  1158. 				}
  1159. 			}
  1160. 			if (redrawSelf)
  1161. 			{
  1162. 				if (updateType === Kekule.Render.ObjectUpdateType.CLEAR)
  1163. 					return this.doClear(context);
  1164. 				else
  1165. 				{
  1166. 					//console.log('<update by redraw>', this.getClassName(), updatedObjDetails);
  1167. 					// simpliest method to update is to redraw the whole chemObj
  1168. 					this.doClear(context);
  1169. 					var p = this.getRenderCache(context);
  1170. 					return this.draw(context, p.baseCoord, p.options);
  1171. 				}
  1172. 			}
  1173. 			/**/
  1174. 			/*
  1175. 			var T = Kekule.Render.ObjectUpdateType;
  1176. 			switch (updateType)
  1177. 			{
  1178. 				case T.ADD:
  1179. 					r = this.doAddNew(context, updatedObjs);
  1180. 					break;
  1181. 				case T.MODIFY:
  1182. 					r = this.doModify(context, updatedObjs);
  1183. 					break;
  1184. 				case T.REMOVE:
  1185. 					r = this.doRemove(context, updatedObjs);
  1186. 					break;
  1187. 				case T.CLEAR:
  1188. 					r = this.doClear(context);
  1189. 					this.invokeEvent('clear', {'context': context, 'obj': this.getChemObj()});
  1190. 					break;
  1191. 			}
  1192. 			*/
  1193. 		}
  1194. 		return r;
  1195. 	},
  1197. 	/** @ignore */
  1198. 	_extractObjsOfUpdateObjDetails: function(updatedObjDetails)
  1199. 	{
  1200. 		return Kekule.Render.UpdateObjUtils._extractObjsOfUpdateObjDetails(updatedObjDetails);
  1201. 	},
  1202. 	/** @ignore */
  1203. 	_createUpdateObjDetailsFromObjs: function(updatedObjs)
  1204. 	{
  1205. 		return Kekule.Render.UpdateObjUtils._createUpdateObjDetailsFromObjs(updatedObjs);
  1206. 	},
  1208. 	/**
  1209. 	 * Add a new child object to chemObj. Must be called after draw.
  1210. 	 * @param {Object} context
  1211. 	 * @param {Variant} updatedObjs
  1212. 	 * @returns {Bool} Whether the actual add job is done.
  1213. 	 * @private
  1214. 	 */
  1215. 	addNew: function(context, updatedObjs)
  1216. 	{
  1217. 		var details = this._createUpdateObjDetailsFromObjs(updatedObjs);
  1218. 		return this.update(context, details, Kekule.Render.ObjectUpdateType.ADD);
  1219. 	},
  1220. 	/*
  1221. 	 * Do actual work of addNew. Descendants should override this.
  1222. 	 * This function should return true after actual work done. Otherwise false should be returned.
  1223. 	 * @param {Object} context
  1224. 	 * @param {Variant} updatedObjs
  1225. 	 * @returns {Bool}
  1226. 	 * @private
  1227. 	 * @deprecated
  1228. 	 */
  1229. 	/*
  1230. 	doAddNew: function(context, updatedObjs)
  1231. 	{
  1232. 		return false;
  1233. 	},
  1234. 	*/
  1235. 	/**
  1236. 	 * Modify chemObj or a child object inside chemObj. Must be called after draw.
  1237. 	 * @param {Object} context
  1238. 	 * @param {Variant} updatedObjs
  1239. 	 * @returns {Bool} Whether the actual modify job is done.
  1240. 	 * @private
  1241. 	 */
  1242. 	modify: function(context, updatedObjDetails)
  1243. 	{
  1244. 		return this.update(context, updatedObjDetails, Kekule.Render.ObjectUpdateType.MODIFY);
  1245. 	},
  1246. 	/*
  1247. 	 * Do actual work of modify. Descendants should override this.
  1248. 	 * This function should return true after actual work done. Otherwise false should be returned.
  1249. 	 * @param {Object} context
  1250. 	 * @param {Variant} updatedObjs
  1251. 	 * @returns {Bool}
  1252. 	 * @private
  1253. 	 * @deprecated
  1254. 	 */
  1255. 	/*
  1256. 	doModify: function(context, updatedObjs)
  1257. 	{
  1258. 		return false;
  1259. 	},
  1260. 	*/
  1261. 	/**
  1262. 	 * Remove a child object inside chemObj and update the rendering. Must be called after draw.
  1263. 	 * @param {Object} context
  1264. 	 * @param {Variant} removedObjs
  1265. 	 * @returns {Bool} Whether the actual remove job is done.
  1266. 	 * @private
  1267. 	 */
  1268. 	remove: function(context, removedObjs)
  1269. 	{
  1270. 		var details = this._createUpdateObjDetailsFromObjs(removedObjs);
  1271. 		return this.update(context, details, Kekule.Render.ObjectUpdateType.REMOVE);
  1272. 	},
  1273. 	/*
  1274. 	 * Do actual work of remove. Descendants should override this.
  1275. 	 * This function should return true after actual work done. Otherwise false should be returned.
  1276. 	 * @param {Object} context
  1277. 	 * @param {Variant} removedObjs
  1278. 	 * @returns {Bool}
  1279. 	 * @private
  1280. 	 * @deprecated
  1281. 	 */
  1282. 	/*
  1283. 	doRemove: function(context, removedObjs)
  1284. 	{
  1285. 		return false;
  1286. 	},
  1287. 	*/
  1289. 	/**
  1290. 	 * Clear whole chemObj on context.
  1291. 	 * @param {Object} context
  1292. 	 * @returns {Bool} Whether the actual clear job is done.
  1293. 	 */
  1294. 	clear: function(context)
  1295. 	{
  1296. 		//console.log('[Clear]', this.getClassName(), this.getChemObj().getId? this.getChemObj().getId(): null);
  1297. 		//return this.update(context, Kekule.Render.UpdateObjUtils._createUpdateObjDetailsFromObjs([this.getChemObj()]), Kekule.Render.ObjectUpdateType.CLEAR);
  1298. 		var result = this.doClear(context);
  1299. 		this.invokeEvent('clear', {'context': context, 'obj': this.getChemObj()});
  1300. 	},
  1301. 	/**
  1302. 	 * Do actual job of clear.
  1303. 	 * This function should return true after actual work done. Otherwise false should be returned.
  1304. 	 * @param {Object} context
  1305. 	 * @returns {Bool}
  1306. 	 */
  1307. 	doClear: function(context)
  1308. 	{
  1309. 		if (this.canModifyGraphic())
  1310. 		{
  1311. 			return this.doClearSelf(context);
  1312. 		}
  1313. 		else
  1314. 			return false;
  1315. 	},
  1316. 	/**
  1317. 	 * Do actual job of clear self (without children). Descendants should override this method.
  1318. 	 * This function should return true after actual work done. Otherwise false should be returned.
  1319. 	 * @param {Object} context
  1320. 	 * @returns {Bool}
  1321. 	 */
  1322. 	doClearSelf: function(context)
  1323. 	{
  1324. 		if (this.canModifyGraphic())
  1325. 		{
  1326. 			//console.log('clear', this.getClassName());
  1327. 			var drawnElem = this.getRenderCache(context).drawnElem;
  1328. 			//console.log('clear', drawnElem);
  1329. 			if (drawnElem)
  1330. 			{
  1331. 				try
  1332. 				{
  1333. 					this.getDrawBridge().removeDrawnElem(context, drawnElem);
  1334. 				}
  1335. 				catch(e)  // avoid error when drawnElem is already removed from context
  1336. 				{
  1337. 					//console.log('clear error', this.getClassName(), drawnElem);
  1338. 				}
  1339. 			}
  1340. 			this.getRenderCache(context).drawnElem = null;
  1341. 		}
  1342. 		else
  1343. 			return false;
  1344. 	},
  1345. 	/**
  1346. 	 * Estimate the bound box around current chemObj (in chem coord system).
  1347. 	 * @param {Object} context
  1348. 	 * @param {Object} options
  1349. 	 * @param {Bool} allowCoordBorrow
  1350. 	 * @returns {Hash} A 2D or 3D box, in chemObj's coord system.
  1351. 	 */
  1352. 	estimateObjBox: function(context, options, allowCoordBorrow)
  1353. 	{
  1354. 		var box = this.doEstimateObjBox(context, options, allowCoordBorrow);
  1355. 		//console.log('get box', this.getClassName(), box);
  1356. 		// if box has some field which is undefined or null, set it to 0
  1357. 		if (box)
  1358. 			box = this._fillBoxDefaultValue(box, this.getRendererType());
  1359. 		return box;
  1360. 	},
  1361. 	/**
  1362. 	 * Do actual work of {@link Kekule.Render.AbstractRenderer.estimateObjBox}.
  1363. 	 * @param {Object} context
  1364. 	 * @param {Object} options
  1365. 	 * @param {Bool} allowCoordBorrow
  1366. 	 * @returns {Hash} A 2D or 3D box.
  1367. 	 * @private
  1368. 	 */
  1369. 	doEstimateObjBox: function(context, options, allowCoordBorrow)
  1370. 	{
  1371. 		return this.doEstimateSelfObjBox(context, options, allowCoordBorrow);
  1372. 	},
  1373. 	/**
  1374. 	 * Calculate the containing box of only this object (without children).
  1375. 	 * Descendants may override this method.
  1376. 	 * @param {Object} context
  1377. 	 * @param {Object} options
  1378. 	 * @param {Bool} allowCoordBorrow
  1379. 	 * @returns {Hash} A 2D or 3D box.
  1380. 	 * @private
  1381. 	 */
  1382. 	doEstimateSelfObjBox: function(context, options, allowCoordBorrow)
  1383. 	{
  1384. 		return null;
  1385. 	},
  1387. 	/**
  1388. 	 * Estimate the bound box need to render current chemObj (in context coord system).
  1389. 	 * Note: this method should not be called outside draw(). Otherwise the result may be unreliable or even no result can be returned.
  1390. 	 * @param {Object} context
  1391. 	 * @param {Hash} baseCoord Center coord in context to draw object. Can be null.
  1392. 	 * @param {Object} options
  1393. 	 * @param {Bool} allowCoordBorrow
  1394. 	 * @returns {Hash} A 2D or 3D box, in context's coord system.
  1395. 	 */
  1396. 	estimateRenderBox: function(context, baseCoord, options, allowCoordBorrow)
  1397. 	{
  1398. 		var box = this.doEstimateRenderBox(context, baseCoord, options, allowCoordBorrow);
  1399. 		// if box has some field which is undefined or null, set it to 0
  1400. 		if (box)
  1401. 			box = this._fillBoxDefaultValue(box, this.getRendererType());
  1402. 		return box;
  1403. 	},
  1404. 	/**
  1405. 	 * Do actual work of {@link Kekule.Render.AbstractRenderer.estimateRenderBox}.
  1406. 	 * @param {Object} context
  1407. 	 * @param {Hash} baseCoord Center coord in context to draw object. Can be null.
  1408. 	 * @param {Object} options
  1409. 	 * @param {Bool} allowCoordBorrow
  1410. 	 * @returns {Hash} A 2D or 3D box.
  1411. 	 * @private
  1412. 	 */
  1413. 	doEstimateRenderBox: function(context, baseCoord, options, allowCoordBorrow)
  1414. 	{
  1415. 		// do nothing here
  1416. 		return null;
  1417. 	},
  1419. 	/** @private */
  1420. 	_fillBoxDefaultValue: function(box, rendererType)
  1421. 	{
  1422. 		if (!box)
  1423. 			box = {};
  1424. 		var is3D = rendererType === Kekule.Render.RendererType.R3D;
  1425. 		var r = {
  1426. 			'x1': box.x1 || 0,
  1427. 			'x2': box.x2 || 0,
  1428. 			'y1': box.y1 || 0,
  1429. 			'y2': box.y2 || 0
  1430. 		};
  1431. 		if (is3D)
  1432. 		{
  1433. 			r.z1 = box.z1 || 0;
  1434. 			r.z2 = box.z2 || 0;
  1435. 		}
  1436. 		return r;
  1437. 	},
  1439. 	/**
  1440. 	 * Transform a context based coord to inner coord basd on chemObj coord system.
  1441. 	 * @param {Object} context
  1442. 	 * @param {Kekule.ChemObject} chemObj
  1443. 	 * @param {Hash} coord
  1444. 	 * @returns {Hash}
  1445. 	 */
  1446. 	transformCoordToObj: function(context, chemObj, coord)
  1447. 	{
  1448. 		return this.doTransformCoordToObj(context, chemObj, coord);
  1449. 	},
  1450. 	/** @private */
  1451. 	doTransformCoordToObj: function(context, chemObj, coord)
  1452. 	{
  1453. 		return coord;
  1454. 	},
  1455. 	/**
  1456. 	 * Transform a chemObj based inner coord to context based one.
  1457. 	 * @param {Object} context
  1458. 	 * @param {Kekule.ChemObject} chemObj
  1459. 	 * @param {Hash} coord
  1460. 	 * @returns {Hash}
  1461. 	 */
  1462. 	transformCoordToContext: function(context, chemObj, coord)
  1463. 	{
  1464. 		return this.doTransformCoordToContext(context, chemObj, coord);
  1465. 	},
  1466. 	/** @private */
  1467. 	doTransformCoordToContext: function(context, chemObj, coord)
  1468. 	{
  1469. 		return coord;
  1470. 	},
  1471. 	/**
  1472. 	 * Transform a context based coord to screen based one (usually in pixel).
  1473. 	 * @param {Object} context
  1474. 	 * @param {Hash} coord
  1475. 	 * @return {Hash}
  1476. 	 */
  1477. 	transformContextCoordToScreen: function(context, coord)
  1478. 	{
  1479. 		return this.doTransformContextCoordToScreen(context, coord);
  1480. 	},
  1481. 	/** @private */
  1482. 	doTransformContextCoordToScreen: function(context, coord)
  1483. 	{
  1484. 		var b = this.getDrawBridge();
  1485. 		return (b && b.transformContextCoordToScreen)? b.transformContextCoordToScreen(context, coord): coord;
  1486. 	},
  1488. 	/**
  1489. 	 * Should be called when a basic object (node, connector, glyph...) is drawn on context.
  1490. 	 * @param {Object} obj
  1491. 	 * @param {Object} boundInfo
  1492. 	 * @private
  1493. 	 */
  1494. 	basicDrawObjectUpdated: function(context, obj, parentObj, boundInfo, updateType)
  1495. 	{
  1496. 		/*
  1497. 		if (!boundInfo)
  1498. 			console.log(arguments.callee.caller.toString());
  1499. 		*/
  1500. 		this.invokeEvent('updateBasicDrawObject', {'context': context, 'obj': obj, 'parentObj': parentObj, 'boundInfo': boundInfo, 'updateType': updateType});
  1501. 	},
  1503. 	/**
  1504. 	 * Indicate whether a chemObj (including childObj) is rendered by this renderer, or should be rendered by this renderer.
  1505. 	 * Descendants may override this method.
  1506. 	 * @param {Object} context
  1507. 	 * @param {Object} obj
  1508. 	 * @returns {boolean}
  1509. 	 */
  1510. 	isChemObjRenderedBySelf: function(context, obj)
  1511. 	{
  1512. 		return (obj === this.getRenderCache(context).chemObj);
  1513. 	},
  1514. 	/**
  1515. 	 * Indicate whether a chemObj (including childObj) is rendered directly by this renderer (not by child renderers).
  1516. 	 * Descendants may override this method.
  1517. 	 * @param {Object} context
  1518. 	 * @param {Object} obj
  1519. 	 * @returns {boolean}
  1520. 	 */
  1521. 	isChemObjRenderedDirectlyBySelf: function(context, obj)
  1522. 	{
  1523. 		if (obj && this.getRenderCache(context).chemObj)
  1524. 			return (obj === this.getRenderCache(context).chemObj);
  1525. 		else
  1526. 			return false;
  1527. 	},
  1529. 	/** @private */
  1530. 	createBoundInfo: function(boundType, coords, additionalInfos)
  1531. 	{
  1532. 		return Kekule.Render.MetaShapeUtils.createShapeInfo(boundType, coords, additionalInfos);
  1533. 	},
  1534. 	/** @private */
  1535. 	createPointBoundInfo: function(coord)
  1536. 	{
  1537. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.POINT, [coord]);
  1538. 	},
  1539. 	/** @private */
  1540. 	createCircleBoundInfo: function(coord, radius)
  1541. 	{
  1542. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.CIRCLE, [coord], {'radius': radius});
  1543. 	},
  1544. 	/** @private */
  1545. 	createArcBoundInfo: function(coord, radius, startAngle, endAngle, anticlockwise, width)
  1546. 	{
  1547. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.ARC, [coord],
  1548. 				{'radius': radius, 'startAngle': startAngle, 'endAngle': endAngle, 'anticlockwise': anticlockwise, 'width': width});
  1549. 	},
  1550. 	/** @private */
  1551. 	createLineBoundInfo: function(coord1, coord2, width)
  1552. 	{
  1553. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.LINE, [coord1, coord2], {'width': width});
  1554. 	},
  1555. 	/** @private */
  1556. 	createRectBoundInfo: function(coord1, coord2)
  1557. 	{
  1558. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.RECT, [coord1, coord2]);
  1559. 	},
  1560. 	/** @private */
  1561. 	createSphereBoundInfo: function(coord, radius)
  1562. 	{
  1563. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.SPHERE, [coord], {'radius': radius});
  1564. 	},
  1565. 	/** @private */
  1566. 	createCylinderBoundInfo: function(coord1, coord2, radius)
  1567. 	{
  1568. 		return this.createBoundInfo(Kekule.Render.BoundShapeType.CYLINDER, [coord1, coord2], {'radius': radius});
  1569. 	}
  1570. });
  1571. Kekule.ClassDefineUtils.addExtraObjMapSupport(Kekule.Render.AbstractRenderer);
  1573. /**
  1574.  * A dummy renderer that does nothing.
  1575.  * @class
  1576.  * @augments Kekule.Render.AbstractRenderer
  1577.  */
  1578. Kekule.Render.DummyRenderer = Class.create(Kekule.Render.AbstractRenderer,
  1579. /** @lends Kekule.Render.DummyRenderer# */
  1580. {
  1581. 	/** @private */
  1582. 	CLASS_NAME: 'Kekule.Render.DummyRenderer',
  1583. 	/** @ignore */
  1584. 	draw: function(context, baseCoord, options)
  1585. 	{
  1586. 		return;
  1587. 	},
  1588. 	/** @ignore */
  1589. 	redraw: function(context)
  1590. 	{
  1591. 		return;
  1592. 	}
  1593. });
  1595. /**
  1596.  * A base renderer class to draw object togather with its children.
  1597.  * @class
  1598.  * @augments Kekule.Render.AbstractRenderer
  1599.  */
  1600. Kekule.Render.CompositeRenderer = Class.create(Kekule.Render.AbstractRenderer,
  1601. /** @lends Kekule.Render.CompositeRenderer# */
  1602. {
  1603. 	/** @private */
  1604. 	CLASS_NAME: 'Kekule.Render.CompositeRenderer',
  1605. 	/** @private */
  1606. 	initProperties: function()
  1607. 	{
  1608. 		this.defineProp('targetChildObjs', {
  1609. 			'dataType': DataType.ARRAY,
  1610. 			'serializable': false
  1611. 		});
  1612. 		this.defineProp('childRendererMap', {
  1613. 			'dataType': DataType.OBJECT,
  1614. 			'serializable': false,
  1615. 			'getter': function()
  1616. 			{
  1617. 				var result = this.getPropStoreFieldValue('childRendererMap');
  1618. 				if (!result)
  1619. 				{
  1620. 					result = new Kekule.MapEx(true);  // non-weak map, as we should store the renderers
  1621. 					this.setPropStoreFieldValue('childRendererMap', result);
  1622. 				}
  1623. 				return result;
  1624. 			}
  1625. 		});
  1626. 	},
  1627. 	/** @ignore */
  1628. 	finalize: function($super)
  1629. 	{
  1630. 		this.reset();
  1631. 		$super();
  1632. 	},
  1634. 	/** @ignore */
  1635. 	doEstimateObjBox: function($super, context, options, allowCoordBorrow)
  1636. 	{
  1637. 		var result = $super(context, options, allowCoordBorrow);
  1638. 		var renderers = this.prepareChildRenderers();
  1639. 		var BU = Kekule.BoxUtils;
  1640. 		for (var i = 0, l = renderers.length; i < l; ++i)
  1641. 		{
  1642. 			var r = renderers[i];
  1643. 			if (r)
  1644. 			{
  1645. 				var b = r.estimateObjBox(context, options, allowCoordBorrow);
  1646. 				if (b)
  1647. 				{
  1648. 					if (!result)
  1649. 						result = BU.clone(b); //Object.extend({}, b);
  1650. 					else
  1651. 						result = BU.getContainerBox(result, b);
  1652. 				}
  1653. 			}
  1654. 		}
  1655. 		return result;
  1656. 	},
  1658. 	/** @ignore */
  1659. 	isChemObjRenderedBySelf: function($super, context, obj)
  1660. 	{
  1661. 		var result = $super(context, obj);
  1662. 		//console.log('check rendered by self', obj.getClassName(), this.getClassName(), result);
  1663. 		if (!result)
  1664. 		{
  1665. 			var childRenderers = this.getChildRenderers();
  1666. 			for (var i = 0, l = childRenderers.length; i < l; ++i)
  1667. 			{
  1668. 				var r = childRenderers[i];
  1669. 				if (r.isChemObjRenderedBySelf(context, obj))
  1670. 					return true;
  1671. 			}
  1672. 		}
  1673. 		if (!result)
  1674. 		{
  1675. 			this.refreshChildObjs();
  1676. 			var objs = this.getTargetChildObjs();
  1677. 			result = (objs && objs.indexOf(obj) >= 0);
  1678. 			//console.log('here', this.getClassName(), obj.getClassName(), result);
  1679. 		}
  1680. 		return result;
  1681. 	},
  1682. 	/** @ignore */
  1683. 	isChemObjRenderedDirectlyBySelf: function($super, context, obj)
  1684. 	{
  1685. 		return $super(context, obj);
  1686. 	},
  1687. 	/** @ignore */
  1688. 	doSetRedirectContext: function($super, value)
  1689. 	{
  1690. 		$super(value);
  1691. 		// if has child renderers, set redirect context as well
  1692. 		var childRenderers = this.getChildRenderers();
  1693. 		if (childRenderers && childRenderers.length)
  1694. 		{
  1695. 			for (var i = 0, l = childRenderers.length; i < l; ++i)
  1696. 			{
  1697. 				childRenderers[i].setRedirectContext(value);
  1698. 			}
  1699. 		}
  1700. 	},
  1703. 	/**
  1704. 	 * Returns all children of this.getChemObj(). Descendants must override this method.
  1705. 	 * If no children is found, null should be returned.
  1706. 	 * @returns {Array}
  1707. 	 * @private
  1708. 	 */
  1709. 	getChildObjs: function()
  1710. 	{
  1711. 		var chemObj = this.getChemObj();
  1712. 		if (chemObj && chemObj.getAttachedMarkers)
  1713. 			return [].concat(chemObj.getAttachedMarkers() || []);
  1714. 		else
  1715. 			return [];
  1716. 	},
  1717. 	/**
  1718. 	 * Prepare all child objects to be drawn.
  1719. 	 * @private
  1720. 	 */
  1721. 	prepareChildObjs: function()
  1722. 	{
  1723. 		var childObjs = this.getTargetChildObjs();
  1724. 		if (childObjs)  // already prepared
  1725. 			return childObjs;
  1727. 		this.setTargetChildObjs(this.getChildObjs());
  1728. 		return this.getTargetChildObjs();
  1729. 	},
  1730. 	/** @private */
  1731. 	refreshChildObjs: function()
  1732. 	{
  1733. 		this.setTargetChildObjs(null);
  1734. 		this.prepareChildObjs();
  1735. 		/*
  1736. 		if (this.getTargetChildObjs().length)
  1737. 			console.log('refresh child', this.getClassName(), this.getTargetChildObjs());
  1738. 		*/
  1739. 	},
  1740. 	/** @private */
  1741. 	getChildRenderers: function()
  1742. 	{
  1743. 		return this.getChildRendererMap().getValues();
  1744. 	},
  1745. 	/** @private */
  1746. 	getRendererForChild: function(childObj, canCreate)
  1747. 	{
  1748. 		var renderSelector = (this.getRendererType() === Kekule.Render.RendererType.R3D)?
  1749. 				Kekule.Render.get3DRendererClass: Kekule.Render.get2DRendererClass;
  1750. 		var rendererMap = this.getChildRendererMap();
  1751. 		var result = rendererMap.get(childObj);
  1752. 		if (!result && canCreate)
  1753. 		{
  1754. 			var c = renderSelector(childObj) || Kekule.Render.DummyRenderer;  // dummy renderer, do nothing
  1755. 			var result = c? new c(childObj, this.getDrawBridge(), /*this.getRenderConfigs(),*/ this): null;  // renderer may be null for some unregistered objects
  1756. 			rendererMap.set(childObj, result);
  1757. 			result.setRedirectContext(this.getRedirectContext());
  1758. 		}
  1759. 		return result;
  1760. 	},
  1761. 	/**
  1762. 	 * Prepare renders to draw child objects.
  1763. 	 * @private
  1764. 	 */
  1765. 	prepareChildRenderers: function()
  1766. 	{
  1767. 		var rendererMap = this.getChildRendererMap();
  1769. 		var childObjs = this.prepareChildObjs() || [];
  1771. 		// remove unneed renderers
  1772. 		var oldRenderedObjs = rendererMap.getKeys();
  1773. 		for (var i = 0, l = oldRenderedObjs.length; i < l; ++i)
  1774. 		{
  1775. 			var obj = oldRenderedObjs[i];
  1776. 			if (childObjs.indexOf(obj) < 0)
  1777. 				rendererMap.remove(obj);
  1778. 		}
  1779. 		// add new renderers if needed
  1780. 		for (var i = 0, l = childObjs.length; i < l; ++i)
  1781. 		{
  1782. 			var childObj = childObjs[i];
  1783. 			this.getRendererForChild(childObj, true);
  1784. 		}
  1786. 		//return childRenderers;
  1787. 		return rendererMap.getValues();
  1788. 	},
  1789. 	/**
  1790. 	 * Release all child renderer instance.
  1791. 	 * @private
  1792. 	 */
  1793. 	releaseChildRenderers: function()
  1794. 	{
  1795. 		var rendererMap = this.getChildRendererMap();
  1796. 		var childRenderers = rendererMap.getValues();
  1797. 		if (!childRenderers)
  1798. 			return;
  1799. 		for (var i = 0, l = childRenderers.length; i < l; ++i)
  1800. 		{
  1801. 			childRenderers[i].finalize();
  1802. 		}
  1803. 		rendererMap.clear();
  1804. 	},
  1805. 	/** @private */
  1806. 	hasChildRenderers: function()
  1807. 	{
  1808. 		var childRenderers = this.getChildRendererMap().getValues();
  1809. 		var result = childRenderers && childRenderers.length;
  1810. 		return result;
  1811. 	},
  1813. 	/**
  1814. 	 * Prepare child objects and renderers, a must have step before draw.
  1815. 	 * @private
  1816. 	 */
  1817. 	prepare: function()
  1818. 	{
  1819. 		this.prepareChildObjs();
  1820. 		this.prepareChildRenderers();
  1821. 	},
  1822. 	/**
  1823. 	 * Set renderer to initialized state, clear childObjs and childRenderers.
  1824. 	 * @private
  1825. 	 */
  1826. 	reset: function()
  1827. 	{
  1828. 		//console.log('reset', this.getClassName());
  1829. 		this.setTargetChildObjs(null);
  1830. 		this.releaseChildRenderers();
  1831. 	},
  1833. 	/**
  1834. 	 * Whether the whole renderer (and its children) should be wholely repainted even in partial draw mode.
  1835. 	 * Descendants may override this.
  1836. 	 * @returns {Bool}
  1837. 	 * @private
  1838. 	 */
  1839. 	_needWholelyDraw: function(partialDrawObjs, context)
  1840. 	{
  1841. 		var selfObj = this.getChemObj();
  1842. 		return !partialDrawObjs || partialDrawObjs.indexOf(selfObj) >= 0;
  1843. 	},
  1845. 	/** @private */
  1846. 	doDraw: function($super, context, baseCoord, options)
  1847. 	{
  1848. 		//this.reset();
  1849. 		/*
  1850. 		this.setTargetChildObjs(null);  // refresh child objects first
  1851. 		this.prepare();
  1852. 		//console.log('draw', this.getClassName(), options.partialDrawObjs, baseCoord);
  1853. 		*/
  1854. 		this.refreshChildObjs();  // refresh child objects first
  1855. 		this.prepareChildRenderers();  // refresh renderer list
  1857. 		var op = Object.create(options);
  1858. 		if (options.partialDrawObjs && this._needWholelyDraw(options.partialDrawObjs, context))
  1859. 			op.partialDrawObjs = null;  // if self need to be draw, all child renderers should be repainted as well
  1861. 		//if (!this.hasChildRenderers())
  1862. 		if (!this.getTargetChildObjs().length)
  1863. 			return $super(context, baseCoord, op);
  1864. 		else  // then draw each child objects by child renderers
  1865. 		{
  1866. 			//console.log('do draw self', this.getClassName());
  1867. 			var selfElem = this.doDrawSelf(context, baseCoord, op);
  1868. 			var group = this.doDrawChildren(context, baseCoord, op);
  1869. 			// self
  1870. 			if (selfElem)
  1871. 				this.addToDrawGroup(selfElem, group);
  1872. 			return group;
  1873. 		}
  1874. 	},
  1875. 	/** @private */
  1876. 	doDrawChildren: function(context, baseCoord, options)
  1877. 	{
  1878. 		var group = this.createDrawGroup(context);
  1879. 		var childRenderers = this.getChildRenderers();
  1881. 		var ops = Object.create(options);
  1883. 		this.getRenderCache(context).childDrawOptions = ops;
  1885. 		for (var i = 0, l = childRenderers.length; i < l; ++i)
  1886. 		{
  1887. 			var r = childRenderers[i];
  1888. 			var baseCoord = null;
  1889. 			var elem = r.draw(context, baseCoord, ops);
  1890. 			if (group && elem)
  1891. 				this.addToDrawGroup(elem, group);
  1892. 		}
  1893. 		//console.log('draw children', this.getClassName(), group, childRenderers.length, this.getTargetChildObjs());
  1894. 		return group;
  1895. 	},
  1896. 	/** @private */
  1897. 	doClear: function($super, context)
  1898. 	{
  1899. 		$super(context);
  1900. 		if (this.hasChildRenderers())
  1901. 		{
  1902. 			this.doClearChildren(context);
  1903. 		}
  1904. 		return true;
  1905. 	},
  1906. 	/** @private */
  1907. 	doClearChildren: function(context)
  1908. 	{
  1909. 		var childRenderers = this.getChildRendererMap().getValues();
  1910. 		for (var i = 0, l = childRenderers.length; i < l; ++i)
  1911. 		{
  1912. 			if (childRenderers[i])
  1913. 			{
  1914. 				childRenderers[i].clear(context);
  1915. 			}
  1916. 		}
  1917. 	},
  1918. 	/** @private */
  1919. 	doUpdate: function($super, context, updateObjDetails, updateType)
  1920. 	{
  1921. 		this.refreshChildObjs();  // refresh child objects first
  1922. 		//this.prepare();
  1923. 		// update self
  1924. 		$super(context, updateObjDetails, updateType);
  1925. 		//if (this.hasChildRenderers())
  1926. 		if (this.getTargetChildObjs().length)
  1927. 		{
  1928. 			//console.log('do update children of ', this.getClassName());
  1929. 			this.doUpdateChildren(context, updateObjDetails, updateType);
  1930. 		}
  1931. 		return true;
  1932. 	},
  1933. 	/** @private */
  1934. 	doUpdateChildren: function(context, updateObjDetails, updateType)
  1935. 	{
  1936. 		var updatedObjs = Kekule.Render.UpdateObjUtils._extractObjsOfUpdateObjDetails(updateObjDetails);
  1938. 		//console.log('update Objs', this.getClassName(), updatedObjs);
  1940. 		var directChildren = this.getTargetChildObjs() || [];
  1941. 		var childRendererMap = this.getChildRendererMap();
  1942. 		var objs = Kekule.ArrayUtils.toArray(updatedObjs);
  1943. 		var objsMap = new Kekule.MapEx(false);
  1944. 		var renderers = [];
  1945. 		var redrawRoot = false;
  1947. 		for (var i = 0, l = objs.length; i < l; ++i)
  1948. 		{
  1949. 			var obj = objs[i];
  1950. 			if (this.isChemObjRenderedDirectlyBySelf(context, obj))  // need redraw self
  1951. 			{
  1952. 				redrawRoot = true;
  1953. 			}
  1954. 		}
  1955. 		if (redrawRoot)
  1956. 		{
  1957. 			this.doClear(context);
  1958. 			this.redraw(context);
  1959. 			return true;
  1960. 		}
  1962. 		for (var i = 0, l = objs.length; i < l; ++i)
  1963. 		{
  1964. 			var obj = objs[i];
  1965. 			/*  // TODO: now has bugs, disable it currently
  1966. 			 if (this.isChemObjRenderedDirectlyBySelf(context, obj))  // the root object it self updated, need re-render self
  1967. 			 {
  1968. 			 //console.log('do redraw');
  1969. 			 redrawRoot = true;
  1970. 			 //return true;
  1971. 			 }
  1972. 			 */
  1974. 			var renderer = childRendererMap.get(obj);
  1976. 			if (renderer)  // is direct child and has a corresponding renderer
  1977. 			{
  1978. 				// check update type, if updateType is remove, just remove the renderer
  1979. 				if (updateType === Kekule.Render.ObjectUpdateType.REMOVE)
  1980. 				{
  1981. 					renderer.clear();
  1982. 					childRendererMap.remove(obj);
  1983. 				}
  1984. 				else
  1985. 				{
  1986. 					Kekule.ArrayUtils.pushUnique(renderers, renderer);
  1987. 					olds = [obj];
  1988. 					objsMap.set(renderer, olds);
  1989. 				}
  1990. 			}
  1991. 			else
  1992. 			{
  1993. 				var rs = this._getRenderersForChildObj(context, obj);
  1994. 				if (!rs.length)
  1995. 				{
  1996. 					if (directChildren.indexOf(obj) >= 0)  // still can not find
  1997. 					{
  1998. 						var r = this.getRendererForChild(obj, true);
  2000. 						var drawnResult = r.draw(context, null, this.getRenderCache(context).childDrawOptions);
  2001. 						if (drawnResult)
  2002. 						{
  2003. 							var drawnElem = this.getCachedDrawnElem(context);
  2004. 							if (drawnElem)
  2005. 								this.addToDrawGroup(drawnResult, drawnElem);
  2006. 						}
  2007. 					}
  2008. 				}
  2009. 				for (var j = 0, k = rs.length; j < k; ++j)
  2010. 				{
  2011. 					var renderer = rs[j];
  2012. 					var olds = objsMap.get(renderer);
  2013. 					if (!olds)
  2014. 					{
  2015. 						renderers.push(renderer);
  2016. 						olds = [];
  2017. 						objsMap.set(renderer, olds);
  2018. 					}
  2019. 					olds.push(obj);
  2020. 				}
  2021. 			}
  2022. 		}
  2024. 		// apply update in each renderer
  2025. 		var result = true;
  2026. 		for (var i = 0, l = renderers.length; i < l; ++i)
  2027. 		{
  2028. 			var renderer = renderers[i];
  2029. 			var o = objsMap.get(renderer);
  2030. 			var details = Kekule.Render.UpdateObjUtils._createUpdateObjDetailsFromObjs(o);
  2031. 			//console.log('child renderer update', renderer.getClassName(), details);
  2032. 			var r = renderer.update(context, details, updateType);
  2033. 			result = result && r;
  2034. 		}
  2035. 		return result;
  2036. 	},
  2038. 	/** @private */
  2039. 	_getRenderersForChildObj: function(context, childObj)
  2040. 	{
  2041. 		var result = [];
  2042. 		var childRenderers = this.getChildRenderers();
  2043. 		for (var i = 0, l = childRenderers.length; i < l; ++i)
  2044. 		{
  2045. 			var r = childRenderers[i];
  2046. 			if (r.isChemObjRenderedBySelf(context, childObj))
  2047. 				result.push(r);
  2048. 		}
  2049. 		return result;
  2050. 	}
  2051. });
  2054. /**
  2055.  * 2D renderer factory.
  2056.  * @class
  2057.  */
  2058. Kekule.Render.Renderer2DFactory = Kekule.FactoryUtils.createSimpleFactory(Kekule.FactoryUtils.MATCH_BY_CLASS);
  2059. /**
  2060.  * Returns a suitable 2D renderer class for chemObj
  2061.  * @param {Object} chemObj
  2062.  * @returns {Kekule.Render.AbstractRenderer}
  2063.  * @function
  2064.  */
  2065. Kekule.Render.get2DRendererClass = function(chemObj)
  2066. {
  2067. 	var aClass = (chemObj instanceof ObjectEx)? chemObj.getClass(): chemObj;
  2068. 	return Kekule.Render.Renderer2DFactory.getClass(aClass);
  2069. };
  2070. /**
  2071.  * 3D renderer factory.
  2072.  * @class
  2073.  */
  2074. Kekule.Render.Renderer3DFactory = Kekule.FactoryUtils.createSimpleFactory(Kekule.FactoryUtils.MATCH_BY_CLASS);
  2075. /**
  2076.  * Returns a suitable 3D renderer class for chemObj
  2077.  * @param {Object} chemObj
  2078.  * @returns {Kekule.Render.AbstractRenderer}
  2079.  * @function
  2080.  */
  2081. Kekule.Render.get3DRendererClass = function(chemObj)
  2082. {
  2083. 	var aClass = (chemObj instanceof ObjectEx)? chemObj.getClass(): chemObj;
  2084. 	return Kekule.Render.Renderer3DFactory.getClass(aClass);
  2085. };
  2088. /**
  2089.  * Implemtation of 2D/3D draw bridge manager.
  2090.  * @class
  2091.  * @ignore
  2092.  */
  2093. Kekule.Render.DrawBridgeManager = Class.create({
  2094. 	/** @private */
  2095. 	CLASS_NAME: 'Kekule.Render.DrawBridgeManager',
  2096. 	/** @ignore */
  2097. 	initialize: function()
  2098. 	{
  2099. 		this._items = [];
  2100. 		this._preferredItem = null;
  2101. 	},
  2102. 	/** @private */
  2103. 	_indexOfBridgeClass: function(bridgeClass)
  2104. 	{
  2105. 		for (var i = 0, l = this._items.length; i < l; ++i)
  2106. 		{
  2107. 			var item = this._items[i];
  2108. 			if (item.bridgeClass === bridgeClass)
  2109. 				return i;
  2110. 		}
  2111. 		return -1;
  2112. 	},
  2113. 	/** @private */
  2114. 	_sortItems: function()
  2115. 	{
  2116. 		this._items.sort(
  2117. 			function(item1, item2)
  2118. 			{
  2119. 				return (item1.priorityLevel || 0) - (item2.priorityLevel || 0);
  2120. 			}
  2121. 		)
  2122. 	},
  2123. 	/** @private */
  2124. 	_reselectPreferred: function()
  2125. 	{
  2126. 		this._sortItems();
  2127. 		for (var i = this._items.length - 1; i >= 0; --i)
  2128. 		{
  2129. 			var item = this._items[i];
  2130. 			if (item.isSupported)
  2131. 			{
  2132. 				this._preferredItem = item;
  2133. 				return item;
  2134. 			}
  2135. 		}
  2136. 		this._preferredItem = null;
  2137. 		return null;
  2138. 	},
  2140. 	/**
  2141. 	 * Register a bridge.
  2142. 	 * @param {Class} bridgeClass
  2143. 	 * @param {Int} priorityLevel
  2144. 	 * @returns {Object}
  2145. 	 * @ignore
  2146. 	 */
  2147. 	register: function(bridgeClass, priorityLevel)
  2148. 	{
  2149. 		if (!priorityLevel)
  2150. 			priorityLevel = 0;
  2151. 		var index = this._indexOfBridgeClass(bridgeClass);
  2152. 		var item;
  2153. 		if (index >= 0)
  2154. 		{
  2155. 			item = this._items[index];
  2156. 			item.priorityLevel = priorityLevel;
  2157. 		}
  2158. 		else
  2159. 		{
  2160. 			item = {'bridgeClass': bridgeClass, 'priorityLevel': priorityLevel};
  2161. 			item.isSupported = bridgeClass.isSupported? bridgeClass.isSupported(): false;
  2162. 			this._items.push(item);
  2163. 		}
  2164. 		this._sortItems();
  2166. 		if ((!this._preferredItem) || (this._preferredItem.priorityLevel < priorityLevel))
  2167. 		{
  2168. 			if (item.isSupported)  // if isSupported method not exists, assure it always not be supported
  2169. 				this._preferredItem = item;
  2170. 		}
  2172. 		return item;
  2173. 	},
  2175. 	/**
  2176. 	 * Unregister a bridge.
  2177. 	 * @param {Class} bridgeClass
  2178. 	 * @returns {Object}
  2179. 	 * @ignore
  2180. 	 */
  2181. 	unregister: function(bridgeClass)
  2182. 	{
  2183. 		var item = null;
  2184. 		var i = this._indexOfBridgeClass(bridgeClass);
  2185. 		if (i >= 0)
  2186. 		{
  2187. 			item = this._items[i];
  2188. 			this._items.splice(i, 1);
  2189. 			if (item === this._preferredItem)
  2190. 				this._reselectPreferred();
  2191. 		}
  2192. 		return item;
  2193. 	},
  2195. 	/**
  2196. 	 * Gets most suitable bridge class in current environment.
  2197. 	 * @returns {Class}
  2198. 	 * @ignore
  2199. 	 */
  2200. 	getPreferredBridgeClass: function()
  2201. 	{
  2202. 		return (this._preferredItem)? this._preferredItem.bridgeClass: null;
  2203. 	},
  2204. 	/**
  2205. 	 * Returns instance of preferred bridge in current environment.
  2206. 	 * @returns {Object}
  2207. 	 * @ignore
  2208. 	 */
  2209. 	getPreferredBridgeInstance: function()
  2210. 	{
  2211. 		var c = this.getPreferredBridgeClass();
  2212. 		if (c)
  2213. 		{
  2214. 			/*
  2215. 			if (!c.getInstance)  // class has not been singletoned
  2216. 				Kekule.ClassUtils.makeSingleton(c);
  2217. 			return c.getInstance()
  2218. 			*/
  2219. 			return new c();
  2220. 		}
  2221. 		else
  2222. 			return null;
  2223. 	}
  2224. });
  2226. /**
  2227.  * Draw bridge manager for 2D rendering.
  2228.  * @object
  2229.  */
  2230. Kekule.Render.DrawBridge2DMananger = new Kekule.Render.DrawBridgeManager();
  2231. /**
  2232.  * Draw bridge manager for 3D rendering.
  2233.  * @object
  2234.  */
  2235. Kekule.Render.DrawBridge3DMananger = new Kekule.Render.DrawBridgeManager();