") + + // inject the contents of the document in, removing the scripts + // to avoid any 'Permission Denied' errors in IE + .append( responseText.replace( rscript, "" ) ) + + // Locate the specified elements + .find( selector ) : + + // If not, just inject the full result + responseText ); + + }); + + return this; +}; + +// Attach a bunch of functions for handling common AJAX events +jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){ + jQuery.fn[ o ] = function( f ){ + return this.on( o, f ); + }; +}); + +jQuery.each( [ "get", "post" ], function( i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { + // shift arguments if data argument was omitted + if ( jQuery.isFunction( data ) ) { + type = type || callback; + callback = data; + data = undefined; + } + + return jQuery.ajax({ + type: method, + url: url, + data: data, + success: callback, + dataType: type + }); + }; +}); + +jQuery.extend({ + + getScript: function( url, callback ) { + return jQuery.get( url, undefined, callback, "script" ); + }, + + getJSON: function( url, data, callback ) { + return jQuery.get( url, data, callback, "json" ); + }, + + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function( target, settings ) { + if ( settings ) { + // Building a settings object + ajaxExtend( target, jQuery.ajaxSettings ); + } else { + // Extending ajaxSettings + settings = target; + target = jQuery.ajaxSettings; + } + ajaxExtend( target, settings ); + return target; + }, + + ajaxSettings: { + url: ajaxLocation, + isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ), + global: true, + type: "GET", + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + processData: true, + async: true, + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + + accepts: { + xml: "application/xml, text/xml", + html: "text/html", + text: "text/plain", + json: "application/json, text/javascript", + "*": allTypes + }, + + contents: { + xml: /xml/, + html: /html/, + json: /json/ + }, + + responseFields: { + xml: "responseXML", + text: "responseText" + }, + + // List of data converters + // 1) key format is "source_type destination_type" (a single space in-between) + // 2) the catchall symbol "*" can be used for source_type + converters: { + + // Convert anything to text + "* text": window.String, + + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": jQuery.parseJSON, + + // Parse text as xml + "text xml": jQuery.parseXML + }, + + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + context: true, + url: true + } + }, + + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), + ajaxTransport: addToPrefiltersOrTransports( transports ), + + // Main method + ajax: function( url, options ) { + + // If url is an object, simulate pre-1.5 signature + if ( typeof url === "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var // ifModified key + ifModifiedKey, + // Response headers + responseHeadersString, + responseHeaders, + // transport + transport, + // timeout handle + timeoutTimer, + // Cross-domain detection vars + parts, + // To know if global events are to be dispatched + fireGlobals, + // Loop variable + i, + // Create the final options object + s = jQuery.ajaxSetup( {}, options ), + // Callbacks context + callbackContext = s.context || s, + // Context for global events + // It's the callbackContext if one was provided in the options + // and if it's a DOM node or a jQuery collection + globalEventContext = callbackContext !== s && + ( callbackContext.nodeType || callbackContext instanceof jQuery ) ? + jQuery( callbackContext ) : jQuery.event, + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery.Callbacks( "once memory" ), + // Status-dependent callbacks + statusCode = s.statusCode || {}, + // Headers (they are sent all at once) + requestHeaders = {}, + requestHeadersNames = {}, + // The jqXHR state + state = 0, + // Default abort message + strAbort = "canceled", + // Fake xhr + jqXHR = { + + readyState: 0, + + // Caches the header + setRequestHeader: function( name, value ) { + if ( !state ) { + var lname = name.toLowerCase(); + name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name; + requestHeaders[ name ] = value; + } + return this; + }, + + // Raw string + getAllResponseHeaders: function() { + return state === 2 ? responseHeadersString : null; + }, + + // Builds headers hashtable if needed + getResponseHeader: function( key ) { + var match; + if ( state === 2 ) { + if ( !responseHeaders ) { + responseHeaders = {}; + while( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[1].toLowerCase() ] = match[ 2 ]; + } + } + match = responseHeaders[ key.toLowerCase() ]; + } + return match === undefined ? null : match; + }, + + // Overrides response content-type header + overrideMimeType: function( type ) { + if ( !state ) { + s.mimeType = type; + } + return this; + }, + + // Cancel the request + abort: function( statusText ) { + statusText = statusText || strAbort; + if ( transport ) { + transport.abort( statusText ); + } + done( 0, statusText ); + return this; + } + }; + + // Callback for when everything is done + // It is defined here because jslint complains if it is declared + // at the end of the function (which would be more logical and readable) + function done( status, nativeStatusText, responses, headers ) { + var isSuccess, success, error, response, modified, + statusText = nativeStatusText; + + // Called once + if ( state === 2 ) { + return; + } + + // State is "done" now + state = 2; + + // Clear timeout if it exists + if ( timeoutTimer ) { + clearTimeout( timeoutTimer ); + } + + // Dereference transport for early garbage collection + // (no matter how long the jqXHR object will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Get response data + if ( responses ) { + response = ajaxHandleResponses( s, jqXHR, responses ); + } + + // If successful, handle type chaining + if ( status >= 200 && status < 300 || status === 304 ) { + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + + modified = jqXHR.getResponseHeader("Last-Modified"); + if ( modified ) { + jQuery.lastModified[ ifModifiedKey ] = modified; + } + modified = jqXHR.getResponseHeader("Etag"); + if ( modified ) { + jQuery.etag[ ifModifiedKey ] = modified; + } + } + + // If not modified + if ( status === 304 ) { + + statusText = "notmodified"; + isSuccess = true; + + // If we have data + } else { + + isSuccess = ajaxConvert( s, response ); + statusText = isSuccess.state; + success = isSuccess.data; + error = isSuccess.error; + isSuccess = !error; + } + } else { + // We extract error from statusText + // then normalize statusText and status for non-aborts + error = statusText; + if ( !statusText || status ) { + statusText = "error"; + if ( status < 0 ) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; + + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); + } else { + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); + } + + // Status-dependent callbacks + jqXHR.statusCode( statusCode ); + statusCode = undefined; + + if ( fireGlobals ) { + globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ), + [ jqXHR, s, isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); + + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); + // Handle the global AJAX counter + if ( !( --jQuery.active ) ) { + jQuery.event.trigger( "ajaxStop" ); + } + } + } + + // Attach deferreds + deferred.promise( jqXHR ); + jqXHR.success = jqXHR.done; + jqXHR.error = jqXHR.fail; + jqXHR.complete = completeDeferred.add; + + // Status-dependent callbacks + jqXHR.statusCode = function( map ) { + if ( map ) { + var tmp; + if ( state < 2 ) { + for ( tmp in map ) { + statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ]; + } + } else { + tmp = map[ jqXHR.status ]; + jqXHR.always( tmp ); + } + } + return this; + }; + + // Remove hash character (#7531: and string promotion) + // Add protocol if not provided (#5866: IE7 issue with protocol-less urls) + // We also use the url parameter if available + s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" ); + + // Extract dataTypes list + s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( core_rspace ); + + // A cross-domain request is in order when we have a protocol:host:port mismatch + if ( s.crossDomain == null ) { + parts = rurl.exec( s.url.toLowerCase() ); + s.crossDomain = !!( parts && + ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] || + ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) != + ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) ) + ); + } + + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data, s.traditional ); + } + + // Apply prefilters + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); + + // If request was aborted inside a prefilter, stop there + if ( state === 2 ) { + return jqXHR; + } + + // We can fire global events as of now if asked to + fireGlobals = s.global; + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test( s.type ); + + // Watch for a new set of requests + if ( fireGlobals && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); + } + + // More options handling for requests with no content + if ( !s.hasContent ) { + + // If data is available, append data to url + if ( s.data ) { + s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data; + // #9682: remove data so that it's not used in an eventual retry + delete s.data; + } + + // Get ifModifiedKey before adding the anti-cache parameter + ifModifiedKey = s.url; + + // Add anti-cache in url if needed + if ( s.cache === false ) { + + var ts = jQuery.now(), + // try replacing _= if it is there + ret = s.url.replace( rts, "$1_=" + ts ); + + // if nothing was replaced, add timestamp to the end + s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" ); + } + } + + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + jqXHR.setRequestHeader( "Content-Type", s.contentType ); + } + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + ifModifiedKey = ifModifiedKey || s.url; + if ( jQuery.lastModified[ ifModifiedKey ] ) { + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] ); + } + if ( jQuery.etag[ ifModifiedKey ] ) { + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] ); + } + } + + // Set the Accepts header for the server, depending on the dataType + jqXHR.setRequestHeader( + "Accept", + s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ? + s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : + s.accepts[ "*" ] + ); + + // Check for headers option + for ( i in s.headers ) { + jqXHR.setRequestHeader( i, s.headers[ i ] ); + } + + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) { + // Abort if not done already and return + return jqXHR.abort(); + + } + + // aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + for ( i in { success: 1, error: 1, complete: 1 } ) { + jqXHR[ i ]( s[ i ] ); + } + + // Get transport + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); + + // If no transport, we auto-abort + if ( !transport ) { + done( -1, "No Transport" ); + } else { + jqXHR.readyState = 1; + // Send global event + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); + } + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = setTimeout( function(){ + jqXHR.abort( "timeout" ); + }, s.timeout ); + } + + try { + state = 1; + transport.send( requestHeaders, done ); + } catch (e) { + // Propagate exception as error if not done + if ( state < 2 ) { + done( -1, e ); + // Simply rethrow otherwise + } else { + throw e; + } + } + } + + return jqXHR; + }, + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {} + +}); + +/* Handles responses to an ajax request: + * - sets all responseXXX fields accordingly + * - finds the right dataType (mediates between content-type and expected dataType) + * - returns the corresponding response + */ +function ajaxHandleResponses( s, jqXHR, responses ) { + + var ct, type, finalDataType, firstDataType, + contents = s.contents, + dataTypes = s.dataTypes, + responseFields = s.responseFields; + + // Fill responseXXX fields + for ( type in responseFields ) { + if ( type in responses ) { + jqXHR[ responseFields[type] ] = responses[ type ]; + } + } + + // Remove auto dataType and get content-type in the process + while( dataTypes[ 0 ] === "*" ) { + dataTypes.shift(); + if ( ct === undefined ) { + ct = s.mimeType || jqXHR.getResponseHeader( "content-type" ); + } + } + + // Check if we're dealing with a known content-type + if ( ct ) { + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + dataTypes.unshift( type ); + break; + } + } + } + + // Check to see if we have a response for the expected dataType + if ( dataTypes[ 0 ] in responses ) { + finalDataType = dataTypes[ 0 ]; + } else { + // Try convertible dataTypes + for ( type in responses ) { + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) { + finalDataType = type; + break; + } + if ( !firstDataType ) { + firstDataType = type; + } + } + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if ( finalDataType ) { + if ( finalDataType !== dataTypes[ 0 ] ) { + dataTypes.unshift( finalDataType ); + } + return responses[ finalDataType ]; + } +} + +// Chain conversions given the request and the original response +function ajaxConvert( s, response ) { + + var conv, conv2, current, tmp, + // Work with a copy of dataTypes in case we need to modify it for conversion + dataTypes = s.dataTypes.slice(), + prev = dataTypes[ 0 ], + converters = {}, + i = 0; + + // Apply the dataFilter if provided + if ( s.dataFilter ) { + response = s.dataFilter( response, s.dataType ); + } + + // Create converters map with lowercased keys + if ( dataTypes[ 1 ] ) { + for ( conv in s.converters ) { + converters[ conv.toLowerCase() ] = s.converters[ conv ]; + } + } + + // Convert to each sequential dataType, tolerating list modification + for ( ; (current = dataTypes[++i]); ) { + + // There's only work to do if current dataType is non-auto + if ( current !== "*" ) { + + // Convert response if prev dataType is non-auto and differs from current + if ( prev !== "*" && prev !== current ) { + + // Seek a direct converter + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; + + // If none found, seek a pair + if ( !conv ) { + for ( conv2 in converters ) { + + // If conv2 outputs current + tmp = conv2.split(" "); + if ( tmp[ 1 ] === current ) { + + // If prev can be converted to accepted input + conv = converters[ prev + " " + tmp[ 0 ] ] || + converters[ "* " + tmp[ 0 ] ]; + if ( conv ) { + // Condense equivalence converters + if ( conv === true ) { + conv = converters[ conv2 ]; + + // Otherwise, insert the intermediate dataType + } else if ( converters[ conv2 ] !== true ) { + current = tmp[ 0 ]; + dataTypes.splice( i--, 0, current ); + } + + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if ( conv !== true ) { + + // Unless errors are allowed to bubble, catch and return them + if ( conv && s["throws"] ) { + response = conv( response ); + } else { + try { + response = conv( response ); + } catch ( e ) { + return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; + } + } + } + } + + // Update prev for next iteration + prev = current; + } + } + + return { state: "success", data: response }; +} +var oldCallbacks = [], + rquestion = /\?/, + rjsonp = /(=)\?(?=&|$)|\?\?/, + nonce = jQuery.now(); + +// Default jsonp settings +jQuery.ajaxSetup({ + jsonp: "callback", + jsonpCallback: function() { + var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); + this[ callback ] = true; + return callback; + } +}); + +// Detect, normalize options and install callbacks for jsonp requests +jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { + + var callbackName, overwritten, responseContainer, + data = s.data, + url = s.url, + hasCallback = s.jsonp !== false, + replaceInUrl = hasCallback && rjsonp.test( url ), + replaceInData = hasCallback && !replaceInUrl && typeof data === "string" && + !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && + rjsonp.test( data ); + + // Handle iff the expected data type is "jsonp" or we have a parameter to set + if ( s.dataTypes[ 0 ] === "jsonp" || replaceInUrl || replaceInData ) { + + // Get callback name, remembering preexisting value associated with it + callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ? + s.jsonpCallback() : + s.jsonpCallback; + overwritten = window[ callbackName ]; + + // Insert callback into url or form data + if ( replaceInUrl ) { + s.url = url.replace( rjsonp, "$1" + callbackName ); + } else if ( replaceInData ) { + s.data = data.replace( rjsonp, "$1" + callbackName ); + } else if ( hasCallback ) { + s.url += ( rquestion.test( url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; + } + + // Use data converter to retrieve json after script execution + s.converters["script json"] = function() { + if ( !responseContainer ) { + jQuery.error( callbackName + " was not called" ); + } + return responseContainer[ 0 ]; + }; + + // force json dataType + s.dataTypes[ 0 ] = "json"; + + // Install callback + window[ callbackName ] = function() { + responseContainer = arguments; + }; + + // Clean-up function (fires after converters) + jqXHR.always(function() { + // Restore preexisting value + window[ callbackName ] = overwritten; + + // Save back as free + if ( s[ callbackName ] ) { + // make sure that re-using the options doesn't screw things around + s.jsonpCallback = originalSettings.jsonpCallback; + + // save the callback name for future use + oldCallbacks.push( callbackName ); + } + + // Call if it was a function and we have a response + if ( responseContainer && jQuery.isFunction( overwritten ) ) { + overwritten( responseContainer[ 0 ] ); + } + + responseContainer = overwritten = undefined; + }); + + // Delegate to script + return "script"; + } +}); +// Install script dataType +jQuery.ajaxSetup({ + accepts: { + script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /javascript|ecmascript/ + }, + converters: { + "text script": function( text ) { + jQuery.globalEval( text ); + return text; + } + } +}); + +// Handle cache's special case and global +jQuery.ajaxPrefilter( "script", function( s ) { + if ( s.cache === undefined ) { + s.cache = false; + } + if ( s.crossDomain ) { + s.type = "GET"; + s.global = false; + } +}); + +// Bind script tag hack transport +jQuery.ajaxTransport( "script", function(s) { + + // This transport only deals with cross domain requests + if ( s.crossDomain ) { + + var script, + head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement; + + return { + + send: function( _, callback ) { + + script = document.createElement( "script" ); + + script.async = "async"; + + if ( s.scriptCharset ) { + script.charset = s.scriptCharset; + } + + script.src = s.url; + + // Attach handlers for all browsers + script.onload = script.onreadystatechange = function( _, isAbort ) { + + if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) { + + // Handle memory leak in IE + script.onload = script.onreadystatechange = null; + + // Remove the script + if ( head && script.parentNode ) { + head.removeChild( script ); + } + + // Dereference the script + script = undefined; + + // Callback if not abort + if ( !isAbort ) { + callback( 200, "success" ); + } + } + }; + // Use insertBefore instead of appendChild to circumvent an IE6 bug. + // This arises when a base node is used (#2709 and #4378). + head.insertBefore( script, head.firstChild ); + }, + + abort: function() { + if ( script ) { + script.onload( 0, 1 ); + } + } + }; + } +}); +var xhrCallbacks, + // #5280: Internet Explorer will keep connections alive if we don't abort on unload + xhrOnUnloadAbort = window.ActiveXObject ? function() { + // Abort all pending requests + for ( var key in xhrCallbacks ) { + xhrCallbacks[ key ]( 0, 1 ); + } + } : false, + xhrId = 0; + +// Functions to create xhrs +function createStandardXHR() { + try { + return new window.XMLHttpRequest(); + } catch( e ) {} +} + +function createActiveXHR() { + try { + return new window.ActiveXObject( "Microsoft.XMLHTTP" ); + } catch( e ) {} +} + +// Create the request object +// (This is still attached to ajaxSettings for backward compatibility) +jQuery.ajaxSettings.xhr = window.ActiveXObject ? + /* Microsoft failed to properly + * implement the XMLHttpRequest in IE7 (can't request local files), + * so we use the ActiveXObject when it is available + * Additionally XMLHttpRequest can be disabled in IE7/IE8 so + * we need a fallback. + */ + function() { + return !this.isLocal && createStandardXHR() || createActiveXHR(); + } : + // For all other browsers, use the standard XMLHttpRequest object + createStandardXHR; + +// Determine support properties +(function( xhr ) { + jQuery.extend( jQuery.support, { + ajax: !!xhr, + cors: !!xhr && ( "withCredentials" in xhr ) + }); +})( jQuery.ajaxSettings.xhr() ); + +// Create transport if the browser can provide an xhr +if ( jQuery.support.ajax ) { + + jQuery.ajaxTransport(function( s ) { + // Cross domain only allowed if supported through XMLHttpRequest + if ( !s.crossDomain || jQuery.support.cors ) { + + var callback; + + return { + send: function( headers, complete ) { + + // Get a new xhr + var handle, i, + xhr = s.xhr(); + + // Open the socket + // Passing null username, generates a login popup on Opera (#2865) + if ( s.username ) { + xhr.open( s.type, s.url, s.async, s.username, s.password ); + } else { + xhr.open( s.type, s.url, s.async ); + } + + // Apply custom fields if provided + if ( s.xhrFields ) { + for ( i in s.xhrFields ) { + xhr[ i ] = s.xhrFields[ i ]; + } + } + + // Override mime type if needed + if ( s.mimeType && xhr.overrideMimeType ) { + xhr.overrideMimeType( s.mimeType ); + } + + // X-Requested-With header + // For cross-domain requests, seeing as conditions for a preflight are + // akin to a jigsaw puzzle, we simply never set it to be sure. + // (it can always be set on a per-request basis or even using ajaxSetup) + // For same-domain requests, won't change header if already provided. + if ( !s.crossDomain && !headers["X-Requested-With"] ) { + headers[ "X-Requested-With" ] = "XMLHttpRequest"; + } + + // Need an extra try/catch for cross domain requests in Firefox 3 + try { + for ( i in headers ) { + xhr.setRequestHeader( i, headers[ i ] ); + } + } catch( _ ) {} + + // Do send the request + // This may raise an exception which is actually + // handled in jQuery.ajax (so no try/catch here) + xhr.send( ( s.hasContent && s.data ) || null ); + + // Listener + callback = function( _, isAbort ) { + + var status, + statusText, + responseHeaders, + responses, + xml; + + // Firefox throws exceptions when accessing properties + // of an xhr when a network error occurred + // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE) + try { + + // Was never called and is aborted or complete + if ( callback && ( isAbort || xhr.readyState === 4 ) ) { + + // Only called once + callback = undefined; + + // Do not keep as active anymore + if ( handle ) { + xhr.onreadystatechange = jQuery.noop; + if ( xhrOnUnloadAbort ) { + delete xhrCallbacks[ handle ]; + } + } + + // If it's an abort + if ( isAbort ) { + // Abort it manually if needed + if ( xhr.readyState !== 4 ) { + xhr.abort(); + } + } else { + status = xhr.status; + responseHeaders = xhr.getAllResponseHeaders(); + responses = {}; + xml = xhr.responseXML; + + // Construct response list + if ( xml && xml.documentElement /* #4958 */ ) { + responses.xml = xml; + } + + // When requesting binary data, IE6-9 will throw an exception + // on any attempt to access responseText (#11426) + try { + responses.text = xhr.responseText; + } catch( e ) { + } + + // Firefox throws an exception when accessing + // statusText for faulty cross-domain requests + try { + statusText = xhr.statusText; + } catch( e ) { + // We normalize with Webkit giving an empty statusText + statusText = ""; + } + + // Filter status for non standard behaviors + + // If the request is local and we have data: assume a success + // (success with no data won't get notified, that's the best we + // can do given current implementations) + if ( !status && s.isLocal && !s.crossDomain ) { + status = responses.text ? 200 : 404; + // IE - #1450: sometimes returns 1223 when it should be 204 + } else if ( status === 1223 ) { + status = 204; + } + } + } + } catch( firefoxAccessException ) { + if ( !isAbort ) { + complete( -1, firefoxAccessException ); + } + } + + // Call complete if needed + if ( responses ) { + complete( status, statusText, responses, responseHeaders ); + } + }; + + if ( !s.async ) { + // if we're in sync mode we fire the callback + callback(); + } else if ( xhr.readyState === 4 ) { + // (IE6 & IE7) if it's in cache and has been + // retrieved directly we need to fire the callback + setTimeout( callback, 0 ); + } else { + handle = ++xhrId; + if ( xhrOnUnloadAbort ) { + // Create the active xhrs callbacks list if needed + // and attach the unload handler + if ( !xhrCallbacks ) { + xhrCallbacks = {}; + jQuery( window ).unload( xhrOnUnloadAbort ); + } + // Add to list of active xhrs callbacks + xhrCallbacks[ handle ] = callback; + } + xhr.onreadystatechange = callback; + } + }, + + abort: function() { + if ( callback ) { + callback(0,1); + } + } + }; + } + }); +} +var fxNow, timerId, + rfxtypes = /^(?:toggle|show|hide)$/, + rfxnum = new RegExp( "^(?:([-+])=|)(" + core_pnum + ")([a-z%]*)$", "i" ), + rrun = /queueHooks$/, + animationPrefilters = [ defaultPrefilter ], + tweeners = { + "*": [function( prop, value ) { + var end, unit, + tween = this.createTween( prop, value ), + parts = rfxnum.exec( value ), + target = tween.cur(), + start = +target || 0, + scale = 1, + maxIterations = 20; + + if ( parts ) { + end = +parts[2]; + unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + + // We need to compute starting value + if ( unit !== "px" && start ) { + // Iteratively approximate from a nonzero starting point + // Prefer the current property, because this process will be trivial if it uses the same units + // Fallback to end or a simple constant + start = jQuery.css( tween.elem, prop, true ) || end || 1; + + do { + // If previous iteration zeroed out, double until we get *something* + // Use a string for doubling factor so we don't accidentally see scale as unchanged below + scale = scale || ".5"; + + // Adjust and apply + start = start / scale; + jQuery.style( tween.elem, prop, start + unit ); + + // Update scale, tolerating zero or NaN from tween.cur() + // And breaking the loop if scale is unchanged or perfect, or if we've just had enough + } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations ); + } + + tween.unit = unit; + tween.start = start; + // If a +=/-= token was provided, we're doing a relative animation + tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end; + } + return tween; + }] + }; + +// Animations created synchronously will run synchronously +function createFxNow() { + setTimeout(function() { + fxNow = undefined; + }, 0 ); + return ( fxNow = jQuery.now() ); +} + +function createTweens( animation, props ) { + jQuery.each( props, function( prop, value ) { + var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ), + index = 0, + length = collection.length; + for ( ; index < length; index++ ) { + if ( collection[ index ].call( animation, prop, value ) ) { + + // we're done with this property + return; + } + } + }); +} + +function Animation( elem, properties, options ) { + var result, + index = 0, + tweenerIndex = 0, + length = animationPrefilters.length, + deferred = jQuery.Deferred().always( function() { + // don't match elem in the :animated selector + delete tick.elem; + }), + tick = function() { + var currentTime = fxNow || createFxNow(), + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), + // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497) + temp = remaining / animation.duration || 0, + percent = 1 - temp, + index = 0, + length = animation.tweens.length; + + for ( ; index < length ; index++ ) { + animation.tweens[ index ].run( percent ); + } + + deferred.notifyWith( elem, [ animation, percent, remaining ]); + + if ( percent < 1 && length ) { + return remaining; + } else { + deferred.resolveWith( elem, [ animation ] ); + return false; + } + }, + animation = deferred.promise({ + elem: elem, + props: jQuery.extend( {}, properties ), + opts: jQuery.extend( true, { specialEasing: {} }, options ), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function( prop, end, easing ) { + var tween = jQuery.Tween( elem, animation.opts, prop, end, + animation.opts.specialEasing[ prop ] || animation.opts.easing ); + animation.tweens.push( tween ); + return tween; + }, + stop: function( gotoEnd ) { + var index = 0, + // if we are going to the end, we want to run all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + + for ( ; index < length ; index++ ) { + animation.tweens[ index ].run( 1 ); + } + + // resolve when we played the last frame + // otherwise, reject + if ( gotoEnd ) { + deferred.resolveWith( elem, [ animation, gotoEnd ] ); + } else { + deferred.rejectWith( elem, [ animation, gotoEnd ] ); + } + return this; + } + }), + props = animation.props; + + propFilter( props, animation.opts.specialEasing ); + + for ( ; index < length ; index++ ) { + result = animationPrefilters[ index ].call( animation, elem, props, animation.opts ); + if ( result ) { + return result; + } + } + + createTweens( animation, props ); + + if ( jQuery.isFunction( animation.opts.start ) ) { + animation.opts.start.call( elem, animation ); + } + + jQuery.fx.timer( + jQuery.extend( tick, { + anim: animation, + queue: animation.opts.queue, + elem: elem + }) + ); + + // attach callbacks from options + return animation.progress( animation.opts.progress ) + .done( animation.opts.done, animation.opts.complete ) + .fail( animation.opts.fail ) + .always( animation.opts.always ); +} + +function propFilter( props, specialEasing ) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for ( index in props ) { + name = jQuery.camelCase( index ); + easing = specialEasing[ name ]; + value = props[ index ]; + if ( jQuery.isArray( value ) ) { + easing = value[ 1 ]; + value = props[ index ] = value[ 0 ]; + } + + if ( index !== name ) { + props[ name ] = value; + delete props[ index ]; + } + + hooks = jQuery.cssHooks[ name ]; + if ( hooks && "expand" in hooks ) { + value = hooks.expand( value ); + delete props[ name ]; + + // not quite $.extend, this wont overwrite keys already present. + // also - reusing 'index' from above because we have the correct "name" + for ( index in value ) { + if ( !( index in props ) ) { + props[ index ] = value[ index ]; + specialEasing[ index ] = easing; + } + } + } else { + specialEasing[ name ] = easing; + } + } +} + +jQuery.Animation = jQuery.extend( Animation, { + + tweener: function( props, callback ) { + if ( jQuery.isFunction( props ) ) { + callback = props; + props = [ "*" ]; + } else { + props = props.split(" "); + } + + var prop, + index = 0, + length = props.length; + + for ( ; index < length ; index++ ) { + prop = props[ index ]; + tweeners[ prop ] = tweeners[ prop ] || []; + tweeners[ prop ].unshift( callback ); + } + }, + + prefilter: function( callback, prepend ) { + if ( prepend ) { + animationPrefilters.unshift( callback ); + } else { + animationPrefilters.push( callback ); + } + } +}); + +function defaultPrefilter( elem, props, opts ) { + var index, prop, value, length, dataShow, toggle, tween, hooks, oldfire, + anim = this, + style = elem.style, + orig = {}, + handled = [], + hidden = elem.nodeType && isHidden( elem ); + + // handle queue: false promises + if ( !opts.queue ) { + hooks = jQuery._queueHooks( elem, "fx" ); + if ( hooks.unqueued == null ) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if ( !hooks.unqueued ) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always(function() { + // doing this makes sure that the complete handler will be called + // before this completes + anim.always(function() { + hooks.unqueued--; + if ( !jQuery.queue( elem, "fx" ).length ) { + hooks.empty.fire(); + } + }); + }); + } + + // height/width overflow pass + if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) { + // Make sure that nothing sneaks out + // Record all 3 overflow attributes because IE does not + // change the overflow attribute when overflowX and + // overflowY are set to the same value + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Set display property to inline-block for height/width + // animations on inline elements that are having width/height animated + if ( jQuery.css( elem, "display" ) === "inline" && + jQuery.css( elem, "float" ) === "none" ) { + + // inline-level elements accept inline-block; + // block-level elements need to be inline with layout + if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) { + style.display = "inline-block"; + + } else { + style.zoom = 1; + } + } + } + + if ( opts.overflow ) { + style.overflow = "hidden"; + if ( !jQuery.support.shrinkWrapBlocks ) { + anim.done(function() { + style.overflow = opts.overflow[ 0 ]; + style.overflowX = opts.overflow[ 1 ]; + style.overflowY = opts.overflow[ 2 ]; + }); + } + } + + + // show/hide pass + for ( index in props ) { + value = props[ index ]; + if ( rfxtypes.exec( value ) ) { + delete props[ index ]; + toggle = toggle || value === "toggle"; + if ( value === ( hidden ? "hide" : "show" ) ) { + continue; + } + handled.push( index ); + } + } + + length = handled.length; + if ( length ) { + dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} ); + if ( "hidden" in dataShow ) { + hidden = dataShow.hidden; + } + + // store state if its toggle - enables .stop().toggle() to "reverse" + if ( toggle ) { + dataShow.hidden = !hidden; + } + if ( hidden ) { + jQuery( elem ).show(); + } else { + anim.done(function() { + jQuery( elem ).hide(); + }); + } + anim.done(function() { + var prop; + jQuery.removeData( elem, "fxshow", true ); + for ( prop in orig ) { + jQuery.style( elem, prop, orig[ prop ] ); + } + }); + for ( index = 0 ; index < length ; index++ ) { + prop = handled[ index ]; + tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 ); + orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop ); + + if ( !( prop in dataShow ) ) { + dataShow[ prop ] = tween.start; + if ( hidden ) { + tween.end = tween.start; + tween.start = prop === "width" || prop === "height" ? 1 : 0; + } + } + } + } +} + +function Tween( elem, options, prop, end, easing ) { + return new Tween.prototype.init( elem, options, prop, end, easing ); +} +jQuery.Tween = Tween; + +Tween.prototype = { + constructor: Tween, + init: function( elem, options, prop, end, easing, unit ) { + this.elem = elem; + this.prop = prop; + this.easing = easing || "swing"; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + }, + cur: function() { + var hooks = Tween.propHooks[ this.prop ]; + + return hooks && hooks.get ? + hooks.get( this ) : + Tween.propHooks._default.get( this ); + }, + run: function( percent ) { + var eased, + hooks = Tween.propHooks[ this.prop ]; + + if ( this.options.duration ) { + this.pos = eased = jQuery.easing[ this.easing ]( + percent, this.options.duration * percent, 0, 1, this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = ( this.end - this.start ) * eased + this.start; + + if ( this.options.step ) { + this.options.step.call( this.elem, this.now, this ); + } + + if ( hooks && hooks.set ) { + hooks.set( this ); + } else { + Tween.propHooks._default.set( this ); + } + return this; + } +}; + +Tween.prototype.init.prototype = Tween.prototype; + +Tween.propHooks = { + _default: { + get: function( tween ) { + var result; + + if ( tween.elem[ tween.prop ] != null && + (!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) { + return tween.elem[ tween.prop ]; + } + + // passing any value as a 4th parameter to .css will automatically + // attempt a parseFloat and fallback to a string if the parse fails + // so, simple values such as "10px" are parsed to Float. + // complex values such as "rotate(1rad)" are returned as is. + result = jQuery.css( tween.elem, tween.prop, false, "" ); + // Empty strings, null, undefined and "auto" are converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set: function( tween ) { + // use step hook for back compat - use cssHook if its there - use .style if its + // available and use plain properties where available + if ( jQuery.fx.step[ tween.prop ] ) { + jQuery.fx.step[ tween.prop ]( tween ); + } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); + } else { + tween.elem[ tween.prop ] = tween.now; + } + } + } +}; + +// Remove in 2.0 - this supports IE8's panic based approach +// to setting things on disconnected nodes + +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function( tween ) { + if ( tween.elem.nodeType && tween.elem.parentNode ) { + tween.elem[ tween.prop ] = tween.now; + } + } +}; + +jQuery.each([ "toggle", "show", "hide" ], function( i, name ) { + var cssFn = jQuery.fn[ name ]; + jQuery.fn[ name ] = function( speed, easing, callback ) { + return speed == null || typeof speed === "boolean" || + // special check for .toggle( handler, handler, ... ) + ( !i && jQuery.isFunction( speed ) && jQuery.isFunction( easing ) ) ? + cssFn.apply( this, arguments ) : + this.animate( genFx( name, true ), speed, easing, callback ); + }; +}); + +jQuery.fn.extend({ + fadeTo: function( speed, to, easing, callback ) { + + // show any hidden elements after setting opacity to 0 + return this.filter( isHidden ).css( "opacity", 0 ).show() + + // animate to the value specified + .end().animate({ opacity: to }, speed, easing, callback ); + }, + animate: function( prop, speed, easing, callback ) { + var empty = jQuery.isEmptyObject( prop ), + optall = jQuery.speed( speed, easing, callback ), + doAnimation = function() { + // Operate on a copy of prop so per-property easing won't be lost + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); + + // Empty animations resolve immediately + if ( empty ) { + anim.stop( true ); + } + }; + + return empty || optall.queue === false ? + this.each( doAnimation ) : + this.queue( optall.queue, doAnimation ); + }, + stop: function( type, clearQueue, gotoEnd ) { + var stopQueue = function( hooks ) { + var stop = hooks.stop; + delete hooks.stop; + stop( gotoEnd ); + }; + + if ( typeof type !== "string" ) { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if ( clearQueue && type !== false ) { + this.queue( type || "fx", [] ); + } + + return this.each(function() { + var dequeue = true, + index = type != null && type + "queueHooks", + timers = jQuery.timers, + data = jQuery._data( this ); + + if ( index ) { + if ( data[ index ] && data[ index ].stop ) { + stopQueue( data[ index ] ); + } + } else { + for ( index in data ) { + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { + stopQueue( data[ index ] ); + } + } + } + + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) { + timers[ index ].anim.stop( gotoEnd ); + dequeue = false; + timers.splice( index, 1 ); + } + } + + // start the next in the queue if the last step wasn't forced + // timers currently will call their complete callbacks, which will dequeue + // but only if they were gotoEnd + if ( dequeue || !gotoEnd ) { + jQuery.dequeue( this, type ); + } + }); + } +}); + +// Generate parameters to create a standard animation +function genFx( type, includeWidth ) { + var which, + attrs = { height: type }, + i = 0; + + // if we include width, step value is 1 to do all cssExpand values, + // if we don't include width, step value is 2 to skip over Left and Right + includeWidth = includeWidth? 1 : 0; + for( ; i < 4 ; i += 2 - includeWidth ) { + which = cssExpand[ i ]; + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; + } + + if ( includeWidth ) { + attrs.opacity = attrs.width = type; + } + + return attrs; +} + +// Generate shortcuts for custom animations +jQuery.each({ + slideDown: genFx("show"), + slideUp: genFx("hide"), + slideToggle: genFx("toggle"), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } +}, function( name, props ) { + jQuery.fn[ name ] = function( speed, easing, callback ) { + return this.animate( props, speed, easing, callback ); + }; +}); + +jQuery.speed = function( speed, easing, fn ) { + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { + complete: fn || !fn && easing || + jQuery.isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing + }; + + opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration : + opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default; + + // normalize opt.queue - true/undefined/null -> "fx" + if ( opt.queue == null || opt.queue === true ) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if ( jQuery.isFunction( opt.old ) ) { + opt.old.call( this ); + } + + if ( opt.queue ) { + jQuery.dequeue( this, opt.queue ); + } + }; + + return opt; +}; + +jQuery.easing = { + linear: function( p ) { + return p; + }, + swing: function( p ) { + return 0.5 - Math.cos( p*Math.PI ) / 2; + } +}; + +jQuery.timers = []; +jQuery.fx = Tween.prototype.init; +jQuery.fx.tick = function() { + var timer, + timers = jQuery.timers, + i = 0; + + fxNow = jQuery.now(); + + for ( ; i < timers.length; i++ ) { + timer = timers[ i ]; + // Checks the timer has not already been removed + if ( !timer() && timers[ i ] === timer ) { + timers.splice( i--, 1 ); + } + } + + if ( !timers.length ) { + jQuery.fx.stop(); + } + fxNow = undefined; +}; + +jQuery.fx.timer = function( timer ) { + if ( timer() && jQuery.timers.push( timer ) && !timerId ) { + timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval ); + } +}; + +jQuery.fx.interval = 13; + +jQuery.fx.stop = function() { + clearInterval( timerId ); + timerId = null; +}; + +jQuery.fx.speeds = { + slow: 600, + fast: 200, + // Default speed + _default: 400 +}; + +// Back Compat <1.8 extension point +jQuery.fx.step = {}; + +if ( jQuery.expr && jQuery.expr.filters ) { + jQuery.expr.filters.animated = function( elem ) { + return jQuery.grep(jQuery.timers, function( fn ) { + return elem === fn.elem; + }).length; + }; +} +var rroot = /^(?:body|html)$/i; + +jQuery.fn.offset = function( options ) { + if ( arguments.length ) { + return options === undefined ? + this : + this.each(function( i ) { + jQuery.offset.setOffset( this, options, i ); + }); + } + + var docElem, body, win, clientTop, clientLeft, scrollTop, scrollLeft, + box = { top: 0, left: 0 }, + elem = this[ 0 ], + doc = elem && elem.ownerDocument; + + if ( !doc ) { + return; + } + + if ( (body = doc.body) === elem ) { + return jQuery.offset.bodyOffset( elem ); + } + + docElem = doc.documentElement; + + // Make sure it's not a disconnected DOM node + if ( !jQuery.contains( docElem, elem ) ) { + return box; + } + + // If we don't have gBCR, just use 0,0 rather than error + // BlackBerry 5, iOS 3 (original iPhone) + if ( typeof elem.getBoundingClientRect !== "undefined" ) { + box = elem.getBoundingClientRect(); + } + win = getWindow( doc ); + clientTop = docElem.clientTop || body.clientTop || 0; + clientLeft = docElem.clientLeft || body.clientLeft || 0; + scrollTop = win.pageYOffset || docElem.scrollTop; + scrollLeft = win.pageXOffset || docElem.scrollLeft; + return { + top: box.top + scrollTop - clientTop, + left: box.left + scrollLeft - clientLeft + }; +}; + +jQuery.offset = { + + bodyOffset: function( body ) { + var top = body.offsetTop, + left = body.offsetLeft; + + if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) { + top += parseFloat( jQuery.css(body, "marginTop") ) || 0; + left += parseFloat( jQuery.css(body, "marginLeft") ) || 0; + } + + return { top: top, left: left }; + }, + + setOffset: function( elem, options, i ) { + var position = jQuery.css( elem, "position" ); + + // set position first, in-case top/left are set even on static elem + if ( position === "static" ) { + elem.style.position = "relative"; + } + + var curElem = jQuery( elem ), + curOffset = curElem.offset(), + curCSSTop = jQuery.css( elem, "top" ), + curCSSLeft = jQuery.css( elem, "left" ), + calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1, + props = {}, curPosition = {}, curTop, curLeft; + + // need to be able to calculate position if either top or left is auto and position is either absolute or fixed + if ( calculatePosition ) { + curPosition = curElem.position(); + curTop = curPosition.top; + curLeft = curPosition.left; + } else { + curTop = parseFloat( curCSSTop ) || 0; + curLeft = parseFloat( curCSSLeft ) || 0; + } + + if ( jQuery.isFunction( options ) ) { + options = options.call( elem, i, curOffset ); + } + + if ( options.top != null ) { + props.top = ( options.top - curOffset.top ) + curTop; + } + if ( options.left != null ) { + props.left = ( options.left - curOffset.left ) + curLeft; + } + + if ( "using" in options ) { + options.using.call( elem, props ); + } else { + curElem.css( props ); + } + } +}; + + +jQuery.fn.extend({ + + position: function() { + if ( !this[0] ) { + return; + } + + var elem = this[0], + + // Get *real* offsetParent + offsetParent = this.offsetParent(), + + // Get correct offsets + offset = this.offset(), + parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset(); + + // Subtract element margins + // note: when an element has margin: auto the offsetLeft and marginLeft + // are the same in Safari causing offset.left to incorrectly be 0 + offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0; + offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0; + + // Add offsetParent borders + parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0; + parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0; + + // Subtract the two offsets + return { + top: offset.top - parentOffset.top, + left: offset.left - parentOffset.left + }; + }, + + offsetParent: function() { + return this.map(function() { + var offsetParent = this.offsetParent || document.body; + while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) { + offsetParent = offsetParent.offsetParent; + } + return offsetParent || document.body; + }); + } +}); + + +// Create scrollLeft and scrollTop methods +jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) { + var top = /Y/.test( prop ); + + jQuery.fn[ method ] = function( val ) { + return jQuery.access( this, function( elem, method, val ) { + var win = getWindow( elem ); + + if ( val === undefined ) { + return win ? (prop in win) ? win[ prop ] : + win.document.documentElement[ method ] : + elem[ method ]; + } + + if ( win ) { + win.scrollTo( + !top ? val : jQuery( win ).scrollLeft(), + top ? val : jQuery( win ).scrollTop() + ); + + } else { + elem[ method ] = val; + } + }, method, val, arguments.length, null ); + }; +}); + +function getWindow( elem ) { + return jQuery.isWindow( elem ) ? + elem : + elem.nodeType === 9 ? + elem.defaultView || elem.parentWindow : + false; +} +// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods +jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { + jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) { + // margin is only for outerHeight, outerWidth + jQuery.fn[ funcName ] = function( margin, value ) { + var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), + extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); + + return jQuery.access( this, function( elem, type, value ) { + var doc; + + if ( jQuery.isWindow( elem ) ) { + // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there + // isn't a whole lot we can do. See pull request at this URL for discussion: + // https://github.com/jquery/jquery/pull/764 + return elem.document.documentElement[ "client" + name ]; + } + + // Get document width or height + if ( elem.nodeType === 9 ) { + doc = elem.documentElement; + + // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest + // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it. + return Math.max( + elem.body[ "scroll" + name ], doc[ "scroll" + name ], + elem.body[ "offset" + name ], doc[ "offset" + name ], + doc[ "client" + name ] + ); + } + + return value === undefined ? + // Get width or height on the element, requesting but not forcing parseFloat + jQuery.css( elem, type, value, extra ) : + + // Set width or height on the element + jQuery.style( elem, type, value, extra ); + }, type, chainable ? margin : undefined, chainable, null ); + }; + }); +}); +// Expose jQuery to the global object +window.jQuery = window.$ = jQuery; + +// Expose jQuery as an AMD module, but only for AMD loaders that +// understand the issues with loading multiple versions of jQuery +// in a page that all might call define(). The loader will indicate +// they have special allowances for multiple jQuery versions by +// specifying define.amd.jQuery = true. Register as a named module, +// since jQuery can be concatenated with other files that may use define, +// but not use a proper concatenation script that understands anonymous +// AMD modules. A named AMD is safest and most robust way to register. +// Lowercase jquery is used because AMD module names are derived from +// file names, and jQuery is normally delivered in a lowercase file name. +// Do this after creating the global so that if an AMD module wants to call +// noConflict to hide this version of jQuery, it will work. +if ( typeof define === "function" && define.amd && define.amd.jQuery ) { + define( "jquery", [], function () { return jQuery; } ); +} + +})( window ); \ No newline at end of file diff --git a/src/scripts/libs/jquery.maskedinput.js b/src/scripts/libs/jquery.maskedinput.js new file mode 100644 index 0000000..40bb3c9 --- /dev/null +++ b/src/scripts/libs/jquery.maskedinput.js @@ -0,0 +1,290 @@ +/* + Masked Input plugin for jQuery + Copyright (c) 2007-2011 Josh Bush (digitalbush.com) + Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) + Version: 1.3 +*/ +(function($) { + var pasteEventName = ($.browser.msie ? 'paste' : 'input') + ".mask"; + var iPhone = (window.orientation != undefined); + + $.mask = { + //Predefined character definitions + definitions: { + '9': "[0-9]", + 'a': "[A-Za-z]", + '*': "[A-Za-z0-9]" + }, + dataName:"rawMaskFn" + }; + + $.fn.extend({ + //Helper Function for Caret positioning + caret: function(begin, end) { + if (this.length == 0) return; + if (typeof begin == 'number') { + end = (typeof end == 'number') ? end : begin; + return this.each(function() { + if (this.setSelectionRange) { + this.setSelectionRange(begin, end); + } else if (this.createTextRange) { + var range = this.createTextRange(); + range.collapse(true); + range.moveEnd('character', end); + range.moveStart('character', begin); + range.select(); + } + }); + } else { + if (this[0].setSelectionRange) { + begin = this[0].selectionStart; + end = this[0].selectionEnd; + } else if (document.selection && document.selection.createRange) { + var range = document.selection.createRange(); + begin = 0 - range.duplicate().moveStart('character', -100000); + end = begin + range.text.length; + } + return { begin: begin, end: end }; + } + }, + unmask: function() { return this.trigger("unmask"); }, + isMaskValid: function(){ + return $(this).data('mask-isvalid'); + }, + mask: function(mask, settings) { + if (!mask && this.length > 0) { + var input = $(this[0]); + return input.data($.mask.dataName)(); + } + settings = $.extend({ + placeholder: "_", + completed: null + }, settings); + + var defs = $.mask.definitions; + var tests = []; + var partialPosition = mask.length; + var firstNonMaskPos = null; + var len = mask.length; + + $.each(mask.split(""), function(i, c) { + if (c == '?') { + len--; + partialPosition = i; + } else if (defs[c]) { + tests.push(new RegExp(defs[c])); + if(firstNonMaskPos==null) + firstNonMaskPos = tests.length - 1; + } else { + tests.push(null); + } + }); + + return this.trigger("unmask").each(function() { + var input = $(this); + var buffer = $.map(mask.split(""), function(c, i) { if (c != '?') return defs[c] ? settings.placeholder : c }); + var focusText = input.val(); + + function seekNext(pos) { + while (++pos <= len && !tests[pos]); + return pos; + }; + function seekPrev(pos) { + while (--pos >= 0 && !tests[pos]); + return pos; + }; + + function shiftL(begin,end) { + if(begin<0) + return; + for (var i = begin,j = seekNext(end); i < len; i++) { + if (tests[i]) { + if (j < len && tests[i].test(buffer[j])) { + buffer[i] = buffer[j]; + buffer[j] = settings.placeholder; + } else + break; + j = seekNext(j); + } + } + writeBuffer(); + input.caret(Math.max(firstNonMaskPos, begin)); + }; + + function shiftR(pos) { + for (var i = pos, c = settings.placeholder; i < len; i++) { + if (tests[i]) { + var j = seekNext(i); + var t = buffer[i]; + buffer[i] = c; + if (j < len && tests[j].test(t)) + c = t; + else + break; + } + } + }; + + function keydownEvent(e) { + var k=e.which; + + //backspace, delete, and escape get special treatment + if(k == 8 || k == 46 || (iPhone && k == 127)){ + var pos = input.caret(), + begin = pos.begin, + end = pos.end; + + if(end-begin==0){ + begin=k!=46?seekPrev(begin):(end=seekNext(begin-1)); + end=k==46?seekNext(end):end; + } + clearBuffer(begin, end); + shiftL(begin,end-1); + isValid(); //twarogowski + + return false; + } else if (k == 27) {//escape + input.val(focusText); + input.caret(0, checkVal()); + return false; + } + }; + + function keypressEvent(e) { + var k = e.which, + pos = input.caret(); + if (e.ctrlKey || e.altKey || e.metaKey || k<32) {//Ignore + return true; + } else if (k) { + if(pos.end-pos.begin!=0){ + clearBuffer(pos.begin, pos.end); + shiftL(pos.begin, pos.end-1); + isValid(); //twarogowski + } + + var p = seekNext(pos.begin - 1); + if (p < len) { + var c = String.fromCharCode(k); + if (tests[p].test(c)) { + shiftR(p); + buffer[p] = c; + writeBuffer(); + var next = seekNext(p); + input.caret(next); + isValid(); //twarogowski + if (settings.completed && next >= len) + settings.completed.call(input); + } + } + return false; + } + }; + + function clearBuffer(start, end) { + for (var i = start; i < end && i < len; i++) { + if (tests[i]) + buffer[i] = settings.placeholder; + } + }; + + function writeBuffer() { return input.val(buffer.join('')).val(); }; + + function isValid(){ + var test = input.val(); + var lastMatch = -1; + for (var i = 0, pos = 0; i < len; i++) { + if (tests[i]) { + buffer[i] = settings.placeholder; + while (pos++ < test.length) { + var c = test.charAt(pos - 1); + if (tests[i].test(c)) { + buffer[i] = c; + lastMatch = i; + break; + } + } + if (pos > test.length) + break; + } else if (buffer[i] == test.charAt(pos) && i!=partialPosition) { + pos++; + lastMatch = i; + } + } + var valid = (lastMatch + 1 >= partialPosition); + input.data('mask-isvalid',valid); + return valid; + } + + function checkVal(allow) { + //try to place characters where they belong + var test = input.val(); + var lastMatch = -1; + for (var i = 0, pos = 0; i < len; i++) { + if (tests[i]) { + buffer[i] = settings.placeholder; + while (pos++ < test.length) { + var c = test.charAt(pos - 1); + if (tests[i].test(c)) { + buffer[i] = c; + lastMatch = i; + break; + } + } + if (pos > test.length) + break; + } else if (buffer[i] == test.charAt(pos) && i!=partialPosition) { + pos++; + lastMatch = i; + } + } + if (!allow && lastMatch + 1 < partialPosition) { + input.val(""); + clearBuffer(0, len); + } else if (allow || lastMatch + 1 >= partialPosition) { + writeBuffer(); + if (!allow) input.val(input.val().substring(0, lastMatch + 1)); + } + return (partialPosition ? i : firstNonMaskPos); + }; + + input.data($.mask.dataName,function(){ + return $.map(buffer, function(c, i) { + return tests[i]&&c!=settings.placeholder ? c : null; + }).join(''); + }) + + if (!input.attr("readonly")) + input + .one("unmask", function() { + input + .unbind(".mask") + .removeData($.mask.dataName); + }) + .bind("focus.mask", function() { + focusText = input.val(); + var pos = checkVal(); + writeBuffer(); + var moveCaret=function(){ + if (pos == mask.length) + input.caret(0, pos); + else + input.caret(pos); + }; + ($.browser.msie ? moveCaret:function(){setTimeout(moveCaret,0)})(); + }) + .bind("blur.mask", function() { + checkVal(); + if (input.val() != focusText) + input.change(); + }) + .bind("keydown.mask", keydownEvent) + .bind("keypress.mask", keypressEvent) + .bind(pasteEventName, function() { + setTimeout(function() { input.caret(checkVal(true)); }, 0); + }); + + checkVal(); //Perform initial check for existing values + }); + } + }); +})(jQuery); \ No newline at end of file diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee new file mode 100644 index 0000000..9ee1471 --- /dev/null +++ b/src/scripts/mask.coffee @@ -0,0 +1,27 @@ +app.directive 'uiMask', [-> + link = ($scope, element, attrs, controller) -> + # We override the render method to run the jQuery mask plugin + controller.$render = -> + value = controller.$viewValue or '' + + element.val value + element.mask $scope.$eval attrs.uiMask + + # Add a parser that extracts the masked value into the model but only if the mask is valid + controller.$parsers.push (value) -> + #the second check (or) is only needed due to the fact that element.isMaskValid() will keep returning undefined + #until there was at least one key event + isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 + + controller.$setValidity 'mask', isValid + + if isValid then value else undefined + + # When keyup, update the view value + element.bind 'keyup', -> + $scope.$apply -> + controller.$setViewValue element.mask() + + link: link + require: 'ngModel' +] \ No newline at end of file From cb84e04b67bbf15bc0a210e6b19c62790d6754cf Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Tue, 20 Nov 2012 18:33:28 -0600 Subject: [PATCH 02/15] removed dataName data attribute --- src/scripts/inputMask.coffee | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/scripts/inputMask.coffee b/src/scripts/inputMask.coffee index 9981466..1f109b4 100644 --- a/src/scripts/inputMask.coffee +++ b/src/scripts/inputMask.coffee @@ -21,9 +21,9 @@ a: '[A-Za-z]' '*': '[A-Za-z0-9]' - dataName = 'rawMaskFn' maskIsValid = false placeholder = '_' + setMaskBuffer = null myCaret = (element, begin, end) -> el = element[0] @@ -69,10 +69,10 @@ element = this el = element[0] - if not mask and element.length > 0 + return if not mask and element.length > 0 input = $(el) - return input.data(dataName)() + setMaskBuffer() tests = [] partialPosition = mask.length @@ -198,7 +198,7 @@ i = start while i < end and i < len - buffer[i] = placeholder if tests[i] + buffer[i] = placeholder if tests[i] i++ writeBuffer = -> @@ -276,14 +276,15 @@ focusText = input.val() - input.data dataName, -> + setMaskBuffer = -> $.map(buffer, (c, i) -> (if tests[i] and c isnt placeholder then c else null) ).join '' unless input.attr('readonly') input.one('unmask', -> - input.unbind('.mask').removeData dataName + input.unbind('.mask') + setMaskBuffer = null ).bind('focus.mask', -> focusText = input.val() pos = checkVal() From c636f5682443ee8e46393574aed138b3c590a32d Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Tue, 20 Nov 2012 23:14:05 -0600 Subject: [PATCH 03/15] removed input --- src/scripts/inputMask.coffee | 101 ++++++++++++++++++++--------------- src/scripts/mask.coffee | 2 + 2 files changed, 60 insertions(+), 43 deletions(-) diff --git a/src/scripts/inputMask.coffee b/src/scripts/inputMask.coffee index 1f109b4..be10a11 100644 --- a/src/scripts/inputMask.coffee +++ b/src/scripts/inputMask.coffee @@ -1,17 +1,19 @@ (($) -> - ua = window.navigator.userAgent.toLowerCase() + isIE = (-> + ua = window.navigator.userAgent.toLowerCase() - match = /(chrome)[ \/]([\w.]+)/.exec(ua) or - /(webkit)[ \/]([\w.]+)/.exec(ua) or - /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or - /(msie) ([\w.]+)/.exec(ua) or - ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or - [] + match = /(chrome)[ \/]([\w.]+)/.exec(ua) or + /(webkit)[ \/]([\w.]+)/.exec(ua) or + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or + /(msie) ([\w.]+)/.exec(ua) or + ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or + [] - browser = match[1] or '' - version = match[2] or '0' + browser = match[1] or '' + version = match[2] or '0' - isIE = browser is 'msie' + browser is 'msie' + )() pasteEventName = (if isIE then 'paste' else 'input') + '.mask' iPhone = not angular.isUndefined window.orientation @@ -24,10 +26,10 @@ maskIsValid = false placeholder = '_' setMaskBuffer = null + element = null + el = null - myCaret = (element, begin, end) -> - el = element[0] - + myCaret = (begin, end) -> return if element.length is 0 if typeof begin is 'number' @@ -54,10 +56,14 @@ {begin, end} $.fn.extend + setElement: (elem) -> + element = elem + el = element[0] + console.log element, el #Helper Function for Caret positioning caret: (begin, end) -> - myCaret this, begin, end + myCaret begin, end unmask: -> @trigger 'unmask' @@ -66,11 +72,8 @@ maskIsValid mask: (mask) -> - element = this - el = element[0] - return if not mask and element.length > 0 - input = $(el) + #input = $(el) setMaskBuffer() @@ -86,7 +89,7 @@ else if definitions[c] tests.push new RegExp(definitions[c]) - firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null + firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null else tests.push null @@ -120,7 +123,8 @@ i++ writeBuffer() - input.caret Math.max(firstNonMaskPos, begin) + #input.caret Math.max(firstNonMaskPos, begin) + myCaret Math.max(firstNonMaskPos, begin) shiftR = (pos) -> i = pos @@ -144,7 +148,8 @@ #backspace, delete, and escape get special treatment if k is 8 or k is 46 or (iPhone and k is 127) - pos = input.caret() + #pos = input.caret() + pos = myCaret() begin = pos.begin end = pos.end @@ -158,14 +163,17 @@ false else if k is 27 #escape - input.val focusText - input.caret 0, checkVal() + #input.val focusText + element.val focusText + #input.caret 0, checkVal() + myCaret 0, checkVal() false keypressEvent = (e) -> k = e.which - pos = input.caret() + #pos = input.caret() + pos = myCaret() if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore true @@ -189,7 +197,8 @@ next = seekNext(p) - input.caret next + #input.caret next + myCaret next isValid() #twarogowski false @@ -202,10 +211,12 @@ i++ writeBuffer = -> - input.val(buffer.join('')).val() + #input.val(buffer.join('')).val() + element.val(buffer.join('')).val() isValid = -> - test = input.val() + #test = input.val() + test = element.val() lastMatch = -1 i = 0 pos = 0 @@ -233,9 +244,9 @@ maskIsValid checkVal = (allow) -> - #try to place characters where they belong - test = input.val() + #test = input.val() + test = element.val() lastMatch = -1 i = 0 pos = 0 @@ -260,42 +271,46 @@ i++ if not allow and lastMatch + 1 < partialPosition - input.val '' + #input.val '' + element.val '' clearBuffer 0, len else if allow or lastMatch + 1 >= partialPosition writeBuffer() - input.val input.val().substring(0, lastMatch + 1) unless allow + #input.val input.val().substring(0, lastMatch + 1) unless allow + element.val element.val().substring(0, lastMatch + 1) unless allow (if partialPosition then i else firstNonMaskPos) - input = $(this) + #input = $(this) buffer = $.map(mask.split(''), (c, i) -> (if definitions[c] then placeholder else c) if c isnt '?' ) - focusText = input.val() + #focusText = input.val() + focusText = element.val() setMaskBuffer = -> $.map(buffer, (c, i) -> (if tests[i] and c isnt placeholder then c else null) ).join '' - unless input.attr('readonly') - input.one('unmask', -> - input.unbind('.mask') - setMaskBuffer = null - ).bind('focus.mask', -> - focusText = input.val() + unless element.attr('readonly') + # input.one('unmask', -> + # input.unbind('.mask') + # setMaskBuffer = null + + element.bind('focus.mask', -> + focusText = element.val() pos = checkVal() writeBuffer() moveCaret = -> if pos is mask.length - input.caret 0, pos + myCaret 0, pos else - input.caret pos + myCaret pos ((if isIE then moveCaret else -> setTimeout moveCaret, 0 @@ -303,10 +318,10 @@ ).bind('blur.mask', -> checkVal() - input.change() if input.val() isnt focusText + #input.change() if input.val() isnt focusText ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> setTimeout (-> - input.caret checkVal(true) + myCaret checkVal(true) ), 0 checkVal() #Perform initial check for existing values diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee index 9ee1471..b2689ec 100644 --- a/src/scripts/mask.coffee +++ b/src/scripts/mask.coffee @@ -1,5 +1,7 @@ app.directive 'uiMask', [-> link = ($scope, element, attrs, controller) -> + $.fn.setElement element + # We override the render method to run the jQuery mask plugin controller.$render = -> value = controller.$viewValue or '' From 597937a2ed2105a56b6c8a101bd0bf8929466bd9 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Tue, 20 Nov 2012 23:38:03 -0600 Subject: [PATCH 04/15] cleanup --- src/scripts/inputMask.coffee | 31 +------------------------------ 1 file changed, 1 insertion(+), 30 deletions(-) diff --git a/src/scripts/inputMask.coffee b/src/scripts/inputMask.coffee index be10a11..fcb5425 100644 --- a/src/scripts/inputMask.coffee +++ b/src/scripts/inputMask.coffee @@ -59,22 +59,12 @@ setElement: (elem) -> element = elem el = element[0] - console.log element, el - - #Helper Function for Caret positioning - caret: (begin, end) -> - myCaret begin, end - - unmask: -> - @trigger 'unmask' isMaskValid: -> maskIsValid mask: (mask) -> return if not mask and element.length > 0 - #input = $(el) - setMaskBuffer() tests = [] @@ -93,7 +83,7 @@ else tests.push null - @trigger('unmask').each -> + angular.forEach element, -> seekNext = (pos) -> continue while ++pos <= len and not tests[pos] @@ -123,7 +113,6 @@ i++ writeBuffer() - #input.caret Math.max(firstNonMaskPos, begin) myCaret Math.max(firstNonMaskPos, begin) shiftR = (pos) -> @@ -148,7 +137,6 @@ #backspace, delete, and escape get special treatment if k is 8 or k is 46 or (iPhone and k is 127) - #pos = input.caret() pos = myCaret() begin = pos.begin end = pos.end @@ -163,16 +151,13 @@ false else if k is 27 #escape - #input.val focusText element.val focusText - #input.caret 0, checkVal() myCaret 0, checkVal() false keypressEvent = (e) -> k = e.which - #pos = input.caret() pos = myCaret() if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore @@ -197,7 +182,6 @@ next = seekNext(p) - #input.caret next myCaret next isValid() #twarogowski @@ -211,11 +195,9 @@ i++ writeBuffer = -> - #input.val(buffer.join('')).val() element.val(buffer.join('')).val() isValid = -> - #test = input.val() test = element.val() lastMatch = -1 i = 0 @@ -245,7 +227,6 @@ checkVal = (allow) -> #try to place characters where they belong - #test = input.val() test = element.val() lastMatch = -1 i = 0 @@ -271,23 +252,18 @@ i++ if not allow and lastMatch + 1 < partialPosition - #input.val '' element.val '' clearBuffer 0, len else if allow or lastMatch + 1 >= partialPosition writeBuffer() - #input.val input.val().substring(0, lastMatch + 1) unless allow element.val element.val().substring(0, lastMatch + 1) unless allow (if partialPosition then i else firstNonMaskPos) - #input = $(this) - buffer = $.map(mask.split(''), (c, i) -> (if definitions[c] then placeholder else c) if c isnt '?' ) - #focusText = input.val() focusText = element.val() setMaskBuffer = -> @@ -296,10 +272,6 @@ ).join '' unless element.attr('readonly') - # input.one('unmask', -> - # input.unbind('.mask') - # setMaskBuffer = null - element.bind('focus.mask', -> focusText = element.val() pos = checkVal() @@ -318,7 +290,6 @@ ).bind('blur.mask', -> checkVal() - #input.change() if input.val() isnt focusText ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> setTimeout (-> myCaret checkVal(true) From e1148ef46dff38339b8b79e8a109b23b073ee37a Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Wed, 21 Nov 2012 16:01:57 -0600 Subject: [PATCH 05/15] removed map function --- src/scripts/inputMask.coffee | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/src/scripts/inputMask.coffee b/src/scripts/inputMask.coffee index fcb5425..6e8072c 100644 --- a/src/scripts/inputMask.coffee +++ b/src/scripts/inputMask.coffee @@ -24,7 +24,7 @@ '*': '[A-Za-z0-9]' maskIsValid = false - placeholder = '_' + placeholder = 'z' setMaskBuffer = null element = null el = null @@ -260,16 +260,27 @@ (if partialPosition then i else firstNonMaskPos) - buffer = $.map(mask.split(''), (c, i) -> - (if definitions[c] then placeholder else c) if c isnt '?' - ) + # buffer = $.map(mask.split(''), (c, i) -> + # (if definitions[c] then placeholder else c) if c isnt '?' + # ) + + buffer = [] + + angular.forEach mask.split(''), (c, i) -> + if c isnt '?' + if definitions[c] + buffer.push placeholder + else + buffer.push c focusText = element.val() setMaskBuffer = -> - $.map(buffer, (c, i) -> - (if tests[i] and c isnt placeholder then c else null) - ).join '' + # $.map(buffer, (c, i) -> + # (if tests[i] and c isnt placeholder then c else null) + # ).join '' + + buffer.join '' unless element.attr('readonly') element.bind('focus.mask', -> From a387634178681a25bf0f308122e903ff2978a347 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Wed, 21 Nov 2012 17:05:08 -0600 Subject: [PATCH 06/15] merged inputMask contents to mask --- grunt.js | 9 + src/index.html | 2 +- src/scripts/inputMask.coffee | 486 +++++++++++++++++------------------ src/scripts/mask.coffee | 313 +++++++++++++++++++++- 4 files changed, 562 insertions(+), 248 deletions(-) diff --git a/grunt.js b/grunt.js index e22af08..4e1134e 100644 --- a/grunt.js +++ b/grunt.js @@ -55,6 +55,11 @@ module.exports = function (grunt) { files: { './dist/': './staging/**/*.js' } + }, + views: { + files: { + './dist/': './src/**/*.html' + } } }, @@ -73,6 +78,10 @@ module.exports = function (grunt) { coffee: { files: './src/scripts/**/*.coffee', tasks: 'coffeeLint coffee lint copy:scripts' + }, + views: { + files: './src/**/*.html', + tasks: 'copy:views' } }, diff --git a/src/index.html b/src/index.html index ddaced9..e2165e2 100644 --- a/src/index.html +++ b/src/index.html @@ -8,7 +8,7 @@ - + diff --git a/src/scripts/inputMask.coffee b/src/scripts/inputMask.coffee index 6e8072c..8f32bf1 100644 --- a/src/scripts/inputMask.coffee +++ b/src/scripts/inputMask.coffee @@ -1,310 +1,310 @@ (($) -> - isIE = (-> - ua = window.navigator.userAgent.toLowerCase() - - match = /(chrome)[ \/]([\w.]+)/.exec(ua) or - /(webkit)[ \/]([\w.]+)/.exec(ua) or - /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or - /(msie) ([\w.]+)/.exec(ua) or - ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or - [] - - browser = match[1] or '' - version = match[2] or '0' - - browser is 'msie' - )() - - pasteEventName = (if isIE then 'paste' else 'input') + '.mask' - iPhone = not angular.isUndefined window.orientation - - definitions = - 9: '[0-9]' - a: '[A-Za-z]' - '*': '[A-Za-z0-9]' - - maskIsValid = false - placeholder = 'z' - setMaskBuffer = null - element = null - el = null - - myCaret = (begin, end) -> - return if element.length is 0 - - if typeof begin is 'number' - end = (if (typeof end is 'number') then end else begin) - - if el.setSelectionRange - el.setSelectionRange begin, end - else if el.createTextRange - range = el.createTextRange() - - range.collapse true - range.moveEnd 'character', end - range.moveStart 'character', begin - range.select() - else - if el.setSelectionRange - begin = el.selectionStart - end = el.selectionEnd - else if document.selection and document.selection.createRange - range = document.selection.createRange() - begin = 0 - range.duplicate().moveStart('character', -100000) - end = begin + range.text.length - - {begin, end} + # isIE = (-> + # ua = window.navigator.userAgent.toLowerCase() + + # match = /(chrome)[ \/]([\w.]+)/.exec(ua) or + # /(webkit)[ \/]([\w.]+)/.exec(ua) or + # /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or + # /(msie) ([\w.]+)/.exec(ua) or + # ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or + # [] + + # browser = match[1] or '' + # version = match[2] or '0' + + # browser is 'msie' + # )() + + # pasteEventName = (if isIE then 'paste' else 'input') + '.mask' + # iPhone = not angular.isUndefined window.orientation + # placeholder = '_' + + # definitions = + # 9: '[0-9]' + # a: '[A-Za-z]' + # '*': '[A-Za-z0-9]' + + # maskIsValid = false + # setMaskBuffer = null + # element = null + # el = null + + # caret = (begin, end) -> + # return if element.length is 0 + + # if typeof begin is 'number' + # end = (if (typeof end is 'number') then end else begin) + + # if el.setSelectionRange + # el.setSelectionRange begin, end + # else if el.createTextRange + # range = el.createTextRange() + + # range.collapse true + # range.moveEnd 'character', end + # range.moveStart 'character', begin + # range.select() + # else + # if el.setSelectionRange + # begin = el.selectionStart + # end = el.selectionEnd + # else if document.selection and document.selection.createRange + # range = document.selection.createRange() + # begin = 0 - range.duplicate().moveStart('character', -100000) + # end = begin + range.text.length + + # {begin, end} $.fn.extend - setElement: (elem) -> - element = elem - el = element[0] + # setElement: (elem) -> + # element = elem + # el = element[0] - isMaskValid: -> - maskIsValid + # isMaskValid: -> + # maskIsValid - mask: (mask) -> - return if not mask and element.length > 0 - setMaskBuffer() + # mask: (mask) -> + # return if not mask and element.length > 0 + # setMaskBuffer() - tests = [] - partialPosition = mask.length - firstNonMaskPos = null - len = mask.length + # tests = [] + # partialPosition = mask.length + # firstNonMaskPos = null + # len = mask.length - angular.forEach mask.split(''), (c, i) -> - if c is '?' - len-- - partialPosition = i - else if definitions[c] - tests.push new RegExp(definitions[c]) + # angular.forEach mask.split(''), (c, i) -> + # if c is '?' + # len-- + # partialPosition = i + # else if definitions[c] + # tests.push new RegExp(definitions[c]) - firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null - else - tests.push null + # firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null + # else + # tests.push null - angular.forEach element, -> - seekNext = (pos) -> - continue while ++pos <= len and not tests[pos] + # angular.forEach element, -> + # seekNext = (pos) -> + # continue while ++pos <= len and not tests[pos] - pos + # pos - seekPrev = (pos) -> - continue while --pos >= 0 and not tests[pos] + # seekPrev = (pos) -> + # continue while --pos >= 0 and not tests[pos] - pos + # pos - shiftL = (begin, end) -> - return if begin < 0 + # shiftL = (begin, end) -> + # return if begin < 0 - i = begin - j = seekNext(end) + # i = begin + # j = seekNext(end) - while i < len - if tests[i] - if j < len and tests[i].test(buffer[j]) - buffer[i] = buffer[j] - buffer[j] = placeholder - else - break + # while i < len + # if tests[i] + # if j < len and tests[i].test(buffer[j]) + # buffer[i] = buffer[j] + # buffer[j] = placeholder + # else + # break - j = seekNext(j) + # j = seekNext(j) - i++ + # i++ - writeBuffer() - myCaret Math.max(firstNonMaskPos, begin) + # writeBuffer() + # caret Math.max(firstNonMaskPos, begin) - shiftR = (pos) -> - i = pos - c = placeholder + # shiftR = (pos) -> + # i = pos + # c = placeholder - while i < len - if tests[i] - j = seekNext(i) - t = buffer[i] - buffer[i] = c + # while i < len + # if tests[i] + # j = seekNext(i) + # t = buffer[i] + # buffer[i] = c - if j < len and tests[j].test(t) - c = t - else - break + # if j < len and tests[j].test(t) + # c = t + # else + # break - i++ + # i++ - keydownEvent = (e) -> - k = e.which + # keydownEvent = (e) -> + # k = e.which - #backspace, delete, and escape get special treatment - if k is 8 or k is 46 or (iPhone and k is 127) - pos = myCaret() - begin = pos.begin - end = pos.end + # #backspace, delete, and escape get special treatment + # if k is 8 or k is 46 or (iPhone and k is 127) + # pos = caret() + # begin = pos.begin + # end = pos.end - if end - begin is 0 - begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) - end = (if k is 46 then seekNext(end) else end) + # if end - begin is 0 + # begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) + # end = (if k is 46 then seekNext(end) else end) - clearBuffer begin, end - shiftL begin, end - 1 - isValid() #twarogowski + # clearBuffer begin, end + # shiftL begin, end - 1 + # isValid() #twarogowski - false - else if k is 27 #escape - element.val focusText - myCaret 0, checkVal() + # false + # else if k is 27 #escape + # element.val focusText + # caret 0, checkVal() - false + # false - keypressEvent = (e) -> - k = e.which - pos = myCaret() + # keypressEvent = (e) -> + # k = e.which + # pos = caret() - if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore - true - else if k - if pos.end - pos.begin isnt 0 - clearBuffer pos.begin, pos.end - shiftL pos.begin, pos.end - 1 - isValid() #twarogowski + # if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore + # true + # else if k + # if pos.end - pos.begin isnt 0 + # clearBuffer pos.begin, pos.end + # shiftL pos.begin, pos.end - 1 + # isValid() #twarogowski - p = seekNext(pos.begin - 1) + # p = seekNext(pos.begin - 1) - if p < len - c = String.fromCharCode(k) + # if p < len + # c = String.fromCharCode(k) - if tests[p].test(c) - shiftR p + # if tests[p].test(c) + # shiftR p - buffer[p] = c + # buffer[p] = c - writeBuffer() + # writeBuffer() - next = seekNext(p) + # next = seekNext(p) - myCaret next - isValid() #twarogowski + # caret next + # isValid() #twarogowski - false + # false - clearBuffer = (start, end) -> - i = start + # clearBuffer = (start, end) -> + # i = start - while i < end and i < len - buffer[i] = placeholder if tests[i] - i++ + # while i < end and i < len + # buffer[i] = placeholder if tests[i] + # i++ - writeBuffer = -> - element.val(buffer.join('')).val() + # writeBuffer = -> + # element.val(buffer.join('')).val() - isValid = -> - test = element.val() - lastMatch = -1 - i = 0 - pos = 0 + # isValid = -> + # test = element.val() + # lastMatch = -1 + # i = 0 + # pos = 0 - while i < len - if tests[i] - buffer[i] = placeholder + # while i < len + # if tests[i] + # buffer[i] = placeholder - while pos++ < test.length - c = test.charAt(pos - 1) + # while pos++ < test.length + # c = test.charAt(pos - 1) - if tests[i].test(c) - buffer[i] = c - lastMatch = i + # if tests[i].test(c) + # buffer[i] = c + # lastMatch = i - break + # break - break if pos > test.length - else if buffer[i] is test.charAt(pos) and i isnt partialPosition - pos++ - lastMatch = i + # break if pos > test.length + # else if buffer[i] is test.charAt(pos) and i isnt partialPosition + # pos++ + # lastMatch = i - i++ - maskIsValid = (lastMatch + 1 >= partialPosition) - maskIsValid + # i++ + # maskIsValid = (lastMatch + 1 >= partialPosition) + # maskIsValid - checkVal = (allow) -> - #try to place characters where they belong - test = element.val() - lastMatch = -1 - i = 0 - pos = 0 + # checkVal = (allow) -> + # #try to place characters where they belong + # test = element.val() + # lastMatch = -1 + # i = 0 + # pos = 0 - while i < len - if tests[i] - buffer[i] = placeholder + # while i < len + # if tests[i] + # buffer[i] = placeholder - while pos++ < test.length - c = test.charAt(pos - 1) + # while pos++ < test.length + # c = test.charAt(pos - 1) - if tests[i].test(c) - buffer[i] = c - lastMatch = i + # if tests[i].test(c) + # buffer[i] = c + # lastMatch = i - break + # break - break if pos > test.length - else if buffer[i] is test.charAt(pos) and i isnt partialPosition - pos++ - lastMatch = i - i++ + # break if pos > test.length + # else if buffer[i] is test.charAt(pos) and i isnt partialPosition + # pos++ + # lastMatch = i + # i++ - if not allow and lastMatch + 1 < partialPosition - element.val '' - clearBuffer 0, len - else if allow or lastMatch + 1 >= partialPosition - writeBuffer() - element.val element.val().substring(0, lastMatch + 1) unless allow + # if not allow and lastMatch + 1 < partialPosition + # element.val '' + # clearBuffer 0, len + # else if allow or lastMatch + 1 >= partialPosition + # writeBuffer() + # element.val element.val().substring(0, lastMatch + 1) unless allow - (if partialPosition then i else firstNonMaskPos) + # (if partialPosition then i else firstNonMaskPos) - # buffer = $.map(mask.split(''), (c, i) -> - # (if definitions[c] then placeholder else c) if c isnt '?' - # ) + # # buffer = $.map(mask.split(''), (c, i) -> + # # (if definitions[c] then placeholder else c) if c isnt '?' + # # ) - buffer = [] + # buffer = [] - angular.forEach mask.split(''), (c, i) -> - if c isnt '?' - if definitions[c] - buffer.push placeholder - else - buffer.push c + # angular.forEach mask.split(''), (c, i) -> + # if c isnt '?' + # if definitions[c] + # buffer.push placeholder + # else + # buffer.push c - focusText = element.val() + # focusText = element.val() - setMaskBuffer = -> - # $.map(buffer, (c, i) -> - # (if tests[i] and c isnt placeholder then c else null) - # ).join '' + # setMaskBuffer = -> + # # $.map(buffer, (c, i) -> + # # (if tests[i] and c isnt placeholder then c else null) + # # ).join '' - buffer.join '' + # buffer.join '' - unless element.attr('readonly') - element.bind('focus.mask', -> - focusText = element.val() - pos = checkVal() + # unless element.attr('readonly') + # element.bind('focus.mask', -> + # focusText = element.val() + # pos = checkVal() - writeBuffer() + # writeBuffer() - moveCaret = -> - if pos is mask.length - myCaret 0, pos - else - myCaret pos - - ((if isIE then moveCaret else -> - setTimeout moveCaret, 0 - ))() - - ).bind('blur.mask', -> - checkVal() - ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> - setTimeout (-> - myCaret checkVal(true) - ), 0 + # moveCaret = -> + # if pos is mask.length + # caret 0, pos + # else + # caret pos + + # ((if isIE then moveCaret else -> + # setTimeout moveCaret, 0 + # ))() + + # ).bind('blur.mask', -> + # checkVal() + # ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> + # setTimeout (-> + # caret checkVal(true) + # ), 0 - checkVal() #Perform initial check for existing values + # checkVal() #Perform initial check for existing values ) jQuery \ No newline at end of file diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee index b2689ec..78357b0 100644 --- a/src/scripts/mask.coffee +++ b/src/scripts/mask.coffee @@ -1,19 +1,324 @@ app.directive 'uiMask', [-> + isIE = (-> + ua = window.navigator.userAgent.toLowerCase() + + match = /(chrome)[ \/]([\w.]+)/.exec(ua) or + /(webkit)[ \/]([\w.]+)/.exec(ua) or + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or + /(msie) ([\w.]+)/.exec(ua) or + ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or + [] + + browser = match[1] or '' + version = match[2] or '0' + + browser is 'msie' + )() + + pasteEventName = (if isIE then 'paste' else 'input') + '.mask' + iPhone = not angular.isUndefined window.orientation + placeholder = '_' + + definitions = + 9: '[0-9]' + a: '[A-Za-z]' + '*': '[A-Za-z0-9]' + link = ($scope, element, attrs, controller) -> - $.fn.setElement element + isMaskValid = false + setMaskBuffer = null + el = element[0] + + caret = (begin, end) -> + return if element.length is 0 + + if typeof begin is 'number' + end = (if (typeof end is 'number') then end else begin) + + if el.setSelectionRange + el.setSelectionRange begin, end + else if el.createTextRange + range = el.createTextRange() + + range.collapse true + range.moveEnd 'character', end + range.moveStart 'character', begin + range.select() + else + if el.setSelectionRange + begin = el.selectionStart + end = el.selectionEnd + else if document.selection and document.selection.createRange + range = document.selection.createRange() + begin = 0 - range.duplicate().moveStart('character', -100000) + end = begin + range.text.length + + {begin, end} + + createMask = (mask) -> + return if not mask and element.length > 0 + setMaskBuffer() + + tests = [] + partialPosition = mask.length + firstNonMaskPos = null + len = mask.length + + angular.forEach mask.split(''), (c, i) -> + if c is '?' + len-- + partialPosition = i + else if definitions[c] + tests.push new RegExp(definitions[c]) + + firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null + else + tests.push null + + angular.forEach element, -> + seekNext = (pos) -> + continue while ++pos <= len and not tests[pos] + + pos + + seekPrev = (pos) -> + continue while --pos >= 0 and not tests[pos] + + pos + + shiftL = (begin, end) -> + return if begin < 0 + + i = begin + j = seekNext(end) + + while i < len + if tests[i] + if j < len and tests[i].test(buffer[j]) + buffer[i] = buffer[j] + buffer[j] = placeholder + else + break + + j = seekNext(j) + + i++ + + writeBuffer() + caret Math.max(firstNonMaskPos, begin) + + shiftR = (pos) -> + i = pos + c = placeholder + + while i < len + if tests[i] + j = seekNext(i) + t = buffer[i] + buffer[i] = c + + if j < len and tests[j].test(t) + c = t + else + break + + i++ + + keydownEvent = (e) -> + k = e.which + + #backspace, delete, and escape get special treatment + if k is 8 or k is 46 or (iPhone and k is 127) + pos = caret() + begin = pos.begin + end = pos.end + + if end - begin is 0 + begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) + end = (if k is 46 then seekNext(end) else end) + + clearBuffer begin, end + shiftL begin, end - 1 + isValid() #twarogowski + + false + else if k is 27 #escape + element.val focusText + caret 0, checkVal() + + false + + keypressEvent = (e) -> + k = e.which + pos = caret() + + if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore + true + else if k + if pos.end - pos.begin isnt 0 + clearBuffer pos.begin, pos.end + shiftL pos.begin, pos.end - 1 + isValid() #twarogowski + + p = seekNext(pos.begin - 1) + + if p < len + c = String.fromCharCode(k) + + if tests[p].test(c) + shiftR p + + buffer[p] = c + + writeBuffer() + + next = seekNext(p) + + caret next + isValid() #twarogowski + + false + + clearBuffer = (start, end) -> + i = start + + while i < end and i < len + buffer[i] = placeholder if tests[i] + i++ + + writeBuffer = -> + element.val(buffer.join('')).val() + + isValid = -> + test = element.val() + lastMatch = -1 + i = 0 + pos = 0 + + while i < len + if tests[i] + buffer[i] = placeholder + + while pos++ < test.length + c = test.charAt(pos - 1) + + if tests[i].test(c) + buffer[i] = c + lastMatch = i + + break + + break if pos > test.length + else if buffer[i] is test.charAt(pos) and i isnt partialPosition + pos++ + lastMatch = i + + i++ + maskIsValid = (lastMatch + 1 >= partialPosition) + maskIsValid + + checkVal = (allow) -> + #try to place characters where they belong + test = element.val() + lastMatch = -1 + i = 0 + pos = 0 + + while i < len + if tests[i] + buffer[i] = placeholder + + while pos++ < test.length + c = test.charAt(pos - 1) + + if tests[i].test(c) + buffer[i] = c + lastMatch = i + + break + + break if pos > test.length + else if buffer[i] is test.charAt(pos) and i isnt partialPosition + pos++ + lastMatch = i + i++ + + if not allow and lastMatch + 1 < partialPosition + element.val '' + clearBuffer 0, len + else if allow or lastMatch + 1 >= partialPosition + writeBuffer() + element.val element.val().substring(0, lastMatch + 1) unless allow + + (if partialPosition then i else firstNonMaskPos) + + # buffer = $.map(mask.split(''), (c, i) -> + # (if definitions[c] then placeholder else c) if c isnt '?' + # ) + + buffer = [] + + angular.forEach mask.split(''), (c, i) -> + if c isnt '?' + if definitions[c] + buffer.push placeholder + else + buffer.push c + + focusText = element.val() + + setMaskBuffer = -> + # $.map(buffer, (c, i) -> + # (if tests[i] and c isnt placeholder then c else null) + # ).join '' + + buffer.join '' + + unless element.attr('readonly') + element.bind('focus.mask', -> + focusText = element.val() + pos = checkVal() + + writeBuffer() + + moveCaret = -> + if pos is mask.length + caret 0, pos + else + caret pos + + ((if isIE then moveCaret else -> + setTimeout moveCaret, 0 + ))() + + ).bind('blur.mask', -> + checkVal() + ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> + setTimeout (-> + caret checkVal(true) + ), 0 + + checkVal() #Perform initial check for existing values + + + + + # We override the render method to run the jQuery mask plugin controller.$render = -> value = controller.$viewValue or '' element.val value - element.mask $scope.$eval attrs.uiMask + #element.mask $scope.$eval attrs.uiMask + createMask $scope.$eval attrs.uiMask # Add a parser that extracts the masked value into the model but only if the mask is valid controller.$parsers.push (value) -> #the second check (or) is only needed due to the fact that element.isMaskValid() will keep returning undefined #until there was at least one key event - isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 + #isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 + isValid = isMaskValid or angular.isUndefined(isMaskValid) and element.val().length > 0 controller.$setValidity 'mask', isValid @@ -22,7 +327,7 @@ app.directive 'uiMask', [-> # When keyup, update the view value element.bind 'keyup', -> $scope.$apply -> - controller.$setViewValue element.mask() + #controller.$setViewValue element.mask() link: link require: 'ngModel' From 16ed6bfc5040ee3af6307068b33ac085864e8b3a Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Fri, 11 Jan 2013 22:20:12 -0600 Subject: [PATCH 07/15] second stab --- grunt.js | 4 + src/index.html | 3 +- src/scripts/inputMask.coffee | 310 ------------ src/scripts/libs/jquery.maskedinput.js | 622 +++++++++++++------------ src/scripts/mask.coffee | 338 +------------- 5 files changed, 361 insertions(+), 916 deletions(-) delete mode 100644 src/scripts/inputMask.coffee diff --git a/grunt.js b/grunt.js index 4e1134e..579a80b 100644 --- a/grunt.js +++ b/grunt.js @@ -79,6 +79,10 @@ module.exports = function (grunt) { files: './src/scripts/**/*.coffee', tasks: 'coffeeLint coffee lint copy:scripts' }, + scripts: { + files: './src/scripts/**/*.js', + tasks: 'lint copy:staging copy:scripts' + }, views: { files: './src/**/*.html', tasks: 'copy:views' diff --git a/src/index.html b/src/index.html index e2165e2..0e689fa 100644 --- a/src/index.html +++ b/src/index.html @@ -8,7 +8,8 @@ - + + diff --git a/src/scripts/inputMask.coffee b/src/scripts/inputMask.coffee deleted file mode 100644 index 8f32bf1..0000000 --- a/src/scripts/inputMask.coffee +++ /dev/null @@ -1,310 +0,0 @@ -(($) -> - # isIE = (-> - # ua = window.navigator.userAgent.toLowerCase() - - # match = /(chrome)[ \/]([\w.]+)/.exec(ua) or - # /(webkit)[ \/]([\w.]+)/.exec(ua) or - # /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or - # /(msie) ([\w.]+)/.exec(ua) or - # ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or - # [] - - # browser = match[1] or '' - # version = match[2] or '0' - - # browser is 'msie' - # )() - - # pasteEventName = (if isIE then 'paste' else 'input') + '.mask' - # iPhone = not angular.isUndefined window.orientation - # placeholder = '_' - - # definitions = - # 9: '[0-9]' - # a: '[A-Za-z]' - # '*': '[A-Za-z0-9]' - - # maskIsValid = false - # setMaskBuffer = null - # element = null - # el = null - - # caret = (begin, end) -> - # return if element.length is 0 - - # if typeof begin is 'number' - # end = (if (typeof end is 'number') then end else begin) - - # if el.setSelectionRange - # el.setSelectionRange begin, end - # else if el.createTextRange - # range = el.createTextRange() - - # range.collapse true - # range.moveEnd 'character', end - # range.moveStart 'character', begin - # range.select() - # else - # if el.setSelectionRange - # begin = el.selectionStart - # end = el.selectionEnd - # else if document.selection and document.selection.createRange - # range = document.selection.createRange() - # begin = 0 - range.duplicate().moveStart('character', -100000) - # end = begin + range.text.length - - # {begin, end} - - $.fn.extend - # setElement: (elem) -> - # element = elem - # el = element[0] - - # isMaskValid: -> - # maskIsValid - - # mask: (mask) -> - # return if not mask and element.length > 0 - # setMaskBuffer() - - # tests = [] - # partialPosition = mask.length - # firstNonMaskPos = null - # len = mask.length - - # angular.forEach mask.split(''), (c, i) -> - # if c is '?' - # len-- - # partialPosition = i - # else if definitions[c] - # tests.push new RegExp(definitions[c]) - - # firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null - # else - # tests.push null - - # angular.forEach element, -> - # seekNext = (pos) -> - # continue while ++pos <= len and not tests[pos] - - # pos - - # seekPrev = (pos) -> - # continue while --pos >= 0 and not tests[pos] - - # pos - - # shiftL = (begin, end) -> - # return if begin < 0 - - # i = begin - # j = seekNext(end) - - # while i < len - # if tests[i] - # if j < len and tests[i].test(buffer[j]) - # buffer[i] = buffer[j] - # buffer[j] = placeholder - # else - # break - - # j = seekNext(j) - - # i++ - - # writeBuffer() - # caret Math.max(firstNonMaskPos, begin) - - # shiftR = (pos) -> - # i = pos - # c = placeholder - - # while i < len - # if tests[i] - # j = seekNext(i) - # t = buffer[i] - # buffer[i] = c - - # if j < len and tests[j].test(t) - # c = t - # else - # break - - # i++ - - # keydownEvent = (e) -> - # k = e.which - - # #backspace, delete, and escape get special treatment - # if k is 8 or k is 46 or (iPhone and k is 127) - # pos = caret() - # begin = pos.begin - # end = pos.end - - # if end - begin is 0 - # begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) - # end = (if k is 46 then seekNext(end) else end) - - # clearBuffer begin, end - # shiftL begin, end - 1 - # isValid() #twarogowski - - # false - # else if k is 27 #escape - # element.val focusText - # caret 0, checkVal() - - # false - - # keypressEvent = (e) -> - # k = e.which - # pos = caret() - - # if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore - # true - # else if k - # if pos.end - pos.begin isnt 0 - # clearBuffer pos.begin, pos.end - # shiftL pos.begin, pos.end - 1 - # isValid() #twarogowski - - # p = seekNext(pos.begin - 1) - - # if p < len - # c = String.fromCharCode(k) - - # if tests[p].test(c) - # shiftR p - - # buffer[p] = c - - # writeBuffer() - - # next = seekNext(p) - - # caret next - # isValid() #twarogowski - - # false - - # clearBuffer = (start, end) -> - # i = start - - # while i < end and i < len - # buffer[i] = placeholder if tests[i] - # i++ - - # writeBuffer = -> - # element.val(buffer.join('')).val() - - # isValid = -> - # test = element.val() - # lastMatch = -1 - # i = 0 - # pos = 0 - - # while i < len - # if tests[i] - # buffer[i] = placeholder - - # while pos++ < test.length - # c = test.charAt(pos - 1) - - # if tests[i].test(c) - # buffer[i] = c - # lastMatch = i - - # break - - # break if pos > test.length - # else if buffer[i] is test.charAt(pos) and i isnt partialPosition - # pos++ - # lastMatch = i - - # i++ - # maskIsValid = (lastMatch + 1 >= partialPosition) - # maskIsValid - - # checkVal = (allow) -> - # #try to place characters where they belong - # test = element.val() - # lastMatch = -1 - # i = 0 - # pos = 0 - - # while i < len - # if tests[i] - # buffer[i] = placeholder - - # while pos++ < test.length - # c = test.charAt(pos - 1) - - # if tests[i].test(c) - # buffer[i] = c - # lastMatch = i - - # break - - # break if pos > test.length - # else if buffer[i] is test.charAt(pos) and i isnt partialPosition - # pos++ - # lastMatch = i - # i++ - - # if not allow and lastMatch + 1 < partialPosition - # element.val '' - # clearBuffer 0, len - # else if allow or lastMatch + 1 >= partialPosition - # writeBuffer() - # element.val element.val().substring(0, lastMatch + 1) unless allow - - # (if partialPosition then i else firstNonMaskPos) - - # # buffer = $.map(mask.split(''), (c, i) -> - # # (if definitions[c] then placeholder else c) if c isnt '?' - # # ) - - # buffer = [] - - # angular.forEach mask.split(''), (c, i) -> - # if c isnt '?' - # if definitions[c] - # buffer.push placeholder - # else - # buffer.push c - - # focusText = element.val() - - # setMaskBuffer = -> - # # $.map(buffer, (c, i) -> - # # (if tests[i] and c isnt placeholder then c else null) - # # ).join '' - - # buffer.join '' - - # unless element.attr('readonly') - # element.bind('focus.mask', -> - # focusText = element.val() - # pos = checkVal() - - # writeBuffer() - - # moveCaret = -> - # if pos is mask.length - # caret 0, pos - # else - # caret pos - - # ((if isIE then moveCaret else -> - # setTimeout moveCaret, 0 - # ))() - - # ).bind('blur.mask', -> - # checkVal() - # ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> - # setTimeout (-> - # caret checkVal(true) - # ), 0 - - # checkVal() #Perform initial check for existing values -) jQuery \ No newline at end of file diff --git a/src/scripts/libs/jquery.maskedinput.js b/src/scripts/libs/jquery.maskedinput.js index 40bb3c9..c1dec65 100644 --- a/src/scripts/libs/jquery.maskedinput.js +++ b/src/scripts/libs/jquery.maskedinput.js @@ -1,290 +1,340 @@ /* - Masked Input plugin for jQuery - Copyright (c) 2007-2011 Josh Bush (digitalbush.com) - Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) - Version: 1.3 + Masked Input plugin for jQuery + Copyright (c) 2007-@Year Josh Bush (digitalbush.com) + Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) + Version: @version */ + +var $injector = angular.injector(['ng']), + $timeout = $injector.get('$timeout'), + $document = $injector.get('$document'), + document = $document[0]; + (function($) { - var pasteEventName = ($.browser.msie ? 'paste' : 'input') + ".mask"; - var iPhone = (window.orientation != undefined); - - $.mask = { - //Predefined character definitions - definitions: { - '9': "[0-9]", - 'a': "[A-Za-z]", - '*': "[A-Za-z0-9]" - }, - dataName:"rawMaskFn" - }; - - $.fn.extend({ - //Helper Function for Caret positioning - caret: function(begin, end) { - if (this.length == 0) return; - if (typeof begin == 'number') { - end = (typeof end == 'number') ? end : begin; - return this.each(function() { - if (this.setSelectionRange) { - this.setSelectionRange(begin, end); - } else if (this.createTextRange) { - var range = this.createTextRange(); - range.collapse(true); - range.moveEnd('character', end); - range.moveStart('character', begin); - range.select(); - } - }); - } else { - if (this[0].setSelectionRange) { - begin = this[0].selectionStart; - end = this[0].selectionEnd; - } else if (document.selection && document.selection.createRange) { - var range = document.selection.createRange(); - begin = 0 - range.duplicate().moveStart('character', -100000); - end = begin + range.text.length; - } - return { begin: begin, end: end }; - } - }, - unmask: function() { return this.trigger("unmask"); }, - isMaskValid: function(){ - return $(this).data('mask-isvalid'); - }, - mask: function(mask, settings) { - if (!mask && this.length > 0) { - var input = $(this[0]); - return input.data($.mask.dataName)(); - } - settings = $.extend({ - placeholder: "_", - completed: null - }, settings); - - var defs = $.mask.definitions; - var tests = []; - var partialPosition = mask.length; - var firstNonMaskPos = null; - var len = mask.length; - - $.each(mask.split(""), function(i, c) { - if (c == '?') { - len--; - partialPosition = i; - } else if (defs[c]) { - tests.push(new RegExp(defs[c])); - if(firstNonMaskPos==null) - firstNonMaskPos = tests.length - 1; - } else { - tests.push(null); - } - }); - - return this.trigger("unmask").each(function() { - var input = $(this); - var buffer = $.map(mask.split(""), function(c, i) { if (c != '?') return defs[c] ? settings.placeholder : c }); - var focusText = input.val(); - - function seekNext(pos) { - while (++pos <= len && !tests[pos]); - return pos; - }; - function seekPrev(pos) { - while (--pos >= 0 && !tests[pos]); - return pos; - }; - - function shiftL(begin,end) { - if(begin<0) - return; - for (var i = begin,j = seekNext(end); i < len; i++) { - if (tests[i]) { - if (j < len && tests[i].test(buffer[j])) { - buffer[i] = buffer[j]; - buffer[j] = settings.placeholder; - } else - break; - j = seekNext(j); - } - } - writeBuffer(); - input.caret(Math.max(firstNonMaskPos, begin)); - }; - - function shiftR(pos) { - for (var i = pos, c = settings.placeholder; i < len; i++) { - if (tests[i]) { - var j = seekNext(i); - var t = buffer[i]; - buffer[i] = c; - if (j < len && tests[j].test(t)) - c = t; - else - break; - } - } - }; - - function keydownEvent(e) { - var k=e.which; - - //backspace, delete, and escape get special treatment - if(k == 8 || k == 46 || (iPhone && k == 127)){ - var pos = input.caret(), - begin = pos.begin, - end = pos.end; - - if(end-begin==0){ - begin=k!=46?seekPrev(begin):(end=seekNext(begin-1)); - end=k==46?seekNext(end):end; - } - clearBuffer(begin, end); - shiftL(begin,end-1); - isValid(); //twarogowski - - return false; - } else if (k == 27) {//escape - input.val(focusText); - input.caret(0, checkVal()); - return false; - } - }; - - function keypressEvent(e) { - var k = e.which, - pos = input.caret(); - if (e.ctrlKey || e.altKey || e.metaKey || k<32) {//Ignore - return true; - } else if (k) { - if(pos.end-pos.begin!=0){ - clearBuffer(pos.begin, pos.end); - shiftL(pos.begin, pos.end-1); - isValid(); //twarogowski - } - - var p = seekNext(pos.begin - 1); - if (p < len) { - var c = String.fromCharCode(k); - if (tests[p].test(c)) { - shiftR(p); - buffer[p] = c; - writeBuffer(); - var next = seekNext(p); - input.caret(next); - isValid(); //twarogowski - if (settings.completed && next >= len) - settings.completed.call(input); - } - } - return false; - } - }; - - function clearBuffer(start, end) { - for (var i = start; i < end && i < len; i++) { - if (tests[i]) - buffer[i] = settings.placeholder; - } - }; - - function writeBuffer() { return input.val(buffer.join('')).val(); }; - - function isValid(){ - var test = input.val(); - var lastMatch = -1; - for (var i = 0, pos = 0; i < len; i++) { - if (tests[i]) { - buffer[i] = settings.placeholder; - while (pos++ < test.length) { - var c = test.charAt(pos - 1); - if (tests[i].test(c)) { - buffer[i] = c; - lastMatch = i; - break; - } - } - if (pos > test.length) - break; - } else if (buffer[i] == test.charAt(pos) && i!=partialPosition) { - pos++; - lastMatch = i; - } - } - var valid = (lastMatch + 1 >= partialPosition); - input.data('mask-isvalid',valid); - return valid; - } - - function checkVal(allow) { - //try to place characters where they belong - var test = input.val(); - var lastMatch = -1; - for (var i = 0, pos = 0; i < len; i++) { - if (tests[i]) { - buffer[i] = settings.placeholder; - while (pos++ < test.length) { - var c = test.charAt(pos - 1); - if (tests[i].test(c)) { - buffer[i] = c; - lastMatch = i; - break; - } - } - if (pos > test.length) - break; - } else if (buffer[i] == test.charAt(pos) && i!=partialPosition) { - pos++; - lastMatch = i; - } - } - if (!allow && lastMatch + 1 < partialPosition) { - input.val(""); - clearBuffer(0, len); - } else if (allow || lastMatch + 1 >= partialPosition) { - writeBuffer(); - if (!allow) input.val(input.val().substring(0, lastMatch + 1)); - } - return (partialPosition ? i : firstNonMaskPos); - }; - - input.data($.mask.dataName,function(){ - return $.map(buffer, function(c, i) { - return tests[i]&&c!=settings.placeholder ? c : null; - }).join(''); - }) - - if (!input.attr("readonly")) - input - .one("unmask", function() { - input - .unbind(".mask") - .removeData($.mask.dataName); - }) - .bind("focus.mask", function() { - focusText = input.val(); - var pos = checkVal(); - writeBuffer(); - var moveCaret=function(){ - if (pos == mask.length) - input.caret(0, pos); - else - input.caret(pos); - }; - ($.browser.msie ? moveCaret:function(){setTimeout(moveCaret,0)})(); - }) - .bind("blur.mask", function() { - checkVal(); - if (input.val() != focusText) - input.change(); - }) - .bind("keydown.mask", keydownEvent) - .bind("keypress.mask", keypressEvent) - .bind(pasteEventName, function() { - setTimeout(function() { input.caret(checkVal(true)); }, 0); - }); - - checkVal(); //Perform initial check for existing values - }); - } - }); + function getPasteEvent() { + var el = document.createElement('input'), + name = 'onpaste'; + el.setAttribute(name, ''); + return (typeof el[name] === 'function')?'paste':'input'; + } + + var pasteEventName = getPasteEvent() + ".mask", + ua = navigator.userAgent, + iPhone = /iphone/i.test(ua), + android=/android/i.test(ua), + caretTimeoutId, + definitions = { + '9': "[0-9]", + 'a': "[A-Za-z]", + '*': "[A-Za-z0-9]" + }, + dataName = "rawMaskFn", + placeholder = '_'; + + $.fn.extend({ + //Helper Function for Caret positioning + caret: function(begin, end) { + var range; + + if (this.length === 0 || this.is(":hidden")) { + return; + } + + if (typeof begin == 'number') { + end = (typeof end === 'number') ? end : begin; + return angular.forEach(this, function(me) { + if (me.setSelectionRange) { + me.setSelectionRange(begin, end); + } else if (me.createTextRange) { + range = me.createTextRange(); + range.collapse(true); + range.moveEnd('character', end); + range.moveStart('character', begin); + range.select(); + } + }); + } else { + if (this[0].setSelectionRange) { + begin = this[0].selectionStart; + end = this[0].selectionEnd; + } else if (document.selection && document.selection.createRange) { + range = document.selection.createRange(); + begin = 0 - range.duplicate().moveStart('character', -100000); + end = begin + range.text.length; + } + return { begin: begin, end: end }; + } + }, + mask: function(mask, settings) { + var $input, + defs, + tests, + partialPosition, + firstNonMaskPos, + len; + + if (!mask && this.length > 0) { + $input = angular.element(this[0]); + return $input.data(dataName)(); + } + + settings = { + placeholder: placeholder, // Load default placeholder + completed: null + }; + + defs = definitions; + tests = []; + partialPosition = len = mask.length; + firstNonMaskPos = null; + + angular.forEach(mask.split(""), function(c, i) { + if (c == '?') { + len--; + partialPosition = i; + } else if (defs[c]) { + tests.push(new RegExp(defs[c])); + if (firstNonMaskPos === null) { + firstNonMaskPos = tests.length - 1; + } + } else { + tests.push(null); + } + }); + + return angular.forEach(this, function(input) { + var $input = angular.element(input), + buffer = [], + focusText = $input.val(); + + angular.forEach(mask.split(''), function (c, i) { + if (c !== '?') { + var val = defs[c] ? settings.placeholder : c; + + if (val !== null) { + buffer.push(val); + } + } + }); + + function seekNext(pos) { + while (++pos < len && !tests[pos]); + return pos; + } + + function seekPrev(pos) { + while (--pos >= 0 && !tests[pos]); + return pos; + } + + function shiftL(begin,end) { + var i, + j; + + if (begin<0) { + return; + } + + for (i = begin, j = seekNext(end); i < len; i++) { + if (tests[i]) { + if (j < len && tests[i].test(buffer[j])) { + buffer[i] = buffer[j]; + buffer[j] = settings.placeholder; + } else { + break; + } + + j = seekNext(j); + } + } + writeBuffer(); + $input.caret(Math.max(firstNonMaskPos, begin)); + } + + function shiftR(pos) { + var i, + c, + j, + t; + + for (i = pos, c = settings.placeholder; i < len; i++) { + if (tests[i]) { + j = seekNext(i); + t = buffer[i]; + buffer[i] = c; + if (j < len && tests[j].test(t)) { + c = t; + } else { + break; + } + } + } + } + + function keydownEvent(e) { + var k = e.which, + pos, + begin, + end; + + //backspace, delete, and escape get special treatment + if (k === 8 || k === 46 || (iPhone && k === 127)) { + pos = $input.caret(); + begin = pos.begin; + end = pos.end; + + if (end - begin === 0) { + begin=k!==46?seekPrev(begin):(end=seekNext(begin-1)); + end=k===46?seekNext(end):end; + } + clearBuffer(begin, end); + shiftL(begin, end - 1); + + return false; + } else if (k == 27) {//escape + $input.val(focusText); + $input.caret(0, checkVal()); + return false; + } + } + + function keypressEvent(e) { + var k = e.which, + pos = $input.caret(), + p, + c, + next; + + if (e.ctrlKey || e.altKey || e.metaKey || k < 32) {//Ignore + return true; + } else if (k) { + if (pos.end - pos.begin !== 0){ + clearBuffer(pos.begin, pos.end); + shiftL(pos.begin, pos.end-1); + } + + p = seekNext(pos.begin - 1); + if (p < len) { + c = String.fromCharCode(k); + if (tests[p].test(c)) { + shiftR(p); + + buffer[p] = c; + writeBuffer(); + + next = seekNext(p); + if(android){ + $timeout($.proxy($.fn.caret,$input,next),0); + }else{ + $input.caret(next); + } + + if (settings.completed && next >= len) { + settings.completed.call($input); + } + } + } + return false; + } + } + + function clearBuffer(start, end) { + var i; + for (i = start; i < end && i < len; i++) { + if (tests[i]) { + buffer[i] = settings.placeholder; + } + } + } + + function writeBuffer() { $input.val(buffer.join('')); } + + function checkVal(allow) { + //try to place characters where they belong + var test = $input.val(), + lastMatch = -1, + i, + c; + + for (i = 0, pos = 0; i < len; i++) { + if (tests[i]) { + buffer[i] = settings.placeholder; + while (pos++ < test.length) { + c = test.charAt(pos - 1); + if (tests[i].test(c)) { + buffer[i] = c; + lastMatch = i; + break; + } + } + if (pos > test.length) { + break; + } + } else if (buffer[i] === test.charAt(pos) && i !== partialPosition) { + pos++; + lastMatch = i; + } + } + if (allow) { + writeBuffer(); + } else if (lastMatch + 1 < partialPosition) { + $input.val(""); + clearBuffer(0, len); + } else { + writeBuffer(); + $input.val($input.val().substring(0, lastMatch + 1)); + } + return (partialPosition ? i : firstNonMaskPos); + } + + $input.data(dataName,function(){ + var arr = []; + + angular.forEach(buffer, function (c, i) { + if (tests[i] && c !== settings.placeholder) { + arr.push(c); + } + }); + + return arr.join(''); + }); + + if (!$input.attr("readonly")) + $input + .bind("focus.mask", function() { + $timeout.cancel(caretTimeoutId); + var pos, + moveCaret; + + focusText = $input.val(); + pos = checkVal(); + + caretTimeoutId = $timeout(function(){ + writeBuffer(); + if (pos == mask.length) { + $input.caret(0, pos); + } else { + $input.caret(pos); + } + }, 10); + }) + .bind("blur.mask", function() { + checkVal(); + if ($input.val() != focusText) + $input.change(); + }) + .bind("keydown.mask", keydownEvent) + .bind("keypress.mask", keypressEvent) + .bind(pasteEventName, function() { + $timeout(function() { + var pos=checkVal(true); + $input.caret(pos); + if (settings.completed && pos == $input.val().length) + settings.completed.call($input); + }, 0); + }); + checkVal(); //Perform initial check for existing values + }); + } + }); })(jQuery); \ No newline at end of file diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee index 78357b0..5532559 100644 --- a/src/scripts/mask.coffee +++ b/src/scripts/mask.coffee @@ -1,334 +1,34 @@ -app.directive 'uiMask', [-> - isIE = (-> - ua = window.navigator.userAgent.toLowerCase() - - match = /(chrome)[ \/]([\w.]+)/.exec(ua) or - /(webkit)[ \/]([\w.]+)/.exec(ua) or - /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) or - /(msie) ([\w.]+)/.exec(ua) or - ua.indexOf('compatible') < 0 and /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) or - [] - - browser = match[1] or '' - version = match[2] or '0' - - browser is 'msie' - )() - - pasteEventName = (if isIE then 'paste' else 'input') + '.mask' - iPhone = not angular.isUndefined window.orientation - placeholder = '_' - - definitions = - 9: '[0-9]' - a: '[A-Za-z]' - '*': '[A-Za-z0-9]' - - link = ($scope, element, attrs, controller) -> - isMaskValid = false - setMaskBuffer = null - el = element[0] - - caret = (begin, end) -> - return if element.length is 0 - - if typeof begin is 'number' - end = (if (typeof end is 'number') then end else begin) - - if el.setSelectionRange - el.setSelectionRange begin, end - else if el.createTextRange - range = el.createTextRange() - - range.collapse true - range.moveEnd 'character', end - range.moveStart 'character', begin - range.select() - else - if el.setSelectionRange - begin = el.selectionStart - end = el.selectionEnd - else if document.selection and document.selection.createRange - range = document.selection.createRange() - begin = 0 - range.duplicate().moveStart('character', -100000) - end = begin + range.text.length - - {begin, end} - - createMask = (mask) -> - return if not mask and element.length > 0 - setMaskBuffer() - - tests = [] - partialPosition = mask.length - firstNonMaskPos = null - len = mask.length - - angular.forEach mask.split(''), (c, i) -> - if c is '?' - len-- - partialPosition = i - else if definitions[c] - tests.push new RegExp(definitions[c]) - - firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null - else - tests.push null - - angular.forEach element, -> - seekNext = (pos) -> - continue while ++pos <= len and not tests[pos] - - pos - - seekPrev = (pos) -> - continue while --pos >= 0 and not tests[pos] - - pos - - shiftL = (begin, end) -> - return if begin < 0 - - i = begin - j = seekNext(end) - - while i < len - if tests[i] - if j < len and tests[i].test(buffer[j]) - buffer[i] = buffer[j] - buffer[j] = placeholder - else - break - - j = seekNext(j) - - i++ - - writeBuffer() - caret Math.max(firstNonMaskPos, begin) - - shiftR = (pos) -> - i = pos - c = placeholder - - while i < len - if tests[i] - j = seekNext(i) - t = buffer[i] - buffer[i] = c - - if j < len and tests[j].test(t) - c = t - else - break - - i++ - - keydownEvent = (e) -> - k = e.which - - #backspace, delete, and escape get special treatment - if k is 8 or k is 46 or (iPhone and k is 127) - pos = caret() - begin = pos.begin - end = pos.end - - if end - begin is 0 - begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) - end = (if k is 46 then seekNext(end) else end) - - clearBuffer begin, end - shiftL begin, end - 1 - isValid() #twarogowski - - false - else if k is 27 #escape - element.val focusText - caret 0, checkVal() - - false - - keypressEvent = (e) -> - k = e.which - pos = caret() - - if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore - true - else if k - if pos.end - pos.begin isnt 0 - clearBuffer pos.begin, pos.end - shiftL pos.begin, pos.end - 1 - isValid() #twarogowski - - p = seekNext(pos.begin - 1) - - if p < len - c = String.fromCharCode(k) - - if tests[p].test(c) - shiftR p - - buffer[p] = c - - writeBuffer() - - next = seekNext(p) - - caret next - isValid() #twarogowski - - false - - clearBuffer = (start, end) -> - i = start - - while i < end and i < len - buffer[i] = placeholder if tests[i] - i++ - - writeBuffer = -> - element.val(buffer.join('')).val() - - isValid = -> - test = element.val() - lastMatch = -1 - i = 0 - pos = 0 - - while i < len - if tests[i] - buffer[i] = placeholder - - while pos++ < test.length - c = test.charAt(pos - 1) - - if tests[i].test(c) - buffer[i] = c - lastMatch = i - - break - - break if pos > test.length - else if buffer[i] is test.charAt(pos) and i isnt partialPosition - pos++ - lastMatch = i - - i++ - maskIsValid = (lastMatch + 1 >= partialPosition) - maskIsValid - - checkVal = (allow) -> - #try to place characters where they belong - test = element.val() - lastMatch = -1 - i = 0 - pos = 0 - - while i < len - if tests[i] - buffer[i] = placeholder - - while pos++ < test.length - c = test.charAt(pos - 1) - - if tests[i].test(c) - buffer[i] = c - lastMatch = i - - break - - break if pos > test.length - else if buffer[i] is test.charAt(pos) and i isnt partialPosition - pos++ - lastMatch = i - i++ - - if not allow and lastMatch + 1 < partialPosition - element.val '' - clearBuffer 0, len - else if allow or lastMatch + 1 >= partialPosition - writeBuffer() - element.val element.val().substring(0, lastMatch + 1) unless allow - - (if partialPosition then i else firstNonMaskPos) - - # buffer = $.map(mask.split(''), (c, i) -> - # (if definitions[c] then placeholder else c) if c isnt '?' - # ) - - buffer = [] - - angular.forEach mask.split(''), (c, i) -> - if c isnt '?' - if definitions[c] - buffer.push placeholder - else - buffer.push c - - focusText = element.val() - - setMaskBuffer = -> - # $.map(buffer, (c, i) -> - # (if tests[i] and c isnt placeholder then c else null) - # ).join '' - - buffer.join '' - - unless element.attr('readonly') - element.bind('focus.mask', -> - focusText = element.val() - pos = checkVal() - - writeBuffer() - - moveCaret = -> - if pos is mask.length - caret 0, pos - else - caret pos - - ((if isIE then moveCaret else -> - setTimeout moveCaret, 0 - ))() - - ).bind('blur.mask', -> - checkVal() - ).bind('keydown.mask', keydownEvent).bind('keypress.mask', keypressEvent).bind pasteEventName, -> - setTimeout (-> - caret checkVal(true) - ), 0 - - checkVal() #Perform initial check for existing values - - - - - +# +# Attaches jquery-ui input mask onto input element +# +app.directive "uiMask", ['$log', ($log)-> + require: "ngModel" + link: ($scope, element, attrs, controller) -> # We override the render method to run the jQuery mask plugin + # controller.$render = -> - value = controller.$viewValue or '' - + value = controller.$viewValue or "" element.val value - #element.mask $scope.$eval attrs.uiMask - createMask $scope.$eval attrs.uiMask + element.mask $scope.$eval(attrs.uiMask) + # Add a parser that extracts the masked value into the model but only if the mask is valid + # controller.$parsers.push (value) -> + #the second check (or) is only needed due to the fact that element.isMaskValid() will keep returning undefined #until there was at least one key event - #isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 - isValid = isMaskValid or angular.isUndefined(isMaskValid) and element.val().length > 0 + # isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 + # controller.$setValidity "mask", isValid + # (if isValid then value else undefined) - controller.$setValidity 'mask', isValid + value - if isValid then value else undefined # When keyup, update the view value - element.bind 'keyup', -> + # + element.bind "keyup", -> $scope.$apply -> - #controller.$setViewValue element.mask() - - link: link - require: 'ngModel' + controller.$setViewValue element.mask() ] \ No newline at end of file From 8bbf298e0888c7cb085544d1b76ef75b84b9f8e6 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Fri, 11 Jan 2013 22:29:11 -0600 Subject: [PATCH 08/15] removed namespaced events --- src/scripts/libs/jquery.maskedinput.js | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/scripts/libs/jquery.maskedinput.js b/src/scripts/libs/jquery.maskedinput.js index c1dec65..05647ba 100644 --- a/src/scripts/libs/jquery.maskedinput.js +++ b/src/scripts/libs/jquery.maskedinput.js @@ -18,7 +18,7 @@ var $injector = angular.injector(['ng']), return (typeof el[name] === 'function')?'paste':'input'; } - var pasteEventName = getPasteEvent() + ".mask", + var pasteEventName = getPasteEvent(), ua = navigator.userAgent, iPhone = /iphone/i.test(ua), android=/android/i.test(ua), @@ -89,7 +89,7 @@ var $injector = angular.injector(['ng']), firstNonMaskPos = null; angular.forEach(mask.split(""), function(c, i) { - if (c == '?') { + if (c === '?') { len--; partialPosition = i; } else if (defs[c]) { @@ -191,7 +191,7 @@ var $injector = angular.injector(['ng']), shiftL(begin, end - 1); return false; - } else if (k == 27) {//escape + } else if (k === 27) {//escape $input.val(focusText); $input.caret(0, checkVal()); return false; @@ -301,7 +301,7 @@ var $injector = angular.injector(['ng']), if (!$input.attr("readonly")) $input - .bind("focus.mask", function() { + .bind("focus", function() { $timeout.cancel(caretTimeoutId); var pos, moveCaret; @@ -311,25 +311,25 @@ var $injector = angular.injector(['ng']), caretTimeoutId = $timeout(function(){ writeBuffer(); - if (pos == mask.length) { + if (pos === mask.length) { $input.caret(0, pos); } else { $input.caret(pos); } }, 10); }) - .bind("blur.mask", function() { + .bind("blur", function() { checkVal(); - if ($input.val() != focusText) + if ($input.val() !== focusText) $input.change(); }) - .bind("keydown.mask", keydownEvent) - .bind("keypress.mask", keypressEvent) + .bind("keydown", keydownEvent) + .bind("keypress", keypressEvent) .bind(pasteEventName, function() { $timeout(function() { var pos=checkVal(true); $input.caret(pos); - if (settings.completed && pos == $input.val().length) + if (settings.completed && pos === $input.val().length) settings.completed.call($input); }, 0); }); From fe850b706bc2c5cb46b06c9a0188ef5be85b6fc0 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Fri, 11 Jan 2013 22:44:42 -0600 Subject: [PATCH 09/15] extracted caret from jquery prototype, renamed to caretHelper to avoid name conflict --- src/scripts/libs/jquery.maskedinput.js | 84 ++++++++++++++------------ 1 file changed, 44 insertions(+), 40 deletions(-) diff --git a/src/scripts/libs/jquery.maskedinput.js b/src/scripts/libs/jquery.maskedinput.js index 05647ba..90f757e 100644 --- a/src/scripts/libs/jquery.maskedinput.js +++ b/src/scripts/libs/jquery.maskedinput.js @@ -8,7 +8,9 @@ var $injector = angular.injector(['ng']), $timeout = $injector.get('$timeout'), $document = $injector.get('$document'), - document = $document[0]; + document = $document[0], + $window = $injector.get('$window'), + navigator = window.navigator; (function($) { function getPasteEvent() { @@ -31,40 +33,40 @@ var $injector = angular.injector(['ng']), dataName = "rawMaskFn", placeholder = '_'; - $.fn.extend({ - //Helper Function for Caret positioning - caret: function(begin, end) { - var range; + var caretHelper = function ($input, begin, end) { + var range; - if (this.length === 0 || this.is(":hidden")) { - return; - } + if ($input.length === 0 || $input.is(":hidden")) { + return; + } - if (typeof begin == 'number') { - end = (typeof end === 'number') ? end : begin; - return angular.forEach(this, function(me) { - if (me.setSelectionRange) { - me.setSelectionRange(begin, end); - } else if (me.createTextRange) { - range = me.createTextRange(); - range.collapse(true); - range.moveEnd('character', end); - range.moveStart('character', begin); - range.select(); - } - }); - } else { - if (this[0].setSelectionRange) { - begin = this[0].selectionStart; - end = this[0].selectionEnd; - } else if (document.selection && document.selection.createRange) { - range = document.selection.createRange(); - begin = 0 - range.duplicate().moveStart('character', -100000); - end = begin + range.text.length; + if (typeof begin == 'number') { + end = (typeof end === 'number') ? end : begin; + return angular.forEach($input, function(me) { + if (me.setSelectionRange) { + me.setSelectionRange(begin, end); + } else if (me.createTextRange) { + range = me.createTextRange(); + range.collapse(true); + range.moveEnd('character', end); + range.moveStart('character', begin); + range.select(); } - return { begin: begin, end: end }; + }); + } else { + if ($input[0].setSelectionRange) { + begin = $input[0].selectionStart; + end = $input[0].selectionEnd; + } else if (document.selection && document.selection.createRange) { + range = document.selection.createRange(); + begin = 0 - range.duplicate().moveStart('character', -100000); + end = begin + range.text.length; } - }, + return { begin: begin, end: end }; + } + }; + + $.fn.extend({ mask: function(mask, settings) { var $input, defs, @@ -148,7 +150,7 @@ var $injector = angular.injector(['ng']), } } writeBuffer(); - $input.caret(Math.max(firstNonMaskPos, begin)); + caretHelper($input, Math.max(firstNonMaskPos, begin)); } function shiftR(pos) { @@ -179,7 +181,7 @@ var $injector = angular.injector(['ng']), //backspace, delete, and escape get special treatment if (k === 8 || k === 46 || (iPhone && k === 127)) { - pos = $input.caret(); + pos = caretHelper($input); begin = pos.begin; end = pos.end; @@ -193,14 +195,14 @@ var $injector = angular.injector(['ng']), return false; } else if (k === 27) {//escape $input.val(focusText); - $input.caret(0, checkVal()); + caretHelper($input, 0, checkVal()); return false; } } function keypressEvent(e) { var k = e.which, - pos = $input.caret(), + pos = caretHelper($input), p, c, next; @@ -224,9 +226,11 @@ var $injector = angular.injector(['ng']), next = seekNext(p); if(android){ - $timeout($.proxy($.fn.caret,$input,next),0); + // Commented out the next line. No substitute for proxy. + // $timeout($.proxy(caretHelper,$input,next),0); + caretHelper($input, next); }else{ - $input.caret(next); + caretHelper($input, next); } if (settings.completed && next >= len) { @@ -312,9 +316,9 @@ var $injector = angular.injector(['ng']), caretTimeoutId = $timeout(function(){ writeBuffer(); if (pos === mask.length) { - $input.caret(0, pos); + caretHelper($input, 0, pos); } else { - $input.caret(pos); + caretHelper($input, pos); } }, 10); }) @@ -328,7 +332,7 @@ var $injector = angular.injector(['ng']), .bind(pasteEventName, function() { $timeout(function() { var pos=checkVal(true); - $input.caret(pos); + caretHelper($input, pos); if (settings.completed && pos === $input.val().length) settings.completed.call($input); }, 0); From a4e80cdcdedca84c1e5c3725b1da89f64e62fbe2 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Fri, 11 Jan 2013 22:47:36 -0600 Subject: [PATCH 10/15] renamed caretHelper to caret after name conflict resolution --- src/scripts/libs/jquery.maskedinput.js | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/scripts/libs/jquery.maskedinput.js b/src/scripts/libs/jquery.maskedinput.js index 90f757e..5f3941e 100644 --- a/src/scripts/libs/jquery.maskedinput.js +++ b/src/scripts/libs/jquery.maskedinput.js @@ -33,7 +33,7 @@ var $injector = angular.injector(['ng']), dataName = "rawMaskFn", placeholder = '_'; - var caretHelper = function ($input, begin, end) { + var caret = function ($input, begin, end) { var range; if ($input.length === 0 || $input.is(":hidden")) { @@ -150,7 +150,7 @@ var $injector = angular.injector(['ng']), } } writeBuffer(); - caretHelper($input, Math.max(firstNonMaskPos, begin)); + caret($input, Math.max(firstNonMaskPos, begin)); } function shiftR(pos) { @@ -181,7 +181,7 @@ var $injector = angular.injector(['ng']), //backspace, delete, and escape get special treatment if (k === 8 || k === 46 || (iPhone && k === 127)) { - pos = caretHelper($input); + pos = caret($input); begin = pos.begin; end = pos.end; @@ -195,14 +195,14 @@ var $injector = angular.injector(['ng']), return false; } else if (k === 27) {//escape $input.val(focusText); - caretHelper($input, 0, checkVal()); + caret($input, 0, checkVal()); return false; } } function keypressEvent(e) { var k = e.which, - pos = caretHelper($input), + pos = caret($input), p, c, next; @@ -227,10 +227,10 @@ var $injector = angular.injector(['ng']), next = seekNext(p); if(android){ // Commented out the next line. No substitute for proxy. - // $timeout($.proxy(caretHelper,$input,next),0); - caretHelper($input, next); + // $timeout($.proxy(caret,$input,next),0); + caret($input, next); }else{ - caretHelper($input, next); + caret($input, next); } if (settings.completed && next >= len) { @@ -316,9 +316,9 @@ var $injector = angular.injector(['ng']), caretTimeoutId = $timeout(function(){ writeBuffer(); if (pos === mask.length) { - caretHelper($input, 0, pos); + caret($input, 0, pos); } else { - caretHelper($input, pos); + caret($input, pos); } }, 10); }) @@ -332,7 +332,7 @@ var $injector = angular.injector(['ng']), .bind(pasteEventName, function() { $timeout(function() { var pos=checkVal(true); - caretHelper($input, pos); + caret($input, pos); if (settings.completed && pos === $input.val().length) settings.completed.call($input); }, 0); From 82e4a248c801aa5a8eb925c4b17c2810f8e0616d Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Fri, 11 Jan 2013 23:30:52 -0600 Subject: [PATCH 11/15] converted to coffeescript --- src/index.html | 6 +++--- src/scripts/libs/jquery.maskedinput.js | 4 +++- src/scripts/mask.coffee | 26 +++++++++----------------- 3 files changed, 15 insertions(+), 21 deletions(-) diff --git a/src/index.html b/src/index.html index 0e689fa..699ba21 100644 --- a/src/index.html +++ b/src/index.html @@ -8,15 +8,15 @@ - - + +

Phone Number - +

\ No newline at end of file diff --git a/src/scripts/libs/jquery.maskedinput.js b/src/scripts/libs/jquery.maskedinput.js index 5f3941e..a70625b 100644 --- a/src/scripts/libs/jquery.maskedinput.js +++ b/src/scripts/libs/jquery.maskedinput.js @@ -251,7 +251,9 @@ var $injector = angular.injector(['ng']), } } - function writeBuffer() { $input.val(buffer.join('')); } + function writeBuffer() { + $input.val(buffer.join('')); + } function checkVal(allow) { //try to place characters where they belong diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee index 5532559..3bcd288 100644 --- a/src/scripts/mask.coffee +++ b/src/scripts/mask.coffee @@ -1,34 +1,26 @@ -# -# Attaches jquery-ui input mask onto input element -# -app.directive "uiMask", ['$log', ($log)-> - require: "ngModel" - link: ($scope, element, attrs, controller) -> - +app.directive 'appMask', ['$log', ($log) -> + link = ($scope, element, attrs, controller) -> # We override the render method to run the jQuery mask plugin - # controller.$render = -> - value = controller.$viewValue or "" + value = controller.$viewValue or '' element.val value - element.mask $scope.$eval(attrs.uiMask) - + element.mask $scope.$eval attrs.appMask # Add a parser that extracts the masked value into the model but only if the mask is valid - # controller.$parsers.push (value) -> - #the second check (or) is only needed due to the fact that element.isMaskValid() will keep returning undefined #until there was at least one key event # isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 - # controller.$setValidity "mask", isValid + # controller.$setValidity 'mask', isValid # (if isValid then value else undefined) value - # When keyup, update the view value - # - element.bind "keyup", -> + element.bind 'keyup', -> $scope.$apply -> controller.$setViewValue element.mask() + + link: link + require: 'ngModel' ] \ No newline at end of file From 2702dee20467153678524cdfa35243979a0b88d1 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Sat, 12 Jan 2013 19:52:35 -0600 Subject: [PATCH 12/15] coffeescripted --- src/scripts/jquery.maskedinput.coffee | 307 ++++++++++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 src/scripts/jquery.maskedinput.coffee diff --git a/src/scripts/jquery.maskedinput.coffee b/src/scripts/jquery.maskedinput.coffee new file mode 100644 index 0000000..32b2ad6 --- /dev/null +++ b/src/scripts/jquery.maskedinput.coffee @@ -0,0 +1,307 @@ +# +# Masked Input plugin for jQuery +# Copyright (c) 2007-@Year Josh Bush (digitalbush.com) +# Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) +# Version: @version +# +$injector = angular.injector ['ng'] +$timeout = $injector.get '$timeout' +$document = $injector.get '$document' +document = $document[0] +$window = $injector.get '$window' +navigator = window.navigator + +(($) -> + getPasteEvent = -> + el = document.createElement 'input' + name = 'onpaste' + el.setAttribute name, '' + (if (typeof el[name] is 'function') then 'paste' else 'input') + + pasteEventName = getPasteEvent() + ua = navigator.userAgent + iPhone = /iphone/i.test ua + android = /android/i.test ua + caretTimeoutId = undefined + + definitions = + 9: '[0-9]' + a: '[A-Za-z]' + '*': '[A-Za-z0-9]' + + dataName = 'rawMaskFn' + placeholder = '_' + + caret = ($input, begin, end) -> + range = undefined + + return if $input.length is 0 #or $input.is(':hidden') + + if typeof begin is 'number' + end = (if (typeof end is 'number') then end else begin) + + angular.forEach $input, (input) -> + if input.setSelectionRange + input.setSelectionRange begin, end + else if input.createTextRange + range = input.createTextRange() + range.collapse true + range.moveEnd 'character', end + range.moveStart 'character', begin + range.select() + else + if $input[0].setSelectionRange + begin = $input[0].selectionStart + end = $input[0].selectionEnd + else if document.selection and document.selection.createRange + range = document.selection.createRange() + begin = 0 - range.duplicate().moveStart 'character', -100000 + end = begin + range.text.length + + begin: begin + end: end + + $.fn.extend mask: (mask) -> + $input = undefined + defs = undefined + tests = undefined + partialPosition = undefined + firstNonMaskPos = undefined + len = undefined + + if not mask and @length > 0 + $input = angular.element this[0] + + return $input.data(dataName)() + + completed = null + + defs = definitions + tests = [] + partialPosition = len = mask.length + firstNonMaskPos = null + + angular.forEach mask.split(''), (c, i) -> + if c is '?' + len-- + + partialPosition = i + else if defs[c] + tests.push new RegExp defs[c] + + firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null + else + tests.push null + + angular.forEach this, (input) -> + seekNext = (pos) -> + continue while ++pos < len and not tests[pos] + + pos + seekPrev = (pos) -> + continue while --pos >= 0 and not tests[pos] + + pos + shiftL = (begin, end) -> + i = undefined + j = undefined + + return if begin < 0 + + i = begin + j = seekNext(end) + + while i < len + if tests[i] + if j < len and tests[i].test buffer[j] + buffer[i] = buffer[j] + buffer[j] = placeholder + else + break + + j = seekNext(j) + + i++ + + writeBuffer() + caret $input, Math.max firstNonMaskPos, begin + shiftR = (pos) -> + i = undefined + c = undefined + j = undefined + t = undefined + i = pos + c = placeholder + + while i < len + if tests[i] + j = seekNext(i) + t = buffer[i] + buffer[i] = c + + if j < len and tests[j].test t + c = t + else + break + + i++ + keydownEvent = (e) -> + k = e.which + pos = undefined + begin = undefined + end = undefined + + #backspace, delete, and escape get special treatment + if k is 8 or k is 46 or (iPhone and k is 127) + pos = caret($input) + begin = pos.begin + end = pos.end + + if end - begin is 0 + begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) + end = (if k is 46 then seekNext(end) else end) + + clearBuffer begin, end + shiftL begin, end - 1 + + false + else if k is 27 #escape + $input.val focusText + caret $input, 0, checkVal() + + false + keypressEvent = (e) -> + k = e.which + pos = caret($input) + p = undefined + c = undefined + next = undefined + + if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore + true + else if k + if pos.end - pos.begin isnt 0 + clearBuffer pos.begin, pos.end + shiftL pos.begin, pos.end - 1 + + p = seekNext pos.begin - 1 + + if p < len + c = String.fromCharCode k + + if tests[p].test c + shiftR p + + buffer[p] = c + + writeBuffer() + + next = seekNext p + + if android + # Commented out the next line. Need a substitute for proxy. + # $timeout($.proxy(caret, $input, next), 0); + caret $input, next + else + caret $input, next + + completed.call $input if completed and next >= len + + false + clearBuffer = (start, end) -> + i = undefined + i = start + + while i < end and i < len + buffer[i] = placeholder if tests[i] + + i++ + writeBuffer = -> + $input.val buffer.join '' + checkVal = (allow) -> + #try to place characters where they belong + test = $input.val() + lastMatch = -1 + i = undefined + c = undefined + i = 0 + pos = 0 + + while i < len + if tests[i] + buffer[i] = placeholder + + while pos++ < test.length + c = test.charAt pos - 1 + + if tests[i].test c + buffer[i] = c + lastMatch = i + + break + + break if pos > test.length + else if buffer[i] is test.charAt(pos) and i isnt partialPosition + pos++ + + lastMatch = i + + i++ + if allow + writeBuffer() + else if lastMatch + 1 < partialPosition + $input.val '' + clearBuffer 0, len + else + writeBuffer() + $input.val $input.val().substring 0, lastMatch + 1 + + (if partialPosition then i else firstNonMaskPos) + + $input = angular.element(input) + buffer = [] + focusText = $input.val() + + angular.forEach mask.split(''), (c, i) -> + if c isnt '?' + val = (if defs[c] then placeholder else c) + + buffer.push val if val isnt null + + $input.data dataName, -> + arr = [] + + angular.forEach buffer, (c, i) -> + arr.push c if tests[i] and c isnt placeholder + + arr.join '' + + unless $input.attr 'readonly' + $input.bind('focus', -> + $timeout.cancel caretTimeoutId + + pos = undefined + moveCaret = undefined + focusText = $input.val() + pos = checkVal() + + caretTimeoutId = $timeout(-> + writeBuffer() + + if pos is mask.length + caret $input, 0, pos + else + caret $input, pos + , 10) + ).bind('blur', -> + checkVal() + $input.change() if $input.val() isnt focusText + ).bind('keydown', keydownEvent).bind('keypress', keypressEvent).bind pasteEventName, -> + $timeout (-> + pos = checkVal(true) + caret $input, pos + completed.call $input if completed and pos is $input.val().length + ), 0 + + checkVal() #Perform initial check for existing values +) jQuery \ No newline at end of file From 8aa69715d38f7cfaa3a41725791458ba2bdee742 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Sat, 12 Jan 2013 19:58:43 -0600 Subject: [PATCH 13/15] added window --- src/scripts/jquery.maskedinput.coffee | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/scripts/jquery.maskedinput.coffee b/src/scripts/jquery.maskedinput.coffee index 32b2ad6..4b188ab 100644 --- a/src/scripts/jquery.maskedinput.coffee +++ b/src/scripts/jquery.maskedinput.coffee @@ -9,9 +9,10 @@ $timeout = $injector.get '$timeout' $document = $injector.get '$document' document = $document[0] $window = $injector.get '$window' +window = $window[0] navigator = window.navigator -(($) -> +(($, window) -> getPasteEvent = -> el = document.createElement 'input' name = 'onpaste' @@ -304,4 +305,4 @@ navigator = window.navigator ), 0 checkVal() #Perform initial check for existing values -) jQuery \ No newline at end of file +) jQuery, window \ No newline at end of file From 463681ef8d3acf3710a6ce41040d561f88b17e29 Mon Sep 17 00:00:00 2001 From: Cary Landholt Date: Sat, 12 Jan 2013 21:03:11 -0600 Subject: [PATCH 14/15] jquery is no longer a dependency; however, it doesn't work without it - ugh --- src/index.html | 2 - src/scripts/jquery.maskedinput.coffee | 308 -------------------------- src/scripts/mask.coffee | 308 +++++++++++++++++++++++++- 3 files changed, 305 insertions(+), 313 deletions(-) delete mode 100644 src/scripts/jquery.maskedinput.coffee diff --git a/src/index.html b/src/index.html index 699ba21..068173e 100644 --- a/src/index.html +++ b/src/index.html @@ -8,8 +8,6 @@ - - diff --git a/src/scripts/jquery.maskedinput.coffee b/src/scripts/jquery.maskedinput.coffee deleted file mode 100644 index 4b188ab..0000000 --- a/src/scripts/jquery.maskedinput.coffee +++ /dev/null @@ -1,308 +0,0 @@ -# -# Masked Input plugin for jQuery -# Copyright (c) 2007-@Year Josh Bush (digitalbush.com) -# Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) -# Version: @version -# -$injector = angular.injector ['ng'] -$timeout = $injector.get '$timeout' -$document = $injector.get '$document' -document = $document[0] -$window = $injector.get '$window' -window = $window[0] -navigator = window.navigator - -(($, window) -> - getPasteEvent = -> - el = document.createElement 'input' - name = 'onpaste' - el.setAttribute name, '' - (if (typeof el[name] is 'function') then 'paste' else 'input') - - pasteEventName = getPasteEvent() - ua = navigator.userAgent - iPhone = /iphone/i.test ua - android = /android/i.test ua - caretTimeoutId = undefined - - definitions = - 9: '[0-9]' - a: '[A-Za-z]' - '*': '[A-Za-z0-9]' - - dataName = 'rawMaskFn' - placeholder = '_' - - caret = ($input, begin, end) -> - range = undefined - - return if $input.length is 0 #or $input.is(':hidden') - - if typeof begin is 'number' - end = (if (typeof end is 'number') then end else begin) - - angular.forEach $input, (input) -> - if input.setSelectionRange - input.setSelectionRange begin, end - else if input.createTextRange - range = input.createTextRange() - range.collapse true - range.moveEnd 'character', end - range.moveStart 'character', begin - range.select() - else - if $input[0].setSelectionRange - begin = $input[0].selectionStart - end = $input[0].selectionEnd - else if document.selection and document.selection.createRange - range = document.selection.createRange() - begin = 0 - range.duplicate().moveStart 'character', -100000 - end = begin + range.text.length - - begin: begin - end: end - - $.fn.extend mask: (mask) -> - $input = undefined - defs = undefined - tests = undefined - partialPosition = undefined - firstNonMaskPos = undefined - len = undefined - - if not mask and @length > 0 - $input = angular.element this[0] - - return $input.data(dataName)() - - completed = null - - defs = definitions - tests = [] - partialPosition = len = mask.length - firstNonMaskPos = null - - angular.forEach mask.split(''), (c, i) -> - if c is '?' - len-- - - partialPosition = i - else if defs[c] - tests.push new RegExp defs[c] - - firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null - else - tests.push null - - angular.forEach this, (input) -> - seekNext = (pos) -> - continue while ++pos < len and not tests[pos] - - pos - seekPrev = (pos) -> - continue while --pos >= 0 and not tests[pos] - - pos - shiftL = (begin, end) -> - i = undefined - j = undefined - - return if begin < 0 - - i = begin - j = seekNext(end) - - while i < len - if tests[i] - if j < len and tests[i].test buffer[j] - buffer[i] = buffer[j] - buffer[j] = placeholder - else - break - - j = seekNext(j) - - i++ - - writeBuffer() - caret $input, Math.max firstNonMaskPos, begin - shiftR = (pos) -> - i = undefined - c = undefined - j = undefined - t = undefined - i = pos - c = placeholder - - while i < len - if tests[i] - j = seekNext(i) - t = buffer[i] - buffer[i] = c - - if j < len and tests[j].test t - c = t - else - break - - i++ - keydownEvent = (e) -> - k = e.which - pos = undefined - begin = undefined - end = undefined - - #backspace, delete, and escape get special treatment - if k is 8 or k is 46 or (iPhone and k is 127) - pos = caret($input) - begin = pos.begin - end = pos.end - - if end - begin is 0 - begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) - end = (if k is 46 then seekNext(end) else end) - - clearBuffer begin, end - shiftL begin, end - 1 - - false - else if k is 27 #escape - $input.val focusText - caret $input, 0, checkVal() - - false - keypressEvent = (e) -> - k = e.which - pos = caret($input) - p = undefined - c = undefined - next = undefined - - if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore - true - else if k - if pos.end - pos.begin isnt 0 - clearBuffer pos.begin, pos.end - shiftL pos.begin, pos.end - 1 - - p = seekNext pos.begin - 1 - - if p < len - c = String.fromCharCode k - - if tests[p].test c - shiftR p - - buffer[p] = c - - writeBuffer() - - next = seekNext p - - if android - # Commented out the next line. Need a substitute for proxy. - # $timeout($.proxy(caret, $input, next), 0); - caret $input, next - else - caret $input, next - - completed.call $input if completed and next >= len - - false - clearBuffer = (start, end) -> - i = undefined - i = start - - while i < end and i < len - buffer[i] = placeholder if tests[i] - - i++ - writeBuffer = -> - $input.val buffer.join '' - checkVal = (allow) -> - #try to place characters where they belong - test = $input.val() - lastMatch = -1 - i = undefined - c = undefined - i = 0 - pos = 0 - - while i < len - if tests[i] - buffer[i] = placeholder - - while pos++ < test.length - c = test.charAt pos - 1 - - if tests[i].test c - buffer[i] = c - lastMatch = i - - break - - break if pos > test.length - else if buffer[i] is test.charAt(pos) and i isnt partialPosition - pos++ - - lastMatch = i - - i++ - if allow - writeBuffer() - else if lastMatch + 1 < partialPosition - $input.val '' - clearBuffer 0, len - else - writeBuffer() - $input.val $input.val().substring 0, lastMatch + 1 - - (if partialPosition then i else firstNonMaskPos) - - $input = angular.element(input) - buffer = [] - focusText = $input.val() - - angular.forEach mask.split(''), (c, i) -> - if c isnt '?' - val = (if defs[c] then placeholder else c) - - buffer.push val if val isnt null - - $input.data dataName, -> - arr = [] - - angular.forEach buffer, (c, i) -> - arr.push c if tests[i] and c isnt placeholder - - arr.join '' - - unless $input.attr 'readonly' - $input.bind('focus', -> - $timeout.cancel caretTimeoutId - - pos = undefined - moveCaret = undefined - focusText = $input.val() - pos = checkVal() - - caretTimeoutId = $timeout(-> - writeBuffer() - - if pos is mask.length - caret $input, 0, pos - else - caret $input, pos - , 10) - ).bind('blur', -> - checkVal() - $input.change() if $input.val() isnt focusText - ).bind('keydown', keydownEvent).bind('keypress', keypressEvent).bind pasteEventName, -> - $timeout (-> - pos = checkVal(true) - caret $input, pos - completed.call $input if completed and pos is $input.val().length - ), 0 - - checkVal() #Perform initial check for existing values -) jQuery, window \ No newline at end of file diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee index 3bcd288..b503c88 100644 --- a/src/scripts/mask.coffee +++ b/src/scripts/mask.coffee @@ -1,10 +1,311 @@ -app.directive 'appMask', ['$log', ($log) -> +app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $timeout, $document, $window) -> + document = $document[0] + navigator = $window.navigator + + getPasteEvent = -> + el = document.createElement 'input' + name = 'onpaste' + el.setAttribute name, '' + (if (typeof el[name] is 'function') then 'paste' else 'input') + + pasteEventName = getPasteEvent() + ua = navigator.userAgent + iPhone = /iphone/i.test ua + android = /android/i.test ua + dataName = 'rawMaskFn' + placeholder = '_' + + definitions = + 9: '[0-9]' + a: '[A-Za-z]' + '*': '[A-Za-z0-9]' + + caret = ($input, begin, end) -> + range = undefined + + return if $input.length is 0 #or $input.is(':hidden') + + input = $input[0] + + if typeof begin is 'number' + end = (if (typeof end is 'number') then end else begin) + + # angular.forEach $input, (input) -> + if input.setSelectionRange + input.setSelectionRange begin, end + else if input.createTextRange + range = input.createTextRange() + range.collapse true + range.moveEnd 'character', end + range.moveStart 'character', begin + range.select() + else + if input.setSelectionRange + begin = input.selectionStart + end = input.selectionEnd + else if document.selection and document.selection.createRange + range = document.selection.createRange() + begin = 0 - range.duplicate().moveStart 'character', -100000 + end = begin + range.text.length + + begin: begin + end: end + link = ($scope, element, attrs, controller) -> + caretTimeoutId = undefined + + # $.fn.extend mask: (mask) -> + mask = ($input, mask) -> + # $input = undefined + defs = undefined + tests = undefined + partialPosition = undefined + firstNonMaskPos = undefined + len = undefined + + if not mask and @length > 0 + # $input = angular.element this[0] + + return $input.data(dataName)() + + completed = null + + defs = definitions + tests = [] + partialPosition = len = mask.length + firstNonMaskPos = null + + angular.forEach mask.split(''), (c, i) -> + if c is '?' + len-- + + partialPosition = i + else if defs[c] + tests.push new RegExp defs[c] + + firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null + else + tests.push null + + # angular.forEach this, (input) -> + seekNext = (pos) -> + continue while ++pos < len and not tests[pos] + + pos + seekPrev = (pos) -> + continue while --pos >= 0 and not tests[pos] + + pos + shiftL = (begin, end) -> + i = undefined + j = undefined + + return if begin < 0 + + i = begin + j = seekNext(end) + + while i < len + if tests[i] + if j < len and tests[i].test buffer[j] + buffer[i] = buffer[j] + buffer[j] = placeholder + else + break + + j = seekNext(j) + + i++ + + writeBuffer() + caret $input, Math.max firstNonMaskPos, begin + shiftR = (pos) -> + i = undefined + c = undefined + j = undefined + t = undefined + i = pos + c = placeholder + + while i < len + if tests[i] + j = seekNext(i) + t = buffer[i] + buffer[i] = c + + if j < len and tests[j].test t + c = t + else + break + + i++ + keydownEvent = (e) -> + k = e.which + pos = undefined + begin = undefined + end = undefined + + #backspace, delete, and escape get special treatment + if k is 8 or k is 46 or (iPhone and k is 127) + pos = caret($input) + begin = pos.begin + end = pos.end + + if end - begin is 0 + begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) + end = (if k is 46 then seekNext(end) else end) + + clearBuffer begin, end + shiftL begin, end - 1 + + false + else if k is 27 #escape + $input.val focusText + caret $input, 0, checkVal() + + false + keypressEvent = (e) -> + k = e.which + pos = caret($input) + p = undefined + c = undefined + next = undefined + + if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore + true + else if k + if pos.end - pos.begin isnt 0 + clearBuffer pos.begin, pos.end + shiftL pos.begin, pos.end - 1 + + p = seekNext pos.begin - 1 + + if p < len + c = String.fromCharCode k + + if tests[p].test c + shiftR p + + buffer[p] = c + + writeBuffer() + + next = seekNext p + + if android + # Commented out the next line. Need a substitute for proxy. + # $timeout($.proxy(caret, $input, next), 0); + caret $input, next + else + caret $input, next + + completed.call $input if completed and next >= len + + false + clearBuffer = (start, end) -> + i = undefined + i = start + + while i < end and i < len + buffer[i] = placeholder if tests[i] + + i++ + writeBuffer = -> + $input.val buffer.join '' + checkVal = (allow) -> + #try to place characters where they belong + test = $input.val() + lastMatch = -1 + i = undefined + c = undefined + i = 0 + pos = 0 + + while i < len + if tests[i] + buffer[i] = placeholder + + while pos++ < test.length + c = test.charAt pos - 1 + + if tests[i].test c + buffer[i] = c + lastMatch = i + + break + + break if pos > test.length + else if buffer[i] is test.charAt(pos) and i isnt partialPosition + pos++ + + lastMatch = i + + i++ + + if allow + writeBuffer() + else if lastMatch + 1 < partialPosition + $input.val '' + clearBuffer 0, len + else + writeBuffer() + $input.val $input.val().substring 0, lastMatch + 1 + + (if partialPosition then i else firstNonMaskPos) + + # $input = angular.element(input) + buffer = [] + focusText = $input.val() + + angular.forEach mask.split(''), (c, i) -> + if c isnt '?' + val = (if defs[c] then placeholder else c) + + buffer.push val if val isnt null + + $input.data dataName, -> + arr = [] + + angular.forEach buffer, (c, i) -> + arr.push c if tests[i] and c isnt placeholder + + arr.join '' + + unless $input.attr 'readonly' + $input.bind('focus', -> + $timeout.cancel caretTimeoutId + + pos = undefined + moveCaret = undefined + focusText = $input.val() + pos = checkVal() + + caretTimeoutId = $timeout(-> + writeBuffer() + + if pos is mask.length + caret $input, 0, pos + else + caret $input, pos + , 10) + ).bind('blur', -> + checkVal() + $input.change() if $input.val() isnt focusText + ).bind('keydown', keydownEvent).bind('keypress', keypressEvent).bind pasteEventName, -> + $timeout (-> + pos = checkVal(true) + caret $input, pos + completed.call $input if completed and pos is $input.val().length + ), 0 + + checkVal() #Perform initial check for existing values + # We override the render method to run the jQuery mask plugin controller.$render = -> value = controller.$viewValue or '' element.val value - element.mask $scope.$eval attrs.appMask + # element.mask $scope.$eval attrs.appMask + mask element, $scope.$eval attrs.appMask # Add a parser that extracts the masked value into the model but only if the mask is valid controller.$parsers.push (value) -> @@ -19,7 +320,8 @@ app.directive 'appMask', ['$log', ($log) -> # When keyup, update the view value element.bind 'keyup', -> $scope.$apply -> - controller.$setViewValue element.mask() + # controller.$setViewValue element.mask() + # controller.$setViewValue mask element link: link require: 'ngModel' From ede81bf5ed02a06bdb3d10be4da93ea226f27c38 Mon Sep 17 00:00:00 2001 From: Maks Makarevich Date: Sun, 20 Jan 2013 19:54:11 -0600 Subject: [PATCH 15/15] Angularized mask. Not tested in IE7' --- src/index.html | 8 +- src/scripts/app.coffee | 2 + src/scripts/mask.coffee | 136 +++++++++------ src/scripts/maska.coffee | 356 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 446 insertions(+), 56 deletions(-) create mode 100644 src/scripts/maska.coffee diff --git a/src/index.html b/src/index.html index 068173e..824db7a 100644 --- a/src/index.html +++ b/src/index.html @@ -6,7 +6,7 @@ - + @@ -15,6 +15,12 @@

Phone Number + Model:{{phoneNumber}} + + Date + + Model:{{theDate}} +

\ No newline at end of file diff --git a/src/scripts/app.coffee b/src/scripts/app.coffee index 49febc1..770385e 100644 --- a/src/scripts/app.coffee +++ b/src/scripts/app.coffee @@ -2,4 +2,6 @@ app = angular.module('app', []) app.controller 'myController', ['$scope', ($scope) -> $scope.name = 'Cary' + $scope.phoneNumber = '8472083404' + $scope.theDate = '01/01/2013' ] \ No newline at end of file diff --git a/src/scripts/mask.coffee b/src/scripts/mask.coffee index b503c88..9515030 100644 --- a/src/scripts/mask.coffee +++ b/src/scripts/mask.coffee @@ -22,15 +22,12 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti caret = ($input, begin, end) -> range = undefined - return if $input.length is 0 #or $input.is(':hidden') - input = $input[0] if typeof begin is 'number' end = (if (typeof end is 'number') then end else begin) - # angular.forEach $input, (input) -> if input.setSelectionRange input.setSelectionRange begin, end else if input.createTextRange @@ -52,11 +49,20 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti end: end link = ($scope, element, attrs, controller) -> + controller.$render = -> + + $scope.$watch 'ngModel', (newValue, oldValue) -> + console.log 'WATCH:', newValue, oldValue + caretTimeoutId = undefined + maskedString = '' + + mask = ($input, mask, initValue) -> + $input.val initValue + + isInit = true + theMask = mask - # $.fn.extend mask: (mask) -> - mask = ($input, mask) -> - # $input = undefined defs = undefined tests = undefined partialPosition = undefined @@ -64,12 +70,9 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti len = undefined if not mask and @length > 0 - # $input = angular.element this[0] - return $input.data(dataName)() completed = null - defs = definitions tests = [] partialPosition = len = mask.length @@ -78,33 +81,28 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti angular.forEach mask.split(''), (c, i) -> if c is '?' len-- - partialPosition = i else if defs[c] tests.push new RegExp defs[c] - firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null else tests.push null - # angular.forEach this, (input) -> seekNext = (pos) -> continue while ++pos < len and not tests[pos] - pos + seekPrev = (pos) -> continue while --pos >= 0 and not tests[pos] - pos - shiftL = (begin, end) -> - i = undefined - j = undefined + shiftL = (begin, end) -> return if begin < 0 i = begin j = seekNext(end) + console.log 'shiftL', ', ',i, ', ', j while i < len if tests[i] if j < len and tests[i].test buffer[j] @@ -119,6 +117,8 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti writeBuffer() caret $input, Math.max firstNonMaskPos, begin + console.log 'change valkkkk', $input.val() + shiftR = (pos) -> i = undefined c = undefined @@ -137,10 +137,11 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti c = t else break - i++ + keydownEvent = (e) -> - k = e.which + k = e.which || e.keyCode + #k = e.keyCode pos = undefined begin = undefined end = undefined @@ -157,23 +158,34 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti clearBuffer begin, end shiftL begin, end - 1 + console.log 'keyDown1', ', ',begin, ', ', end, buffer + e.preventDefault?() + e.cancelBubble = true false else if k is 27 #escape $input.val focusText caret $input, 0, checkVal() - + console.log 'keyDown2' + e.preventDefault?() + e.cancelBubble = true false + keypressEvent = (e) -> - k = e.which + k = e.which || e.keyCode + #k = e.keyCode pos = caret($input) p = undefined c = undefined next = undefined if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore + console.log 'val: ', $input.val() + console.log 'keyPress1' true + else if k + console.log 'keyPress2' if pos.end - pos.begin isnt 0 clearBuffer pos.begin, pos.end shiftL pos.begin, pos.end - 1 @@ -188,6 +200,7 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti buffer[p] = c + console.log 'b4writeBuffer4' writeBuffer() next = seekNext p @@ -201,17 +214,39 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti completed.call $input if completed and next >= len + e.preventDefault?() + e.cancelBubble = true + console.log 'canceled bublee' false + clearBuffer = (start, end) -> i = undefined i = start while i < end and i < len buffer[i] = placeholder if tests[i] - i++ + writeBuffer = -> + console.log 'writeBuffer: ', buffer.join '' $input.val buffer.join '' + + # mm: Notify Angular + console.log 'Notify Angular : ', $input.val(), $scope.ngModel + + console.log 'APPLY33', isInit + if isInit + isInit = false + console.log 'APPLY22', $input.val() + else + $scope.$apply -> + console.log 'APPLY' + val = $input.val() + if val is maskedString + $scope.ngModel = '' + else + $scope.ngModel = val + checkVal = (allow) -> #try to place characters where they belong test = $input.val() @@ -231,44 +266,46 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti if tests[i].test c buffer[i] = c lastMatch = i - break - break if pos > test.length else if buffer[i] is test.charAt(pos) and i isnt partialPosition pos++ - lastMatch = i i++ if allow + console.log 'b4writeBuffer1_checkVal' writeBuffer() else if lastMatch + 1 < partialPosition - $input.val '' clearBuffer 0, len + writeBuffer() + $input.val '' + console.log 'checkVal_EMPTY2', ',', $input.val() else + console.log 'b4writeBuffer2_checkVal' + $scope.ngModel = $input.val() writeBuffer() $input.val $input.val().substring 0, lastMatch + 1 (if partialPosition then i else firstNonMaskPos) - # $input = angular.element(input) buffer = [] focusText = $input.val() - angular.forEach mask.split(''), (c, i) -> if c isnt '?' val = (if defs[c] then placeholder else c) - buffer.push val if val isnt null + # MM added line to define the blank masked input + maskedString = buffer.join '' + console.log 'MASKED STRING', maskedString + $input.data dataName, -> + console.log 'data-update' arr = [] - angular.forEach buffer, (c, i) -> arr.push c if tests[i] and c isnt placeholder - arr.join '' unless $input.attr 'readonly' @@ -281,6 +318,7 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti pos = checkVal() caretTimeoutId = $timeout(-> + console.log 'b4writeBuffer3_focus' writeBuffer() if pos is mask.length @@ -288,41 +326,29 @@ app.directive 'appMask', ['$log', '$timeout', '$document', '$window', ($log, $ti else caret $input, pos , 10) - ).bind('blur', -> + ).bind('blur', (e) -> + console.log 'BlurEventStart:', $scope.ngModel checkVal() - $input.change() if $input.val() isnt focusText + console.log 'BlurEvent:', $scope.ngModel , $input.val() + $input.change() if $input.change and $input.val() isnt focusText ).bind('keydown', keydownEvent).bind('keypress', keypressEvent).bind pasteEventName, -> $timeout (-> + console.log 'pasteEventName:', $input.val() pos = checkVal(true) caret $input, pos completed.call $input if completed and pos is $input.val().length ), 0 + #$input[0].attachEvent 'onkeypress', keypressEvent + #$input[0].attachEvent 'onkeydown', keydownEvent + checkVal() #Perform initial check for existing values - # We override the render method to run the jQuery mask plugin - controller.$render = -> - value = controller.$viewValue or '' - element.val value - # element.mask $scope.$eval attrs.appMask - mask element, $scope.$eval attrs.appMask - - # Add a parser that extracts the masked value into the model but only if the mask is valid - controller.$parsers.push (value) -> - #the second check (or) is only needed due to the fact that element.isMaskValid() will keep returning undefined - #until there was at least one key event - # isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 - # controller.$setValidity 'mask', isValid - # (if isValid then value else undefined) - - value - - # When keyup, update the view value - element.bind 'keyup', -> - $scope.$apply -> - # controller.$setViewValue element.mask() - # controller.$setViewValue mask element + mask element, $scope.$eval(attrs.appMask), $scope.ngModel + $scope.ngModel = element.val() link: link require: 'ngModel' + scope: + ngModel: '=' ] \ No newline at end of file diff --git a/src/scripts/maska.coffee b/src/scripts/maska.coffee new file mode 100644 index 0000000..a43b3c4 --- /dev/null +++ b/src/scripts/maska.coffee @@ -0,0 +1,356 @@ +app.directive 'appMaska', ['$log', '$timeout', '$document', '$window', ($log, $timeout, $document, $window) -> + document = $document[0] + navigator = $window.navigator + + getPasteEvent = -> + el = document.createElement 'input' + name = 'onpaste' + el.setAttribute name, '' + (if (typeof el[name] is 'function') then 'paste' else 'input') + + pasteEventName = getPasteEvent() + ua = navigator.userAgent + iPhone = /iphone/i.test ua + android = /android/i.test ua + dataName = 'rawMaskFn' + placeholder = '_' + + definitions = + 9: '[0-9]' + a: '[A-Za-z]' + '*': '[A-Za-z0-9]' + + caret = ($input, begin, end) -> + range = undefined + + return if $input.length is 0 #or $input.is(':hidden') + + input = $input[0] + + if typeof begin is 'number' + end = (if (typeof end is 'number') then end else begin) + + # angular.forEach $input, (input) -> + if input.setSelectionRange + input.setSelectionRange begin, end + else if input.createTextRange + range = input.createTextRange() + range.collapse true + range.moveEnd 'character', end + range.moveStart 'character', begin + range.select() + else + console.log 'vvvvval:', $input.val() + if input.setSelectionRange + begin = input.selectionStart + end = input.selectionEnd + else if document.selection and document.selection.createRange + range = document.selection.createRange() + begin = 0 - range.duplicate().moveStart 'character', -100000 + end = begin + range.text.length + + begin: begin + end: end + + link = ($scope, element, attrs, controller) -> + caretTimeoutId = undefined + + # $.fn.extend mask: (mask) -> + mask = ($input, mask) -> + # $input = undefined + defs = undefined + tests = undefined + partialPosition = undefined + firstNonMaskPos = undefined + len = undefined + + if not mask and @length > 0 + # $input = angular.element this[0] + + return $input.data(dataName)() + + completed = null + + defs = definitions + tests = [] + partialPosition = len = mask.length + firstNonMaskPos = null + + angular.forEach mask.split(''), (c, i) -> + if c is '?' + len-- + + partialPosition = i + else if defs[c] + tests.push new RegExp defs[c] + + firstNonMaskPos = tests.length - 1 if firstNonMaskPos is null + else + tests.push null + + # angular.forEach this, (input) -> + seekNext = (pos) -> + continue while ++pos < len and not tests[pos] + + pos + seekPrev = (pos) -> + continue while --pos >= 0 and not tests[pos] + + pos + shiftL = (begin, end) -> + i = undefined + j = undefined + + return if begin < 0 + + i = begin + j = seekNext(end) + + console.log 'shiftL', ', ',i, ', ', j + while i < len + if tests[i] + if j < len and tests[i].test buffer[j] + buffer[i] = buffer[j] + buffer[j] = placeholder + else + break + + j = seekNext(j) + + i++ + + writeBuffer() + caret $input, Math.max firstNonMaskPos, begin + console.log 'change valkkkk', $input.val() + shiftR = (pos) -> + i = undefined + c = undefined + j = undefined + t = undefined + i = pos + c = placeholder + + while i < len + if tests[i] + j = seekNext(i) + t = buffer[i] + buffer[i] = c + + if j < len and tests[j].test t + c = t + else + break + + i++ + keydownEvent = (e) -> + #k = e.which + k = e.keyCode + pos = undefined + begin = undefined + end = undefined + + #backspace, delete, and escape get special treatment + if k is 8 or k is 46 or (iPhone and k is 127) + pos = caret($input) + begin = pos.begin + end = pos.end + + if end - begin is 0 + begin = (if k isnt 46 then seekPrev(begin) else (end = seekNext(begin - 1))) + end = (if k is 46 then seekNext(end) else end) + + clearBuffer begin, end + shiftL begin, end - 1 + console.log 'keyDown1', ', ',begin, ', ', end, buffer + + e.preventDefault?() + e.cancelBubble = true + false + else if k is 27 #escape + $input.val focusText + caret $input, 0, checkVal() + console.log 'keyDown2' + e.preventDefault?() + e.cancelBubble = true + false + keypressEvent = (e) -> + #k = e.which + k = e.keyCode + pos = caret($input) + p = undefined + c = undefined + next = undefined + + if e.ctrlKey or e.altKey or e.metaKey or k < 32 #Ignore + console.log 'val: ', $input.val() + console.log 'keyPress1' + true + else if k + + console.log 'keyPress2' + if pos.end - pos.begin isnt 0 + clearBuffer pos.begin, pos.end + shiftL pos.begin, pos.end - 1 + + p = seekNext pos.begin - 1 + + if p < len + c = String.fromCharCode k + + if tests[p].test c + shiftR p + + buffer[p] = c + + console.log 'b4writeBuffer4' + writeBuffer() + + next = seekNext p + + if android + # Commented out the next line. Need a substitute for proxy. + # $timeout($.proxy(caret, $input, next), 0); + caret $input, next + else + caret $input, next + + completed.call $input if completed and next >= len + + e.preventDefault?() + e.cancelBubble = true + false + clearBuffer = (start, end) -> + i = undefined + i = start + + while i < end and i < len + buffer[i] = placeholder if tests[i] + + i++ + writeBuffer = -> + console.log 'writeBuffer: ', buffer.join '' + $input.val buffer.join '' + checkVal = (allow) -> + #try to place characters where they belong + test = $input.val() + lastMatch = -1 + i = undefined + c = undefined + i = 0 + pos = 0 + + while i < len + if tests[i] + buffer[i] = placeholder + + while pos++ < test.length + c = test.charAt pos - 1 + + if tests[i].test c + buffer[i] = c + lastMatch = i + + break + + break if pos > test.length + else if buffer[i] is test.charAt(pos) and i isnt partialPosition + pos++ + + lastMatch = i + + i++ + + if allow + console.log 'b4writeBuffer1' + writeBuffer() + else if lastMatch + 1 < partialPosition + $input.val '' + clearBuffer 0, len + else + console.log 'b4writeBuffer2' + writeBuffer() + $input.val $input.val().substring 0, lastMatch + 1 + + (if partialPosition then i else firstNonMaskPos) + + # $input = angular.element(input) + buffer = [] + focusText = $input.val() + + angular.forEach mask.split(''), (c, i) -> + if c isnt '?' + val = (if defs[c] then placeholder else c) + + buffer.push val if val isnt null + + $input.data dataName, -> + console.log 'data-update' + arr = [] + + angular.forEach buffer, (c, i) -> + arr.push c if tests[i] and c isnt placeholder + + arr.join '' + + unless $input.attr 'readonly' + $input.bind('focus', -> + $timeout.cancel caretTimeoutId + + pos = undefined + moveCaret = undefined + focusText = $input.val() + pos = checkVal() + + caretTimeoutId = $timeout(-> + console.log 'b4writeBuffer3' + writeBuffer() + + if pos is mask.length + caret $input, 0, pos + else + caret $input, pos + , 10) + ).bind('blur', -> + checkVal() + $input.change() if $input.change and $input.val() isnt focusText + ).bind('keydown', keydownEvent).bind('keypress', keypressEvent).bind 'keyupp', -> + $timeout (-> + console.log 'input' + pos = checkVal(true) + caret $input, pos + completed.call $input if completed and pos is $input.val().length + ), 0 + + $input[0].attachEvent 'onkeypress', keypressEvent + #$input[0].attachEvent 'onkeydown', keydownEvent + + checkVal() #Perform initial check for existing values + + # We override the render method to run the jQuery mask plugin + controller.$render = -> + value = controller.$viewValue or '' + console.log 'render...' + element.val value + # element.mask $scope.$eval attrs.appMask + mask element, $scope.$eval attrs.appMask + + # Add a parser that extracts the masked value into the model but only if the mask is valid + controller.$parsers.push (value) -> + #the second check (or) is only needed due to the fact that element.isMaskValid() will keep returning undefined + #until there was at least one key event + # isValid = element.isMaskValid() or angular.isUndefined(element.isMaskValid()) and element.val().length > 0 + # controller.$setValidity 'mask', isValid + # (if isValid then value else undefined) + + value + + # When keyup, update the view value + element.bind 'keyup', -> + console.log 'keyup:', element[0].value + $scope.$apply -> + # controller.$setViewValue element.mask() + # controller.$setViewValue mask element + + link: link + require: 'ngModel' +] \ No newline at end of file