Gary Sharp
599 lines
20 KiB
JavaScript
599 lines
20 KiB
JavaScript
/*
|
|
Watermark plugin for jQuery
|
|
Version: 3.1.4
|
|
http://jquery-watermark.googlecode.com/
|
|
|
|
Copyright (c) 2009-2012 Todd Northrop
|
|
http://www.speednet.biz/
|
|
|
|
August 13, 2012
|
|
|
|
Requires: jQuery 1.2.3+
|
|
|
|
Dual licensed under the MIT or GPL Version 2 licenses.
|
|
See mit-license.txt and gpl2-license.txt in the project root for details.
|
|
------------------------------------------------------*/
|
|
|
|
( function ( $, window, undefined ) {
|
|
|
|
var
|
|
// String constants for data names
|
|
dataFlag = "watermark",
|
|
dataClass = "watermarkClass",
|
|
dataFocus = "watermarkFocus",
|
|
dataFormSubmit = "watermarkSubmit",
|
|
dataMaxLen = "watermarkMaxLength",
|
|
dataPassword = "watermarkPassword",
|
|
dataText = "watermarkText",
|
|
|
|
// Copy of native jQuery regex use to strip return characters from element value
|
|
rreturn = /\r/g,
|
|
|
|
// Used to determine if type attribute of input element is a non-text type (invalid)
|
|
rInvalidType = /^(button|checkbox|hidden|image|radio|range|reset|submit)$/i,
|
|
|
|
// Includes only elements with watermark defined
|
|
selWatermarkDefined = "input:data(" + dataFlag + "),textarea:data(" + dataFlag + ")",
|
|
|
|
// Includes only elements capable of having watermark
|
|
selWatermarkAble = ":watermarkable",
|
|
|
|
// triggerFns:
|
|
// Array of function names to look for in the global namespace.
|
|
// Any such functions found will be hijacked to trigger a call to
|
|
// hideAll() any time they are called. The default value is the
|
|
// ASP.NET function that validates the controls on the page
|
|
// prior to a postback.
|
|
//
|
|
// Am I missing other important trigger function(s) to look for?
|
|
// Please leave me feedback:
|
|
// http://code.google.com/p/jquery-watermark/issues/list
|
|
triggerFns = [
|
|
"Page_ClientValidate"
|
|
],
|
|
|
|
// Holds a value of true if a watermark was displayed since the last
|
|
// hideAll() was executed. Avoids repeatedly calling hideAll().
|
|
pageDirty = false,
|
|
|
|
// Detects if the browser can handle native placeholders
|
|
hasNativePlaceholder = ( "placeholder" in document.createElement( "input" ) );
|
|
|
|
// Best practice: this plugin adds only one method to the jQuery object.
|
|
// Also ensures that the watermark code is only added once.
|
|
$.watermark = $.watermark || {
|
|
|
|
// Current version number of the plugin
|
|
version: "3.1.4",
|
|
|
|
runOnce: true,
|
|
|
|
// Default options used when watermarks are instantiated.
|
|
// Can be changed to affect the default behavior for all
|
|
// new or updated watermarks.
|
|
options: {
|
|
|
|
// Default class name for all watermarks
|
|
className: "watermark",
|
|
|
|
// If true, plugin will detect and use native browser support for
|
|
// watermarks, if available. (e.g., WebKit's placeholder attribute.)
|
|
useNative: true,
|
|
|
|
// If true, all watermarks will be hidden during the window's
|
|
// beforeunload event. This is done mainly because WebKit
|
|
// browsers remember the watermark text during navigation
|
|
// and try to restore the watermark text after the user clicks
|
|
// the Back button. We can avoid this by hiding the text before
|
|
// the browser has a chance to save it. The regular unload event
|
|
// was tried, but it seems the browser saves the text before
|
|
// that event kicks off, because it didn't work.
|
|
hideBeforeUnload: true
|
|
},
|
|
|
|
// Hide one or more watermarks by specifying any selector type
|
|
// i.e., DOM element, string selector, jQuery matched set, etc.
|
|
hide: function ( selector ) {
|
|
$( selector ).filter( selWatermarkDefined ).each(
|
|
function () {
|
|
$.watermark._hide( $( this ) );
|
|
}
|
|
);
|
|
},
|
|
|
|
// Internal use only.
|
|
_hide: function ( $input, focus ) {
|
|
var elem = $input[ 0 ],
|
|
inputVal = ( elem.value || "" ).replace( rreturn, "" ),
|
|
inputWm = $input.data( dataText ) || "",
|
|
maxLen = $input.data( dataMaxLen ) || 0,
|
|
className = $input.data( dataClass );
|
|
|
|
if ( ( inputWm.length ) && ( inputVal == inputWm ) ) {
|
|
elem.value = "";
|
|
|
|
// Password type?
|
|
if ( $input.data( dataPassword ) ) {
|
|
|
|
if ( ( $input.attr( "type" ) || "" ) === "text" ) {
|
|
var $pwd = $input.data( dataPassword ) || [],
|
|
$wrap = $input.parent() || [];
|
|
|
|
if ( ( $pwd.length ) && ( $wrap.length ) ) {
|
|
$wrap[ 0 ].removeChild( $input[ 0 ] ); // Can't use jQuery methods, because they destroy data
|
|
$wrap[ 0 ].appendChild( $pwd[ 0 ] );
|
|
$input = $pwd;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( maxLen ) {
|
|
$input.attr( "maxLength", maxLen );
|
|
$input.removeData( dataMaxLen );
|
|
}
|
|
|
|
if ( focus ) {
|
|
$input.attr( "autocomplete", "off" ); // Avoid NS_ERROR_XPC_JS_THREW_STRING error in Firefox
|
|
|
|
window.setTimeout(
|
|
function () {
|
|
$input.select(); // Fix missing cursor in IE
|
|
}
|
|
, 1 );
|
|
}
|
|
}
|
|
|
|
className && $input.removeClass( className );
|
|
},
|
|
|
|
// Display one or more watermarks by specifying any selector type
|
|
// i.e., DOM element, string selector, jQuery matched set, etc.
|
|
// If conditions are not right for displaying a watermark, ensures that watermark is not shown.
|
|
show: function ( selector ) {
|
|
$( selector ).filter( selWatermarkDefined ).each(
|
|
function () {
|
|
$.watermark._show( $( this ) );
|
|
}
|
|
);
|
|
},
|
|
|
|
// Internal use only.
|
|
_show: function ( $input ) {
|
|
var elem = $input[ 0 ],
|
|
val = ( elem.value || "" ).replace( rreturn, "" ),
|
|
text = $input.data( dataText ) || "",
|
|
type = $input.attr( "type" ) || "",
|
|
className = $input.data( dataClass );
|
|
|
|
if ( ( ( val.length == 0 ) || ( val == text ) ) && ( !$input.data( dataFocus ) ) ) {
|
|
pageDirty = true;
|
|
|
|
// Password type?
|
|
if ( $input.data( dataPassword ) ) {
|
|
|
|
if ( type === "password" ) {
|
|
var $pwd = $input.data( dataPassword ) || [],
|
|
$wrap = $input.parent() || [];
|
|
|
|
if ( ( $pwd.length ) && ( $wrap.length ) ) {
|
|
$wrap[ 0 ].removeChild( $input[ 0 ] ); // Can't use jQuery methods, because they destroy data
|
|
$wrap[ 0 ].appendChild( $pwd[ 0 ] );
|
|
$input = $pwd;
|
|
$input.attr( "maxLength", text.length );
|
|
elem = $input[ 0 ];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ensure maxLength big enough to hold watermark (input of type="text" or type="search" only)
|
|
if ( ( type === "text" ) || ( type === "search" ) ) {
|
|
var maxLen = $input.attr( "maxLength" ) || 0;
|
|
|
|
if ( ( maxLen > 0 ) && ( text.length > maxLen ) ) {
|
|
$input.data( dataMaxLen, maxLen );
|
|
$input.attr( "maxLength", text.length );
|
|
}
|
|
}
|
|
|
|
className && $input.addClass( className );
|
|
elem.value = text;
|
|
}
|
|
else {
|
|
$.watermark._hide( $input );
|
|
}
|
|
},
|
|
|
|
// Hides all watermarks on the current page.
|
|
hideAll: function () {
|
|
if ( pageDirty ) {
|
|
$.watermark.hide( selWatermarkAble );
|
|
pageDirty = false;
|
|
}
|
|
},
|
|
|
|
// Displays all watermarks on the current page.
|
|
showAll: function () {
|
|
$.watermark.show( selWatermarkAble );
|
|
}
|
|
};
|
|
|
|
$.fn.watermark = $.fn.watermark || function ( text, options ) {
|
|
/// <summary>
|
|
/// Set watermark text and class name on all input elements of type="text/password/search" and
|
|
/// textareas within the matched set. If className is not specified in options, the default is
|
|
/// "watermark". Within the matched set, only input elements with type="text/password/search"
|
|
/// and textareas are affected; all other elements are ignored.
|
|
/// </summary>
|
|
/// <returns type="jQuery">
|
|
/// Returns the original jQuery matched set (not just the input and texarea elements).
|
|
/// </returns>
|
|
/// <param name="text" type="String">
|
|
/// Text to display as a watermark when the input or textarea element has an empty value and does not
|
|
/// have focus. The first time watermark() is called on an element, if this argument is empty (or not
|
|
/// a String type), then the watermark will have the net effect of only changing the class name when
|
|
/// the input or textarea element's value is empty and it does not have focus.
|
|
/// </param>
|
|
/// <param name="options" type="Object" optional="true">
|
|
/// Provides the ability to override the default watermark options ($.watermark.options). For backward
|
|
/// compatibility, if a string value is supplied, it is used as the class name that overrides the class
|
|
/// name in $.watermark.options.className. Properties include:
|
|
/// className: When the watermark is visible, the element will be styled using this class name.
|
|
/// useNative (Boolean or Function): Specifies if native browser support for watermarks will supersede
|
|
/// plugin functionality. If useNative is a function, the return value from the function will
|
|
/// determine if native support is used. The function is passed one argument -- a jQuery object
|
|
/// containing the element being tested as the only element in its matched set -- and the DOM
|
|
/// element being tested is the object on which the function is invoked (the value of "this").
|
|
/// </param>
|
|
/// <remarks>
|
|
/// The effect of changing the text and class name on an input element is called a watermark because
|
|
/// typically light gray text is used to provide a hint as to what type of input is required. However,
|
|
/// the appearance of the watermark can be something completely different: simply change the CSS style
|
|
/// pertaining to the supplied class name.
|
|
///
|
|
/// The first time watermark() is called on an element, the watermark text and class name are initialized,
|
|
/// and the focus and blur events are hooked in order to control the display of the watermark. Also, as
|
|
/// of version 3.0, drag and drop events are hooked to guard against dropped text being appended to the
|
|
/// watermark. If native watermark support is provided by the browser, it is detected and used, unless
|
|
/// the useNative option is set to false.
|
|
///
|
|
/// Subsequently, watermark() can be called again on an element in order to change the watermark text
|
|
/// and/or class name, and it can also be called without any arguments in order to refresh the display.
|
|
///
|
|
/// For example, after changing the value of the input or textarea element programmatically, watermark()
|
|
/// should be called without any arguments to refresh the display, because the change event is only
|
|
/// triggered by user actions, not by programmatic changes to an input or textarea element's value.
|
|
///
|
|
/// The one exception to programmatic updates is for password input elements: you are strongly cautioned
|
|
/// against changing the value of a password input element programmatically (after the page loads).
|
|
/// The reason is that some fairly hairy code is required behind the scenes to make the watermarks bypass
|
|
/// IE security and switch back and forth between clear text (for watermarks) and obscured text (for
|
|
/// passwords). It is *possible* to make programmatic changes, but it must be done in a certain way, and
|
|
/// overall it is not recommended.
|
|
/// </remarks>
|
|
|
|
if ( !this.length ) {
|
|
return this;
|
|
}
|
|
|
|
var hasClass = false,
|
|
hasText = ( typeof( text ) === "string" );
|
|
|
|
if ( hasText ) {
|
|
text = text.replace( rreturn, "" );
|
|
}
|
|
|
|
if ( typeof( options ) === "object" ) {
|
|
hasClass = ( typeof( options.className ) === "string" );
|
|
options = $.extend( {}, $.watermark.options, options );
|
|
}
|
|
else if ( typeof( options ) === "string" ) {
|
|
hasClass = true;
|
|
options = $.extend( {}, $.watermark.options, { className: options } );
|
|
}
|
|
else {
|
|
options = $.watermark.options;
|
|
}
|
|
|
|
if ( typeof( options.useNative ) !== "function" ) {
|
|
options.useNative = options.useNative? function () { return true; } : function () { return false; };
|
|
}
|
|
|
|
return this.each(
|
|
function () {
|
|
var $input = $( this );
|
|
|
|
if ( !$input.is( selWatermarkAble ) ) {
|
|
return;
|
|
}
|
|
|
|
// Watermark already initialized?
|
|
if ( $input.data( dataFlag ) ) {
|
|
|
|
// If re-defining text or class, first remove existing watermark, then make changes
|
|
if ( hasText || hasClass ) {
|
|
$.watermark._hide( $input );
|
|
|
|
if ( hasText ) {
|
|
$input.data( dataText, text );
|
|
}
|
|
|
|
if ( hasClass ) {
|
|
$input.data( dataClass, options.className );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
|
|
// Detect and use native browser support, if enabled in options
|
|
if (
|
|
( hasNativePlaceholder )
|
|
&& ( options.useNative.call( this, $input ) )
|
|
&& ( ( $input.attr( "tagName" ) || "" ) !== "TEXTAREA" )
|
|
) {
|
|
// className is not set because current placeholder standard doesn't
|
|
// have a separate class name property for placeholders (watermarks).
|
|
if ( hasText ) {
|
|
$input.attr( "placeholder", text );
|
|
}
|
|
|
|
// Only set data flag for non-native watermarks
|
|
// [purposely commented-out] -> $input.data(dataFlag, 1);
|
|
return;
|
|
}
|
|
|
|
$input.data( dataText, hasText? text : "" );
|
|
$input.data( dataClass, options.className );
|
|
$input.data( dataFlag, 1 ); // Flag indicates watermark was initialized
|
|
|
|
// Special processing for password type
|
|
if ( ( $input.attr( "type" ) || "" ) === "password" ) {
|
|
var $wrap = $input.wrap( "<span>" ).parent(),
|
|
$wm = $( $wrap.html().replace( /type=["']?password["']?/i, 'type="text"' ) );
|
|
|
|
$wm.data( dataText, $input.data( dataText ) );
|
|
$wm.data( dataClass, $input.data( dataClass ) );
|
|
$wm.data( dataFlag, 1 );
|
|
$wm.attr( "maxLength", text.length );
|
|
|
|
$wm.focus(
|
|
function () {
|
|
$.watermark._hide( $wm, true );
|
|
}
|
|
).bind( "dragenter",
|
|
function () {
|
|
$.watermark._hide( $wm );
|
|
}
|
|
).bind( "dragend",
|
|
function () {
|
|
window.setTimeout( function () { $wm.blur(); }, 1 );
|
|
}
|
|
);
|
|
|
|
$input.blur(
|
|
function () {
|
|
$.watermark._show( $input );
|
|
}
|
|
).bind( "dragleave",
|
|
function () {
|
|
$.watermark._show( $input );
|
|
}
|
|
);
|
|
|
|
$wm.data( dataPassword, $input );
|
|
$input.data( dataPassword, $wm );
|
|
}
|
|
else {
|
|
|
|
$input.focus(
|
|
function () {
|
|
$input.data( dataFocus, 1 );
|
|
$.watermark._hide( $input, true );
|
|
}
|
|
).blur(
|
|
function () {
|
|
$input.data( dataFocus, 0 );
|
|
$.watermark._show( $input );
|
|
}
|
|
).bind( "dragenter",
|
|
function () {
|
|
$.watermark._hide( $input );
|
|
}
|
|
).bind( "dragleave",
|
|
function () {
|
|
$.watermark._show( $input );
|
|
}
|
|
).bind( "dragend",
|
|
function () {
|
|
window.setTimeout( function () { $.watermark._show($input); }, 1 );
|
|
}
|
|
).bind( "drop",
|
|
// Firefox makes this lovely function necessary because the dropped text
|
|
// is merged with the watermark before the drop event is called.
|
|
function ( evt ) {
|
|
var elem = $input[ 0 ],
|
|
dropText = evt.originalEvent.dataTransfer.getData( "Text" );
|
|
|
|
if ( ( elem.value || "" ).replace( rreturn, "" ).replace( dropText, "" ) === $input.data( dataText ) ) {
|
|
elem.value = dropText;
|
|
}
|
|
|
|
$input.focus();
|
|
}
|
|
);
|
|
}
|
|
|
|
// In order to reliably clear all watermarks before form submission,
|
|
// we need to replace the form's submit function with our own
|
|
// function. Otherwise watermarks won't be cleared when the form
|
|
// is submitted programmatically.
|
|
if ( this.form ) {
|
|
var form = this.form,
|
|
$form = $( form );
|
|
|
|
if ( !$form.data( dataFormSubmit ) ) {
|
|
$form.submit( $.watermark.hideAll );
|
|
|
|
// form.submit exists for all browsers except Google Chrome
|
|
// (see "else" below for explanation)
|
|
if ( form.submit ) {
|
|
$form.data( dataFormSubmit, form.submit );
|
|
|
|
form.submit = ( function ( f, $f ) {
|
|
return function () {
|
|
var nativeSubmit = $f.data( dataFormSubmit );
|
|
|
|
$.watermark.hideAll();
|
|
|
|
if ( nativeSubmit.apply ) {
|
|
nativeSubmit.apply( f, Array.prototype.slice.call( arguments ) );
|
|
}
|
|
else {
|
|
nativeSubmit();
|
|
}
|
|
};
|
|
})( form, $form );
|
|
}
|
|
else {
|
|
$form.data( dataFormSubmit, 1 );
|
|
|
|
// This strangeness is due to the fact that Google Chrome's
|
|
// form.submit function is not visible to JavaScript (identifies
|
|
// as "undefined"). I had to invent a solution here because hours
|
|
// of Googling (ironically) for an answer did not turn up anything
|
|
// useful. Within my own form.submit function I delete the form's
|
|
// submit function, and then call the non-existent function --
|
|
// which, in the world of Google Chrome, still exists.
|
|
form.submit = ( function ( f ) {
|
|
return function () {
|
|
$.watermark.hideAll();
|
|
delete f.submit;
|
|
f.submit();
|
|
};
|
|
})( form );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$.watermark._show( $input );
|
|
}
|
|
);
|
|
};
|
|
|
|
// The code included within the following if structure is guaranteed to only run once,
|
|
// even if the watermark script file is included multiple times in the page.
|
|
if ( $.watermark.runOnce ) {
|
|
$.watermark.runOnce = false;
|
|
|
|
$.extend( $.expr[ ":" ], {
|
|
|
|
// Extends jQuery with a custom selector - ":data(...)"
|
|
// :data(<name>) Includes elements that have a specific name defined in the jQuery data
|
|
// collection. (Only the existence of the name is checked; the value is ignored.)
|
|
// A more sophisticated version of the :data() custom selector originally part of this plugin
|
|
// was removed for compatibility with jQuery UI. The original code can be found in the SVN
|
|
// source listing in the file, "jquery.data.js".
|
|
data: $.expr.createPseudo ?
|
|
$.expr.createPseudo( function( dataName ) {
|
|
return function( elem ) {
|
|
return !!$.data( elem, dataName );
|
|
};
|
|
}) :
|
|
// support: jQuery <1.8
|
|
function( elem, i, match ) {
|
|
return !!$.data( elem, match[ 3 ] );
|
|
},
|
|
|
|
// Extends jQuery with a custom selector - ":watermarkable"
|
|
// Includes elements that can be watermarked, including textareas and most input elements
|
|
// that accept text input. It uses a "negative" test (i.e., testing for input types that DON'T
|
|
// work) because the HTML spec states that you can basically use any type, and if it doesn't
|
|
// recognize the type it will default to type=text. So if we only looked for certain type attributes
|
|
// we would fail to recognize non-standard types, which are still valid and watermarkable.
|
|
watermarkable: function ( elem ) {
|
|
var type,
|
|
name = elem.nodeName;
|
|
|
|
if ( name === "TEXTAREA" ) {
|
|
return true;
|
|
}
|
|
|
|
if ( name !== "INPUT" ) {
|
|
return false;
|
|
}
|
|
|
|
type = elem.getAttribute( "type" );
|
|
|
|
return ( ( !type ) || ( !rInvalidType.test( type ) ) );
|
|
}
|
|
});
|
|
|
|
// Overloads the jQuery .val() function to return the underlying input value on
|
|
// watermarked input elements. When .val() is being used to set values, this
|
|
// function ensures watermarks are properly set/removed after the values are set.
|
|
// Uses self-executing function to override the default jQuery function.
|
|
( function ( valOld ) {
|
|
|
|
$.fn.val = function () {
|
|
var args = Array.prototype.slice.call( arguments );
|
|
|
|
// Best practice: return immediately if empty matched set
|
|
if ( !this.length ) {
|
|
return args.length? this : undefined;
|
|
}
|
|
|
|
// If no args, then we're getting the value of the first element;
|
|
// else we're setting values for all elements in matched set
|
|
if ( !args.length ) {
|
|
|
|
// If element is watermarked, get the underlying value;
|
|
// else use native jQuery .val()
|
|
if ( this.data( dataFlag ) ) {
|
|
var v = ( this[ 0 ].value || "" ).replace( rreturn, "" );
|
|
return ( v === ( this.data( dataText ) || "" ) )? "" : v;
|
|
}
|
|
else {
|
|
return valOld.apply( this );
|
|
}
|
|
}
|
|
else {
|
|
valOld.apply( this, args );
|
|
$.watermark.show( this );
|
|
return this;
|
|
}
|
|
};
|
|
|
|
})( $.fn.val );
|
|
|
|
// Hijack any functions found in the triggerFns list
|
|
if ( triggerFns.length ) {
|
|
|
|
// Wait until DOM is ready before searching
|
|
$( function () {
|
|
var i, name, fn;
|
|
|
|
for ( i = triggerFns.length - 1; i >= 0; i-- ) {
|
|
name = triggerFns[ i ];
|
|
fn = window[ name ];
|
|
|
|
if ( typeof( fn ) === "function" ) {
|
|
window[ name ] = ( function ( origFn ) {
|
|
return function () {
|
|
$.watermark.hideAll();
|
|
return origFn.apply( null, Array.prototype.slice.call( arguments ) );
|
|
};
|
|
})( fn );
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
$( window ).bind( "beforeunload", function () {
|
|
if ( $.watermark.options.hideBeforeUnload ) {
|
|
$.watermark.hideAll();
|
|
}
|
|
});
|
|
}
|
|
|
|
})( jQuery, window );
|