corrade-http-templates – Blame information for rev 57
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
57 | office | 1 | define( [ |
2 | "./core", |
||
3 | "./var/document", |
||
4 | "./var/documentElement", |
||
5 | "./var/isFunction", |
||
6 | "./var/rnothtmlwhite", |
||
7 | "./var/slice", |
||
8 | "./data/var/dataPriv", |
||
9 | "./core/nodeName", |
||
10 | |||
11 | "./core/init", |
||
12 | "./selector" |
||
13 | ], function( jQuery, document, documentElement, isFunction, rnothtmlwhite, |
||
14 | slice, dataPriv, nodeName ) { |
||
15 | |||
16 | "use strict"; |
||
17 | |||
18 | var |
||
19 | rkeyEvent = /^key/, |
||
20 | rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, |
||
21 | rtypenamespace = /^([^.]*)(?:\.(.+)|)/; |
||
22 | |||
23 | function returnTrue() { |
||
24 | return true; |
||
25 | } |
||
26 | |||
27 | function returnFalse() { |
||
28 | return false; |
||
29 | } |
||
30 | |||
31 | // Support: IE <=9 only |
||
32 | // See #13393 for more info |
||
33 | function safeActiveElement() { |
||
34 | try { |
||
35 | return document.activeElement; |
||
36 | } catch ( err ) { } |
||
37 | } |
||
38 | |||
39 | function on( elem, types, selector, data, fn, one ) { |
||
40 | var origFn, type; |
||
41 | |||
42 | // Types can be a map of types/handlers |
||
43 | if ( typeof types === "object" ) { |
||
44 | |||
45 | // ( types-Object, selector, data ) |
||
46 | if ( typeof selector !== "string" ) { |
||
47 | |||
48 | // ( types-Object, data ) |
||
49 | data = data || selector; |
||
50 | selector = undefined; |
||
51 | } |
||
52 | for ( type in types ) { |
||
53 | on( elem, type, selector, data, types[ type ], one ); |
||
54 | } |
||
55 | return elem; |
||
56 | } |
||
57 | |||
58 | if ( data == null && fn == null ) { |
||
59 | |||
60 | // ( types, fn ) |
||
61 | fn = selector; |
||
62 | data = selector = undefined; |
||
63 | } else if ( fn == null ) { |
||
64 | if ( typeof selector === "string" ) { |
||
65 | |||
66 | // ( types, selector, fn ) |
||
67 | fn = data; |
||
68 | data = undefined; |
||
69 | } else { |
||
70 | |||
71 | // ( types, data, fn ) |
||
72 | fn = data; |
||
73 | data = selector; |
||
74 | selector = undefined; |
||
75 | } |
||
76 | } |
||
77 | if ( fn === false ) { |
||
78 | fn = returnFalse; |
||
79 | } else if ( !fn ) { |
||
80 | return elem; |
||
81 | } |
||
82 | |||
83 | if ( one === 1 ) { |
||
84 | origFn = fn; |
||
85 | fn = function( event ) { |
||
86 | |||
87 | // Can use an empty set, since event contains the info |
||
88 | jQuery().off( event ); |
||
89 | return origFn.apply( this, arguments ); |
||
90 | }; |
||
91 | |||
92 | // Use same guid so caller can remove using origFn |
||
93 | fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); |
||
94 | } |
||
95 | return elem.each( function() { |
||
96 | jQuery.event.add( this, types, fn, data, selector ); |
||
97 | } ); |
||
98 | } |
||
99 | |||
100 | /* |
||
101 | * Helper functions for managing events -- not part of the public interface. |
||
102 | * Props to Dean Edwards' addEvent library for many of the ideas. |
||
103 | */ |
||
104 | jQuery.event = { |
||
105 | |||
106 | global: {}, |
||
107 | |||
108 | add: function( elem, types, handler, data, selector ) { |
||
109 | |||
110 | var handleObjIn, eventHandle, tmp, |
||
111 | events, t, handleObj, |
||
112 | special, handlers, type, namespaces, origType, |
||
113 | elemData = dataPriv.get( elem ); |
||
114 | |||
115 | // Don't attach events to noData or text/comment nodes (but allow plain objects) |
||
116 | if ( !elemData ) { |
||
117 | return; |
||
118 | } |
||
119 | |||
120 | // Caller can pass in an object of custom data in lieu of the handler |
||
121 | if ( handler.handler ) { |
||
122 | handleObjIn = handler; |
||
123 | handler = handleObjIn.handler; |
||
124 | selector = handleObjIn.selector; |
||
125 | } |
||
126 | |||
127 | // Ensure that invalid selectors throw exceptions at attach time |
||
128 | // Evaluate against documentElement in case elem is a non-element node (e.g., document) |
||
129 | if ( selector ) { |
||
130 | jQuery.find.matchesSelector( documentElement, selector ); |
||
131 | } |
||
132 | |||
133 | // Make sure that the handler has a unique ID, used to find/remove it later |
||
134 | if ( !handler.guid ) { |
||
135 | handler.guid = jQuery.guid++; |
||
136 | } |
||
137 | |||
138 | // Init the element's event structure and main handler, if this is the first |
||
139 | if ( !( events = elemData.events ) ) { |
||
140 | events = elemData.events = {}; |
||
141 | } |
||
142 | if ( !( eventHandle = elemData.handle ) ) { |
||
143 | eventHandle = elemData.handle = function( e ) { |
||
144 | |||
145 | // Discard the second event of a jQuery.event.trigger() and |
||
146 | // when an event is called after a page has unloaded |
||
147 | return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? |
||
148 | jQuery.event.dispatch.apply( elem, arguments ) : undefined; |
||
149 | }; |
||
150 | } |
||
151 | |||
152 | // Handle multiple events separated by a space |
||
153 | types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; |
||
154 | t = types.length; |
||
155 | while ( t-- ) { |
||
156 | tmp = rtypenamespace.exec( types[ t ] ) || []; |
||
157 | type = origType = tmp[ 1 ]; |
||
158 | namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); |
||
159 | |||
160 | // There *must* be a type, no attaching namespace-only handlers |
||
161 | if ( !type ) { |
||
162 | continue; |
||
163 | } |
||
164 | |||
165 | // If event changes its type, use the special event handlers for the changed type |
||
166 | special = jQuery.event.special[ type ] || {}; |
||
167 | |||
168 | // If selector defined, determine special event api type, otherwise given type |
||
169 | type = ( selector ? special.delegateType : special.bindType ) || type; |
||
170 | |||
171 | // Update special based on newly reset type |
||
172 | special = jQuery.event.special[ type ] || {}; |
||
173 | |||
174 | // handleObj is passed to all event handlers |
||
175 | handleObj = jQuery.extend( { |
||
176 | type: type, |
||
177 | origType: origType, |
||
178 | data: data, |
||
179 | handler: handler, |
||
180 | guid: handler.guid, |
||
181 | selector: selector, |
||
182 | needsContext: selector && jQuery.expr.match.needsContext.test( selector ), |
||
183 | namespace: namespaces.join( "." ) |
||
184 | }, handleObjIn ); |
||
185 | |||
186 | // Init the event handler queue if we're the first |
||
187 | if ( !( handlers = events[ type ] ) ) { |
||
188 | handlers = events[ type ] = []; |
||
189 | handlers.delegateCount = 0; |
||
190 | |||
191 | // Only use addEventListener if the special events handler returns false |
||
192 | if ( !special.setup || |
||
193 | special.setup.call( elem, data, namespaces, eventHandle ) === false ) { |
||
194 | |||
195 | if ( elem.addEventListener ) { |
||
196 | elem.addEventListener( type, eventHandle ); |
||
197 | } |
||
198 | } |
||
199 | } |
||
200 | |||
201 | if ( special.add ) { |
||
202 | special.add.call( elem, handleObj ); |
||
203 | |||
204 | if ( !handleObj.handler.guid ) { |
||
205 | handleObj.handler.guid = handler.guid; |
||
206 | } |
||
207 | } |
||
208 | |||
209 | // Add to the element's handler list, delegates in front |
||
210 | if ( selector ) { |
||
211 | handlers.splice( handlers.delegateCount++, 0, handleObj ); |
||
212 | } else { |
||
213 | handlers.push( handleObj ); |
||
214 | } |
||
215 | |||
216 | // Keep track of which events have ever been used, for event optimization |
||
217 | jQuery.event.global[ type ] = true; |
||
218 | } |
||
219 | |||
220 | }, |
||
221 | |||
222 | // Detach an event or set of events from an element |
||
223 | remove: function( elem, types, handler, selector, mappedTypes ) { |
||
224 | |||
225 | var j, origCount, tmp, |
||
226 | events, t, handleObj, |
||
227 | special, handlers, type, namespaces, origType, |
||
228 | elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); |
||
229 | |||
230 | if ( !elemData || !( events = elemData.events ) ) { |
||
231 | return; |
||
232 | } |
||
233 | |||
234 | // Once for each type.namespace in types; type may be omitted |
||
235 | types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; |
||
236 | t = types.length; |
||
237 | while ( t-- ) { |
||
238 | tmp = rtypenamespace.exec( types[ t ] ) || []; |
||
239 | type = origType = tmp[ 1 ]; |
||
240 | namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); |
||
241 | |||
242 | // Unbind all events (on this namespace, if provided) for the element |
||
243 | if ( !type ) { |
||
244 | for ( type in events ) { |
||
245 | jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); |
||
246 | } |
||
247 | continue; |
||
248 | } |
||
249 | |||
250 | special = jQuery.event.special[ type ] || {}; |
||
251 | type = ( selector ? special.delegateType : special.bindType ) || type; |
||
252 | handlers = events[ type ] || []; |
||
253 | tmp = tmp[ 2 ] && |
||
254 | new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); |
||
255 | |||
256 | // Remove matching events |
||
257 | origCount = j = handlers.length; |
||
258 | while ( j-- ) { |
||
259 | handleObj = handlers[ j ]; |
||
260 | |||
261 | if ( ( mappedTypes || origType === handleObj.origType ) && |
||
262 | ( !handler || handler.guid === handleObj.guid ) && |
||
263 | ( !tmp || tmp.test( handleObj.namespace ) ) && |
||
264 | ( !selector || selector === handleObj.selector || |
||
265 | selector === "**" && handleObj.selector ) ) { |
||
266 | handlers.splice( j, 1 ); |
||
267 | |||
268 | if ( handleObj.selector ) { |
||
269 | handlers.delegateCount--; |
||
270 | } |
||
271 | if ( special.remove ) { |
||
272 | special.remove.call( elem, handleObj ); |
||
273 | } |
||
274 | } |
||
275 | } |
||
276 | |||
277 | // Remove generic event handler if we removed something and no more handlers exist |
||
278 | // (avoids potential for endless recursion during removal of special event handlers) |
||
279 | if ( origCount && !handlers.length ) { |
||
280 | if ( !special.teardown || |
||
281 | special.teardown.call( elem, namespaces, elemData.handle ) === false ) { |
||
282 | |||
283 | jQuery.removeEvent( elem, type, elemData.handle ); |
||
284 | } |
||
285 | |||
286 | delete events[ type ]; |
||
287 | } |
||
288 | } |
||
289 | |||
290 | // Remove data and the expando if it's no longer used |
||
291 | if ( jQuery.isEmptyObject( events ) ) { |
||
292 | dataPriv.remove( elem, "handle events" ); |
||
293 | } |
||
294 | }, |
||
295 | |||
296 | dispatch: function( nativeEvent ) { |
||
297 | |||
298 | // Make a writable jQuery.Event from the native event object |
||
299 | var event = jQuery.event.fix( nativeEvent ); |
||
300 | |||
301 | var i, j, ret, matched, handleObj, handlerQueue, |
||
302 | args = new Array( arguments.length ), |
||
303 | handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], |
||
304 | special = jQuery.event.special[ event.type ] || {}; |
||
305 | |||
306 | // Use the fix-ed jQuery.Event rather than the (read-only) native event |
||
307 | args[ 0 ] = event; |
||
308 | |||
309 | for ( i = 1; i < arguments.length; i++ ) { |
||
310 | args[ i ] = arguments[ i ]; |
||
311 | } |
||
312 | |||
313 | event.delegateTarget = this; |
||
314 | |||
315 | // Call the preDispatch hook for the mapped type, and let it bail if desired |
||
316 | if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { |
||
317 | return; |
||
318 | } |
||
319 | |||
320 | // Determine handlers |
||
321 | handlerQueue = jQuery.event.handlers.call( this, event, handlers ); |
||
322 | |||
323 | // Run delegates first; they may want to stop propagation beneath us |
||
324 | i = 0; |
||
325 | while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { |
||
326 | event.currentTarget = matched.elem; |
||
327 | |||
328 | j = 0; |
||
329 | while ( ( handleObj = matched.handlers[ j++ ] ) && |
||
330 | !event.isImmediatePropagationStopped() ) { |
||
331 | |||
332 | // Triggered event must either 1) have no namespace, or 2) have namespace(s) |
||
333 | // a subset or equal to those in the bound event (both can have no namespace). |
||
334 | if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) { |
||
335 | |||
336 | event.handleObj = handleObj; |
||
337 | event.data = handleObj.data; |
||
338 | |||
339 | ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || |
||
340 | handleObj.handler ).apply( matched.elem, args ); |
||
341 | |||
342 | if ( ret !== undefined ) { |
||
343 | if ( ( event.result = ret ) === false ) { |
||
344 | event.preventDefault(); |
||
345 | event.stopPropagation(); |
||
346 | } |
||
347 | } |
||
348 | } |
||
349 | } |
||
350 | } |
||
351 | |||
352 | // Call the postDispatch hook for the mapped type |
||
353 | if ( special.postDispatch ) { |
||
354 | special.postDispatch.call( this, event ); |
||
355 | } |
||
356 | |||
357 | return event.result; |
||
358 | }, |
||
359 | |||
360 | handlers: function( event, handlers ) { |
||
361 | var i, handleObj, sel, matchedHandlers, matchedSelectors, |
||
362 | handlerQueue = [], |
||
363 | delegateCount = handlers.delegateCount, |
||
364 | cur = event.target; |
||
365 | |||
366 | // Find delegate handlers |
||
367 | if ( delegateCount && |
||
368 | |||
369 | // Support: IE <=9 |
||
370 | // Black-hole SVG <use> instance trees (trac-13180) |
||
371 | cur.nodeType && |
||
372 | |||
373 | // Support: Firefox <=42 |
||
374 | // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) |
||
375 | // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click |
||
376 | // Support: IE 11 only |
||
377 | // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) |
||
378 | !( event.type === "click" && event.button >= 1 ) ) { |
||
379 | |||
380 | for ( ; cur !== this; cur = cur.parentNode || this ) { |
||
381 | |||
382 | // Don't check non-elements (#13208) |
||
383 | // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) |
||
384 | if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { |
||
385 | matchedHandlers = []; |
||
386 | matchedSelectors = {}; |
||
387 | for ( i = 0; i < delegateCount; i++ ) { |
||
388 | handleObj = handlers[ i ]; |
||
389 | |||
390 | // Don't conflict with Object.prototype properties (#13203) |
||
391 | sel = handleObj.selector + " "; |
||
392 | |||
393 | if ( matchedSelectors[ sel ] === undefined ) { |
||
394 | matchedSelectors[ sel ] = handleObj.needsContext ? |
||
395 | jQuery( sel, this ).index( cur ) > -1 : |
||
396 | jQuery.find( sel, this, null, [ cur ] ).length; |
||
397 | } |
||
398 | if ( matchedSelectors[ sel ] ) { |
||
399 | matchedHandlers.push( handleObj ); |
||
400 | } |
||
401 | } |
||
402 | if ( matchedHandlers.length ) { |
||
403 | handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); |
||
404 | } |
||
405 | } |
||
406 | } |
||
407 | } |
||
408 | |||
409 | // Add the remaining (directly-bound) handlers |
||
410 | cur = this; |
||
411 | if ( delegateCount < handlers.length ) { |
||
412 | handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); |
||
413 | } |
||
414 | |||
415 | return handlerQueue; |
||
416 | }, |
||
417 | |||
418 | addProp: function( name, hook ) { |
||
419 | Object.defineProperty( jQuery.Event.prototype, name, { |
||
420 | enumerable: true, |
||
421 | configurable: true, |
||
422 | |||
423 | get: isFunction( hook ) ? |
||
424 | function() { |
||
425 | if ( this.originalEvent ) { |
||
426 | return hook( this.originalEvent ); |
||
427 | } |
||
428 | } : |
||
429 | function() { |
||
430 | if ( this.originalEvent ) { |
||
431 | return this.originalEvent[ name ]; |
||
432 | } |
||
433 | }, |
||
434 | |||
435 | set: function( value ) { |
||
436 | Object.defineProperty( this, name, { |
||
437 | enumerable: true, |
||
438 | configurable: true, |
||
439 | writable: true, |
||
440 | value: value |
||
441 | } ); |
||
442 | } |
||
443 | } ); |
||
444 | }, |
||
445 | |||
446 | fix: function( originalEvent ) { |
||
447 | return originalEvent[ jQuery.expando ] ? |
||
448 | originalEvent : |
||
449 | new jQuery.Event( originalEvent ); |
||
450 | }, |
||
451 | |||
452 | special: { |
||
453 | load: { |
||
454 | |||
455 | // Prevent triggered image.load events from bubbling to window.load |
||
456 | noBubble: true |
||
457 | }, |
||
458 | focus: { |
||
459 | |||
460 | // Fire native event if possible so blur/focus sequence is correct |
||
461 | trigger: function() { |
||
462 | if ( this !== safeActiveElement() && this.focus ) { |
||
463 | this.focus(); |
||
464 | return false; |
||
465 | } |
||
466 | }, |
||
467 | delegateType: "focusin" |
||
468 | }, |
||
469 | blur: { |
||
470 | trigger: function() { |
||
471 | if ( this === safeActiveElement() && this.blur ) { |
||
472 | this.blur(); |
||
473 | return false; |
||
474 | } |
||
475 | }, |
||
476 | delegateType: "focusout" |
||
477 | }, |
||
478 | click: { |
||
479 | |||
480 | // For checkbox, fire native event so checked state will be right |
||
481 | trigger: function() { |
||
482 | if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) { |
||
483 | this.click(); |
||
484 | return false; |
||
485 | } |
||
486 | }, |
||
487 | |||
488 | // For cross-browser consistency, don't fire native .click() on links |
||
489 | _default: function( event ) { |
||
490 | return nodeName( event.target, "a" ); |
||
491 | } |
||
492 | }, |
||
493 | |||
494 | beforeunload: { |
||
495 | postDispatch: function( event ) { |
||
496 | |||
497 | // Support: Firefox 20+ |
||
498 | // Firefox doesn't alert if the returnValue field is not set. |
||
499 | if ( event.result !== undefined && event.originalEvent ) { |
||
500 | event.originalEvent.returnValue = event.result; |
||
501 | } |
||
502 | } |
||
503 | } |
||
504 | } |
||
505 | }; |
||
506 | |||
507 | jQuery.removeEvent = function( elem, type, handle ) { |
||
508 | |||
509 | // This "if" is needed for plain objects |
||
510 | if ( elem.removeEventListener ) { |
||
511 | elem.removeEventListener( type, handle ); |
||
512 | } |
||
513 | }; |
||
514 | |||
515 | jQuery.Event = function( src, props ) { |
||
516 | |||
517 | // Allow instantiation without the 'new' keyword |
||
518 | if ( !( this instanceof jQuery.Event ) ) { |
||
519 | return new jQuery.Event( src, props ); |
||
520 | } |
||
521 | |||
522 | // Event object |
||
523 | if ( src && src.type ) { |
||
524 | this.originalEvent = src; |
||
525 | this.type = src.type; |
||
526 | |||
527 | // Events bubbling up the document may have been marked as prevented |
||
528 | // by a handler lower down the tree; reflect the correct value. |
||
529 | this.isDefaultPrevented = src.defaultPrevented || |
||
530 | src.defaultPrevented === undefined && |
||
531 | |||
532 | // Support: Android <=2.3 only |
||
533 | src.returnValue === false ? |
||
534 | returnTrue : |
||
535 | returnFalse; |
||
536 | |||
537 | // Create target properties |
||
538 | // Support: Safari <=6 - 7 only |
||
539 | // Target should not be a text node (#504, #13143) |
||
540 | this.target = ( src.target && src.target.nodeType === 3 ) ? |
||
541 | src.target.parentNode : |
||
542 | src.target; |
||
543 | |||
544 | this.currentTarget = src.currentTarget; |
||
545 | this.relatedTarget = src.relatedTarget; |
||
546 | |||
547 | // Event type |
||
548 | } else { |
||
549 | this.type = src; |
||
550 | } |
||
551 | |||
552 | // Put explicitly provided properties onto the event object |
||
553 | if ( props ) { |
||
554 | jQuery.extend( this, props ); |
||
555 | } |
||
556 | |||
557 | // Create a timestamp if incoming event doesn't have one |
||
558 | this.timeStamp = src && src.timeStamp || Date.now(); |
||
559 | |||
560 | // Mark it as fixed |
||
561 | this[ jQuery.expando ] = true; |
||
562 | }; |
||
563 | |||
564 | // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding |
||
565 | // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html |
||
566 | jQuery.Event.prototype = { |
||
567 | constructor: jQuery.Event, |
||
568 | isDefaultPrevented: returnFalse, |
||
569 | isPropagationStopped: returnFalse, |
||
570 | isImmediatePropagationStopped: returnFalse, |
||
571 | isSimulated: false, |
||
572 | |||
573 | preventDefault: function() { |
||
574 | var e = this.originalEvent; |
||
575 | |||
576 | this.isDefaultPrevented = returnTrue; |
||
577 | |||
578 | if ( e && !this.isSimulated ) { |
||
579 | e.preventDefault(); |
||
580 | } |
||
581 | }, |
||
582 | stopPropagation: function() { |
||
583 | var e = this.originalEvent; |
||
584 | |||
585 | this.isPropagationStopped = returnTrue; |
||
586 | |||
587 | if ( e && !this.isSimulated ) { |
||
588 | e.stopPropagation(); |
||
589 | } |
||
590 | }, |
||
591 | stopImmediatePropagation: function() { |
||
592 | var e = this.originalEvent; |
||
593 | |||
594 | this.isImmediatePropagationStopped = returnTrue; |
||
595 | |||
596 | if ( e && !this.isSimulated ) { |
||
597 | e.stopImmediatePropagation(); |
||
598 | } |
||
599 | |||
600 | this.stopPropagation(); |
||
601 | } |
||
602 | }; |
||
603 | |||
604 | // Includes all common event props including KeyEvent and MouseEvent specific props |
||
605 | jQuery.each( { |
||
606 | altKey: true, |
||
607 | bubbles: true, |
||
608 | cancelable: true, |
||
609 | changedTouches: true, |
||
610 | ctrlKey: true, |
||
611 | detail: true, |
||
612 | eventPhase: true, |
||
613 | metaKey: true, |
||
614 | pageX: true, |
||
615 | pageY: true, |
||
616 | shiftKey: true, |
||
617 | view: true, |
||
618 | "char": true, |
||
619 | charCode: true, |
||
620 | key: true, |
||
621 | keyCode: true, |
||
622 | button: true, |
||
623 | buttons: true, |
||
624 | clientX: true, |
||
625 | clientY: true, |
||
626 | offsetX: true, |
||
627 | offsetY: true, |
||
628 | pointerId: true, |
||
629 | pointerType: true, |
||
630 | screenX: true, |
||
631 | screenY: true, |
||
632 | targetTouches: true, |
||
633 | toElement: true, |
||
634 | touches: true, |
||
635 | |||
636 | which: function( event ) { |
||
637 | var button = event.button; |
||
638 | |||
639 | // Add which for key events |
||
640 | if ( event.which == null && rkeyEvent.test( event.type ) ) { |
||
641 | return event.charCode != null ? event.charCode : event.keyCode; |
||
642 | } |
||
643 | |||
644 | // Add which for click: 1 === left; 2 === middle; 3 === right |
||
645 | if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { |
||
646 | if ( button & 1 ) { |
||
647 | return 1; |
||
648 | } |
||
649 | |||
650 | if ( button & 2 ) { |
||
651 | return 3; |
||
652 | } |
||
653 | |||
654 | if ( button & 4 ) { |
||
655 | return 2; |
||
656 | } |
||
657 | |||
658 | return 0; |
||
659 | } |
||
660 | |||
661 | return event.which; |
||
662 | } |
||
663 | }, jQuery.event.addProp ); |
||
664 | |||
665 | // Create mouseenter/leave events using mouseover/out and event-time checks |
||
666 | // so that event delegation works in jQuery. |
||
667 | // Do the same for pointerenter/pointerleave and pointerover/pointerout |
||
668 | // |
||
669 | // Support: Safari 7 only |
||
670 | // Safari sends mouseenter too often; see: |
||
671 | // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 |
||
672 | // for the description of the bug (it existed in older Chrome versions as well). |
||
673 | jQuery.each( { |
||
674 | mouseenter: "mouseover", |
||
675 | mouseleave: "mouseout", |
||
676 | pointerenter: "pointerover", |
||
677 | pointerleave: "pointerout" |
||
678 | }, function( orig, fix ) { |
||
679 | jQuery.event.special[ orig ] = { |
||
680 | delegateType: fix, |
||
681 | bindType: fix, |
||
682 | |||
683 | handle: function( event ) { |
||
684 | var ret, |
||
685 | target = this, |
||
686 | related = event.relatedTarget, |
||
687 | handleObj = event.handleObj; |
||
688 | |||
689 | // For mouseenter/leave call the handler if related is outside the target. |
||
690 | // NB: No relatedTarget if the mouse left/entered the browser window |
||
691 | if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { |
||
692 | event.type = handleObj.origType; |
||
693 | ret = handleObj.handler.apply( this, arguments ); |
||
694 | event.type = fix; |
||
695 | } |
||
696 | return ret; |
||
697 | } |
||
698 | }; |
||
699 | } ); |
||
700 | |||
701 | jQuery.fn.extend( { |
||
702 | |||
703 | on: function( types, selector, data, fn ) { |
||
704 | return on( this, types, selector, data, fn ); |
||
705 | }, |
||
706 | one: function( types, selector, data, fn ) { |
||
707 | return on( this, types, selector, data, fn, 1 ); |
||
708 | }, |
||
709 | off: function( types, selector, fn ) { |
||
710 | var handleObj, type; |
||
711 | if ( types && types.preventDefault && types.handleObj ) { |
||
712 | |||
713 | // ( event ) dispatched jQuery.Event |
||
714 | handleObj = types.handleObj; |
||
715 | jQuery( types.delegateTarget ).off( |
||
716 | handleObj.namespace ? |
||
717 | handleObj.origType + "." + handleObj.namespace : |
||
718 | handleObj.origType, |
||
719 | handleObj.selector, |
||
720 | handleObj.handler |
||
721 | ); |
||
722 | return this; |
||
723 | } |
||
724 | if ( typeof types === "object" ) { |
||
725 | |||
726 | // ( types-object [, selector] ) |
||
727 | for ( type in types ) { |
||
728 | this.off( type, selector, types[ type ] ); |
||
729 | } |
||
730 | return this; |
||
731 | } |
||
732 | if ( selector === false || typeof selector === "function" ) { |
||
733 | |||
734 | // ( types [, fn] ) |
||
735 | fn = selector; |
||
736 | selector = undefined; |
||
737 | } |
||
738 | if ( fn === false ) { |
||
739 | fn = returnFalse; |
||
740 | } |
||
741 | return this.each( function() { |
||
742 | jQuery.event.remove( this, types, fn, selector ); |
||
743 | } ); |
||
744 | } |
||
745 | } ); |
||
746 | |||
747 | return jQuery; |
||
748 | } ); |