/SPUtility.js

http://sputility.codeplex.com · JavaScript · 1235 lines · 879 code · 167 blank · 189 comment · 146 complexity · b121bff26cb367d30a057136ce4b14cb MD5 · raw file 

    

  1. /*

    2. 

  2. 	Name: SPUtility.js

    3. 

  3. 	Version: 0.8.1

    4. 

  4. 	Description: 

    5. 

  5. 		A JavaScript library that is used to alter SharePoint's user interface

    6. 

  6. 		(mostly NewForm and EditForm). It can be used to populate fields, make

    7. 

  7. 		fields read only, or hide a field from view.

    8. 

  8. 	Author: Kit Menke

    9. 

  9. 	http://SPUtility.codeplex.com/

    10. 

  10. 	License: Microsoft Public License (see http://sputility.codeplex.com/license)

    11. 

  11. 	Changelog: http://sputility.codeplex.com/wikipage?title=Changelog

    12. 

  12. */

    13. 

  13. 

    14. 

  14. /*jslint white: true, browser: true, devel: true, onevar: true, undef: true, eqeqeq: true, plusplus: true, bitwise: true, regexp: true, newcap: true, immed: true, indent: 3 */

    15. 

  15. /*global Element: false, Class: false, $: false, $$: false, $A: false, Hash: false, Event: false, Prototype: false, $break: false, $H: false, RTE_GetIFrameContents: false, RTE_TransferTextAreaContentsToIFrame: false, RTE_GetEditorIFrame: false */

    16. 

  16. 

    17. 

  17. 

    18. 

  18. // getTextContent credit to Dan Dean

    19. 

  19. // http://dandean.com/category/code/2009/hatin-on-textcontent-and-innertext/

    20. 

  20. Element.addMethods({

    21. 

  21. 	/**

    22. 

  22. 	*  Element#getTextContent(@element) -> String

    23. 

  23. 	*  Cross-browser means of getting Element#textContent or Element#innerText

    24. 

  24. 	**/

    25. 

  25. 	getTextContent: function (element) {

    26. 

  26. 		if (!Object.isUndefined(element.textContent)) {

    27. 

  27. 			return element.textContent;

    28. 

  28. 		}

    29. 

  29. 		return element.innerText;

    30. 

  30. 	},

    31. 

  31. 	

    32. 

  32. 	setTextContent: function (element, value) {

    33. 

  33. 		if (!Object.isUndefined(element.textContent)) {

    34. 

  34. 			element.textContent = value;

    35. 

  35. 		}

    36. 

  36. 		element.innerText = value;

    37. 

  37. 	}

    38. 

  38. });

    39. 

  39. 

    40. 

  40. //+ Jonas Raoni Soares Silva

    41. 

  41. //@ http://jsfromhell.com/number/fmt-money [rev. #2]

    42. 

  42. // Modified to pass JSLint

    43. 

  43. // c = # of floating point decimal places

    44. 

  44. // d = decimal separator

    45. 

  45. // t = thousands separator

    46. 

  46. Number.prototype.formatMoney = function (c, d, t) {

    47. 

  47. 	c = (isNaN(c = Math.abs(c)) ? 2 : c);

    48. 

  48. 	d = (d === undefined ? "." : d);

    49. 

  49. 	t = (t === undefined ? "," : t);

    50. 

  50. 	var n = this, 

    51. 

  51. 		s = (n < 0 ? "-" : ""),

    52. 

  52. 		i = parseInt(n = Math.abs(+n || 0).toFixed(c), 10) + "", 

    53. 

  53. 		j = (j = i.length) > 3 ? j % 3 : 0;

    54. 

  54. 	return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "");

    55. 

  55. };

    56. 

  56. 

    57. 

  57. /*

    58. 

  58.  *	SPUtility namespace

    59. 

  59.  */

    60. 

  60. var SPUtility = (function () {

    61. 

  61. 	"use strict";

    62. 

  62. 	

    63. 

  63. 	/*

    64. 

  64. 	 *	SPUtility Private Variables

    65. 

  65. 	**/

    66. 

  66. 	

    67. 

  67. 	var SPField, SPTextField, SPUserField, SPURLField, SPChoiceField, 

    68. 

  68. 		SPDateTimeField, SPDateTimeFieldValue, SPFileField, SPCurrencyField, 

    69. 

  69. 		SPNumberField, SPBooleanField, SPNoteField, SPLookupField, SPLookupMultiField,

    70. 

  70. 		_fieldsHashtable = null,

    71. 

  71. 		_debugMode = false,

    72. 

  72. 		_isSurveyForm = false,

    73. 

  73. 		_numErrors = 0; 

    74. 

  74. 	

    75. 

  75. 	/*

    76. 

  76. 	 *	SPUtility Private Methods

    77. 

  77. 	**/

    78. 

  78. 	

    79. 

  79. 	function log(message, exception) {

    80. 

  80. 		var property;

    81. 

  81. 		try {

    82. 

  82. 			if (!_debugMode) {

    83. 

  83. 				return;

    84. 

  84. 			}

    85. 

  85. 			if (exception) {

    86. 

  86. 				message += '\r\n';

    87. 

  87. 				for (property in exception) {

    88. 

  88. 					if (exception.hasOwnProperty(property)) {

    89. 

  89. 						message += property + ': ' + exception[property] + '\r\n';

    90. 

  90. 					}

    91. 

  91. 				}

    92. 

  92. 			}

    93. 

  93. 			if (Prototype.Browser.IE || Object.isUndefined(console)) {

    94. 

  94. 				_numErrors += 1;

    95. 

  95. 				if (_numErrors === 3) {

    96. 

  96. 					message = "More than 3 errors (additional errors will not be shown):\r\n" + message;

    97. 

  97. 				}

    98. 

  98. 				if (_numErrors <= 3) {

    99. 

  99. 					alert(message);

    100. 

  100. 				}

    101. 

  101. 			} else {

    102. 

  102. 				console.error(message);

    103. 

  103. 			}

    104. 

  104. 		} catch (ex) { }

    105. 

  105. 	}

    106. 

  106. 	

    107. 

  107. 	function convertStringToNumber(val) {

    108. 

  108. 		if (typeof val === "string") {

    109. 

  109. 			var match = val.match(/[0-9,.]+/g);

    110. 

  110. 			if (null !== match) {

    111. 

  111. 				val = match[0].replace(/,/g, ''); // commas to delimit thousands need to be removed

    112. 

  112. 				val = parseFloat(val);

    113. 

  113. 			}

    114. 

  114. 		}

    115. 

  115. 		return val;

    116. 

  116. 	}

    117. 

  117. 	

    118. 

  118. 	// Gets the input controls for a field (used for Textboxes)

    119. 

  119. 	function getInputControl(spField) {

    120. 

  120. 		var controls = spField.Controls.select('input');

    121. 

  121. 		if (null !== controls && 1 === controls.length) {

    122. 

  122. 			return controls[0];

    123. 

  123. 		}

    124. 

  124. 		

    125. 

  125. 		throw 'Unable to retrieve the input control for ' + spField.Name;

    126. 

  126. 	}

    127. 

  127. 	

    128. 

  128. 	function getHashFromInputControls(spField, selector) {

    129. 

  129. 		var oHash = null, inputTags = spField.Controls.select(selector), inputLabel, key;

    130. 

  130. 		if (null !== inputTags && inputTags.length > 0) {

    131. 

  131. 			oHash = new Hash();

    132. 

  132. 			

    133. 

  133. 			inputTags.each(function (elem) {

    134. 

  134. 				inputLabel = elem.next(0);

    135. 

  135. 				if (!Object.isUndefined(inputLabel)) {

    136. 

  136. 					key = inputLabel.getTextContent();

    137. 

  137. 					oHash.set(key, elem);

    138. 

  138. 				}

    139. 

  139. 			});

    140. 

  140. 		}

    141. 

  141. 		return oHash;

    142. 

  142. 	}

    143. 

  143. 	

    144. 

  144. 	function getSPFieldType(element) {

    145. 

  145. 		var matches, comment, n;

    146. 

  146. 		try {

    147. 

  147. 			// find the HTML comment and get the field's type

    148. 

  148. 			for (n = 0; n < element.childNodes.length; n += 1) {

    149. 

  149. 				if (8 === element.childNodes[n].nodeType) {

    150. 

  150. 					comment = element.childNodes[n].data;

    151. 

  151. 					matches = comment.match(/SPField\w+/);

    152. 

  152. 					if (null !== matches) {

    153. 

  153. 						return matches[0];

    154. 

  154. 					}

    155. 

  155. 					break;

    156. 

  156. 				}

    157. 

  157. 			}			

    158. 

  158. 		} catch (ex) {

    159. 

  159. 			log('getSPFieldType: Error getting field type', ex);

    160. 

  160. 		}

    161. 

  161. 		return null;

    162. 

  162. 	}

    163. 

  163. 	

    164. 

  164. 	function getSPFieldFromType(spFieldParams) {

    165. 

  165. 		var field = null;

    166. 

  166. 		

    167. 

  167. 		switch (spFieldParams.type) {

    168. 

  168. 		case 'SPFieldText':

    169. 

  169. 			field = new SPTextField(spFieldParams);

    170. 

  170. 			break;

    171. 

  171. 		case 'SPFieldNote':

    172. 

  172. 			field = new SPNoteField(spFieldParams);

    173. 

  173. 			break;

    174. 

  174. 		case 'SPFieldBoolean':

    175. 

  175. 			field = new SPBooleanField(spFieldParams);

    176. 

  176. 			break;

    177. 

  177. 		case 'SPFieldNumber':

    178. 

  178. 			field = new SPNumberField(spFieldParams);

    179. 

  179. 			break;

    180. 

  180. 		case 'SPFieldCurrency':

    181. 

  181. 			field = new SPCurrencyField(spFieldParams);

    182. 

  182. 			break;

    183. 

  183. 		case 'SPFieldFile':

    184. 

  184. 			field = new SPFileField(spFieldParams);

    185. 

  185. 			break;

    186. 

  186. 		case 'SPFieldDateTime':

    187. 

  187. 			field = new SPDateTimeField(spFieldParams);

    188. 

  188. 			break;

    189. 

  189. 		case 'SPFieldChoice':

    190. 

  190. 		case 'SPFieldMultiChoice':

    191. 

  191. 			field = new SPChoiceField(spFieldParams);

    192. 

  192. 			break;

    193. 

  193. 		case 'SPFieldURL':

    194. 

  194. 			field = new SPURLField(spFieldParams);

    195. 

  195. 			break;

    196. 

  196. 		case 'SPFieldUser':

    197. 

  197. 		case 'SPFieldUserMulti':

    198. 

  198. 			field = new SPUserField(spFieldParams);

    199. 

  199. 			break;

    200. 

  200. 		case 'SPFieldLookup':

    201. 

  201. 			field = new SPLookupField(spFieldParams);

    202. 

  202. 			break;

    203. 

  203. 		case 'SPFieldLookupMulti':

    204. 

  204. 			field = new SPLookupMultiField(spFieldParams);

    205. 

  205. 			break;

    206. 

  206. 		default:

    207. 

  207. 			field = new SPField(spFieldParams);

    208. 

  208. 			break;

    209. 

  209. 		}

    210. 

  210. 		return field;

    211. 

  211. 	}

    212. 

  212. 	

    213. 

  213. 	function createSPField(spFieldParams) {

    214. 

  214. 		var field = null;

    215. 

  215. 		try {

    216. 

  216. 			if (null === spFieldParams.controlsCell) {

    217. 

  217. 				// the only time this property will NOT be null is in survey forms

    218. 

  218. 				spFieldParams.controlsCell = spFieldParams.labelCell.next();

    219. 

  219. 				// use nextSibling?

    220. 

  220. 			}

    221. 

  221. 			spFieldParams.type = getSPFieldType(spFieldParams.controlsCell);

    222. 

  222. 			

    223. 

  223. 			// if we can't get the type then we can't create the field

    224. 

  224. 			if (null === spFieldParams.type) {

    225. 

  225. 				return null;

    226. 

  226. 			}

    227. 

  227. 			

    228. 

  228. 			field = getSPFieldFromType(spFieldParams);

    229. 

  229. 		} catch (e) {

    230. 

  230. 			log('createSPField: Error creating field for ' + spFieldParams.name, e);

    231. 

  231. 		}

    232. 

  232. 		return field;

    233. 

  233. 	}

    234. 

  234. 	

    235. 

  235. 	function getFieldParams(elemTD, surveyElemTD, isSurveyForm) {

    236. 

  236. 		var fieldParams = null, fieldName = 'Unknown field', elemLabel, isRequired;

    237. 

  237. 		try {

    238. 

  238. 			if (isSurveyForm) {

    239. 

  239. 				elemLabel = elemTD;

    240. 

  240. 			} else {

    241. 

  241. 				// navigate TD -> ??

    242. 

  242. 				elemLabel = elemTD.firstDescendant();

    243. 

  243. 				if (null === elemLabel || elemLabel.nodeName === 'NOBR') {

    244. 

  244. 					return null; // attachments row not currently supported

    245. 

  245. 				}

    246. 

  246. 			}

    247. 

  247. 			

    248. 

  248. 			fieldName = (elemLabel.getTextContent()).strip();

    249. 

  249. 			isRequired = fieldName.endsWith(' *');

    250. 

  250. 			

    251. 

  251. 			if (true === isRequired) {

    252. 

  252. 				fieldName = fieldName.substring(0, fieldName.length - 2);

    253. 

  253. 			}

    254. 

  254. 			

    255. 

  255. 			fieldParams = {

    256. 

  256. 				'name': fieldName,

    257. 

  257. 				'label': $(elemLabel),

    258. 

  258. 				'labelRow': $(elemTD.parentNode),

    259. 

  259. 				'labelCell': elemTD,

    260. 

  260. 				'isRequired': isRequired,

    261. 

  261. 				'controlsRow': Object.isUndefined(surveyElemTD) ? null : $(surveyElemTD.parentNode),

    262. 

  262. 				'controlsCell': Object.isUndefined(surveyElemTD) ? null : surveyElemTD,

    263. 

  263. 				'type': null,

    264. 

  264. 				'spField': null

    265. 

  265. 			};

    266. 

  266. 		} catch (e) {

    267. 

  267. 			log('getFieldParams: Error getting field parameters ' + fieldName, e);

    268. 

  268. 		}

    269. 

  269. 		return fieldParams;

    270. 

  270. 	}

    271. 

  271. 	

    272. 

  272. 	function lazyLoadSPFields() {

    273. 

  273. 		if (null === _fieldsHashtable) {

    274. 

  274. 			var i, fieldParams,

    275. 

  275. 				fieldElements = $$('table.ms-formtable td.ms-formlabel'),

    276. 

  276. 				surveyElements = $$('table.ms-formtable td.ms-formbodysurvey'),

    277. 

  277. 				len = fieldElements.length;

    278. 

  278. 

    279. 

  279. 			_isSurveyForm = (surveyElements.length > 0);

    280. 

  280. 			_fieldsHashtable = new Hash();

    281. 

  281. 			

    282. 

  282. 			for (i = 0; i < len; i += 1) {

    283. 

  283. 				fieldParams = getFieldParams(fieldElements[i], surveyElements[i], _isSurveyForm);

    284. 

  284. 				if (null !== fieldParams) {

    285. 

  285. 					_fieldsHashtable.set(fieldParams.name, fieldParams);

    286. 

  286. 				}

    287. 

  287. 			}

    288. 

  288. 		}

    289. 

  289. 	}

    290. 

  290. 	

    291. 

  291. 	function toggleSPFieldRows(labelRow, controlsRow, bShowField) {

    292. 

  292. 		// controlsRow is populated on survey forms (null otherwise)

    293. 

  293. 		if (bShowField) {

    294. 

  294. 			labelRow.show();

    295. 

  295. 			if (null !== controlsRow) {

    296. 

  296. 				controlsRow.show();

    297. 

  297. 			}

    298. 

  298. 		} else {

    299. 

  299. 			labelRow.hide();

    300. 

  300. 			if (null !== controlsRow) {

    301. 

  301. 				controlsRow.hide();

    302. 

  302. 			}

    303. 

  303. 		}

    304. 

  304. 	}

    305. 

  305. 	

    306. 

  306. 	function toggleSPField(strFieldName, bShowField) {

    307. 

  307. 		lazyLoadSPFields();

    308. 

  308. 			

    309. 

  309. 		var fieldParams = _fieldsHashtable.get(strFieldName);

    310. 

  310. 		

    311. 

  311. 		if (Object.isUndefined(fieldParams)) { 

    312. 

  312. 			log('toggleSPField: Unable to find a SPField named ' + strFieldName + ' - ' + bShowField);

    313. 

  313. 			return;

    314. 

  314. 		}

    315. 

  315. 		

    316. 

  316. 		toggleSPFieldRows(fieldParams.labelRow, fieldParams.controlsRow, bShowField);

    317. 

  317. 	}

    318. 

  318. 	

    319. 

  319. 	function updateReadOnlyLabel(spField, value) {

    320. 

  320. 		if (spField.ReadOnlyLabel) {

    321. 

  321. 			spField.ReadOnlyLabel.update(spField.GetValue());

    322. 

  322. 		}

    323. 

  323. 	}

    324. 

  324. 	

    325. 

  325. 	function makeReadOnly(spField, htmlToInsert) {

    326. 

  326. 		try {

    327. 

  327. 			Element.hide(spField.Controls);

    328. 

  328. 			if (null === spField.ReadOnlyLabel) {

    329. 

  329. 				spField.ReadOnlyLabel = new Element('div');

    330. 

  330. 				spField.ReadOnlyLabel.addClassName('sputility-readonly');

    331. 

  331. 				Element.insert(spField.Controls, { after: spField.ReadOnlyLabel });

    332. 

  332. 			}

    333. 

  333. 			spField.ReadOnlyLabel.update(htmlToInsert);

    334. 

  334. 			spField.ReadOnlyLabel.show();

    335. 

  335. 		} catch (ex) {

    336. 

  336. 			alert('Error making ' + spField.Name + ' read only. ' + ex.toString());

    337. 

  337. 		}

    338. 

  338. 		return spField;

    339. 

  339. 	}

    340. 

  340. 	

    341. 

  341. 	function arrayToSemicolonList(arr) {

    342. 

  342. 		var text = '';

    343. 

  343. 		

    344. 

  344. 		arr.each(function (value) {

    345. 

  345. 			text += value + '; ';

    346. 

  346. 		});

    347. 

  347. 		

    348. 

  348. 		if (text.length > 2) {

    349. 

  349. 			text = text.substring(0, text.length - 2);

    350. 

  350. 		}

    351. 

  351. 		

    352. 

  352. 		return text;

    353. 

  353. 	}

    354. 

  354. 	

    355. 

  355. 	/*

    356. 

  356. 	 *	SPUtility Classes

    357. 

  357. 	**/

    358. 

  358. 	

    359. 

  359. 	/*

    360. 

  360. 	 *	SPField class

    361. 

  361. 	 *	Contains all of the common properties and functions used by the specialized

    362. 

  362. 	 *	sub-classes. Typically, this should not be intantiated directly.

    363. 

  363. 	 */

    364. 

  364. 	SPField = Class.create({

    365. 

  365. 		initialize: function (fieldParams) {

    366. 

  366. 			// Public Properties

    367. 

  367. 			this.Label = fieldParams.label;

    368. 

  368. 			this.LabelRow = fieldParams.labelRow;

    369. 

  369. 			this.Name = fieldParams.name;

    370. 

  370. 			this.IsRequired = fieldParams.isRequired;

    371. 

  371. 			this.Type = fieldParams.type;

    372. 

  372. 			this.Controls = fieldParams.controlsCell.firstDescendant();

    373. 

  373. 			this.ControlsRow = fieldParams.controlsRow;

    374. 

  374. 			this.ReadOnlyLabel = null;

    375. 

  375. 		},

    376. 

  376. 		

    377. 

  377. 		/*

    378. 

  378. 		 *	Public SPField Methods

    379. 

  379. 		 */

    380. 

  380. 		Show: function () {

    381. 

  381. 			toggleSPFieldRows(this.LabelRow, this.ControlsRow, true);

    382. 

  382. 			return this;

    383. 

  383. 		},

    384. 

  384. 		

    385. 

  385. 		Hide: function () {

    386. 

  386. 			toggleSPFieldRows(this.LabelRow, this.ControlsRow, false);

    387. 

  387. 			return this;

    388. 

  388. 		},

    389. 

  389. 		

    390. 

  390. 		MakeReadOnly: function () {

    391. 

  391. 			return makeReadOnly(this, this.GetValue().toString());

    392. 

  392. 		},

    393. 

  393. 		  

    394. 

  394. 		MakeEditable: function () {

    395. 

  395. 			try {

    396. 

  396. 				Element.show(this.Controls);

    397. 

  397. 				if (null !== this.ReadOnlyLabel) {

    398. 

  398. 					this.ReadOnlyLabel.hide();

    399. 

  399. 				}

    400. 

  400. 			} catch (ex) {

    401. 

  401. 				alert('Error making ' + this.Name + ' editable. ' + ex.toString());

    402. 

  402. 			}

    403. 

  403. 			return this;

    404. 

  404. 		},

    405. 

  405. 		

    406. 

  406. 		toString: function () {

    407. 

  407. 			return this.Name;		

    408. 

  408. 		},

    409. 

  409. 		

    410. 

  410. 		/*

    411. 

  411. 		 *	Public SPField Override Methods

    412. 

  412. 		 *	All of the below methods need to be implemented in each sub-class

    413. 

  413. 		 */

    414. 

  414. 		GetValue: function () {

    415. 

  415. 			throw 'GetValue not yet implemented for ' + this.Type + ' in ' + this.Name;

    416. 

  416. 		},

    417. 

  417. 		

    418. 

  418. 		SetValue: function (value) {

    419. 

  419. 			throw 'SetValue not yet implemented for ' + this.Type + ' in ' + this.Name;

    420. 

  420. 		}

    421. 

  421. 	});

    422. 

  422. 	

    423. 

  423. 	/*

    424. 

  424. 	 *	SPTextField class

    425. 

  425. 	 *	Supports Single line of text and Currency fields (base class for number fields)

    426. 

  426. 	 */

    427. 

  427. 	SPTextField = Class.create(SPField, {

    428. 

  428. 		initialize: function ($super, spParams) {

    429. 

  429. 			$super(spParams);

    430. 

  430. 			

    431. 

  431. 			this.Textbox = getInputControl(this);

    432. 

  432. 		},

    433. 

  433. 		

    434. 

  434. 		/*

    435. 

  435. 		 *	SPTextField Public Methods

    436. 

  436. 		 *	Overrides SPField class methods.

    437. 

  437. 		 */

    438. 

  438. 		GetValue: function () {

    439. 

  439. 			return this.Textbox.getValue();

    440. 

  440. 		},

    441. 

  441. 		

    442. 

  442. 		SetValue: function (value) {

    443. 

  443. 			this.Textbox.setValue(value);

    444. 

  444. 			updateReadOnlyLabel(this);

    445. 

  445. 			return this;

    446. 

  446. 		}

    447. 

  447. 	});

    448. 

  448. 	

    449. 

  449. 	/*

    450. 

  450. 	 *	SPLookupField class

    451. 

  451. 	 *	Supports single select lookup fields

    452. 

  452. 	 */

    453. 

  453. 	SPLookupField = Class.create(SPField, {

    454. 

  454. 		initialize: function ($super, spParams) {

    455. 

  455. 			$super(spParams);

    456. 

  456. 			

    457. 

  457. 			var controls = this.Controls.select('input');

    458. 

  458. 			if (1 === controls.length) {

    459. 

  459. 				// autocomplete lookup

    460. 

  460. 				this.Textbox = controls[0];

    461. 

  461. 				

    462. 

  462. 				this.GetValue = function () {

    463. 

  463. 					return this.Textbox.getValue();

    464. 

  464. 				};

    465. 

  465. 				

    466. 

  466. 				this.SetValue = function (value) {

    467. 

  467. 					var choices, hash;

    468. 

  468. 					

    469. 

  469. 					if (Object.isNumber(value)) {

    470. 

  470. 						// a list item ID was passed to the function so attempt to lookup the text value

    471. 

  471. 						choices = this.Textbox.readAttribute('choices');

    472. 

  472. 						hash = new Hash();

    473. 

  473. 						// JSLint error here but not much I can do...

    474. 

  474. 						choices.scan(/(([^\|]|\|\|)+)\|(\d+)/, function (match) {

    475. 

  475. 							hash.set(match[3], match[1].replace(/\|\|/g, '|'));

    476. 

  476. 						});

    477. 

  477. 

    478. 

  478. 						this.Textbox.setValue(hash.get(value.toString()));

    479. 

  479. 					} else {

    480. 

  480. 						this.Textbox.setValue(value);

    481. 

  481. 					}

    482. 

  482. 					

    483. 

  483. 					updateReadOnlyLabel(this);

    484. 

  484. 					return this;

    485. 

  485. 				};

    486. 

  486. 				

    487. 

  487. 			} else {

    488. 

  488. 				controls = this.Controls.select('select');

    489. 

  489. 				if (1 === controls.length) {

    490. 

  490. 					// regular dropdown lookup

    491. 

  491. 					this.Dropdown = controls[0];

    492. 

  492. 					

    493. 

  493. 					this.GetValue = function () {

    494. 

  494. 						return this.Dropdown.options[this.Dropdown.selectedIndex].text;

    495. 

  495. 					};

    496. 

  496. 					

    497. 

  497. 					this.SetValue = function (value) {

    498. 

  498. 						if (Object.isNumber(value)) {

    499. 

  499. 							this.Dropdown.setValue(value);

    500. 

  500. 						} else {

    501. 

  501. 							var i, numOptions;

    502. 

  502. 							// need to set the dropdown based on text

    503. 

  503. 							numOptions = this.Dropdown.options.length;

    504. 

  504. 							for (i = 0; i < numOptions; i += 1) {

    505. 

  505. 								if (this.Dropdown.options[i].text === value) {

    506. 

  506. 									this.Dropdown.selectedIndex = i;

    507. 

  507. 									break;

    508. 

  508. 								}

    509. 

  509. 							}

    510. 

  510. 						}

    511. 

  511. 						updateReadOnlyLabel(this);

    512. 

  512. 						return this;

    513. 

  513. 					};

    514. 

  514. 				}

    515. 

  515. 			}

    516. 

  516. 		}

    517. 

  517. 	});

    518. 

  518. 	

    519. 

  519. 	/*

    520. 

  520. 	 *	SPLookupMultiField class

    521. 

  521. 	 *	Supports multi select lookup fields

    522. 

  522. 	 */

    523. 

  523. 	SPLookupMultiField = Class.create(SPField, {

    524. 

  524. 		initialize: function ($super, spParams) {

    525. 

  525. 			$super(spParams);

    526. 

  526. 			

    527. 

  527. 			var controls = this.Controls.select('select');

    528. 

  528. 			if (2 === controls.length) {

    529. 

  529. 				// multi-select lookup

    530. 

  530. 				this.ListChoices = controls[0];

    531. 

  531. 				this.ListSelections = controls[1];

    532. 

  532. 				controls = this.Controls.select('button');

    533. 

  533. 				this.ButtonAdd = controls[0];

    534. 

  534. 				this.ButtonRemove = controls[1];

    535. 

  535. 				

    536. 

  536. 				this.GetValue = function () {

    537. 

  537. 					var values = [], i, numOptions;

    538. 

  538. 					

    539. 

  539. 					numOptions = this.ListSelections.options.length;

    540. 

  540. 					for (i = 0; i < numOptions; i += 1) {

    541. 

  541. 						values.push(this.ListSelections.options[i].text);

    542. 

  542. 					}

    543. 

  543. 					

    544. 

  544. 					return values;

    545. 

  545. 				};

    546. 

  546. 				

    547. 

  547. 				// display as semicolon delimited list

    548. 

  548. 				this.MakeReadOnly = function (options) {

    549. 

  549. 					return makeReadOnly(this, arrayToSemicolonList(this.GetValue()));

    550. 

  550. 				};

    551. 

  551. 				

    552. 

  552. 				this.SetValue = function (value, addValue) {

    553. 

  553. 					if (Object.isUndefined(addValue)) {

    554. 

  554. 						addValue = true;

    555. 

  555. 					}

    556. 

  556. 					

    557. 

  557. 					var i, option, options, numOptions, funcAction;

    558. 

  558. 					

    559. 

  559. 					if (addValue) {

    560. 

  560. 						options = this.ListChoices.options;

    561. 

  561. 						funcAction = this.ButtonAdd.onclick;

    562. 

  562. 					} else {

    563. 

  563. 						options = this.ListSelections.options;

    564. 

  564. 						funcAction = this.ButtonRemove.onclick;

    565. 

  565. 					}

    566. 

  566. 					

    567. 

  567. 					numOptions = options.length;

    568. 

  568. 					

    569. 

  569. 					// select the value

    570. 

  570. 					if (Object.isNumber(value)) {

    571. 

  571. 						value = value.toString();

    572. 

  572. 						for (i = 0; i < numOptions; i += 1) {

    573. 

  573. 							option = options[i];

    574. 

  574. 							

    575. 

  575. 							// deliberate fuzzy comparison

    576. 

  576. 							if (option.value === value) {

    577. 

  577. 								option.selected = true;

    578. 

  578. 							} else {

    579. 

  579. 								option.selected = false;

    580. 

  580. 							}

    581. 

  581. 						}

    582. 

  582. 					} else {

    583. 

  583. 						for (i = 0; i < numOptions; i += 1) {

    584. 

  584. 							option = options[i];

    585. 

  585. 							

    586. 

  586. 							// deliberate fuzzy comparison

    587. 

  587. 							if (option.text === value) {

    588. 

  588. 								option.selected = true;

    589. 

  589. 							} else {

    590. 

  590. 								option.selected = false;

    591. 

  591. 							}

    592. 

  592. 						}

    593. 

  593. 					}

    594. 

  594. 					

    595. 

  595. 					funcAction(); // add or remove the value

    596. 

  596. 					

    597. 

  597. 					updateReadOnlyLabel(this);

    598. 

  598. 					return this;

    599. 

  599. 				};

    600. 

  600. 			}

    601. 

  601. 		}

    602. 

  602. 	});

    603. 

  603. 	

    604. 

  604. 	/*

    605. 

  605. 	 *	SPNoteField class

    606. 

  606. 	 *	Supports rich text fields (SPFieldNote)

    607. 

  607. 	 */

    608. 

  608. 	SPNoteField = Class.create(SPField, {

    609. 

  609. 		initialize: function ($super, spParams) {

    610. 

  610. 			$super(spParams);

    611. 

  611. 			

    612. 

  612. 			this.Textbox = null;

    613. 

  613. 			var controls = this.Controls.select('textarea');

    614. 

  614. 			if (1 === controls.length) {

    615. 

  615. 				this.Textbox = controls[0];

    616. 

  616. 			}

    617. 

  617. 			

    618. 

  618. 			this.IsRichText = (RTE_GetEditorIFrame(this.Textbox.id) !== null);

    619. 

  619. 			

    620. 

  620. 			if (this.IsRichText) {

    621. 

  621. 				// RTE functions are defined in layouts/1033/form.js

    622. 

  622. 				this.GetValue = function () {

    623. 

  623. 					return RTE_GetIFrameContents(this.Textbox.id);

    624. 

  624. 				};

    625. 

  625. 				

    626. 

  626. 				this.SetValue = function (value) {

    627. 

  627. 					this.Textbox.setValue(value);

    628. 

  628. 					RTE_TransferTextAreaContentsToIFrame(this.Textbox.id);

    629. 

  629. 					updateReadOnlyLabel(this);

    630. 

  630. 					return this;

    631. 

  631. 				};

    632. 

  632. 			} else {

    633. 

  633. 				this.GetValue = function () {

    634. 

  634. 					return this.Textbox.getValue();

    635. 

  635. 				};

    636. 

  636. 				

    637. 

  637. 				this.SetValue = function (value) {

    638. 

  638. 					this.Textbox.setValue(value);

    639. 

  639. 					updateReadOnlyLabel(this);

    640. 

  640. 					return this;

    641. 

  641. 				};

    642. 

  642. 			}

    643. 

  643. 		}

    644. 

  644. 		

    645. 

  645. 	});

    646. 

  646. 

    647. 

  647. 	/*

    648. 

  648. 	 *	SPBooleanField class

    649. 

  649. 	 *	Supports yes/no fields (SPFieldBoolean)

    650. 

  650. 	 */

    651. 

  651. 	SPBooleanField = Class.create(SPField, {

    652. 

  652. 		initialize: function ($super, spParams) {

    653. 

  653. 			$super(spParams);

    654. 

  654. 			

    655. 

  655. 			this.Checkbox = getInputControl(this);

    656. 

  656. 		},

    657. 

  657. 		

    658. 

  658. 		/*

    659. 

  659. 		 *	SPBooleanField Public Methods

    660. 

  660. 		 *	Overrides SPField class methods.

    661. 

  661. 		 */

    662. 

  662. 		GetValue: function () {

    663. 

  663. 			// double negative to return a boolean value

    664. 

  664. 			return !!this.Checkbox.getValue();

    665. 

  665. 		},

    666. 

  666. 		

    667. 

  667. 		SetValue: function (value) {

    668. 

  668. 			this.Checkbox.setValue(value);

    669. 

  669. 			updateReadOnlyLabel(this);

    670. 

  670. 			return this;

    671. 

  671. 		}

    672. 

  672. 	});

    673. 

  673. 

    674. 

  674. 	

    675. 

  675. 	/*

    676. 

  676. 	 *	SPNumberField class

    677. 

  677. 	 *	Supports Number fields

    678. 

  678. 	 */

    679. 

  679. 	SPNumberField = Class.create(SPTextField, {

    680. 

  680. 		initialize: function ($super, spParams) {

    681. 

  681. 			$super(spParams);

    682. 

  682. 		},

    683. 

  683. 		

    684. 

  684. 		/*

    685. 

  685. 		 *	SPNumberField Public Methods

    686. 

  686. 		 *	Overrides SPTextField class methods.

    687. 

  687. 		 */

    688. 

  688. 		GetValue: function () {

    689. 

  689. 			return convertStringToNumber(this.Textbox.getValue());

    690. 

  690. 		}

    691. 

  691. 	});

    692. 

  692. 	

    693. 

  693. 	/*

    694. 

  694. 	 *	SPCurrencyField class

    695. 

  695. 	 *	Supports currency fields (SPCurrencyField)

    696. 

  696. 	 */

    697. 

  697. 	SPCurrencyField = Class.create(SPNumberField, {

    698. 

  698. 		initialize: function ($super, spParams) {

    699. 

  699. 			$super(spParams);

    700. 

  700. 			this.FormatOptions = {

    701. 

  701. 				eventHandler: null,

    702. 

  702. 				autoCorrect: false,

    703. 

  703. 				decimalPlaces: 2

    704. 

  704. 			};

    705. 

  705. 		},

    706. 

  706. 		

    707. 

  707. 		Format: function () {

    708. 

  708. 			if (this.FormatOptions.autoCorrect) {

    709. 

  709. 				this.FormatOptions.eventHandler = function () {

    710. 

  710. 					this.SetValue(this.GetFormattedValue());

    711. 

  711. 				}.bindAsEventListener(this);

    712. 

  712. 				Event.observe(this.Textbox, 'change', this.FormatOptions.eventHandler);

    713. 

  713. 				this.FormatOptions.eventHandler(); // run once

    714. 

  714. 			} else {

    715. 

  715. 				if (this.FormatOptions.eventHandler) {

    716. 

  716. 					Event.stopObserving(this.Textbox, 'change', this.FormatOptions.eventHandler);

    717. 

  717. 					this.FormatOptions.eventHandler = null;

    718. 

  718. 				}

    719. 

  719. 			}

    720. 

  720. 		},

    721. 

  721. 		

    722. 

  722. 		GetFormattedValue: function () {

    723. 

  723. 			var text = this.GetValue();

    724. 

  724. 			if (typeof text === "number") {

    725. 

  725. 				text = '$' + text.formatMoney(this.FormatOptions.decimalPlaces);

    726. 

  726. 			}

    727. 

  727. 			return text;

    728. 

  728. 		},

    729. 

  729. 		

    730. 

  730. 		// Override the default MakeReadOnly function to allow displaying

    731. 

  731. 		// the value with currency symbols

    732. 

  732. 		MakeReadOnly: function (options) {

    733. 

  733. 			return makeReadOnly(this, this.GetFormattedValue());

    734. 

  734. 		}

    735. 

  735. 	});

    736. 

  736. 	

    737. 

  737. 	/*

    738. 

  738. 	 *	SPUserField class

    739. 

  739. 	 *	Supports people fields (SPFieldUser)

    740. 

  740. 	 */

    741. 

  741. 	SPUserField = Class.create(SPField, {

    742. 

  742. 		initialize: function ($super, spParams) {

    743. 

  743. 			$super(spParams);

    744. 

  744. 			

    745. 

  745. 			this.spanUserField = null;

    746. 

  746. 			this.upLevelDiv = null;

    747. 

  747. 			this.textareaDownLevelTextBox = null;

    748. 

  748. 			this.linkCheckNames = null;

    749. 

  749. 			this.txtHiddenSpanData = null;

    750. 

  750. 						

    751. 

  751. 			var controls = this.Controls.select('span.ms-usereditor');

    752. 

  752. 			if (null !== controls && 1 === controls.length) {

    753. 

  753. 				this.spanUserField = controls[0];

    754. 

  754. 				this.upLevelDiv = $(this.spanUserField.id + '_upLevelDiv');

    755. 

  755. 				this.textareaDownLevelTextBox = $(this.spanUserField.id + '_downlevelTextBox');

    756. 

  756. 				this.linkCheckNames = $(this.spanUserField.id + '_checkNames');

    757. 

  757. 				this.txtHiddenSpanData = $(this.spanUserField.id + '_hiddenSpanData');

    758. 

  758. 			}

    759. 

  759. 		},

    760. 

  760. 		

    761. 

  761. 		/*

    762. 

  762. 		 *	SPUserField Public Methods

    763. 

  763. 		 *	Overrides SPField class methods.

    764. 

  764. 		 */

    765. 

  765. 		GetValue: function () {

    766. 

  766. 			//this.textareaDownLevelTextBox.getValue()

    767. 

  767. 			return this.upLevelDiv.getTextContent();

    768. 

  768. 		},

    769. 

  769. 		

    770. 

  770. 		SetValue: function (value) {

    771. 

  771. 			if (Prototype.Browser.IE) {

    772. 

  772. 				this.upLevelDiv.innerHTML = value;

    773. 

  773. 				this.txtHiddenSpanData.setValue(value);

    774. 

  774. 				this.linkCheckNames.click();

    775. 

  775. 			} else { // FireFox (maybe others?)

    776. 

  776. 				this.textareaDownLevelTextBox.setValue(value);

    777. 

  777. 				this.linkCheckNames.onclick();

    778. 

  778. 			}

    779. 

  779. 			updateReadOnlyLabel(this);

    780. 

  780. 			return this;

    781. 

  781. 		}

    782. 

  782. 	});

    783. 

  783. 	

    784. 

  784. 	/*

    785. 

  785. 	 *	SPURLField class

    786. 

  786. 	 *	Supports hyperlink fields (SPFieldURL)

    787. 

  787. 	 */

    788. 

  788. 	SPURLField = Class.create(SPField, {

    789. 

  789. 		initialize: function ($super, spParams) {

    790. 

  790. 			$super(spParams);

    791. 

  791. 			

    792. 

  792. 			this.TextboxURL = null;

    793. 

  793. 			this.TextboxDescription = null;

    794. 

  794. 			

    795. 

  795. 			var controls = this.Controls.select('input');

    796. 

  796. 			if (null !== controls && 2 === controls.length) {

    797. 

  797. 				this.TextboxURL = controls[0];

    798. 

  798. 				this.TextboxDescription = controls[1];

    799. 

  799. 			}

    800. 

  800. 		},

    801. 

  801. 		

    802. 

  802. 		/*

    803. 

  803. 		 *	SPURLField Public Methods

    804. 

  804. 		 *	Overrides SPField class methods.

    805. 

  805. 		 */

    806. 

  806. 		GetValue: function () {

    807. 

  807. 			return [this.TextboxURL.getValue(), this.TextboxDescription.getValue()];

    808. 

  808. 		},

    809. 

  809. 		

    810. 

  810. 		SetValue: function (url, description) {

    811. 

  811. 			this.TextboxURL.setValue(url);

    812. 

  812. 			this.TextboxDescription.setValue(description);

    813. 

  813. 			updateReadOnlyLabel(this);

    814. 

  814. 			return this;

    815. 

  815. 		},

    816. 

  816. 		

    817. 

  817. 		// overriding the default MakeReadOnly function because we have multiple values returned

    818. 

  818. 		// and we want to have the hyperlink field show up as a URL

    819. 

  819. 		MakeReadOnly: function (options) {

    820. 

  820. 			var text, values = this.GetValue();

    821. 

  821. 			

    822. 

  822. 			if (options && true === options.TextOnly) {

    823. 

  823. 				text = values[0] + ', ' + values[1];

    824. 

  824. 			} else {				

    825. 

  825. 				text = '<a href="' + values[0] + '">' + values[1] + '</a>';

    826. 

  826. 			}

    827. 

  827. 			

    828. 

  828. 			return makeReadOnly(this, text);

    829. 

  829. 		}

    830. 

  830. 	});

    831. 

  831. 	

    832. 

  832. 	/*

    833. 

  833. 	 *	SPFileField class

    834. 

  834. 	 *	Supports the name field of a Document Library

    835. 

  835. 	 */

    836. 

  836. 	SPFileField = Class.create(SPTextField, {

    837. 

  837. 		initialize: function ($super, spParams) {

    838. 

  838. 			$super(spParams);

    839. 

  839. 			

    840. 

  840. 			this.FileExtension = this.Textbox.up(0).getTextContent();

    841. 

  841. 		},

    842. 

  842. 		

    843. 

  843. 		/*

    844. 

  844. 		 *	SPFileField Public Methods

    845. 

  845. 		 *	Overrides SPField class methods.

    846. 

  846. 		 */

    847. 

  847. 		GetValue: function () {

    848. 

  848. 			return this.Textbox.getValue() + this.FileExtension;

    849. 

  849. 		}

    850. 

  850. 	});

    851. 

  851. 	

    852. 

  852. 	/*

    853. 

  853. 	 *	SPChoiceField class

    854. 

  854. 	 *	Supports single select choice fields that show as either a dropdown or radio buttons

    855. 

  855. 	 */

    856. 

  856. 	SPChoiceField = Class.create(SPField, {

    857. 

  857. 		initialize: function ($super, spParams) {

    858. 

  858. 			var FILL_IN_VALUE = 'Specify your own value:',

    859. 

  859. 				CHECKBOX_SELECTOR = 'input[type="checkbox"]',

    860. 

  860. 				RADIO_SELECTOR = 'input[type="radio"]',

    861. 

  861. 				controls = null;

    862. 

  862. 			

    863. 

  863. 			$super(spParams);

    864. 

  864. 			

    865. 

  865. 			this.FillInTextbox = this.Controls.select('input[type="text"]');

    866. 

  866. 			if (this.FillInTextbox.length === 1) {

    867. 

  867. 				this.FillInTextbox = this.FillInTextbox[0];

    868. 

  868. 				this.FillInAllowed = true;

    869. 

  869. 				this.FillInElement = null;

    870. 

  870. 			} else {

    871. 

  871. 				this.FillInAllowed = false;

    872. 

  872. 				this.FillInTextbox = null;

    873. 

  873. 				this.FillInElement = null;

    874. 

  874. 			}

    875. 

  875. 			

    876. 

  876. 			// is this a single select or multi-select?

    877. 

  877. 			if (this.Type === 'SPFieldChoice') {

    878. 

  878. 				// single select choice field using a dropdown

    879. 

  879. 				controls = this.Controls.select('select');

    880. 

  880. 				if (1 === controls.length) {

    881. 

  881. 					this.Dropdown = controls[0];

    882. 

  882. 					

    883. 

  883. 					if (!this.FillInAllowed) {

    884. 

  884. 						// dynamically set our getter/setter functions

    885. 

  885. 						this.GetValue = function () {

    886. 

  886. 							return this.Dropdown.getValue();

    887. 

  887. 						};

    888. 

  888. 						this.SetValue = function (value) {

    889. 

  889. 							this.Dropdown.setValue(value);

    890. 

  890. 							updateReadOnlyLabel(this);

    891. 

  891. 							return this;

    892. 

  892. 						};

    893. 

  893. 					} else {

    894. 

  894. 						// dropdown with a fill-in value

    895. 

  895. 						controls = getHashFromInputControls(this, RADIO_SELECTOR);

    896. 

  896. 						this.FillInElement = controls.get(FILL_IN_VALUE);

    897. 

  897. 						controls.unset(FILL_IN_VALUE);

    898. 

  898. 						

    899. 

  899. 						this.GetValue = function () {

    900. 

  900. 							if (this.FillInElement.checked === true) {

    901. 

  901. 								return this.FillInTextbox.getValue();

    902. 

  902. 							}

    903. 

  903. 							return this.Dropdown.getValue();

    904. 

  904. 						};

    905. 

  905. 						

    906. 

  906. 						this.SetValue = function (value) {

    907. 

  907. 							var found = false;

    908. 

  908. 							found = !Object.isUndefined($A(this.Dropdown.options).find(function (option) { return option.value === value; }));

    909. 

  909. 							if (found) {

    910. 

  910. 								this.Dropdown.setValue(value);

    911. 

  911. 								this.FillInElement.checked = false;

    912. 

  912. 								// fires the function to select the radio button

    913. 

  913. 								this.Dropdown.onclick();

    914. 

  914. 							} else {

    915. 

  915. 								this.FillInElement.checked = true;

    916. 

  916. 								this.FillInTextbox.setValue(value);

    917. 

  917. 							}

    918. 

  918. 							updateReadOnlyLabel(this);

    919. 

  919. 							return this;

    920. 

  920. 						};

    921. 

  921. 					}

    922. 

  922. 				}

    923. 

  923. 			}

    924. 

  924. 			

    925. 

  925. 			// if the field is single select, then we will have already found

    926. 

  926. 			// a dropdown control and everything is setup. otherwise we have setup to do

    927. 

  927. 			if (Object.isUndefined(this.Dropdown)) {

    928. 

  928. 				if (this.Type === 'SPFieldMultiChoice') {

    929. 

  929. 					// multi-choice fields use checkboxes

    930. 

  930. 					this.Checkboxes = getHashFromInputControls(this, CHECKBOX_SELECTOR);

    931. 

  931. 					

    932. 

  932. 					// remove the fill-in checkbox because we will check it separately

    933. 

  933. 					if (this.FillInAllowed) {

    934. 

  934. 						this.FillInElement = this.Checkboxes.get(FILL_IN_VALUE);

    935. 

  935. 						this.Checkboxes.unset(FILL_IN_VALUE);

    936. 

  936. 					}

    937. 

  937. 					

    938. 

  938. 					this.GetValue = function () {

    939. 

  939. 						var values = [];

    940. 

  940. 						

    941. 

  941. 						this.Checkboxes.each(function (pair) {

    942. 

  942. 							var checkbox = pair.value;

    943. 

  943. 							if (checkbox.checked === true) {

    944. 

  944. 								values.push(pair.key);

    945. 

  945. 							}

    946. 

  946. 						});

    947. 

  947. 						

    948. 

  948. 						if (this.FillInAllowed && this.FillInElement.checked === true) {

    949. 

  949. 							values.push(this.FillInTextbox.getValue());

    950. 

  950. 						}

    951. 

  951. 						

    952. 

  952. 						return values;

    953. 

  953. 					};

    954. 

  954. 					

    955. 

  955. 					this.SetValue = function (value, checked) {

    956. 

  956. 						// find the radio button we need to set in our hashtable

    957. 

  957. 						var checkBox = this.Checkboxes.get(value);

    958. 

  958. 						

    959. 

  959. 						// if couldn't find the element in the hashtable

    960. 

  960. 						// and fill-in is allowed, assume they meant the fill-in value

    961. 

  961. 						if (Object.isUndefined(checkBox) && this.FillInAllowed) {

    962. 

  962. 							checkBox = this.FillInElement;

    963. 

  963. 							this.FillInTextbox.setValue(value);

    964. 

  964. 						}

    965. 

  965. 						

    966. 

  966. 						if (!Object.isUndefined(checkBox)) {						

    967. 

  967. 							if (!Object.isUndefined(checked)) {

    968. 

  968. 								checkBox.checked = (true === checked);

    969. 

  969. 							} else {

    970. 

  970. 								checkBox.checked = true;

    971. 

  971. 							}

    972. 

  972. 						}

    973. 

  973. 						updateReadOnlyLabel(this);

    974. 

  974. 						return this;

    975. 

  975. 					};

    976. 

  976. 					

    977. 

  977. 					// display as semicolon delimited list

    978. 

  978. 					this.MakeReadOnly = function (options) {

    979. 

  979. 						return makeReadOnly(this, arrayToSemicolonList(this.GetValue()));

    980. 

  980. 					};

    981. 

  981. 				} else {

    982. 

  982. 					this.RadioButtons = getHashFromInputControls(this, RADIO_SELECTOR);

    983. 

  983. 					

    984. 

  984. 					// remove the fill-in radio button because we will check it separately

    985. 

  985. 					if (this.FillInAllowed) {

    986. 

  986. 						this.FillInElement = this.RadioButtons.get(FILL_IN_VALUE);

    987. 

  987. 						this.RadioButtons.unset(FILL_IN_VALUE);

    988. 

  988. 					}

    989. 

  989. 					

    990. 

  990. 					this.GetValue = function () {

    991. 

  991. 						var value = null;

    992. 

  992. 						// find the radio button we need to get in our hashtable

    993. 

  993. 						this.RadioButtons.each(function (pair) {

    994. 

  994. 							var radioButton = pair.value;

    995. 

  995. 							if (true === radioButton.checked) {

    996. 

  996. 								value = pair.key;

    997. 

  997. 								throw $break;

    998. 

  998. 							}

    999. 

  999. 						});

    1000. 

  1000. 						

    1001. 

  1001. 						if (this.FillInAllowed && value === null && this.FillInElement.checked === true) {

    1002. 

  1002. 							value = this.FillInTextbox.getValue();

    1003. 

  1003. 						}

    1004. 

  1004. 						

    1005. 

  1005. 						return value;

    1006. 

  1006. 					};

    1007. 

  1007. 					

    1008. 

  1008. 					this.SetValue = function (value) {

    1009. 

  1009. 						// find the radio button we need to set in our hashtable

    1010. 

  1010. 						var radioButton = this.RadioButtons.get(value);

    1011. 

  1011. 						

    1012. 

  1012. 						// if couldn't find the element in the hashtable and fill-in

    1013. 

  1013. 						// is allowed, assume they want to set the fill-in value

    1014. 

  1014. 						if (Object.isUndefined(radioButton) && this.FillInAllowed) {

    1015. 

  1015. 							radioButton = this.FillInElement;

    1016. 

  1016. 							this.FillInTextbox.setValue(value);

    1017. 

  1017. 						}

    1018. 

  1018. 						

    1019. 

  1019. 						if (!Object.isUndefined(radioButton)) {

    1020. 

  1020. 							radioButton.checked = true;

    1021. 

  1021. 						}

    1022. 

  1022. 						updateReadOnlyLabel(this);

    1023. 

  1023. 						return this;

    1024. 

  1024. 					};

    1025. 

  1025. 				}

    1026. 

  1026. 			}

    1027. 

  1027. 		}

    1028. 

  1028. 	});

    1029. 

  1029. 	

    1030. 

  1030. 	/*

    1031. 

  1031. 	 *	SPDateTimeFieldValue class

    1032. 

  1032. 	 *	Used to set/get values for SPDateTimeField fields

    1033. 

  1033. 	 */

    1034. 

  1034. 	SPDateTimeFieldValue = Class.create({

    1035. 

  1035. 		initialize: function (year, month, day, strHour, strMinute) {

    1036. 

  1036. 			this.Year = year;

    1037. 

  1037. 			this.Month = month;

    1038. 

  1038. 			this.Day = day;

    1039. 

  1039. 			this.Hour = strHour;

    1040. 

  1040. 			this.Minute = strMinute;

    1041. 

  1041. 			this.IsTimeIncluded = !Object.isUndefined(this.Hour) && !Object.isUndefined(this.Minute);

    1042. 

  1042. 			

    1043. 

  1043. 			if (this.IsTimeIncluded) {

    1044. 

  1044. 				if (!this.IsValidHour(this.Hour)) {

    1045. 

  1045. 					throw 'Hour parameter is not in the correct format. Needs to be formatted like "1 PM" or "12 AM".';

    1046. 

  1046. 				}

    1047. 

  1047. 				if (!this.IsValidMinute(this.Minute)) {

    1048. 

  1048. 					throw 'Minute parameter is not in the correct format. Needs to be formatted like "00", "05" or "35".';

    1049. 

  1049. 				}

    1050. 

  1050. 			}

    1051. 

  1051. 		},

    1052. 

  1052. 		

    1053. 

  1053. 		/*

    1054. 

  1054. 		 *	SPDateTimeFieldValue Public Methods

    1055. 

  1055. 		 */

    1056. 

  1056. 		

    1057. 

  1057. 		IsValidDate: function () {

    1058. 

  1058. 			return !Object.isUndefined(this.Year) && !Object.isUndefined(this.Month) && !Object.isUndefined(this.Day);

    1059. 

  1059. 		},

    1060. 

  1060. 		

    1061. 

  1061. 		IsValidHour: function (h) {

    1062. 

  1062. 			return !Object.isUndefined(h) && (/^([1-9]|10|11|12) (AM|PM)$/).test(h);

    1063. 

  1063. 		},

    1064. 

  1064. 			

    1065. 

  1065. 		IsValidMinute: function (m) {

    1066. 

  1066. 			return !Object.isUndefined(m) && (/^([0-5](0|5))$/).test(m);

    1067. 

  1067. 		},

    1068. 

  1068. 		

    1069. 

  1069. 		// returns the part of a date as a string and pads with a 0 if necessary

    1070. 

  1070. 		PadWithZero: function (d) {

    1071. 

  1071. 			if (Object.isUndefined(d) || null === d) {

    1072. 

  1072. 				return '';

    1073. 

  1073. 			}

    1074. 

  1074. 			if (typeof d === 'string') {

    1075. 

  1075. 				d = parseInt(d, 10);

    1076. 

  1076. 				if (isNaN(d)) {

    1077. 

  1077. 					return '';

    1078. 

  1078. 				}

    1079. 

  1079. 			}

    1080. 

  1080. 			if (typeof d === 'number' && d < 10) {

    1081. 

  1081. 				return '0' + d.toString();

    1082. 

  1082. 			}

    1083. 

  1083. 			return d.toString();

    1084. 

  1084. 		},

    1085. 

  1085. 		

    1086. 

  1086. 		// transforms a date object into a string

    1087. 

  1087. 		GetShortDateString: function () {

    1088. 

  1088. 			if (!this.IsValidDate()) {

    1089. 

  1089. 				return '';

    1090. 

  1090. 			}

    1091. 

  1091. 			var strDate = this.PadWithZero(this.Month) + "/" +

    1092. 

  1092. 				this.PadWithZero(this.Day) + "/" +

    1093. 

  1093. 				this.PadWithZero(this.Year);

    1094. 

  1094. 			return strDate;

    1095. 

  1095. 		},

    1096. 

  1096. 		

    1097. 

  1097. 		toString: function () {

    1098. 

  1098. 			var str = this.GetShortDateString(), arrHour;

    1099. 

  1099. 			if (this.IsValidHour(this.Hour) && this.IsValidMinute(this.Minute)) {

    1100. 

  1100. 				arrHour = this.Hour.split(' ');

    1101. 

  1101. 				str += ' ' + arrHour[0] + ':' + this.Minute + arrHour[1];

    1102. 

  1102. 			}

    1103. 

  1103. 			return str;

    1104. 

  1104. 		}

    1105. 

  1105. 	});

    1106. 

  1106. 	

    1107. 

  1107. 	/*

    1108. 

  1108. 	 *	SPDateTimeField class

    1109. 

  1109. 	 *	Date and DateTime fields

    1110. 

  1110. 	 */

    1111. 

  1111. 	SPDateTimeField = Class.create(SPField, {

    1112. 

  1112. 		initialize: function ($super, spParams) {

    1113. 

  1113. 			$super(spParams);

    1114. 

  1114. 			

    1115. 

  1115. 			this.DateTextbox = getInputControl(this);

    1116. 

  1116. 			

    1117. 

  1117. 			this.HourDropdown = null;

    1118. 

  1118. 			this.MinuteDropdown = null;

    1119. 

  1119. 			var timeControls = this.Controls.select('select');

    1120. 

  1120. 			if (null !== timeControls && 2 === timeControls.length) {

    1121. 

  1121. 				this.HourDropdown = $(timeControls[0]);

    1122. 

  1122. 				this.MinuteDropdown = $(timeControls[1]);

    1123. 

  1123. 			}

    1124. 

  1124. 		},

    1125. 

  1125. 		

    1126. 

  1126. 		/*

    1127. 

  1127. 		 *	SPDateTimeField Public Methods

    1128. 

  1128. 		 *	Overrides SPField class methods.

    1129. 

  1129. 		 */

    1130. 

  1130. 		GetValue: function () {

    1131. 

  1131. 			var strHour, strMinute, arrShortDate,

    1132. 

  1132. 				strShortDate = this.DateTextbox.getValue();

    1133. 

  1133. 

    1134. 

  1134. 			if (null !== this.HourDropdown && null !== this.MinuteDropdown) {

    1135. 

  1135. 				strHour = this.HourDropdown.getValue();

    1136. 

  1136. 				strMinute = this.MinuteDropdown.getValue();

    1137. 

  1137. 			}

    1138. 

  1138. 			

    1139. 

  1139. 			arrShortDate = strShortDate.split('/');

    1140. 

  1140. 			

    1141. 

  1141. 			if (arrShortDate.length === 3) {

    1142. 

  1142. 				return new SPDateTimeFieldValue(arrShortDate[2], arrShortDate[0], arrShortDate[1], strHour, strMinute);

    1143. 

  1143. 			}

    1144. 

  1144. 			

    1145. 

  1145. 			// empty or invalid date

    1146. 

  1146. 			return '';

    1147. 

  1147. 		},

    1148. 

  1148. 		

    1149. 

  1149. 		SetValue: function (year, month, day, strHour, strMinute) {

    1150. 

  1150. 			if (Object.isString(year) && Object.isUndefined(month)) {

    1151. 

  1151. 				// one string param passed to SetValue

    1152. 

  1152. 				// assume they know what they are doing

    1153. 

  1153. 				this.DateTextbox.setValue(year);

    1154. 

  1154. 			} else {

    1155. 

  1155. 				var value = new SPDateTimeFieldValue(year, month, day, strHour, strMinute);

    1156. 

  1156. 				this.DateTextbox.setValue(value.GetShortDateString());

    1157. 

  1157. 				if (null !== this.HourDropdown && null !== this.MinuteDropdown) {

    1158. 

  1158. 					this.HourDropdown.setValue(value.Hour);

    1159. 

  1159. 					this.MinuteDropdown.setValue(value.Minute);

    1160. 

  1160. 				}

    1161. 

  1161. 			}

    1162. 

  1162. 			updateReadOnlyLabel(this);

    1163. 

  1163. 			return this;

    1164. 

  1164. 		}

    1165. 

  1165. 		

    1166. 

  1166. 	});

    1167. 

  1167. 	

    1168. 

  1168. 	/*

    1169. 

  1169. 	 *	SPUtility Public Methods

    1170. 

  1170. 	 */

    1171. 

  1171. 	 

    1172. 

  1172. 	return {

    1173. 

  1173. 		// Creates a soap envelope for use with an AJAX call to SharePoint web services

    1174. 

  1174. 		CreateSoapEnvelope: function (action, namespace, parameters) {

    1175. 

  1175. 			var soap = '<?xml version="1.0" encoding="utf-8"?>';

    1176. 

  1176. 			soap += '<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">';

    1177. 

  1177. 			soap += '  <soap:Body>';

    1178. 

  1178. 			

    1179. 

  1179. 			// creat body of the soap envelope

    1180. 

  1180. 			if (typeof parameters === 'object' && $H(parameters).keys().length > 0) {

    1181. 

  1181. 				soap += '    <' + action + ' xmlns="' + namespace + '">';

    1182. 

  1182. 				$H(parameters).each(function (pair) {

    1183. 

  1183. 					soap += "<" + pair.key + ">" + pair.value + "</" + pair.key + ">";

    1184. 

  1184. 				});

    1185. 

  1185. 				soap += '    </' + action + '>';

    1186. 

  1186. 			} else {

    1187. 

  1187. 				soap += '    <' + action + ' xmlns="' + namespace + '" />';

    1188. 

  1188. 			}

    1189. 

  1189. 			

    1190. 

  1190. 			soap += '  </soap:Body>';

    1191. 

  1191. 			soap += '</soap:Envelope>';

    1192. 

  1192. 			return soap;

    1193. 

  1193. 		},

    1194. 

  1194. 		

    1195. 

  1195. 		Debug: function (isDebug) {

    1196. 

  1196. 			if ('boolean' === typeof isDebug) {

    1197. 

  1197. 				_debugMode = isDebug;

    1198. 

  1198. 			}

    1199. 

  1199. 			return _debugMode;

    1200. 

  1200. 		},

    1201. 

  1201. 	

    1202. 

  1202. 		// Gets all of the SPFields on the page

    1203. 

  1203. 		GetSPFields: function () {

    1204. 

  1204. 			lazyLoadSPFields();

    1205. 

  1205. 			return _fieldsHashtable;

    1206. 

  1206. 		},

    1207. 

  1207. 		

    1208. 

  1208. 		// Searches the page for a specific field by name

    1209. 

  1209. 		GetSPField: function (strFieldName) {

    1210. 

  1210. 			lazyLoadSPFields();

    1211. 

  1211. 			

    1212. 

  1212. 			var fieldParams = _fieldsHashtable.get(strFieldName);

    1213. 

  1213. 			

    1214. 

  1214. 			if (Object.isUndefined(fieldParams)) { 

    1215. 

  1215. 				log('GetSPField: Unable to find a SPField named ' + strFieldName);

    1216. 

  1216. 				return null;

    1217. 

  1217. 			}

    1218. 

  1218. 			

    1219. 

  1219. 			if (fieldParams.spField === null) {

    1220. 

  1220. 				// field hasn't been initialized yet

    1221. 

  1221. 				fieldParams.spField = createSPField(fieldParams);

    1222. 

  1222. 			}

    1223. 

  1223. 			

    1224. 

  1224. 			return fieldParams.spField;

    1225. 

  1225. 		},

    1226. 

  1226. 		

    1227. 

  1227. 		HideSPField: function (strFieldName) {

    1228. 

  1228. 			toggleSPField(strFieldName, false);

    1229. 

  1229. 		},

    1230. 

  1230. 		

    1231. 

  1231. 		ShowSPField: function (strFieldName) {

    1232. 

  1232. 			toggleSPField(strFieldName, true);

    1233. 

  1233. 		}

    1234. 

  1234. 	};

    1235. 

  1235. }());
    1236.