1// Copyright 2005 The Apache Software Foundation 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15// Define a Tapestry object to contain most functions. 16 17var Tapestry = new Object(); 18 19Tapestry.default_invalid_field_handler = function(event, field, message) 20{ 21 if (!event.abort && !field.disabled) 22 { 23 Tapestry.set_focus(field); 24 25 window.alert(message); 26 27 event.abort = true; 28 event.cancel_handlers = true; 29 } 30} 31 32Tapestry.find = function(elementId) 33{ 34 return document.getElementById(elementId); 35} 36 37Tapestry.register_form = function(formId) 38{ 39 var form = this.find(formId); 40 41 form.events = new FormEventManager(form); 42} 43 44Tapestry.onpresubmit = function(formId, handler) 45{ 46 var form = this.find(formId); 47 48 form.events.add_presubmit_handler(handler); 49} 50 51Tapestry.onsubmit = function(formId, handler) 52{ 53 var form = this.find(formId); 54 55 form.events.add_submit_handler(handler); 56} 57 58Tapestry.onpostsubmit = function(formId, handler) 59{ 60 var form = this.find(formId); 61 62 form.events.add_postsubmit_handler(handler); 63} 64 65Tapestry.onreset = function(formId, handler) 66{ 67 var form = this.find(formId); 68 69 form.events.add_reset_handler(handler); 70} 71 72Tapestry.onrefresh = function(formId, handler) 73{ 74 var form = this.find(formId); 75 76 form.events.add_refresh_handler(handler); 77} 78 79Tapestry.oncancel = function(formId, handler) 80{ 81 var form = this.find(formId); 82 83 form.events.add_cancel_handler(handler); 84} 85 86Tapestry.set_focus = function (field) 87{ 88 if (typeof field == "string") { 89 field = this.find(field); 90 91 if (field) { 92 if (!field.disabled && field.clientWidth > 0) { 93 if (field.focus) { 94 field.focus(); 95 } 96 if (field.isContentEditable || field.isContentEditable == null) { 97 if (field.select) { 98 field.select(); 99 } 100 } 101 } 102 } 103 } 104} 105 106Tapestry.trim_field_value = function(fieldId) 107{ 108 var field = this.find(fieldId); 109 110 field.value = field.value.replace(/^\s+/g, '').replace(/\s+$/g, ''); 111} 112 113Tapestry.require_field = function(event, fieldId, message) 114{ 115 var field = this.find(fieldId); 116 117 if (field.value.length == 0) 118 event.invalid_field(field, message); 119} 120 121// Used by LinkSubmit components to force the form to submit 122 123Tapestry.submit_form = function(form_id, field_name) 124{ 125 var form = this.find(form_id); 126 127 form.events.submit(field_name); 128} 129 130// FormSubmitEvent 131// 132// Event object that identifies the form that was submitted, 133// the type of submission ("submit", "refresh", "reset" or "cancel") 134// and two flags. 135// A listener may set the abort flag to true, which will prevent 136// the Form submit or reset from occuring, but will not prevent 137// other listeners from being invoked. A listener may also set the 138// cancel_handlers flag, which will prevent further listeners from being 139// invoked. 140// The invalid_field_handler is provided (by the FormEventManager) 141// to handle any invalid fields. 142 143function FormSubmitEvent(form, type, invalid_field_handler) 144{ 145 this.form = form; 146 this.type = type; 147 this.abort = false;
148 this.cancel_handlers = false; 149 this.invalid_field_handler = invalid_field_handler; 150} 151 152FormSubmitEvent.prototype.invalid_field = function(field, message) 153{ 154 this.invalid_field_handler.call(window, this, field, message); 155} 156 157FormSubmitEvent.prototype.toString = function() 158{ 159 return "FormSubmitEvent[" + this.form.name + " " + this.type + " " + this.abort + "]"; 160} 161 162 163// FormEventManager 164// 165// Manages listeners (as handler functions) for a given Form object. Installs 166// onsubmit and onreset listeners on the form. 167 168function FormEventManager(form) 169{ 170 this.form = form; 171 172 // Key is handler type ("submit", "refresh", "reset" or "cancel"), value 173 // is an array of functions. 174 this.handlers = {}; 175 176 // Inside onsubmit and onreset, "this" will be the form (how convienient) 177 // so we need to carefully bridge this back to the FormEventManager instance. 178 179 form.onsubmit = function() { return this.events.onsubmit_handler(); }; 180 form.onreset = function() { return this.events.onreset_handler(); }; 181 182 // Override this property when doing something more ambitious than 183 // the default (which invokes window.alert(), focuses the field, and aborts 184 // the form submit and the rest of the listeners). 185 // The function should take three parameters: 186 // the FormSubmitEvent, the field object, and the message 187 188 this.invalid_field_handler = Tapestry.default_invalid_field_handler; 189} 190 191// add_handler(type, handler) 192// 193// type -- the handler type to add ("submit", "refresh", "reset" or "cancel" 194// handler -- a function to execute 195 196FormEventManager.prototype.add_handler = function(type, handler) 197{ 198 var array = this.handlers[type]; 199 if (array == null) 200 { 201 array = []; 202 this.handlers[type] = array; 203 } 204 205 array.push(handler); 206} 207 208// invoke_handlers(type, eventObject) 209// 210// type -- the type of handler to execute 211// eventObj -- passed to the handler function 212 213FormEventManager.prototype.invoke_handlers = function(type, eventObj) 214{ 215 if (eventObj.cancel_handlers) return; 216 217 var array = this.handlers[type]; 218 219 if (array == null) return; 220 221 var length = array.length; 222 for (var i = 0; i < length; i++) 223 { 224 var handler = array[i]; 225 handler.call(window, eventObj); 226 227 if (eventObj.cancel_handlers) return; 228 } 229} 230 231// add_cancel_handler(handler) 232// 233// handler - receives notifications when the form is canceled 234 235FormEventManager.prototype.add_cancel_handler = function(handler) 236{ 237 this.add_handler("cancel", handler); 238} 239 240// cancel() 241// 242// Cancels the form. Any cancel listeners are invoked; unless one of them sets the abort 243// flag on the event, then the form will be submitted, and the mode set to "cancel". 244 245FormEventManager.prototype.cancel = function() 246{ 247 var event = new FormSubmitEvent(this.form, "cancel", this.invalid_field_handler); 248 249 this.invoke_handlers("cancel", event); 250 251 if (event.abort == false) 252 { 253 this.form.submitmode.value = "cancel"; 254 this.form.onsubmit = null; 255 this.form.submit(); 256 } 257} 258 259// add_presubmit_handler(handler) 260// 261// Typically used to setup state prior to the submit handlers being invoked. 262// Pre-submit listeners are invoked before submit handlers are invoked. If 263// a pre-submit listener sets the cancelListeners flag on the event, the 264// submit and post-submit listeners will not be invoked. 265 266// 267// form - the Form object for which a listener is added 268// handler - recieves notification when the form is submitted 269 270FormEventManager.prototype.add_presubmit_handler = function(handler) 271{ 272 this.add_handler("presubmit", handler); 273} 274 275// add_submit_handler(handler) 276// 277// Typically used for input validations; normal submit listeners are skipped when 278// a form is submitted to refresh some of its values. If a handler sets 279// the cancelListener flag on the event, then subsequent submit handlers, and all 280// post-submit handlers, will not be invoked. 281// 282// form - the Form object for which a listener is added 283// handler - receives notifications when the form is submitted 284 285FormEventManager.prototype.add_submit_handler = function(handler) 286{ 287 this.add_handler("submit", handler); 288} 289 290// add_postsubmit_handler(handler) 291// 292// Used to perform final cleanup after all submit listeners have been invoked. 293// 294// form - the Form object for which a listener is added 295// handler - receives notifications when the form is submitted 296 297FormEventManager.prototype.add_postsubmit_handler = function(handler) 298{ 299 this.add_handler("postsubmit", handler); 300} 301 302// submit() 303// 304// Submits a form programatically. 305// 306 307FormEventManager.prototype.submit = function(name) 308{ 309 if (this.onsubmit_handler()) 310 { 311 this.form.onsubmit = null; 312 313 this.form.submitname.value = name; 314 this.form.submit(); 315 } 316} 317 318// onsubmit_handler() 319// 320// The handler for the form's onsubmit event. Invokes the presubmit, submit 321// and postsubmit handlers and returns false if any handler sets the 322// event's abort flag. Otherwise, sets the form's submitmode to "submit" 323// and return true. 324// 325 326FormEventManager.prototype.onsubmit_handler = function() 327{ 328 var event = new FormSubmitEvent(this.form, "submit", this.invalid_field_handler); 329 330 this.invoke_handlers("presubmit", event); 331 this.invoke_handlers("submit", event); 332 this.invoke_handlers("postsubmit", event); 333 334 if (event.abort) 335 return false;
336 337 this.form.submitmode.value = "submit"; 338 this.form.submitname.value = ""; 339 340 return true; 341} 342 343// add_refresh_handler(handler) 344// 345// Used for a limited number of situations where some logic is necessary even 346// when a form is submitted for refresh. Normal submit listeners are skipped, but 347// refresh listeners are invoked. The handler is added as a submit listener and 348// a refresh listener. 349// 350// handler - receives notifications when the form is submitted (normally, or for refresh) 351 352FormEventManager.prototype.add_refresh_handler = function(handler) 353{ 354 this.add_handler("submit", handler); 355 this.add_handler("refresh", handler); 356} 357 358// refresh() 359// 360// Refreshes the form, which is a special kind of submit that bypasses the normal 361// submit listeners. This is used, typically, when updating a field causes requires 362// that another field be updated via a server round-trip. Refresh listeners 363// can prevent the form submission by setting the event's abort flag. 364 365FormEventManager.prototype.refresh = function(name) 366{ 367 var event = new FormSubmitEvent(this.form, "refresh", this.invalid_field_handler); 368 369 this.invoke_handlers("refresh", event); 370 371 if (event.abort) 372 return; 373 374 this.form.submitmode.value = "refresh"; 375 this.form.submitname.value = name; 376 this.form.onsubmit = null; 377 this.form.submit(); 378} 379 380// add_reset_handler(handler) 381// 382// Allow for special behavior when a form is reset, intended as the 383// form's onreset . Listeners are invoked 384// before the form is reset. 385 386FormEventManager.prototype.add_reset_handler = function(handler) 387{ 388 this.add_handler("reset", handler); 389} 390 391// onreset_handler() 392// 393// Handles a reset by invoking any "reset" handlers (which are rare). 394// Returns true, unless a handler sets the event.abort flag. 395 396FormEventManager.prototype.onreset_handler = function() 397{ 398 var event = new FormSubmitEvent(this.form, "reset", this.invalid_field_handler); 399 400 this.invoke_handlers("reset", event); 401 402 return ! event.abort; 403} 404 405
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.