PageRenderTime 41ms CodeModel.GetById 8ms RepoModel.GetById 0ms app.codeStats 0ms

/Typps/Resources/ClientScripts/startup.js

#
JavaScript | 772 lines | 730 code | 9 blank | 33 comment | 212 complexity | 4063ab908209103a6e0ba03b33bb1d6f MD5 | raw file
    

  1. /*

    2. 

  2. Typps HTML Editor for ASP.NET

    3. 

  3. FULL EDITION

    4. 

  4. 

    5. 

  5. Copyright (c) 2009 Alessandro Zifiglio, http://www.Typps.com

    6. 

  6. EMail: alessandro@Typps.com

    7. 

  7. 

    8. 

  8. This program is free software: you can redistribute it and/or modify

    9. 

  9. it under the terms of the GNU General Public License as published by

    10. 

  10. the Free Software Foundation, either version 3 of the License, or

    11. 

  11. (at your option) any later version.

    12. 

  12. 

    13. 

  13. This program is distributed in the hope that it will be useful,

    14. 

  14. but WITHOUT ANY WARRANTY; without even the implied warranty of

    15. 

  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16. 

  16. GNU General Public License for more details.

    17. 

  17. 

    18. 

  18. You should have received a copy of the GNU General Public License

    19. 

  19. along with this program.  If not, see <http://www.gnu.org/licenses/>.

    20. 

  20. */

    21. 

  21. Sys.Browser.WebKit = {}; //Safari 3 is considered WebKit

    22. 

  22. if (navigator.userAgent.indexOf('WebKit/') > -1) {

    23. 

  23. 	Sys.Browser.agent = Sys.Browser.WebKit;

    24. 

  24. 	Sys.Browser.version = parseFloat(navigator.userAgent.match(/WebKit\/(\d+(\.\d+)?)/)[1]);

    25. 

  25. 	Sys.Browser.name = 'WebKit';

    26. 

  26. }

    27. 

  27. 

    28. 

  28. Type.registerNamespace("Typps");

    29. 

  29. 

    30. 

  30. Typps.EventArgs = function () {

    31. 

  31. 	Typps.EventArgs.initializeBase(this);

    32. 

  32. 	this._commandName = null;

    33. 

  33. 	this._commandArgument = null;

    34. 

  34. 	this._innerArgs = null;

    35. 

  35. }

    36. 

  36. Typps.EventArgs.prototype = {

    37. 

  37. 	get_commandName: function () { return this._commandName; },

    38. 

  38. 	set_commandName: function (value) { this._commandName = value; },

    39. 

  39. 	get_commandArgument: function () { return this._commandArgument; },

    40. 

  40. 	set_commandArgument: function (value) { this._commandArgument = value; },

    41. 

  41. 	get_innerArgs: function () { return this._innerArgs; },

    42. 

  42. 	set_innerArgs: function (value) { this._innerArgs = value; }

    43. 

  43. }

    44. 

  44. Typps.EventArgs.registerClass('Typps.EventArgs', Sys.EventArgs);

    45. 

  45. 

    46. 

  46. Typps.MediaItemEventArgs = function () {

    47. 

  47. 	Typps.MediaItemEventArgs.initializeBase(this);

    48. 

  48. 	this._sender = null;

    49. 

  49. 	this._element = null;

    50. 

  50. 	this._header = null;

    51. 

  51. 	this._footer = null;

    52. 

  52. 	this._oldWidth = null;

    53. 

  53. 	this._oldHeight = null;

    54. 

  54. }

    55. 

  55. Typps.MediaItemEventArgs.prototype = {

    56. 

  56. 	get_sender: function () { return this._sender; },

    57. 

  57. 	set_sender: function (value) { this._sender = value; },

    58. 

  58. 	get_element: function () { return this._element; },

    59. 

  59. 	set_element: function (value) { this._element = value; },

    60. 

  60. 	get_header: function () { return this._header; },

    61. 

  61. 	set_header: function (value) { this._header = value; },

    62. 

  62. 	get_footer: function () { return this._footer; },

    63. 

  63. 	set_footer: function (value) { this._footer = value; },

    64. 

  64. 	get_oldWidth: function () { return this._oldWidth; },

    65. 

  65. 	set_oldWidth: function (value) { this._oldWidth = value; },

    66. 

  66. 	get_oldHeight: function () { return this._oldHeight; },

    67. 

  67. 	set_oldHeight: function (value) { this._oldHeight = value; }

    68. 

  68. }

    69. 

  69. 

    70. 

  70. Typps.MediaItemEventArgs.registerClass('Typps.MediaItemEventArgs', Sys.EventArgs);

    71. 

  71. Typps.Perform = function () { };

    72. 

  72. Typps.Perform.prototype =

    73. 

  73. {

    74. 

  74. 	Add: 0,

    75. 

  75. 	Remove: 1,

    76. 

  76. 	Toggle: 2

    77. 

  77. }

    78. 

  78. Typps.Perform.registerEnum('Typps.Perform');

    79. 

  79. Typps.Utility = function () {

    80. 

  80. 	//hr,br cannot contain child elements, so keep them in the list.

    81. 

  81. 	this._blockElements = ['ol', 'p', 'pre', 'table', 'td', 'ul', 'blockquote', 'div', 'dl', 'fieldset', 'address', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'noscript', 'hr'];

    82. 

  82. 	this._blockContentNodes = ['p', 'div', 'li', 'tr', 'td', 'pre', 'dl', 'dt', 'dd'];

    83. 

  83. }

    84. 

  84. Typps.Utility.getInstance = function Typps$Utility$getInstance() {

    85. 

  85. 	var instance = Typps.Utility._instance;

    86. 

  86. 	if (!instance) {

    87. 

  87. 		instance = Typps.Utility._instance = new Typps.Utility();

    88. 

  88. 	}

    89. 

  89. 	return instance;

    90. 

  90. }

    91. 

  91. Typps.Utility.getBlockLevelElements = function Typps$Utility$getBlockLevelElements() {

    92. 

  92. 	return Typps.Utility.getInstance()._blockElements;

    93. 

  93. }

    94. 

  94. Typps.Utility.getHighestZIndex = function Typps$Utility$getHighestZIndex() {

    95. 

  95. 	var zIndex = Typps.Utility._zIndex;

    96. 

  96. 	if (!zIndex) {

    97. 

  97. 		zIndex = Typps.Utility._zIndex = Typps.Utility.getInstance()._getNextHighestZindex(null);

    98. 

  98. 	}

    99. 

  99. 	return zIndex;

    100. 

  100. }

    101. 

  101. Typps.Utility.isAlphaNumericValidate = function Typps$Utility$isAlphaNumericValidate(alphanumeric) {

    102. 

  102. 	return Typps.Utility.getInstance()._isAlphaNumericValidate(alphanumeric);

    103. 

  103. }

    104. 

  104. Typps.Utility.regExpEscape = function Typps$Utility$regExpEscape(text) {

    105. 

  105. 	return Typps.Utility.getInstance()._regExpEscape(text);

    106. 

  106. }

    107. 

  107. Typps.Utility.incrementZIndex = function Typps$Utility$incrementZIndex(i) {

    108. 

  108. 	if (i == null || i < 0) i = 1;

    109. 

  109. 	var zIndex = Typps.Utility._zIndex;

    110. 

  110. 	if (zIndex)

    111. 

  111. 		zIndex = Typps.Utility._zIndex = Typps.Utility._zIndex + i;

    112. 

  112. 	else

    113. 

  113. 		zIndex = Typps.Utility.getHighestZIndex(null);

    114. 

  114. 	return zIndex;

    115. 

  115. }

    116. 

  116. Typps.Utility.paragraphWrap = function Typps$Utility$paragraphWrap(node, doc) {

    117. 

  117. 	return Typps.Utility.getInstance()._paragraphWrap(node, doc);

    118. 

  118. }

    119. 

  119. Typps.Utility.isNbsp = function Typps$Utility$isNbsp(textNode) {

    120. 

  120. 	return Typps.Utility.getInstance()._isNbsp(textNode);

    121. 

  121. }

    122. 

  122. Typps.Utility.getFormKeyValuePair = function Typps$Utility$(id, formKeyValuePair, form, includeAll) {

    123. 

  123. 	return Typps.Utility.getInstance()._getFormKeyValuePair(id, formKeyValuePair, form, includeAll);

    124. 

  124. }

    125. 

  125. Typps.Utility.splitText = function Typps$Utility$(doc, node, offset) {

    126. 

  126. 	return Typps.Utility.getInstance()._splitText(doc, node, offset);

    127. 

  127. }

    128. 

  128. Typps.Utility.getCommandArgument = function Typps$Utility$getCommandArgument(command, ae) {

    129. 

  129. 	return Typps.Utility.getInstance()._getCommandArgument(command, ae);

    130. 

  130. }

    131. 

  131. Typps.Utility.windowBounds = function Typps$Utility$windowBounds() {

    132. 

  132. 	return Typps.Utility.getInstance()._windowBounds();

    133. 

  133. }

    134. 

  134. Typps.Utility.scrollDistance = function Typps$Utility$scrollDistance(w) {

    135. 

  135. 	return Typps.Utility.getInstance()._scrollDistance(w);

    136. 

  136. }

    137. 

  137. Typps.Utility.getScrollBarWidth = function Typps$Utility$getScrollBarWidth() {

    138. 

  138. 	return Typps.Utility.getInstance()._getScrollBarWidth();

    139. 

  139. }

    140. 

  140. Typps.Utility.getParentOffset = function Typps$Utility$getParentOffset(elem) {

    141. 

  141. 	return Typps.Utility.getInstance()._getParentOffset(elem);

    142. 

  142. }

    143. 

  143. Typps.Utility.getAdjacentHTML = function Typps$Utility$getAdjacentHTML(markup, container) {

    144. 

  144. 	return Typps.Utility.getInstance()._getAdjacentHTML(markup, container);

    145. 

  145. }

    146. 

  146. Typps.Utility.getIndexByNameFromOptions = function Typps$Utility$getIndexByNameFromOptions(value, option) {

    147. 

  147. 	return Typps.Utility.getInstance()._getIndexByNameFromOptions(value, option);

    148. 

  148. }

    149. 

  149. Typps.Utility.applyShade = function Typps$Utility$applyShade(element, shaderColor, transparency, zIndex) {

    150. 

  150. 	return Typps.Utility.getInstance()._applyShade(element, shaderColor, transparency, zIndex);

    151. 

  151. }

    152. 

  152. Typps.Utility.setFloat = function Typps$Utility$setFloat(element, direction) {

    153. 

  153. 	return Typps.Utility.getInstance()._setFloat(element, direction);

    154. 

  154. }

    155. 

  155. Typps.Utility.setTransparency = function Typps$Utility$setTransparency(element, val1) {

    156. 

  156. 	return Typps.Utility.getInstance()._setTransparency(element, val1);

    157. 

  157. }

    158. 

  158. Typps.Utility.setBackGroundImage = function Typps$Utility$setBackGroundImage(element, imageUrl, repeat, position) {

    159. 

  159. 	return Typps.Utility.getInstance()._setBackGroundImage(element, imageUrl, repeat, position);

    160. 

  160. }

    161. 

  161. Typps.Utility.isDesignMode = function Typps$Utility$isDesignMode(doc) {

    162. 

  162. 	return Typps.Utility.getInstance()._isDesignMode(doc);

    163. 

  163. }

    164. 

  164. Typps.Utility.addScriptBlocks = function Typps$Utility$addScriptBlocks(id, evt, code) {

    165. 

  165. 	return Typps.Utility.getInstance()._addScriptBlocks(id, evt, code);

    166. 

  166. }

    167. 

  167. Typps.Utility.setDesignMode = function Typps$Utility$setDesignMode(doc, value) {

    168. 

  168. 	return Typps.Utility.getInstance()._setDesignMode(doc, value);

    169. 

  169. }

    170. 

  170. Typps.Utility.createBlockScreen = function Typps$Utility$createBlockScreen(id, shaderColor, shaderOpacity) {

    171. 

  171. 	return Typps.Utility.getInstance()._createBlockScreen(id, shaderColor, shaderOpacity);

    172. 

  172. }

    173. 

  173. Typps.Utility.toggleBlockScreen = function Typps$Utility$toggleBlockScreen(elem, zIndex) {

    174. 

  174. 	return Typps.Utility.getInstance()._toggleBlockScreen(elem, zIndex);

    175. 

  175. }

    176. 

  176. Typps.Utility.applyBlockScreenBounds = function Typps$Utility$applyBlockScreenBounds(id) {

    177. 

  177. 	return Typps.Utility.getInstance()._applyBlockScreenBounds(id);

    178. 

  178. }

    179. 

  179. Typps.Utility.setLocation = function Typps$Utility$setLocation(elem) {

    180. 

  180. 	return Typps.Utility.getInstance()._setLocation(elem);

    181. 

  181. }

    182. 

  182. Typps.Utility.getLocationByElement = function Typps$Utility$getLocationByElement(elem) {

    183. 

  183. 	return Typps.Utility.getInstance()._getLocationByElement(elem);

    184. 

  184. }

    185. 

  185. Typps.Utility.getLocationBySize = function Typps$Utility$getLocationBySize(width, height) {

    186. 

  186. 	return Typps.Utility.getInstance()._getLocationBySize(width, height);

    187. 

  187. }

    188. 

  188. Typps.Utility.toggleSelectElement = function Typps$Utility$toggleSelectElement(elem, selectCache) {

    189. 

  189. 	return Typps.Utility.getInstance()._toggleSelectElement(elem, selectCache);

    190. 

  190. }

    191. 

  191. Typps.Utility.isNullOrEmpty = function Typps$Utility$isNullOrEmpty(value) {

    192. 

  192. 	return Typps.Utility.getInstance()._isNullOrEmpty(value);

    193. 

  193. }

    194. 

  194. Typps.Utility.addRemoveClassName = function Typps$Utility$addRemoveClassName(elem, className, operation) {

    195. 

  195. 	return Typps.Utility.getInstance()._addRemoveClassName(elem, className, operation);

    196. 

  196. }

    197. 

  197. Typps.Utility.containsCssClass = function Typps$Utility$addRemoveClassName(elem, className) {

    198. 

  198. 	return Typps.Utility.getInstance()._containsCssClass(elem, className);

    199. 

  199. }

    200. 

  200. Typps.Utility.requiresParagraph = function Typps$Utility$requiresParagraph(node) {

    201. 

  201. 	return Typps.Utility.getInstance()._requiresParagraph(node);

    202. 

  202. }

    203. 

  203. Typps.Utility.getTokenId = function Typps$Utility$getTokenId(doc) {

    204. 

  204. 	return Typps.Utility.getInstance()._getTokenId(doc);

    205. 

  205. }

    206. 

  206. Typps.Utility.isEmptyTextNode = function Typps$Utility$isEmptyTextNode(node) {

    207. 

  207. 	return Typps.Utility.getInstance()._isEmptyTextNode(node);

    208. 

  208. }

    209. 

  209. Typps.Utility.isBr = function Typps$Utility$isBr(node) {

    210. 

  210. 	return Typps.Utility.getInstance()._isBr(node);

    211. 

  211. }

    212. 

  212. Typps.Utility.isElementNode = function Typps$Utility$isElementNode(node) {

    213. 

  213. 	return Typps.Utility.getInstance()._isElementNode(node);

    214. 

  214. }

    215. 

  215. Typps.Utility.insertAfter = function Typps$Utility$insertAfter(newNode, node) {

    216. 

  216. 	return Typps.Utility.getInstance()._insertAfter(newNode, node);

    217. 

  217. }

    218. 

  218. Typps.Utility.getForm = function Typps$Utility$getForm(id) {

    219. 

  219. 	return Typps.Utility.getInstance()._getForm(id);

    220. 

  220. }

    221. 

  221. Typps.Utility.prototype = {

    222. 

  222. 	_requiresParagraph: function (node) {

    223. 

  223. 		//nodeType 1 = Element node

    224. 

  224. 		if (node.nodeType != 1 || this._isEmptyTextNode(node) ||

    225. 

  225.             this._isNbsp(node))

    226. 

  226. 			return true;

    227. 

  227. 		var nodeName = node.nodeName.toLowerCase();

    228. 

  228. 		switch (nodeName) {

    229. 

  229. 			case 'br':

    230. 

  230. 			case 'hr':

    231. 

  231. 				return false;

    232. 

  232. 		}

    233. 

  233. 		for (var num1 = 0; num1 < this._blockContentNodes.length; num1++) {

    234. 

  234. 			var match = this._blockContentNodes[num1];

    235. 

  235. 			if (match == nodeName)

    236. 

  236. 				return false;

    237. 

  237. 		}

    238. 

  238. 		return true;

    239. 

  239. 	},

    240. 

  240. 	_insertAfter: function (parent, node, referenceNode) {

    241. 

  241. 		parent.insertBefore(node, referenceNode.nextSibling);

    242. 

  242. 	},

    243. 

  243. 	_paragraphWrap: function (node, doc) {

    244. 

  244. 		if (this._isNestedInBlockElement(node) ||

    245. 

  245.             !this._requiresParagraph(node))

    246. 

  246. 			return null;

    247. 

  247. 		var container = doc.createElement('p');

    248. 

  248. 		var newParagraph = doc.createElement('p');

    249. 

  249. 		this._insertAfter(node.parentNode, container, node);

    250. 

  250. 		while (node != null) {

    251. 

  251. 			var currentNode = node;

    252. 

  252. 			node = node.previousSibling;

    253. 

  253. 			if (this._requiresParagraph(currentNode))

    254. 

  254. 				container.insertBefore(currentNode.parentNode.removeChild(currentNode), container.firstChild);

    255. 

  255. 			else

    256. 

  256. 				break;

    257. 

  257. 		}

    258. 

  258. 		this._insertAfter(container.parentNode, newParagraph, container);

    259. 

  259. 		var br = doc.createElement('br');

    260. 

  260. 		newParagraph.appendChild(br);

    261. 

  261. 		return br;

    262. 

  262. 	},

    263. 

  263. 	_isPreWrapped: function (textNode) {

    264. 

  264. 		var parentNode = textNode.parentNode;

    265. 

  265. 		while (parentNode) {

    266. 

  266. 			if (parentNode.nodeName.toLowerCase() == 'pre')

    267. 

  267. 				return true;

    268. 

  268. 			parentNode = parentNode.parentNode;

    269. 

  269. 		}

    270. 

  270. 		return false;

    271. 

  271. 	},

    272. 

  272. 	_isNbsp: function (textNode) {

    273. 

  273. 		if (textNode.nodeType != 3)

    274. 

  274. 			return false;

    275. 

  275. 		var pat = /\u00A0/;

    276. 

  276. 		return textNode.nodeValue.match(pat);

    277. 

  277. 	},

    278. 

  278. 	_isNestedInBlockElement: function (element) {

    279. 

  279. 		for (var num1 = 0; num1 < this._blockContentNodes.length; num1++) {

    280. 

  280. 			var tagName = this._blockContentNodes[num1];

    281. 

  281. 			while (element.nodeName.toLowerCase() != tagName) {

    282. 

  282. 				element = element.parentNode;

    283. 

  283. 				if (element == null || element.nodeName.toLowerCase() == 'body')

    284. 

  284. 					return false;

    285. 

  285. 			}

    286. 

  286. 			if (element.nodeName.toLowerCase() == tagName)

    287. 

  287. 				break;

    288. 

  288. 		}

    289. 

  289. 		return true;

    290. 

  290. 	},

    291. 

  291. 	_getFormKeyValuePair: function (id, formKeyValuePair, form, includeAll) {

    292. 

  292. 		var formBody = new Sys.StringBuilder();

    293. 

  293. 		for (var s in formKeyValuePair) {

    294. 

  294. 			if (s != 'formdata')

    295. 

  295. 				formBody.append(String.format('{0}={1}&', s, encodeURIComponent(formKeyValuePair[s])));

    296. 

  296. 			else

    297. 

  297. 				formBody.append(String.format('{0}${1}={2}&', s, id, encodeURIComponent(formKeyValuePair[s])));

    298. 

  298. 		}

    299. 

  299. 		formBody.append(String.format('iscallback${0}=true&', id));

    300. 

  300. 		formBody.append('iscallback$Typps=true&');

    301. 

  301. 		if (includeAll) {

    302. 

  302. 			var count = form.elements.length;

    303. 

  303. 			for (var i = 0; i < count; i++) {

    304. 

  304. 				var element = form.elements[i];

    305. 

  305. 				var name = element.name;

    306. 

  306. 				if (typeof (name) === "undefined" || (name === null) || (name.length === 0)) {

    307. 

  307. 					continue;

    308. 

  308. 				}

    309. 

  309. 				var tagName = element.tagName;

    310. 

  310. 				if (tagName === 'INPUT') {

    311. 

  311. 					var type = element.type;

    312. 

  312. 					if ((type === 'text') ||

    313. 

  313.                         (type === 'password') ||

    314. 

  314.                         (type === 'hidden') ||

    315. 

  315.                         (((type === 'checkbox') || (type === 'radio')) && element.checked)) {

    316. 

  316. 						formBody.append(encodeURIComponent(name));

    317. 

  317. 						formBody.append('=');

    318. 

  318. 						formBody.append(encodeURIComponent(element.value));

    319. 

  319. 						formBody.append('&');

    320. 

  320. 					}

    321. 

  321. 				}

    322. 

  322. 				else if (tagName === 'SELECT') {

    323. 

  323. 					var optionCount = element.options.length;

    324. 

  324. 					for (var j = 0; j < optionCount; j++) {

    325. 

  325. 						var option = element.options[j];

    326. 

  326. 						if (option.selected) {

    327. 

  327. 							formBody.append(encodeURIComponent(name));

    328. 

  328. 							formBody.append('=');

    329. 

  329. 							formBody.append(encodeURIComponent(option.value));

    330. 

  330. 							formBody.append('&');

    331. 

  331. 						}

    332. 

  332. 					}

    333. 

  333. 				}

    334. 

  334. 				else if (tagName === 'TEXTAREA') {

    335. 

  335. 					formBody.append(encodeURIComponent(name));

    336. 

  336. 					formBody.append('=');

    337. 

  337. 					formBody.append(encodeURIComponent(element.value));

    338. 

  338. 					formBody.append('&');

    339. 

  339. 				}

    340. 

  340. 			}

    341. 

  341. 		}

    342. 

  342. 		return formBody.toString();

    343. 

  343. 	},

    344. 

  344. 	_getCommandArgument: function (commandName, callbacks) {

    345. 

  345. 		for (var index in callbacks) {

    346. 

  346. 			var c = callbacks[index];

    347. 

  347. 			if (c.commandName == commandName)

    348. 

  348. 				return c;

    349. 

  349. 		}

    350. 

  350. 		return { message: null, commandArgument: null };

    351. 

  351. 	},

    352. 

  352. 	_windowBounds: function (w) {

    353. 

  353. 		if (w == null)

    354. 

  354. 			w = window;

    355. 

  355. 		var inner = { x: 0, y: 0 };

    356. 

  356. 		var outer = { x: 0, y: 0 };

    357. 

  357. 		var doc = w.document;

    358. 

  358. 		if (w.innerHeight) {

    359. 

  359. 			inner.x = w.innerWidth;

    360. 

  360. 			inner.y = w.innerHeight;

    361. 

  361. 			outer.x = w.outerWidth;

    362. 

  362. 			outer.y = w.outerHeight;

    363. 

  363. 		}

    364. 

  364. 		else if (doc.documentElement && doc.documentElement.clientHeight) {

    365. 

  365. 			// Explorer 6 Strict Mode

    366. 

  366. 			inner.x = doc.documentElement.clientWidth;

    367. 

  367. 			inner.y = doc.documentElement.clientHeight;

    368. 

  368. 			outer.x = doc.documentElement.scrollWidth;

    369. 

  369. 			outer.y = doc.documentElement.scrollHeight;

    370. 

  370. 		}

    371. 

  371. 		else if (doc.body) {

    372. 

  372. 			// other Explorers

    373. 

  373. 			inner.x = doc.body.clientWidth;

    374. 

  374. 			inner.y = doc.body.clientHeight;

    375. 

  375. 			outer.x = doc.body.scrollWidth;

    376. 

  376. 			outer.y = doc.body.scrollHeight;

    377. 

  377. 		}

    378. 

  378. 		return { ix: inner.x, iy: inner.y, ox: outer.x, oy: outer.y };

    379. 

  379. 	},

    380. 

  380. 	_scrollDistance: function (w) {

    381. 

  381. 		if (w == null)

    382. 

  382. 			w = window;

    383. 

  383. 		var scroll = { x: 0, y: 0 };

    384. 

  384. 		var doc = w.document;

    385. 

  385. 		// all except Explorer

    386. 

  386. 		if (w.pageYOffset ||

    387. 

  387. 		    w.pageXOffset) {

    388. 

  388. 			scroll.x = w.scrollX;

    389. 

  389. 			scroll.y = w.scrollY;

    390. 

  390. 		}

    391. 

  391. 		else if (doc.documentElement && (doc.documentElement.scrollTop ||

    392. 

  392. 		        doc.documentElement.scrollLeft)) {

    393. 

  393. 			// Explorer 6 Strict

    394. 

  394. 			scroll.x = doc.documentElement.scrollLeft;

    395. 

  395. 			scroll.y = doc.documentElement.scrollTop;

    396. 

  396. 		}

    397. 

  397. 		// all other Explorers

    398. 

  398. 		else if (doc.body) {

    399. 

  399. 			scroll.x = doc.body.scrollLeft;

    400. 

  400. 			scroll.y = doc.body.scrollTop;

    401. 

  401. 		}

    402. 

  402. 		return scroll;

    403. 

  403. 	},

    404. 

  404. 	_getScrollBarWidth: function () {

    405. 

  405. 		var container = document.createElement('div');

    406. 

  406. 		container.style.position = 'absolute';

    407. 

  407. 		container.style.top = '-1000px';

    408. 

  408. 		container.style.left = '-1000px';

    409. 

  409. 		container.style.width = '100px';

    410. 

  410. 		container.style.height = '50px';

    411. 

  411. 		container.style.overflow = 'hidden';

    412. 

  412. 

    413. 

  413. 		var content = document.createElement('div');

    414. 

  414. 		content.style.width = '100%';

    415. 

  415. 		content.style.height = '200px';

    416. 

  416. 		container.appendChild(content);

    417. 

  417. 		document.body.appendChild(container);

    418. 

  418. 

    419. 

  419. 		var contentWidth = content.offsetWidth;

    420. 

  420. 		container.style.overflow = 'auto';

    421. 

  421. 		var containerWidth = content.offsetWidth;

    422. 

  422. 		container.parentNode.removeChild(container);

    423. 

  423. 

    424. 

  424. 		return (contentWidth - containerWidth);

    425. 

  425. 	},

    426. 

  426. 	_getParentOffset: function (elem) {

    427. 

  427. 		var position = { x: 0, y: 0 }, offsetParent;

    428. 

  428. 		do {

    429. 

  429. 			position.x += elem.offsetLeft;

    430. 

  430. 			position.y += elem.offsetTop;

    431. 

  431. 			offsetParent = elem.offsetParent;

    432. 

  432. 			if (offsetParent && (offsetParent.style.left != 0 || offsetParent.style.top != 0)) {

    433. 

  433. 				break;

    434. 

  434. 			}

    435. 

  435. 		} while (elem = offsetParent);

    436. 

  436. 		return position;

    437. 

  437. 	},

    438. 

  438. 	_getAdjacentHTML: function (markup, container) {

    439. 

  439. 		if (container.insertAdjacentHTML) { // IE and opera

    440. 

  440. 			container.insertAdjacentHTML('beforeEnd', markup);

    441. 

  441. 		}

    442. 

  442. 		else if (container.ownerDocument.createRange) { // all others, opera included.

    443. 

  443. 			var range = container.ownerDocument.createRange();

    444. 

  444. 			range.selectNodeContents(container);

    445. 

  445. 			range.deleteContents();

    446. 

  446. 			if (range.createContextualFragment) { // exclude opera, since it does not support it :-)

    447. 

  447. 				var documentFragment = range.createContextualFragment(markup);

    448. 

  448. 				container.appendChild(documentFragment);

    449. 

  449. 			}

    450. 

  450. 		}

    451. 

  451. 		return container;

    452. 

  452. 	},

    453. 

  453. 	_getIndexByNameFromOptions: function (value, options) {

    454. 

  454. 		for (var num1 = 0; num1 < options.length; num1++) {

    455. 

  455. 			var option = options[num1];

    456. 

  456. 			if (option.value.toLowerCase() == value.toLowerCase())

    457. 

  457. 				return num1;

    458. 

  458. 		}

    459. 

  459. 		return -1;

    460. 

  460. 	},

    461. 

  461. 	_applyShade: function (element, shaderColor, transparency, zIndex) {

    462. 

  462. 		var bounds = this.windowBounds();

    463. 

  463. 		element.style.width = bounds.ix + 'px';

    464. 

  464. 		element.style.height = bounds.iy + 'px';

    465. 

  465. 		element.style.zIndex = zIndex; // pick a random high zindex

    466. 

  466. 		Sys.UI.DomElement.setLocation(element, 0, 0);

    467. 

  467. 		element.style.backgroundColor = shaderColor;

    468. 

  468. 		this.setTransparency(element, transparency);

    469. 

  469. 	},

    470. 

  470. 	_setFloat: function (element, direction) {

    471. 

  471. 		if (element == null) return;

    472. 

  472. 		if (Sys.Browser.agent == Sys.Browser.InternetExplorer)

    473. 

  473. 			element.style.styleFloat = direction;

    474. 

  474. 		else

    475. 

  475. 			element.style.cssFloat = direction;

    476. 

  476. 	},

    477. 

  477. 	_setTransparency: function (element, val1) {

    478. 

  478. 		///val1 is transparency value as supported by IE, for non IE divide by 100

    479. 

  479. 		var val2 = val1 / 100;

    480. 

  480. 		if (Sys.Browser.agent == Sys.Browser.InternetExplorer) {

    481. 

  481. 			if (val1 == 100)

    482. 

  482. 				element.style.filter = '';

    483. 

  483. 			else

    484. 

  484. 				element.style.filter += String.format('progid:DXImageTransform.Microsoft.Alpha(Opacity={0})', val1);

    485. 

  485. 		}

    486. 

  486. 		else {

    487. 

  487. 			element.style.opacity = val2;

    488. 

  488. 		}

    489. 

  489. 	},

    490. 

  490. 	_setBackGroundImage: function (element, imageUrl, repeat, position) {

    491. 

  491. 		element.style.backgroundRepeat = repeat;

    492. 

  492. 		element.style.backgroundPosition = position;

    493. 

  493. 		element.style.backgroundImage = String.format("url({0})", imageUrl);

    494. 

  494. 	},

    495. 

  495. 	_isDesignMode: function (doc) {

    496. 

  496. 		var returnValue = false;

    497. 

  497. 		var designMode = doc.designMode.toLowerCase();

    498. 

  498. 		if (designMode == 'on')

    499. 

  499. 			returnValue = true;

    500. 

  500. 		if (Sys.Browser.agent == Sys.Browser.InternetExplorer) {

    501. 

  501. 			if (doc.body != null && doc.body.contentEditable == 'true')

    502. 

  502. 				returnValue = true;

    503. 

  503. 		}

    504. 

  504. 		return returnValue;

    505. 

  505. 	},

    506. 

  506. 	_setDesignMode: function (doc, value) {/*use contentEditable for ie, works better with dynamic css contained in the object tag*/

    507. 

  507. 		if (Sys.Browser.agent == Sys.Browser.InternetExplorer)

    508. 

  508. 			doc.body.contentEditable = value;

    509. 

  509. 		else

    510. 

  510. 			doc.designMode = (value == true) ? 'on' : 'off';

    511. 

  511. 	},

    512. 

  512. 	_addScriptBlocks: function (id, evt, code) {

    513. 

  513. 		var scriptclick = document.createElement('script');

    514. 

  514. 		scriptclick.htmlFor = id;

    515. 

  515. 		scriptclick.setAttribute('type', 'text/javascript');

    516. 

  516. 		scriptclick.event = 'on' + evt;

    517. 

  517. 		scriptclick.text = code;

    518. 

  518. 		document.getElementsByTagName('head')[0].appendChild(scriptclick);

    519. 

  519. 	},

    520. 

  520. 	_getNextHighestZindex: function (obj) {

    521. 

  521. 		var highestIndex = 0;

    522. 

  522. 		var currentIndex = 0;

    523. 

  523. 		var elArray = Array();

    524. 

  524. 		if (obj) { elArray = obj.getElementsByTagName('*'); } else { elArray = document.getElementsByTagName('*'); }

    525. 

  525. 		for (var i = 0; i < elArray.length; i++) {

    526. 

  526. 			if (elArray[i].currentStyle) {

    527. 

  527. 				currentIndex = parseFloat(elArray[i].currentStyle['zIndex']);

    528. 

  528. 			} else if (window.getComputedStyle) {

    529. 

  529. 				currentIndex = parseFloat(document.defaultView.getComputedStyle(elArray[i], null).getPropertyValue('z-index'));

    530. 

  530. 			}

    531. 

  531. 			if (!isNaN(currentIndex) && currentIndex > highestIndex) { highestIndex = currentIndex; }

    532. 

  532. 		}

    533. 

  533. 		return (highestIndex + 1);

    534. 

  534. 	},

    535. 

  535. 	_isAlphaNumericValidate: function (alphanumeric) {

    536. 

  536. 		var regex = /^[0-9a-zA-Z\s]+$/;

    537. 

  537. 		return regex.test(alphanumeric);

    538. 

  538. 	},

    539. 

  539. 	_regExpEscape: function (text) {

    540. 

  540. 		return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");

    541. 

  541. 	},

    542. 

  542. 	_createBlockScreen: function (id, shaderColor, shaderOpacity) {

    543. 

  543. 		var shadeElement = $get(id);

    544. 

  544. 		if (shadeElement == null) {

    545. 

  545. 			shadeElement = document.createElement('div');

    546. 

  546. 			shadeElement.id = id;

    547. 

  547. 			shadeElement.style.backgroundColor = shaderColor;

    548. 

  548. 			shadeElement.style.position = 'absolute';

    549. 

  549. 			shadeElement.style.left = '0px';

    550. 

  550. 			shadeElement.style.top = '0px';

    551. 

  551. 			this._setTransparency(shadeElement, shaderOpacity);

    552. 

  552. 			var container = document.body;

    553. 

  553. 			if ((Sys.Browser.agent == Sys.Browser.InternetExplorer &&

    554. 

  554.                             Sys.Browser.version == 6) && document.forms.length > 0)

    555. 

  555. 				container = document.forms[0];

    556. 

  556. 			container.appendChild(shadeElement);

    557. 

  557. 			shadeElement.style.display = 'none';

    558. 

  558. 		}

    559. 

  559. 		this._applyBlockScreenBounds(id);

    560. 

  560. 		return shadeElement;

    561. 

  561. 	},

    562. 

  562. 	_toggleBlockScreen: function (elem, zIndex) {

    563. 

  563. 		if (elem == null) return;

    564. 

  564. 		elem.style.zIndex = zIndex;

    565. 

  565. 		if (elem.style.display == '')

    566. 

  566. 			elem.style.display = 'none';

    567. 

  567. 		else

    568. 

  568. 			elem.style.display = '';

    569. 

  569. 	},

    570. 

  570. 	_applyBlockScreenBounds: function (id) {

    571. 

  571. 		var elem = $get(id);

    572. 

  572. 		if (elem == null) return;

    573. 

  573. 		var bounds = this._windowBounds();

    574. 

  574. 		var distance = this._scrollDistance();

    575. 

  575. 		var x = bounds.ix;

    576. 

  576. 		var y = bounds.iy;

    577. 

  577. 		var barWidth = 0;

    578. 

  578. 		if (Sys.Browser.agent != Sys.Browser.InternetExplorer)

    579. 

  579. 			barWidth = this._getScrollBarWidth();

    580. 

  580. 		var html = document.getElementsByTagName('html')[0];

    581. 

  581. 		if (html.scrollHeight > y && barWidth > 0)

    582. 

  582. 			x -= barWidth;

    583. 

  583. 		elem.style.width = x + distance.x + 'px';

    584. 

  584. 		elem.style.height = y + distance.y + 'px';

    585. 

  585. 	},

    586. 

  586. 	_setLocation: function (elem) {

    587. 

  587. 		if (elem == null) return;

    588. 

  588. 		var location = Typps.Utility.getLocationByElement(elem);

    589. 

  589. 		elem.style.left = location.x + 'px';

    590. 

  590. 		elem.style.top = location.y + 'px';

    591. 

  591. 	},

    592. 

  592. 	_getLocationByElement: function (elem) {

    593. 

  593. 		if (elem == null) return;

    594. 

  594. 		return this._getLocationBySize(elem.offsetWidth, elem.offsetHeight);

    595. 

  595. 	},

    596. 

  596. 	_getLocationBySize: function (width, height) {

    597. 

  597. 		var bounds = this._windowBounds();

    598. 

  598. 		var distance = this._scrollDistance();

    599. 

  599. 		var barWidth = 0;

    600. 

  600. 		if (Sys.Browser.agent != Sys.Browser.InternetExplorer)

    601. 

  601. 			barWidth = this._getScrollBarWidth();

    602. 

  602. 		var x = bounds.ix;

    603. 

  603. 		var y = bounds.iy;

    604. 

  604. 		var html = document.getElementsByTagName('html')[0];

    605. 

  605. 		if (html.scrollHeight > y && barWidth > 0)

    606. 

  606. 			x -= barWidth;

    607. 

  607. 		x = Math.round((x - width) / 2);

    608. 

  608. 		y = Math.round((y - height) / 2);

    609. 

  609. 		return { x: (x + distance.x), y: (y + distance.y) };

    610. 

  610. 	},

    611. 

  611. 	_toggleSelectElement: function (elem, selectsCache) {

    612. 

  612. 		if (Sys.Browser.agent == Sys.Browser.InternetExplorer && Sys.Browser.version <= 7) {

    613. 

  613. 			var selects = document.getElementsByTagName('SELECT');

    614. 

  614. 			//not all the selects! We want to ignore the ones in this popup

    615. 

  615. 			var selectsToIgnore = elem.getElementsByTagName('SELECT');

    616. 

  616. 			var sel = null;

    617. 

  617. 

    618. 

  618. 			if (selectsCache == null) {

    619. 

  619. 				for (var num1 = 0; num1 < selects.length; num1++) {

    620. 

  620. 					sel = selects[num1];

    621. 

  621. 					var skip = false;

    622. 

  622. 					if (selectsToIgnore.length > 0) {

    623. 

  623. 						for (var num2 = 0; num2 < selectsToIgnore.length; num2++) {

    624. 

  624. 							if (sel == selectsToIgnore[num2]) {

    625. 

  625. 								skip = true;

    626. 

  626. 								break;

    627. 

  627. 							}

    628. 

  628. 						}

    629. 

  629. 					}

    630. 

  630. 					if (skip == true) continue;

    631. 

  631. 					if (sel.style.display != 'none') {

    632. 

  632. 						sel.style.display = 'none';

    633. 

  633. 						if (selectsCache == null)

    634. 

  634. 							selectsCache = new Array();

    635. 

  635. 						selectsCache[selectsCache.length] = sel;

    636. 

  636. 					}

    637. 

  637. 				}

    638. 

  638. 			}

    639. 

  639. 			else {

    640. 

  640. 				var length = selectsCache.length;

    641. 

  641. 				for (var num3 = 0; num3 < length; num3++) {

    642. 

  642. 					sel = selectsCache.pop();

    643. 

  643. 					sel.style.display = '';

    644. 

  644. 				}

    645. 

  645. 				selectsCache = null;

    646. 

  646. 			}

    647. 

  647. 		}

    648. 

  648. 		return selectsCache;

    649. 

  649. 	},

    650. 

  650. 	_isNullOrEmpty: function (value) {

    651. 

  651. 		var isNullOrEmpty = true;

    652. 

  652. 		if (value) {

    653. 

  653. 			if (typeof (value) == 'string') {

    654. 

  654. 				if (value.length > 0)

    655. 

  655. 					isNullOrEmpty = false;

    656. 

  656. 			}

    657. 

  657. 		}

    658. 

  658. 		return isNullOrEmpty;

    659. 

  659. 	},

    660. 

  660. 	_addRemoveClassName: function (elem, className, operation) {

    661. 

  661. 		var add = operation == Typps.Perform.Add;

    662. 

  662. 		var remove = operation == Typps.Perform.Remove;

    663. 

  663. 		var toggle = operation == Typps.Perform.Toggle;

    664. 

  664. 		var containsCssClass = this._containsCssClass(elem, className);

    665. 

  665. 		if (!containsCssClass && remove) return;

    666. 

  666. 		if (containsCssClass && add) return;

    667. 

  667. 

    668. 

  668. 		var namesList = className.split(' ');

    669. 

  669. 		if (namesList.length > 0) {

    670. 

  670. 			for (var index in namesList) {

    671. 

  671. 				var cn = namesList[index];

    672. 

  672. 				if (cn != '') {

    673. 

  673. 					var containsClass = Sys.UI.DomElement.containsCssClass(elem, cn);

    674. 

  674. 					if (add) {

    675. 

  675. 						if (!containsClass)

    676. 

  676. 							Sys.UI.DomElement.addCssClass(elem, cn);

    677. 

  677. 					} else if (remove) {

    678. 

  678. 						if (containsClass)

    679. 

  679. 							Sys.UI.DomElement.removeCssClass(elem, cn);

    680. 

  680. 					} else if (toggle) {

    681. 

  681. 						if (containsCssClass)

    682. 

  682. 							Sys.UI.DomElement.removeCssClass(elem, cn);

    683. 

  683. 						else

    684. 

  684. 							Sys.UI.DomElement.addCssClass(elem, cn);

    685. 

  685. 					}

    686. 

  686. 				}

    687. 

  687. 			}

    688. 

  688. 		}

    689. 

  689. 		if (elem.className == '') {

    690. 

  690. 			if (this._isIE)

    691. 

  691. 				elem.removeAttribute('className');

    692. 

  692. 			else

    693. 

  693. 				elem.removeAttribute('class');

    694. 

  694. 		}

    695. 

  695. 	},

    696. 

  696. 	_containsCssClass: function (elem, className) {

    697. 

  697. 		var namesList = className.split(' ');

    698. 

  698. 		var returnValue = false;

    699. 

  699. 		if (namesList.length > 0) {

    700. 

  700. 			for (var index in namesList) {

    701. 

  701. 				var cn = namesList[index];

    702. 

  702. 				if (cn != '') {

    703. 

  703. 					var containsClass = Sys.UI.DomElement.containsCssClass(elem, cn);

    704. 

  704. 					//match all classes in list

    705. 

  705. 					if (containsClass)

    706. 

  706. 						returnValue = true;

    707. 

  707. 					else

    708. 

  708. 						returnValue = false;

    709. 

  709. 				}

    710. 

  710. 			}

    711. 

  711. 		}

    712. 

  712. 		return returnValue;

    713. 

  713. 	},

    714. 

  714. 	_getTokenId: function (doc) {

    715. 

  715. 		var tokenId = 'token';

    716. 

  716. 		var tokenIndex = 0;

    717. 

  717. 		while ($get(String.format('{0}{1}', tokenId, tokenIndex), doc)) {

    718. 

  718. 			tokenIndex++;

    719. 

  719. 		}

    720. 

  720. 		return tokenId += tokenIndex;

    721. 

  721. 	},

    722. 

  722. 	_isEmptyTextNode: function (node) {

    723. 

  723. 		if (node != null && (node.nodeType == 3 && node.data.trim() == ''))

    724. 

  724. 			return true;

    725. 

  725. 		return false;

    726. 

  726. 	},

    727. 

  727. 	_isBr: function (node) {

    728. 

  728. 		if (node != null && (node.nodeType == 1 && node.nodeName.toLowerCase() == 'br'))

    729. 

  729. 			return true;

    730. 

  730. 		return false;

    731. 

  731. 	},

    732. 

  732. 	_isElementNode: function (node) {

    733. 

  733. 		if (node != null && (node.nodeType == 1)) return true;

    734. 

  734. 		return false;

    735. 

  735. 	},

    736. 

  736. 	_insertAfter: function (newNode, node) {

    737. 

  737. 		if (!node.nextSibling)

    738. 

  738. 			node.parentNode.appendChild(newNode);

    739. 

  739. 		else

    740. 

  740. 			node.parentNode.insertBefore(newNode, node.nextSibling);

    741. 

  741. 	},

    742. 

  742. 	_getForm: function (id) {

    743. 

  743. 		var form = null;

    744. 

  744. 		if (!Typps.Utility.isNullOrEmpty(id))

    745. 

  745. 			form = $get(id);

    746. 

  746. 		if (!form)

    747. 

  747. 			form = document.forms[0];

    748. 

  748. 		return form;

    749. 

  749. 	},

    750. 

  750. 	_splitText: function (doc, node, offset) {

    751. 

  751. 		if (node.nodeType != 3) return;

    752. 

  752. 		var nextSibling, newTextNode;

    753. 

  753. 		if (node.length == offset) {

    754. 

  754. 			nextSibling = node.nextSibling;

    755. 

  755. 			newTextNode = doc.createTextNode('');

    756. 

  756. 			if (nextSibling == null) {

    757. 

  757. 				node.parentNode.appendChild(newTextNode);

    758. 

  758. 			} else {

    759. 

  759. 				node.parentNode.insertBefore(newTextNode, nextSibling);

    760. 

  760. 			}

    761. 

  761. 		}

    762. 

  762. 		else {

    763. 

  763. 			return node.splitText(offset);

    764. 

  764. 		}

    765. 

  765. 		return newTextNode;

    766. 

  766. 	}

    767. 

  767. }

    768. 

  768. Typps.Utility.registerClass('Typps.Utility');

    769. 

  769. // Since this script is not loaded by System.Web.Handlers.ScriptResourceHandler

    770. 

  770. // invoke Sys.Application.notifyScriptLoaded to notify ScriptManager 

    771. 

  771. // that this is the end of the script.

    772. 

  772. if (typeof (Sys) !== 'undefined') Sys.Application.notifyScriptLoaded(); 

    773. 

  773.