Last active
August 29, 2015 14:07
-
-
Save ganezasan/579e7b5bb17cd521bb4e to your computer and use it in GitHub Desktop.
NEND
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!DOCTYPE html> | |
| <html> | |
| <head> | |
| <title>Nend</title> | |
| <meta charset="utf-8" /> | |
| <meta name="viewport" content="width=device-width, initial-scale=1 maximum-scale=1 minimum-scale=1"> | |
| <link href="jquery.mobile.structure-1.4.3.min.css" type="text/css" rel="stylesheet"> | |
| <link href="jquery.mobile.icons.min.css" type="text/css" rel="stylesheet"> | |
| <link href="nend-jqm-theme.css" type="text/css" rel="stylesheet"> | |
| </head> | |
| <body> | |
| <div id="home_page" data-role="page"> | |
| <h1>hello NEND</h1> | |
| <div class="nend"> | |
| <script type="text/javascript"> | |
| var nend_params = {"media":7336,"site":93621,"spot":227711,"type":1,"oriented":2}; | |
| </script> | |
| <script type="text/javascript" src="http://js1.nend.net/js/nendAdLoader.js"></script> | |
| </div> | |
| <div role="main" class="ui-content"> | |
| <ul class="ui-listview" data-role="listview" data-filter="true" data-input="#filter-for-listview"> | |
| <li data-role="list-divider" data-theme="b">スレタイトル１<span class="ui-li-count">3</span></li> | |
| <li><a href="index.html"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="index.html"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="index.html"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <div class="nend"> | |
| <script type="text/javascript"> | |
| var nend_params = {"media":7336,"site":91474,"spot":221241,"type":1,"oriented":2}; | |
| </script> | |
| <script type="text/javascript" src="http://js1.nend.net/js/nendAdLoader.js"></script> | |
| </div> | |
| <li data-role="list-divider" data-theme="b">スレタイトル２<span class="ui-li-count">3</span></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <div class="nend"> | |
| <script type="text/javascript"> | |
| var nend_params = {"media":7336,"site":93621,"spot":227881,"type":1,"oriented":2,"ad_num":4,"space":1,"align":1,"tdisplay":2,"tcolor":"%23000000","width":57,"height":57}; | |
| </script> | |
| <script type="text/javascript" src="http://js1.nend.net/js/nendAdLoader.js"></script> | |
| </div> | |
| <li data-role="list-divider" data-theme="b">スレタイトル３<span class="ui-li-count">3</span></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li data-role="list-divider" data-theme="b">スレタイトル４<span class="ui-li-count">3</span></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| <li><a href="javascript:void(0)"> | |
| <h2>スレッドタイトル(512)</h2> | |
| <p>latest comment 2013/12/24</p> | |
| </a></li> | |
| </ul> | |
| </div> | |
| </div> | |
| <script src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> | |
| <script src="jquery.mobile-1.4.3.js"></script> | |
| <script> | |
| //ホーム用 | |
| window.addEventListener('load', function() { | |
| console.log("pageload"); | |
| var userAgent = window.navigator.userAgent.toLowerCase(); | |
| if(userAgent.indexOf('Mac OS X') == -1){ | |
| $(".nend a").bind("click",function(d){ | |
| location.href = encodeURI(d.currentTarget.href); | |
| return false; | |
| }); | |
| } | |
| }); | |
| </script> | |
| </body> | |
| </html> |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /*! | |
| * jQuery Mobile 1.4.3 | |
| * Git HEAD hash: b9c6473e3d90af26570e6f14e5a0307897ab385c <> Date: Tue Jul 1 2014 15:37:36 UTC | |
| * http://jquerymobile.com | |
| * | |
| * Copyright 2010, 2014 jQuery Foundation, Inc. and othercontributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| */ | |
| (function ( root, doc, factory ) { | |
| if ( typeof define === "function" && define.amd ) { | |
| // AMD. Register as an anonymous module. | |
| define( [ "jquery" ], function ( $ ) { | |
| factory( $, root, doc ); | |
| return $.mobile; | |
| }); | |
| } else { | |
| // Browser globals | |
| factory( root.jQuery, root, doc ); | |
| } | |
| }( this, document, function ( jQuery, window, document, undefined ) { | |
| (function( $ ) { | |
| $.mobile = {}; | |
| }( jQuery )); | |
| (function( $, window, undefined ) { | |
| $.extend( $.mobile, { | |
| // Version of the jQuery Mobile Framework | |
| version: "1.4.3", | |
| // Deprecated and no longer used in 1.4 remove in 1.5 | |
| // Define the url parameter used for referencing widget-generated sub-pages. | |
| // Translates to example.html&ui-page=subpageIdentifier | |
| // hash segment before &ui-page= is used to make Ajax request | |
| subPageUrlKey: "ui-page", | |
| hideUrlBar: true, | |
| // Keepnative Selector | |
| keepNative: ":jqmData(role='none'), :jqmData(role='nojs')", | |
| // Deprecated in 1.4 remove in 1.5 | |
| // Class assigned to page currently in view, and during transitions | |
| activePageClass: "ui-page-active", | |
| // Deprecated in 1.4 remove in 1.5 | |
| // Class used for "active" button state, from CSS framework | |
| activeBtnClass: "ui-btn-active", | |
| // Deprecated in 1.4 remove in 1.5 | |
| // Class used for "focus" form element state, from CSS framework | |
| focusClass: "ui-focus", | |
| // Automatically handle clicks and form submissions through Ajax, when same-domain | |
| ajaxEnabled: true, | |
| // Automatically load and show pages based on location.hash | |
| hashListeningEnabled: true, | |
| // disable to prevent jquery from bothering with links | |
| linkBindingEnabled: true, | |
| // Set default page transition - 'none' for no transitions | |
| defaultPageTransition: "fade", | |
| // Set maximum window width for transitions to apply - 'false' for no limit | |
| maxTransitionWidth: false, | |
| // Minimum scroll distance that will be remembered when returning to a page | |
| // Deprecated remove in 1.5 | |
| minScrollBack: 0, | |
| // Set default dialog transition - 'none' for no transitions | |
| defaultDialogTransition: "pop", | |
| // Error response message - appears when an Ajax page request fails | |
| pageLoadErrorMessage: "Error Loading Page", | |
| // For error messages, which theme does the box use? | |
| pageLoadErrorMessageTheme: "a", | |
| // replace calls to window.history.back with phonegaps navigation helper | |
| // where it is provided on the window object | |
| phonegapNavigationEnabled: false, | |
| //automatically initialize the DOM when it's ready | |
| autoInitializePage: true, | |
| pushStateEnabled: true, | |
| // allows users to opt in to ignoring content by marking a parent element as | |
| // data-ignored | |
| ignoreContentEnabled: false, | |
| buttonMarkup: { | |
| hoverDelay: 200 | |
| }, | |
| // disable the alteration of the dynamic base tag or links in the case | |
| // that a dynamic base tag isn't supported | |
| dynamicBaseEnabled: true, | |
| // default the property to remove dependency on assignment in init module | |
| pageContainer: $(), | |
| //enable cross-domain page support | |
| allowCrossDomainPages: false, | |
| dialogHashKey: "&ui-state=dialog" | |
| }); | |
| })( jQuery, this ); | |
| (function( $, window, undefined ) { | |
| var nsNormalizeDict = {}, | |
| oldFind = $.find, | |
| rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, | |
| jqmDataRE = /:jqmData\(([^)]*)\)/g; | |
| $.extend( $.mobile, { | |
| // Namespace used framework-wide for data-attrs. Default is no namespace | |
| ns: "", | |
| // Retrieve an attribute from an element and perform some massaging of the value | |
| getAttribute: function( element, key ) { | |
| var data; | |
| element = element.jquery ? element[0] : element; | |
| if ( element && element.getAttribute ) { | |
| data = element.getAttribute( "data-" + $.mobile.ns + key ); | |
| } | |
| // Copied from core's src/data.js:dataAttr() | |
| // Convert from a string to a proper data type | |
| try { | |
| data = data === "true" ? true : | |
| data === "false" ? false : | |
| data === "null" ? null : | |
| // Only convert to a number if it doesn't change the string | |
| +data + "" === data ? +data : | |
| rbrace.test( data ) ? JSON.parse( data ) : | |
| data; | |
| } catch( err ) {} | |
| return data; | |
| }, | |
| // Expose our cache for testing purposes. | |
| nsNormalizeDict: nsNormalizeDict, | |
| // Take a data attribute property, prepend the namespace | |
| // and then camel case the attribute string. Add the result | |
| // to our nsNormalizeDict so we don't have to do this again. | |
| nsNormalize: function( prop ) { | |
| return nsNormalizeDict[ prop ] || | |
| ( nsNormalizeDict[ prop ] = $.camelCase( $.mobile.ns + prop ) ); | |
| }, | |
| // Find the closest javascript page element to gather settings data jsperf test | |
| // http://jsperf.com/single-complex-selector-vs-many-complex-selectors/edit | |
| // possibly naive, but it shows that the parsing overhead for *just* the page selector vs | |
| // the page and dialog selector is negligable. This could probably be speed up by | |
| // doing a similar parent node traversal to the one found in the inherited theme code above | |
| closestPageData: function( $target ) { | |
| return $target | |
| .closest( ":jqmData(role='page'), :jqmData(role='dialog')" ) | |
| .data( "mobile-page" ); | |
| } | |
| }); | |
| // Mobile version of data and removeData and hasData methods | |
| // ensures all data is set and retrieved using jQuery Mobile's data namespace | |
| $.fn.jqmData = function( prop, value ) { | |
| var result; | |
| if ( typeof prop !== "undefined" ) { | |
| if ( prop ) { | |
| prop = $.mobile.nsNormalize( prop ); | |
| } | |
| // undefined is permitted as an explicit input for the second param | |
| // in this case it returns the value and does not set it to undefined | |
| if ( arguments.length < 2 || value === undefined ) { | |
| result = this.data( prop ); | |
| } else { | |
| result = this.data( prop, value ); | |
| } | |
| } | |
| return result; | |
| }; | |
| $.jqmData = function( elem, prop, value ) { | |
| var result; | |
| if ( typeof prop !== "undefined" ) { | |
| result = $.data( elem, prop ? $.mobile.nsNormalize( prop ) : prop, value ); | |
| } | |
| return result; | |
| }; | |
| $.fn.jqmRemoveData = function( prop ) { | |
| return this.removeData( $.mobile.nsNormalize( prop ) ); | |
| }; | |
| $.jqmRemoveData = function( elem, prop ) { | |
| return $.removeData( elem, $.mobile.nsNormalize( prop ) ); | |
| }; | |
| $.find = function( selector, context, ret, extra ) { | |
| if ( selector.indexOf( ":jqmData" ) > -1 ) { | |
| selector = selector.replace( jqmDataRE, "[data-" + ( $.mobile.ns || "" ) + "$1]" ); | |
| } | |
| return oldFind.call( this, selector, context, ret, extra ); | |
| }; | |
| $.extend( $.find, oldFind ); | |
| })( jQuery, this ); | |
| /*! | |
| * jQuery UI Core c0ab71056b936627e8a7821f03c044aec6280a40 | |
| * http://jqueryui.com | |
| * | |
| * Copyright 2013 jQuery Foundation and other contributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| * http://api.jqueryui.com/category/ui-core/ | |
| */ | |
| (function( $, undefined ) { | |
| var uuid = 0, | |
| runiqueId = /^ui-id-\d+$/; | |
| // $.ui might exist from components with no dependencies, e.g., $.ui.position | |
| $.ui = $.ui || {}; | |
| $.extend( $.ui, { | |
| version: "c0ab71056b936627e8a7821f03c044aec6280a40", | |
| keyCode: { | |
| BACKSPACE: 8, | |
| COMMA: 188, | |
| DELETE: 46, | |
| DOWN: 40, | |
| END: 35, | |
| ENTER: 13, | |
| ESCAPE: 27, | |
| HOME: 36, | |
| LEFT: 37, | |
| PAGE_DOWN: 34, | |
| PAGE_UP: 33, | |
| PERIOD: 190, | |
| RIGHT: 39, | |
| SPACE: 32, | |
| TAB: 9, | |
| UP: 38 | |
| } | |
| }); | |
| // plugins | |
| $.fn.extend({ | |
| focus: (function( orig ) { | |
| return function( delay, fn ) { | |
| return typeof delay === "number" ? | |
| this.each(function() { | |
| var elem = this; | |
| setTimeout(function() { | |
| $( elem ).focus(); | |
| if ( fn ) { | |
| fn.call( elem ); | |
| } | |
| }, delay ); | |
| }) : | |
| orig.apply( this, arguments ); | |
| }; | |
| })( $.fn.focus ), | |
| scrollParent: function() { | |
| var scrollParent; | |
| if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) { | |
| scrollParent = this.parents().filter(function() { | |
| return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x")); | |
| }).eq(0); | |
| } else { | |
| scrollParent = this.parents().filter(function() { | |
| return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x")); | |
| }).eq(0); | |
| } | |
| return ( /fixed/ ).test( this.css( "position") ) || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent; | |
| }, | |
| uniqueId: function() { | |
| return this.each(function() { | |
| if ( !this.id ) { | |
| this.id = "ui-id-" + (++uuid); | |
| } | |
| }); | |
| }, | |
| removeUniqueId: function() { | |
| return this.each(function() { | |
| if ( runiqueId.test( this.id ) ) { | |
| $( this ).removeAttr( "id" ); | |
| } | |
| }); | |
| } | |
| }); | |
| // selectors | |
| function focusable( element, isTabIndexNotNaN ) { | |
| var map, mapName, img, | |
| nodeName = element.nodeName.toLowerCase(); | |
| if ( "area" === nodeName ) { | |
| map = element.parentNode; | |
| mapName = map.name; | |
| if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) { | |
| return false; | |
| } | |
| img = $( "img[usemap=#" + mapName + "]" )[0]; | |
| return !!img && visible( img ); | |
| } | |
| return ( /input|select|textarea|button|object/.test( nodeName ) ? | |
| !element.disabled : | |
| "a" === nodeName ? | |
| element.href || isTabIndexNotNaN : | |
| isTabIndexNotNaN) && | |
| // the element and all of its ancestors must be visible | |
| visible( element ); | |
| } | |
| function visible( element ) { | |
| return $.expr.filters.visible( element ) && | |
| !$( element ).parents().addBack().filter(function() { | |
| return $.css( this, "visibility" ) === "hidden"; | |
| }).length; | |
| } | |
| $.extend( $.expr[ ":" ], { | |
| 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 ] ); | |
| }, | |
| focusable: function( element ) { | |
| return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) ); | |
| }, | |
| tabbable: function( element ) { | |
| var tabIndex = $.attr( element, "tabindex" ), | |
| isTabIndexNaN = isNaN( tabIndex ); | |
| return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN ); | |
| } | |
| }); | |
| // support: jQuery <1.8 | |
| if ( !$( "<a>" ).outerWidth( 1 ).jquery ) { | |
| $.each( [ "Width", "Height" ], function( i, name ) { | |
| var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ], | |
| type = name.toLowerCase(), | |
| orig = { | |
| innerWidth: $.fn.innerWidth, | |
| innerHeight: $.fn.innerHeight, | |
| outerWidth: $.fn.outerWidth, | |
| outerHeight: $.fn.outerHeight | |
| }; | |
| function reduce( elem, size, border, margin ) { | |
| $.each( side, function() { | |
| size -= parseFloat( $.css( elem, "padding" + this ) ) || 0; | |
| if ( border ) { | |
| size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0; | |
| } | |
| if ( margin ) { | |
| size -= parseFloat( $.css( elem, "margin" + this ) ) || 0; | |
| } | |
| }); | |
| return size; | |
| } | |
| $.fn[ "inner" + name ] = function( size ) { | |
| if ( size === undefined ) { | |
| return orig[ "inner" + name ].call( this ); | |
| } | |
| return this.each(function() { | |
| $( this ).css( type, reduce( this, size ) + "px" ); | |
| }); | |
| }; | |
| $.fn[ "outer" + name] = function( size, margin ) { | |
| if ( typeof size !== "number" ) { | |
| return orig[ "outer" + name ].call( this, size ); | |
| } | |
| return this.each(function() { | |
| $( this).css( type, reduce( this, size, true, margin ) + "px" ); | |
| }); | |
| }; | |
| }); | |
| } | |
| // support: jQuery <1.8 | |
| if ( !$.fn.addBack ) { | |
| $.fn.addBack = function( selector ) { | |
| return this.add( selector == null ? | |
| this.prevObject : this.prevObject.filter( selector ) | |
| ); | |
| }; | |
| } | |
| // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413) | |
| if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) { | |
| $.fn.removeData = (function( removeData ) { | |
| return function( key ) { | |
| if ( arguments.length ) { | |
| return removeData.call( this, $.camelCase( key ) ); | |
| } else { | |
| return removeData.call( this ); | |
| } | |
| }; | |
| })( $.fn.removeData ); | |
| } | |
| // deprecated | |
| $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() ); | |
| $.support.selectstart = "onselectstart" in document.createElement( "div" ); | |
| $.fn.extend({ | |
| disableSelection: function() { | |
| return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) + | |
| ".ui-disableSelection", function( event ) { | |
| event.preventDefault(); | |
| }); | |
| }, | |
| enableSelection: function() { | |
| return this.unbind( ".ui-disableSelection" ); | |
| }, | |
| zIndex: function( zIndex ) { | |
| if ( zIndex !== undefined ) { | |
| return this.css( "zIndex", zIndex ); | |
| } | |
| if ( this.length ) { | |
| var elem = $( this[ 0 ] ), position, value; | |
| while ( elem.length && elem[ 0 ] !== document ) { | |
| // Ignore z-index if position is set to a value where z-index is ignored by the browser | |
| // This makes behavior of this function consistent across browsers | |
| // WebKit always returns auto if the element is positioned | |
| position = elem.css( "position" ); | |
| if ( position === "absolute" || position === "relative" || position === "fixed" ) { | |
| // IE returns 0 when zIndex is not specified | |
| // other browsers return a string | |
| // we ignore the case of nested elements with an explicit value of 0 | |
| // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> | |
| value = parseInt( elem.css( "zIndex" ), 10 ); | |
| if ( !isNaN( value ) && value !== 0 ) { | |
| return value; | |
| } | |
| } | |
| elem = elem.parent(); | |
| } | |
| } | |
| return 0; | |
| } | |
| }); | |
| // $.ui.plugin is deprecated. Use $.widget() extensions instead. | |
| $.ui.plugin = { | |
| add: function( module, option, set ) { | |
| var i, | |
| proto = $.ui[ module ].prototype; | |
| for ( i in set ) { | |
| proto.plugins[ i ] = proto.plugins[ i ] || []; | |
| proto.plugins[ i ].push( [ option, set[ i ] ] ); | |
| } | |
| }, | |
| call: function( instance, name, args, allowDisconnected ) { | |
| var i, | |
| set = instance.plugins[ name ]; | |
| if ( !set ) { | |
| return; | |
| } | |
| if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) { | |
| return; | |
| } | |
| for ( i = 0; i < set.length; i++ ) { | |
| if ( instance.options[ set[ i ][ 0 ] ] ) { | |
| set[ i ][ 1 ].apply( instance.element, args ); | |
| } | |
| } | |
| } | |
| }; | |
| })( jQuery ); | |
| (function( $, window, undefined ) { | |
| // Subtract the height of external toolbars from the page height, if the page does not have | |
| // internal toolbars of the same type | |
| var compensateToolbars = function( page, desiredHeight ) { | |
| var pageParent = page.parent(), | |
| toolbarsAffectingHeight = [], | |
| externalHeaders = pageParent.children( ":jqmData(role='header')" ), | |
| internalHeaders = page.children( ":jqmData(role='header')" ), | |
| externalFooters = pageParent.children( ":jqmData(role='footer')" ), | |
| internalFooters = page.children( ":jqmData(role='footer')" ); | |
| // If we have no internal headers, but we do have external headers, then their height | |
| // reduces the page height | |
| if ( internalHeaders.length === 0 && externalHeaders.length > 0 ) { | |
| toolbarsAffectingHeight = toolbarsAffectingHeight.concat( externalHeaders.toArray() ); | |
| } | |
| // If we have no internal footers, but we do have external footers, then their height | |
| // reduces the page height | |
| if ( internalFooters.length === 0 && externalFooters.length > 0 ) { | |
| toolbarsAffectingHeight = toolbarsAffectingHeight.concat( externalFooters.toArray() ); | |
| } | |
| $.each( toolbarsAffectingHeight, function( index, value ) { | |
| desiredHeight -= $( value ).outerHeight(); | |
| }); | |
| // Height must be at least zero | |
| return Math.max( 0, desiredHeight ); | |
| }; | |
| $.extend( $.mobile, { | |
| // define the window and the document objects | |
| window: $( window ), | |
| document: $( document ), | |
| // TODO: Remove and use $.ui.keyCode directly | |
| keyCode: $.ui.keyCode, | |
| // Place to store various widget extensions | |
| behaviors: {}, | |
| // Scroll page vertically: scroll to 0 to hide iOS address bar, or pass a Y value | |
| silentScroll: function( ypos ) { | |
| if ( $.type( ypos ) !== "number" ) { | |
| ypos = $.mobile.defaultHomeScroll; | |
| } | |
| // prevent scrollstart and scrollstop events | |
| $.event.special.scrollstart.enabled = false; | |
| setTimeout(function() { | |
| window.scrollTo( 0, ypos ); | |
| $.mobile.document.trigger( "silentscroll", { x: 0, y: ypos }); | |
| }, 20 ); | |
| setTimeout(function() { | |
| $.event.special.scrollstart.enabled = true; | |
| }, 150 ); | |
| }, | |
| getClosestBaseUrl: function( ele ) { | |
| // Find the closest page and extract out its url. | |
| var url = $( ele ).closest( ".ui-page" ).jqmData( "url" ), | |
| base = $.mobile.path.documentBase.hrefNoHash; | |
| if ( !$.mobile.dynamicBaseEnabled || !url || !$.mobile.path.isPath( url ) ) { | |
| url = base; | |
| } | |
| return $.mobile.path.makeUrlAbsolute( url, base ); | |
| }, | |
| removeActiveLinkClass: function( forceRemoval ) { | |
| if ( !!$.mobile.activeClickedLink && | |
| ( !$.mobile.activeClickedLink.closest( "." + $.mobile.activePageClass ).length || | |
| forceRemoval ) ) { | |
| $.mobile.activeClickedLink.removeClass( $.mobile.activeBtnClass ); | |
| } | |
| $.mobile.activeClickedLink = null; | |
| }, | |
| // DEPRECATED in 1.4 | |
| // Find the closest parent with a theme class on it. Note that | |
| // we are not using $.fn.closest() on purpose here because this | |
| // method gets called quite a bit and we need it to be as fast | |
| // as possible. | |
| getInheritedTheme: function( el, defaultTheme ) { | |
| var e = el[ 0 ], | |
| ltr = "", | |
| re = /ui-(bar|body|overlay)-([a-z])\b/, | |
| c, m; | |
| while ( e ) { | |
| c = e.className || ""; | |
| if ( c && ( m = re.exec( c ) ) && ( ltr = m[ 2 ] ) ) { | |
| // We found a parent with a theme class | |
| // on it so bail from this loop. | |
| break; | |
| } | |
| e = e.parentNode; | |
| } | |
| // Return the theme letter we found, if none, return the | |
| // specified default. | |
| return ltr || defaultTheme || "a"; | |
| }, | |
| enhanceable: function( elements ) { | |
| return this.haveParents( elements, "enhance" ); | |
| }, | |
| hijackable: function( elements ) { | |
| return this.haveParents( elements, "ajax" ); | |
| }, | |
| haveParents: function( elements, attr ) { | |
| if ( !$.mobile.ignoreContentEnabled ) { | |
| return elements; | |
| } | |
| var count = elements.length, | |
| $newSet = $(), | |
| e, $element, excluded, | |
| i, c; | |
| for ( i = 0; i < count; i++ ) { | |
| $element = elements.eq( i ); | |
| excluded = false; | |
| e = elements[ i ]; | |
| while ( e ) { | |
| c = e.getAttribute ? e.getAttribute( "data-" + $.mobile.ns + attr ) : ""; | |
| if ( c === "false" ) { | |
| excluded = true; | |
| break; | |
| } | |
| e = e.parentNode; | |
| } | |
| if ( !excluded ) { | |
| $newSet = $newSet.add( $element ); | |
| } | |
| } | |
| return $newSet; | |
| }, | |
| getScreenHeight: function() { | |
| // Native innerHeight returns more accurate value for this across platforms, | |
| // jQuery version is here as a normalized fallback for platforms like Symbian | |
| return window.innerHeight || $.mobile.window.height(); | |
| }, | |
| //simply set the active page's minimum height to screen height, depending on orientation | |
| resetActivePageHeight: function( height ) { | |
| var page = $( "." + $.mobile.activePageClass ), | |
| pageHeight = page.height(), | |
| pageOuterHeight = page.outerHeight( true ); | |
| height = compensateToolbars( page, | |
| ( typeof height === "number" ) ? height : $.mobile.getScreenHeight() ); | |
| // Remove any previous min-height setting | |
| page.css( "min-height", "" ); | |
| // Set the minimum height only if the height as determined by CSS is insufficient | |
| if ( page.height() < height ) { | |
| page.css( "min-height", height - ( pageOuterHeight - pageHeight ) ); | |
| } | |
| }, | |
| loading: function() { | |
| // If this is the first call to this function, instantiate a loader widget | |
| var loader = this.loading._widget || $( $.mobile.loader.prototype.defaultHtml ).loader(), | |
| // Call the appropriate method on the loader | |
| returnValue = loader.loader.apply( loader, arguments ); | |
| // Make sure the loader is retained for future calls to this function. | |
| this.loading._widget = loader; | |
| return returnValue; | |
| } | |
| }); | |
| $.addDependents = function( elem, newDependents ) { | |
| var $elem = $( elem ), | |
| dependents = $elem.jqmData( "dependents" ) || $(); | |
| $elem.jqmData( "dependents", $( dependents ).add( newDependents ) ); | |
| }; | |
| // plugins | |
| $.fn.extend({ | |
| removeWithDependents: function() { | |
| $.removeWithDependents( this ); | |
| }, | |
| // Enhance child elements | |
| enhanceWithin: function() { | |
| var index, | |
| widgetElements = {}, | |
| keepNative = $.mobile.page.prototype.keepNativeSelector(), | |
| that = this; | |
| // Add no js class to elements | |
| if ( $.mobile.nojs ) { | |
| $.mobile.nojs( this ); | |
| } | |
| // Bind links for ajax nav | |
| if ( $.mobile.links ) { | |
| $.mobile.links( this ); | |
| } | |
| // Degrade inputs for styleing | |
| if ( $.mobile.degradeInputsWithin ) { | |
| $.mobile.degradeInputsWithin( this ); | |
| } | |
| // Run buttonmarkup | |
| if ( $.fn.buttonMarkup ) { | |
| this.find( $.fn.buttonMarkup.initSelector ).not( keepNative ) | |
| .jqmEnhanceable().buttonMarkup(); | |
| } | |
| // Add classes for fieldContain | |
| if ( $.fn.fieldcontain ) { | |
| this.find( ":jqmData(role='fieldcontain')" ).not( keepNative ) | |
| .jqmEnhanceable().fieldcontain(); | |
| } | |
| // Enhance widgets | |
| $.each( $.mobile.widgets, function( name, constructor ) { | |
| // If initSelector not false find elements | |
| if ( constructor.initSelector ) { | |
| // Filter elements that should not be enhanced based on parents | |
| var elements = $.mobile.enhanceable( that.find( constructor.initSelector ) ); | |
| // If any matching elements remain filter ones with keepNativeSelector | |
| if ( elements.length > 0 ) { | |
| // $.mobile.page.prototype.keepNativeSelector is deprecated this is just for backcompat | |
| // Switch to $.mobile.keepNative in 1.5 which is just a value not a function | |
| elements = elements.not( keepNative ); | |
| } | |
| // Enhance whatever is left | |
| if ( elements.length > 0 ) { | |
| widgetElements[ constructor.prototype.widgetName ] = elements; | |
| } | |
| } | |
| }); | |
| for ( index in widgetElements ) { | |
| widgetElements[ index ][ index ](); | |
| } | |
| return this; | |
| }, | |
| addDependents: function( newDependents ) { | |
| $.addDependents( this, newDependents ); | |
| }, | |
| // note that this helper doesn't attempt to handle the callback | |
| // or setting of an html element's text, its only purpose is | |
| // to return the html encoded version of the text in all cases. (thus the name) | |
| getEncodedText: function() { | |
| return $( "<a>" ).text( this.text() ).html(); | |
| }, | |
| // fluent helper function for the mobile namespaced equivalent | |
| jqmEnhanceable: function() { | |
| return $.mobile.enhanceable( this ); | |
| }, | |
| jqmHijackable: function() { | |
| return $.mobile.hijackable( this ); | |
| } | |
| }); | |
| $.removeWithDependents = function( nativeElement ) { | |
| var element = $( nativeElement ); | |
| ( element.jqmData( "dependents" ) || $() ).remove(); | |
| element.remove(); | |
| }; | |
| $.addDependents = function( nativeElement, newDependents ) { | |
| var element = $( nativeElement ), | |
| dependents = element.jqmData( "dependents" ) || $(); | |
| element.jqmData( "dependents", $( dependents ).add( newDependents ) ); | |
| }; | |
| $.find.matches = function( expr, set ) { | |
| return $.find( expr, null, null, set ); | |
| }; | |
| $.find.matchesSelector = function( node, expr ) { | |
| return $.find( expr, null, null, [ node ] ).length > 0; | |
| }; | |
| })( jQuery, this ); | |
| /*! | |
| * jQuery UI Widget c0ab71056b936627e8a7821f03c044aec6280a40 | |
| * http://jqueryui.com | |
| * | |
| * Copyright 2013 jQuery Foundation and other contributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| * http://api.jqueryui.com/jQuery.widget/ | |
| */ | |
| (function( $, undefined ) { | |
| var uuid = 0, | |
| slice = Array.prototype.slice, | |
| _cleanData = $.cleanData; | |
| $.cleanData = function( elems ) { | |
| for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) { | |
| try { | |
| $( elem ).triggerHandler( "remove" ); | |
| // http://bugs.jquery.com/ticket/8235 | |
| } catch( e ) {} | |
| } | |
| _cleanData( elems ); | |
| }; | |
| $.widget = function( name, base, prototype ) { | |
| var fullName, existingConstructor, constructor, basePrototype, | |
| // proxiedPrototype allows the provided prototype to remain unmodified | |
| // so that it can be used as a mixin for multiple widgets (#8876) | |
| proxiedPrototype = {}, | |
| namespace = name.split( "." )[ 0 ]; | |
| name = name.split( "." )[ 1 ]; | |
| fullName = namespace + "-" + name; | |
| if ( !prototype ) { | |
| prototype = base; | |
| base = $.Widget; | |
| } | |
| // create selector for plugin | |
| $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) { | |
| return !!$.data( elem, fullName ); | |
| }; | |
| $[ namespace ] = $[ namespace ] || {}; | |
| existingConstructor = $[ namespace ][ name ]; | |
| constructor = $[ namespace ][ name ] = function( options, element ) { | |
| // allow instantiation without "new" keyword | |
| if ( !this._createWidget ) { | |
| return new constructor( options, element ); | |
| } | |
| // allow instantiation without initializing for simple inheritance | |
| // must use "new" keyword (the code above always passes args) | |
| if ( arguments.length ) { | |
| this._createWidget( options, element ); | |
| } | |
| }; | |
| // extend with the existing constructor to carry over any static properties | |
| $.extend( constructor, existingConstructor, { | |
| version: prototype.version, | |
| // copy the object used to create the prototype in case we need to | |
| // redefine the widget later | |
| _proto: $.extend( {}, prototype ), | |
| // track widgets that inherit from this widget in case this widget is | |
| // redefined after a widget inherits from it | |
| _childConstructors: [] | |
| }); | |
| basePrototype = new base(); | |
| // we need to make the options hash a property directly on the new instance | |
| // otherwise we'll modify the options hash on the prototype that we're | |
| // inheriting from | |
| basePrototype.options = $.widget.extend( {}, basePrototype.options ); | |
| $.each( prototype, function( prop, value ) { | |
| if ( !$.isFunction( value ) ) { | |
| proxiedPrototype[ prop ] = value; | |
| return; | |
| } | |
| proxiedPrototype[ prop ] = (function() { | |
| var _super = function() { | |
| return base.prototype[ prop ].apply( this, arguments ); | |
| }, | |
| _superApply = function( args ) { | |
| return base.prototype[ prop ].apply( this, args ); | |
| }; | |
| return function() { | |
| var __super = this._super, | |
| __superApply = this._superApply, | |
| returnValue; | |
| this._super = _super; | |
| this._superApply = _superApply; | |
| returnValue = value.apply( this, arguments ); | |
| this._super = __super; | |
| this._superApply = __superApply; | |
| return returnValue; | |
| }; | |
| })(); | |
| }); | |
| constructor.prototype = $.widget.extend( basePrototype, { | |
| // TODO: remove support for widgetEventPrefix | |
| // always use the name + a colon as the prefix, e.g., draggable:start | |
| // don't prefix for widgets that aren't DOM-based | |
| widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name | |
| }, proxiedPrototype, { | |
| constructor: constructor, | |
| namespace: namespace, | |
| widgetName: name, | |
| widgetFullName: fullName | |
| }); | |
| // If this widget is being redefined then we need to find all widgets that | |
| // are inheriting from it and redefine all of them so that they inherit from | |
| // the new version of this widget. We're essentially trying to replace one | |
| // level in the prototype chain. | |
| if ( existingConstructor ) { | |
| $.each( existingConstructor._childConstructors, function( i, child ) { | |
| var childPrototype = child.prototype; | |
| // redefine the child widget using the same prototype that was | |
| // originally used, but inherit from the new version of the base | |
| $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto ); | |
| }); | |
| // remove the list of existing child constructors from the old constructor | |
| // so the old child constructors can be garbage collected | |
| delete existingConstructor._childConstructors; | |
| } else { | |
| base._childConstructors.push( constructor ); | |
| } | |
| $.widget.bridge( name, constructor ); | |
| return constructor; | |
| }; | |
| $.widget.extend = function( target ) { | |
| var input = slice.call( arguments, 1 ), | |
| inputIndex = 0, | |
| inputLength = input.length, | |
| key, | |
| value; | |
| for ( ; inputIndex < inputLength; inputIndex++ ) { | |
| for ( key in input[ inputIndex ] ) { | |
| value = input[ inputIndex ][ key ]; | |
| if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) { | |
| // Clone objects | |
| if ( $.isPlainObject( value ) ) { | |
| target[ key ] = $.isPlainObject( target[ key ] ) ? | |
| $.widget.extend( {}, target[ key ], value ) : | |
| // Don't extend strings, arrays, etc. with objects | |
| $.widget.extend( {}, value ); | |
| // Copy everything else by reference | |
| } else { | |
| target[ key ] = value; | |
| } | |
| } | |
| } | |
| } | |
| return target; | |
| }; | |
| $.widget.bridge = function( name, object ) { | |
| var fullName = object.prototype.widgetFullName || name; | |
| $.fn[ name ] = function( options ) { | |
| var isMethodCall = typeof options === "string", | |
| args = slice.call( arguments, 1 ), | |
| returnValue = this; | |
| // allow multiple hashes to be passed on init | |
| options = !isMethodCall && args.length ? | |
| $.widget.extend.apply( null, [ options ].concat(args) ) : | |
| options; | |
| if ( isMethodCall ) { | |
| this.each(function() { | |
| var methodValue, | |
| instance = $.data( this, fullName ); | |
| if ( options === "instance" ) { | |
| returnValue = instance; | |
| return false; | |
| } | |
| if ( !instance ) { | |
| return $.error( "cannot call methods on " + name + " prior to initialization; " + | |
| "attempted to call method '" + options + "'" ); | |
| } | |
| if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) { | |
| return $.error( "no such method '" + options + "' for " + name + " widget instance" ); | |
| } | |
| methodValue = instance[ options ].apply( instance, args ); | |
| if ( methodValue !== instance && methodValue !== undefined ) { | |
| returnValue = methodValue && methodValue.jquery ? | |
| returnValue.pushStack( methodValue.get() ) : | |
| methodValue; | |
| return false; | |
| } | |
| }); | |
| } else { | |
| this.each(function() { | |
| var instance = $.data( this, fullName ); | |
| if ( instance ) { | |
| instance.option( options || {} )._init(); | |
| } else { | |
| $.data( this, fullName, new object( options, this ) ); | |
| } | |
| }); | |
| } | |
| return returnValue; | |
| }; | |
| }; | |
| $.Widget = function( /* options, element */ ) {}; | |
| $.Widget._childConstructors = []; | |
| $.Widget.prototype = { | |
| widgetName: "widget", | |
| widgetEventPrefix: "", | |
| defaultElement: "<div>", | |
| options: { | |
| disabled: false, | |
| // callbacks | |
| create: null | |
| }, | |
| _createWidget: function( options, element ) { | |
| element = $( element || this.defaultElement || this )[ 0 ]; | |
| this.element = $( element ); | |
| this.uuid = uuid++; | |
| this.eventNamespace = "." + this.widgetName + this.uuid; | |
| this.options = $.widget.extend( {}, | |
| this.options, | |
| this._getCreateOptions(), | |
| options ); | |
| this.bindings = $(); | |
| this.hoverable = $(); | |
| this.focusable = $(); | |
| if ( element !== this ) { | |
| $.data( element, this.widgetFullName, this ); | |
| this._on( true, this.element, { | |
| remove: function( event ) { | |
| if ( event.target === element ) { | |
| this.destroy(); | |
| } | |
| } | |
| }); | |
| this.document = $( element.style ? | |
| // element within the document | |
| element.ownerDocument : | |
| // element is window or document | |
| element.document || element ); | |
| this.window = $( this.document[0].defaultView || this.document[0].parentWindow ); | |
| } | |
| this._create(); | |
| this._trigger( "create", null, this._getCreateEventData() ); | |
| this._init(); | |
| }, | |
| _getCreateOptions: $.noop, | |
| _getCreateEventData: $.noop, | |
| _create: $.noop, | |
| _init: $.noop, | |
| destroy: function() { | |
| this._destroy(); | |
| // we can probably remove the unbind calls in 2.0 | |
| // all event bindings should go through this._on() | |
| this.element | |
| .unbind( this.eventNamespace ) | |
| .removeData( this.widgetFullName ) | |
| // support: jquery <1.6.3 | |
| // http://bugs.jquery.com/ticket/9413 | |
| .removeData( $.camelCase( this.widgetFullName ) ); | |
| this.widget() | |
| .unbind( this.eventNamespace ) | |
| .removeAttr( "aria-disabled" ) | |
| .removeClass( | |
| this.widgetFullName + "-disabled " + | |
| "ui-state-disabled" ); | |
| // clean up events and states | |
| this.bindings.unbind( this.eventNamespace ); | |
| this.hoverable.removeClass( "ui-state-hover" ); | |
| this.focusable.removeClass( "ui-state-focus" ); | |
| }, | |
| _destroy: $.noop, | |
| widget: function() { | |
| return this.element; | |
| }, | |
| option: function( key, value ) { | |
| var options = key, | |
| parts, | |
| curOption, | |
| i; | |
| if ( arguments.length === 0 ) { | |
| // don't return a reference to the internal hash | |
| return $.widget.extend( {}, this.options ); | |
| } | |
| if ( typeof key === "string" ) { | |
| // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } } | |
| options = {}; | |
| parts = key.split( "." ); | |
| key = parts.shift(); | |
| if ( parts.length ) { | |
| curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] ); | |
| for ( i = 0; i < parts.length - 1; i++ ) { | |
| curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {}; | |
| curOption = curOption[ parts[ i ] ]; | |
| } | |
| key = parts.pop(); | |
| if ( value === undefined ) { | |
| return curOption[ key ] === undefined ? null : curOption[ key ]; | |
| } | |
| curOption[ key ] = value; | |
| } else { | |
| if ( value === undefined ) { | |
| return this.options[ key ] === undefined ? null : this.options[ key ]; | |
| } | |
| options[ key ] = value; | |
| } | |
| } | |
| this._setOptions( options ); | |
| return this; | |
| }, | |
| _setOptions: function( options ) { | |
| var key; | |
| for ( key in options ) { | |
| this._setOption( key, options[ key ] ); | |
| } | |
| return this; | |
| }, | |
| _setOption: function( key, value ) { | |
| this.options[ key ] = value; | |
| if ( key === "disabled" ) { | |
| this.widget() | |
| .toggleClass( this.widgetFullName + "-disabled", !!value ); | |
| this.hoverable.removeClass( "ui-state-hover" ); | |
| this.focusable.removeClass( "ui-state-focus" ); | |
| } | |
| return this; | |
| }, | |
| enable: function() { | |
| return this._setOptions({ disabled: false }); | |
| }, | |
| disable: function() { | |
| return this._setOptions({ disabled: true }); | |
| }, | |
| _on: function( suppressDisabledCheck, element, handlers ) { | |
| var delegateElement, | |
| instance = this; | |
| // no suppressDisabledCheck flag, shuffle arguments | |
| if ( typeof suppressDisabledCheck !== "boolean" ) { | |
| handlers = element; | |
| element = suppressDisabledCheck; | |
| suppressDisabledCheck = false; | |
| } | |
| // no element argument, shuffle and use this.element | |
| if ( !handlers ) { | |
| handlers = element; | |
| element = this.element; | |
| delegateElement = this.widget(); | |
| } else { | |
| // accept selectors, DOM elements | |
| element = delegateElement = $( element ); | |
| this.bindings = this.bindings.add( element ); | |
| } | |
| $.each( handlers, function( event, handler ) { | |
| function handlerProxy() { | |
| // allow widgets to customize the disabled handling | |
| // - disabled as an array instead of boolean | |
| // - disabled class as method for disabling individual parts | |
| if ( !suppressDisabledCheck && | |
| ( instance.options.disabled === true || | |
| $( this ).hasClass( "ui-state-disabled" ) ) ) { | |
| return; | |
| } | |
| return ( typeof handler === "string" ? instance[ handler ] : handler ) | |
| .apply( instance, arguments ); | |
| } | |
| // copy the guid so direct unbinding works | |
| if ( typeof handler !== "string" ) { | |
| handlerProxy.guid = handler.guid = | |
| handler.guid || handlerProxy.guid || $.guid++; | |
| } | |
| var match = event.match( /^(\w+)\s*(.*)$/ ), | |
| eventName = match[1] + instance.eventNamespace, | |
| selector = match[2]; | |
| if ( selector ) { | |
| delegateElement.delegate( selector, eventName, handlerProxy ); | |
| } else { | |
| element.bind( eventName, handlerProxy ); | |
| } | |
| }); | |
| }, | |
| _off: function( element, eventName ) { | |
| eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace; | |
| element.unbind( eventName ).undelegate( eventName ); | |
| }, | |
| _delay: function( handler, delay ) { | |
| function handlerProxy() { | |
| return ( typeof handler === "string" ? instance[ handler ] : handler ) | |
| .apply( instance, arguments ); | |
| } | |
| var instance = this; | |
| return setTimeout( handlerProxy, delay || 0 ); | |
| }, | |
| _hoverable: function( element ) { | |
| this.hoverable = this.hoverable.add( element ); | |
| this._on( element, { | |
| mouseenter: function( event ) { | |
| $( event.currentTarget ).addClass( "ui-state-hover" ); | |
| }, | |
| mouseleave: function( event ) { | |
| $( event.currentTarget ).removeClass( "ui-state-hover" ); | |
| } | |
| }); | |
| }, | |
| _focusable: function( element ) { | |
| this.focusable = this.focusable.add( element ); | |
| this._on( element, { | |
| focusin: function( event ) { | |
| $( event.currentTarget ).addClass( "ui-state-focus" ); | |
| }, | |
| focusout: function( event ) { | |
| $( event.currentTarget ).removeClass( "ui-state-focus" ); | |
| } | |
| }); | |
| }, | |
| _trigger: function( type, event, data ) { | |
| var prop, orig, | |
| callback = this.options[ type ]; | |
| data = data || {}; | |
| event = $.Event( event ); | |
| event.type = ( type === this.widgetEventPrefix ? | |
| type : | |
| this.widgetEventPrefix + type ).toLowerCase(); | |
| // the original event may come from any element | |
| // so we need to reset the target on the new event | |
| event.target = this.element[ 0 ]; | |
| // copy original event properties over to the new event | |
| orig = event.originalEvent; | |
| if ( orig ) { | |
| for ( prop in orig ) { | |
| if ( !( prop in event ) ) { | |
| event[ prop ] = orig[ prop ]; | |
| } | |
| } | |
| } | |
| this.element.trigger( event, data ); | |
| return !( $.isFunction( callback ) && | |
| callback.apply( this.element[0], [ event ].concat( data ) ) === false || | |
| event.isDefaultPrevented() ); | |
| } | |
| }; | |
| $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) { | |
| $.Widget.prototype[ "_" + method ] = function( element, options, callback ) { | |
| if ( typeof options === "string" ) { | |
| options = { effect: options }; | |
| } | |
| var hasOptions, | |
| effectName = !options ? | |
| method : | |
| options === true || typeof options === "number" ? | |
| defaultEffect : | |
| options.effect || defaultEffect; | |
| options = options || {}; | |
| if ( typeof options === "number" ) { | |
| options = { duration: options }; | |
| } | |
| hasOptions = !$.isEmptyObject( options ); | |
| options.complete = callback; | |
| if ( options.delay ) { | |
| element.delay( options.delay ); | |
| } | |
| if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) { | |
| element[ method ]( options ); | |
| } else if ( effectName !== method && element[ effectName ] ) { | |
| element[ effectName ]( options.duration, options.easing, callback ); | |
| } else { | |
| element.queue(function( next ) { | |
| $( this )[ method ](); | |
| if ( callback ) { | |
| callback.call( element[ 0 ] ); | |
| } | |
| next(); | |
| }); | |
| } | |
| }; | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var rcapitals = /[A-Z]/g, | |
| replaceFunction = function( c ) { | |
| return "-" + c.toLowerCase(); | |
| }; | |
| $.extend( $.Widget.prototype, { | |
| _getCreateOptions: function() { | |
| var option, value, | |
| elem = this.element[ 0 ], | |
| options = {}; | |
| // | |
| if ( !$.mobile.getAttribute( elem, "defaults" ) ) { | |
| for ( option in this.options ) { | |
| value = $.mobile.getAttribute( elem, option.replace( rcapitals, replaceFunction ) ); | |
| if ( value != null ) { | |
| options[ option ] = value; | |
| } | |
| } | |
| } | |
| return options; | |
| } | |
| }); | |
| //TODO: Remove in 1.5 for backcompat only | |
| $.mobile.widget = $.Widget; | |
| })( jQuery ); | |
| (function( $ ) { | |
| // TODO move loader class down into the widget settings | |
| var loaderClass = "ui-loader", $html = $( "html" ); | |
| $.widget( "mobile.loader", { | |
| // NOTE if the global config settings are defined they will override these | |
| // options | |
| options: { | |
| // the theme for the loading message | |
| theme: "a", | |
| // whether the text in the loading message is shown | |
| textVisible: false, | |
| // custom html for the inner content of the loading message | |
| html: "", | |
| // the text to be displayed when the popup is shown | |
| text: "loading" | |
| }, | |
| defaultHtml: "<div class='" + loaderClass + "'>" + | |
| "<span class='ui-icon-loading'></span>" + | |
| "<h1></h1>" + | |
| "</div>", | |
| // For non-fixed supportin browsers. Position at y center (if scrollTop supported), above the activeBtn (if defined), or just 100px from top | |
| fakeFixLoader: function() { | |
| var activeBtn = $( "." + $.mobile.activeBtnClass ).first(); | |
| this.element | |
| .css({ | |
| top: $.support.scrollTop && this.window.scrollTop() + this.window.height() / 2 || | |
| activeBtn.length && activeBtn.offset().top || 100 | |
| }); | |
| }, | |
| // check position of loader to see if it appears to be "fixed" to center | |
| // if not, use abs positioning | |
| checkLoaderPosition: function() { | |
| var offset = this.element.offset(), | |
| scrollTop = this.window.scrollTop(), | |
| screenHeight = $.mobile.getScreenHeight(); | |
| if ( offset.top < scrollTop || ( offset.top - scrollTop ) > screenHeight ) { | |
| this.element.addClass( "ui-loader-fakefix" ); | |
| this.fakeFixLoader(); | |
| this.window | |
| .unbind( "scroll", this.checkLoaderPosition ) | |
| .bind( "scroll", $.proxy( this.fakeFixLoader, this ) ); | |
| } | |
| }, | |
| resetHtml: function() { | |
| this.element.html( $( this.defaultHtml ).html() ); | |
| }, | |
| // Turn on/off page loading message. Theme doubles as an object argument | |
| // with the following shape: { theme: '', text: '', html: '', textVisible: '' } | |
| // NOTE that the $.mobile.loading* settings and params past the first are deprecated | |
| // TODO sweet jesus we need to break some of this out | |
| show: function( theme, msgText, textonly ) { | |
| var textVisible, message, loadSettings; | |
| this.resetHtml(); | |
| // use the prototype options so that people can set them globally at | |
| // mobile init. Consistency, it's what's for dinner | |
| if ( $.type( theme ) === "object" ) { | |
| loadSettings = $.extend( {}, this.options, theme ); | |
| theme = loadSettings.theme; | |
| } else { | |
| loadSettings = this.options; | |
| // here we prefer the theme value passed as a string argument, then | |
| // we prefer the global option because we can't use undefined default | |
| // prototype options, then the prototype option | |
| theme = theme || loadSettings.theme; | |
| } | |
| // set the message text, prefer the param, then the settings object | |
| // then loading message | |
| message = msgText || ( loadSettings.text === false ? "" : loadSettings.text ); | |
| // prepare the dom | |
| $html.addClass( "ui-loading" ); | |
| textVisible = loadSettings.textVisible; | |
| // add the proper css given the options (theme, text, etc) | |
| // Force text visibility if the second argument was supplied, or | |
| // if the text was explicitly set in the object args | |
| this.element.attr("class", loaderClass + | |
| " ui-corner-all ui-body-" + theme + | |
| " ui-loader-" + ( textVisible || msgText || theme.text ? "verbose" : "default" ) + | |
| ( loadSettings.textonly || textonly ? " ui-loader-textonly" : "" ) ); | |
| // TODO verify that jquery.fn.html is ok to use in both cases here | |
| // this might be overly defensive in preventing unknowing xss | |
| // if the html attribute is defined on the loading settings, use that | |
| // otherwise use the fallbacks from above | |
| if ( loadSettings.html ) { | |
| this.element.html( loadSettings.html ); | |
| } else { | |
| this.element.find( "h1" ).text( message ); | |
| } | |
| // attach the loader to the DOM | |
| this.element.appendTo( $.mobile.pageContainer ); | |
| // check that the loader is visible | |
| this.checkLoaderPosition(); | |
| // on scroll check the loader position | |
| this.window.bind( "scroll", $.proxy( this.checkLoaderPosition, this ) ); | |
| }, | |
| hide: function() { | |
| $html.removeClass( "ui-loading" ); | |
| if ( this.options.text ) { | |
| this.element.removeClass( "ui-loader-fakefix" ); | |
| } | |
| $.mobile.window.unbind( "scroll", this.fakeFixLoader ); | |
| $.mobile.window.unbind( "scroll", this.checkLoaderPosition ); | |
| } | |
| }); | |
| })(jQuery, this); | |
| /*! | |
| * jQuery hashchange event - v1.3 - 7/21/2010 | |
| * http://benalman.com/projects/jquery-hashchange-plugin/ | |
| * | |
| * Copyright (c) 2010 "Cowboy" Ben Alman | |
| * Dual licensed under the MIT and GPL licenses. | |
| * http://benalman.com/about/license/ | |
| */ | |
| // Script: jQuery hashchange event | |
| // | |
| // *Version: 1.3, Last updated: 7/21/2010* | |
| // | |
| // Project Home - http://benalman.com/projects/jquery-hashchange-plugin/ | |
| // GitHub - http://github.com/cowboy/jquery-hashchange/ | |
| // Source - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js | |
| // (Minified) - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (0.8kb gzipped) | |
| // | |
| // About: License | |
| // | |
| // Copyright (c) 2010 "Cowboy" Ben Alman, | |
| // Dual licensed under the MIT and GPL licenses. | |
| // http://benalman.com/about/license/ | |
| // | |
| // About: Examples | |
| // | |
| // These working examples, complete with fully commented code, illustrate a few | |
| // ways in which this plugin can be used. | |
| // | |
| // hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/ | |
| // document.domain - http://benalman.com/code/projects/jquery-hashchange/examples/document_domain/ | |
| // | |
| // About: Support and Testing | |
| // | |
| // Information about what version or versions of jQuery this plugin has been | |
| // tested with, what browsers it has been tested in, and where the unit tests | |
| // reside (so you can test it yourself). | |
| // | |
| // jQuery Versions - 1.2.6, 1.3.2, 1.4.1, 1.4.2 | |
| // Browsers Tested - Internet Explorer 6-8, Firefox 2-4, Chrome 5-6, Safari 3.2-5, | |
| // Opera 9.6-10.60, iPhone 3.1, Android 1.6-2.2, BlackBerry 4.6-5. | |
| // Unit Tests - http://benalman.com/code/projects/jquery-hashchange/unit/ | |
| // | |
| // About: Known issues | |
| // | |
| // While this jQuery hashchange event implementation is quite stable and | |
| // robust, there are a few unfortunate browser bugs surrounding expected | |
| // hashchange event-based behaviors, independent of any JavaScript | |
| // window.onhashchange abstraction. See the following examples for more | |
| // information: | |
| // | |
| // Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/ | |
| // Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/ | |
| // WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/ | |
| // Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/ | |
| // | |
| // Also note that should a browser natively support the window.onhashchange | |
| // event, but not report that it does, the fallback polling loop will be used. | |
| // | |
| // About: Release History | |
| // | |
| // 1.3 - (7/21/2010) Reorganized IE6/7 Iframe code to make it more | |
| // "removable" for mobile-only development. Added IE6/7 document.title | |
| // support. Attempted to make Iframe as hidden as possible by using | |
| // techniques from http://www.paciellogroup.com/blog/?p=604. Added | |
| // support for the "shortcut" format $(window).hashchange( fn ) and | |
| // $(window).hashchange() like jQuery provides for built-in events. | |
| // Renamed jQuery.hashchangeDelay to <jQuery.fn.hashchange.delay> and | |
| // lowered its default value to 50. Added <jQuery.fn.hashchange.domain> | |
| // and <jQuery.fn.hashchange.src> properties plus document-domain.html | |
| // file to address access denied issues when setting document.domain in | |
| // IE6/7. | |
| // 1.2 - (2/11/2010) Fixed a bug where coming back to a page using this plugin | |
| // from a page on another domain would cause an error in Safari 4. Also, | |
| // IE6/7 Iframe is now inserted after the body (this actually works), | |
| // which prevents the page from scrolling when the event is first bound. | |
| // Event can also now be bound before DOM ready, but it won't be usable | |
| // before then in IE6/7. | |
| // 1.1 - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug | |
| // where browser version is incorrectly reported as 8.0, despite | |
| // inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag. | |
| // 1.0 - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special | |
| // window.onhashchange functionality into a separate plugin for users | |
| // who want just the basic event & back button support, without all the | |
| // extra awesomeness that BBQ provides. This plugin will be included as | |
| // part of jQuery BBQ, but also be available separately. | |
| (function($,window,undefined){ | |
| '$:nomunge'; // Used by YUI compressor. | |
| // Reused string. | |
| var str_hashchange = 'hashchange', | |
| // Method / object references. | |
| doc = document, | |
| fake_onhashchange, | |
| special = $.event.special, | |
| // Does the browser support window.onhashchange? Note that IE8 running in | |
| // IE7 compatibility mode reports true for 'onhashchange' in window, even | |
| // though the event isn't supported, so also test document.documentMode. | |
| doc_mode = doc.documentMode, | |
| supports_onhashchange = 'on' + str_hashchange in window && ( doc_mode === undefined || doc_mode > 7 ); | |
| // Get location.hash (or what you'd expect location.hash to be) sans any | |
| // leading #. Thanks for making this necessary, Firefox! | |
| function get_fragment( url ) { | |
| url = url || location.href; | |
| return '#' + url.replace( /^[^#]*#?(.*)$/, '$1' ); | |
| }; | |
| // Method: jQuery.fn.hashchange | |
| // | |
| // Bind a handler to the window.onhashchange event or trigger all bound | |
| // window.onhashchange event handlers. This behavior is consistent with | |
| // jQuery's built-in event handlers. | |
| // | |
| // Usage: | |
| // | |
| // > jQuery(window).hashchange( [ handler ] ); | |
| // | |
| // Arguments: | |
| // | |
| // handler - (Function) Optional handler to be bound to the hashchange | |
| // event. This is a "shortcut" for the more verbose form: | |
| // jQuery(window).bind( 'hashchange', handler ). If handler is omitted, | |
| // all bound window.onhashchange event handlers will be triggered. This | |
| // is a shortcut for the more verbose | |
| // jQuery(window).trigger( 'hashchange' ). These forms are described in | |
| // the <hashchange event> section. | |
| // | |
| // Returns: | |
| // | |
| // (jQuery) The initial jQuery collection of elements. | |
| // Allow the "shortcut" format $(elem).hashchange( fn ) for binding and | |
| // $(elem).hashchange() for triggering, like jQuery does for built-in events. | |
| $.fn[ str_hashchange ] = function( fn ) { | |
| return fn ? this.bind( str_hashchange, fn ) : this.trigger( str_hashchange ); | |
| }; | |
| // Property: jQuery.fn.hashchange.delay | |
| // | |
| // The numeric interval (in milliseconds) at which the <hashchange event> | |
| // polling loop executes. Defaults to 50. | |
| // Property: jQuery.fn.hashchange.domain | |
| // | |
| // If you're setting document.domain in your JavaScript, and you want hash | |
| // history to work in IE6/7, not only must this property be set, but you must | |
| // also set document.domain BEFORE jQuery is loaded into the page. This | |
| // property is only applicable if you are supporting IE6/7 (or IE8 operating | |
| // in "IE7 compatibility" mode). | |
| // | |
| // In addition, the <jQuery.fn.hashchange.src> property must be set to the | |
| // path of the included "document-domain.html" file, which can be renamed or | |
| // modified if necessary (note that the document.domain specified must be the | |
| // same in both your main JavaScript as well as in this file). | |
| // | |
| // Usage: | |
| // | |
| // jQuery.fn.hashchange.domain = document.domain; | |
| // Property: jQuery.fn.hashchange.src | |
| // | |
| // If, for some reason, you need to specify an Iframe src file (for example, | |
| // when setting document.domain as in <jQuery.fn.hashchange.domain>), you can | |
| // do so using this property. Note that when using this property, history | |
| // won't be recorded in IE6/7 until the Iframe src file loads. This property | |
| // is only applicable if you are supporting IE6/7 (or IE8 operating in "IE7 | |
| // compatibility" mode). | |
| // | |
| // Usage: | |
| // | |
| // jQuery.fn.hashchange.src = 'path/to/file.html'; | |
| $.fn[ str_hashchange ].delay = 50; | |
| /* | |
| $.fn[ str_hashchange ].domain = null; | |
| $.fn[ str_hashchange ].src = null; | |
| */ | |
| // Event: hashchange event | |
| // | |
| // Fired when location.hash changes. In browsers that support it, the native | |
| // HTML5 window.onhashchange event is used, otherwise a polling loop is | |
| // initialized, running every <jQuery.fn.hashchange.delay> milliseconds to | |
| // see if the hash has changed. In IE6/7 (and IE8 operating in "IE7 | |
| // compatibility" mode), a hidden Iframe is created to allow the back button | |
| // and hash-based history to work. | |
| // | |
| // Usage as described in <jQuery.fn.hashchange>: | |
| // | |
| // > // Bind an event handler. | |
| // > jQuery(window).hashchange( function(e) { | |
| // > var hash = location.hash; | |
| // > ... | |
| // > }); | |
| // > | |
| // > // Manually trigger the event handler. | |
| // > jQuery(window).hashchange(); | |
| // | |
| // A more verbose usage that allows for event namespacing: | |
| // | |
| // > // Bind an event handler. | |
| // > jQuery(window).bind( 'hashchange', function(e) { | |
| // > var hash = location.hash; | |
| // > ... | |
| // > }); | |
| // > | |
| // > // Manually trigger the event handler. | |
| // > jQuery(window).trigger( 'hashchange' ); | |
| // | |
| // Additional Notes: | |
| // | |
| // * The polling loop and Iframe are not created until at least one handler | |
| // is actually bound to the 'hashchange' event. | |
| // * If you need the bound handler(s) to execute immediately, in cases where | |
| // a location.hash exists on page load, via bookmark or page refresh for | |
| // example, use jQuery(window).hashchange() or the more verbose | |
| // jQuery(window).trigger( 'hashchange' ). | |
| // * The event can be bound before DOM ready, but since it won't be usable | |
| // before then in IE6/7 (due to the necessary Iframe), recommended usage is | |
| // to bind it inside a DOM ready handler. | |
| // Override existing $.event.special.hashchange methods (allowing this plugin | |
| // to be defined after jQuery BBQ in BBQ's source code). | |
| special[ str_hashchange ] = $.extend( special[ str_hashchange ], { | |
| // Called only when the first 'hashchange' event is bound to window. | |
| setup: function() { | |
| // If window.onhashchange is supported natively, there's nothing to do.. | |
| if ( supports_onhashchange ) { return false; } | |
| // Otherwise, we need to create our own. And we don't want to call this | |
| // until the user binds to the event, just in case they never do, since it | |
| // will create a polling loop and possibly even a hidden Iframe. | |
| $( fake_onhashchange.start ); | |
| }, | |
| // Called only when the last 'hashchange' event is unbound from window. | |
| teardown: function() { | |
| // If window.onhashchange is supported natively, there's nothing to do.. | |
| if ( supports_onhashchange ) { return false; } | |
| // Otherwise, we need to stop ours (if possible). | |
| $( fake_onhashchange.stop ); | |
| } | |
| }); | |
| // fake_onhashchange does all the work of triggering the window.onhashchange | |
| // event for browsers that don't natively support it, including creating a | |
| // polling loop to watch for hash changes and in IE 6/7 creating a hidden | |
| // Iframe to enable back and forward. | |
| fake_onhashchange = (function(){ | |
| var self = {}, | |
| timeout_id, | |
| // Remember the initial hash so it doesn't get triggered immediately. | |
| last_hash = get_fragment(), | |
| fn_retval = function(val){ return val; }, | |
| history_set = fn_retval, | |
| history_get = fn_retval; | |
| // Start the polling loop. | |
| self.start = function() { | |
| timeout_id || poll(); | |
| }; | |
| // Stop the polling loop. | |
| self.stop = function() { | |
| timeout_id && clearTimeout( timeout_id ); | |
| timeout_id = undefined; | |
| }; | |
| // This polling loop checks every $.fn.hashchange.delay milliseconds to see | |
| // if location.hash has changed, and triggers the 'hashchange' event on | |
| // window when necessary. | |
| function poll() { | |
| var hash = get_fragment(), | |
| history_hash = history_get( last_hash ); | |
| if ( hash !== last_hash ) { | |
| history_set( last_hash = hash, history_hash ); | |
| $(window).trigger( str_hashchange ); | |
| } else if ( history_hash !== last_hash ) { | |
| location.href = location.href.replace( /#.*/, '' ) + history_hash; | |
| } | |
| timeout_id = setTimeout( poll, $.fn[ str_hashchange ].delay ); | |
| }; | |
| // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv | |
| // vvvvvvvvvvvvvvvvvvv REMOVE IF NOT SUPPORTING IE6/7/8 vvvvvvvvvvvvvvvvvvv | |
| // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv | |
| window.attachEvent && !window.addEventListener && !supports_onhashchange && (function(){ | |
| // Not only do IE6/7 need the "magical" Iframe treatment, but so does IE8 | |
| // when running in "IE7 compatibility" mode. | |
| var iframe, | |
| iframe_src; | |
| // When the event is bound and polling starts in IE 6/7, create a hidden | |
| // Iframe for history handling. | |
| self.start = function(){ | |
| if ( !iframe ) { | |
| iframe_src = $.fn[ str_hashchange ].src; | |
| iframe_src = iframe_src && iframe_src + get_fragment(); | |
| // Create hidden Iframe. Attempt to make Iframe as hidden as possible | |
| // by using techniques from http://www.paciellogroup.com/blog/?p=604. | |
| iframe = $('<iframe tabindex="-1" title="empty"/>').hide() | |
| // When Iframe has completely loaded, initialize the history and | |
| // start polling. | |
| .one( 'load', function(){ | |
| iframe_src || history_set( get_fragment() ); | |
| poll(); | |
| }) | |
| // Load Iframe src if specified, otherwise nothing. | |
| .attr( 'src', iframe_src || 'javascript:0' ) | |
| // Append Iframe after the end of the body to prevent unnecessary | |
| // initial page scrolling (yes, this works). | |
| .insertAfter( 'body' )[0].contentWindow; | |
| // Whenever `document.title` changes, update the Iframe's title to | |
| // prettify the back/next history menu entries. Since IE sometimes | |
| // errors with "Unspecified error" the very first time this is set | |
| // (yes, very useful) wrap this with a try/catch block. | |
| doc.onpropertychange = function(){ | |
| try { | |
| if ( event.propertyName === 'title' ) { | |
| iframe.document.title = doc.title; | |
| } | |
| } catch(e) {} | |
| }; | |
| } | |
| }; | |
| // Override the "stop" method since an IE6/7 Iframe was created. Even | |
| // if there are no longer any bound event handlers, the polling loop | |
| // is still necessary for back/next to work at all! | |
| self.stop = fn_retval; | |
| // Get history by looking at the hidden Iframe's location.hash. | |
| history_get = function() { | |
| return get_fragment( iframe.location.href ); | |
| }; | |
| // Set a new history item by opening and then closing the Iframe | |
| // document, *then* setting its location.hash. If document.domain has | |
| // been set, update that as well. | |
| history_set = function( hash, history_hash ) { | |
| var iframe_doc = iframe.document, | |
| domain = $.fn[ str_hashchange ].domain; | |
| if ( hash !== history_hash ) { | |
| // Update Iframe with any initial `document.title` that might be set. | |
| iframe_doc.title = doc.title; | |
| // Opening the Iframe's document after it has been closed is what | |
| // actually adds a history entry. | |
| iframe_doc.open(); | |
| // Set document.domain for the Iframe document as well, if necessary. | |
| domain && iframe_doc.write( '\x3cscript>document.domain="' + domain + '"\x3c/script>' ); | |
| iframe_doc.close(); | |
| // Update the Iframe's hash, for great justice. | |
| iframe.location.hash = hash; | |
| } | |
| }; | |
| })(); | |
| // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| // ^^^^^^^^^^^^^^^^^^^ REMOVE IF NOT SUPPORTING IE6/7/8 ^^^^^^^^^^^^^^^^^^^ | |
| // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| return self; | |
| })(); | |
| })(jQuery,this); | |
| (function( $, undefined ) { | |
| /*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas. Dual MIT/BSD license */ | |
| window.matchMedia = window.matchMedia || (function( doc, undefined ) { | |
| var bool, | |
| docElem = doc.documentElement, | |
| refNode = docElem.firstElementChild || docElem.firstChild, | |
| // fakeBody required for <FF4 when executed in <head> | |
| fakeBody = doc.createElement( "body" ), | |
| div = doc.createElement( "div" ); | |
| div.id = "mq-test-1"; | |
| div.style.cssText = "position:absolute;top:-100em"; | |
| fakeBody.style.background = "none"; | |
| fakeBody.appendChild(div); | |
| return function(q){ | |
| div.innerHTML = "­<style media=\"" + q + "\"> #mq-test-1 { width: 42px; }</style>"; | |
| docElem.insertBefore( fakeBody, refNode ); | |
| bool = div.offsetWidth === 42; | |
| docElem.removeChild( fakeBody ); | |
| return { | |
| matches: bool, | |
| media: q | |
| }; | |
| }; | |
| }( document )); | |
| // $.mobile.media uses matchMedia to return a boolean. | |
| $.mobile.media = function( q ) { | |
| return window.matchMedia( q ).matches; | |
| }; | |
| })(jQuery); | |
| (function( $, undefined ) { | |
| var support = { | |
| touch: "ontouchend" in document | |
| }; | |
| $.mobile.support = $.mobile.support || {}; | |
| $.extend( $.support, support ); | |
| $.extend( $.mobile.support, support ); | |
| }( jQuery )); | |
| (function( $, undefined ) { | |
| $.extend( $.support, { | |
| orientation: "orientation" in window && "onorientationchange" in window | |
| }); | |
| }( jQuery )); | |
| (function( $, undefined ) { | |
| // thx Modernizr | |
| function propExists( prop ) { | |
| var uc_prop = prop.charAt( 0 ).toUpperCase() + prop.substr( 1 ), | |
| props = ( prop + " " + vendors.join( uc_prop + " " ) + uc_prop ).split( " " ), | |
| v; | |
| for ( v in props ) { | |
| if ( fbCSS[ props[ v ] ] !== undefined ) { | |
| return true; | |
| } | |
| } | |
| } | |
| var fakeBody = $( "<body>" ).prependTo( "html" ), | |
| fbCSS = fakeBody[ 0 ].style, | |
| vendors = [ "Webkit", "Moz", "O" ], | |
| webos = "palmGetResource" in window, //only used to rule out scrollTop | |
| operamini = window.operamini && ({}).toString.call( window.operamini ) === "[object OperaMini]", | |
| bb = window.blackberry && !propExists( "-webkit-transform" ), //only used to rule out box shadow, as it's filled opaque on BB 5 and lower | |
| nokiaLTE7_3; | |
| // inline SVG support test | |
| function inlineSVG() { | |
| // Thanks Modernizr & Erik Dahlstrom | |
| var w = window, | |
| svg = !!w.document.createElementNS && !!w.document.createElementNS( "http://www.w3.org/2000/svg", "svg" ).createSVGRect && !( w.opera && navigator.userAgent.indexOf( "Chrome" ) === -1 ), | |
| support = function( data ) { | |
| if ( !( data && svg ) ) { | |
| $( "html" ).addClass( "ui-nosvg" ); | |
| } | |
| }, | |
| img = new w.Image(); | |
| img.onerror = function() { | |
| support( false ); | |
| }; | |
| img.onload = function() { | |
| support( img.width === 1 && img.height === 1 ); | |
| }; | |
| img.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="; | |
| } | |
| function transform3dTest() { | |
| var mqProp = "transform-3d", | |
| // Because the `translate3d` test below throws false positives in Android: | |
| ret = $.mobile.media( "(-" + vendors.join( "-" + mqProp + "),(-" ) + "-" + mqProp + "),(" + mqProp + ")" ), | |
| el, transforms, t; | |
| if ( ret ) { | |
| return !!ret; | |
| } | |
| el = document.createElement( "div" ); | |
| transforms = { | |
| // We’re omitting Opera for the time being; MS uses unprefixed. | |
| "MozTransform": "-moz-transform", | |
| "transform": "transform" | |
| }; | |
| fakeBody.append( el ); | |
| for ( t in transforms ) { | |
| if ( el.style[ t ] !== undefined ) { | |
| el.style[ t ] = "translate3d( 100px, 1px, 1px )"; | |
| ret = window.getComputedStyle( el ).getPropertyValue( transforms[ t ] ); | |
| } | |
| } | |
| return ( !!ret && ret !== "none" ); | |
| } | |
| // Test for dynamic-updating base tag support ( allows us to avoid href,src attr rewriting ) | |
| function baseTagTest() { | |
| var fauxBase = location.protocol + "//" + location.host + location.pathname + "ui-dir/", | |
| base = $( "head base" ), | |
| fauxEle = null, | |
| href = "", | |
| link, rebase; | |
| if ( !base.length ) { | |
| base = fauxEle = $( "<base>", { "href": fauxBase }).appendTo( "head" ); | |
| } else { | |
| href = base.attr( "href" ); | |
| } | |
| link = $( "<a href='testurl' />" ).prependTo( fakeBody ); | |
| rebase = link[ 0 ].href; | |
| base[ 0 ].href = href || location.pathname; | |
| if ( fauxEle ) { | |
| fauxEle.remove(); | |
| } | |
| return rebase.indexOf( fauxBase ) === 0; | |
| } | |
| // Thanks Modernizr | |
| function cssPointerEventsTest() { | |
| var element = document.createElement( "x" ), | |
| documentElement = document.documentElement, | |
| getComputedStyle = window.getComputedStyle, | |
| supports; | |
| if ( !( "pointerEvents" in element.style ) ) { | |
| return false; | |
| } | |
| element.style.pointerEvents = "auto"; | |
| element.style.pointerEvents = "x"; | |
| documentElement.appendChild( element ); | |
| supports = getComputedStyle && | |
| getComputedStyle( element, "" ).pointerEvents === "auto"; | |
| documentElement.removeChild( element ); | |
| return !!supports; | |
| } | |
| function boundingRect() { | |
| var div = document.createElement( "div" ); | |
| return typeof div.getBoundingClientRect !== "undefined"; | |
| } | |
| // non-UA-based IE version check by James Padolsey, modified by jdalton - from http://gist.github.com/527683 | |
| // allows for inclusion of IE 6+, including Windows Mobile 7 | |
| $.extend( $.mobile, { browser: {} } ); | |
| $.mobile.browser.oldIE = (function() { | |
| var v = 3, | |
| div = document.createElement( "div" ), | |
| a = div.all || []; | |
| do { | |
| div.innerHTML = "<!--[if gt IE " + ( ++v ) + "]><br><![endif]-->"; | |
| } while( a[0] ); | |
| return v > 4 ? v : !v; | |
| })(); | |
| function fixedPosition() { | |
| var w = window, | |
| ua = navigator.userAgent, | |
| platform = navigator.platform, | |
| // Rendering engine is Webkit, and capture major version | |
| wkmatch = ua.match( /AppleWebKit\/([0-9]+)/ ), | |
| wkversion = !!wkmatch && wkmatch[ 1 ], | |
| ffmatch = ua.match( /Fennec\/([0-9]+)/ ), | |
| ffversion = !!ffmatch && ffmatch[ 1 ], | |
| operammobilematch = ua.match( /Opera Mobi\/([0-9]+)/ ), | |
| omversion = !!operammobilematch && operammobilematch[ 1 ]; | |
| if ( | |
| // iOS 4.3 and older : Platform is iPhone/Pad/Touch and Webkit version is less than 534 (ios5) | |
| ( ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1 || platform.indexOf( "iPod" ) > -1 ) && wkversion && wkversion < 534 ) || | |
| // Opera Mini | |
| ( w.operamini && ({}).toString.call( w.operamini ) === "[object OperaMini]" ) || | |
| ( operammobilematch && omversion < 7458 ) || | |
| //Android lte 2.1: Platform is Android and Webkit version is less than 533 (Android 2.2) | |
| ( ua.indexOf( "Android" ) > -1 && wkversion && wkversion < 533 ) || | |
| // Firefox Mobile before 6.0 - | |
| ( ffversion && ffversion < 6 ) || | |
| // WebOS less than 3 | |
| ( "palmGetResource" in window && wkversion && wkversion < 534 ) || | |
| // MeeGo | |
| ( ua.indexOf( "MeeGo" ) > -1 && ua.indexOf( "NokiaBrowser/8.5.0" ) > -1 ) ) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| $.extend( $.support, { | |
| // Note, Chrome for iOS has an extremely quirky implementation of popstate. | |
| // We've chosen to take the shortest path to a bug fix here for issue #5426 | |
| // See the following link for information about the regex chosen | |
| // https://developers.google.com/chrome/mobile/docs/user-agent#chrome_for_ios_user-agent | |
| pushState: "pushState" in history && | |
| "replaceState" in history && | |
| // When running inside a FF iframe, calling replaceState causes an error | |
| !( window.navigator.userAgent.indexOf( "Firefox" ) >= 0 && window.top !== window ) && | |
| ( window.navigator.userAgent.search(/CriOS/) === -1 ), | |
| mediaquery: $.mobile.media( "only all" ), | |
| cssPseudoElement: !!propExists( "content" ), | |
| touchOverflow: !!propExists( "overflowScrolling" ), | |
| cssTransform3d: transform3dTest(), | |
| boxShadow: !!propExists( "boxShadow" ) && !bb, | |
| fixedPosition: fixedPosition(), | |
| scrollTop: ("pageXOffset" in window || | |
| "scrollTop" in document.documentElement || | |
| "scrollTop" in fakeBody[ 0 ]) && !webos && !operamini, | |
| dynamicBaseTag: baseTagTest(), | |
| cssPointerEvents: cssPointerEventsTest(), | |
| boundingRect: boundingRect(), | |
| inlineSVG: inlineSVG | |
| }); | |
| fakeBody.remove(); | |
| // $.mobile.ajaxBlacklist is used to override ajaxEnabled on platforms that have known conflicts with hash history updates (BB5, Symbian) | |
| // or that generally work better browsing in regular http for full page refreshes (Opera Mini) | |
| // Note: This detection below is used as a last resort. | |
| // We recommend only using these detection methods when all other more reliable/forward-looking approaches are not possible | |
| nokiaLTE7_3 = (function() { | |
| var ua = window.navigator.userAgent; | |
| //The following is an attempt to match Nokia browsers that are running Symbian/s60, with webkit, version 7.3 or older | |
| return ua.indexOf( "Nokia" ) > -1 && | |
| ( ua.indexOf( "Symbian/3" ) > -1 || ua.indexOf( "Series60/5" ) > -1 ) && | |
| ua.indexOf( "AppleWebKit" ) > -1 && | |
| ua.match( /(BrowserNG|NokiaBrowser)\/7\.[0-3]/ ); | |
| })(); | |
| // Support conditions that must be met in order to proceed | |
| // default enhanced qualifications are media query support OR IE 7+ | |
| $.mobile.gradeA = function() { | |
| return ( ( $.support.mediaquery && $.support.cssPseudoElement ) || $.mobile.browser.oldIE && $.mobile.browser.oldIE >= 8 ) && ( $.support.boundingRect || $.fn.jquery.match(/1\.[0-7+]\.[0-9+]?/) !== null ); | |
| }; | |
| $.mobile.ajaxBlacklist = | |
| // BlackBerry browsers, pre-webkit | |
| window.blackberry && !window.WebKitPoint || | |
| // Opera Mini | |
| operamini || | |
| // Symbian webkits pre 7.3 | |
| nokiaLTE7_3; | |
| // Lastly, this workaround is the only way we've found so far to get pre 7.3 Symbian webkit devices | |
| // to render the stylesheets when they're referenced before this script, as we'd recommend doing. | |
| // This simply reappends the CSS in place, which for some reason makes it apply | |
| if ( nokiaLTE7_3 ) { | |
| $(function() { | |
| $( "head link[rel='stylesheet']" ).attr( "rel", "alternate stylesheet" ).attr( "rel", "stylesheet" ); | |
| }); | |
| } | |
| // For ruling out shadows via css | |
| if ( !$.support.boxShadow ) { | |
| $( "html" ).addClass( "ui-noboxshadow" ); | |
| } | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var $win = $.mobile.window, self, | |
| dummyFnToInitNavigate = function() { | |
| }; | |
| $.event.special.beforenavigate = { | |
| setup: function() { | |
| $win.on( "navigate", dummyFnToInitNavigate ); | |
| }, | |
| teardown: function() { | |
| $win.off( "navigate", dummyFnToInitNavigate ); | |
| } | |
| }; | |
| $.event.special.navigate = self = { | |
| bound: false, | |
| pushStateEnabled: true, | |
| originalEventName: undefined, | |
| // If pushstate support is present and push state support is defined to | |
| // be true on the mobile namespace. | |
| isPushStateEnabled: function() { | |
| return $.support.pushState && | |
| $.mobile.pushStateEnabled === true && | |
| this.isHashChangeEnabled(); | |
| }, | |
| // !! assumes mobile namespace is present | |
| isHashChangeEnabled: function() { | |
| return $.mobile.hashListeningEnabled === true; | |
| }, | |
| // TODO a lot of duplication between popstate and hashchange | |
| popstate: function( event ) { | |
| var newEvent = new $.Event( "navigate" ), | |
| beforeNavigate = new $.Event( "beforenavigate" ), | |
| state = event.originalEvent.state || {}; | |
| beforeNavigate.originalEvent = event; | |
| $win.trigger( beforeNavigate ); | |
| if ( beforeNavigate.isDefaultPrevented() ) { | |
| return; | |
| } | |
| if ( event.historyState ) { | |
| $.extend(state, event.historyState); | |
| } | |
| // Make sure the original event is tracked for the end | |
| // user to inspect incase they want to do something special | |
| newEvent.originalEvent = event; | |
| // NOTE we let the current stack unwind because any assignment to | |
| // location.hash will stop the world and run this event handler. By | |
| // doing this we create a similar behavior to hashchange on hash | |
| // assignment | |
| setTimeout(function() { | |
| $win.trigger( newEvent, { | |
| state: state | |
| }); | |
| }, 0); | |
| }, | |
| hashchange: function( event /*, data */ ) { | |
| var newEvent = new $.Event( "navigate" ), | |
| beforeNavigate = new $.Event( "beforenavigate" ); | |
| beforeNavigate.originalEvent = event; | |
| $win.trigger( beforeNavigate ); | |
| if ( beforeNavigate.isDefaultPrevented() ) { | |
| return; | |
| } | |
| // Make sure the original event is tracked for the end | |
| // user to inspect incase they want to do something special | |
| newEvent.originalEvent = event; | |
| // Trigger the hashchange with state provided by the user | |
| // that altered the hash | |
| $win.trigger( newEvent, { | |
| // Users that want to fully normalize the two events | |
| // will need to do history management down the stack and | |
| // add the state to the event before this binding is fired | |
| // TODO consider allowing for the explicit addition of callbacks | |
| // to be fired before this value is set to avoid event timing issues | |
| state: event.hashchangeState || {} | |
| }); | |
| }, | |
| // TODO We really only want to set this up once | |
| // but I'm not clear if there's a beter way to achieve | |
| // this with the jQuery special event structure | |
| setup: function( /* data, namespaces */ ) { | |
| if ( self.bound ) { | |
| return; | |
| } | |
| self.bound = true; | |
| if ( self.isPushStateEnabled() ) { | |
| self.originalEventName = "popstate"; | |
| $win.bind( "popstate.navigate", self.popstate ); | |
| } else if ( self.isHashChangeEnabled() ) { | |
| self.originalEventName = "hashchange"; | |
| $win.bind( "hashchange.navigate", self.hashchange ); | |
| } | |
| } | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var path, $base, dialogHashKey = "&ui-state=dialog"; | |
| $.mobile.path = path = { | |
| uiStateKey: "&ui-state", | |
| // This scary looking regular expression parses an absolute URL or its relative | |
| // variants (protocol, site, document, query, and hash), into the various | |
| // components (protocol, host, path, query, fragment, etc that make up the | |
| // URL as well as some other commonly used sub-parts. When used with RegExp.exec() | |
| // or String.match, it parses the URL into a results array that looks like this: | |
| // | |
| // [0]: http://jblas:[email protected]:8080/mail/inbox?msg=1234&type=unread#msg-content | |
| // [1]: http://jblas:[email protected]:8080/mail/inbox?msg=1234&type=unread | |
| // [2]: http://jblas:[email protected]:8080/mail/inbox | |
| // [3]: http://jblas:[email protected]:8080 | |
| // [4]: http: | |
| // [5]: // | |
| // [6]: jblas:[email protected]:8080 | |
| // [7]: jblas:password | |
| // [8]: jblas | |
| // [9]: password | |
| // [10]: mycompany.com:8080 | |
| // [11]: mycompany.com | |
| // [12]: 8080 | |
| // [13]: /mail/inbox | |
| // [14]: /mail/ | |
| // [15]: inbox | |
| // [16]: ?msg=1234&type=unread | |
| // [17]: #msg-content | |
| // | |
| urlParseRE: /^\s*(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/, | |
| // Abstraction to address xss (Issue #4787) by removing the authority in | |
| // browsers that auto-decode it. All references to location.href should be | |
| // replaced with a call to this method so that it can be dealt with properly here | |
| getLocation: function( url ) { | |
| var parsedUrl = this.parseUrl( url || location.href ), | |
| uri = url ? parsedUrl : location, | |
| // Make sure to parse the url or the location object for the hash because using | |
| // location.hash is autodecoded in firefox, the rest of the url should be from | |
| // the object (location unless we're testing) to avoid the inclusion of the | |
| // authority | |
| hash = parsedUrl.hash; | |
| // mimic the browser with an empty string when the hash is empty | |
| hash = hash === "#" ? "" : hash; | |
| return uri.protocol + | |
| parsedUrl.doubleSlash + | |
| uri.host + | |
| // The pathname must start with a slash if there's a protocol, because you | |
| // can't have a protocol followed by a relative path. Also, it's impossible to | |
| // calculate absolute URLs from relative ones if the absolute one doesn't have | |
| // a leading "/". | |
| ( ( uri.protocol !== "" && uri.pathname.substring( 0, 1 ) !== "/" ) ? | |
| "/" : "" ) + | |
| uri.pathname + | |
| uri.search + | |
| hash; | |
| }, | |
| //return the original document url | |
| getDocumentUrl: function( asParsedObject ) { | |
| return asParsedObject ? $.extend( {}, path.documentUrl ) : path.documentUrl.href; | |
| }, | |
| parseLocation: function() { | |
| return this.parseUrl( this.getLocation() ); | |
| }, | |
| //Parse a URL into a structure that allows easy access to | |
| //all of the URL components by name. | |
| parseUrl: function( url ) { | |
| // If we're passed an object, we'll assume that it is | |
| // a parsed url object and just return it back to the caller. | |
| if ( $.type( url ) === "object" ) { | |
| return url; | |
| } | |
| var matches = path.urlParseRE.exec( url || "" ) || []; | |
| // Create an object that allows the caller to access the sub-matches | |
| // by name. Note that IE returns an empty string instead of undefined, | |
| // like all other browsers do, so we normalize everything so its consistent | |
| // no matter what browser we're running on. | |
| return { | |
| href: matches[ 0 ] || "", | |
| hrefNoHash: matches[ 1 ] || "", | |
| hrefNoSearch: matches[ 2 ] || "", | |
| domain: matches[ 3 ] || "", | |
| protocol: matches[ 4 ] || "", | |
| doubleSlash: matches[ 5 ] || "", | |
| authority: matches[ 6 ] || "", | |
| username: matches[ 8 ] || "", | |
| password: matches[ 9 ] || "", | |
| host: matches[ 10 ] || "", | |
| hostname: matches[ 11 ] || "", | |
| port: matches[ 12 ] || "", | |
| pathname: matches[ 13 ] || "", | |
| directory: matches[ 14 ] || "", | |
| filename: matches[ 15 ] || "", | |
| search: matches[ 16 ] || "", | |
| hash: matches[ 17 ] || "" | |
| }; | |
| }, | |
| //Turn relPath into an asbolute path. absPath is | |
| //an optional absolute path which describes what | |
| //relPath is relative to. | |
| makePathAbsolute: function( relPath, absPath ) { | |
| var absStack, | |
| relStack, | |
| i, d; | |
| if ( relPath && relPath.charAt( 0 ) === "/" ) { | |
| return relPath; | |
| } | |
| relPath = relPath || ""; | |
| absPath = absPath ? absPath.replace( /^\/|(\/[^\/]*|[^\/]+)$/g, "" ) : ""; | |
| absStack = absPath ? absPath.split( "/" ) : []; | |
| relStack = relPath.split( "/" ); | |
| for ( i = 0; i < relStack.length; i++ ) { | |
| d = relStack[ i ]; | |
| switch ( d ) { | |
| case ".": | |
| break; | |
| case "..": | |
| if ( absStack.length ) { | |
| absStack.pop(); | |
| } | |
| break; | |
| default: | |
| absStack.push( d ); | |
| break; | |
| } | |
| } | |
| return "/" + absStack.join( "/" ); | |
| }, | |
| //Returns true if both urls have the same domain. | |
| isSameDomain: function( absUrl1, absUrl2 ) { | |
| return path.parseUrl( absUrl1 ).domain === path.parseUrl( absUrl2 ).domain; | |
| }, | |
| //Returns true for any relative variant. | |
| isRelativeUrl: function( url ) { | |
| // All relative Url variants have one thing in common, no protocol. | |
| return path.parseUrl( url ).protocol === ""; | |
| }, | |
| //Returns true for an absolute url. | |
| isAbsoluteUrl: function( url ) { | |
| return path.parseUrl( url ).protocol !== ""; | |
| }, | |
| //Turn the specified realtive URL into an absolute one. This function | |
| //can handle all relative variants (protocol, site, document, query, fragment). | |
| makeUrlAbsolute: function( relUrl, absUrl ) { | |
| if ( !path.isRelativeUrl( relUrl ) ) { | |
| return relUrl; | |
| } | |
| if ( absUrl === undefined ) { | |
| absUrl = this.documentBase; | |
| } | |
| var relObj = path.parseUrl( relUrl ), | |
| absObj = path.parseUrl( absUrl ), | |
| protocol = relObj.protocol || absObj.protocol, | |
| doubleSlash = relObj.protocol ? relObj.doubleSlash : ( relObj.doubleSlash || absObj.doubleSlash ), | |
| authority = relObj.authority || absObj.authority, | |
| hasPath = relObj.pathname !== "", | |
| pathname = path.makePathAbsolute( relObj.pathname || absObj.filename, absObj.pathname ), | |
| search = relObj.search || ( !hasPath && absObj.search ) || "", | |
| hash = relObj.hash; | |
| return protocol + doubleSlash + authority + pathname + search + hash; | |
| }, | |
| //Add search (aka query) params to the specified url. | |
| addSearchParams: function( url, params ) { | |
| var u = path.parseUrl( url ), | |
| p = ( typeof params === "object" ) ? $.param( params ) : params, | |
| s = u.search || "?"; | |
| return u.hrefNoSearch + s + ( s.charAt( s.length - 1 ) !== "?" ? "&" : "" ) + p + ( u.hash || "" ); | |
| }, | |
| convertUrlToDataUrl: function( absUrl ) { | |
| var u = path.parseUrl( absUrl ); | |
| if ( path.isEmbeddedPage( u ) ) { | |
| // For embedded pages, remove the dialog hash key as in getFilePath(), | |
| // and remove otherwise the Data Url won't match the id of the embedded Page. | |
| return u.hash | |
| .split( dialogHashKey )[0] | |
| .replace( /^#/, "" ) | |
| .replace( /\?.*$/, "" ); | |
| } else if ( path.isSameDomain( u, this.documentBase ) ) { | |
| return u.hrefNoHash.replace( this.documentBase.domain, "" ).split( dialogHashKey )[0]; | |
| } | |
| return window.decodeURIComponent(absUrl); | |
| }, | |
| //get path from current hash, or from a file path | |
| get: function( newPath ) { | |
| if ( newPath === undefined ) { | |
| newPath = path.parseLocation().hash; | |
| } | |
| return path.stripHash( newPath ).replace( /[^\/]*\.[^\/*]+$/, "" ); | |
| }, | |
| //set location hash to path | |
| set: function( path ) { | |
| location.hash = path; | |
| }, | |
| //test if a given url (string) is a path | |
| //NOTE might be exceptionally naive | |
| isPath: function( url ) { | |
| return ( /\// ).test( url ); | |
| }, | |
| //return a url path with the window's location protocol/hostname/pathname removed | |
| clean: function( url ) { | |
| return url.replace( this.documentBase.domain, "" ); | |
| }, | |
| //just return the url without an initial # | |
| stripHash: function( url ) { | |
| return url.replace( /^#/, "" ); | |
| }, | |
| stripQueryParams: function( url ) { | |
| return url.replace( /\?.*$/, "" ); | |
| }, | |
| //remove the preceding hash, any query params, and dialog notations | |
| cleanHash: function( hash ) { | |
| return path.stripHash( hash.replace( /\?.*$/, "" ).replace( dialogHashKey, "" ) ); | |
| }, | |
| isHashValid: function( hash ) { | |
| return ( /^#[^#]+$/ ).test( hash ); | |
| }, | |
| //check whether a url is referencing the same domain, or an external domain or different protocol | |
| //could be mailto, etc | |
| isExternal: function( url ) { | |
| var u = path.parseUrl( url ); | |
| return u.protocol && u.domain !== this.documentUrl.domain ? true : false; | |
| }, | |
| hasProtocol: function( url ) { | |
| return ( /^(:?\w+:)/ ).test( url ); | |
| }, | |
| isEmbeddedPage: function( url ) { | |
| var u = path.parseUrl( url ); | |
| //if the path is absolute, then we need to compare the url against | |
| //both the this.documentUrl and the documentBase. The main reason for this | |
| //is that links embedded within external documents will refer to the | |
| //application document, whereas links embedded within the application | |
| //document will be resolved against the document base. | |
| if ( u.protocol !== "" ) { | |
| return ( !this.isPath(u.hash) && u.hash && ( u.hrefNoHash === this.documentUrl.hrefNoHash || ( this.documentBaseDiffers && u.hrefNoHash === this.documentBase.hrefNoHash ) ) ); | |
| } | |
| return ( /^#/ ).test( u.href ); | |
| }, | |
| squash: function( url, resolutionUrl ) { | |
| var href, cleanedUrl, search, stateIndex, | |
| isPath = this.isPath( url ), | |
| uri = this.parseUrl( url ), | |
| preservedHash = uri.hash, | |
| uiState = ""; | |
| // produce a url against which we can resole the provided path | |
| resolutionUrl = resolutionUrl || (path.isPath(url) ? path.getLocation() : path.getDocumentUrl()); | |
| // If the url is anything but a simple string, remove any preceding hash | |
| // eg #foo/bar -> foo/bar | |
| // #foo -> #foo | |
| cleanedUrl = isPath ? path.stripHash( url ) : url; | |
| // If the url is a full url with a hash check if the parsed hash is a path | |
| // if it is, strip the #, and use it otherwise continue without change | |
| cleanedUrl = path.isPath( uri.hash ) ? path.stripHash( uri.hash ) : cleanedUrl; | |
| // Split the UI State keys off the href | |
| stateIndex = cleanedUrl.indexOf( this.uiStateKey ); | |
| // store the ui state keys for use | |
| if ( stateIndex > -1 ) { | |
| uiState = cleanedUrl.slice( stateIndex ); | |
| cleanedUrl = cleanedUrl.slice( 0, stateIndex ); | |
| } | |
| // make the cleanedUrl absolute relative to the resolution url | |
| href = path.makeUrlAbsolute( cleanedUrl, resolutionUrl ); | |
| // grab the search from the resolved url since parsing from | |
| // the passed url may not yield the correct result | |
| search = this.parseUrl( href ).search; | |
| // TODO all this crap is terrible, clean it up | |
| if ( isPath ) { | |
| // reject the hash if it's a path or it's just a dialog key | |
| if ( path.isPath( preservedHash ) || preservedHash.replace("#", "").indexOf( this.uiStateKey ) === 0) { | |
| preservedHash = ""; | |
| } | |
| // Append the UI State keys where it exists and it's been removed | |
| // from the url | |
| if ( uiState && preservedHash.indexOf( this.uiStateKey ) === -1) { | |
| preservedHash += uiState; | |
| } | |
| // make sure that pound is on the front of the hash | |
| if ( preservedHash.indexOf( "#" ) === -1 && preservedHash !== "" ) { | |
| preservedHash = "#" + preservedHash; | |
| } | |
| // reconstruct each of the pieces with the new search string and hash | |
| href = path.parseUrl( href ); | |
| href = href.protocol + href.doubleSlash + href.host + href.pathname + search + | |
| preservedHash; | |
| } else { | |
| href += href.indexOf( "#" ) > -1 ? uiState : "#" + uiState; | |
| } | |
| return href; | |
| }, | |
| isPreservableHash: function( hash ) { | |
| return hash.replace( "#", "" ).indexOf( this.uiStateKey ) === 0; | |
| }, | |
| // Escape weird characters in the hash if it is to be used as a selector | |
| hashToSelector: function( hash ) { | |
| var hasHash = ( hash.substring( 0, 1 ) === "#" ); | |
| if ( hasHash ) { | |
| hash = hash.substring( 1 ); | |
| } | |
| return ( hasHash ? "#" : "" ) + hash.replace( /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, "\\$1" ); | |
| }, | |
| // return the substring of a filepath before the sub-page key, for making | |
| // a server request | |
| getFilePath: function( path ) { | |
| var splitkey = "&" + $.mobile.subPageUrlKey; | |
| return path && path.split( splitkey )[0].split( dialogHashKey )[0]; | |
| }, | |
| // check if the specified url refers to the first page in the main | |
| // application document. | |
| isFirstPageUrl: function( url ) { | |
| // We only deal with absolute paths. | |
| var u = path.parseUrl( path.makeUrlAbsolute( url, this.documentBase ) ), | |
| // Does the url have the same path as the document? | |
| samePath = u.hrefNoHash === this.documentUrl.hrefNoHash || | |
| ( this.documentBaseDiffers && | |
| u.hrefNoHash === this.documentBase.hrefNoHash ), | |
| // Get the first page element. | |
| fp = $.mobile.firstPage, | |
| // Get the id of the first page element if it has one. | |
| fpId = fp && fp[0] ? fp[0].id : undefined; | |
| // The url refers to the first page if the path matches the document and | |
| // it either has no hash value, or the hash is exactly equal to the id | |
| // of the first page element. | |
| return samePath && | |
| ( !u.hash || | |
| u.hash === "#" || | |
| ( fpId && u.hash.replace( /^#/, "" ) === fpId ) ); | |
| }, | |
| // Some embedded browsers, like the web view in Phone Gap, allow | |
| // cross-domain XHR requests if the document doing the request was loaded | |
| // via the file:// protocol. This is usually to allow the application to | |
| // "phone home" and fetch app specific data. We normally let the browser | |
| // handle external/cross-domain urls, but if the allowCrossDomainPages | |
| // option is true, we will allow cross-domain http/https requests to go | |
| // through our page loading logic. | |
| isPermittedCrossDomainRequest: function( docUrl, reqUrl ) { | |
| return $.mobile.allowCrossDomainPages && | |
| (docUrl.protocol === "file:" || docUrl.protocol === "content:") && | |
| reqUrl.search( /^https?:/ ) !== -1; | |
| } | |
| }; | |
| path.documentUrl = path.parseLocation(); | |
| $base = $( "head" ).find( "base" ); | |
| path.documentBase = $base.length ? | |
| path.parseUrl( path.makeUrlAbsolute( $base.attr( "href" ), path.documentUrl.href ) ) : | |
| path.documentUrl; | |
| path.documentBaseDiffers = (path.documentUrl.hrefNoHash !== path.documentBase.hrefNoHash); | |
| //return the original document base url | |
| path.getDocumentBase = function( asParsedObject ) { | |
| return asParsedObject ? $.extend( {}, path.documentBase ) : path.documentBase.href; | |
| }; | |
| // DEPRECATED as of 1.4.0 - remove in 1.5.0 | |
| $.extend( $.mobile, { | |
| //return the original document url | |
| getDocumentUrl: path.getDocumentUrl, | |
| //return the original document base url | |
| getDocumentBase: path.getDocumentBase | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.mobile.History = function( stack, index ) { | |
| this.stack = stack || []; | |
| this.activeIndex = index || 0; | |
| }; | |
| $.extend($.mobile.History.prototype, { | |
| getActive: function() { | |
| return this.stack[ this.activeIndex ]; | |
| }, | |
| getLast: function() { | |
| return this.stack[ this.previousIndex ]; | |
| }, | |
| getNext: function() { | |
| return this.stack[ this.activeIndex + 1 ]; | |
| }, | |
| getPrev: function() { | |
| return this.stack[ this.activeIndex - 1 ]; | |
| }, | |
| // addNew is used whenever a new page is added | |
| add: function( url, data ) { | |
| data = data || {}; | |
| //if there's forward history, wipe it | |
| if ( this.getNext() ) { | |
| this.clearForward(); | |
| } | |
| // if the hash is included in the data make sure the shape | |
| // is consistent for comparison | |
| if ( data.hash && data.hash.indexOf( "#" ) === -1) { | |
| data.hash = "#" + data.hash; | |
| } | |
| data.url = url; | |
| this.stack.push( data ); | |
| this.activeIndex = this.stack.length - 1; | |
| }, | |
| //wipe urls ahead of active index | |
| clearForward: function() { | |
| this.stack = this.stack.slice( 0, this.activeIndex + 1 ); | |
| }, | |
| find: function( url, stack, earlyReturn ) { | |
| stack = stack || this.stack; | |
| var entry, i, length = stack.length, index; | |
| for ( i = 0; i < length; i++ ) { | |
| entry = stack[i]; | |
| if ( decodeURIComponent(url) === decodeURIComponent(entry.url) || | |
| decodeURIComponent(url) === decodeURIComponent(entry.hash) ) { | |
| index = i; | |
| if ( earlyReturn ) { | |
| return index; | |
| } | |
| } | |
| } | |
| return index; | |
| }, | |
| closest: function( url ) { | |
| var closest, a = this.activeIndex; | |
| // First, take the slice of the history stack before the current index and search | |
| // for a url match. If one is found, we'll avoid avoid looking through forward history | |
| // NOTE the preference for backward history movement is driven by the fact that | |
| // most mobile browsers only have a dedicated back button, and users rarely use | |
| // the forward button in desktop browser anyhow | |
| closest = this.find( url, this.stack.slice(0, a) ); | |
| // If nothing was found in backward history check forward. The `true` | |
| // value passed as the third parameter causes the find method to break | |
| // on the first match in the forward history slice. The starting index | |
| // of the slice must then be added to the result to get the element index | |
| // in the original history stack :( :( | |
| // | |
| // TODO this is hyper confusing and should be cleaned up (ugh so bad) | |
| if ( closest === undefined ) { | |
| closest = this.find( url, this.stack.slice(a), true ); | |
| closest = closest === undefined ? closest : closest + a; | |
| } | |
| return closest; | |
| }, | |
| direct: function( opts ) { | |
| var newActiveIndex = this.closest( opts.url ), a = this.activeIndex; | |
| // save new page index, null check to prevent falsey 0 result | |
| // record the previous index for reference | |
| if ( newActiveIndex !== undefined ) { | |
| this.activeIndex = newActiveIndex; | |
| this.previousIndex = a; | |
| } | |
| // invoke callbacks where appropriate | |
| // | |
| // TODO this is also convoluted and confusing | |
| if ( newActiveIndex < a ) { | |
| ( opts.present || opts.back || $.noop )( this.getActive(), "back" ); | |
| } else if ( newActiveIndex > a ) { | |
| ( opts.present || opts.forward || $.noop )( this.getActive(), "forward" ); | |
| } else if ( newActiveIndex === undefined && opts.missing ) { | |
| opts.missing( this.getActive() ); | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var path = $.mobile.path, | |
| initialHref = location.href; | |
| $.mobile.Navigator = function( history ) { | |
| this.history = history; | |
| this.ignoreInitialHashChange = true; | |
| $.mobile.window.bind({ | |
| "popstate.history": $.proxy( this.popstate, this ), | |
| "hashchange.history": $.proxy( this.hashchange, this ) | |
| }); | |
| }; | |
| $.extend($.mobile.Navigator.prototype, { | |
| squash: function( url, data ) { | |
| var state, href, hash = path.isPath(url) ? path.stripHash(url) : url; | |
| href = path.squash( url ); | |
| // make sure to provide this information when it isn't explicitly set in the | |
| // data object that was passed to the squash method | |
| state = $.extend({ | |
| hash: hash, | |
| url: href | |
| }, data); | |
| // replace the current url with the new href and store the state | |
| // Note that in some cases we might be replacing an url with the | |
| // same url. We do this anyways because we need to make sure that | |
| // all of our history entries have a state object associated with | |
| // them. This allows us to work around the case where $.mobile.back() | |
| // is called to transition from an external page to an embedded page. | |
| // In that particular case, a hashchange event is *NOT* generated by the browser. | |
| // Ensuring each history entry has a state object means that onPopState() | |
| // will always trigger our hashchange callback even when a hashchange event | |
| // is not fired. | |
| window.history.replaceState( state, state.title || document.title, href ); | |
| return state; | |
| }, | |
| hash: function( url, href ) { | |
| var parsed, loc, hash, resolved; | |
| // Grab the hash for recording. If the passed url is a path | |
| // we used the parsed version of the squashed url to reconstruct, | |
| // otherwise we assume it's a hash and store it directly | |
| parsed = path.parseUrl( url ); | |
| loc = path.parseLocation(); | |
| if ( loc.pathname + loc.search === parsed.pathname + parsed.search ) { | |
| // If the pathname and search of the passed url is identical to the current loc | |
| // then we must use the hash. Otherwise there will be no event | |
| // eg, url = "/foo/bar?baz#bang", location.href = "http://example.com/foo/bar?baz" | |
| hash = parsed.hash ? parsed.hash : parsed.pathname + parsed.search; | |
| } else if ( path.isPath(url) ) { | |
| resolved = path.parseUrl( href ); | |
| // If the passed url is a path, make it domain relative and remove any trailing hash | |
| hash = resolved.pathname + resolved.search + (path.isPreservableHash( resolved.hash )? resolved.hash.replace( "#", "" ) : ""); | |
| } else { | |
| hash = url; | |
| } | |
| return hash; | |
| }, | |
| // TODO reconsider name | |
| go: function( url, data, noEvents ) { | |
| var state, href, hash, popstateEvent, | |
| isPopStateEvent = $.event.special.navigate.isPushStateEnabled(); | |
| // Get the url as it would look squashed on to the current resolution url | |
| href = path.squash( url ); | |
| // sort out what the hash sould be from the url | |
| hash = this.hash( url, href ); | |
| // Here we prevent the next hash change or popstate event from doing any | |
| // history management. In the case of hashchange we don't swallow it | |
| // if there will be no hashchange fired (since that won't reset the value) | |
| // and will swallow the following hashchange | |
| if ( noEvents && hash !== path.stripHash(path.parseLocation().hash) ) { | |
| this.preventNextHashChange = noEvents; | |
| } | |
| // IMPORTANT in the case where popstate is supported the event will be triggered | |
| // directly, stopping further execution - ie, interupting the flow of this | |
| // method call to fire bindings at this expression. Below the navigate method | |
| // there is a binding to catch this event and stop its propagation. | |
| // | |
| // We then trigger a new popstate event on the window with a null state | |
| // so that the navigate events can conclude their work properly | |
| // | |
| // if the url is a path we want to preserve the query params that are available on | |
| // the current url. | |
| this.preventHashAssignPopState = true; | |
| window.location.hash = hash; | |
| // If popstate is enabled and the browser triggers `popstate` events when the hash | |
| // is set (this often happens immediately in browsers like Chrome), then the | |
| // this flag will be set to false already. If it's a browser that does not trigger | |
| // a `popstate` on hash assignement or `replaceState` then we need avoid the branch | |
| // that swallows the event created by the popstate generated by the hash assignment | |
| // At the time of this writing this happens with Opera 12 and some version of IE | |
| this.preventHashAssignPopState = false; | |
| state = $.extend({ | |
| url: href, | |
| hash: hash, | |
| title: document.title | |
| }, data); | |
| if ( isPopStateEvent ) { | |
| popstateEvent = new $.Event( "popstate" ); | |
| popstateEvent.originalEvent = { | |
| type: "popstate", | |
| state: null | |
| }; | |
| this.squash( url, state ); | |
| // Trigger a new faux popstate event to replace the one that we | |
| // caught that was triggered by the hash setting above. | |
| if ( !noEvents ) { | |
| this.ignorePopState = true; | |
| $.mobile.window.trigger( popstateEvent ); | |
| } | |
| } | |
| // record the history entry so that the information can be included | |
| // in hashchange event driven navigate events in a similar fashion to | |
| // the state that's provided by popstate | |
| this.history.add( state.url, state ); | |
| }, | |
| // This binding is intended to catch the popstate events that are fired | |
| // when execution of the `$.navigate` method stops at window.location.hash = url; | |
| // and completely prevent them from propagating. The popstate event will then be | |
| // retriggered after execution resumes | |
| // | |
| // TODO grab the original event here and use it for the synthetic event in the | |
| // second half of the navigate execution that will follow this binding | |
| popstate: function( event ) { | |
| var hash, state; | |
| // Partly to support our test suite which manually alters the support | |
| // value to test hashchange. Partly to prevent all around weirdness | |
| if ( !$.event.special.navigate.isPushStateEnabled() ) { | |
| return; | |
| } | |
| // If this is the popstate triggered by the actual alteration of the hash | |
| // prevent it completely. History is tracked manually | |
| if ( this.preventHashAssignPopState ) { | |
| this.preventHashAssignPopState = false; | |
| event.stopImmediatePropagation(); | |
| return; | |
| } | |
| // if this is the popstate triggered after the `replaceState` call in the go | |
| // method, then simply ignore it. The history entry has already been captured | |
| if ( this.ignorePopState ) { | |
| this.ignorePopState = false; | |
| return; | |
| } | |
| // If there is no state, and the history stack length is one were | |
| // probably getting the page load popstate fired by browsers like chrome | |
| // avoid it and set the one time flag to false. | |
| // TODO: Do we really need all these conditions? Comparing location hrefs | |
| // should be sufficient. | |
| if ( !event.originalEvent.state && | |
| this.history.stack.length === 1 && | |
| this.ignoreInitialHashChange ) { | |
| this.ignoreInitialHashChange = false; | |
| if ( location.href === initialHref ) { | |
| event.preventDefault(); | |
| return; | |
| } | |
| } | |
| // account for direct manipulation of the hash. That is, we will receive a popstate | |
| // when the hash is changed by assignment, and it won't have a state associated. We | |
| // then need to squash the hash. See below for handling of hash assignment that | |
| // matches an existing history entry | |
| // TODO it might be better to only add to the history stack | |
| // when the hash is adjacent to the active history entry | |
| hash = path.parseLocation().hash; | |
| if ( !event.originalEvent.state && hash ) { | |
| // squash the hash that's been assigned on the URL with replaceState | |
| // also grab the resulting state object for storage | |
| state = this.squash( hash ); | |
| // record the new hash as an additional history entry | |
| // to match the browser's treatment of hash assignment | |
| this.history.add( state.url, state ); | |
| // pass the newly created state information | |
| // along with the event | |
| event.historyState = state; | |
| // do not alter history, we've added a new history entry | |
| // so we know where we are | |
| return; | |
| } | |
| // If all else fails this is a popstate that comes from the back or forward buttons | |
| // make sure to set the state of our history stack properly, and record the directionality | |
| this.history.direct({ | |
| url: (event.originalEvent.state || {}).url || hash, | |
| // When the url is either forward or backward in history include the entry | |
| // as data on the event object for merging as data in the navigate event | |
| present: function( historyEntry, direction ) { | |
| // make sure to create a new object to pass down as the navigate event data | |
| event.historyState = $.extend({}, historyEntry); | |
| event.historyState.direction = direction; | |
| } | |
| }); | |
| }, | |
| // NOTE must bind before `navigate` special event hashchange binding otherwise the | |
| // navigation data won't be attached to the hashchange event in time for those | |
| // bindings to attach it to the `navigate` special event | |
| // TODO add a check here that `hashchange.navigate` is bound already otherwise it's | |
| // broken (exception?) | |
| hashchange: function( event ) { | |
| var history, hash; | |
| // If hashchange listening is explicitly disabled or pushstate is supported | |
| // avoid making use of the hashchange handler. | |
| if (!$.event.special.navigate.isHashChangeEnabled() || | |
| $.event.special.navigate.isPushStateEnabled() ) { | |
| return; | |
| } | |
| // On occasion explicitly want to prevent the next hash from propogating because we only | |
| // with to alter the url to represent the new state do so here | |
| if ( this.preventNextHashChange ) { | |
| this.preventNextHashChange = false; | |
| event.stopImmediatePropagation(); | |
| return; | |
| } | |
| history = this.history; | |
| hash = path.parseLocation().hash; | |
| // If this is a hashchange caused by the back or forward button | |
| // make sure to set the state of our history stack properly | |
| this.history.direct({ | |
| url: hash, | |
| // When the url is either forward or backward in history include the entry | |
| // as data on the event object for merging as data in the navigate event | |
| present: function( historyEntry, direction ) { | |
| // make sure to create a new object to pass down as the navigate event data | |
| event.hashchangeState = $.extend({}, historyEntry); | |
| event.hashchangeState.direction = direction; | |
| }, | |
| // When we don't find a hash in our history clearly we're aiming to go there | |
| // record the entry as new for future traversal | |
| // | |
| // NOTE it's not entirely clear that this is the right thing to do given that we | |
| // can't know the users intention. It might be better to explicitly _not_ | |
| // support location.hash assignment in preference to $.navigate calls | |
| // TODO first arg to add should be the href, but it causes issues in identifying | |
| // embeded pages | |
| missing: function() { | |
| history.add( hash, { | |
| hash: hash, | |
| title: document.title | |
| }); | |
| } | |
| }); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| // TODO consider queueing navigation activity until previous activities have completed | |
| // so that end users don't have to think about it. Punting for now | |
| // TODO !! move the event bindings into callbacks on the navigate event | |
| $.mobile.navigate = function( url, data, noEvents ) { | |
| $.mobile.navigate.navigator.go( url, data, noEvents ); | |
| }; | |
| // expose the history on the navigate method in anticipation of full integration with | |
| // existing navigation functionalty that is tightly coupled to the history information | |
| $.mobile.navigate.history = new $.mobile.History(); | |
| // instantiate an instance of the navigator for use within the $.navigate method | |
| $.mobile.navigate.navigator = new $.mobile.Navigator( $.mobile.navigate.history ); | |
| var loc = $.mobile.path.parseLocation(); | |
| $.mobile.navigate.history.add( loc.href, {hash: loc.hash} ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var props = { | |
| "animation": {}, | |
| "transition": {} | |
| }, | |
| testElement = document.createElement( "a" ), | |
| vendorPrefixes = [ "", "webkit-", "moz-", "o-" ]; | |
| $.each( [ "animation", "transition" ], function( i, test ) { | |
| // Get correct name for test | |
| var testName = ( i === 0 ) ? test + "-" + "name" : test; | |
| $.each( vendorPrefixes, function( j, prefix ) { | |
| if ( testElement.style[ $.camelCase( prefix + testName ) ] !== undefined ) { | |
| props[ test ][ "prefix" ] = prefix; | |
| return false; | |
| } | |
| }); | |
| // Set event and duration names for later use | |
| props[ test ][ "duration" ] = | |
| $.camelCase( props[ test ][ "prefix" ] + test + "-" + "duration" ); | |
| props[ test ][ "event" ] = | |
| $.camelCase( props[ test ][ "prefix" ] + test + "-" + "end" ); | |
| // All lower case if not a vendor prop | |
| if ( props[ test ][ "prefix" ] === "" ) { | |
| props[ test ][ "event" ] = props[ test ][ "event" ].toLowerCase(); | |
| } | |
| }); | |
| // If a valid prefix was found then the it is supported by the browser | |
| $.support.cssTransitions = ( props[ "transition" ][ "prefix" ] !== undefined ); | |
| $.support.cssAnimations = ( props[ "animation" ][ "prefix" ] !== undefined ); | |
| // Remove the testElement | |
| $( testElement ).remove(); | |
| // Animation complete callback | |
| $.fn.animationComplete = function( callback, type, fallbackTime ) { | |
| var timer, duration, | |
| that = this, | |
| eventBinding = function() { | |
| // Clear the timer so we don't call callback twice | |
| clearTimeout( timer ); | |
| callback.apply( this, arguments ); | |
| }, | |
| animationType = ( !type || type === "animation" ) ? "animation" : "transition"; | |
| // Make sure selected type is supported by browser | |
| if ( ( $.support.cssTransitions && animationType === "transition" ) || | |
| ( $.support.cssAnimations && animationType === "animation" ) ) { | |
| // If a fallback time was not passed set one | |
| if ( fallbackTime === undefined ) { | |
| // Make sure the was not bound to document before checking .css | |
| if ( $( this ).context !== document ) { | |
| // Parse the durration since its in second multiple by 1000 for milliseconds | |
| // Multiply by 3 to make sure we give the animation plenty of time. | |
| duration = parseFloat( | |
| $( this ).css( props[ animationType ].duration ) | |
| ) * 3000; | |
| } | |
| // If we could not read a duration use the default | |
| if ( duration === 0 || duration === undefined || isNaN( duration ) ) { | |
| duration = $.fn.animationComplete.defaultDuration; | |
| } | |
| } | |
| // Sets up the fallback if event never comes | |
| timer = setTimeout( function() { | |
| $( that ).off( props[ animationType ].event, eventBinding ); | |
| callback.apply( that ); | |
| }, duration ); | |
| // Bind the event | |
| return $( this ).one( props[ animationType ].event, eventBinding ); | |
| } else { | |
| // CSS animation / transitions not supported | |
| // Defer execution for consistency between webkit/non webkit | |
| setTimeout( $.proxy( callback, this ), 0 ); | |
| return $( this ); | |
| } | |
| }; | |
| // Allow default callback to be configured on mobileInit | |
| $.fn.animationComplete.defaultDuration = 1000; | |
| })( jQuery ); | |
| // This plugin is an experiment for abstracting away the touch and mouse | |
| // events so that developers don't have to worry about which method of input | |
| // the device their document is loaded on supports. | |
| // | |
| // The idea here is to allow the developer to register listeners for the | |
| // basic mouse events, such as mousedown, mousemove, mouseup, and click, | |
| // and the plugin will take care of registering the correct listeners | |
| // behind the scenes to invoke the listener at the fastest possible time | |
| // for that device, while still retaining the order of event firing in | |
| // the traditional mouse environment, should multiple handlers be registered | |
| // on the same element for different events. | |
| // | |
| // The current version exposes the following virtual events to jQuery bind methods: | |
| // "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel" | |
| (function( $, window, document, undefined ) { | |
| var dataPropertyName = "virtualMouseBindings", | |
| touchTargetPropertyName = "virtualTouchID", | |
| virtualEventNames = "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split( " " ), | |
| touchEventProps = "clientX clientY pageX pageY screenX screenY".split( " " ), | |
| mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [], | |
| mouseEventProps = $.event.props.concat( mouseHookProps ), | |
| activeDocHandlers = {}, | |
| resetTimerID = 0, | |
| startX = 0, | |
| startY = 0, | |
| didScroll = false, | |
| clickBlockList = [], | |
| blockMouseTriggers = false, | |
| blockTouchTriggers = false, | |
| eventCaptureSupported = "addEventListener" in document, | |
| $document = $( document ), | |
| nextTouchID = 1, | |
| lastTouchID = 0, threshold, | |
| i; | |
| $.vmouse = { | |
| moveDistanceThreshold: 10, | |
| clickDistanceThreshold: 10, | |
| resetTimerDuration: 1500 | |
| }; | |
| function getNativeEvent( event ) { | |
| while ( event && typeof event.originalEvent !== "undefined" ) { | |
| event = event.originalEvent; | |
| } | |
| return event; | |
| } | |
| function createVirtualEvent( event, eventType ) { | |
| var t = event.type, | |
| oe, props, ne, prop, ct, touch, i, j, len; | |
| event = $.Event( event ); | |
| event.type = eventType; | |
| oe = event.originalEvent; | |
| props = $.event.props; | |
| // addresses separation of $.event.props in to $.event.mouseHook.props and Issue 3280 | |
| // https://github.com/jquery/jquery-mobile/issues/3280 | |
| if ( t.search( /^(mouse|click)/ ) > -1 ) { | |
| props = mouseEventProps; | |
| } | |
| // copy original event properties over to the new event | |
| // this would happen if we could call $.event.fix instead of $.Event | |
| // but we don't have a way to force an event to be fixed multiple times | |
| if ( oe ) { | |
| for ( i = props.length, prop; i; ) { | |
| prop = props[ --i ]; | |
| event[ prop ] = oe[ prop ]; | |
| } | |
| } | |
| // make sure that if the mouse and click virtual events are generated | |
| // without a .which one is defined | |
| if ( t.search(/mouse(down|up)|click/) > -1 && !event.which ) { | |
| event.which = 1; | |
| } | |
| if ( t.search(/^touch/) !== -1 ) { | |
| ne = getNativeEvent( oe ); | |
| t = ne.touches; | |
| ct = ne.changedTouches; | |
| touch = ( t && t.length ) ? t[0] : ( ( ct && ct.length ) ? ct[ 0 ] : undefined ); | |
| if ( touch ) { | |
| for ( j = 0, len = touchEventProps.length; j < len; j++) { | |
| prop = touchEventProps[ j ]; | |
| event[ prop ] = touch[ prop ]; | |
| } | |
| } | |
| } | |
| return event; | |
| } | |
| function getVirtualBindingFlags( element ) { | |
| var flags = {}, | |
| b, k; | |
| while ( element ) { | |
| b = $.data( element, dataPropertyName ); | |
| for ( k in b ) { | |
| if ( b[ k ] ) { | |
| flags[ k ] = flags.hasVirtualBinding = true; | |
| } | |
| } | |
| element = element.parentNode; | |
| } | |
| return flags; | |
| } | |
| function getClosestElementWithVirtualBinding( element, eventType ) { | |
| var b; | |
| while ( element ) { | |
| b = $.data( element, dataPropertyName ); | |
| if ( b && ( !eventType || b[ eventType ] ) ) { | |
| return element; | |
| } | |
| element = element.parentNode; | |
| } | |
| return null; | |
| } | |
| function enableTouchBindings() { | |
| blockTouchTriggers = false; | |
| } | |
| function disableTouchBindings() { | |
| blockTouchTriggers = true; | |
| } | |
| function enableMouseBindings() { | |
| lastTouchID = 0; | |
| clickBlockList.length = 0; | |
| blockMouseTriggers = false; | |
| // When mouse bindings are enabled, our | |
| // touch bindings are disabled. | |
| disableTouchBindings(); | |
| } | |
| function disableMouseBindings() { | |
| // When mouse bindings are disabled, our | |
| // touch bindings are enabled. | |
| enableTouchBindings(); | |
| } | |
| function startResetTimer() { | |
| clearResetTimer(); | |
| resetTimerID = setTimeout( function() { | |
| resetTimerID = 0; | |
| enableMouseBindings(); | |
| }, $.vmouse.resetTimerDuration ); | |
| } | |
| function clearResetTimer() { | |
| if ( resetTimerID ) { | |
| clearTimeout( resetTimerID ); | |
| resetTimerID = 0; | |
| } | |
| } | |
| function triggerVirtualEvent( eventType, event, flags ) { | |
| var ve; | |
| if ( ( flags && flags[ eventType ] ) || | |
| ( !flags && getClosestElementWithVirtualBinding( event.target, eventType ) ) ) { | |
| ve = createVirtualEvent( event, eventType ); | |
| $( event.target).trigger( ve ); | |
| } | |
| return ve; | |
| } | |
| function mouseEventCallback( event ) { | |
| var touchID = $.data( event.target, touchTargetPropertyName ), | |
| ve; | |
| if ( !blockMouseTriggers && ( !lastTouchID || lastTouchID !== touchID ) ) { | |
| ve = triggerVirtualEvent( "v" + event.type, event ); | |
| if ( ve ) { | |
| if ( ve.isDefaultPrevented() ) { | |
| event.preventDefault(); | |
| } | |
| if ( ve.isPropagationStopped() ) { | |
| event.stopPropagation(); | |
| } | |
| if ( ve.isImmediatePropagationStopped() ) { | |
| event.stopImmediatePropagation(); | |
| } | |
| } | |
| } | |
| } | |
| function handleTouchStart( event ) { | |
| var touches = getNativeEvent( event ).touches, | |
| target, flags, t; | |
| if ( touches && touches.length === 1 ) { | |
| target = event.target; | |
| flags = getVirtualBindingFlags( target ); | |
| if ( flags.hasVirtualBinding ) { | |
| lastTouchID = nextTouchID++; | |
| $.data( target, touchTargetPropertyName, lastTouchID ); | |
| clearResetTimer(); | |
| disableMouseBindings(); | |
| didScroll = false; | |
| t = getNativeEvent( event ).touches[ 0 ]; | |
| startX = t.pageX; | |
| startY = t.pageY; | |
| triggerVirtualEvent( "vmouseover", event, flags ); | |
| triggerVirtualEvent( "vmousedown", event, flags ); | |
| } | |
| } | |
| } | |
| function handleScroll( event ) { | |
| if ( blockTouchTriggers ) { | |
| return; | |
| } | |
| if ( !didScroll ) { | |
| triggerVirtualEvent( "vmousecancel", event, getVirtualBindingFlags( event.target ) ); | |
| } | |
| didScroll = true; | |
| startResetTimer(); | |
| } | |
| function handleTouchMove( event ) { | |
| if ( blockTouchTriggers ) { | |
| return; | |
| } | |
| var t = getNativeEvent( event ).touches[ 0 ], | |
| didCancel = didScroll, | |
| moveThreshold = $.vmouse.moveDistanceThreshold, | |
| flags = getVirtualBindingFlags( event.target ); | |
| didScroll = didScroll || | |
| ( Math.abs( t.pageX - startX ) > moveThreshold || | |
| Math.abs( t.pageY - startY ) > moveThreshold ); | |
| if ( didScroll && !didCancel ) { | |
| triggerVirtualEvent( "vmousecancel", event, flags ); | |
| } | |
| triggerVirtualEvent( "vmousemove", event, flags ); | |
| startResetTimer(); | |
| } | |
| function handleTouchEnd( event ) { | |
| if ( blockTouchTriggers ) { | |
| return; | |
| } | |
| disableTouchBindings(); | |
| var flags = getVirtualBindingFlags( event.target ), | |
| ve, t; | |
| triggerVirtualEvent( "vmouseup", event, flags ); | |
| if ( !didScroll ) { | |
| ve = triggerVirtualEvent( "vclick", event, flags ); | |
| if ( ve && ve.isDefaultPrevented() ) { | |
| // The target of the mouse events that follow the touchend | |
| // event don't necessarily match the target used during the | |
| // touch. This means we need to rely on coordinates for blocking | |
| // any click that is generated. | |
| t = getNativeEvent( event ).changedTouches[ 0 ]; | |
| clickBlockList.push({ | |
| touchID: lastTouchID, | |
| x: t.clientX, | |
| y: t.clientY | |
| }); | |
| // Prevent any mouse events that follow from triggering | |
| // virtual event notifications. | |
| blockMouseTriggers = true; | |
| } | |
| } | |
| triggerVirtualEvent( "vmouseout", event, flags); | |
| didScroll = false; | |
| startResetTimer(); | |
| } | |
| function hasVirtualBindings( ele ) { | |
| var bindings = $.data( ele, dataPropertyName ), | |
| k; | |
| if ( bindings ) { | |
| for ( k in bindings ) { | |
| if ( bindings[ k ] ) { | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| function dummyMouseHandler() {} | |
| function getSpecialEventObject( eventType ) { | |
| var realType = eventType.substr( 1 ); | |
| return { | |
| setup: function(/* data, namespace */) { | |
| // If this is the first virtual mouse binding for this element, | |
| // add a bindings object to its data. | |
| if ( !hasVirtualBindings( this ) ) { | |
| $.data( this, dataPropertyName, {} ); | |
| } | |
| // If setup is called, we know it is the first binding for this | |
| // eventType, so initialize the count for the eventType to zero. | |
| var bindings = $.data( this, dataPropertyName ); | |
| bindings[ eventType ] = true; | |
| // If this is the first virtual mouse event for this type, | |
| // register a global handler on the document. | |
| activeDocHandlers[ eventType ] = ( activeDocHandlers[ eventType ] || 0 ) + 1; | |
| if ( activeDocHandlers[ eventType ] === 1 ) { | |
| $document.bind( realType, mouseEventCallback ); | |
| } | |
| // Some browsers, like Opera Mini, won't dispatch mouse/click events | |
| // for elements unless they actually have handlers registered on them. | |
| // To get around this, we register dummy handlers on the elements. | |
| $( this ).bind( realType, dummyMouseHandler ); | |
| // For now, if event capture is not supported, we rely on mouse handlers. | |
| if ( eventCaptureSupported ) { | |
| // If this is the first virtual mouse binding for the document, | |
| // register our touchstart handler on the document. | |
| activeDocHandlers[ "touchstart" ] = ( activeDocHandlers[ "touchstart" ] || 0) + 1; | |
| if ( activeDocHandlers[ "touchstart" ] === 1 ) { | |
| $document.bind( "touchstart", handleTouchStart ) | |
| .bind( "touchend", handleTouchEnd ) | |
| // On touch platforms, touching the screen and then dragging your finger | |
| // causes the window content to scroll after some distance threshold is | |
| // exceeded. On these platforms, a scroll prevents a click event from being | |
| // dispatched, and on some platforms, even the touchend is suppressed. To | |
| // mimic the suppression of the click event, we need to watch for a scroll | |
| // event. Unfortunately, some platforms like iOS don't dispatch scroll | |
| // events until *AFTER* the user lifts their finger (touchend). This means | |
| // we need to watch both scroll and touchmove events to figure out whether | |
| // or not a scroll happenens before the touchend event is fired. | |
| .bind( "touchmove", handleTouchMove ) | |
| .bind( "scroll", handleScroll ); | |
| } | |
| } | |
| }, | |
| teardown: function(/* data, namespace */) { | |
| // If this is the last virtual binding for this eventType, | |
| // remove its global handler from the document. | |
| --activeDocHandlers[ eventType ]; | |
| if ( !activeDocHandlers[ eventType ] ) { | |
| $document.unbind( realType, mouseEventCallback ); | |
| } | |
| if ( eventCaptureSupported ) { | |
| // If this is the last virtual mouse binding in existence, | |
| // remove our document touchstart listener. | |
| --activeDocHandlers[ "touchstart" ]; | |
| if ( !activeDocHandlers[ "touchstart" ] ) { | |
| $document.unbind( "touchstart", handleTouchStart ) | |
| .unbind( "touchmove", handleTouchMove ) | |
| .unbind( "touchend", handleTouchEnd ) | |
| .unbind( "scroll", handleScroll ); | |
| } | |
| } | |
| var $this = $( this ), | |
| bindings = $.data( this, dataPropertyName ); | |
| // teardown may be called when an element was | |
| // removed from the DOM. If this is the case, | |
| // jQuery core may have already stripped the element | |
| // of any data bindings so we need to check it before | |
| // using it. | |
| if ( bindings ) { | |
| bindings[ eventType ] = false; | |
| } | |
| // Unregister the dummy event handler. | |
| $this.unbind( realType, dummyMouseHandler ); | |
| // If this is the last virtual mouse binding on the | |
| // element, remove the binding data from the element. | |
| if ( !hasVirtualBindings( this ) ) { | |
| $this.removeData( dataPropertyName ); | |
| } | |
| } | |
| }; | |
| } | |
| // Expose our custom events to the jQuery bind/unbind mechanism. | |
| for ( i = 0; i < virtualEventNames.length; i++ ) { | |
| $.event.special[ virtualEventNames[ i ] ] = getSpecialEventObject( virtualEventNames[ i ] ); | |
| } | |
| // Add a capture click handler to block clicks. | |
| // Note that we require event capture support for this so if the device | |
| // doesn't support it, we punt for now and rely solely on mouse events. | |
| if ( eventCaptureSupported ) { | |
| document.addEventListener( "click", function( e ) { | |
| var cnt = clickBlockList.length, | |
| target = e.target, | |
| x, y, ele, i, o, touchID; | |
| if ( cnt ) { | |
| x = e.clientX; | |
| y = e.clientY; | |
| threshold = $.vmouse.clickDistanceThreshold; | |
| // The idea here is to run through the clickBlockList to see if | |
| // the current click event is in the proximity of one of our | |
| // vclick events that had preventDefault() called on it. If we find | |
| // one, then we block the click. | |
| // | |
| // Why do we have to rely on proximity? | |
| // | |
| // Because the target of the touch event that triggered the vclick | |
| // can be different from the target of the click event synthesized | |
| // by the browser. The target of a mouse/click event that is synthesized | |
| // from a touch event seems to be implementation specific. For example, | |
| // some browsers will fire mouse/click events for a link that is near | |
| // a touch event, even though the target of the touchstart/touchend event | |
| // says the user touched outside the link. Also, it seems that with most | |
| // browsers, the target of the mouse/click event is not calculated until the | |
| // time it is dispatched, so if you replace an element that you touched | |
| // with another element, the target of the mouse/click will be the new | |
| // element underneath that point. | |
| // | |
| // Aside from proximity, we also check to see if the target and any | |
| // of its ancestors were the ones that blocked a click. This is necessary | |
| // because of the strange mouse/click target calculation done in the | |
| // Android 2.1 browser, where if you click on an element, and there is a | |
| // mouse/click handler on one of its ancestors, the target will be the | |
| // innermost child of the touched element, even if that child is no where | |
| // near the point of touch. | |
| ele = target; | |
| while ( ele ) { | |
| for ( i = 0; i < cnt; i++ ) { | |
| o = clickBlockList[ i ]; | |
| touchID = 0; | |
| if ( ( ele === target && Math.abs( o.x - x ) < threshold && Math.abs( o.y - y ) < threshold ) || | |
| $.data( ele, touchTargetPropertyName ) === o.touchID ) { | |
| // XXX: We may want to consider removing matches from the block list | |
| // instead of waiting for the reset timer to fire. | |
| e.preventDefault(); | |
| e.stopPropagation(); | |
| return; | |
| } | |
| } | |
| ele = ele.parentNode; | |
| } | |
| } | |
| }, true); | |
| } | |
| })( jQuery, window, document ); | |
| (function( $, window, undefined ) { | |
| var $document = $( document ), | |
| supportTouch = $.mobile.support.touch, | |
| scrollEvent = "touchmove scroll", | |
| touchStartEvent = supportTouch ? "touchstart" : "mousedown", | |
| touchStopEvent = supportTouch ? "touchend" : "mouseup", | |
| touchMoveEvent = supportTouch ? "touchmove" : "mousemove"; | |
| // setup new event shortcuts | |
| $.each( ( "touchstart touchmove touchend " + | |
| "tap taphold " + | |
| "swipe swipeleft swiperight " + | |
| "scrollstart scrollstop" ).split( " " ), function( i, name ) { | |
| $.fn[ name ] = function( fn ) { | |
| return fn ? this.bind( name, fn ) : this.trigger( name ); | |
| }; | |
| // jQuery < 1.8 | |
| if ( $.attrFn ) { | |
| $.attrFn[ name ] = true; | |
| } | |
| }); | |
| function triggerCustomEvent( obj, eventType, event, bubble ) { | |
| var originalType = event.type; | |
| event.type = eventType; | |
| if ( bubble ) { | |
| $.event.trigger( event, undefined, obj ); | |
| } else { | |
| $.event.dispatch.call( obj, event ); | |
| } | |
| event.type = originalType; | |
| } | |
| // also handles scrollstop | |
| $.event.special.scrollstart = { | |
| enabled: true, | |
| setup: function() { | |
| var thisObject = this, | |
| $this = $( thisObject ), | |
| scrolling, | |
| timer; | |
| function trigger( event, state ) { | |
| scrolling = state; | |
| triggerCustomEvent( thisObject, scrolling ? "scrollstart" : "scrollstop", event ); | |
| } | |
| // iPhone triggers scroll after a small delay; use touchmove instead | |
| $this.bind( scrollEvent, function( event ) { | |
| if ( !$.event.special.scrollstart.enabled ) { | |
| return; | |
| } | |
| if ( !scrolling ) { | |
| trigger( event, true ); | |
| } | |
| clearTimeout( timer ); | |
| timer = setTimeout( function() { | |
| trigger( event, false ); | |
| }, 50 ); | |
| }); | |
| }, | |
| teardown: function() { | |
| $( this ).unbind( scrollEvent ); | |
| } | |
| }; | |
| // also handles taphold | |
| $.event.special.tap = { | |
| tapholdThreshold: 750, | |
| emitTapOnTaphold: true, | |
| setup: function() { | |
| var thisObject = this, | |
| $this = $( thisObject ), | |
| isTaphold = false; | |
| $this.bind( "vmousedown", function( event ) { | |
| isTaphold = false; | |
| if ( event.which && event.which !== 1 ) { | |
| return false; | |
| } | |
| var origTarget = event.target, | |
| timer; | |
| function clearTapTimer() { | |
| clearTimeout( timer ); | |
| } | |
| function clearTapHandlers() { | |
| clearTapTimer(); | |
| $this.unbind( "vclick", clickHandler ) | |
| .unbind( "vmouseup", clearTapTimer ); | |
| $document.unbind( "vmousecancel", clearTapHandlers ); | |
| } | |
| function clickHandler( event ) { | |
| clearTapHandlers(); | |
| // ONLY trigger a 'tap' event if the start target is | |
| // the same as the stop target. | |
| if ( !isTaphold && origTarget === event.target ) { | |
| triggerCustomEvent( thisObject, "tap", event ); | |
| } else if ( isTaphold ) { | |
| event.preventDefault(); | |
| } | |
| } | |
| $this.bind( "vmouseup", clearTapTimer ) | |
| .bind( "vclick", clickHandler ); | |
| $document.bind( "vmousecancel", clearTapHandlers ); | |
| timer = setTimeout( function() { | |
| if ( !$.event.special.tap.emitTapOnTaphold ) { | |
| isTaphold = true; | |
| } | |
| triggerCustomEvent( thisObject, "taphold", $.Event( "taphold", { target: origTarget } ) ); | |
| }, $.event.special.tap.tapholdThreshold ); | |
| }); | |
| }, | |
| teardown: function() { | |
| $( this ).unbind( "vmousedown" ).unbind( "vclick" ).unbind( "vmouseup" ); | |
| $document.unbind( "vmousecancel" ); | |
| } | |
| }; | |
| // Also handles swipeleft, swiperight | |
| $.event.special.swipe = { | |
| // More than this horizontal displacement, and we will suppress scrolling. | |
| scrollSupressionThreshold: 30, | |
| // More time than this, and it isn't a swipe. | |
| durationThreshold: 1000, | |
| // Swipe horizontal displacement must be more than this. | |
| horizontalDistanceThreshold: 30, | |
| // Swipe vertical displacement must be less than this. | |
| verticalDistanceThreshold: 30, | |
| getLocation: function ( event ) { | |
| var winPageX = window.pageXOffset, | |
| winPageY = window.pageYOffset, | |
| x = event.clientX, | |
| y = event.clientY; | |
| if ( event.pageY === 0 && Math.floor( y ) > Math.floor( event.pageY ) || | |
| event.pageX === 0 && Math.floor( x ) > Math.floor( event.pageX ) ) { | |
| // iOS4 clientX/clientY have the value that should have been | |
| // in pageX/pageY. While pageX/page/ have the value 0 | |
| x = x - winPageX; | |
| y = y - winPageY; | |
| } else if ( y < ( event.pageY - winPageY) || x < ( event.pageX - winPageX ) ) { | |
| // Some Android browsers have totally bogus values for clientX/Y | |
| // when scrolling/zooming a page. Detectable since clientX/clientY | |
| // should never be smaller than pageX/pageY minus page scroll | |
| x = event.pageX - winPageX; | |
| y = event.pageY - winPageY; | |
| } | |
| return { | |
| x: x, | |
| y: y | |
| }; | |
| }, | |
| start: function( event ) { | |
| var data = event.originalEvent.touches ? | |
| event.originalEvent.touches[ 0 ] : event, | |
| location = $.event.special.swipe.getLocation( data ); | |
| return { | |
| time: ( new Date() ).getTime(), | |
| coords: [ location.x, location.y ], | |
| origin: $( event.target ) | |
| }; | |
| }, | |
| stop: function( event ) { | |
| var data = event.originalEvent.touches ? | |
| event.originalEvent.touches[ 0 ] : event, | |
| location = $.event.special.swipe.getLocation( data ); | |
| return { | |
| time: ( new Date() ).getTime(), | |
| coords: [ location.x, location.y ] | |
| }; | |
| }, | |
| handleSwipe: function( start, stop, thisObject, origTarget ) { | |
| if ( stop.time - start.time < $.event.special.swipe.durationThreshold && | |
| Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold && | |
| Math.abs( start.coords[ 1 ] - stop.coords[ 1 ] ) < $.event.special.swipe.verticalDistanceThreshold ) { | |
| var direction = start.coords[0] > stop.coords[ 0 ] ? "swipeleft" : "swiperight"; | |
| triggerCustomEvent( thisObject, "swipe", $.Event( "swipe", { target: origTarget, swipestart: start, swipestop: stop }), true ); | |
| triggerCustomEvent( thisObject, direction,$.Event( direction, { target: origTarget, swipestart: start, swipestop: stop } ), true ); | |
| return true; | |
| } | |
| return false; | |
| }, | |
| // This serves as a flag to ensure that at most one swipe event event is | |
| // in work at any given time | |
| eventInProgress: false, | |
| setup: function() { | |
| var events, | |
| thisObject = this, | |
| $this = $( thisObject ), | |
| context = {}; | |
| // Retrieve the events data for this element and add the swipe context | |
| events = $.data( this, "mobile-events" ); | |
| if ( !events ) { | |
| events = { length: 0 }; | |
| $.data( this, "mobile-events", events ); | |
| } | |
| events.length++; | |
| events.swipe = context; | |
| context.start = function( event ) { | |
| // Bail if we're already working on a swipe event | |
| if ( $.event.special.swipe.eventInProgress ) { | |
| return; | |
| } | |
| $.event.special.swipe.eventInProgress = true; | |
| var stop, | |
| start = $.event.special.swipe.start( event ), | |
| origTarget = event.target, | |
| emitted = false; | |
| context.move = function( event ) { | |
| if ( !start ) { | |
| return; | |
| } | |
| stop = $.event.special.swipe.stop( event ); | |
| if ( !emitted ) { | |
| emitted = $.event.special.swipe.handleSwipe( start, stop, thisObject, origTarget ); | |
| if ( emitted ) { | |
| // Reset the context to make way for the next swipe event | |
| $.event.special.swipe.eventInProgress = false; | |
| } | |
| } | |
| // prevent scrolling | |
| if ( Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.scrollSupressionThreshold ) { | |
| event.preventDefault(); | |
| } | |
| }; | |
| context.stop = function() { | |
| emitted = true; | |
| // Reset the context to make way for the next swipe event | |
| $.event.special.swipe.eventInProgress = false; | |
| $document.off( touchMoveEvent, context.move ); | |
| context.move = null; | |
| }; | |
| $document.on( touchMoveEvent, context.move ) | |
| .one( touchStopEvent, context.stop ); | |
| }; | |
| $this.on( touchStartEvent, context.start ); | |
| }, | |
| teardown: function() { | |
| var events, context; | |
| events = $.data( this, "mobile-events" ); | |
| if ( events ) { | |
| context = events.swipe; | |
| delete events.swipe; | |
| events.length--; | |
| if ( events.length === 0 ) { | |
| $.removeData( this, "mobile-events" ); | |
| } | |
| } | |
| if ( context ) { | |
| if ( context.start ) { | |
| $( this ).off( touchStartEvent, context.start ); | |
| } | |
| if ( context.move ) { | |
| $document.off( touchMoveEvent, context.move ); | |
| } | |
| if ( context.stop ) { | |
| $document.off( touchStopEvent, context.stop ); | |
| } | |
| } | |
| } | |
| }; | |
| $.each({ | |
| scrollstop: "scrollstart", | |
| taphold: "tap", | |
| swipeleft: "swipe.left", | |
| swiperight: "swipe.right" | |
| }, function( event, sourceEvent ) { | |
| $.event.special[ event ] = { | |
| setup: function() { | |
| $( this ).bind( sourceEvent, $.noop ); | |
| }, | |
| teardown: function() { | |
| $( this ).unbind( sourceEvent ); | |
| } | |
| }; | |
| }); | |
| })( jQuery, this ); | |
| // throttled resize event | |
| (function( $ ) { | |
| $.event.special.throttledresize = { | |
| setup: function() { | |
| $( this ).bind( "resize", handler ); | |
| }, | |
| teardown: function() { | |
| $( this ).unbind( "resize", handler ); | |
| } | |
| }; | |
| var throttle = 250, | |
| handler = function() { | |
| curr = ( new Date() ).getTime(); | |
| diff = curr - lastCall; | |
| if ( diff >= throttle ) { | |
| lastCall = curr; | |
| $( this ).trigger( "throttledresize" ); | |
| } else { | |
| if ( heldCall ) { | |
| clearTimeout( heldCall ); | |
| } | |
| // Promise a held call will still execute | |
| heldCall = setTimeout( handler, throttle - diff ); | |
| } | |
| }, | |
| lastCall = 0, | |
| heldCall, | |
| curr, | |
| diff; | |
| })( jQuery ); | |
| (function( $, window ) { | |
| var win = $( window ), | |
| event_name = "orientationchange", | |
| get_orientation, | |
| last_orientation, | |
| initial_orientation_is_landscape, | |
| initial_orientation_is_default, | |
| portrait_map = { "0": true, "180": true }, | |
| ww, wh, landscape_threshold; | |
| // It seems that some device/browser vendors use window.orientation values 0 and 180 to | |
| // denote the "default" orientation. For iOS devices, and most other smart-phones tested, | |
| // the default orientation is always "portrait", but in some Android and RIM based tablets, | |
| // the default orientation is "landscape". The following code attempts to use the window | |
| // dimensions to figure out what the current orientation is, and then makes adjustments | |
| // to the to the portrait_map if necessary, so that we can properly decode the | |
| // window.orientation value whenever get_orientation() is called. | |
| // | |
| // Note that we used to use a media query to figure out what the orientation the browser | |
| // thinks it is in: | |
| // | |
| // initial_orientation_is_landscape = $.mobile.media("all and (orientation: landscape)"); | |
| // | |
| // but there was an iPhone/iPod Touch bug beginning with iOS 4.2, up through iOS 5.1, | |
| // where the browser *ALWAYS* applied the landscape media query. This bug does not | |
| // happen on iPad. | |
| if ( $.support.orientation ) { | |
| // Check the window width and height to figure out what the current orientation | |
| // of the device is at this moment. Note that we've initialized the portrait map | |
| // values to 0 and 180, *AND* we purposely check for landscape so that if we guess | |
| // wrong, , we default to the assumption that portrait is the default orientation. | |
| // We use a threshold check below because on some platforms like iOS, the iPhone | |
| // form-factor can report a larger width than height if the user turns on the | |
| // developer console. The actual threshold value is somewhat arbitrary, we just | |
| // need to make sure it is large enough to exclude the developer console case. | |
| ww = window.innerWidth || win.width(); | |
| wh = window.innerHeight || win.height(); | |
| landscape_threshold = 50; | |
| initial_orientation_is_landscape = ww > wh && ( ww - wh ) > landscape_threshold; | |
| // Now check to see if the current window.orientation is 0 or 180. | |
| initial_orientation_is_default = portrait_map[ window.orientation ]; | |
| // If the initial orientation is landscape, but window.orientation reports 0 or 180, *OR* | |
| // if the initial orientation is portrait, but window.orientation reports 90 or -90, we | |
| // need to flip our portrait_map values because landscape is the default orientation for | |
| // this device/browser. | |
| if ( ( initial_orientation_is_landscape && initial_orientation_is_default ) || ( !initial_orientation_is_landscape && !initial_orientation_is_default ) ) { | |
| portrait_map = { "-90": true, "90": true }; | |
| } | |
| } | |
| $.event.special.orientationchange = $.extend( {}, $.event.special.orientationchange, { | |
| setup: function() { | |
| // If the event is supported natively, return false so that jQuery | |
| // will bind to the event using DOM methods. | |
| if ( $.support.orientation && !$.event.special.orientationchange.disabled ) { | |
| return false; | |
| } | |
| // Get the current orientation to avoid initial double-triggering. | |
| last_orientation = get_orientation(); | |
| // Because the orientationchange event doesn't exist, simulate the | |
| // event by testing window dimensions on resize. | |
| win.bind( "throttledresize", handler ); | |
| }, | |
| teardown: function() { | |
| // If the event is not supported natively, return false so that | |
| // jQuery will unbind the event using DOM methods. | |
| if ( $.support.orientation && !$.event.special.orientationchange.disabled ) { | |
| return false; | |
| } | |
| // Because the orientationchange event doesn't exist, unbind the | |
| // resize event handler. | |
| win.unbind( "throttledresize", handler ); | |
| }, | |
| add: function( handleObj ) { | |
| // Save a reference to the bound event handler. | |
| var old_handler = handleObj.handler; | |
| handleObj.handler = function( event ) { | |
| // Modify event object, adding the .orientation property. | |
| event.orientation = get_orientation(); | |
| // Call the originally-bound event handler and return its result. | |
| return old_handler.apply( this, arguments ); | |
| }; | |
| } | |
| }); | |
| // If the event is not supported natively, this handler will be bound to | |
| // the window resize event to simulate the orientationchange event. | |
| function handler() { | |
| // Get the current orientation. | |
| var orientation = get_orientation(); | |
| if ( orientation !== last_orientation ) { | |
| // The orientation has changed, so trigger the orientationchange event. | |
| last_orientation = orientation; | |
| win.trigger( event_name ); | |
| } | |
| } | |
| // Get the current page orientation. This method is exposed publicly, should it | |
| // be needed, as jQuery.event.special.orientationchange.orientation() | |
| $.event.special.orientationchange.orientation = get_orientation = function() { | |
| var isPortrait = true, elem = document.documentElement; | |
| // prefer window orientation to the calculation based on screensize as | |
| // the actual screen resize takes place before or after the orientation change event | |
| // has been fired depending on implementation (eg android 2.3 is before, iphone after). | |
| // More testing is required to determine if a more reliable method of determining the new screensize | |
| // is possible when orientationchange is fired. (eg, use media queries + element + opacity) | |
| if ( $.support.orientation ) { | |
| // if the window orientation registers as 0 or 180 degrees report | |
| // portrait, otherwise landscape | |
| isPortrait = portrait_map[ window.orientation ]; | |
| } else { | |
| isPortrait = elem && elem.clientWidth / elem.clientHeight < 1.1; | |
| } | |
| return isPortrait ? "portrait" : "landscape"; | |
| }; | |
| $.fn[ event_name ] = function( fn ) { | |
| return fn ? this.bind( event_name, fn ) : this.trigger( event_name ); | |
| }; | |
| // jQuery < 1.8 | |
| if ( $.attrFn ) { | |
| $.attrFn[ event_name ] = true; | |
| } | |
| }( jQuery, this )); | |
| (function( $, undefined ) { | |
| // existing base tag? | |
| var baseElement = $( "head" ).children( "base" ), | |
| // base element management, defined depending on dynamic base tag support | |
| // TODO move to external widget | |
| base = { | |
| // define base element, for use in routing asset urls that are referenced | |
| // in Ajax-requested markup | |
| element: ( baseElement.length ? baseElement : | |
| $( "<base>", { href: $.mobile.path.documentBase.hrefNoHash } ).prependTo( $( "head" ) ) ), | |
| linkSelector: "[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]", | |
| // set the generated BASE element's href to a new page's base path | |
| set: function( href ) { | |
| // we should do nothing if the user wants to manage their url base | |
| // manually | |
| if ( !$.mobile.dynamicBaseEnabled ) { | |
| return; | |
| } | |
| // we should use the base tag if we can manipulate it dynamically | |
| if ( $.support.dynamicBaseTag ) { | |
| base.element.attr( "href", | |
| $.mobile.path.makeUrlAbsolute( href, $.mobile.path.documentBase ) ); | |
| } | |
| }, | |
| rewrite: function( href, page ) { | |
| var newPath = $.mobile.path.get( href ); | |
| page.find( base.linkSelector ).each(function( i, link ) { | |
| var thisAttr = $( link ).is( "[href]" ) ? "href" : | |
| $( link ).is( "[src]" ) ? "src" : "action", | |
| theLocation = $.mobile.path.parseLocation(), | |
| thisUrl = $( link ).attr( thisAttr ); | |
| // XXX_jblas: We need to fix this so that it removes the document | |
| // base URL, and then prepends with the new page URL. | |
| // if full path exists and is same, chop it - helps IE out | |
| thisUrl = thisUrl.replace( theLocation.protocol + theLocation.doubleSlash + | |
| theLocation.host + theLocation.pathname, "" ); | |
| if ( !/^(\w+:|#|\/)/.test( thisUrl ) ) { | |
| $( link ).attr( thisAttr, newPath + thisUrl ); | |
| } | |
| }); | |
| }, | |
| // set the generated BASE element's href to a new page's base path | |
| reset: function(/* href */) { | |
| base.element.attr( "href", $.mobile.path.documentBase.hrefNoSearch ); | |
| } | |
| }; | |
| $.mobile.base = base; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.mobile.widgets = {}; | |
| var originalWidget = $.widget, | |
| // Record the original, non-mobileinit-modified version of $.mobile.keepNative | |
| // so we can later determine whether someone has modified $.mobile.keepNative | |
| keepNativeFactoryDefault = $.mobile.keepNative; | |
| $.widget = (function( orig ) { | |
| return function() { | |
| var constructor = orig.apply( this, arguments ), | |
| name = constructor.prototype.widgetName; | |
| constructor.initSelector = ( ( constructor.prototype.initSelector !== undefined ) ? | |
| constructor.prototype.initSelector : ":jqmData(role='" + name + "')" ); | |
| $.mobile.widgets[ name ] = constructor; | |
| return constructor; | |
| }; | |
| })( $.widget ); | |
| // Make sure $.widget still has bridge and extend methods | |
| $.extend( $.widget, originalWidget ); | |
| // For backcompat remove in 1.5 | |
| $.mobile.document.on( "create", function( event ) { | |
| $( event.target ).enhanceWithin(); | |
| }); | |
| $.widget( "mobile.page", { | |
| options: { | |
| theme: "a", | |
| domCache: false, | |
| // Deprecated in 1.4 remove in 1.5 | |
| keepNativeDefault: $.mobile.keepNative, | |
| // Deprecated in 1.4 remove in 1.5 | |
| contentTheme: null, | |
| enhanced: false | |
| }, | |
| // DEPRECATED for > 1.4 | |
| // TODO remove at 1.5 | |
| _createWidget: function() { | |
| $.Widget.prototype._createWidget.apply( this, arguments ); | |
| this._trigger( "init" ); | |
| }, | |
| _create: function() { | |
| // If false is returned by the callbacks do not create the page | |
| if ( this._trigger( "beforecreate" ) === false ) { | |
| return false; | |
| } | |
| if ( !this.options.enhanced ) { | |
| this._enhance(); | |
| } | |
| this._on( this.element, { | |
| pagebeforehide: "removeContainerBackground", | |
| pagebeforeshow: "_handlePageBeforeShow" | |
| }); | |
| this.element.enhanceWithin(); | |
| // Dialog widget is deprecated in 1.4 remove this in 1.5 | |
| if ( $.mobile.getAttribute( this.element[0], "role" ) === "dialog" && $.mobile.dialog ) { | |
| this.element.dialog(); | |
| } | |
| }, | |
| _enhance: function () { | |
| var attrPrefix = "data-" + $.mobile.ns, | |
| self = this; | |
| if ( this.options.role ) { | |
| this.element.attr( "data-" + $.mobile.ns + "role", this.options.role ); | |
| } | |
| this.element | |
| .attr( "tabindex", "0" ) | |
| .addClass( "ui-page ui-page-theme-" + this.options.theme ); | |
| // Manipulation of content os Deprecated as of 1.4 remove in 1.5 | |
| this.element.find( "[" + attrPrefix + "role='content']" ).each( function() { | |
| var $this = $( this ), | |
| theme = this.getAttribute( attrPrefix + "theme" ) || undefined; | |
| self.options.contentTheme = theme || self.options.contentTheme || ( self.options.dialog && self.options.theme ) || ( self.element.jqmData("role") === "dialog" && self.options.theme ); | |
| $this.addClass( "ui-content" ); | |
| if ( self.options.contentTheme ) { | |
| $this.addClass( "ui-body-" + ( self.options.contentTheme ) ); | |
| } | |
| // Add ARIA role | |
| $this.attr( "role", "main" ).addClass( "ui-content" ); | |
| }); | |
| }, | |
| bindRemove: function( callback ) { | |
| var page = this.element; | |
| // when dom caching is not enabled or the page is embedded bind to remove the page on hide | |
| if ( !page.data( "mobile-page" ).options.domCache && | |
| page.is( ":jqmData(external-page='true')" ) ) { | |
| // TODO use _on - that is, sort out why it doesn't work in this case | |
| page.bind( "pagehide.remove", callback || function( e, data ) { | |
| //check if this is a same page transition and if so don't remove the page | |
| if( !data.samePage ){ | |
| var $this = $( this ), | |
| prEvent = new $.Event( "pageremove" ); | |
| $this.trigger( prEvent ); | |
| if ( !prEvent.isDefaultPrevented() ) { | |
| $this.removeWithDependents(); | |
| } | |
| } | |
| }); | |
| } | |
| }, | |
| _setOptions: function( o ) { | |
| if ( o.theme !== undefined ) { | |
| this.element.removeClass( "ui-page-theme-" + this.options.theme ).addClass( "ui-page-theme-" + o.theme ); | |
| } | |
| if ( o.contentTheme !== undefined ) { | |
| this.element.find( "[data-" + $.mobile.ns + "='content']" ).removeClass( "ui-body-" + this.options.contentTheme ) | |
| .addClass( "ui-body-" + o.contentTheme ); | |
| } | |
| }, | |
| _handlePageBeforeShow: function(/* e */) { | |
| this.setContainerBackground(); | |
| }, | |
| // Deprecated in 1.4 remove in 1.5 | |
| removeContainerBackground: function() { | |
| this.element.closest( ":mobile-pagecontainer" ).pagecontainer({ "theme": "none" }); | |
| }, | |
| // Deprecated in 1.4 remove in 1.5 | |
| // set the page container background to the page theme | |
| setContainerBackground: function( theme ) { | |
| this.element.parent().pagecontainer( { "theme": theme || this.options.theme } ); | |
| }, | |
| // Deprecated in 1.4 remove in 1.5 | |
| keepNativeSelector: function() { | |
| var options = this.options, | |
| keepNative = $.trim( options.keepNative || "" ), | |
| globalValue = $.trim( $.mobile.keepNative ), | |
| optionValue = $.trim( options.keepNativeDefault ), | |
| // Check if $.mobile.keepNative has changed from the factory default | |
| newDefault = ( keepNativeFactoryDefault === globalValue ? | |
| "" : globalValue ), | |
| // If $.mobile.keepNative has not changed, use options.keepNativeDefault | |
| oldDefault = ( newDefault === "" ? optionValue : "" ); | |
| // Concatenate keepNative selectors from all sources where the value has | |
| // changed or, if nothing has changed, return the default | |
| return ( ( keepNative ? [ keepNative ] : [] ) | |
| .concat( newDefault ? [ newDefault ] : [] ) | |
| .concat( oldDefault ? [ oldDefault ] : [] ) | |
| .join( ", " ) ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.pagecontainer", { | |
| options: { | |
| theme: "a" | |
| }, | |
| initSelector: false, | |
| _create: function() { | |
| this._trigger( "beforecreate" ); | |
| this.setLastScrollEnabled = true; | |
| this._on( this.window, { | |
| // disable an scroll setting when a hashchange has been fired, | |
| // this only works because the recording of the scroll position | |
| // is delayed for 100ms after the browser might have changed the | |
| // position because of the hashchange | |
| navigate: "_disableRecordScroll", | |
| // bind to scrollstop for the first page, "pagechange" won't be | |
| // fired in that case | |
| scrollstop: "_delayedRecordScroll" | |
| }); | |
| // TODO consider moving the navigation handler OUT of widget into | |
| // some other object as glue between the navigate event and the | |
| // content widget load and change methods | |
| this._on( this.window, { navigate: "_filterNavigateEvents" }); | |
| // TODO move from page* events to content* events | |
| this._on({ pagechange: "_afterContentChange" }); | |
| // handle initial hashchange from chrome :( | |
| this.window.one( "navigate", $.proxy(function() { | |
| this.setLastScrollEnabled = true; | |
| }, this)); | |
| }, | |
| _setOptions: function( options ) { | |
| if ( options.theme !== undefined && options.theme !== "none" ) { | |
| this.element.removeClass( "ui-overlay-" + this.options.theme ) | |
| .addClass( "ui-overlay-" + options.theme ); | |
| } else if ( options.theme !== undefined ) { | |
| this.element.removeClass( "ui-overlay-" + this.options.theme ); | |
| } | |
| this._super( options ); | |
| }, | |
| _disableRecordScroll: function() { | |
| this.setLastScrollEnabled = false; | |
| }, | |
| _enableRecordScroll: function() { | |
| this.setLastScrollEnabled = true; | |
| }, | |
| // TODO consider the name here, since it's purpose specific | |
| _afterContentChange: function() { | |
| // once the page has changed, re-enable the scroll recording | |
| this.setLastScrollEnabled = true; | |
| // remove any binding that previously existed on the get scroll | |
| // which may or may not be different than the scroll element | |
| // determined for this page previously | |
| this._off( this.window, "scrollstop" ); | |
| // determine and bind to the current scoll element which may be the | |
| // window or in the case of touch overflow the element touch overflow | |
| this._on( this.window, { scrollstop: "_delayedRecordScroll" }); | |
| }, | |
| _recordScroll: function() { | |
| // this barrier prevents setting the scroll value based on | |
| // the browser scrolling the window based on a hashchange | |
| if ( !this.setLastScrollEnabled ) { | |
| return; | |
| } | |
| var active = this._getActiveHistory(), | |
| currentScroll, minScroll, defaultScroll; | |
| if ( active ) { | |
| currentScroll = this._getScroll(); | |
| minScroll = this._getMinScroll(); | |
| defaultScroll = this._getDefaultScroll(); | |
| // Set active page's lastScroll prop. If the location we're | |
| // scrolling to is less than minScrollBack, let it go. | |
| active.lastScroll = currentScroll < minScroll ? defaultScroll : currentScroll; | |
| } | |
| }, | |
| _delayedRecordScroll: function() { | |
| setTimeout( $.proxy(this, "_recordScroll"), 100 ); | |
| }, | |
| _getScroll: function() { | |
| return this.window.scrollTop(); | |
| }, | |
| _getMinScroll: function() { | |
| return $.mobile.minScrollBack; | |
| }, | |
| _getDefaultScroll: function() { | |
| return $.mobile.defaultHomeScroll; | |
| }, | |
| _filterNavigateEvents: function( e, data ) { | |
| var url; | |
| if ( e.originalEvent && e.originalEvent.isDefaultPrevented() ) { | |
| return; | |
| } | |
| url = e.originalEvent.type.indexOf( "hashchange" ) > -1 ? data.state.hash : data.state.url; | |
| if ( !url ) { | |
| url = this._getHash(); | |
| } | |
| if ( !url || url === "#" || url.indexOf( "#" + $.mobile.path.uiStateKey ) === 0 ) { | |
| url = location.href; | |
| } | |
| this._handleNavigate( url, data.state ); | |
| }, | |
| _getHash: function() { | |
| return $.mobile.path.parseLocation().hash; | |
| }, | |
| // TODO active page should be managed by the container (ie, it should be a property) | |
| getActivePage: function() { | |
| return this.activePage; | |
| }, | |
| // TODO the first page should be a property set during _create using the logic | |
| // that currently resides in init | |
| _getInitialContent: function() { | |
| return $.mobile.firstPage; | |
| }, | |
| // TODO each content container should have a history object | |
| _getHistory: function() { | |
| return $.mobile.navigate.history; | |
| }, | |
| // TODO use _getHistory | |
| _getActiveHistory: function() { | |
| return $.mobile.navigate.history.getActive(); | |
| }, | |
| // TODO the document base should be determined at creation | |
| _getDocumentBase: function() { | |
| return $.mobile.path.documentBase; | |
| }, | |
| back: function() { | |
| this.go( -1 ); | |
| }, | |
| forward: function() { | |
| this.go( 1 ); | |
| }, | |
| go: function( steps ) { | |
| //if hashlistening is enabled use native history method | |
| if ( $.mobile.hashListeningEnabled ) { | |
| window.history.go( steps ); | |
| } else { | |
| //we are not listening to the hash so handle history internally | |
| var activeIndex = $.mobile.navigate.history.activeIndex, | |
| index = activeIndex + parseInt( steps, 10 ), | |
| url = $.mobile.navigate.history.stack[ index ].url, | |
| direction = ( steps >= 1 )? "forward" : "back"; | |
| //update the history object | |
| $.mobile.navigate.history.activeIndex = index; | |
| $.mobile.navigate.history.previousIndex = activeIndex; | |
| //change to the new page | |
| this.change( url, { direction: direction, changeHash: false, fromHashChange: true } ); | |
| } | |
| }, | |
| // TODO rename _handleDestination | |
| _handleDestination: function( to ) { | |
| var history; | |
| // clean the hash for comparison if it's a url | |
| if ( $.type(to) === "string" ) { | |
| to = $.mobile.path.stripHash( to ); | |
| } | |
| if ( to ) { | |
| history = this._getHistory(); | |
| // At this point, 'to' can be one of 3 things, a cached page | |
| // element from a history stack entry, an id, or site-relative / | |
| // absolute URL. If 'to' is an id, we need to resolve it against | |
| // the documentBase, not the location.href, since the hashchange | |
| // could've been the result of a forward/backward navigation | |
| // that crosses from an external page/dialog to an internal | |
| // page/dialog. | |
| // | |
| // TODO move check to history object or path object? | |
| to = !$.mobile.path.isPath( to ) ? ( $.mobile.path.makeUrlAbsolute( "#" + to, this._getDocumentBase() ) ) : to; | |
| // If we're about to go to an initial URL that contains a | |
| // reference to a non-existent internal page, go to the first | |
| // page instead. We know that the initial hash refers to a | |
| // non-existent page, because the initial hash did not end | |
| // up in the initial history entry | |
| // TODO move check to history object? | |
| if ( to === $.mobile.path.makeUrlAbsolute( "#" + history.initialDst, this._getDocumentBase() ) && | |
| history.stack.length && | |
| history.stack[0].url !== history.initialDst.replace( $.mobile.dialogHashKey, "" ) ) { | |
| to = this._getInitialContent(); | |
| } | |
| } | |
| return to || this._getInitialContent(); | |
| }, | |
| _handleDialog: function( changePageOptions, data ) { | |
| var to, active, activeContent = this.getActivePage(); | |
| // If current active page is not a dialog skip the dialog and continue | |
| // in the same direction | |
| if ( activeContent && !activeContent.hasClass( "ui-dialog" ) ) { | |
| // determine if we're heading forward or backward and continue | |
| // accordingly past the current dialog | |
| if ( data.direction === "back" ) { | |
| this.back(); | |
| } else { | |
| this.forward(); | |
| } | |
| // prevent changePage call | |
| return false; | |
| } else { | |
| // if the current active page is a dialog and we're navigating | |
| // to a dialog use the dialog objected saved in the stack | |
| to = data.pageUrl; | |
| active = this._getActiveHistory(); | |
| // make sure to set the role, transition and reversal | |
| // as most of this is lost by the domCache cleaning | |
| $.extend( changePageOptions, { | |
| role: active.role, | |
| transition: active.transition, | |
| reverse: data.direction === "back" | |
| }); | |
| } | |
| return to; | |
| }, | |
| _handleNavigate: function( url, data ) { | |
| //find first page via hash | |
| // TODO stripping the hash twice with handleUrl | |
| var to = $.mobile.path.stripHash( url ), history = this._getHistory(), | |
| // transition is false if it's the first page, undefined | |
| // otherwise (and may be overridden by default) | |
| transition = history.stack.length === 0 ? "none" : undefined, | |
| // default options for the changPage calls made after examining | |
| // the current state of the page and the hash, NOTE that the | |
| // transition is derived from the previous history entry | |
| changePageOptions = { | |
| changeHash: false, | |
| fromHashChange: true, | |
| reverse: data.direction === "back" | |
| }; | |
| $.extend( changePageOptions, data, { | |
| transition: ( history.getLast() || {} ).transition || transition | |
| }); | |
| // TODO move to _handleDestination ? | |
| // If this isn't the first page, if the current url is a dialog hash | |
| // key, and the initial destination isn't equal to the current target | |
| // page, use the special dialog handling | |
| if ( history.activeIndex > 0 && | |
| to.indexOf( $.mobile.dialogHashKey ) > -1 && | |
| history.initialDst !== to ) { | |
| to = this._handleDialog( changePageOptions, data ); | |
| if ( to === false ) { | |
| return; | |
| } | |
| } | |
| this._changeContent( this._handleDestination( to ), changePageOptions ); | |
| }, | |
| _changeContent: function( to, opts ) { | |
| $.mobile.changePage( to, opts ); | |
| }, | |
| _getBase: function() { | |
| return $.mobile.base; | |
| }, | |
| _getNs: function() { | |
| return $.mobile.ns; | |
| }, | |
| _enhance: function( content, role ) { | |
| // TODO consider supporting a custom callback, and passing in | |
| // the settings which includes the role | |
| return content.page({ role: role }); | |
| }, | |
| _include: function( page, settings ) { | |
| // append to page and enhance | |
| page.appendTo( this.element ); | |
| // use the page widget to enhance | |
| this._enhance( page, settings.role ); | |
| // remove page on hide | |
| page.page( "bindRemove" ); | |
| }, | |
| _find: function( absUrl ) { | |
| // TODO consider supporting a custom callback | |
| var fileUrl = this._createFileUrl( absUrl ), | |
| dataUrl = this._createDataUrl( absUrl ), | |
| page, initialContent = this._getInitialContent(); | |
| // Check to see if the page already exists in the DOM. | |
| // NOTE do _not_ use the :jqmData pseudo selector because parenthesis | |
| // are a valid url char and it breaks on the first occurence | |
| page = this.element | |
| .children( "[data-" + this._getNs() +"url='" + dataUrl + "']" ); | |
| // If we failed to find the page, check to see if the url is a | |
| // reference to an embedded page. If so, it may have been dynamically | |
| // injected by a developer, in which case it would be lacking a | |
| // data-url attribute and in need of enhancement. | |
| if ( page.length === 0 && dataUrl && !$.mobile.path.isPath( dataUrl ) ) { | |
| page = this.element.children( $.mobile.path.hashToSelector("#" + dataUrl) ) | |
| .attr( "data-" + this._getNs() + "url", dataUrl ) | |
| .jqmData( "url", dataUrl ); | |
| } | |
| // If we failed to find a page in the DOM, check the URL to see if it | |
| // refers to the first page in the application. Also check to make sure | |
| // our cached-first-page is actually in the DOM. Some user deployed | |
| // apps are pruning the first page from the DOM for various reasons. | |
| // We check for this case here because we don't want a first-page with | |
| // an id falling through to the non-existent embedded page error case. | |
| if ( page.length === 0 && | |
| $.mobile.path.isFirstPageUrl( fileUrl ) && | |
| initialContent && | |
| initialContent.parent().length ) { | |
| page = $( initialContent ); | |
| } | |
| return page; | |
| }, | |
| _getLoader: function() { | |
| return $.mobile.loading(); | |
| }, | |
| _showLoading: function( delay, theme, msg, textonly ) { | |
| // This configurable timeout allows cached pages a brief | |
| // delay to load without showing a message | |
| if ( this._loadMsg ) { | |
| return; | |
| } | |
| this._loadMsg = setTimeout($.proxy(function() { | |
| this._getLoader().loader( "show", theme, msg, textonly ); | |
| this._loadMsg = 0; | |
| }, this), delay ); | |
| }, | |
| _hideLoading: function() { | |
| // Stop message show timer | |
| clearTimeout( this._loadMsg ); | |
| this._loadMsg = 0; | |
| // Hide loading message | |
| this._getLoader().loader( "hide" ); | |
| }, | |
| _showError: function() { | |
| // make sure to remove the current loading message | |
| this._hideLoading(); | |
| // show the error message | |
| this._showLoading( 0, $.mobile.pageLoadErrorMessageTheme, $.mobile.pageLoadErrorMessage, true ); | |
| // hide the error message after a delay | |
| // TODO configuration | |
| setTimeout( $.proxy(this, "_hideLoading"), 1500 ); | |
| }, | |
| _parse: function( html, fileUrl ) { | |
| // TODO consider allowing customization of this method. It's very JQM specific | |
| var page, all = $( "<div></div>" ); | |
| //workaround to allow scripts to execute when included in page divs | |
| all.get( 0 ).innerHTML = html; | |
| page = all.find( ":jqmData(role='page'), :jqmData(role='dialog')" ).first(); | |
| //if page elem couldn't be found, create one and insert the body element's contents | |
| if ( !page.length ) { | |
| page = $( "<div data-" + this._getNs() + "role='page'>" + | |
| ( html.split( /<\/?body[^>]*>/gmi )[1] || "" ) + | |
| "</div>" ); | |
| } | |
| // TODO tagging a page with external to make sure that embedded pages aren't | |
| // removed by the various page handling code is bad. Having page handling code | |
| // in many places is bad. Solutions post 1.0 | |
| page.attr( "data-" + this._getNs() + "url", $.mobile.path.convertUrlToDataUrl(fileUrl) ) | |
| .attr( "data-" + this._getNs() + "external-page", true ); | |
| return page; | |
| }, | |
| _setLoadedTitle: function( page, html ) { | |
| //page title regexp | |
| var newPageTitle = html.match( /<title[^>]*>([^<]*)/ ) && RegExp.$1; | |
| if ( newPageTitle && !page.jqmData("title") ) { | |
| newPageTitle = $( "<div>" + newPageTitle + "</div>" ).text(); | |
| page.jqmData( "title", newPageTitle ); | |
| } | |
| }, | |
| _isRewritableBaseTag: function() { | |
| return $.mobile.dynamicBaseEnabled && !$.support.dynamicBaseTag; | |
| }, | |
| _createDataUrl: function( absoluteUrl ) { | |
| return $.mobile.path.convertUrlToDataUrl( absoluteUrl ); | |
| }, | |
| _createFileUrl: function( absoluteUrl ) { | |
| return $.mobile.path.getFilePath( absoluteUrl ); | |
| }, | |
| _triggerWithDeprecated: function( name, data, page ) { | |
| var deprecatedEvent = $.Event( "page" + name ), | |
| newEvent = $.Event( this.widgetName + name ); | |
| // DEPRECATED | |
| // trigger the old deprecated event on the page if it's provided | |
| ( page || this.element ).trigger( deprecatedEvent, data ); | |
| // use the widget trigger method for the new content* event | |
| this._trigger( name, newEvent, data ); | |
| return { | |
| deprecatedEvent: deprecatedEvent, | |
| event: newEvent | |
| }; | |
| }, | |
| // TODO it would be nice to split this up more but everything appears to be "one off" | |
| // or require ordering such that other bits are sprinkled in between parts that | |
| // could be abstracted out as a group | |
| _loadSuccess: function( absUrl, triggerData, settings, deferred ) { | |
| var fileUrl = this._createFileUrl( absUrl ), | |
| dataUrl = this._createDataUrl( absUrl ); | |
| return $.proxy(function( html, textStatus, xhr ) { | |
| //pre-parse html to check for a data-url, | |
| //use it as the new fileUrl, base path, etc | |
| var content, | |
| // TODO handle dialogs again | |
| pageElemRegex = new RegExp( "(<[^>]+\\bdata-" + this._getNs() + "role=[\"']?page[\"']?[^>]*>)" ), | |
| dataUrlRegex = new RegExp( "\\bdata-" + this._getNs() + "url=[\"']?([^\"'>]*)[\"']?" ); | |
| // data-url must be provided for the base tag so resource requests | |
| // can be directed to the correct url. loading into a temprorary | |
| // element makes these requests immediately | |
| if ( pageElemRegex.test( html ) && | |
| RegExp.$1 && | |
| dataUrlRegex.test( RegExp.$1 ) && | |
| RegExp.$1 ) { | |
| fileUrl = $.mobile.path.getFilePath( $("<div>" + RegExp.$1 + "</div>").text() ); | |
| } | |
| //dont update the base tag if we are prefetching | |
| if ( settings.prefetch === undefined ) { | |
| this._getBase().set( fileUrl ); | |
| } | |
| content = this._parse( html, fileUrl ); | |
| this._setLoadedTitle( content, html ); | |
| // Add the content reference and xhr to our triggerData. | |
| triggerData.xhr = xhr; | |
| triggerData.textStatus = textStatus; | |
| // DEPRECATED | |
| triggerData.page = content; | |
| triggerData.content = content; | |
| triggerData.toPage = content; | |
| // If the default behavior is prevented, stop here! | |
| // Note that it is the responsibility of the listener/handler | |
| // that called preventDefault(), to resolve/reject the | |
| // deferred object within the triggerData. | |
| if ( this._triggerWithDeprecated( "load" ).event.isDefaultPrevented() ) { | |
| return; | |
| } | |
| // rewrite src and href attrs to use a base url if the base tag won't work | |
| if ( this._isRewritableBaseTag() && content ) { | |
| this._getBase().rewrite( fileUrl, content ); | |
| } | |
| this._include( content, settings ); | |
| // Enhancing the content may result in new dialogs/sub content being inserted | |
| // into the DOM. If the original absUrl refers to a sub-content, that is the | |
| // real content we are interested in. | |
| if ( absUrl.indexOf( "&" + $.mobile.subPageUrlKey ) > -1 ) { | |
| content = this.element.children( "[data-" + this._getNs() +"url='" + dataUrl + "']" ); | |
| } | |
| // Remove loading message. | |
| if ( settings.showLoadMsg ) { | |
| this._hideLoading(); | |
| } | |
| deferred.resolve( absUrl, settings, content ); | |
| }, this); | |
| }, | |
| _loadDefaults: { | |
| type: "get", | |
| data: undefined, | |
| // DEPRECATED | |
| reloadPage: false, | |
| reload: false, | |
| // By default we rely on the role defined by the @data-role attribute. | |
| role: undefined, | |
| showLoadMsg: false, | |
| // This delay allows loads that pull from browser cache to | |
| // occur without showing the loading message. | |
| loadMsgDelay: 50 | |
| }, | |
| load: function( url, options ) { | |
| // This function uses deferred notifications to let callers | |
| // know when the content is done loading, or if an error has occurred. | |
| var deferred = ( options && options.deferred ) || $.Deferred(), | |
| // The default load options with overrides specified by the caller. | |
| settings = $.extend( {}, this._loadDefaults, options ), | |
| // The DOM element for the content after it has been loaded. | |
| content = null, | |
| // The absolute version of the URL passed into the function. This | |
| // version of the URL may contain dialog/subcontent params in it. | |
| absUrl = $.mobile.path.makeUrlAbsolute( url, this._findBaseWithDefault() ), | |
| fileUrl, dataUrl, pblEvent, triggerData; | |
| // DEPRECATED reloadPage | |
| settings.reload = settings.reloadPage; | |
| // If the caller provided data, and we're using "get" request, | |
| // append the data to the URL. | |
| if ( settings.data && settings.type === "get" ) { | |
| absUrl = $.mobile.path.addSearchParams( absUrl, settings.data ); | |
| settings.data = undefined; | |
| } | |
| // If the caller is using a "post" request, reload must be true | |
| if ( settings.data && settings.type === "post" ) { | |
| settings.reload = true; | |
| } | |
| // The absolute version of the URL minus any dialog/subcontent params. | |
| // In otherwords the real URL of the content to be loaded. | |
| fileUrl = this._createFileUrl( absUrl ); | |
| // The version of the Url actually stored in the data-url attribute of | |
| // the content. For embedded content, it is just the id of the page. For | |
| // content within the same domain as the document base, it is the site | |
| // relative path. For cross-domain content (Phone Gap only) the entire | |
| // absolute Url is used to load the content. | |
| dataUrl = this._createDataUrl( absUrl ); | |
| content = this._find( absUrl ); | |
| // If it isn't a reference to the first content and refers to missing | |
| // embedded content reject the deferred and return | |
| if ( content.length === 0 && | |
| $.mobile.path.isEmbeddedPage(fileUrl) && | |
| !$.mobile.path.isFirstPageUrl(fileUrl) ) { | |
| deferred.reject( absUrl, settings ); | |
| return deferred.promise(); | |
| } | |
| // Reset base to the default document base | |
| // TODO figure out why we doe this | |
| this._getBase().reset(); | |
| // If the content we are interested in is already in the DOM, | |
| // and the caller did not indicate that we should force a | |
| // reload of the file, we are done. Resolve the deferrred so that | |
| // users can bind to .done on the promise | |
| if ( content.length && !settings.reload ) { | |
| this._enhance( content, settings.role ); | |
| deferred.resolve( absUrl, settings, content ); | |
| //if we are reloading the content make sure we update | |
| // the base if its not a prefetch | |
| if ( !settings.prefetch ) { | |
| this._getBase().set(url); | |
| } | |
| return deferred.promise(); | |
| } | |
| triggerData = { | |
| url: url, | |
| absUrl: absUrl, | |
| toPage: url, | |
| prevPage: options ? options.fromPage : undefined, | |
| dataUrl: dataUrl, | |
| deferred: deferred, | |
| options: settings | |
| }; | |
| // Let listeners know we're about to load content. | |
| pblEvent = this._triggerWithDeprecated( "beforeload", triggerData ); | |
| // If the default behavior is prevented, stop here! | |
| if ( pblEvent.deprecatedEvent.isDefaultPrevented() || | |
| pblEvent.event.isDefaultPrevented() ) { | |
| return deferred.promise(); | |
| } | |
| if ( settings.showLoadMsg ) { | |
| this._showLoading( settings.loadMsgDelay ); | |
| } | |
| // Reset base to the default document base. | |
| // only reset if we are not prefetching | |
| if ( settings.prefetch === undefined ) { | |
| this._getBase().reset(); | |
| } | |
| if ( !( $.mobile.allowCrossDomainPages || | |
| $.mobile.path.isSameDomain($.mobile.path.documentUrl, absUrl ) ) ) { | |
| deferred.reject( absUrl, settings ); | |
| return deferred.promise(); | |
| } | |
| // Load the new content. | |
| $.ajax({ | |
| url: fileUrl, | |
| type: settings.type, | |
| data: settings.data, | |
| contentType: settings.contentType, | |
| dataType: "html", | |
| success: this._loadSuccess( absUrl, triggerData, settings, deferred ), | |
| error: this._loadError( absUrl, triggerData, settings, deferred ) | |
| }); | |
| return deferred.promise(); | |
| }, | |
| _loadError: function( absUrl, triggerData, settings, deferred ) { | |
| return $.proxy(function( xhr, textStatus, errorThrown ) { | |
| //set base back to current path | |
| this._getBase().set( $.mobile.path.get() ); | |
| // Add error info to our triggerData. | |
| triggerData.xhr = xhr; | |
| triggerData.textStatus = textStatus; | |
| triggerData.errorThrown = errorThrown; | |
| // Let listeners know the page load failed. | |
| var plfEvent = this._triggerWithDeprecated( "loadfailed", triggerData ); | |
| // If the default behavior is prevented, stop here! | |
| // Note that it is the responsibility of the listener/handler | |
| // that called preventDefault(), to resolve/reject the | |
| // deferred object within the triggerData. | |
| if ( plfEvent.deprecatedEvent.isDefaultPrevented() || | |
| plfEvent.event.isDefaultPrevented() ) { | |
| return; | |
| } | |
| // Remove loading message. | |
| if ( settings.showLoadMsg ) { | |
| this._showError(); | |
| } | |
| deferred.reject( absUrl, settings ); | |
| }, this); | |
| }, | |
| _getTransitionHandler: function( transition ) { | |
| transition = $.mobile._maybeDegradeTransition( transition ); | |
| //find the transition handler for the specified transition. If there | |
| //isn't one in our transitionHandlers dictionary, use the default one. | |
| //call the handler immediately to kick-off the transition. | |
| return $.mobile.transitionHandlers[ transition ] || $.mobile.defaultTransitionHandler; | |
| }, | |
| // TODO move into transition handlers? | |
| _triggerCssTransitionEvents: function( to, from, prefix ) { | |
| var samePage = false; | |
| prefix = prefix || ""; | |
| // TODO decide if these events should in fact be triggered on the container | |
| if ( from ) { | |
| //Check if this is a same page transition and tell the handler in page | |
| if( to[0] === from[0] ){ | |
| samePage = true; | |
| } | |
| //trigger before show/hide events | |
| // TODO deprecate nextPage in favor of next | |
| this._triggerWithDeprecated( prefix + "hide", { | |
| // Deprecated in 1.4 remove in 1.5 | |
| nextPage: to, | |
| toPage: to, | |
| prevPage: from, | |
| samePage: samePage | |
| }, from ); | |
| } | |
| // TODO deprecate prevPage in favor of previous | |
| this._triggerWithDeprecated( prefix + "show", { | |
| prevPage: from || $( "" ), | |
| toPage: to | |
| }, to ); | |
| }, | |
| // TODO make private once change has been defined in the widget | |
| _cssTransition: function( to, from, options ) { | |
| var transition = options.transition, | |
| reverse = options.reverse, | |
| deferred = options.deferred, | |
| TransitionHandler, | |
| promise; | |
| this._triggerCssTransitionEvents( to, from, "before" ); | |
| // TODO put this in a binding to events *outside* the widget | |
| this._hideLoading(); | |
| TransitionHandler = this._getTransitionHandler( transition ); | |
| promise = ( new TransitionHandler( transition, reverse, to, from ) ).transition(); | |
| promise.done( $.proxy( function() { | |
| this._triggerCssTransitionEvents( to, from ); | |
| }, this )); | |
| // TODO temporary accomodation of argument deferred | |
| promise.done(function() { | |
| deferred.resolve.apply( deferred, arguments ); | |
| }); | |
| }, | |
| _releaseTransitionLock: function() { | |
| //release transition lock so navigation is free again | |
| isPageTransitioning = false; | |
| if ( pageTransitionQueue.length > 0 ) { | |
| $.mobile.changePage.apply( null, pageTransitionQueue.pop() ); | |
| } | |
| }, | |
| _removeActiveLinkClass: function( force ) { | |
| //clear out the active button state | |
| $.mobile.removeActiveLinkClass( force ); | |
| }, | |
| _loadUrl: function( to, triggerData, settings ) { | |
| // preserve the original target as the dataUrl value will be | |
| // simplified eg, removing ui-state, and removing query params | |
| // from the hash this is so that users who want to use query | |
| // params have access to them in the event bindings for the page | |
| // life cycle See issue #5085 | |
| settings.target = to; | |
| settings.deferred = $.Deferred(); | |
| this.load( to, settings ); | |
| settings.deferred.done($.proxy(function( url, options, content ) { | |
| isPageTransitioning = false; | |
| // store the original absolute url so that it can be provided | |
| // to events in the triggerData of the subsequent changePage call | |
| options.absUrl = triggerData.absUrl; | |
| this.transition( content, triggerData, options ); | |
| }, this)); | |
| settings.deferred.fail($.proxy(function(/* url, options */) { | |
| this._removeActiveLinkClass( true ); | |
| this._releaseTransitionLock(); | |
| this._triggerWithDeprecated( "changefailed", triggerData ); | |
| }, this)); | |
| }, | |
| _triggerPageBeforeChange: function( to, triggerData, settings ) { | |
| var returnEvents; | |
| triggerData.prevPage = this.activePage; | |
| $.extend( triggerData, { | |
| toPage: to, | |
| options: settings | |
| }); | |
| // NOTE: preserve the original target as the dataUrl value will be | |
| // simplified eg, removing ui-state, and removing query params from | |
| // the hash this is so that users who want to use query params have | |
| // access to them in the event bindings for the page life cycle | |
| // See issue #5085 | |
| if ( $.type(to) === "string" ) { | |
| // if the toPage is a string simply convert it | |
| triggerData.absUrl = $.mobile.path.makeUrlAbsolute( to, this._findBaseWithDefault() ); | |
| } else { | |
| // if the toPage is a jQuery object grab the absolute url stored | |
| // in the loadPage callback where it exists | |
| triggerData.absUrl = settings.absUrl; | |
| } | |
| // Let listeners know we're about to change the current page. | |
| returnEvents = this._triggerWithDeprecated( "beforechange", triggerData ); | |
| // If the default behavior is prevented, stop here! | |
| if ( returnEvents.event.isDefaultPrevented() || | |
| returnEvents.deprecatedEvent.isDefaultPrevented() ) { | |
| return false; | |
| } | |
| return true; | |
| }, | |
| change: function( to, options ) { | |
| // If we are in the midst of a transition, queue the current request. | |
| // We'll call changePage() once we're done with the current transition | |
| // to service the request. | |
| if ( isPageTransitioning ) { | |
| pageTransitionQueue.unshift( arguments ); | |
| return; | |
| } | |
| var settings = $.extend( {}, $.mobile.changePage.defaults, options ), | |
| triggerData = {}; | |
| // Make sure we have a fromPage. | |
| settings.fromPage = settings.fromPage || this.activePage; | |
| // if the page beforechange default is prevented return early | |
| if ( !this._triggerPageBeforeChange(to, triggerData, settings) ) { | |
| return; | |
| } | |
| // We allow "pagebeforechange" observers to modify the to in | |
| // the trigger data to allow for redirects. Make sure our to is | |
| // updated. We also need to re-evaluate whether it is a string, | |
| // because an object can also be replaced by a string | |
| to = triggerData.toPage; | |
| // If the caller passed us a url, call loadPage() | |
| // to make sure it is loaded into the DOM. We'll listen | |
| // to the promise object it returns so we know when | |
| // it is done loading or if an error ocurred. | |
| if ( $.type(to) === "string" ) { | |
| // Set the isPageTransitioning flag to prevent any requests from | |
| // entering this method while we are in the midst of loading a page | |
| // or transitioning. | |
| isPageTransitioning = true; | |
| this._loadUrl( to, triggerData, settings ); | |
| } else { | |
| this.transition( to, triggerData, settings ); | |
| } | |
| }, | |
| transition: function( toPage, triggerData, settings ) { | |
| var fromPage, url, pageUrl, fileUrl, | |
| active, activeIsInitialPage, | |
| historyDir, pageTitle, isDialog, | |
| alreadyThere, newPageTitle, | |
| params, cssTransitionDeferred, | |
| beforeTransition; | |
| // If we are in the midst of a transition, queue the current request. | |
| // We'll call changePage() once we're done with the current transition | |
| // to service the request. | |
| if ( isPageTransitioning ) { | |
| // make sure to only queue the to and settings values so the arguments | |
| // work with a call to the change method | |
| pageTransitionQueue.unshift( [toPage, settings] ); | |
| return; | |
| } | |
| // DEPRECATED - this call only, in favor of the before transition | |
| // if the page beforechange default is prevented return early | |
| if ( !this._triggerPageBeforeChange(toPage, triggerData, settings) ) { | |
| return; | |
| } | |
| triggerData.prevPage = settings.fromPage; | |
| // if the (content|page)beforetransition default is prevented return early | |
| // Note, we have to check for both the deprecated and new events | |
| beforeTransition = this._triggerWithDeprecated( "beforetransition", triggerData ); | |
| if (beforeTransition.deprecatedEvent.isDefaultPrevented() || | |
| beforeTransition.event.isDefaultPrevented() ) { | |
| return; | |
| } | |
| // Set the isPageTransitioning flag to prevent any requests from | |
| // entering this method while we are in the midst of loading a page | |
| // or transitioning. | |
| isPageTransitioning = true; | |
| // If we are going to the first-page of the application, we need to make | |
| // sure settings.dataUrl is set to the application document url. This allows | |
| // us to avoid generating a document url with an id hash in the case where the | |
| // first-page of the document has an id attribute specified. | |
| if ( toPage[ 0 ] === $.mobile.firstPage[ 0 ] && !settings.dataUrl ) { | |
| settings.dataUrl = $.mobile.path.documentUrl.hrefNoHash; | |
| } | |
| // The caller passed us a real page DOM element. Update our | |
| // internal state and then trigger a transition to the page. | |
| fromPage = settings.fromPage; | |
| url = ( settings.dataUrl && $.mobile.path.convertUrlToDataUrl(settings.dataUrl) ) || | |
| toPage.jqmData( "url" ); | |
| // The pageUrl var is usually the same as url, except when url is obscured | |
| // as a dialog url. pageUrl always contains the file path | |
| pageUrl = url; | |
| fileUrl = $.mobile.path.getFilePath( url ); | |
| active = $.mobile.navigate.history.getActive(); | |
| activeIsInitialPage = $.mobile.navigate.history.activeIndex === 0; | |
| historyDir = 0; | |
| pageTitle = document.title; | |
| isDialog = ( settings.role === "dialog" || | |
| toPage.jqmData( "role" ) === "dialog" ) && | |
| toPage.jqmData( "dialog" ) !== true; | |
| // By default, we prevent changePage requests when the fromPage and toPage | |
| // are the same element, but folks that generate content | |
| // manually/dynamically and reuse pages want to be able to transition to | |
| // the same page. To allow this, they will need to change the default | |
| // value of allowSamePageTransition to true, *OR*, pass it in as an | |
| // option when they manually call changePage(). It should be noted that | |
| // our default transition animations assume that the formPage and toPage | |
| // are different elements, so they may behave unexpectedly. It is up to | |
| // the developer that turns on the allowSamePageTransitiona option to | |
| // either turn off transition animations, or make sure that an appropriate | |
| // animation transition is used. | |
| if ( fromPage && fromPage[0] === toPage[0] && | |
| !settings.allowSamePageTransition ) { | |
| isPageTransitioning = false; | |
| this._triggerWithDeprecated( "transition", triggerData ); | |
| this._triggerWithDeprecated( "change", triggerData ); | |
| // Even if there is no page change to be done, we should keep the | |
| // urlHistory in sync with the hash changes | |
| if ( settings.fromHashChange ) { | |
| $.mobile.navigate.history.direct({ url: url }); | |
| } | |
| return; | |
| } | |
| // We need to make sure the page we are given has already been enhanced. | |
| toPage.page({ role: settings.role }); | |
| // If the changePage request was sent from a hashChange event, check to | |
| // see if the page is already within the urlHistory stack. If so, we'll | |
| // assume the user hit the forward/back button and will try to match the | |
| // transition accordingly. | |
| if ( settings.fromHashChange ) { | |
| historyDir = settings.direction === "back" ? -1 : 1; | |
| } | |
| // Kill the keyboard. | |
| // XXX_jblas: We need to stop crawling the entire document to kill focus. | |
| // Instead, we should be tracking focus with a delegate() | |
| // handler so we already have the element in hand at this | |
| // point. | |
| // Wrap this in a try/catch block since IE9 throw "Unspecified error" if | |
| // document.activeElement is undefined when we are in an IFrame. | |
| try { | |
| if ( document.activeElement && | |
| document.activeElement.nodeName.toLowerCase() !== "body" ) { | |
| $( document.activeElement ).blur(); | |
| } else { | |
| $( "input:focus, textarea:focus, select:focus" ).blur(); | |
| } | |
| } catch( e ) {} | |
| // Record whether we are at a place in history where a dialog used to be - | |
| // if so, do not add a new history entry and do not change the hash either | |
| alreadyThere = false; | |
| // If we're displaying the page as a dialog, we don't want the url | |
| // for the dialog content to be used in the hash. Instead, we want | |
| // to append the dialogHashKey to the url of the current page. | |
| if ( isDialog && active ) { | |
| // on the initial page load active.url is undefined and in that case | |
| // should be an empty string. Moving the undefined -> empty string back | |
| // into urlHistory.addNew seemed imprudent given undefined better | |
| // represents the url state | |
| // If we are at a place in history that once belonged to a dialog, reuse | |
| // this state without adding to urlHistory and without modifying the | |
| // hash. However, if a dialog is already displayed at this point, and | |
| // we're about to display another dialog, then we must add another hash | |
| // and history entry on top so that one may navigate back to the | |
| // original dialog | |
| if ( active.url && | |
| active.url.indexOf( $.mobile.dialogHashKey ) > -1 && | |
| this.activePage && | |
| !this.activePage.hasClass( "ui-dialog" ) && | |
| $.mobile.navigate.history.activeIndex > 0 ) { | |
| settings.changeHash = false; | |
| alreadyThere = true; | |
| } | |
| // Normally, we tack on a dialog hash key, but if this is the location | |
| // of a stale dialog, we reuse the URL from the entry | |
| url = ( active.url || "" ); | |
| // account for absolute urls instead of just relative urls use as hashes | |
| if ( !alreadyThere && url.indexOf("#") > -1 ) { | |
| url += $.mobile.dialogHashKey; | |
| } else { | |
| url += "#" + $.mobile.dialogHashKey; | |
| } | |
| // tack on another dialogHashKey if this is the same as the initial hash | |
| // this makes sure that a history entry is created for this dialog | |
| if ( $.mobile.navigate.history.activeIndex === 0 && url === $.mobile.navigate.history.initialDst ) { | |
| url += $.mobile.dialogHashKey; | |
| } | |
| } | |
| // if title element wasn't found, try the page div data attr too | |
| // If this is a deep-link or a reload ( active === undefined ) then just | |
| // use pageTitle | |
| newPageTitle = ( !active ) ? pageTitle : toPage.jqmData( "title" ) || | |
| toPage.children( ":jqmData(role='header')" ).find( ".ui-title" ).text(); | |
| if ( !!newPageTitle && pageTitle === document.title ) { | |
| pageTitle = newPageTitle; | |
| } | |
| if ( !toPage.jqmData( "title" ) ) { | |
| toPage.jqmData( "title", pageTitle ); | |
| } | |
| // Make sure we have a transition defined. | |
| settings.transition = settings.transition || | |
| ( ( historyDir && !activeIsInitialPage ) ? active.transition : undefined ) || | |
| ( isDialog ? $.mobile.defaultDialogTransition : $.mobile.defaultPageTransition ); | |
| //add page to history stack if it's not back or forward | |
| if ( !historyDir && alreadyThere ) { | |
| $.mobile.navigate.history.getActive().pageUrl = pageUrl; | |
| } | |
| // Set the location hash. | |
| if ( url && !settings.fromHashChange ) { | |
| // rebuilding the hash here since we loose it earlier on | |
| // TODO preserve the originally passed in path | |
| if ( !$.mobile.path.isPath( url ) && url.indexOf( "#" ) < 0 ) { | |
| url = "#" + url; | |
| } | |
| // TODO the property names here are just silly | |
| params = { | |
| transition: settings.transition, | |
| title: pageTitle, | |
| pageUrl: pageUrl, | |
| role: settings.role | |
| }; | |
| if ( settings.changeHash !== false && $.mobile.hashListeningEnabled ) { | |
| $.mobile.navigate( url, params, true); | |
| } else if ( toPage[ 0 ] !== $.mobile.firstPage[ 0 ] ) { | |
| $.mobile.navigate.history.add( url, params ); | |
| } | |
| } | |
| //set page title | |
| document.title = pageTitle; | |
| //set "toPage" as activePage deprecated in 1.4 remove in 1.5 | |
| $.mobile.activePage = toPage; | |
| //new way to handle activePage | |
| this.activePage = toPage; | |
| // If we're navigating back in the URL history, set reverse accordingly. | |
| settings.reverse = settings.reverse || historyDir < 0; | |
| cssTransitionDeferred = $.Deferred(); | |
| this._cssTransition(toPage, fromPage, { | |
| transition: settings.transition, | |
| reverse: settings.reverse, | |
| deferred: cssTransitionDeferred | |
| }); | |
| cssTransitionDeferred.done($.proxy(function( name, reverse, $to, $from, alreadyFocused ) { | |
| $.mobile.removeActiveLinkClass(); | |
| //if there's a duplicateCachedPage, remove it from the DOM now that it's hidden | |
| if ( settings.duplicateCachedPage ) { | |
| settings.duplicateCachedPage.remove(); | |
| } | |
| // despite visibility: hidden addresses issue #2965 | |
| // https://github.com/jquery/jquery-mobile/issues/2965 | |
| if ( !alreadyFocused ) { | |
| $.mobile.focusPage( toPage ); | |
| } | |
| this._releaseTransitionLock(); | |
| this._triggerWithDeprecated( "transition", triggerData ); | |
| this._triggerWithDeprecated( "change", triggerData ); | |
| }, this)); | |
| }, | |
| // determine the current base url | |
| _findBaseWithDefault: function() { | |
| var closestBase = ( this.activePage && | |
| $.mobile.getClosestBaseUrl( this.activePage ) ); | |
| return closestBase || $.mobile.path.documentBase.hrefNoHash; | |
| } | |
| }); | |
| // The following handlers should be bound after mobileinit has been triggered | |
| // the following deferred is resolved in the init file | |
| $.mobile.navreadyDeferred = $.Deferred(); | |
| //these variables make all page containers use the same queue and only navigate one at a time | |
| // queue to hold simultanious page transitions | |
| var pageTransitionQueue = [], | |
| // indicates whether or not page is in process of transitioning | |
| isPageTransitioning = false; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| // resolved on domready | |
| var domreadyDeferred = $.Deferred(), | |
| // resolved and nulled on window.load() | |
| loadDeferred = $.Deferred(), | |
| // function that resolves the above deferred | |
| pageIsFullyLoaded = function() { | |
| // Resolve and null the deferred | |
| loadDeferred.resolve(); | |
| loadDeferred = null; | |
| }, | |
| documentUrl = $.mobile.path.documentUrl, | |
| // used to track last vclicked element to make sure its value is added to form data | |
| $lastVClicked = null; | |
| /* Event Bindings - hashchange, submit, and click */ | |
| function findClosestLink( ele ) { | |
| while ( ele ) { | |
| // Look for the closest element with a nodeName of "a". | |
| // Note that we are checking if we have a valid nodeName | |
| // before attempting to access it. This is because the | |
| // node we get called with could have originated from within | |
| // an embedded SVG document where some symbol instance elements | |
| // don't have nodeName defined on them, or strings are of type | |
| // SVGAnimatedString. | |
| if ( ( typeof ele.nodeName === "string" ) && ele.nodeName.toLowerCase() === "a" ) { | |
| break; | |
| } | |
| ele = ele.parentNode; | |
| } | |
| return ele; | |
| } | |
| $.mobile.loadPage = function( url, opts ) { | |
| var container; | |
| opts = opts || {}; | |
| container = ( opts.pageContainer || $.mobile.pageContainer ); | |
| // create the deferred that will be supplied to loadPage callers | |
| // and resolved by the content widget's load method | |
| opts.deferred = $.Deferred(); | |
| // Preferring to allow exceptions for uninitialized opts.pageContainer | |
| // widgets so we know if we need to force init here for users | |
| container.pagecontainer( "load", url, opts ); | |
| // provide the deferred | |
| return opts.deferred.promise(); | |
| }; | |
| //define vars for interal use | |
| /* internal utility functions */ | |
| // NOTE Issue #4950 Android phonegap doesn't navigate back properly | |
| // when a full page refresh has taken place. It appears that hashchange | |
| // and replacestate history alterations work fine but we need to support | |
| // both forms of history traversal in our code that uses backward history | |
| // movement | |
| $.mobile.back = function() { | |
| var nav = window.navigator; | |
| // if the setting is on and the navigator object is | |
| // available use the phonegap navigation capability | |
| if ( this.phonegapNavigationEnabled && | |
| nav && | |
| nav.app && | |
| nav.app.backHistory ) { | |
| nav.app.backHistory(); | |
| } else { | |
| $.mobile.pageContainer.pagecontainer( "back" ); | |
| } | |
| }; | |
| // Direct focus to the page title, or otherwise first focusable element | |
| $.mobile.focusPage = function ( page ) { | |
| var autofocus = page.find( "[autofocus]" ), | |
| pageTitle = page.find( ".ui-title:eq(0)" ); | |
| if ( autofocus.length ) { | |
| autofocus.focus(); | |
| return; | |
| } | |
| if ( pageTitle.length ) { | |
| pageTitle.focus(); | |
| } else{ | |
| page.focus(); | |
| } | |
| }; | |
| // No-op implementation of transition degradation | |
| $.mobile._maybeDegradeTransition = $.mobile._maybeDegradeTransition || function( transition ) { | |
| return transition; | |
| }; | |
| // Exposed $.mobile methods | |
| $.mobile.changePage = function( to, options ) { | |
| $.mobile.pageContainer.pagecontainer( "change", to, options ); | |
| }; | |
| $.mobile.changePage.defaults = { | |
| transition: undefined, | |
| reverse: false, | |
| changeHash: true, | |
| fromHashChange: false, | |
| role: undefined, // By default we rely on the role defined by the @data-role attribute. | |
| duplicateCachedPage: undefined, | |
| pageContainer: undefined, | |
| showLoadMsg: true, //loading message shows by default when pages are being fetched during changePage | |
| dataUrl: undefined, | |
| fromPage: undefined, | |
| allowSamePageTransition: false | |
| }; | |
| $.mobile._registerInternalEvents = function() { | |
| var getAjaxFormData = function( $form, calculateOnly ) { | |
| var url, ret = true, formData, vclickedName, method; | |
| if ( !$.mobile.ajaxEnabled || | |
| // test that the form is, itself, ajax false | |
| $form.is( ":jqmData(ajax='false')" ) || | |
| // test that $.mobile.ignoreContentEnabled is set and | |
| // the form or one of it's parents is ajax=false | |
| !$form.jqmHijackable().length || | |
| $form.attr( "target" ) ) { | |
| return false; | |
| } | |
| url = ( $lastVClicked && $lastVClicked.attr( "formaction" ) ) || | |
| $form.attr( "action" ); | |
| method = ( $form.attr( "method" ) || "get" ).toLowerCase(); | |
| // If no action is specified, browsers default to using the | |
| // URL of the document containing the form. Since we dynamically | |
| // pull in pages from external documents, the form should submit | |
| // to the URL for the source document of the page containing | |
| // the form. | |
| if ( !url ) { | |
| // Get the @data-url for the page containing the form. | |
| url = $.mobile.getClosestBaseUrl( $form ); | |
| // NOTE: If the method is "get", we need to strip off the query string | |
| // because it will get replaced with the new form data. See issue #5710. | |
| if ( method === "get" ) { | |
| url = $.mobile.path.parseUrl( url ).hrefNoSearch; | |
| } | |
| if ( url === $.mobile.path.documentBase.hrefNoHash ) { | |
| // The url we got back matches the document base, | |
| // which means the page must be an internal/embedded page, | |
| // so default to using the actual document url as a browser | |
| // would. | |
| url = documentUrl.hrefNoSearch; | |
| } | |
| } | |
| url = $.mobile.path.makeUrlAbsolute( url, $.mobile.getClosestBaseUrl( $form ) ); | |
| if ( ( $.mobile.path.isExternal( url ) && !$.mobile.path.isPermittedCrossDomainRequest( documentUrl, url ) ) ) { | |
| return false; | |
| } | |
| if ( !calculateOnly ) { | |
| formData = $form.serializeArray(); | |
| if ( $lastVClicked && $lastVClicked[ 0 ].form === $form[ 0 ] ) { | |
| vclickedName = $lastVClicked.attr( "name" ); | |
| if ( vclickedName ) { | |
| // Make sure the last clicked element is included in the form | |
| $.each( formData, function( key, value ) { | |
| if ( value.name === vclickedName ) { | |
| // Unset vclickedName - we've found it in the serialized data already | |
| vclickedName = ""; | |
| return false; | |
| } | |
| }); | |
| if ( vclickedName ) { | |
| formData.push( { name: vclickedName, value: $lastVClicked.attr( "value" ) } ); | |
| } | |
| } | |
| } | |
| ret = { | |
| url: url, | |
| options: { | |
| type: method, | |
| data: $.param( formData ), | |
| transition: $form.jqmData( "transition" ), | |
| reverse: $form.jqmData( "direction" ) === "reverse", | |
| reloadPage: true | |
| } | |
| }; | |
| } | |
| return ret; | |
| }; | |
| //bind to form submit events, handle with Ajax | |
| $.mobile.document.delegate( "form", "submit", function( event ) { | |
| var formData; | |
| if ( !event.isDefaultPrevented() ) { | |
| formData = getAjaxFormData( $( this ) ); | |
| if ( formData ) { | |
| $.mobile.changePage( formData.url, formData.options ); | |
| event.preventDefault(); | |
| } | |
| } | |
| }); | |
| //add active state on vclick | |
| $.mobile.document.bind( "vclick", function( event ) { | |
| var $btn, btnEls, target = event.target, needClosest = false; | |
| // if this isn't a left click we don't care. Its important to note | |
| // that when the virtual event is generated it will create the which attr | |
| if ( event.which > 1 || !$.mobile.linkBindingEnabled ) { | |
| return; | |
| } | |
| // Record that this element was clicked, in case we need it for correct | |
| // form submission during the "submit" handler above | |
| $lastVClicked = $( target ); | |
| // Try to find a target element to which the active class will be applied | |
| if ( $.data( target, "mobile-button" ) ) { | |
| // If the form will not be submitted via AJAX, do not add active class | |
| if ( !getAjaxFormData( $( target ).closest( "form" ), true ) ) { | |
| return; | |
| } | |
| // We will apply the active state to this button widget - the parent | |
| // of the input that was clicked will have the associated data | |
| if ( target.parentNode ) { | |
| target = target.parentNode; | |
| } | |
| } else { | |
| target = findClosestLink( target ); | |
| if ( !( target && $.mobile.path.parseUrl( target.getAttribute( "href" ) || "#" ).hash !== "#" ) ) { | |
| return; | |
| } | |
| // TODO teach $.mobile.hijackable to operate on raw dom elements so the | |
| // link wrapping can be avoided | |
| if ( !$( target ).jqmHijackable().length ) { | |
| return; | |
| } | |
| } | |
| // Avoid calling .closest by using the data set during .buttonMarkup() | |
| // List items have the button data in the parent of the element clicked | |
| if ( !!~target.className.indexOf( "ui-link-inherit" ) ) { | |
| if ( target.parentNode ) { | |
| btnEls = $.data( target.parentNode, "buttonElements" ); | |
| } | |
| // Otherwise, look for the data on the target itself | |
| } else { | |
| btnEls = $.data( target, "buttonElements" ); | |
| } | |
| // If found, grab the button's outer element | |
| if ( btnEls ) { | |
| target = btnEls.outer; | |
| } else { | |
| needClosest = true; | |
| } | |
| $btn = $( target ); | |
| // If the outer element wasn't found by the our heuristics, use .closest() | |
| if ( needClosest ) { | |
| $btn = $btn.closest( ".ui-btn" ); | |
| } | |
| if ( $btn.length > 0 && | |
| !( $btn.hasClass( "ui-state-disabled" || | |
| // DEPRECATED as of 1.4.0 - remove after 1.4.0 release | |
| // only ui-state-disabled should be present thereafter | |
| $btn.hasClass( "ui-disabled" ) ) ) ) { | |
| $.mobile.removeActiveLinkClass( true ); | |
| $.mobile.activeClickedLink = $btn; | |
| $.mobile.activeClickedLink.addClass( $.mobile.activeBtnClass ); | |
| } | |
| }); | |
| // click routing - direct to HTTP or Ajax, accordingly | |
| $.mobile.document.bind( "click", function( event ) { | |
| if ( !$.mobile.linkBindingEnabled || event.isDefaultPrevented() ) { | |
| return; | |
| } | |
| var link = findClosestLink( event.target ), | |
| $link = $( link ), | |
| //remove active link class if external (then it won't be there if you come back) | |
| httpCleanup = function() { | |
| window.setTimeout(function() { $.mobile.removeActiveLinkClass( true ); }, 200 ); | |
| }, | |
| baseUrl, href, | |
| useDefaultUrlHandling, isExternal, | |
| transition, reverse, role; | |
| // If a button was clicked, clean up the active class added by vclick above | |
| if ( $.mobile.activeClickedLink && | |
| $.mobile.activeClickedLink[ 0 ] === event.target.parentNode ) { | |
| httpCleanup(); | |
| } | |
| // If there is no link associated with the click or its not a left | |
| // click we want to ignore the click | |
| // TODO teach $.mobile.hijackable to operate on raw dom elements so the link wrapping | |
| // can be avoided | |
| if ( !link || event.which > 1 || !$link.jqmHijackable().length ) { | |
| return; | |
| } | |
| //if there's a data-rel=back attr, go back in history | |
| if ( $link.is( ":jqmData(rel='back')" ) ) { | |
| $.mobile.back(); | |
| return false; | |
| } | |
| baseUrl = $.mobile.getClosestBaseUrl( $link ); | |
| //get href, if defined, otherwise default to empty hash | |
| href = $.mobile.path.makeUrlAbsolute( $link.attr( "href" ) || "#", baseUrl ); | |
| //if ajax is disabled, exit early | |
| if ( !$.mobile.ajaxEnabled && !$.mobile.path.isEmbeddedPage( href ) ) { | |
| httpCleanup(); | |
| //use default click handling | |
| return; | |
| } | |
| // XXX_jblas: Ideally links to application pages should be specified as | |
| // an url to the application document with a hash that is either | |
| // the site relative path or id to the page. But some of the | |
| // internal code that dynamically generates sub-pages for nested | |
| // lists and select dialogs, just write a hash in the link they | |
| // create. This means the actual URL path is based on whatever | |
| // the current value of the base tag is at the time this code | |
| // is called. For now we are just assuming that any url with a | |
| // hash in it is an application page reference. | |
| if ( href.search( "#" ) !== -1 ) { | |
| href = href.replace( /[^#]*#/, "" ); | |
| if ( !href ) { | |
| //link was an empty hash meant purely | |
| //for interaction, so we ignore it. | |
| event.preventDefault(); | |
| return; | |
| } else if ( $.mobile.path.isPath( href ) ) { | |
| //we have apath so make it the href we want to load. | |
| href = $.mobile.path.makeUrlAbsolute( href, baseUrl ); | |
| } else { | |
| //we have a simple id so use the documentUrl as its base. | |
| href = $.mobile.path.makeUrlAbsolute( "#" + href, documentUrl.hrefNoHash ); | |
| } | |
| } | |
| // Should we handle this link, or let the browser deal with it? | |
| useDefaultUrlHandling = $link.is( "[rel='external']" ) || $link.is( ":jqmData(ajax='false')" ) || $link.is( "[target]" ); | |
| // Some embedded browsers, like the web view in Phone Gap, allow cross-domain XHR | |
| // requests if the document doing the request was loaded via the file:// protocol. | |
| // This is usually to allow the application to "phone home" and fetch app specific | |
| // data. We normally let the browser handle external/cross-domain urls, but if the | |
| // allowCrossDomainPages option is true, we will allow cross-domain http/https | |
| // requests to go through our page loading logic. | |
| //check for protocol or rel and its not an embedded page | |
| //TODO overlap in logic from isExternal, rel=external check should be | |
| // moved into more comprehensive isExternalLink | |
| isExternal = useDefaultUrlHandling || ( $.mobile.path.isExternal( href ) && !$.mobile.path.isPermittedCrossDomainRequest( documentUrl, href ) ); | |
| if ( isExternal ) { | |
| httpCleanup(); | |
| //use default click handling | |
| return; | |
| } | |
| //use ajax | |
| transition = $link.jqmData( "transition" ); | |
| reverse = $link.jqmData( "direction" ) === "reverse" || | |
| // deprecated - remove by 1.0 | |
| $link.jqmData( "back" ); | |
| //this may need to be more specific as we use data-rel more | |
| role = $link.attr( "data-" + $.mobile.ns + "rel" ) || undefined; | |
| $.mobile.changePage( href, { transition: transition, reverse: reverse, role: role, link: $link } ); | |
| event.preventDefault(); | |
| }); | |
| //prefetch pages when anchors with data-prefetch are encountered | |
| $.mobile.document.delegate( ".ui-page", "pageshow.prefetch", function() { | |
| var urls = []; | |
| $( this ).find( "a:jqmData(prefetch)" ).each(function() { | |
| var $link = $( this ), | |
| url = $link.attr( "href" ); | |
| if ( url && $.inArray( url, urls ) === -1 ) { | |
| urls.push( url ); | |
| $.mobile.loadPage( url, { role: $link.attr( "data-" + $.mobile.ns + "rel" ),prefetch: true } ); | |
| } | |
| }); | |
| }); | |
| // TODO ensure that the navigate binding in the content widget happens at the right time | |
| $.mobile.pageContainer.pagecontainer(); | |
| //set page min-heights to be device specific | |
| $.mobile.document.bind( "pageshow", function() { | |
| // We need to wait for window.load to make sure that styles have already been rendered, | |
| // otherwise heights of external toolbars will have the wrong value | |
| if ( loadDeferred ) { | |
| loadDeferred.done( $.mobile.resetActivePageHeight ); | |
| } else { | |
| $.mobile.resetActivePageHeight(); | |
| } | |
| }); | |
| $.mobile.window.bind( "throttledresize", $.mobile.resetActivePageHeight ); | |
| };//navreadyDeferred done callback | |
| $( function() { domreadyDeferred.resolve(); } ); | |
| // Account for the possibility that the load event has already fired | |
| if ( document.readyState === "complete" ) { | |
| pageIsFullyLoaded(); | |
| } else { | |
| $.mobile.window.load( pageIsFullyLoaded ); | |
| } | |
| $.when( domreadyDeferred, $.mobile.navreadyDeferred ).done( function() { $.mobile._registerInternalEvents(); } ); | |
| })( jQuery ); | |
| (function( $, window, undefined ) { | |
| // TODO remove direct references to $.mobile and properties, we should | |
| // favor injection with params to the constructor | |
| $.mobile.Transition = function() { | |
| this.init.apply( this, arguments ); | |
| }; | |
| $.extend($.mobile.Transition.prototype, { | |
| toPreClass: " ui-page-pre-in", | |
| init: function( name, reverse, $to, $from ) { | |
| $.extend(this, { | |
| name: name, | |
| reverse: reverse, | |
| $to: $to, | |
| $from: $from, | |
| deferred: new $.Deferred() | |
| }); | |
| }, | |
| cleanFrom: function() { | |
| this.$from | |
| .removeClass( $.mobile.activePageClass + " out in reverse " + this.name ) | |
| .height( "" ); | |
| }, | |
| // NOTE overridden by child object prototypes, noop'd here as defaults | |
| beforeDoneIn: function() {}, | |
| beforeDoneOut: function() {}, | |
| beforeStartOut: function() {}, | |
| doneIn: function() { | |
| this.beforeDoneIn(); | |
| this.$to.removeClass( "out in reverse " + this.name ).height( "" ); | |
| this.toggleViewportClass(); | |
| // In some browsers (iOS5), 3D transitions block the ability to scroll to the desired location during transition | |
| // This ensures we jump to that spot after the fact, if we aren't there already. | |
| if ( $.mobile.window.scrollTop() !== this.toScroll ) { | |
| this.scrollPage(); | |
| } | |
| if ( !this.sequential ) { | |
| this.$to.addClass( $.mobile.activePageClass ); | |
| } | |
| this.deferred.resolve( this.name, this.reverse, this.$to, this.$from, true ); | |
| }, | |
| doneOut: function( screenHeight, reverseClass, none, preventFocus ) { | |
| this.beforeDoneOut(); | |
| this.startIn( screenHeight, reverseClass, none, preventFocus ); | |
| }, | |
| hideIn: function( callback ) { | |
| // Prevent flickering in phonegap container: see comments at #4024 regarding iOS | |
| this.$to.css( "z-index", -10 ); | |
| callback.call( this ); | |
| this.$to.css( "z-index", "" ); | |
| }, | |
| scrollPage: function() { | |
| // By using scrollTo instead of silentScroll, we can keep things better in order | |
| // Just to be precautios, disable scrollstart listening like silentScroll would | |
| $.event.special.scrollstart.enabled = false; | |
| //if we are hiding the url bar or the page was previously scrolled scroll to hide or return to position | |
| if ( $.mobile.hideUrlBar || this.toScroll !== $.mobile.defaultHomeScroll ) { | |
| window.scrollTo( 0, this.toScroll ); | |
| } | |
| // reenable scrollstart listening like silentScroll would | |
| setTimeout( function() { | |
| $.event.special.scrollstart.enabled = true; | |
| }, 150 ); | |
| }, | |
| startIn: function( screenHeight, reverseClass, none, preventFocus ) { | |
| this.hideIn(function() { | |
| this.$to.addClass( $.mobile.activePageClass + this.toPreClass ); | |
| // Send focus to page as it is now display: block | |
| if ( !preventFocus ) { | |
| $.mobile.focusPage( this.$to ); | |
| } | |
| // Set to page height | |
| this.$to.height( screenHeight + this.toScroll ); | |
| if ( !none ) { | |
| this.scrollPage(); | |
| } | |
| }); | |
| this.$to | |
| .removeClass( this.toPreClass ) | |
| .addClass( this.name + " in " + reverseClass ); | |
| if ( !none ) { | |
| this.$to.animationComplete( $.proxy(function() { | |
| this.doneIn(); | |
| }, this )); | |
| } else { | |
| this.doneIn(); | |
| } | |
| }, | |
| startOut: function( screenHeight, reverseClass, none ) { | |
| this.beforeStartOut( screenHeight, reverseClass, none ); | |
| // Set the from page's height and start it transitioning out | |
| // Note: setting an explicit height helps eliminate tiling in the transitions | |
| this.$from | |
| .height( screenHeight + $.mobile.window.scrollTop() ) | |
| .addClass( this.name + " out" + reverseClass ); | |
| }, | |
| toggleViewportClass: function() { | |
| $.mobile.pageContainer.toggleClass( "ui-mobile-viewport-transitioning viewport-" + this.name ); | |
| }, | |
| transition: function() { | |
| // NOTE many of these could be calculated/recorded in the constructor, it's my | |
| // opinion that binding them as late as possible has value with regards to | |
| // better transitions with fewer bugs. Ie, it's not guaranteed that the | |
| // object will be created and transition will be run immediately after as | |
| // it is today. So we wait until transition is invoked to gather the following | |
| var none, | |
| reverseClass = this.reverse ? " reverse" : "", | |
| screenHeight = $.mobile.getScreenHeight(), | |
| maxTransitionOverride = $.mobile.maxTransitionWidth !== false && | |
| $.mobile.window.width() > $.mobile.maxTransitionWidth; | |
| this.toScroll = $.mobile.navigate.history.getActive().lastScroll || $.mobile.defaultHomeScroll; | |
| none = !$.support.cssTransitions || !$.support.cssAnimations || | |
| maxTransitionOverride || !this.name || this.name === "none" || | |
| Math.max( $.mobile.window.scrollTop(), this.toScroll ) > | |
| $.mobile.getMaxScrollForTransition(); | |
| this.toggleViewportClass(); | |
| if ( this.$from && !none ) { | |
| this.startOut( screenHeight, reverseClass, none ); | |
| } else { | |
| this.doneOut( screenHeight, reverseClass, none, true ); | |
| } | |
| return this.deferred.promise(); | |
| } | |
| }); | |
| })( jQuery, this ); | |
| (function( $ ) { | |
| $.mobile.SerialTransition = function() { | |
| this.init.apply(this, arguments); | |
| }; | |
| $.extend($.mobile.SerialTransition.prototype, $.mobile.Transition.prototype, { | |
| sequential: true, | |
| beforeDoneOut: function() { | |
| if ( this.$from ) { | |
| this.cleanFrom(); | |
| } | |
| }, | |
| beforeStartOut: function( screenHeight, reverseClass, none ) { | |
| this.$from.animationComplete($.proxy(function() { | |
| this.doneOut( screenHeight, reverseClass, none ); | |
| }, this )); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $ ) { | |
| $.mobile.ConcurrentTransition = function() { | |
| this.init.apply(this, arguments); | |
| }; | |
| $.extend($.mobile.ConcurrentTransition.prototype, $.mobile.Transition.prototype, { | |
| sequential: false, | |
| beforeDoneIn: function() { | |
| if ( this.$from ) { | |
| this.cleanFrom(); | |
| } | |
| }, | |
| beforeStartOut: function( screenHeight, reverseClass, none ) { | |
| this.doneOut( screenHeight, reverseClass, none ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $ ) { | |
| // generate the handlers from the above | |
| var defaultGetMaxScrollForTransition = function() { | |
| return $.mobile.getScreenHeight() * 3; | |
| }; | |
| //transition handler dictionary for 3rd party transitions | |
| $.mobile.transitionHandlers = { | |
| "sequential": $.mobile.SerialTransition, | |
| "simultaneous": $.mobile.ConcurrentTransition | |
| }; | |
| // Make our transition handler the public default. | |
| $.mobile.defaultTransitionHandler = $.mobile.transitionHandlers.sequential; | |
| $.mobile.transitionFallbacks = {}; | |
| // If transition is defined, check if css 3D transforms are supported, and if not, if a fallback is specified | |
| $.mobile._maybeDegradeTransition = function( transition ) { | |
| if ( transition && !$.support.cssTransform3d && $.mobile.transitionFallbacks[ transition ] ) { | |
| transition = $.mobile.transitionFallbacks[ transition ]; | |
| } | |
| return transition; | |
| }; | |
| // Set the getMaxScrollForTransition to default if no implementation was set by user | |
| $.mobile.getMaxScrollForTransition = $.mobile.getMaxScrollForTransition || defaultGetMaxScrollForTransition; | |
| })( jQuery ); | |
| /* | |
| * fallback transition for flip in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| $.mobile.transitionFallbacks.flip = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for flow in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| $.mobile.transitionFallbacks.flow = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for pop in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| $.mobile.transitionFallbacks.pop = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for slide in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| // Use the simultaneous transitions handler for slide transitions | |
| $.mobile.transitionHandlers.slide = $.mobile.transitionHandlers.simultaneous; | |
| // Set the slide transitions's fallback to "fade" | |
| $.mobile.transitionFallbacks.slide = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for slidedown in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| $.mobile.transitionFallbacks.slidedown = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for slidefade in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| // Set the slide transitions's fallback to "fade" | |
| $.mobile.transitionFallbacks.slidefade = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for slideup in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| $.mobile.transitionFallbacks.slideup = "fade"; | |
| })( jQuery, this ); | |
| /* | |
| * fallback transition for turn in non-3D supporting browsers (which tend to handle complex transitions poorly in general | |
| */ | |
| (function( $, window, undefined ) { | |
| $.mobile.transitionFallbacks.turn = "fade"; | |
| })( jQuery, this ); | |
| (function( $, undefined ) { | |
| $.mobile.degradeInputs = { | |
| color: false, | |
| date: false, | |
| datetime: false, | |
| "datetime-local": false, | |
| email: false, | |
| month: false, | |
| number: false, | |
| range: "number", | |
| search: "text", | |
| tel: false, | |
| time: false, | |
| url: false, | |
| week: false | |
| }; | |
| // Backcompat remove in 1.5 | |
| $.mobile.page.prototype.options.degradeInputs = $.mobile.degradeInputs; | |
| // Auto self-init widgets | |
| $.mobile.degradeInputsWithin = function( target ) { | |
| target = $( target ); | |
| // Degrade inputs to avoid poorly implemented native functionality | |
| target.find( "input" ).not( $.mobile.page.prototype.keepNativeSelector() ).each(function() { | |
| var element = $( this ), | |
| type = this.getAttribute( "type" ), | |
| optType = $.mobile.degradeInputs[ type ] || "text", | |
| html, hasType, findstr, repstr; | |
| if ( $.mobile.degradeInputs[ type ] ) { | |
| html = $( "<div>" ).html( element.clone() ).html(); | |
| // In IE browsers, the type sometimes doesn't exist in the cloned markup, so we replace the closing tag instead | |
| hasType = html.indexOf( " type=" ) > -1; | |
| findstr = hasType ? /\s+type=["']?\w+['"]?/ : /\/?>/; | |
| repstr = " type=\"" + optType + "\" data-" + $.mobile.ns + "type=\"" + type + "\"" + ( hasType ? "" : ">" ); | |
| element.replaceWith( html.replace( findstr, repstr ) ); | |
| } | |
| }); | |
| }; | |
| })( jQuery ); | |
| (function( $, window, undefined ) { | |
| $.widget( "mobile.page", $.mobile.page, { | |
| options: { | |
| // Accepts left, right and none | |
| closeBtn: "left", | |
| closeBtnText: "Close", | |
| overlayTheme: "a", | |
| corners: true, | |
| dialog: false | |
| }, | |
| _create: function() { | |
| this._super(); | |
| if ( this.options.dialog ) { | |
| $.extend( this, { | |
| _inner: this.element.children(), | |
| _headerCloseButton: null | |
| }); | |
| if ( !this.options.enhanced ) { | |
| this._setCloseBtn( this.options.closeBtn ); | |
| } | |
| } | |
| }, | |
| _enhance: function() { | |
| this._super(); | |
| // Class the markup for dialog styling and wrap interior | |
| if ( this.options.dialog ) { | |
| this.element.addClass( "ui-dialog" ) | |
| .wrapInner( $( "<div/>", { | |
| // ARIA role | |
| "role" : "dialog", | |
| "class" : "ui-dialog-contain ui-overlay-shadow" + | |
| ( this.options.corners ? " ui-corner-all" : "" ) | |
| })); | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| var closeButtonLocation, closeButtonText, | |
| currentOpts = this.options; | |
| if ( options.corners !== undefined ) { | |
| this._inner.toggleClass( "ui-corner-all", !!options.corners ); | |
| } | |
| if ( options.overlayTheme !== undefined ) { | |
| if ( $.mobile.activePage[ 0 ] === this.element[ 0 ] ) { | |
| currentOpts.overlayTheme = options.overlayTheme; | |
| this._handlePageBeforeShow(); | |
| } | |
| } | |
| if ( options.closeBtnText !== undefined ) { | |
| closeButtonLocation = currentOpts.closeBtn; | |
| closeButtonText = options.closeBtnText; | |
| } | |
| if ( options.closeBtn !== undefined ) { | |
| closeButtonLocation = options.closeBtn; | |
| } | |
| if ( closeButtonLocation ) { | |
| this._setCloseBtn( closeButtonLocation, closeButtonText ); | |
| } | |
| this._super( options ); | |
| }, | |
| _handlePageBeforeShow: function () { | |
| if ( this.options.overlayTheme && this.options.dialog ) { | |
| this.removeContainerBackground(); | |
| this.setContainerBackground( this.options.overlayTheme ); | |
| } else { | |
| this._super(); | |
| } | |
| }, | |
| _setCloseBtn: function( location, text ) { | |
| var dst, | |
| btn = this._headerCloseButton; | |
| // Sanitize value | |
| location = "left" === location ? "left" : "right" === location ? "right" : "none"; | |
| if ( "none" === location ) { | |
| if ( btn ) { | |
| btn.remove(); | |
| btn = null; | |
| } | |
| } else if ( btn ) { | |
| btn.removeClass( "ui-btn-left ui-btn-right" ).addClass( "ui-btn-" + location ); | |
| if ( text ) { | |
| btn.text( text ); | |
| } | |
| } else { | |
| dst = this._inner.find( ":jqmData(role='header')" ).first(); | |
| btn = $( "<a></a>", { | |
| "href": "#", | |
| "class": "ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" + location | |
| }) | |
| .attr( "data-" + $.mobile.ns + "rel", "back" ) | |
| .text( text || this.options.closeBtnText || "" ) | |
| .prependTo( dst ); | |
| } | |
| this._headerCloseButton = btn; | |
| } | |
| }); | |
| })( jQuery, this ); | |
| (function( $, window, undefined ) { | |
| $.widget( "mobile.dialog", { | |
| options: { | |
| // Accepts left, right and none | |
| closeBtn: "left", | |
| closeBtnText: "Close", | |
| overlayTheme: "a", | |
| corners: true | |
| }, | |
| // Override the theme set by the page plugin on pageshow | |
| _handlePageBeforeShow: function() { | |
| this._isCloseable = true; | |
| if ( this.options.overlayTheme ) { | |
| this.element | |
| .page( "removeContainerBackground" ) | |
| .page( "setContainerBackground", this.options.overlayTheme ); | |
| } | |
| }, | |
| _handlePageBeforeHide: function() { | |
| this._isCloseable = false; | |
| }, | |
| // click and submit events: | |
| // - clicks and submits should use the closing transition that the dialog | |
| // opened with unless a data-transition is specified on the link/form | |
| // - if the click was on the close button, or the link has a data-rel="back" | |
| // it'll go back in history naturally | |
| _handleVClickSubmit: function( event ) { | |
| var attrs, | |
| $target = $( event.target ).closest( event.type === "vclick" ? "a" : "form" ); | |
| if ( $target.length && !$target.jqmData( "transition" ) ) { | |
| attrs = {}; | |
| attrs[ "data-" + $.mobile.ns + "transition" ] = | |
| ( $.mobile.navigate.history.getActive() || {} )[ "transition" ] || | |
| $.mobile.defaultDialogTransition; | |
| attrs[ "data-" + $.mobile.ns + "direction" ] = "reverse"; | |
| $target.attr( attrs ); | |
| } | |
| }, | |
| _create: function() { | |
| var elem = this.element, | |
| opts = this.options; | |
| // Class the markup for dialog styling and wrap interior | |
| elem.addClass( "ui-dialog" ) | |
| .wrapInner( $( "<div/>", { | |
| // ARIA role | |
| "role" : "dialog", | |
| "class" : "ui-dialog-contain ui-overlay-shadow" + | |
| ( !!opts.corners ? " ui-corner-all" : "" ) | |
| })); | |
| $.extend( this, { | |
| _isCloseable: false, | |
| _inner: elem.children(), | |
| _headerCloseButton: null | |
| }); | |
| this._on( elem, { | |
| vclick: "_handleVClickSubmit", | |
| submit: "_handleVClickSubmit", | |
| pagebeforeshow: "_handlePageBeforeShow", | |
| pagebeforehide: "_handlePageBeforeHide" | |
| }); | |
| this._setCloseBtn( opts.closeBtn ); | |
| }, | |
| _setOptions: function( options ) { | |
| var closeButtonLocation, closeButtonText, | |
| currentOpts = this.options; | |
| if ( options.corners !== undefined ) { | |
| this._inner.toggleClass( "ui-corner-all", !!options.corners ); | |
| } | |
| if ( options.overlayTheme !== undefined ) { | |
| if ( $.mobile.activePage[ 0 ] === this.element[ 0 ] ) { | |
| currentOpts.overlayTheme = options.overlayTheme; | |
| this._handlePageBeforeShow(); | |
| } | |
| } | |
| if ( options.closeBtnText !== undefined ) { | |
| closeButtonLocation = currentOpts.closeBtn; | |
| closeButtonText = options.closeBtnText; | |
| } | |
| if ( options.closeBtn !== undefined ) { | |
| closeButtonLocation = options.closeBtn; | |
| } | |
| if ( closeButtonLocation ) { | |
| this._setCloseBtn( closeButtonLocation, closeButtonText ); | |
| } | |
| this._super( options ); | |
| }, | |
| _setCloseBtn: function( location, text ) { | |
| var dst, | |
| btn = this._headerCloseButton; | |
| // Sanitize value | |
| location = "left" === location ? "left" : "right" === location ? "right" : "none"; | |
| if ( "none" === location ) { | |
| if ( btn ) { | |
| btn.remove(); | |
| btn = null; | |
| } | |
| } else if ( btn ) { | |
| btn.removeClass( "ui-btn-left ui-btn-right" ).addClass( "ui-btn-" + location ); | |
| if ( text ) { | |
| btn.text( text ); | |
| } | |
| } else { | |
| dst = this._inner.find( ":jqmData(role='header')" ).first(); | |
| btn = $( "<a></a>", { | |
| "role": "button", | |
| "href": "#", | |
| "class": "ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" + location | |
| }) | |
| .text( text || this.options.closeBtnText || "" ) | |
| .prependTo( dst ); | |
| this._on( btn, { click: "close" } ); | |
| } | |
| this._headerCloseButton = btn; | |
| }, | |
| // Close method goes back in history | |
| close: function() { | |
| var hist = $.mobile.navigate.history; | |
| if ( this._isCloseable ) { | |
| this._isCloseable = false; | |
| // If the hash listening is enabled and there is at least one preceding history | |
| // entry it's ok to go back. Initial pages with the dialog hash state are an example | |
| // where the stack check is necessary | |
| if ( $.mobile.hashListeningEnabled && hist.activeIndex > 0 ) { | |
| $.mobile.back(); | |
| } else { | |
| $.mobile.pageContainer.pagecontainer( "back" ); | |
| } | |
| } | |
| } | |
| }); | |
| })( jQuery, this ); | |
| (function( $, undefined ) { | |
| var rInitialLetter = /([A-Z])/g, | |
| // Construct iconpos class from iconpos value | |
| iconposClass = function( iconpos ) { | |
| return ( "ui-btn-icon-" + ( iconpos === null ? "left" : iconpos ) ); | |
| }; | |
| $.widget( "mobile.collapsible", { | |
| options: { | |
| enhanced: false, | |
| expandCueText: null, | |
| collapseCueText: null, | |
| collapsed: true, | |
| heading: "h1,h2,h3,h4,h5,h6,legend", | |
| collapsedIcon: null, | |
| expandedIcon: null, | |
| iconpos: null, | |
| theme: null, | |
| contentTheme: null, | |
| inset: null, | |
| corners: null, | |
| mini: null | |
| }, | |
| _create: function() { | |
| var elem = this.element, | |
| ui = { | |
| accordion: elem | |
| .closest( ":jqmData(role='collapsible-set')," + | |
| ":jqmData(role='collapsibleset')" + | |
| ( $.mobile.collapsibleset ? ", :mobile-collapsibleset" : | |
| "" ) ) | |
| .addClass( "ui-collapsible-set" ) | |
| }; | |
| this._ui = ui; | |
| this._renderedOptions = this._getOptions( this.options ); | |
| if ( this.options.enhanced ) { | |
| ui.heading = $( ".ui-collapsible-heading", this.element[ 0 ] ); | |
| ui.content = ui.heading.next(); | |
| ui.anchor = $( "a", ui.heading[ 0 ] ).first(); | |
| ui.status = ui.anchor.children( ".ui-collapsible-heading-status" ); | |
| } else { | |
| this._enhance( elem, ui ); | |
| } | |
| this._on( ui.heading, { | |
| "tap": function() { | |
| ui.heading.find( "a" ).first().addClass( $.mobile.activeBtnClass ); | |
| }, | |
| "click": function( event ) { | |
| this._handleExpandCollapse( !ui.heading.hasClass( "ui-collapsible-heading-collapsed" ) ); | |
| event.preventDefault(); | |
| event.stopPropagation(); | |
| } | |
| }); | |
| }, | |
| // Adjust the keys inside options for inherited values | |
| _getOptions: function( options ) { | |
| var key, | |
| accordion = this._ui.accordion, | |
| accordionWidget = this._ui.accordionWidget; | |
| // Copy options | |
| options = $.extend( {}, options ); | |
| if ( accordion.length && !accordionWidget ) { | |
| this._ui.accordionWidget = | |
| accordionWidget = accordion.data( "mobile-collapsibleset" ); | |
| } | |
| for ( key in options ) { | |
| // Retrieve the option value first from the options object passed in and, if | |
| // null, from the parent accordion or, if that's null too, or if there's no | |
| // parent accordion, then from the defaults. | |
| options[ key ] = | |
| ( options[ key ] != null ) ? options[ key ] : | |
| ( accordionWidget ) ? accordionWidget.options[ key ] : | |
| accordion.length ? $.mobile.getAttribute( accordion[ 0 ], | |
| key.replace( rInitialLetter, "-$1" ).toLowerCase() ): | |
| null; | |
| if ( null == options[ key ] ) { | |
| options[ key ] = $.mobile.collapsible.defaults[ key ]; | |
| } | |
| } | |
| return options; | |
| }, | |
| _themeClassFromOption: function( prefix, value ) { | |
| return ( value ? ( value === "none" ? "" : prefix + value ) : "" ); | |
| }, | |
| _enhance: function( elem, ui ) { | |
| var iconclass, | |
| opts = this._renderedOptions, | |
| contentThemeClass = this._themeClassFromOption( "ui-body-", opts.contentTheme ); | |
| elem.addClass( "ui-collapsible " + | |
| ( opts.inset ? "ui-collapsible-inset " : "" ) + | |
| ( opts.inset && opts.corners ? "ui-corner-all " : "" ) + | |
| ( contentThemeClass ? "ui-collapsible-themed-content " : "" ) ); | |
| ui.originalHeading = elem.children( this.options.heading ).first(), | |
| ui.content = elem | |
| .wrapInner( "<div " + | |
| "class='ui-collapsible-content " + | |
| contentThemeClass + "'></div>" ) | |
| .children( ".ui-collapsible-content" ), | |
| ui.heading = ui.originalHeading; | |
| // Replace collapsibleHeading if it's a legend | |
| if ( ui.heading.is( "legend" ) ) { | |
| ui.heading = $( "<div role='heading'>"+ ui.heading.html() +"</div>" ); | |
| ui.placeholder = $( "<div><!-- placeholder for legend --></div>" ).insertBefore( ui.originalHeading ); | |
| ui.originalHeading.remove(); | |
| } | |
| iconclass = ( opts.collapsed ? ( opts.collapsedIcon ? "ui-icon-" + opts.collapsedIcon : "" ): | |
| ( opts.expandedIcon ? "ui-icon-" + opts.expandedIcon : "" ) ); | |
| ui.status = $( "<span class='ui-collapsible-heading-status'></span>" ); | |
| ui.anchor = ui.heading | |
| .detach() | |
| //modify markup & attributes | |
| .addClass( "ui-collapsible-heading" ) | |
| .append( ui.status ) | |
| .wrapInner( "<a href='#' class='ui-collapsible-heading-toggle'></a>" ) | |
| .find( "a" ) | |
| .first() | |
| .addClass( "ui-btn " + | |
| ( iconclass ? iconclass + " " : "" ) + | |
| ( iconclass ? iconposClass( opts.iconpos ) + | |
| " " : "" ) + | |
| this._themeClassFromOption( "ui-btn-", opts.theme ) + " " + | |
| ( opts.mini ? "ui-mini " : "" ) ); | |
| //drop heading in before content | |
| ui.heading.insertBefore( ui.content ); | |
| this._handleExpandCollapse( this.options.collapsed ); | |
| return ui; | |
| }, | |
| refresh: function() { | |
| this._applyOptions( this.options ); | |
| this._renderedOptions = this._getOptions( this.options ); | |
| }, | |
| _applyOptions: function( options ) { | |
| var isCollapsed, newTheme, oldTheme, hasCorners, hasIcon, | |
| elem = this.element, | |
| currentOpts = this._renderedOptions, | |
| ui = this._ui, | |
| anchor = ui.anchor, | |
| status = ui.status, | |
| opts = this._getOptions( options ); | |
| // First and foremost we need to make sure the collapsible is in the proper | |
| // state, in case somebody decided to change the collapsed option at the | |
| // same time as another option | |
| if ( options.collapsed !== undefined ) { | |
| this._handleExpandCollapse( options.collapsed ); | |
| } | |
| isCollapsed = elem.hasClass( "ui-collapsible-collapsed" ); | |
| // We only need to apply the cue text for the current state right away. | |
| // The cue text for the alternate state will be stored in the options | |
| // and applied the next time the collapsible's state is toggled | |
| if ( isCollapsed ) { | |
| if ( opts.expandCueText !== undefined ) { | |
| status.text( opts.expandCueText ); | |
| } | |
| } else { | |
| if ( opts.collapseCueText !== undefined ) { | |
| status.text( opts.collapseCueText ); | |
| } | |
| } | |
| // Update icon | |
| // Is it supposed to have an icon? | |
| hasIcon = | |
| // If the collapsedIcon is being set, consult that | |
| ( opts.collapsedIcon !== undefined ? opts.collapsedIcon !== false : | |
| // Otherwise consult the existing option value | |
| currentOpts.collapsedIcon !== false ); | |
| // If any icon-related options have changed, make sure the new icon | |
| // state is reflected by first removing all icon-related classes | |
| // reflecting the current state and then adding all icon-related | |
| // classes for the new state | |
| if ( !( opts.iconpos === undefined && | |
| opts.collapsedIcon === undefined && | |
| opts.expandedIcon === undefined ) ) { | |
| // Remove all current icon-related classes | |
| anchor.removeClass( [ iconposClass( currentOpts.iconpos ) ] | |
| .concat( ( currentOpts.expandedIcon ? | |
| [ "ui-icon-" + currentOpts.expandedIcon ] : [] ) ) | |
| .concat( ( currentOpts.collapsedIcon ? | |
| [ "ui-icon-" + currentOpts.collapsedIcon ] : [] ) ) | |
| .join( " " ) ); | |
| // Add new classes if an icon is supposed to be present | |
| if ( hasIcon ) { | |
| anchor.addClass( | |
| [ iconposClass( opts.iconpos !== undefined ? | |
| opts.iconpos : currentOpts.iconpos ) ] | |
| .concat( isCollapsed ? | |
| [ "ui-icon-" + ( opts.collapsedIcon !== undefined ? | |
| opts.collapsedIcon : | |
| currentOpts.collapsedIcon ) ] : | |
| [ "ui-icon-" + ( opts.expandedIcon !== undefined ? | |
| opts.expandedIcon : | |
| currentOpts.expandedIcon ) ] ) | |
| .join( " " ) ); | |
| } | |
| } | |
| if ( opts.theme !== undefined ) { | |
| oldTheme = this._themeClassFromOption( "ui-btn-", currentOpts.theme ); | |
| newTheme = this._themeClassFromOption( "ui-btn-", opts.theme ); | |
| anchor.removeClass( oldTheme ).addClass( newTheme ); | |
| } | |
| if ( opts.contentTheme !== undefined ) { | |
| oldTheme = this._themeClassFromOption( "ui-body-", | |
| currentOpts.contentTheme ); | |
| newTheme = this._themeClassFromOption( "ui-body-", | |
| opts.contentTheme ); | |
| ui.content.removeClass( oldTheme ).addClass( newTheme ); | |
| } | |
| if ( opts.inset !== undefined ) { | |
| elem.toggleClass( "ui-collapsible-inset", opts.inset ); | |
| hasCorners = !!( opts.inset && ( opts.corners || currentOpts.corners ) ); | |
| } | |
| if ( opts.corners !== undefined ) { | |
| hasCorners = !!( opts.corners && ( opts.inset || currentOpts.inset ) ); | |
| } | |
| if ( hasCorners !== undefined ) { | |
| elem.toggleClass( "ui-corner-all", hasCorners ); | |
| } | |
| if ( opts.mini !== undefined ) { | |
| anchor.toggleClass( "ui-mini", opts.mini ); | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| this._applyOptions( options ); | |
| this._super( options ); | |
| this._renderedOptions = this._getOptions( this.options ); | |
| }, | |
| _handleExpandCollapse: function( isCollapse ) { | |
| var opts = this._renderedOptions, | |
| ui = this._ui; | |
| ui.status.text( isCollapse ? opts.expandCueText : opts.collapseCueText ); | |
| ui.heading | |
| .toggleClass( "ui-collapsible-heading-collapsed", isCollapse ) | |
| .find( "a" ).first() | |
| .toggleClass( "ui-icon-" + opts.expandedIcon, !isCollapse ) | |
| // logic or cause same icon for expanded/collapsed state would remove the ui-icon-class | |
| .toggleClass( "ui-icon-" + opts.collapsedIcon, ( isCollapse || opts.expandedIcon === opts.collapsedIcon ) ) | |
| .removeClass( $.mobile.activeBtnClass ); | |
| this.element.toggleClass( "ui-collapsible-collapsed", isCollapse ); | |
| ui.content | |
| .toggleClass( "ui-collapsible-content-collapsed", isCollapse ) | |
| .attr( "aria-hidden", isCollapse ) | |
| .trigger( "updatelayout" ); | |
| this.options.collapsed = isCollapse; | |
| this._trigger( isCollapse ? "collapse" : "expand" ); | |
| }, | |
| expand: function() { | |
| this._handleExpandCollapse( false ); | |
| }, | |
| collapse: function() { | |
| this._handleExpandCollapse( true ); | |
| }, | |
| _destroy: function() { | |
| var ui = this._ui, | |
| opts = this.options; | |
| if ( opts.enhanced ) { | |
| return; | |
| } | |
| if ( ui.placeholder ) { | |
| ui.originalHeading.insertBefore( ui.placeholder ); | |
| ui.placeholder.remove(); | |
| ui.heading.remove(); | |
| } else { | |
| ui.status.remove(); | |
| ui.heading | |
| .removeClass( "ui-collapsible-heading ui-collapsible-heading-collapsed" ) | |
| .children() | |
| .contents() | |
| .unwrap(); | |
| } | |
| ui.anchor.contents().unwrap(); | |
| ui.content.contents().unwrap(); | |
| this.element | |
| .removeClass( "ui-collapsible ui-collapsible-collapsed " + | |
| "ui-collapsible-themed-content ui-collapsible-inset ui-corner-all" ); | |
| } | |
| }); | |
| // Defaults to be used by all instances of collapsible if per-instance values | |
| // are unset or if nothing is specified by way of inheritance from an accordion. | |
| // Note that this hash does not contain options "collapsed" or "heading", | |
| // because those are not inheritable. | |
| $.mobile.collapsible.defaults = { | |
| expandCueText: " click to expand contents", | |
| collapseCueText: " click to collapse contents", | |
| collapsedIcon: "plus", | |
| contentTheme: "inherit", | |
| expandedIcon: "minus", | |
| iconpos: "left", | |
| inset: true, | |
| corners: true, | |
| theme: "inherit", | |
| mini: false | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var uiScreenHiddenRegex = /\bui-screen-hidden\b/; | |
| function noHiddenClass( elements ) { | |
| var index, | |
| length = elements.length, | |
| result = []; | |
| for ( index = 0; index < length; index++ ) { | |
| if ( !elements[ index ].className.match( uiScreenHiddenRegex ) ) { | |
| result.push( elements[ index ] ); | |
| } | |
| } | |
| return $( result ); | |
| } | |
| $.mobile.behaviors.addFirstLastClasses = { | |
| _getVisibles: function( $els, create ) { | |
| var visibles; | |
| if ( create ) { | |
| visibles = noHiddenClass( $els ); | |
| } else { | |
| visibles = $els.filter( ":visible" ); | |
| if ( visibles.length === 0 ) { | |
| visibles = noHiddenClass( $els ); | |
| } | |
| } | |
| return visibles; | |
| }, | |
| _addFirstLastClasses: function( $els, $visibles, create ) { | |
| $els.removeClass( "ui-first-child ui-last-child" ); | |
| $visibles.eq( 0 ).addClass( "ui-first-child" ).end().last().addClass( "ui-last-child" ); | |
| if ( !create ) { | |
| this.element.trigger( "updatelayout" ); | |
| } | |
| }, | |
| _removeFirstLastClasses: function( $els ) { | |
| $els.removeClass( "ui-first-child ui-last-child" ); | |
| } | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var childCollapsiblesSelector = ":mobile-collapsible, " + $.mobile.collapsible.initSelector; | |
| $.widget( "mobile.collapsibleset", $.extend( { | |
| // The initSelector is deprecated as of 1.4.0. In 1.5.0 we will use | |
| // :jqmData(role='collapsibleset') which will allow us to get rid of the line | |
| // below altogether, because the autoinit will generate such an initSelector | |
| initSelector: ":jqmData(role='collapsible-set'),:jqmData(role='collapsibleset')", | |
| options: $.extend( { | |
| enhanced: false | |
| }, $.mobile.collapsible.defaults ), | |
| _handleCollapsibleExpand: function( event ) { | |
| var closestCollapsible = $( event.target ).closest( ".ui-collapsible" ); | |
| if ( closestCollapsible.parent().is( ":mobile-collapsibleset, :jqmData(role='collapsible-set')" ) ) { | |
| closestCollapsible | |
| .siblings( ".ui-collapsible:not(.ui-collapsible-collapsed)" ) | |
| .collapsible( "collapse" ); | |
| } | |
| }, | |
| _create: function() { | |
| var elem = this.element, | |
| opts = this.options; | |
| $.extend( this, { | |
| _classes: "" | |
| }); | |
| if ( !opts.enhanced ) { | |
| elem.addClass( "ui-collapsible-set " + | |
| this._themeClassFromOption( "ui-group-theme-", opts.theme ) + " " + | |
| ( opts.corners && opts.inset ? "ui-corner-all " : "" ) ); | |
| this.element.find( $.mobile.collapsible.initSelector ).collapsible(); | |
| } | |
| this._on( elem, { collapsibleexpand: "_handleCollapsibleExpand" } ); | |
| }, | |
| _themeClassFromOption: function( prefix, value ) { | |
| return ( value ? ( value === "none" ? "" : prefix + value ) : "" ); | |
| }, | |
| _init: function() { | |
| this._refresh( true ); | |
| // Because the corners are handled by the collapsible itself and the default state is collapsed | |
| // That was causing https://github.com/jquery/jquery-mobile/issues/4116 | |
| this.element | |
| .children( childCollapsiblesSelector ) | |
| .filter( ":jqmData(collapsed='false')" ) | |
| .collapsible( "expand" ); | |
| }, | |
| _setOptions: function( options ) { | |
| var ret, hasCorners, | |
| elem = this.element, | |
| themeClass = this._themeClassFromOption( "ui-group-theme-", options.theme ); | |
| if ( themeClass ) { | |
| elem | |
| .removeClass( this._themeClassFromOption( "ui-group-theme-", this.options.theme ) ) | |
| .addClass( themeClass ); | |
| } | |
| if ( options.inset !== undefined ) { | |
| hasCorners = !!( options.inset && ( options.corners || this.options.corners ) ); | |
| } | |
| if ( options.corners !== undefined ) { | |
| hasCorners = !!( options.corners && ( options.inset || this.options.inset ) ); | |
| } | |
| if ( hasCorners !== undefined ) { | |
| elem.toggleClass( "ui-corner-all", hasCorners ); | |
| } | |
| ret = this._super( options ); | |
| this.element.children( ":mobile-collapsible" ).collapsible( "refresh" ); | |
| return ret; | |
| }, | |
| _destroy: function() { | |
| var el = this.element; | |
| this._removeFirstLastClasses( el.children( childCollapsiblesSelector ) ); | |
| el | |
| .removeClass( "ui-collapsible-set ui-corner-all " + | |
| this._themeClassFromOption( "ui-group-theme-", this.options.theme ) ) | |
| .children( ":mobile-collapsible" ) | |
| .collapsible( "destroy" ); | |
| }, | |
| _refresh: function( create ) { | |
| var collapsiblesInSet = this.element.children( childCollapsiblesSelector ); | |
| this.element.find( $.mobile.collapsible.initSelector ).not( ".ui-collapsible" ).collapsible(); | |
| this._addFirstLastClasses( collapsiblesInSet, this._getVisibles( collapsiblesInSet, create ), create ); | |
| }, | |
| refresh: function() { | |
| this._refresh( false ); | |
| } | |
| }, $.mobile.behaviors.addFirstLastClasses ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| // Deprecated in 1.4 | |
| $.fn.fieldcontain = function(/* options */) { | |
| return this.addClass( "ui-field-contain" ); | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.fn.grid = function( options ) { | |
| return this.each(function() { | |
| var $this = $( this ), | |
| o = $.extend({ | |
| grid: null | |
| }, options ), | |
| $kids = $this.children(), | |
| gridCols = { solo:1, a:2, b:3, c:4, d:5 }, | |
| grid = o.grid, | |
| iterator, | |
| letter; | |
| if ( !grid ) { | |
| if ( $kids.length <= 5 ) { | |
| for ( letter in gridCols ) { | |
| if ( gridCols[ letter ] === $kids.length ) { | |
| grid = letter; | |
| } | |
| } | |
| } else { | |
| grid = "a"; | |
| $this.addClass( "ui-grid-duo" ); | |
| } | |
| } | |
| iterator = gridCols[grid]; | |
| $this.addClass( "ui-grid-" + grid ); | |
| $kids.filter( ":nth-child(" + iterator + "n+1)" ).addClass( "ui-block-a" ); | |
| if ( iterator > 1 ) { | |
| $kids.filter( ":nth-child(" + iterator + "n+2)" ).addClass( "ui-block-b" ); | |
| } | |
| if ( iterator > 2 ) { | |
| $kids.filter( ":nth-child(" + iterator + "n+3)" ).addClass( "ui-block-c" ); | |
| } | |
| if ( iterator > 3 ) { | |
| $kids.filter( ":nth-child(" + iterator + "n+4)" ).addClass( "ui-block-d" ); | |
| } | |
| if ( iterator > 4 ) { | |
| $kids.filter( ":nth-child(" + iterator + "n+5)" ).addClass( "ui-block-e" ); | |
| } | |
| }); | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.navbar", { | |
| options: { | |
| iconpos: "top", | |
| grid: null | |
| }, | |
| _create: function() { | |
| var $navbar = this.element, | |
| $navbtns = $navbar.find( "a" ), | |
| iconpos = $navbtns.filter( ":jqmData(icon)" ).length ? this.options.iconpos : undefined; | |
| $navbar.addClass( "ui-navbar" ) | |
| .attr( "role", "navigation" ) | |
| .find( "ul" ) | |
| .jqmEnhanceable() | |
| .grid({ grid: this.options.grid }); | |
| $navbtns | |
| .each( function() { | |
| var icon = $.mobile.getAttribute( this, "icon" ), | |
| theme = $.mobile.getAttribute( this, "theme" ), | |
| classes = "ui-btn"; | |
| if ( theme ) { | |
| classes += " ui-btn-" + theme; | |
| } | |
| if ( icon ) { | |
| classes += " ui-icon-" + icon + " ui-btn-icon-" + iconpos; | |
| } | |
| $( this ).addClass( classes ); | |
| }); | |
| $navbar.delegate( "a", "vclick", function( /* event */ ) { | |
| var activeBtn = $( this ); | |
| if ( !( activeBtn.hasClass( "ui-state-disabled" ) || | |
| // DEPRECATED as of 1.4.0 - remove after 1.4.0 release | |
| // only ui-state-disabled should be present thereafter | |
| activeBtn.hasClass( "ui-disabled" ) || | |
| activeBtn.hasClass( $.mobile.activeBtnClass ) ) ) { | |
| $navbtns.removeClass( $.mobile.activeBtnClass ); | |
| activeBtn.addClass( $.mobile.activeBtnClass ); | |
| // The code below is a workaround to fix #1181 | |
| $( document ).one( "pagehide", function() { | |
| activeBtn.removeClass( $.mobile.activeBtnClass ); | |
| }); | |
| } | |
| }); | |
| // Buttons in the navbar with ui-state-persist class should regain their active state before page show | |
| $navbar.closest( ".ui-page" ).bind( "pagebeforeshow", function() { | |
| $navbtns.filter( ".ui-state-persist" ).addClass( $.mobile.activeBtnClass ); | |
| }); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var getAttr = $.mobile.getAttribute; | |
| $.widget( "mobile.listview", $.extend( { | |
| options: { | |
| theme: null, | |
| countTheme: null, /* Deprecated in 1.4 */ | |
| dividerTheme: null, | |
| icon: "carat-r", | |
| splitIcon: "carat-r", | |
| splitTheme: null, | |
| corners: true, | |
| shadow: true, | |
| inset: false | |
| }, | |
| _create: function() { | |
| var t = this, | |
| listviewClasses = ""; | |
| listviewClasses += t.options.inset ? " ui-listview-inset" : ""; | |
| if ( !!t.options.inset ) { | |
| listviewClasses += t.options.corners ? " ui-corner-all" : ""; | |
| listviewClasses += t.options.shadow ? " ui-shadow" : ""; | |
| } | |
| // create listview markup | |
| t.element.addClass( " ui-listview" + listviewClasses ); | |
| t.refresh( true ); | |
| }, | |
| // TODO: Remove in 1.5 | |
| _findFirstElementByTagName: function( ele, nextProp, lcName, ucName ) { | |
| var dict = {}; | |
| dict[ lcName ] = dict[ ucName ] = true; | |
| while ( ele ) { | |
| if ( dict[ ele.nodeName ] ) { | |
| return ele; | |
| } | |
| ele = ele[ nextProp ]; | |
| } | |
| return null; | |
| }, | |
| // TODO: Remove in 1.5 | |
| _addThumbClasses: function( containers ) { | |
| var i, img, len = containers.length; | |
| for ( i = 0; i < len; i++ ) { | |
| img = $( this._findFirstElementByTagName( containers[ i ].firstChild, "nextSibling", "img", "IMG" ) ); | |
| if ( img.length ) { | |
| $( this._findFirstElementByTagName( img[ 0 ].parentNode, "parentNode", "li", "LI" ) ).addClass( img.hasClass( "ui-li-icon" ) ? "ui-li-has-icon" : "ui-li-has-thumb" ); | |
| } | |
| } | |
| }, | |
| _getChildrenByTagName: function( ele, lcName, ucName ) { | |
| var results = [], | |
| dict = {}; | |
| dict[ lcName ] = dict[ ucName ] = true; | |
| ele = ele.firstChild; | |
| while ( ele ) { | |
| if ( dict[ ele.nodeName ] ) { | |
| results.push( ele ); | |
| } | |
| ele = ele.nextSibling; | |
| } | |
| return $( results ); | |
| }, | |
| _beforeListviewRefresh: $.noop, | |
| _afterListviewRefresh: $.noop, | |
| refresh: function( create ) { | |
| var buttonClass, pos, numli, item, itemClass, itemTheme, itemIcon, icon, a, | |
| isDivider, startCount, newStartCount, value, last, splittheme, splitThemeClass, spliticon, | |
| altButtonClass, dividerTheme, li, | |
| o = this.options, | |
| $list = this.element, | |
| ol = !!$.nodeName( $list[ 0 ], "ol" ), | |
| start = $list.attr( "start" ), | |
| itemClassDict = {}, | |
| countBubbles = $list.find( ".ui-li-count" ), | |
| countTheme = getAttr( $list[ 0 ], "counttheme" ) || this.options.countTheme, | |
| countThemeClass = countTheme ? "ui-body-" + countTheme : "ui-body-inherit"; | |
| if ( o.theme ) { | |
| $list.addClass( "ui-group-theme-" + o.theme ); | |
| } | |
| // Check if a start attribute has been set while taking a value of 0 into account | |
| if ( ol && ( start || start === 0 ) ) { | |
| startCount = parseInt( start, 10 ) - 1; | |
| $list.css( "counter-reset", "listnumbering " + startCount ); | |
| } | |
| this._beforeListviewRefresh(); | |
| li = this._getChildrenByTagName( $list[ 0 ], "li", "LI" ); | |
| for ( pos = 0, numli = li.length; pos < numli; pos++ ) { | |
| item = li.eq( pos ); | |
| itemClass = ""; | |
| if ( create || item[ 0 ].className.search( /\bui-li-static\b|\bui-li-divider\b/ ) < 0 ) { | |
| a = this._getChildrenByTagName( item[ 0 ], "a", "A" ); | |
| isDivider = ( getAttr( item[ 0 ], "role" ) === "list-divider" ); | |
| value = item.attr( "value" ); | |
| itemTheme = getAttr( item[ 0 ], "theme" ); | |
| if ( a.length && a[ 0 ].className.search( /\bui-btn\b/ ) < 0 && !isDivider ) { | |
| itemIcon = getAttr( item[ 0 ], "icon" ); | |
| icon = ( itemIcon === false ) ? false : ( itemIcon || o.icon ); | |
| // TODO: Remove in 1.5 together with links.js (links.js / .ui-link deprecated in 1.4) | |
| a.removeClass( "ui-link" ); | |
| buttonClass = "ui-btn"; | |
| if ( itemTheme ) { | |
| buttonClass += " ui-btn-" + itemTheme; | |
| } | |
| if ( a.length > 1 ) { | |
| itemClass = "ui-li-has-alt"; | |
| last = a.last(); | |
| splittheme = getAttr( last[ 0 ], "theme" ) || o.splitTheme || getAttr( item[ 0 ], "theme", true ); | |
| splitThemeClass = splittheme ? " ui-btn-" + splittheme : ""; | |
| spliticon = getAttr( last[ 0 ], "icon" ) || getAttr( item[ 0 ], "icon" ) || o.splitIcon; | |
| altButtonClass = "ui-btn ui-btn-icon-notext ui-icon-" + spliticon + splitThemeClass; | |
| last | |
| .attr( "title", $.trim( last.getEncodedText() ) ) | |
| .addClass( altButtonClass ) | |
| .empty(); | |
| // Reduce to the first anchor, because only the first gets the buttonClass | |
| a = a.first(); | |
| } else if ( icon ) { | |
| buttonClass += " ui-btn-icon-right ui-icon-" + icon; | |
| } | |
| // Apply buttonClass to the (first) anchor | |
| a.addClass( buttonClass ); | |
| } else if ( isDivider ) { | |
| dividerTheme = ( getAttr( item[ 0 ], "theme" ) || o.dividerTheme || o.theme ); | |
| itemClass = "ui-li-divider ui-bar-" + ( dividerTheme ? dividerTheme : "inherit" ); | |
| item.attr( "role", "heading" ); | |
| } else if ( a.length <= 0 ) { | |
| itemClass = "ui-li-static ui-body-" + ( itemTheme ? itemTheme : "inherit" ); | |
| } | |
| if ( ol && value ) { | |
| newStartCount = parseInt( value , 10 ) - 1; | |
| item.css( "counter-reset", "listnumbering " + newStartCount ); | |
| } | |
| } | |
| // Instead of setting item class directly on the list item | |
| // at this point in time, push the item into a dictionary | |
| // that tells us what class to set on it so we can do this after this | |
| // processing loop is finished. | |
| if ( !itemClassDict[ itemClass ] ) { | |
| itemClassDict[ itemClass ] = []; | |
| } | |
| itemClassDict[ itemClass ].push( item[ 0 ] ); | |
| } | |
| // Set the appropriate listview item classes on each list item. | |
| // The main reason we didn't do this | |
| // in the for-loop above is because we can eliminate per-item function overhead | |
| // by calling addClass() and children() once or twice afterwards. This | |
| // can give us a significant boost on platforms like WP7.5. | |
| for ( itemClass in itemClassDict ) { | |
| $( itemClassDict[ itemClass ] ).addClass( itemClass ); | |
| } | |
| countBubbles.each( function() { | |
| $( this ).closest( "li" ).addClass( "ui-li-has-count" ); | |
| }); | |
| if ( countThemeClass ) { | |
| countBubbles.not( "[class*='ui-body-']" ).addClass( countThemeClass ); | |
| } | |
| // Deprecated in 1.4. From 1.5 you have to add class ui-li-has-thumb or ui-li-has-icon to the LI. | |
| this._addThumbClasses( li ); | |
| this._addThumbClasses( li.find( ".ui-btn" ) ); | |
| this._afterListviewRefresh(); | |
| this._addFirstLastClasses( li, this._getVisibles( li, create ), create ); | |
| } | |
| }, $.mobile.behaviors.addFirstLastClasses ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| function defaultAutodividersSelector( elt ) { | |
| // look for the text in the given element | |
| var text = $.trim( elt.text() ) || null; | |
| if ( !text ) { | |
| return null; | |
| } | |
| // create the text for the divider (first uppercased letter) | |
| text = text.slice( 0, 1 ).toUpperCase(); | |
| return text; | |
| } | |
| $.widget( "mobile.listview", $.mobile.listview, { | |
| options: { | |
| autodividers: false, | |
| autodividersSelector: defaultAutodividersSelector | |
| }, | |
| _beforeListviewRefresh: function() { | |
| if ( this.options.autodividers ) { | |
| this._replaceDividers(); | |
| this._superApply( arguments ); | |
| } | |
| }, | |
| _replaceDividers: function() { | |
| var i, lis, li, dividerText, | |
| lastDividerText = null, | |
| list = this.element, | |
| divider; | |
| list.children( "li:jqmData(role='list-divider')" ).remove(); | |
| lis = list.children( "li" ); | |
| for ( i = 0; i < lis.length ; i++ ) { | |
| li = lis[ i ]; | |
| dividerText = this.options.autodividersSelector( $( li ) ); | |
| if ( dividerText && lastDividerText !== dividerText ) { | |
| divider = document.createElement( "li" ); | |
| divider.appendChild( document.createTextNode( dividerText ) ); | |
| divider.setAttribute( "data-" + $.mobile.ns + "role", "list-divider" ); | |
| li.parentNode.insertBefore( divider, li ); | |
| } | |
| lastDividerText = dividerText; | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var rdivider = /(^|\s)ui-li-divider($|\s)/, | |
| rhidden = /(^|\s)ui-screen-hidden($|\s)/; | |
| $.widget( "mobile.listview", $.mobile.listview, { | |
| options: { | |
| hideDividers: false | |
| }, | |
| _afterListviewRefresh: function() { | |
| var items, idx, item, hideDivider = true; | |
| this._superApply( arguments ); | |
| if ( this.options.hideDividers ) { | |
| items = this._getChildrenByTagName( this.element[ 0 ], "li", "LI" ); | |
| for ( idx = items.length - 1 ; idx > -1 ; idx-- ) { | |
| item = items[ idx ]; | |
| if ( item.className.match( rdivider ) ) { | |
| if ( hideDivider ) { | |
| item.className = item.className + " ui-screen-hidden"; | |
| } | |
| hideDivider = true; | |
| } else { | |
| if ( !item.className.match( rhidden ) ) { | |
| hideDivider = false; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.mobile.nojs = function( target ) { | |
| $( ":jqmData(role='nojs')", target ).addClass( "ui-nojs" ); | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.mobile.behaviors.formReset = { | |
| _handleFormReset: function() { | |
| this._on( this.element.closest( "form" ), { | |
| reset: function() { | |
| this._delay( "_reset" ); | |
| } | |
| }); | |
| } | |
| }; | |
| })( jQuery ); | |
| /* | |
| * "checkboxradio" plugin | |
| */ | |
| (function( $, undefined ) { | |
| var escapeId = $.mobile.path.hashToSelector; | |
| $.widget( "mobile.checkboxradio", $.extend( { | |
| initSelector: "input:not( :jqmData(role='flipswitch' ) )[type='checkbox'],input[type='radio']:not( :jqmData(role='flipswitch' ))", | |
| options: { | |
| theme: "inherit", | |
| mini: false, | |
| wrapperClass: null, | |
| enhanced: false, | |
| iconpos: "left" | |
| }, | |
| _create: function() { | |
| var input = this.element, | |
| o = this.options, | |
| inheritAttr = function( input, dataAttr ) { | |
| return input.jqmData( dataAttr ) || | |
| input.closest( "form, fieldset" ).jqmData( dataAttr ); | |
| }, | |
| label = this.options.enhanced ? | |
| { | |
| element: this.element.siblings( "label" ), | |
| isParent: false | |
| } : | |
| this._findLabel(), | |
| inputtype = input[0].type, | |
| checkedClass = "ui-" + inputtype + "-on", | |
| uncheckedClass = "ui-" + inputtype + "-off"; | |
| if ( inputtype !== "checkbox" && inputtype !== "radio" ) { | |
| return; | |
| } | |
| if ( this.element[0].disabled ) { | |
| this.options.disabled = true; | |
| } | |
| o.iconpos = inheritAttr( input, "iconpos" ) || | |
| label.element.attr( "data-" + $.mobile.ns + "iconpos" ) || o.iconpos, | |
| // Establish options | |
| o.mini = inheritAttr( input, "mini" ) || o.mini; | |
| // Expose for other methods | |
| $.extend( this, { | |
| input: input, | |
| label: label.element, | |
| labelIsParent: label.isParent, | |
| inputtype: inputtype, | |
| checkedClass: checkedClass, | |
| uncheckedClass: uncheckedClass | |
| }); | |
| if ( !this.options.enhanced ) { | |
| this._enhance(); | |
| } | |
| this._on( label.element, { | |
| vmouseover: "_handleLabelVMouseOver", | |
| vclick: "_handleLabelVClick" | |
| }); | |
| this._on( input, { | |
| vmousedown: "_cacheVals", | |
| vclick: "_handleInputVClick", | |
| focus: "_handleInputFocus", | |
| blur: "_handleInputBlur" | |
| }); | |
| this._handleFormReset(); | |
| this.refresh(); | |
| }, | |
| _findLabel: function() { | |
| var parentLabel, label, isParent, | |
| input = this.element, | |
| labelsList = input[ 0 ].labels; | |
| if( labelsList && labelsList.length > 0 ) { | |
| label = $( labelsList[ 0 ] ); | |
| isParent = $.contains( label[ 0 ], input[ 0 ] ); | |
| } else { | |
| parentLabel = input.closest( "label" ); | |
| isParent = ( parentLabel.length > 0 ); | |
| // NOTE: Windows Phone could not find the label through a selector | |
| // filter works though. | |
| label = isParent ? parentLabel : | |
| $( this.document[ 0 ].getElementsByTagName( "label" ) ) | |
| .filter( "[for='" + escapeId( input[ 0 ].id ) + "']" ) | |
| .first(); | |
| } | |
| return { | |
| element: label, | |
| isParent: isParent | |
| }; | |
| }, | |
| _enhance: function() { | |
| this.label.addClass( "ui-btn ui-corner-all"); | |
| if ( this.labelIsParent ) { | |
| this.input.add( this.label ).wrapAll( this._wrapper() ); | |
| } else { | |
| //this.element.replaceWith( this.input.add( this.label ).wrapAll( this._wrapper() ) ); | |
| this.element.wrap( this._wrapper() ); | |
| this.element.parent().prepend( this.label ); | |
| } | |
| // Wrap the input + label in a div | |
| this._setOptions({ | |
| "theme": this.options.theme, | |
| "iconpos": this.options.iconpos, | |
| "mini": this.options.mini | |
| }); | |
| }, | |
| _wrapper: function() { | |
| return $( "<div class='" + | |
| ( this.options.wrapperClass ? this.options.wrapperClass : "" ) + | |
| " ui-" + this.inputtype + | |
| ( this.options.disabled ? " ui-state-disabled" : "" ) + "' ></div>" ); | |
| }, | |
| _handleInputFocus: function() { | |
| this.label.addClass( $.mobile.focusClass ); | |
| }, | |
| _handleInputBlur: function() { | |
| this.label.removeClass( $.mobile.focusClass ); | |
| }, | |
| _handleInputVClick: function() { | |
| // Adds checked attribute to checked input when keyboard is used | |
| this.element.prop( "checked", this.element.is( ":checked" ) ); | |
| this._getInputSet().not( this.element ).prop( "checked", false ); | |
| this._updateAll( true ); | |
| }, | |
| _handleLabelVMouseOver: function( event ) { | |
| if ( this.label.parent().hasClass( "ui-state-disabled" ) ) { | |
| event.stopPropagation(); | |
| } | |
| }, | |
| _handleLabelVClick: function( event ) { | |
| var input = this.element; | |
| if ( input.is( ":disabled" ) ) { | |
| event.preventDefault(); | |
| return; | |
| } | |
| this._cacheVals(); | |
| input.prop( "checked", this.inputtype === "radio" && true || !input.prop( "checked" ) ); | |
| // trigger click handler's bound directly to the input as a substitute for | |
| // how label clicks behave normally in the browsers | |
| // TODO: it would be nice to let the browser's handle the clicks and pass them | |
| // through to the associate input. we can swallow that click at the parent | |
| // wrapper element level | |
| input.triggerHandler( "click" ); | |
| // Input set for common radio buttons will contain all the radio | |
| // buttons, but will not for checkboxes. clearing the checked status | |
| // of other radios ensures the active button state is applied properly | |
| this._getInputSet().not( input ).prop( "checked", false ); | |
| this._updateAll(); | |
| return false; | |
| }, | |
| _cacheVals: function() { | |
| this._getInputSet().each( function() { | |
| $( this ).attr("data-" + $.mobile.ns + "cacheVal", this.checked ); | |
| }); | |
| }, | |
| // Returns those radio buttons that are supposed to be in the same group as | |
| // this radio button. In the case of a checkbox or a radio lacking a name | |
| // attribute, it returns this.element. | |
| _getInputSet: function() { | |
| var selector, formId, | |
| radio = this.element[ 0 ], | |
| name = radio.name, | |
| form = radio.form, | |
| doc = this.element.parents().last().get( 0 ), | |
| // A radio is always a member of its own group | |
| radios = this.element; | |
| // Only start running selectors if this is an attached radio button with a name | |
| if ( name && this.inputtype === "radio" && doc ) { | |
| selector = "input[type='radio'][name='" + escapeId( name ) + "']"; | |
| // If we're inside a form | |
| if ( form ) { | |
| formId = form.getAttribute( "id" ); | |
| // If the form has an ID, collect radios scattered throught the document which | |
| // nevertheless are part of the form by way of the value of their form attribute | |
| if ( formId ) { | |
| radios = $( selector + "[form='" + escapeId( formId ) + "']", doc ); | |
| } | |
| // Also add to those the radios in the form itself | |
| radios = $( form ).find( selector ).filter( function() { | |
| // Some radios inside the form may belong to some other form by virtue of | |
| // having a form attribute defined on them, so we must filter them out here | |
| return ( this.form === form ); | |
| }).add( radios ); | |
| // If we're outside a form | |
| } else { | |
| // Collect all those radios which are also outside of a form and match our name | |
| radios = $( selector, doc ).filter( function() { | |
| return !this.form; | |
| }); | |
| } | |
| } | |
| return radios; | |
| }, | |
| _updateAll: function( changeTriggered ) { | |
| var self = this; | |
| this._getInputSet().each( function() { | |
| var $this = $( this ); | |
| if ( ( this.checked || self.inputtype === "checkbox" ) && !changeTriggered ) { | |
| $this.trigger( "change" ); | |
| } | |
| }) | |
| .checkboxradio( "refresh" ); | |
| }, | |
| _reset: function() { | |
| this.refresh(); | |
| }, | |
| // Is the widget supposed to display an icon? | |
| _hasIcon: function() { | |
| var controlgroup, controlgroupWidget, | |
| controlgroupConstructor = $.mobile.controlgroup; | |
| // If the controlgroup widget is defined ... | |
| if ( controlgroupConstructor ) { | |
| controlgroup = this.element.closest( | |
| ":mobile-controlgroup," + | |
| controlgroupConstructor.prototype.initSelector ); | |
| // ... and the checkbox is in a controlgroup ... | |
| if ( controlgroup.length > 0 ) { | |
| // ... look for a controlgroup widget instance, and ... | |
| controlgroupWidget = $.data( controlgroup[ 0 ], "mobile-controlgroup" ); | |
| // ... if found, decide based on the option value, ... | |
| return ( ( controlgroupWidget ? controlgroupWidget.options.type : | |
| // ... otherwise decide based on the "type" data attribute. | |
| controlgroup.attr( "data-" + $.mobile.ns + "type" ) ) !== "horizontal" ); | |
| } | |
| } | |
| // Normally, the widget displays an icon. | |
| return true; | |
| }, | |
| refresh: function() { | |
| var hasIcon = this._hasIcon(), | |
| isChecked = this.element[ 0 ].checked, | |
| active = $.mobile.activeBtnClass, | |
| iconposClass = "ui-btn-icon-" + this.options.iconpos, | |
| addClasses = [], | |
| removeClasses = []; | |
| if ( hasIcon ) { | |
| removeClasses.push( active ); | |
| addClasses.push( iconposClass ); | |
| } else { | |
| removeClasses.push( iconposClass ); | |
| ( isChecked ? addClasses : removeClasses ).push( active ); | |
| } | |
| if ( isChecked ) { | |
| addClasses.push( this.checkedClass ); | |
| removeClasses.push( this.uncheckedClass ); | |
| } else { | |
| addClasses.push( this.uncheckedClass ); | |
| removeClasses.push( this.checkedClass ); | |
| } | |
| this.label | |
| .addClass( addClasses.join( " " ) ) | |
| .removeClass( removeClasses.join( " " ) ); | |
| }, | |
| widget: function() { | |
| return this.label.parent(); | |
| }, | |
| _setOptions: function( options ) { | |
| var label = this.label, | |
| currentOptions = this.options, | |
| outer = this.widget(), | |
| hasIcon = this._hasIcon(); | |
| if ( options.disabled !== undefined ) { | |
| this.input.prop( "disabled", !!options.disabled ); | |
| outer.toggleClass( "ui-state-disabled", !!options.disabled ); | |
| } | |
| if ( options.mini !== undefined ) { | |
| outer.toggleClass( "ui-mini", !!options.mini ); | |
| } | |
| if ( options.theme !== undefined ) { | |
| label | |
| .removeClass( "ui-btn-" + currentOptions.theme ) | |
| .addClass( "ui-btn-" + options.theme ); | |
| } | |
| if ( options.wrapperClass !== undefined ) { | |
| outer | |
| .removeClass( currentOptions.wrapperClass ) | |
| .addClass( options.wrapperClass ); | |
| } | |
| if ( options.iconpos !== undefined && hasIcon ) { | |
| label.removeClass( "ui-btn-icon-" + currentOptions.iconpos ).addClass( "ui-btn-icon-" + options.iconpos ); | |
| } else if ( !hasIcon ) { | |
| label.removeClass( "ui-btn-icon-" + currentOptions.iconpos ); | |
| } | |
| this._super( options ); | |
| } | |
| }, $.mobile.behaviors.formReset ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.button", { | |
| initSelector: "input[type='button'], input[type='submit'], input[type='reset']", | |
| options: { | |
| theme: null, | |
| icon: null, | |
| iconpos: "left", | |
| iconshadow: false, /* TODO: Deprecated in 1.4, remove in 1.5. */ | |
| corners: true, | |
| shadow: true, | |
| inline: null, | |
| mini: null, | |
| wrapperClass: null, | |
| enhanced: false | |
| }, | |
| _create: function() { | |
| if ( this.element.is( ":disabled" ) ) { | |
| this.options.disabled = true; | |
| } | |
| if ( !this.options.enhanced ) { | |
| this._enhance(); | |
| } | |
| $.extend( this, { | |
| wrapper: this.element.parent() | |
| }); | |
| this._on( { | |
| focus: function() { | |
| this.widget().addClass( $.mobile.focusClass ); | |
| }, | |
| blur: function() { | |
| this.widget().removeClass( $.mobile.focusClass ); | |
| } | |
| }); | |
| this.refresh( true ); | |
| }, | |
| _enhance: function() { | |
| this.element.wrap( this._button() ); | |
| }, | |
| _button: function() { | |
| var options = this.options, | |
| iconClasses = this._getIconClasses( this.options ); | |
| return $("<div class='ui-btn ui-input-btn" + | |
| ( options.wrapperClass ? " " + options.wrapperClass : "" ) + | |
| ( options.theme ? " ui-btn-" + options.theme : "" ) + | |
| ( options.corners ? " ui-corner-all" : "" ) + | |
| ( options.shadow ? " ui-shadow" : "" ) + | |
| ( options.inline ? " ui-btn-inline" : "" ) + | |
| ( options.mini ? " ui-mini" : "" ) + | |
| ( options.disabled ? " ui-state-disabled" : "" ) + | |
| ( iconClasses ? ( " " + iconClasses ) : "" ) + | |
| "' >" + this.element.val() + "</div>" ); | |
| }, | |
| widget: function() { | |
| return this.wrapper; | |
| }, | |
| _destroy: function() { | |
| this.element.insertBefore( this.button ); | |
| this.button.remove(); | |
| }, | |
| _getIconClasses: function( options ) { | |
| return ( options.icon ? ( "ui-icon-" + options.icon + | |
| ( options.iconshadow ? " ui-shadow-icon" : "" ) + /* TODO: Deprecated in 1.4, remove in 1.5. */ | |
| " ui-btn-icon-" + options.iconpos ) : "" ); | |
| }, | |
| _setOptions: function( options ) { | |
| var outer = this.widget(); | |
| if ( options.theme !== undefined ) { | |
| outer | |
| .removeClass( this.options.theme ) | |
| .addClass( "ui-btn-" + options.theme ); | |
| } | |
| if ( options.corners !== undefined ) { | |
| outer.toggleClass( "ui-corner-all", options.corners ); | |
| } | |
| if ( options.shadow !== undefined ) { | |
| outer.toggleClass( "ui-shadow", options.shadow ); | |
| } | |
| if ( options.inline !== undefined ) { | |
| outer.toggleClass( "ui-btn-inline", options.inline ); | |
| } | |
| if ( options.mini !== undefined ) { | |
| outer.toggleClass( "ui-mini", options.mini ); | |
| } | |
| if ( options.disabled !== undefined ) { | |
| this.element.prop( "disabled", options.disabled ); | |
| outer.toggleClass( "ui-state-disabled", options.disabled ); | |
| } | |
| if ( options.icon !== undefined || | |
| options.iconshadow !== undefined || /* TODO: Deprecated in 1.4, remove in 1.5. */ | |
| options.iconpos !== undefined ) { | |
| outer | |
| .removeClass( this._getIconClasses( this.options ) ) | |
| .addClass( this._getIconClasses( | |
| $.extend( {}, this.options, options ) ) ); | |
| } | |
| this._super( options ); | |
| }, | |
| refresh: function( create ) { | |
| var originalElement, | |
| isDisabled = this.element.prop( "disabled" ); | |
| if ( this.options.icon && this.options.iconpos === "notext" && this.element.attr( "title" ) ) { | |
| this.element.attr( "title", this.element.val() ); | |
| } | |
| if ( !create ) { | |
| originalElement = this.element.detach(); | |
| $( this.wrapper ).text( this.element.val() ).append( originalElement ); | |
| } | |
| if ( this.options.disabled !== isDisabled ) { | |
| this._setOptions({ disabled: isDisabled }); | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $ ) { | |
| var meta = $( "meta[name=viewport]" ), | |
| initialContent = meta.attr( "content" ), | |
| disabledZoom = initialContent + ",maximum-scale=1, user-scalable=no", | |
| enabledZoom = initialContent + ",maximum-scale=10, user-scalable=yes", | |
| disabledInitially = /(user-scalable[\s]*=[\s]*no)|(maximum-scale[\s]*=[\s]*1)[$,\s]/.test( initialContent ); | |
| $.mobile.zoom = $.extend( {}, { | |
| enabled: !disabledInitially, | |
| locked: false, | |
| disable: function( lock ) { | |
| if ( !disabledInitially && !$.mobile.zoom.locked ) { | |
| meta.attr( "content", disabledZoom ); | |
| $.mobile.zoom.enabled = false; | |
| $.mobile.zoom.locked = lock || false; | |
| } | |
| }, | |
| enable: function( unlock ) { | |
| if ( !disabledInitially && ( !$.mobile.zoom.locked || unlock === true ) ) { | |
| meta.attr( "content", enabledZoom ); | |
| $.mobile.zoom.enabled = true; | |
| $.mobile.zoom.locked = false; | |
| } | |
| }, | |
| restore: function() { | |
| if ( !disabledInitially ) { | |
| meta.attr( "content", initialContent ); | |
| $.mobile.zoom.enabled = true; | |
| } | |
| } | |
| }); | |
| }( jQuery )); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.textinput", { | |
| initSelector: "input[type='text']," + | |
| "input[type='search']," + | |
| ":jqmData(type='search')," + | |
| "input[type='number']," + | |
| ":jqmData(type='number')," + | |
| "input[type='password']," + | |
| "input[type='email']," + | |
| "input[type='url']," + | |
| "input[type='tel']," + | |
| "textarea," + | |
| "input[type='time']," + | |
| "input[type='date']," + | |
| "input[type='month']," + | |
| "input[type='week']," + | |
| "input[type='datetime']," + | |
| "input[type='datetime-local']," + | |
| "input[type='color']," + | |
| "input:not([type])," + | |
| "input[type='file']", | |
| options: { | |
| theme: null, | |
| corners: true, | |
| mini: false, | |
| // This option defaults to true on iOS devices. | |
| preventFocusZoom: /iPhone|iPad|iPod/.test( navigator.platform ) && navigator.userAgent.indexOf( "AppleWebKit" ) > -1, | |
| wrapperClass: "", | |
| enhanced: false | |
| }, | |
| _create: function() { | |
| var options = this.options, | |
| isSearch = this.element.is( "[type='search'], :jqmData(type='search')" ), | |
| isTextarea = this.element[ 0 ].tagName === "TEXTAREA", | |
| isRange = this.element.is( "[data-" + ( $.mobile.ns || "" ) + "type='range']" ), | |
| inputNeedsWrap = ( (this.element.is( "input" ) || | |
| this.element.is( "[data-" + ( $.mobile.ns || "" ) + "type='search']" ) ) && | |
| !isRange ); | |
| if ( this.element.prop( "disabled" ) ) { | |
| options.disabled = true; | |
| } | |
| $.extend( this, { | |
| classes: this._classesFromOptions(), | |
| isSearch: isSearch, | |
| isTextarea: isTextarea, | |
| isRange: isRange, | |
| inputNeedsWrap: inputNeedsWrap | |
| }); | |
| this._autoCorrect(); | |
| if ( !options.enhanced ) { | |
| this._enhance(); | |
| } | |
| this._on( { | |
| "focus": "_handleFocus", | |
| "blur": "_handleBlur" | |
| }); | |
| }, | |
| refresh: function() { | |
| this.setOptions({ | |
| "disabled" : this.element.is( ":disabled" ) | |
| }); | |
| }, | |
| _enhance: function() { | |
| var elementClasses = []; | |
| if ( this.isTextarea ) { | |
| elementClasses.push( "ui-input-text" ); | |
| } | |
| if ( this.isTextarea || this.isRange ) { | |
| elementClasses.push( "ui-shadow-inset" ); | |
| } | |
| //"search" and "text" input widgets | |
| if ( this.inputNeedsWrap ) { | |
| this.element.wrap( this._wrap() ); | |
| } else { | |
| elementClasses = elementClasses.concat( this.classes ); | |
| } | |
| this.element.addClass( elementClasses.join( " " ) ); | |
| }, | |
| widget: function() { | |
| return ( this.inputNeedsWrap ) ? this.element.parent() : this.element; | |
| }, | |
| _classesFromOptions: function() { | |
| var options = this.options, | |
| classes = []; | |
| classes.push( "ui-body-" + ( ( options.theme === null ) ? "inherit" : options.theme ) ); | |
| if ( options.corners ) { | |
| classes.push( "ui-corner-all" ); | |
| } | |
| if ( options.mini ) { | |
| classes.push( "ui-mini" ); | |
| } | |
| if ( options.disabled ) { | |
| classes.push( "ui-state-disabled" ); | |
| } | |
| if ( options.wrapperClass ) { | |
| classes.push( options.wrapperClass ); | |
| } | |
| return classes; | |
| }, | |
| _wrap: function() { | |
| return $( "<div class='" + | |
| ( this.isSearch ? "ui-input-search " : "ui-input-text " ) + | |
| this.classes.join( " " ) + " " + | |
| "ui-shadow-inset'></div>" ); | |
| }, | |
| _autoCorrect: function() { | |
| // XXX: Temporary workaround for issue 785 (Apple bug 8910589). | |
| // Turn off autocorrect and autocomplete on non-iOS 5 devices | |
| // since the popup they use can't be dismissed by the user. Note | |
| // that we test for the presence of the feature by looking for | |
| // the autocorrect property on the input element. We currently | |
| // have no test for iOS 5 or newer so we're temporarily using | |
| // the touchOverflow support flag for jQM 1.0. Yes, I feel dirty. | |
| // - jblas | |
| if ( typeof this.element[0].autocorrect !== "undefined" && | |
| !$.support.touchOverflow ) { | |
| // Set the attribute instead of the property just in case there | |
| // is code that attempts to make modifications via HTML. | |
| this.element[0].setAttribute( "autocorrect", "off" ); | |
| this.element[0].setAttribute( "autocomplete", "off" ); | |
| } | |
| }, | |
| _handleBlur: function() { | |
| this.widget().removeClass( $.mobile.focusClass ); | |
| if ( this.options.preventFocusZoom ) { | |
| $.mobile.zoom.enable( true ); | |
| } | |
| }, | |
| _handleFocus: function() { | |
| // In many situations, iOS will zoom into the input upon tap, this | |
| // prevents that from happening | |
| if ( this.options.preventFocusZoom ) { | |
| $.mobile.zoom.disable( true ); | |
| } | |
| this.widget().addClass( $.mobile.focusClass ); | |
| }, | |
| _setOptions: function ( options ) { | |
| var outer = this.widget(); | |
| this._super( options ); | |
| if ( !( options.disabled === undefined && | |
| options.mini === undefined && | |
| options.corners === undefined && | |
| options.theme === undefined && | |
| options.wrapperClass === undefined ) ) { | |
| outer.removeClass( this.classes.join( " " ) ); | |
| this.classes = this._classesFromOptions(); | |
| outer.addClass( this.classes.join( " " ) ); | |
| } | |
| if ( options.disabled !== undefined ) { | |
| this.element.prop( "disabled", !!options.disabled ); | |
| } | |
| }, | |
| _destroy: function() { | |
| if ( this.options.enhanced ) { | |
| return; | |
| } | |
| if ( this.inputNeedsWrap ) { | |
| this.element.unwrap(); | |
| } | |
| this.element.removeClass( "ui-input-text " + this.classes.join( " " ) ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.slider", $.extend( { | |
| initSelector: "input[type='range'], :jqmData(type='range'), :jqmData(role='slider')", | |
| widgetEventPrefix: "slide", | |
| options: { | |
| theme: null, | |
| trackTheme: null, | |
| corners: true, | |
| mini: false, | |
| highlight: false | |
| }, | |
| _create: function() { | |
| // TODO: Each of these should have comments explain what they're for | |
| var self = this, | |
| control = this.element, | |
| trackTheme = this.options.trackTheme || $.mobile.getAttribute( control[ 0 ], "theme" ), | |
| trackThemeClass = trackTheme ? " ui-bar-" + trackTheme : " ui-bar-inherit", | |
| cornerClass = ( this.options.corners || control.jqmData( "corners" ) ) ? " ui-corner-all" : "", | |
| miniClass = ( this.options.mini || control.jqmData( "mini" ) ) ? " ui-mini" : "", | |
| cType = control[ 0 ].nodeName.toLowerCase(), | |
| isToggleSwitch = ( cType === "select" ), | |
| isRangeslider = control.parent().is( ":jqmData(role='rangeslider')" ), | |
| selectClass = ( isToggleSwitch ) ? "ui-slider-switch" : "", | |
| controlID = control.attr( "id" ), | |
| $label = $( "[for='" + controlID + "']" ), | |
| labelID = $label.attr( "id" ) || controlID + "-label", | |
| min = !isToggleSwitch ? parseFloat( control.attr( "min" ) ) : 0, | |
| max = !isToggleSwitch ? parseFloat( control.attr( "max" ) ) : control.find( "option" ).length-1, | |
| step = window.parseFloat( control.attr( "step" ) || 1 ), | |
| domHandle = document.createElement( "a" ), | |
| handle = $( domHandle ), | |
| domSlider = document.createElement( "div" ), | |
| slider = $( domSlider ), | |
| valuebg = this.options.highlight && !isToggleSwitch ? (function() { | |
| var bg = document.createElement( "div" ); | |
| bg.className = "ui-slider-bg " + $.mobile.activeBtnClass; | |
| return $( bg ).prependTo( slider ); | |
| })() : false, | |
| options, | |
| wrapper, | |
| j, length, | |
| i, optionsCount, origTabIndex, | |
| side, activeClass, sliderImg; | |
| $label.attr( "id", labelID ); | |
| this.isToggleSwitch = isToggleSwitch; | |
| domHandle.setAttribute( "href", "#" ); | |
| domSlider.setAttribute( "role", "application" ); | |
| domSlider.className = [ this.isToggleSwitch ? "ui-slider ui-slider-track ui-shadow-inset " : "ui-slider-track ui-shadow-inset ", selectClass, trackThemeClass, cornerClass, miniClass ].join( "" ); | |
| domHandle.className = "ui-slider-handle"; | |
| domSlider.appendChild( domHandle ); | |
| handle.attr({ | |
| "role": "slider", | |
| "aria-valuemin": min, | |
| "aria-valuemax": max, | |
| "aria-valuenow": this._value(), | |
| "aria-valuetext": this._value(), | |
| "title": this._value(), | |
| "aria-labelledby": labelID | |
| }); | |
| $.extend( this, { | |
| slider: slider, | |
| handle: handle, | |
| control: control, | |
| type: cType, | |
| step: step, | |
| max: max, | |
| min: min, | |
| valuebg: valuebg, | |
| isRangeslider: isRangeslider, | |
| dragging: false, | |
| beforeStart: null, | |
| userModified: false, | |
| mouseMoved: false | |
| }); | |
| if ( isToggleSwitch ) { | |
| // TODO: restore original tabindex (if any) in a destroy method | |
| origTabIndex = control.attr( "tabindex" ); | |
| if ( origTabIndex ) { | |
| handle.attr( "tabindex", origTabIndex ); | |
| } | |
| control.attr( "tabindex", "-1" ).focus(function() { | |
| $( this ).blur(); | |
| handle.focus(); | |
| }); | |
| wrapper = document.createElement( "div" ); | |
| wrapper.className = "ui-slider-inneroffset"; | |
| for ( j = 0, length = domSlider.childNodes.length; j < length; j++ ) { | |
| wrapper.appendChild( domSlider.childNodes[j] ); | |
| } | |
| domSlider.appendChild( wrapper ); | |
| // slider.wrapInner( "<div class='ui-slider-inneroffset'></div>" ); | |
| // make the handle move with a smooth transition | |
| handle.addClass( "ui-slider-handle-snapping" ); | |
| options = control.find( "option" ); | |
| for ( i = 0, optionsCount = options.length; i < optionsCount; i++ ) { | |
| side = !i ? "b" : "a"; | |
| activeClass = !i ? "" : " " + $.mobile.activeBtnClass; | |
| sliderImg = document.createElement( "span" ); | |
| sliderImg.className = [ "ui-slider-label ui-slider-label-", side, activeClass ].join( "" ); | |
| sliderImg.setAttribute( "role", "img" ); | |
| sliderImg.appendChild( document.createTextNode( options[i].innerHTML ) ); | |
| $( sliderImg ).prependTo( slider ); | |
| } | |
| self._labels = $( ".ui-slider-label", slider ); | |
| } | |
| // monitor the input for updated values | |
| control.addClass( isToggleSwitch ? "ui-slider-switch" : "ui-slider-input" ); | |
| this._on( control, { | |
| "change": "_controlChange", | |
| "keyup": "_controlKeyup", | |
| "blur": "_controlBlur", | |
| "vmouseup": "_controlVMouseUp" | |
| }); | |
| slider.bind( "vmousedown", $.proxy( this._sliderVMouseDown, this ) ) | |
| .bind( "vclick", false ); | |
| // We have to instantiate a new function object for the unbind to work properly | |
| // since the method itself is defined in the prototype (causing it to unbind everything) | |
| this._on( document, { "vmousemove": "_preventDocumentDrag" }); | |
| this._on( slider.add( document ), { "vmouseup": "_sliderVMouseUp" }); | |
| slider.insertAfter( control ); | |
| // wrap in a div for styling purposes | |
| if ( !isToggleSwitch && !isRangeslider ) { | |
| wrapper = this.options.mini ? "<div class='ui-slider ui-mini'>" : "<div class='ui-slider'>"; | |
| control.add( slider ).wrapAll( wrapper ); | |
| } | |
| // bind the handle event callbacks and set the context to the widget instance | |
| this._on( this.handle, { | |
| "vmousedown": "_handleVMouseDown", | |
| "keydown": "_handleKeydown", | |
| "keyup": "_handleKeyup" | |
| }); | |
| this.handle.bind( "vclick", false ); | |
| this._handleFormReset(); | |
| this.refresh( undefined, undefined, true ); | |
| }, | |
| _setOptions: function( options ) { | |
| if ( options.theme !== undefined ) { | |
| this._setTheme( options.theme ); | |
| } | |
| if ( options.trackTheme !== undefined ) { | |
| this._setTrackTheme( options.trackTheme ); | |
| } | |
| if ( options.corners !== undefined ) { | |
| this._setCorners( options.corners ); | |
| } | |
| if ( options.mini !== undefined ) { | |
| this._setMini( options.mini ); | |
| } | |
| if ( options.highlight !== undefined ) { | |
| this._setHighlight( options.highlight ); | |
| } | |
| if ( options.disabled !== undefined ) { | |
| this._setDisabled( options.disabled ); | |
| } | |
| this._super( options ); | |
| }, | |
| _controlChange: function( event ) { | |
| // if the user dragged the handle, the "change" event was triggered from inside refresh(); don't call refresh() again | |
| if ( this._trigger( "controlchange", event ) === false ) { | |
| return false; | |
| } | |
| if ( !this.mouseMoved ) { | |
| this.refresh( this._value(), true ); | |
| } | |
| }, | |
| _controlKeyup: function(/* event */) { // necessary? | |
| this.refresh( this._value(), true, true ); | |
| }, | |
| _controlBlur: function(/* event */) { | |
| this.refresh( this._value(), true ); | |
| }, | |
| // it appears the clicking the up and down buttons in chrome on | |
| // range/number inputs doesn't trigger a change until the field is | |
| // blurred. Here we check thif the value has changed and refresh | |
| _controlVMouseUp: function(/* event */) { | |
| this._checkedRefresh(); | |
| }, | |
| // NOTE force focus on handle | |
| _handleVMouseDown: function(/* event */) { | |
| this.handle.focus(); | |
| }, | |
| _handleKeydown: function( event ) { | |
| var index = this._value(); | |
| if ( this.options.disabled ) { | |
| return; | |
| } | |
| // In all cases prevent the default and mark the handle as active | |
| switch ( event.keyCode ) { | |
| case $.mobile.keyCode.HOME: | |
| case $.mobile.keyCode.END: | |
| case $.mobile.keyCode.PAGE_UP: | |
| case $.mobile.keyCode.PAGE_DOWN: | |
| case $.mobile.keyCode.UP: | |
| case $.mobile.keyCode.RIGHT: | |
| case $.mobile.keyCode.DOWN: | |
| case $.mobile.keyCode.LEFT: | |
| event.preventDefault(); | |
| if ( !this._keySliding ) { | |
| this._keySliding = true; | |
| this.handle.addClass( "ui-state-active" ); /* TODO: We don't use this class for styling. Do we need to add it? */ | |
| } | |
| break; | |
| } | |
| // move the slider according to the keypress | |
| switch ( event.keyCode ) { | |
| case $.mobile.keyCode.HOME: | |
| this.refresh( this.min ); | |
| break; | |
| case $.mobile.keyCode.END: | |
| this.refresh( this.max ); | |
| break; | |
| case $.mobile.keyCode.PAGE_UP: | |
| case $.mobile.keyCode.UP: | |
| case $.mobile.keyCode.RIGHT: | |
| this.refresh( index + this.step ); | |
| break; | |
| case $.mobile.keyCode.PAGE_DOWN: | |
| case $.mobile.keyCode.DOWN: | |
| case $.mobile.keyCode.LEFT: | |
| this.refresh( index - this.step ); | |
| break; | |
| } | |
| }, // remove active mark | |
| _handleKeyup: function(/* event */) { | |
| if ( this._keySliding ) { | |
| this._keySliding = false; | |
| this.handle.removeClass( "ui-state-active" ); /* See comment above. */ | |
| } | |
| }, | |
| _sliderVMouseDown: function( event ) { | |
| // NOTE: we don't do this in refresh because we still want to | |
| // support programmatic alteration of disabled inputs | |
| if ( this.options.disabled || !( event.which === 1 || event.which === 0 || event.which === undefined ) ) { | |
| return false; | |
| } | |
| if ( this._trigger( "beforestart", event ) === false ) { | |
| return false; | |
| } | |
| this.dragging = true; | |
| this.userModified = false; | |
| this.mouseMoved = false; | |
| if ( this.isToggleSwitch ) { | |
| this.beforeStart = this.element[0].selectedIndex; | |
| } | |
| this.refresh( event ); | |
| this._trigger( "start" ); | |
| return false; | |
| }, | |
| _sliderVMouseUp: function() { | |
| if ( this.dragging ) { | |
| this.dragging = false; | |
| if ( this.isToggleSwitch ) { | |
| // make the handle move with a smooth transition | |
| this.handle.addClass( "ui-slider-handle-snapping" ); | |
| if ( this.mouseMoved ) { | |
| // this is a drag, change the value only if user dragged enough | |
| if ( this.userModified ) { | |
| this.refresh( this.beforeStart === 0 ? 1 : 0 ); | |
| } else { | |
| this.refresh( this.beforeStart ); | |
| } | |
| } else { | |
| // this is just a click, change the value | |
| this.refresh( this.beforeStart === 0 ? 1 : 0 ); | |
| } | |
| } | |
| this.mouseMoved = false; | |
| this._trigger( "stop" ); | |
| return false; | |
| } | |
| }, | |
| _preventDocumentDrag: function( event ) { | |
| // NOTE: we don't do this in refresh because we still want to | |
| // support programmatic alteration of disabled inputs | |
| if ( this._trigger( "drag", event ) === false) { | |
| return false; | |
| } | |
| if ( this.dragging && !this.options.disabled ) { | |
| // this.mouseMoved must be updated before refresh() because it will be used in the control "change" event | |
| this.mouseMoved = true; | |
| if ( this.isToggleSwitch ) { | |
| // make the handle move in sync with the mouse | |
| this.handle.removeClass( "ui-slider-handle-snapping" ); | |
| } | |
| this.refresh( event ); | |
| // only after refresh() you can calculate this.userModified | |
| this.userModified = this.beforeStart !== this.element[0].selectedIndex; | |
| return false; | |
| } | |
| }, | |
| _checkedRefresh: function() { | |
| if ( this.value !== this._value() ) { | |
| this.refresh( this._value() ); | |
| } | |
| }, | |
| _value: function() { | |
| return this.isToggleSwitch ? this.element[0].selectedIndex : parseFloat( this.element.val() ) ; | |
| }, | |
| _reset: function() { | |
| this.refresh( undefined, false, true ); | |
| }, | |
| refresh: function( val, isfromControl, preventInputUpdate ) { | |
| // NOTE: we don't return here because we want to support programmatic | |
| // alteration of the input value, which should still update the slider | |
| var self = this, | |
| parentTheme = $.mobile.getAttribute( this.element[ 0 ], "theme" ), | |
| theme = this.options.theme || parentTheme, | |
| themeClass = theme ? " ui-btn-" + theme : "", | |
| trackTheme = this.options.trackTheme || parentTheme, | |
| trackThemeClass = trackTheme ? " ui-bar-" + trackTheme : " ui-bar-inherit", | |
| cornerClass = this.options.corners ? " ui-corner-all" : "", | |
| miniClass = this.options.mini ? " ui-mini" : "", | |
| left, width, data, tol, | |
| pxStep, percent, | |
| control, isInput, optionElements, min, max, step, | |
| newval, valModStep, alignValue, percentPerStep, | |
| handlePercent, aPercent, bPercent, | |
| valueChanged; | |
| self.slider[0].className = [ this.isToggleSwitch ? "ui-slider ui-slider-switch ui-slider-track ui-shadow-inset" : "ui-slider-track ui-shadow-inset", trackThemeClass, cornerClass, miniClass ].join( "" ); | |
| if ( this.options.disabled || this.element.prop( "disabled" ) ) { | |
| this.disable(); | |
| } | |
| // set the stored value for comparison later | |
| this.value = this._value(); | |
| if ( this.options.highlight && !this.isToggleSwitch && this.slider.find( ".ui-slider-bg" ).length === 0 ) { | |
| this.valuebg = (function() { | |
| var bg = document.createElement( "div" ); | |
| bg.className = "ui-slider-bg " + $.mobile.activeBtnClass; | |
| return $( bg ).prependTo( self.slider ); | |
| })(); | |
| } | |
| this.handle.addClass( "ui-btn" + themeClass + " ui-shadow" ); | |
| control = this.element; | |
| isInput = !this.isToggleSwitch; | |
| optionElements = isInput ? [] : control.find( "option" ); | |
| min = isInput ? parseFloat( control.attr( "min" ) ) : 0; | |
| max = isInput ? parseFloat( control.attr( "max" ) ) : optionElements.length - 1; | |
| step = ( isInput && parseFloat( control.attr( "step" ) ) > 0 ) ? parseFloat( control.attr( "step" ) ) : 1; | |
| if ( typeof val === "object" ) { | |
| data = val; | |
| // a slight tolerance helped get to the ends of the slider | |
| tol = 8; | |
| left = this.slider.offset().left; | |
| width = this.slider.width(); | |
| pxStep = width/((max-min)/step); | |
| if ( !this.dragging || | |
| data.pageX < left - tol || | |
| data.pageX > left + width + tol ) { | |
| return; | |
| } | |
| if ( pxStep > 1 ) { | |
| percent = ( ( data.pageX - left ) / width ) * 100; | |
| } else { | |
| percent = Math.round( ( ( data.pageX - left ) / width ) * 100 ); | |
| } | |
| } else { | |
| if ( val == null ) { | |
| val = isInput ? parseFloat( control.val() || 0 ) : control[0].selectedIndex; | |
| } | |
| percent = ( parseFloat( val ) - min ) / ( max - min ) * 100; | |
| } | |
| if ( isNaN( percent ) ) { | |
| return; | |
| } | |
| newval = ( percent / 100 ) * ( max - min ) + min; | |
| //from jQuery UI slider, the following source will round to the nearest step | |
| valModStep = ( newval - min ) % step; | |
| alignValue = newval - valModStep; | |
| if ( Math.abs( valModStep ) * 2 >= step ) { | |
| alignValue += ( valModStep > 0 ) ? step : ( -step ); | |
| } | |
| percentPerStep = 100/((max-min)/step); | |
| // Since JavaScript has problems with large floats, round | |
| // the final value to 5 digits after the decimal point (see jQueryUI: #4124) | |
| newval = parseFloat( alignValue.toFixed(5) ); | |
| if ( typeof pxStep === "undefined" ) { | |
| pxStep = width / ( (max-min) / step ); | |
| } | |
| if ( pxStep > 1 && isInput ) { | |
| percent = ( newval - min ) * percentPerStep * ( 1 / step ); | |
| } | |
| if ( percent < 0 ) { | |
| percent = 0; | |
| } | |
| if ( percent > 100 ) { | |
| percent = 100; | |
| } | |
| if ( newval < min ) { | |
| newval = min; | |
| } | |
| if ( newval > max ) { | |
| newval = max; | |
| } | |
| this.handle.css( "left", percent + "%" ); | |
| this.handle[0].setAttribute( "aria-valuenow", isInput ? newval : optionElements.eq( newval ).attr( "value" ) ); | |
| this.handle[0].setAttribute( "aria-valuetext", isInput ? newval : optionElements.eq( newval ).getEncodedText() ); | |
| this.handle[0].setAttribute( "title", isInput ? newval : optionElements.eq( newval ).getEncodedText() ); | |
| if ( this.valuebg ) { | |
| this.valuebg.css( "width", percent + "%" ); | |
| } | |
| // drag the label widths | |
| if ( this._labels ) { | |
| handlePercent = this.handle.width() / this.slider.width() * 100; | |
| aPercent = percent && handlePercent + ( 100 - handlePercent ) * percent / 100; | |
| bPercent = percent === 100 ? 0 : Math.min( handlePercent + 100 - aPercent, 100 ); | |
| this._labels.each(function() { | |
| var ab = $( this ).hasClass( "ui-slider-label-a" ); | |
| $( this ).width( ( ab ? aPercent : bPercent ) + "%" ); | |
| }); | |
| } | |
| if ( !preventInputUpdate ) { | |
| valueChanged = false; | |
| // update control"s value | |
| if ( isInput ) { | |
| valueChanged = control.val() !== newval; | |
| control.val( newval ); | |
| } else { | |
| valueChanged = control[ 0 ].selectedIndex !== newval; | |
| control[ 0 ].selectedIndex = newval; | |
| } | |
| if ( this._trigger( "beforechange", val ) === false) { | |
| return false; | |
| } | |
| if ( !isfromControl && valueChanged ) { | |
| control.trigger( "change" ); | |
| } | |
| } | |
| }, | |
| _setHighlight: function( value ) { | |
| value = !!value; | |
| if ( value ) { | |
| this.options.highlight = !!value; | |
| this.refresh(); | |
| } else if ( this.valuebg ) { | |
| this.valuebg.remove(); | |
| this.valuebg = false; | |
| } | |
| }, | |
| _setTheme: function( value ) { | |
| this.handle | |
| .removeClass( "ui-btn-" + this.options.theme ) | |
| .addClass( "ui-btn-" + value ); | |
| var currentTheme = this.options.theme ? this.options.theme : "inherit", | |
| newTheme = value ? value : "inherit"; | |
| this.control | |
| .removeClass( "ui-body-" + currentTheme ) | |
| .addClass( "ui-body-" + newTheme ); | |
| }, | |
| _setTrackTheme: function( value ) { | |
| var currentTrackTheme = this.options.trackTheme ? this.options.trackTheme : "inherit", | |
| newTrackTheme = value ? value : "inherit"; | |
| this.slider | |
| .removeClass( "ui-body-" + currentTrackTheme ) | |
| .addClass( "ui-body-" + newTrackTheme ); | |
| }, | |
| _setMini: function( value ) { | |
| value = !!value; | |
| if ( !this.isToggleSwitch && !this.isRangeslider ) { | |
| this.slider.parent().toggleClass( "ui-mini", value ); | |
| this.element.toggleClass( "ui-mini", value ); | |
| } | |
| this.slider.toggleClass( "ui-mini", value ); | |
| }, | |
| _setCorners: function( value ) { | |
| this.slider.toggleClass( "ui-corner-all", value ); | |
| if ( !this.isToggleSwitch ) { | |
| this.control.toggleClass( "ui-corner-all", value ); | |
| } | |
| }, | |
| _setDisabled: function( value ) { | |
| value = !!value; | |
| this.element.prop( "disabled", value ); | |
| this.slider | |
| .toggleClass( "ui-state-disabled", value ) | |
| .attr( "aria-disabled", value ); | |
| } | |
| }, $.mobile.behaviors.formReset ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| var popup; | |
| function getPopup() { | |
| if ( !popup ) { | |
| popup = $( "<div></div>", { | |
| "class": "ui-slider-popup ui-shadow ui-corner-all" | |
| }); | |
| } | |
| return popup.clone(); | |
| } | |
| $.widget( "mobile.slider", $.mobile.slider, { | |
| options: { | |
| popupEnabled: false, | |
| showValue: false | |
| }, | |
| _create: function() { | |
| this._super(); | |
| $.extend( this, { | |
| _currentValue: null, | |
| _popup: null, | |
| _popupVisible: false | |
| }); | |
| this._setOption( "popupEnabled", this.options.popupEnabled ); | |
| this._on( this.handle, { "vmousedown" : "_showPopup" } ); | |
| this._on( this.slider.add( this.document ), { "vmouseup" : "_hidePopup" } ); | |
| this._refresh(); | |
| }, | |
| // position the popup centered 5px above the handle | |
| _positionPopup: function() { | |
| var dstOffset = this.handle.offset(); | |
| this._popup.offset( { | |
| left: dstOffset.left + ( this.handle.width() - this._popup.width() ) / 2, | |
| top: dstOffset.top - this._popup.outerHeight() - 5 | |
| }); | |
| }, | |
| _setOption: function( key, value ) { | |
| this._super( key, value ); | |
| if ( key === "showValue" ) { | |
| this.handle.html( value && !this.options.mini ? this._value() : "" ); | |
| } else if ( key === "popupEnabled" ) { | |
| if ( value && !this._popup ) { | |
| this._popup = getPopup() | |
| .addClass( "ui-body-" + ( this.options.theme || "a" ) ) | |
| .hide() | |
| .insertBefore( this.element ); | |
| } | |
| } | |
| }, | |
| // show value on the handle and in popup | |
| refresh: function() { | |
| this._super.apply( this, arguments ); | |
| this._refresh(); | |
| }, | |
| _refresh: function() { | |
| var o = this.options, newValue; | |
| if ( o.popupEnabled ) { | |
| // remove the title attribute from the handle (which is | |
| // responsible for the annoying tooltip); NB we have | |
| // to do it here as the jqm slider sets it every time | |
| // the slider's value changes :( | |
| this.handle.removeAttr( "title" ); | |
| } | |
| newValue = this._value(); | |
| if ( newValue === this._currentValue ) { | |
| return; | |
| } | |
| this._currentValue = newValue; | |
| if ( o.popupEnabled && this._popup ) { | |
| this._positionPopup(); | |
| this._popup.html( newValue ); | |
| } | |
| if ( o.showValue && !this.options.mini ) { | |
| this.handle.html( newValue ); | |
| } | |
| }, | |
| _showPopup: function() { | |
| if ( this.options.popupEnabled && !this._popupVisible ) { | |
| this.handle.html( "" ); | |
| this._popup.show(); | |
| this._positionPopup(); | |
| this._popupVisible = true; | |
| } | |
| }, | |
| _hidePopup: function() { | |
| var o = this.options; | |
| if ( o.popupEnabled && this._popupVisible ) { | |
| if ( o.showValue && !o.mini ) { | |
| this.handle.html( this._value() ); | |
| } | |
| this._popup.hide(); | |
| this._popupVisible = false; | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.flipswitch", $.extend({ | |
| options: { | |
| onText: "On", | |
| offText: "Off", | |
| theme: null, | |
| enhanced: false, | |
| wrapperClass: null, | |
| corners: true, | |
| mini: false | |
| }, | |
| _create: function() { | |
| if ( !this.options.enhanced ) { | |
| this._enhance(); | |
| } else { | |
| $.extend( this, { | |
| flipswitch: this.element.parent(), | |
| on: this.element.find( ".ui-flipswitch-on" ).eq( 0 ), | |
| off: this.element.find( ".ui-flipswitch-off" ).eq(0), | |
| type: this.element.get( 0 ).tagName | |
| }); | |
| } | |
| this._handleFormReset(); | |
| // Transfer tabindex to "on" element and make input unfocusable | |
| this._originalTabIndex = this.element.attr( "tabindex" ); | |
| if ( this._originalTabIndex != null ) { | |
| this.on.attr( "tabindex", this._originalTabIndex ); | |
| } | |
| this.element.attr( "tabindex", "-1" ); | |
| this._on({ | |
| "focus" : "_handleInputFocus" | |
| }); | |
| if ( this.element.is( ":disabled" ) ) { | |
| this._setOptions({ | |
| "disabled": true | |
| }); | |
| } | |
| this._on( this.flipswitch, { | |
| "click": "_toggle", | |
| "swipeleft": "_left", | |
| "swiperight": "_right" | |
| }); | |
| this._on( this.on, { | |
| "keydown": "_keydown" | |
| }); | |
| this._on( { | |
| "change": "refresh" | |
| }); | |
| }, | |
| _handleInputFocus: function() { | |
| this.on.focus(); | |
| }, | |
| widget: function() { | |
| return this.flipswitch; | |
| }, | |
| _left: function() { | |
| this.flipswitch.removeClass( "ui-flipswitch-active" ); | |
| if ( this.type === "SELECT" ) { | |
| this.element.get( 0 ).selectedIndex = 0; | |
| } else { | |
| this.element.prop( "checked", false ); | |
| } | |
| this.element.trigger( "change" ); | |
| }, | |
| _right: function() { | |
| this.flipswitch.addClass( "ui-flipswitch-active" ); | |
| if ( this.type === "SELECT" ) { | |
| this.element.get( 0 ).selectedIndex = 1; | |
| } else { | |
| this.element.prop( "checked", true ); | |
| } | |
| this.element.trigger( "change" ); | |
| }, | |
| _enhance: function() { | |
| var flipswitch = $( "<div>" ), | |
| options = this.options, | |
| element = this.element, | |
| theme = options.theme ? options.theme : "inherit", | |
| // The "on" button is an anchor so it's focusable | |
| on = $( "<a></a>", { | |
| "href": "#" | |
| }), | |
| off = $( "<span></span>" ), | |
| type = element.get( 0 ).tagName, | |
| onText = ( type === "INPUT" ) ? | |
| options.onText : element.find( "option" ).eq( 1 ).text(), | |
| offText = ( type === "INPUT" ) ? | |
| options.offText : element.find( "option" ).eq( 0 ).text(); | |
| on | |
| .addClass( "ui-flipswitch-on ui-btn ui-shadow ui-btn-inherit" ) | |
| .text( onText ); | |
| off | |
| .addClass( "ui-flipswitch-off" ) | |
| .text( offText ); | |
| flipswitch | |
| .addClass( "ui-flipswitch ui-shadow-inset " + | |
| "ui-bar-" + theme + " " + | |
| ( options.wrapperClass ? options.wrapperClass : "" ) + " " + | |
| ( ( element.is( ":checked" ) || | |
| element | |
| .find( "option" ) | |
| .eq( 1 ) | |
| .is( ":selected" ) ) ? "ui-flipswitch-active" : "" ) + | |
| ( element.is(":disabled") ? " ui-state-disabled": "") + | |
| ( options.corners ? " ui-corner-all": "" ) + | |
| ( options.mini ? " ui-mini": "" ) ) | |
| .append( on, off ); | |
| element | |
| .addClass( "ui-flipswitch-input" ) | |
| .after( flipswitch ) | |
| .appendTo( flipswitch ); | |
| $.extend( this, { | |
| flipswitch: flipswitch, | |
| on: on, | |
| off: off, | |
| type: type | |
| }); | |
| }, | |
| _reset: function() { | |
| this.refresh(); | |
| }, | |
| refresh: function() { | |
| var direction, | |
| existingDirection = this.flipswitch.hasClass( "ui-flipswitch-active" ) ? "_right" : "_left"; | |
| if ( this.type === "SELECT" ) { | |
| direction = ( this.element.get( 0 ).selectedIndex > 0 ) ? "_right": "_left"; | |
| } else { | |
| direction = this.element.prop( "checked" ) ? "_right": "_left"; | |
| } | |
| if ( direction !== existingDirection ) { | |
| this[ direction ](); | |
| } | |
| }, | |
| _toggle: function() { | |
| var direction = this.flipswitch.hasClass( "ui-flipswitch-active" ) ? "_left" : "_right"; | |
| this[ direction ](); | |
| }, | |
| _keydown: function( e ) { | |
| if ( e.which === $.mobile.keyCode.LEFT ) { | |
| this._left(); | |
| } else if ( e.which === $.mobile.keyCode.RIGHT ) { | |
| this._right(); | |
| } else if ( e.which === $.mobile.keyCode.SPACE ) { | |
| this._toggle(); | |
| e.preventDefault(); | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| if ( options.theme !== undefined ) { | |
| var currentTheme = options.theme ? options.theme : "inherit", | |
| newTheme = options.theme ? options.theme : "inherit"; | |
| this.widget() | |
| .removeClass( "ui-bar-" + currentTheme ) | |
| .addClass( "ui-bar-" + newTheme ); | |
| } | |
| if ( options.onText !== undefined ) { | |
| this.on.text( options.onText ); | |
| } | |
| if ( options.offText !== undefined ) { | |
| this.off.text( options.offText ); | |
| } | |
| if ( options.disabled !== undefined ) { | |
| this.widget().toggleClass( "ui-state-disabled", options.disabled ); | |
| } | |
| if ( options.mini !== undefined ) { | |
| this.widget().toggleClass( "ui-mini", options.mini ); | |
| } | |
| if ( options.corners !== undefined ) { | |
| this.widget().toggleClass( "ui-corner-all", options.corners ); | |
| } | |
| this._super( options ); | |
| }, | |
| _destroy: function() { | |
| if ( this.options.enhanced ) { | |
| return; | |
| } | |
| if ( this._originalTabIndex != null ) { | |
| this.element.attr( "tabindex", this._originalTabIndex ); | |
| } else { | |
| this.element.removeAttr( "tabindex" ); | |
| } | |
| this.on.remove(); | |
| this.off.remove(); | |
| this.element.unwrap(); | |
| this.flipswitch.remove(); | |
| this.removeClass( "ui-flipswitch-input" ); | |
| } | |
| }, $.mobile.behaviors.formReset ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.rangeslider", $.extend( { | |
| options: { | |
| theme: null, | |
| trackTheme: null, | |
| corners: true, | |
| mini: false, | |
| highlight: true | |
| }, | |
| _create: function() { | |
| var $el = this.element, | |
| elClass = this.options.mini ? "ui-rangeslider ui-mini" : "ui-rangeslider", | |
| _inputFirst = $el.find( "input" ).first(), | |
| _inputLast = $el.find( "input" ).last(), | |
| _label = $el.find( "label" ).first(), | |
| _sliderWidgetFirst = $.data( _inputFirst.get( 0 ), "mobile-slider" ) || | |
| $.data( _inputFirst.slider().get( 0 ), "mobile-slider" ), | |
| _sliderWidgetLast = $.data( _inputLast.get(0), "mobile-slider" ) || | |
| $.data( _inputLast.slider().get( 0 ), "mobile-slider" ), | |
| _sliderFirst = _sliderWidgetFirst.slider, | |
| _sliderLast = _sliderWidgetLast.slider, | |
| firstHandle = _sliderWidgetFirst.handle, | |
| _sliders = $( "<div class='ui-rangeslider-sliders' />" ).appendTo( $el ); | |
| _inputFirst.addClass( "ui-rangeslider-first" ); | |
| _inputLast.addClass( "ui-rangeslider-last" ); | |
| $el.addClass( elClass ); | |
| _sliderFirst.appendTo( _sliders ); | |
| _sliderLast.appendTo( _sliders ); | |
| _label.insertBefore( $el ); | |
| firstHandle.prependTo( _sliderLast ); | |
| $.extend( this, { | |
| _inputFirst: _inputFirst, | |
| _inputLast: _inputLast, | |
| _sliderFirst: _sliderFirst, | |
| _sliderLast: _sliderLast, | |
| _label: _label, | |
| _targetVal: null, | |
| _sliderTarget: false, | |
| _sliders: _sliders, | |
| _proxy: false | |
| }); | |
| this.refresh(); | |
| this._on( this.element.find( "input.ui-slider-input" ), { | |
| "slidebeforestart": "_slidebeforestart", | |
| "slidestop": "_slidestop", | |
| "slidedrag": "_slidedrag", | |
| "slidebeforechange": "_change", | |
| "blur": "_change", | |
| "keyup": "_change" | |
| }); | |
| this._on({ | |
| "mousedown":"_change" | |
| }); | |
| this._on( this.element.closest( "form" ), { | |
| "reset":"_handleReset" | |
| }); | |
| this._on( firstHandle, { | |
| "vmousedown": "_dragFirstHandle" | |
| }); | |
| }, | |
| _handleReset: function() { | |
| var self = this; | |
| //we must wait for the stack to unwind before updateing other wise sliders will not have updated yet | |
| setTimeout( function() { | |
| self._updateHighlight(); | |
| },0); | |
| }, | |
| _dragFirstHandle: function( event ) { | |
| //if the first handle is dragged send the event to the first slider | |
| $.data( this._inputFirst.get(0), "mobile-slider" ).dragging = true; | |
| $.data( this._inputFirst.get(0), "mobile-slider" ).refresh( event ); | |
| return false; | |
| }, | |
| _slidedrag: function( event ) { | |
| var first = $( event.target ).is( this._inputFirst ), | |
| otherSlider = ( first ) ? this._inputLast : this._inputFirst; | |
| this._sliderTarget = false; | |
| //if the drag was initiated on an extreme and the other handle is focused send the events to | |
| //the closest handle | |
| if ( ( this._proxy === "first" && first ) || ( this._proxy === "last" && !first ) ) { | |
| $.data( otherSlider.get(0), "mobile-slider" ).dragging = true; | |
| $.data( otherSlider.get(0), "mobile-slider" ).refresh( event ); | |
| return false; | |
| } | |
| }, | |
| _slidestop: function( event ) { | |
| var first = $( event.target ).is( this._inputFirst ); | |
| this._proxy = false; | |
| //this stops dragging of the handle and brings the active track to the front | |
| //this makes clicks on the track go the the last handle used | |
| this.element.find( "input" ).trigger( "vmouseup" ); | |
| this._sliderFirst.css( "z-index", first ? 1 : "" ); | |
| }, | |
| _slidebeforestart: function( event ) { | |
| this._sliderTarget = false; | |
| //if the track is the target remember this and the original value | |
| if ( $( event.originalEvent.target ).hasClass( "ui-slider-track" ) ) { | |
| this._sliderTarget = true; | |
| this._targetVal = $( event.target ).val(); | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| if ( options.theme !== undefined ) { | |
| this._setTheme( options.theme ); | |
| } | |
| if ( options.trackTheme !== undefined ) { | |
| this._setTrackTheme( options.trackTheme ); | |
| } | |
| if ( options.mini !== undefined ) { | |
| this._setMini( options.mini ); | |
| } | |
| if ( options.highlight !== undefined ) { | |
| this._setHighlight( options.highlight ); | |
| } | |
| this._super( options ); | |
| this.refresh(); | |
| }, | |
| refresh: function() { | |
| var $el = this.element, | |
| o = this.options; | |
| if ( this._inputFirst.is( ":disabled" ) || this._inputLast.is( ":disabled" ) ) { | |
| this.options.disabled = true; | |
| } | |
| $el.find( "input" ).slider({ | |
| theme: o.theme, | |
| trackTheme: o.trackTheme, | |
| disabled: o.disabled, | |
| corners: o.corners, | |
| mini: o.mini, | |
| highlight: o.highlight | |
| }).slider( "refresh" ); | |
| this._updateHighlight(); | |
| }, | |
| _change: function( event ) { | |
| if ( event.type === "keyup" ) { | |
| this._updateHighlight(); | |
| return false; | |
| } | |
| var self = this, | |
| min = parseFloat( this._inputFirst.val(), 10 ), | |
| max = parseFloat( this._inputLast.val(), 10 ), | |
| first = $( event.target ).hasClass( "ui-rangeslider-first" ), | |
| thisSlider = first ? this._inputFirst : this._inputLast, | |
| otherSlider = first ? this._inputLast : this._inputFirst; | |
| if ( ( this._inputFirst.val() > this._inputLast.val() && event.type === "mousedown" && !$(event.target).hasClass("ui-slider-handle")) ) { | |
| thisSlider.blur(); | |
| } else if ( event.type === "mousedown" ) { | |
| return; | |
| } | |
| if ( min > max && !this._sliderTarget ) { | |
| //this prevents min from being greater then max | |
| thisSlider.val( first ? max: min ).slider( "refresh" ); | |
| this._trigger( "normalize" ); | |
| } else if ( min > max ) { | |
| //this makes it so clicks on the target on either extreme go to the closest handle | |
| thisSlider.val( this._targetVal ).slider( "refresh" ); | |
| //You must wait for the stack to unwind so first slider is updated before updating second | |
| setTimeout( function() { | |
| otherSlider.val( first ? min: max ).slider( "refresh" ); | |
| $.data( otherSlider.get(0), "mobile-slider" ).handle.focus(); | |
| self._sliderFirst.css( "z-index", first ? "" : 1 ); | |
| self._trigger( "normalize" ); | |
| }, 0 ); | |
| this._proxy = ( first ) ? "first" : "last"; | |
| } | |
| //fixes issue where when both _sliders are at min they cannot be adjusted | |
| if ( min === max ) { | |
| $.data( thisSlider.get(0), "mobile-slider" ).handle.css( "z-index", 1 ); | |
| $.data( otherSlider.get(0), "mobile-slider" ).handle.css( "z-index", 0 ); | |
| } else { | |
| $.data( otherSlider.get(0), "mobile-slider" ).handle.css( "z-index", "" ); | |
| $.data( thisSlider.get(0), "mobile-slider" ).handle.css( "z-index", "" ); | |
| } | |
| this._updateHighlight(); | |
| if ( min >= max ) { | |
| return false; | |
| } | |
| }, | |
| _updateHighlight: function() { | |
| var min = parseInt( $.data( this._inputFirst.get(0), "mobile-slider" ).handle.get(0).style.left, 10 ), | |
| max = parseInt( $.data( this._inputLast.get(0), "mobile-slider" ).handle.get(0).style.left, 10 ), | |
| width = (max - min); | |
| this.element.find( ".ui-slider-bg" ).css({ | |
| "margin-left": min + "%", | |
| "width": width + "%" | |
| }); | |
| }, | |
| _setTheme: function( value ) { | |
| this._inputFirst.slider( "option", "theme", value ); | |
| this._inputLast.slider( "option", "theme", value ); | |
| }, | |
| _setTrackTheme: function( value ) { | |
| this._inputFirst.slider( "option", "trackTheme", value ); | |
| this._inputLast.slider( "option", "trackTheme", value ); | |
| }, | |
| _setMini: function( value ) { | |
| this._inputFirst.slider( "option", "mini", value ); | |
| this._inputLast.slider( "option", "mini", value ); | |
| this.element.toggleClass( "ui-mini", !!value ); | |
| }, | |
| _setHighlight: function( value ) { | |
| this._inputFirst.slider( "option", "highlight", value ); | |
| this._inputLast.slider( "option", "highlight", value ); | |
| }, | |
| _destroy: function() { | |
| this._label.prependTo( this.element ); | |
| this.element.removeClass( "ui-rangeslider ui-mini" ); | |
| this._inputFirst.after( this._sliderFirst ); | |
| this._inputLast.after( this._sliderLast ); | |
| this._sliders.remove(); | |
| this.element.find( "input" ).removeClass( "ui-rangeslider-first ui-rangeslider-last" ).slider( "destroy" ); | |
| } | |
| }, $.mobile.behaviors.formReset ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.textinput", $.mobile.textinput, { | |
| options: { | |
| clearBtn: false, | |
| clearBtnText: "Clear text" | |
| }, | |
| _create: function() { | |
| this._super(); | |
| if ( !!this.options.clearBtn || this.isSearch ) { | |
| this._addClearBtn(); | |
| } | |
| }, | |
| clearButton: function() { | |
| return $( "<a href='#' class='ui-input-clear ui-btn ui-icon-delete ui-btn-icon-notext ui-corner-all" + | |
| "' title='" + this.options.clearBtnText + "'>" + this.options.clearBtnText + "</a>" ); | |
| }, | |
| _clearBtnClick: function( event ) { | |
| this.element.val( "" ) | |
| .focus() | |
| .trigger( "change" ); | |
| this._clearBtn.addClass( "ui-input-clear-hidden" ); | |
| event.preventDefault(); | |
| }, | |
| _addClearBtn: function() { | |
| if ( !this.options.enhanced ) { | |
| this._enhanceClear(); | |
| } | |
| $.extend( this, { | |
| _clearBtn: this.widget().find("a.ui-input-clear") | |
| }); | |
| this._bindClearEvents(); | |
| this._toggleClear(); | |
| }, | |
| _enhanceClear: function() { | |
| this.clearButton().appendTo( this.widget() ); | |
| this.widget().addClass( "ui-input-has-clear" ); | |
| }, | |
| _bindClearEvents: function() { | |
| this._on( this._clearBtn, { | |
| "click": "_clearBtnClick" | |
| }); | |
| this._on({ | |
| "keyup": "_toggleClear", | |
| "change": "_toggleClear", | |
| "input": "_toggleClear", | |
| "focus": "_toggleClear", | |
| "blur": "_toggleClear", | |
| "cut": "_toggleClear", | |
| "paste": "_toggleClear" | |
| }); | |
| }, | |
| _unbindClear: function() { | |
| this._off( this._clearBtn, "click"); | |
| this._off( this.element, "keyup change input focus blur cut paste" ); | |
| }, | |
| _setOptions: function( options ) { | |
| this._super( options ); | |
| if ( options.clearBtn !== undefined && | |
| !this.element.is( "textarea, :jqmData(type='range')" ) ) { | |
| if ( options.clearBtn ) { | |
| this._addClearBtn(); | |
| } else { | |
| this._destroyClear(); | |
| } | |
| } | |
| if ( options.clearBtnText !== undefined && this._clearBtn !== undefined ) { | |
| this._clearBtn.text( options.clearBtnText ) | |
| .attr("title", options.clearBtnText); | |
| } | |
| }, | |
| _toggleClear: function() { | |
| this._delay( "_toggleClearClass", 0 ); | |
| }, | |
| _toggleClearClass: function() { | |
| this._clearBtn.toggleClass( "ui-input-clear-hidden", !this.element.val() ); | |
| }, | |
| _destroyClear: function() { | |
| this.widget().removeClass( "ui-input-has-clear" ); | |
| this._unbindClear(); | |
| this._clearBtn.remove(); | |
| }, | |
| _destroy: function() { | |
| this._super(); | |
| this._destroyClear(); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.textinput", $.mobile.textinput, { | |
| options: { | |
| autogrow:true, | |
| keyupTimeoutBuffer: 100 | |
| }, | |
| _create: function() { | |
| this._super(); | |
| if ( this.options.autogrow && this.isTextarea ) { | |
| this._autogrow(); | |
| } | |
| }, | |
| _autogrow: function() { | |
| this.element.addClass( "ui-textinput-autogrow" ); | |
| this._on({ | |
| "keyup": "_timeout", | |
| "change": "_timeout", | |
| "input": "_timeout", | |
| "paste": "_timeout" | |
| }); | |
| // Attach to the various you-have-become-visible notifications that the | |
| // various framework elements emit. | |
| // TODO: Remove all but the updatelayout handler once #6426 is fixed. | |
| this._on( true, this.document, { | |
| // TODO: Move to non-deprecated event | |
| "pageshow": "_handleShow", | |
| "popupbeforeposition": "_handleShow", | |
| "updatelayout": "_handleShow", | |
| "panelopen": "_handleShow" | |
| }); | |
| }, | |
| // Synchronously fix the widget height if this widget's parents are such | |
| // that they show/hide content at runtime. We still need to check whether | |
| // the widget is actually visible in case it is contained inside multiple | |
| // such containers. For example: panel contains collapsible contains | |
| // autogrow textinput. The panel may emit "panelopen" indicating that its | |
| // content has become visible, but the collapsible is still collapsed, so | |
| // the autogrow textarea is still not visible. | |
| _handleShow: function( event ) { | |
| if ( $.contains( event.target, this.element[ 0 ] ) && | |
| this.element.is( ":visible" ) ) { | |
| if ( event.type !== "popupbeforeposition" ) { | |
| this.element | |
| .addClass( "ui-textinput-autogrow-resize" ) | |
| .animationComplete( | |
| $.proxy( function() { | |
| this.element.removeClass( "ui-textinput-autogrow-resize" ); | |
| }, this ), | |
| "transition" ); | |
| } | |
| this._timeout(); | |
| } | |
| }, | |
| _unbindAutogrow: function() { | |
| this.element.removeClass( "ui-textinput-autogrow" ); | |
| this._off( this.element, "keyup change input paste" ); | |
| this._off( this.document, | |
| "pageshow popupbeforeposition updatelayout panelopen" ); | |
| }, | |
| keyupTimeout: null, | |
| _prepareHeightUpdate: function( delay ) { | |
| if ( this.keyupTimeout ) { | |
| clearTimeout( this.keyupTimeout ); | |
| } | |
| if ( delay === undefined ) { | |
| this._updateHeight(); | |
| } else { | |
| this.keyupTimeout = this._delay( "_updateHeight", delay ); | |
| } | |
| }, | |
| _timeout: function() { | |
| this._prepareHeightUpdate( this.options.keyupTimeoutBuffer ); | |
| }, | |
| _updateHeight: function() { | |
| var paddingTop, paddingBottom, paddingHeight, scrollHeight, clientHeight, | |
| borderTop, borderBottom, borderHeight, height, | |
| scrollTop = this.window.scrollTop(); | |
| this.keyupTimeout = 0; | |
| // IE8 textareas have the onpage property - others do not | |
| if ( !( "onpage" in this.element[ 0 ] ) ) { | |
| this.element.css({ | |
| "height": 0, | |
| "min-height": 0, | |
| "max-height": 0 | |
| }); | |
| } | |
| scrollHeight = this.element[ 0 ].scrollHeight; | |
| clientHeight = this.element[ 0 ].clientHeight; | |
| borderTop = parseFloat( this.element.css( "border-top-width" ) ); | |
| borderBottom = parseFloat( this.element.css( "border-bottom-width" ) ); | |
| borderHeight = borderTop + borderBottom; | |
| height = scrollHeight + borderHeight + 15; | |
| // Issue 6179: Padding is not included in scrollHeight and | |
| // clientHeight by Firefox if no scrollbar is visible. Because | |
| // textareas use the border-box box-sizing model, padding should be | |
| // included in the new (assigned) height. Because the height is set | |
| // to 0, clientHeight == 0 in Firefox. Therefore, we can use this to | |
| // check if padding must be added. | |
| if ( clientHeight === 0 ) { | |
| paddingTop = parseFloat( this.element.css( "padding-top" ) ); | |
| paddingBottom = parseFloat( this.element.css( "padding-bottom" ) ); | |
| paddingHeight = paddingTop + paddingBottom; | |
| height += paddingHeight; | |
| } | |
| this.element.css({ | |
| "height": height, | |
| "min-height": "", | |
| "max-height": "" | |
| }); | |
| this.window.scrollTop( scrollTop ); | |
| }, | |
| refresh: function() { | |
| if ( this.options.autogrow && this.isTextarea ) { | |
| this._updateHeight(); | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| this._super( options ); | |
| if ( options.autogrow !== undefined && this.isTextarea ) { | |
| if ( options.autogrow ) { | |
| this._autogrow(); | |
| } else { | |
| this._unbindAutogrow(); | |
| } | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.selectmenu", $.extend( { | |
| initSelector: "select:not( :jqmData(role='slider')):not( :jqmData(role='flipswitch') )", | |
| options: { | |
| theme: null, | |
| icon: "carat-d", | |
| iconpos: "right", | |
| inline: false, | |
| corners: true, | |
| shadow: true, | |
| iconshadow: false, /* TODO: Deprecated in 1.4, remove in 1.5. */ | |
| overlayTheme: null, | |
| dividerTheme: null, | |
| hidePlaceholderMenuItems: true, | |
| closeText: "Close", | |
| nativeMenu: true, | |
| // This option defaults to true on iOS devices. | |
| preventFocusZoom: /iPhone|iPad|iPod/.test( navigator.platform ) && navigator.userAgent.indexOf( "AppleWebKit" ) > -1, | |
| mini: false | |
| }, | |
| _button: function() { | |
| return $( "<div/>" ); | |
| }, | |
| _setDisabled: function( value ) { | |
| this.element.attr( "disabled", value ); | |
| this.button.attr( "aria-disabled", value ); | |
| return this._setOption( "disabled", value ); | |
| }, | |
| _focusButton : function() { | |
| var self = this; | |
| setTimeout( function() { | |
| self.button.focus(); | |
| }, 40); | |
| }, | |
| _selectOptions: function() { | |
| return this.select.find( "option" ); | |
| }, | |
| // setup items that are generally necessary for select menu extension | |
| _preExtension: function() { | |
| var inline = this.options.inline || this.element.jqmData( "inline" ), | |
| mini = this.options.mini || this.element.jqmData( "mini" ), | |
| classes = ""; | |
| // TODO: Post 1.1--once we have time to test thoroughly--any classes manually applied to the original element should be carried over to the enhanced element, with an `-enhanced` suffix. See https://github.com/jquery/jquery-mobile/issues/3577 | |
| /* if ( $el[0].className.length ) { | |
| classes = $el[0].className; | |
| } */ | |
| if ( !!~this.element[0].className.indexOf( "ui-btn-left" ) ) { | |
| classes = " ui-btn-left"; | |
| } | |
| if ( !!~this.element[0].className.indexOf( "ui-btn-right" ) ) { | |
| classes = " ui-btn-right"; | |
| } | |
| if ( inline ) { | |
| classes += " ui-btn-inline"; | |
| } | |
| if ( mini ) { | |
| classes += " ui-mini"; | |
| } | |
| this.select = this.element.removeClass( "ui-btn-left ui-btn-right" ).wrap( "<div class='ui-select" + classes + "'>" ); | |
| this.selectId = this.select.attr( "id" ) || ( "select-" + this.uuid ); | |
| this.buttonId = this.selectId + "-button"; | |
| this.label = $( "label[for='"+ this.selectId +"']" ); | |
| this.isMultiple = this.select[ 0 ].multiple; | |
| }, | |
| _destroy: function() { | |
| var wrapper = this.element.parents( ".ui-select" ); | |
| if ( wrapper.length > 0 ) { | |
| if ( wrapper.is( ".ui-btn-left, .ui-btn-right" ) ) { | |
| this.element.addClass( wrapper.hasClass( "ui-btn-left" ) ? "ui-btn-left" : "ui-btn-right" ); | |
| } | |
| this.element.insertAfter( wrapper ); | |
| wrapper.remove(); | |
| } | |
| }, | |
| _create: function() { | |
| this._preExtension(); | |
| this.button = this._button(); | |
| var self = this, | |
| options = this.options, | |
| iconpos = options.icon ? ( options.iconpos || this.select.jqmData( "iconpos" ) ) : false, | |
| button = this.button | |
| .insertBefore( this.select ) | |
| .attr( "id", this.buttonId ) | |
| .addClass( "ui-btn" + | |
| ( options.icon ? ( " ui-icon-" + options.icon + " ui-btn-icon-" + iconpos + | |
| ( options.iconshadow ? " ui-shadow-icon" : "" ) ) : "" ) + /* TODO: Remove in 1.5. */ | |
| ( options.theme ? " ui-btn-" + options.theme : "" ) + | |
| ( options.corners ? " ui-corner-all" : "" ) + | |
| ( options.shadow ? " ui-shadow" : "" ) ); | |
| this.setButtonText(); | |
| // Opera does not properly support opacity on select elements | |
| // In Mini, it hides the element, but not its text | |
| // On the desktop,it seems to do the opposite | |
| // for these reasons, using the nativeMenu option results in a full native select in Opera | |
| if ( options.nativeMenu && window.opera && window.opera.version ) { | |
| button.addClass( "ui-select-nativeonly" ); | |
| } | |
| // Add counter for multi selects | |
| if ( this.isMultiple ) { | |
| this.buttonCount = $( "<span>" ) | |
| .addClass( "ui-li-count ui-body-inherit" ) | |
| .hide() | |
| .appendTo( button.addClass( "ui-li-has-count" ) ); | |
| } | |
| // Disable if specified | |
| if ( options.disabled || this.element.attr( "disabled" )) { | |
| this.disable(); | |
| } | |
| // Events on native select | |
| this.select.change(function() { | |
| self.refresh(); | |
| if ( !!options.nativeMenu ) { | |
| this.blur(); | |
| } | |
| }); | |
| this._handleFormReset(); | |
| this._on( this.button, { | |
| keydown: "_handleKeydown" | |
| }); | |
| this.build(); | |
| }, | |
| build: function() { | |
| var self = this; | |
| this.select | |
| .appendTo( self.button ) | |
| .bind( "vmousedown", function() { | |
| // Add active class to button | |
| self.button.addClass( $.mobile.activeBtnClass ); | |
| }) | |
| .bind( "focus", function() { | |
| self.button.addClass( $.mobile.focusClass ); | |
| }) | |
| .bind( "blur", function() { | |
| self.button.removeClass( $.mobile.focusClass ); | |
| }) | |
| .bind( "focus vmouseover", function() { | |
| self.button.trigger( "vmouseover" ); | |
| }) | |
| .bind( "vmousemove", function() { | |
| // Remove active class on scroll/touchmove | |
| self.button.removeClass( $.mobile.activeBtnClass ); | |
| }) | |
| .bind( "change blur vmouseout", function() { | |
| self.button.trigger( "vmouseout" ) | |
| .removeClass( $.mobile.activeBtnClass ); | |
| }); | |
| // In many situations, iOS will zoom into the select upon tap, this prevents that from happening | |
| self.button.bind( "vmousedown", function() { | |
| if ( self.options.preventFocusZoom ) { | |
| $.mobile.zoom.disable( true ); | |
| } | |
| }); | |
| self.label.bind( "click focus", function() { | |
| if ( self.options.preventFocusZoom ) { | |
| $.mobile.zoom.disable( true ); | |
| } | |
| }); | |
| self.select.bind( "focus", function() { | |
| if ( self.options.preventFocusZoom ) { | |
| $.mobile.zoom.disable( true ); | |
| } | |
| }); | |
| self.button.bind( "mouseup", function() { | |
| if ( self.options.preventFocusZoom ) { | |
| setTimeout(function() { | |
| $.mobile.zoom.enable( true ); | |
| }, 0 ); | |
| } | |
| }); | |
| self.select.bind( "blur", function() { | |
| if ( self.options.preventFocusZoom ) { | |
| $.mobile.zoom.enable( true ); | |
| } | |
| }); | |
| }, | |
| selected: function() { | |
| return this._selectOptions().filter( ":selected" ); | |
| }, | |
| selectedIndices: function() { | |
| var self = this; | |
| return this.selected().map(function() { | |
| return self._selectOptions().index( this ); | |
| }).get(); | |
| }, | |
| setButtonText: function() { | |
| var self = this, | |
| selected = this.selected(), | |
| text = this.placeholder, | |
| span = $( document.createElement( "span" ) ); | |
| this.button.children( "span" ).not( ".ui-li-count" ).remove().end().end().prepend( (function() { | |
| if ( selected.length ) { | |
| text = selected.map(function() { | |
| return $( this ).text(); | |
| }).get().join( ", " ); | |
| } else { | |
| text = self.placeholder; | |
| } | |
| if ( text ) { | |
| span.text( text ); | |
| } else { | |
| // Set the contents to which we write as   to be XHTML compliant - see gh-6699 | |
| span.html( " " ); | |
| } | |
| // TODO possibly aggregate multiple select option classes | |
| return span | |
| .addClass( self.select.attr( "class" ) ) | |
| .addClass( selected.attr( "class" ) ) | |
| .removeClass( "ui-screen-hidden" ); | |
| })()); | |
| }, | |
| setButtonCount: function() { | |
| var selected = this.selected(); | |
| // multiple count inside button | |
| if ( this.isMultiple ) { | |
| this.buttonCount[ selected.length > 1 ? "show" : "hide" ]().text( selected.length ); | |
| } | |
| }, | |
| _handleKeydown: function( /* event */ ) { | |
| this._delay( "_refreshButton" ); | |
| }, | |
| _reset: function() { | |
| this.refresh(); | |
| }, | |
| _refreshButton: function() { | |
| this.setButtonText(); | |
| this.setButtonCount(); | |
| }, | |
| refresh: function() { | |
| this._refreshButton(); | |
| }, | |
| // open and close preserved in native selects | |
| // to simplify users code when looping over selects | |
| open: $.noop, | |
| close: $.noop, | |
| disable: function() { | |
| this._setDisabled( true ); | |
| this.button.addClass( "ui-state-disabled" ); | |
| }, | |
| enable: function() { | |
| this._setDisabled( false ); | |
| this.button.removeClass( "ui-state-disabled" ); | |
| } | |
| }, $.mobile.behaviors.formReset ) ); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.mobile.links = function( target ) { | |
| //links within content areas, tests included with page | |
| $( target ) | |
| .find( "a" ) | |
| .jqmEnhanceable() | |
| .filter( ":jqmData(rel='popup')[href][href!='']" ) | |
| .each( function() { | |
| // Accessibility info for popups | |
| var element = this, | |
| idref = element.getAttribute( "href" ).substring( 1 ); | |
| if ( idref ) { | |
| element.setAttribute( "aria-haspopup", true ); | |
| element.setAttribute( "aria-owns", idref ); | |
| element.setAttribute( "aria-expanded", false ); | |
| } | |
| }) | |
| .end() | |
| .not( ".ui-btn, :jqmData(role='none'), :jqmData(role='nojs')" ) | |
| .addClass( "ui-link" ); | |
| }; | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| function fitSegmentInsideSegment( windowSize, segmentSize, offset, desired ) { | |
| var returnValue = desired; | |
| if ( windowSize < segmentSize ) { | |
| // Center segment if it's bigger than the window | |
| returnValue = offset + ( windowSize - segmentSize ) / 2; | |
| } else { | |
| // Otherwise center it at the desired coordinate while keeping it completely inside the window | |
| returnValue = Math.min( Math.max( offset, desired - segmentSize / 2 ), offset + windowSize - segmentSize ); | |
| } | |
| return returnValue; | |
| } | |
| function getWindowCoordinates( theWindow ) { | |
| return { | |
| x: theWindow.scrollLeft(), | |
| y: theWindow.scrollTop(), | |
| cx: ( theWindow[ 0 ].innerWidth || theWindow.width() ), | |
| cy: ( theWindow[ 0 ].innerHeight || theWindow.height() ) | |
| }; | |
| } | |
| $.widget( "mobile.popup", { | |
| options: { | |
| wrapperClass: null, | |
| theme: null, | |
| overlayTheme: null, | |
| shadow: true, | |
| corners: true, | |
| transition: "none", | |
| positionTo: "origin", | |
| tolerance: null, | |
| closeLinkSelector: "a:jqmData(rel='back')", | |
| closeLinkEvents: "click.popup", | |
| navigateEvents: "navigate.popup", | |
| closeEvents: "navigate.popup pagebeforechange.popup", | |
| dismissible: true, | |
| enhanced: false, | |
| // NOTE Windows Phone 7 has a scroll position caching issue that | |
| // requires us to disable popup history management by default | |
| // https://github.com/jquery/jquery-mobile/issues/4784 | |
| // | |
| // NOTE this option is modified in _create! | |
| history: !$.mobile.browser.oldIE | |
| }, | |
| // When the user depresses the mouse/finger on an element inside the popup while the popup is | |
| // open, we ignore resize events for a short while. This prevents #6961. | |
| _handleDocumentVmousedown: function( theEvent ) { | |
| if ( this._isOpen && $.contains( this._ui.container[ 0 ], theEvent.target ) ) { | |
| this._ignoreResizeEvents(); | |
| } | |
| }, | |
| _create: function() { | |
| var theElement = this.element, | |
| myId = theElement.attr( "id" ), | |
| currentOptions = this.options; | |
| // We need to adjust the history option to be false if there's no AJAX nav. | |
| // We can't do it in the option declarations because those are run before | |
| // it is determined whether there shall be AJAX nav. | |
| currentOptions.history = currentOptions.history && $.mobile.ajaxEnabled && $.mobile.hashListeningEnabled; | |
| this._on( this.document, { | |
| "vmousedown": "_handleDocumentVmousedown" | |
| }); | |
| // Define instance variables | |
| $.extend( this, { | |
| _scrollTop: 0, | |
| _page: theElement.closest( ".ui-page" ), | |
| _ui: null, | |
| _fallbackTransition: "", | |
| _currentTransition: false, | |
| _prerequisites: null, | |
| _isOpen: false, | |
| _tolerance: null, | |
| _resizeData: null, | |
| _ignoreResizeTo: 0, | |
| _orientationchangeInProgress: false | |
| }); | |
| if ( this._page.length === 0 ) { | |
| this._page = $( "body" ); | |
| } | |
| if ( currentOptions.enhanced ) { | |
| this._ui = { | |
| container: theElement.parent(), | |
| screen: theElement.parent().prev(), | |
| placeholder: $( this.document[ 0 ].getElementById( myId + "-placeholder" ) ) | |
| }; | |
| } else { | |
| this._ui = this._enhance( theElement, myId ); | |
| this._applyTransition( currentOptions.transition ); | |
| } | |
| this | |
| ._setTolerance( currentOptions.tolerance ) | |
| ._ui.focusElement = this._ui.container; | |
| // Event handlers | |
| this._on( this._ui.screen, { "vclick": "_eatEventAndClose" } ); | |
| this._on( this.window, { | |
| orientationchange: $.proxy( this, "_handleWindowOrientationchange" ), | |
| resize: $.proxy( this, "_handleWindowResize" ), | |
| keyup: $.proxy( this, "_handleWindowKeyUp" ) | |
| }); | |
| this._on( this.document, { "focusin": "_handleDocumentFocusIn" } ); | |
| }, | |
| _enhance: function( theElement, myId ) { | |
| var currentOptions = this.options, | |
| wrapperClass = currentOptions.wrapperClass, | |
| ui = { | |
| screen: $( "<div class='ui-screen-hidden ui-popup-screen " + | |
| this._themeClassFromOption( "ui-overlay-", currentOptions.overlayTheme ) + "'></div>" ), | |
| placeholder: $( "<div style='display: none;'><!-- placeholder --></div>" ), | |
| container: $( "<div class='ui-popup-container ui-popup-hidden ui-popup-truncate" + | |
| ( wrapperClass ? ( " " + wrapperClass ) : "" ) + "'></div>" ) | |
| }, | |
| fragment = this.document[ 0 ].createDocumentFragment(); | |
| fragment.appendChild( ui.screen[ 0 ] ); | |
| fragment.appendChild( ui.container[ 0 ] ); | |
| if ( myId ) { | |
| ui.screen.attr( "id", myId + "-screen" ); | |
| ui.container.attr( "id", myId + "-popup" ); | |
| ui.placeholder | |
| .attr( "id", myId + "-placeholder" ) | |
| .html( "<!-- placeholder for " + myId + " -->" ); | |
| } | |
| // Apply the proto | |
| this._page[ 0 ].appendChild( fragment ); | |
| // Leave a placeholder where the element used to be | |
| ui.placeholder.insertAfter( theElement ); | |
| theElement | |
| .detach() | |
| .addClass( "ui-popup " + | |
| this._themeClassFromOption( "ui-body-", currentOptions.theme ) + " " + | |
| ( currentOptions.shadow ? "ui-overlay-shadow " : "" ) + | |
| ( currentOptions.corners ? "ui-corner-all " : "" ) ) | |
| .appendTo( ui.container ); | |
| return ui; | |
| }, | |
| _eatEventAndClose: function( theEvent ) { | |
| theEvent.preventDefault(); | |
| theEvent.stopImmediatePropagation(); | |
| if ( this.options.dismissible ) { | |
| this.close(); | |
| } | |
| return false; | |
| }, | |
| // Make sure the screen covers the entire document - CSS is sometimes not | |
| // enough to accomplish this. | |
| _resizeScreen: function() { | |
| var screen = this._ui.screen, | |
| popupHeight = this._ui.container.outerHeight( true ), | |
| screenHeight = screen.removeAttr( "style" ).height(), | |
| // Subtracting 1 here is necessary for an obscure Andrdoid 4.0 bug where | |
| // the browser hangs if the screen covers the entire document :/ | |
| documentHeight = this.document.height() - 1; | |
| if ( screenHeight < documentHeight ) { | |
| screen.height( documentHeight ); | |
| } else if ( popupHeight > screenHeight ) { | |
| screen.height( popupHeight ); | |
| } | |
| }, | |
| _handleWindowKeyUp: function( theEvent ) { | |
| if ( this._isOpen && theEvent.keyCode === $.mobile.keyCode.ESCAPE ) { | |
| return this._eatEventAndClose( theEvent ); | |
| } | |
| }, | |
| _expectResizeEvent: function() { | |
| var windowCoordinates = getWindowCoordinates( this.window ); | |
| if ( this._resizeData ) { | |
| if ( windowCoordinates.x === this._resizeData.windowCoordinates.x && | |
| windowCoordinates.y === this._resizeData.windowCoordinates.y && | |
| windowCoordinates.cx === this._resizeData.windowCoordinates.cx && | |
| windowCoordinates.cy === this._resizeData.windowCoordinates.cy ) { | |
| // timeout not refreshed | |
| return false; | |
| } else { | |
| // clear existing timeout - it will be refreshed below | |
| clearTimeout( this._resizeData.timeoutId ); | |
| } | |
| } | |
| this._resizeData = { | |
| timeoutId: this._delay( "_resizeTimeout", 200 ), | |
| windowCoordinates: windowCoordinates | |
| }; | |
| return true; | |
| }, | |
| _resizeTimeout: function() { | |
| if ( this._isOpen ) { | |
| if ( !this._expectResizeEvent() ) { | |
| if ( this._ui.container.hasClass( "ui-popup-hidden" ) ) { | |
| // effectively rapid-open the popup while leaving the screen intact | |
| this._ui.container.removeClass( "ui-popup-hidden ui-popup-truncate" ); | |
| this.reposition( { positionTo: "window" } ); | |
| this._ignoreResizeEvents(); | |
| } | |
| this._resizeScreen(); | |
| this._resizeData = null; | |
| this._orientationchangeInProgress = false; | |
| } | |
| } else { | |
| this._resizeData = null; | |
| this._orientationchangeInProgress = false; | |
| } | |
| }, | |
| _stopIgnoringResizeEvents: function() { | |
| this._ignoreResizeTo = 0; | |
| }, | |
| _ignoreResizeEvents: function() { | |
| if ( this._ignoreResizeTo ) { | |
| clearTimeout( this._ignoreResizeTo ); | |
| } | |
| this._ignoreResizeTo = this._delay( "_stopIgnoringResizeEvents", 1000 ); | |
| }, | |
| _handleWindowResize: function(/* theEvent */) { | |
| if ( this._isOpen && this._ignoreResizeTo === 0 ) { | |
| if ( ( this._expectResizeEvent() || this._orientationchangeInProgress ) && | |
| !this._ui.container.hasClass( "ui-popup-hidden" ) ) { | |
| // effectively rapid-close the popup while leaving the screen intact | |
| this._ui.container | |
| .addClass( "ui-popup-hidden ui-popup-truncate" ) | |
| .removeAttr( "style" ); | |
| } | |
| } | |
| }, | |
| _handleWindowOrientationchange: function(/* theEvent */) { | |
| if ( !this._orientationchangeInProgress && this._isOpen && this._ignoreResizeTo === 0 ) { | |
| this._expectResizeEvent(); | |
| this._orientationchangeInProgress = true; | |
| } | |
| }, | |
| // When the popup is open, attempting to focus on an element that is not a | |
| // child of the popup will redirect focus to the popup | |
| _handleDocumentFocusIn: function( theEvent ) { | |
| var target, | |
| targetElement = theEvent.target, | |
| ui = this._ui; | |
| if ( !this._isOpen ) { | |
| return; | |
| } | |
| if ( targetElement !== ui.container[ 0 ] ) { | |
| target = $( targetElement ); | |
| if ( 0 === target.parents().filter( ui.container[ 0 ] ).length ) { | |
| $( this.document[ 0 ].activeElement ).one( "focus", function(/* theEvent */) { | |
| target.blur(); | |
| }); | |
| ui.focusElement.focus(); | |
| theEvent.preventDefault(); | |
| theEvent.stopImmediatePropagation(); | |
| return false; | |
| } else if ( ui.focusElement[ 0 ] === ui.container[ 0 ] ) { | |
| ui.focusElement = target; | |
| } | |
| } | |
| this._ignoreResizeEvents(); | |
| }, | |
| _themeClassFromOption: function( prefix, value ) { | |
| return ( value ? ( value === "none" ? "" : ( prefix + value ) ) : ( prefix + "inherit" ) ); | |
| }, | |
| _applyTransition: function( value ) { | |
| if ( value ) { | |
| this._ui.container.removeClass( this._fallbackTransition ); | |
| if ( value !== "none" ) { | |
| this._fallbackTransition = $.mobile._maybeDegradeTransition( value ); | |
| if ( this._fallbackTransition === "none" ) { | |
| this._fallbackTransition = ""; | |
| } | |
| this._ui.container.addClass( this._fallbackTransition ); | |
| } | |
| } | |
| return this; | |
| }, | |
| _setOptions: function( newOptions ) { | |
| var currentOptions = this.options, | |
| theElement = this.element, | |
| screen = this._ui.screen; | |
| if ( newOptions.wrapperClass !== undefined ) { | |
| this._ui.container | |
| .removeClass( currentOptions.wrapperClass ) | |
| .addClass( newOptions.wrapperClass ); | |
| } | |
| if ( newOptions.theme !== undefined ) { | |
| theElement | |
| .removeClass( this._themeClassFromOption( "ui-body-", currentOptions.theme ) ) | |
| .addClass( this._themeClassFromOption( "ui-body-", newOptions.theme ) ); | |
| } | |
| if ( newOptions.overlayTheme !== undefined ) { | |
| screen | |
| .removeClass( this._themeClassFromOption( "ui-overlay-", currentOptions.overlayTheme ) ) | |
| .addClass( this._themeClassFromOption( "ui-overlay-", newOptions.overlayTheme ) ); | |
| if ( this._isOpen ) { | |
| screen.addClass( "in" ); | |
| } | |
| } | |
| if ( newOptions.shadow !== undefined ) { | |
| theElement.toggleClass( "ui-overlay-shadow", newOptions.shadow ); | |
| } | |
| if ( newOptions.corners !== undefined ) { | |
| theElement.toggleClass( "ui-corner-all", newOptions.corners ); | |
| } | |
| if ( newOptions.transition !== undefined ) { | |
| if ( !this._currentTransition ) { | |
| this._applyTransition( newOptions.transition ); | |
| } | |
| } | |
| if ( newOptions.tolerance !== undefined ) { | |
| this._setTolerance( newOptions.tolerance ); | |
| } | |
| if ( newOptions.disabled !== undefined ) { | |
| if ( newOptions.disabled ) { | |
| this.close(); | |
| } | |
| } | |
| return this._super( newOptions ); | |
| }, | |
| _setTolerance: function( value ) { | |
| var tol = { t: 30, r: 15, b: 30, l: 15 }, | |
| ar; | |
| if ( value !== undefined ) { | |
| ar = String( value ).split( "," ); | |
| $.each( ar, function( idx, val ) { ar[ idx ] = parseInt( val, 10 ); } ); | |
| switch( ar.length ) { | |
| // All values are to be the same | |
| case 1: | |
| if ( !isNaN( ar[ 0 ] ) ) { | |
| tol.t = tol.r = tol.b = tol.l = ar[ 0 ]; | |
| } | |
| break; | |
| // The first value denotes top/bottom tolerance, and the second value denotes left/right tolerance | |
| case 2: | |
| if ( !isNaN( ar[ 0 ] ) ) { | |
| tol.t = tol.b = ar[ 0 ]; | |
| } | |
| if ( !isNaN( ar[ 1 ] ) ) { | |
| tol.l = tol.r = ar[ 1 ]; | |
| } | |
| break; | |
| // The array contains values in the order top, right, bottom, left | |
| case 4: | |
| if ( !isNaN( ar[ 0 ] ) ) { | |
| tol.t = ar[ 0 ]; | |
| } | |
| if ( !isNaN( ar[ 1 ] ) ) { | |
| tol.r = ar[ 1 ]; | |
| } | |
| if ( !isNaN( ar[ 2 ] ) ) { | |
| tol.b = ar[ 2 ]; | |
| } | |
| if ( !isNaN( ar[ 3 ] ) ) { | |
| tol.l = ar[ 3 ]; | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| this._tolerance = tol; | |
| return this; | |
| }, | |
| _clampPopupWidth: function( infoOnly ) { | |
| var menuSize, | |
| windowCoordinates = getWindowCoordinates( this.window ), | |
| // rectangle within which the popup must fit | |
| rectangle = { | |
| x: this._tolerance.l, | |
| y: windowCoordinates.y + this._tolerance.t, | |
| cx: windowCoordinates.cx - this._tolerance.l - this._tolerance.r, | |
| cy: windowCoordinates.cy - this._tolerance.t - this._tolerance.b | |
| }; | |
| if ( !infoOnly ) { | |
| // Clamp the width of the menu before grabbing its size | |
| this._ui.container.css( "max-width", rectangle.cx ); | |
| } | |
| menuSize = { | |
| cx: this._ui.container.outerWidth( true ), | |
| cy: this._ui.container.outerHeight( true ) | |
| }; | |
| return { rc: rectangle, menuSize: menuSize }; | |
| }, | |
| _calculateFinalLocation: function( desired, clampInfo ) { | |
| var returnValue, | |
| rectangle = clampInfo.rc, | |
| menuSize = clampInfo.menuSize; | |
| // Center the menu over the desired coordinates, while not going outside | |
| // the window tolerances. This will center wrt. the window if the popup is | |
| // too large. | |
| returnValue = { | |
| left: fitSegmentInsideSegment( rectangle.cx, menuSize.cx, rectangle.x, desired.x ), | |
| top: fitSegmentInsideSegment( rectangle.cy, menuSize.cy, rectangle.y, desired.y ) | |
| }; | |
| // Make sure the top of the menu is visible | |
| returnValue.top = Math.max( 0, returnValue.top ); | |
| // If the height of the menu is smaller than the height of the document | |
| // align the bottom with the bottom of the document | |
| returnValue.top -= Math.min( returnValue.top, | |
| Math.max( 0, returnValue.top + menuSize.cy - this.document.height() ) ); | |
| return returnValue; | |
| }, | |
| // Try and center the overlay over the given coordinates | |
| _placementCoords: function( desired ) { | |
| return this._calculateFinalLocation( desired, this._clampPopupWidth() ); | |
| }, | |
| _createPrerequisites: function( screenPrerequisite, containerPrerequisite, whenDone ) { | |
| var prerequisites, | |
| self = this; | |
| // It is important to maintain both the local variable prerequisites and | |
| // self._prerequisites. The local variable remains in the closure of the | |
| // functions which call the callbacks passed in. The comparison between the | |
| // local variable and self._prerequisites is necessary, because once a | |
| // function has been passed to .animationComplete() it will be called next | |
| // time an animation completes, even if that's not the animation whose end | |
| // the function was supposed to catch (for example, if an abort happens | |
| // during the opening animation, the .animationComplete handler is not | |
| // called for that animation anymore, but the handler remains attached, so | |
| // it is called the next time the popup is opened - making it stale. | |
| // Comparing the local variable prerequisites to the widget-level variable | |
| // self._prerequisites ensures that callbacks triggered by a stale | |
| // .animationComplete will be ignored. | |
| prerequisites = { | |
| screen: $.Deferred(), | |
| container: $.Deferred() | |
| }; | |
| prerequisites.screen.then( function() { | |
| if ( prerequisites === self._prerequisites ) { | |
| screenPrerequisite(); | |
| } | |
| }); | |
| prerequisites.container.then( function() { | |
| if ( prerequisites === self._prerequisites ) { | |
| containerPrerequisite(); | |
| } | |
| }); | |
| $.when( prerequisites.screen, prerequisites.container ).done( function() { | |
| if ( prerequisites === self._prerequisites ) { | |
| self._prerequisites = null; | |
| whenDone(); | |
| } | |
| }); | |
| self._prerequisites = prerequisites; | |
| }, | |
| _animate: function( args ) { | |
| // NOTE before removing the default animation of the screen | |
| // this had an animate callback that would resolve the deferred | |
| // now the deferred is resolved immediately | |
| // TODO remove the dependency on the screen deferred | |
| this._ui.screen | |
| .removeClass( args.classToRemove ) | |
| .addClass( args.screenClassToAdd ); | |
| args.prerequisites.screen.resolve(); | |
| if ( args.transition && args.transition !== "none" ) { | |
| if ( args.applyTransition ) { | |
| this._applyTransition( args.transition ); | |
| } | |
| if ( this._fallbackTransition ) { | |
| this._ui.container | |
| .addClass( args.containerClassToAdd ) | |
| .removeClass( args.classToRemove ) | |
| .animationComplete( $.proxy( args.prerequisites.container, "resolve" ) ); | |
| return; | |
| } | |
| } | |
| this._ui.container.removeClass( args.classToRemove ); | |
| args.prerequisites.container.resolve(); | |
| }, | |
| // The desired coordinates passed in will be returned untouched if no reference element can be identified via | |
| // desiredPosition.positionTo. Nevertheless, this function ensures that its return value always contains valid | |
| // x and y coordinates by specifying the center middle of the window if the coordinates are absent. | |
| // options: { x: coordinate, y: coordinate, positionTo: string: "origin", "window", or jQuery selector | |
| _desiredCoords: function( openOptions ) { | |
| var offset, | |
| dst = null, | |
| windowCoordinates = getWindowCoordinates( this.window ), | |
| x = openOptions.x, | |
| y = openOptions.y, | |
| pTo = openOptions.positionTo; | |
| // Establish which element will serve as the reference | |
| if ( pTo && pTo !== "origin" ) { | |
| if ( pTo === "window" ) { | |
| x = windowCoordinates.cx / 2 + windowCoordinates.x; | |
| y = windowCoordinates.cy / 2 + windowCoordinates.y; | |
| } else { | |
| try { | |
| dst = $( pTo ); | |
| } catch( err ) { | |
| dst = null; | |
| } | |
| if ( dst ) { | |
| dst.filter( ":visible" ); | |
| if ( dst.length === 0 ) { | |
| dst = null; | |
| } | |
| } | |
| } | |
| } | |
| // If an element was found, center over it | |
| if ( dst ) { | |
| offset = dst.offset(); | |
| x = offset.left + dst.outerWidth() / 2; | |
| y = offset.top + dst.outerHeight() / 2; | |
| } | |
| // Make sure x and y are valid numbers - center over the window | |
| if ( $.type( x ) !== "number" || isNaN( x ) ) { | |
| x = windowCoordinates.cx / 2 + windowCoordinates.x; | |
| } | |
| if ( $.type( y ) !== "number" || isNaN( y ) ) { | |
| y = windowCoordinates.cy / 2 + windowCoordinates.y; | |
| } | |
| return { x: x, y: y }; | |
| }, | |
| _reposition: function( openOptions ) { | |
| // We only care about position-related parameters for repositioning | |
| openOptions = { | |
| x: openOptions.x, | |
| y: openOptions.y, | |
| positionTo: openOptions.positionTo | |
| }; | |
| this._trigger( "beforeposition", undefined, openOptions ); | |
| this._ui.container.offset( this._placementCoords( this._desiredCoords( openOptions ) ) ); | |
| }, | |
| reposition: function( openOptions ) { | |
| if ( this._isOpen ) { | |
| this._reposition( openOptions ); | |
| } | |
| }, | |
| _openPrerequisitesComplete: function() { | |
| var id = this.element.attr( "id" ); | |
| this._ui.container.addClass( "ui-popup-active" ); | |
| this._isOpen = true; | |
| this._resizeScreen(); | |
| this._ui.container.attr( "tabindex", "0" ).focus(); | |
| this._ignoreResizeEvents(); | |
| if ( id ) { | |
| this.document.find( "[aria-haspopup='true'][aria-owns='" + id + "']" ).attr( "aria-expanded", true ); | |
| } | |
| this._trigger( "afteropen" ); | |
| }, | |
| _open: function( options ) { | |
| var openOptions = $.extend( {}, this.options, options ), | |
| // TODO move blacklist to private method | |
| androidBlacklist = ( function() { | |
| var ua = navigator.userAgent, | |
| // Rendering engine is Webkit, and capture major version | |
| wkmatch = ua.match( /AppleWebKit\/([0-9\.]+)/ ), | |
| wkversion = !!wkmatch && wkmatch[ 1 ], | |
| androidmatch = ua.match( /Android (\d+(?:\.\d+))/ ), | |
| andversion = !!androidmatch && androidmatch[ 1 ], | |
| chromematch = ua.indexOf( "Chrome" ) > -1; | |
| // Platform is Android, WebKit version is greater than 534.13 ( Android 3.2.1 ) and not Chrome. | |
| if ( androidmatch !== null && andversion === "4.0" && wkversion && wkversion > 534.13 && !chromematch ) { | |
| return true; | |
| } | |
| return false; | |
| }()); | |
| // Count down to triggering "popupafteropen" - we have two prerequisites: | |
| // 1. The popup window animation completes (container()) | |
| // 2. The screen opacity animation completes (screen()) | |
| this._createPrerequisites( | |
| $.noop, | |
| $.noop, | |
| $.proxy( this, "_openPrerequisitesComplete" ) ); | |
| this._currentTransition = openOptions.transition; | |
| this._applyTransition( openOptions.transition ); | |
| this._ui.screen.removeClass( "ui-screen-hidden" ); | |
| this._ui.container.removeClass( "ui-popup-truncate" ); | |
| // Give applications a chance to modify the contents of the container before it appears | |
| this._reposition( openOptions ); | |
| this._ui.container.removeClass( "ui-popup-hidden" ); | |
| if ( this.options.overlayTheme && androidBlacklist ) { | |
| /* TODO: The native browser on Android 4.0.X ("Ice Cream Sandwich") suffers from an issue where the popup overlay appears to be z-indexed above the popup itself when certain other styles exist on the same page -- namely, any element set to `position: fixed` and certain types of input. These issues are reminiscent of previously uncovered bugs in older versions of Android's native browser: https://github.com/scottjehl/Device-Bugs/issues/3 | |
| This fix closes the following bugs ( I use "closes" with reluctance, and stress that this issue should be revisited as soon as possible ): | |
| https://github.com/jquery/jquery-mobile/issues/4816 | |
| https://github.com/jquery/jquery-mobile/issues/4844 | |
| https://github.com/jquery/jquery-mobile/issues/4874 | |
| */ | |
| // TODO sort out why this._page isn't working | |
| this.element.closest( ".ui-page" ).addClass( "ui-popup-open" ); | |
| } | |
| this._animate({ | |
| additionalCondition: true, | |
| transition: openOptions.transition, | |
| classToRemove: "", | |
| screenClassToAdd: "in", | |
| containerClassToAdd: "in", | |
| applyTransition: false, | |
| prerequisites: this._prerequisites | |
| }); | |
| }, | |
| _closePrerequisiteScreen: function() { | |
| this._ui.screen | |
| .removeClass( "out" ) | |
| .addClass( "ui-screen-hidden" ); | |
| }, | |
| _closePrerequisiteContainer: function() { | |
| this._ui.container | |
| .removeClass( "reverse out" ) | |
| .addClass( "ui-popup-hidden ui-popup-truncate" ) | |
| .removeAttr( "style" ); | |
| }, | |
| _closePrerequisitesDone: function() { | |
| var container = this._ui.container, | |
| id = this.element.attr( "id" ); | |
| container.removeAttr( "tabindex" ); | |
| // remove the global mutex for popups | |
| $.mobile.popup.active = undefined; | |
| // Blur elements inside the container, including the container | |
| $( ":focus", container[ 0 ] ).add( container[ 0 ] ).blur(); | |
| if ( id ) { | |
| this.document.find( "[aria-haspopup='true'][aria-owns='" + id + "']" ).attr( "aria-expanded", false ); | |
| } | |
| // alert users that the popup is closed | |
| this._trigger( "afterclose" ); | |
| }, | |
| _close: function( immediate ) { | |
| this._ui.container.removeClass( "ui-popup-active" ); | |
| this._page.removeClass( "ui-popup-open" ); | |
| this._isOpen = false; | |
| // Count down to triggering "popupafterclose" - we have two prerequisites: | |
| // 1. The popup window reverse animation completes (container()) | |
| // 2. The screen opacity animation completes (screen()) | |
| this._createPrerequisites( | |
| $.proxy( this, "_closePrerequisiteScreen" ), | |
| $.proxy( this, "_closePrerequisiteContainer" ), | |
| $.proxy( this, "_closePrerequisitesDone" ) ); | |
| this._animate( { | |
| additionalCondition: this._ui.screen.hasClass( "in" ), | |
| transition: ( immediate ? "none" : ( this._currentTransition ) ), | |
| classToRemove: "in", | |
| screenClassToAdd: "out", | |
| containerClassToAdd: "reverse out", | |
| applyTransition: true, | |
| prerequisites: this._prerequisites | |
| }); | |
| }, | |
| _unenhance: function() { | |
| if ( this.options.enhanced ) { | |
| return; | |
| } | |
| // Put the element back to where the placeholder was and remove the "ui-popup" class | |
| this._setOptions( { theme: $.mobile.popup.prototype.options.theme } ); | |
| this.element | |
| // Cannot directly insertAfter() - we need to detach() first, because | |
| // insertAfter() will do nothing if the payload div was not attached | |
| // to the DOM at the time the widget was created, and so the payload | |
| // will remain inside the container even after we call insertAfter(). | |
| // If that happens and we remove the container a few lines below, we | |
| // will cause an infinite recursion - #5244 | |
| .detach() | |
| .insertAfter( this._ui.placeholder ) | |
| .removeClass( "ui-popup ui-overlay-shadow ui-corner-all ui-body-inherit" ); | |
| this._ui.screen.remove(); | |
| this._ui.container.remove(); | |
| this._ui.placeholder.remove(); | |
| }, | |
| _destroy: function() { | |
| if ( $.mobile.popup.active === this ) { | |
| this.element.one( "popupafterclose", $.proxy( this, "_unenhance" ) ); | |
| this.close(); | |
| } else { | |
| this._unenhance(); | |
| } | |
| return this; | |
| }, | |
| _closePopup: function( theEvent, data ) { | |
| var parsedDst, toUrl, | |
| currentOptions = this.options, | |
| immediate = false; | |
| if ( ( theEvent && theEvent.isDefaultPrevented() ) || $.mobile.popup.active !== this ) { | |
| return; | |
| } | |
| // restore location on screen | |
| window.scrollTo( 0, this._scrollTop ); | |
| if ( theEvent && theEvent.type === "pagebeforechange" && data ) { | |
| // Determine whether we need to rapid-close the popup, or whether we can | |
| // take the time to run the closing transition | |
| if ( typeof data.toPage === "string" ) { | |
| parsedDst = data.toPage; | |
| } else { | |
| parsedDst = data.toPage.jqmData( "url" ); | |
| } | |
| parsedDst = $.mobile.path.parseUrl( parsedDst ); | |
| toUrl = parsedDst.pathname + parsedDst.search + parsedDst.hash; | |
| if ( this._myUrl !== $.mobile.path.makeUrlAbsolute( toUrl ) ) { | |
| // Going to a different page - close immediately | |
| immediate = true; | |
| } else { | |
| theEvent.preventDefault(); | |
| } | |
| } | |
| // remove nav bindings | |
| this.window.off( currentOptions.closeEvents ); | |
| // unbind click handlers added when history is disabled | |
| this.element.undelegate( currentOptions.closeLinkSelector, currentOptions.closeLinkEvents ); | |
| this._close( immediate ); | |
| }, | |
| // any navigation event after a popup is opened should close the popup | |
| // NOTE the pagebeforechange is bound to catch navigation events that don't | |
| // alter the url (eg, dialogs from popups) | |
| _bindContainerClose: function() { | |
| this.window | |
| .on( this.options.closeEvents, $.proxy( this, "_closePopup" ) ); | |
| }, | |
| widget: function() { | |
| return this._ui.container; | |
| }, | |
| // TODO no clear deliniation of what should be here and | |
| // what should be in _open. Seems to be "visual" vs "history" for now | |
| open: function( options ) { | |
| var url, hashkey, activePage, currentIsDialog, hasHash, urlHistory, | |
| self = this, | |
| currentOptions = this.options; | |
| // make sure open is idempotent | |
| if ( $.mobile.popup.active || currentOptions.disabled ) { | |
| return this; | |
| } | |
| // set the global popup mutex | |
| $.mobile.popup.active = this; | |
| this._scrollTop = this.window.scrollTop(); | |
| // if history alteration is disabled close on navigate events | |
| // and leave the url as is | |
| if ( !( currentOptions.history ) ) { | |
| self._open( options ); | |
| self._bindContainerClose(); | |
| // When histoy is disabled we have to grab the data-rel | |
| // back link clicks so we can close the popup instead of | |
| // relying on history to do it for us | |
| self.element | |
| .delegate( currentOptions.closeLinkSelector, currentOptions.closeLinkEvents, function( theEvent ) { | |
| self.close(); | |
| theEvent.preventDefault(); | |
| }); | |
| return this; | |
| } | |
| // cache some values for min/readability | |
| urlHistory = $.mobile.navigate.history; | |
| hashkey = $.mobile.dialogHashKey; | |
| activePage = $.mobile.activePage; | |
| currentIsDialog = ( activePage ? activePage.hasClass( "ui-dialog" ) : false ); | |
| this._myUrl = url = urlHistory.getActive().url; | |
| hasHash = ( url.indexOf( hashkey ) > -1 ) && !currentIsDialog && ( urlHistory.activeIndex > 0 ); | |
| if ( hasHash ) { | |
| self._open( options ); | |
| self._bindContainerClose(); | |
| return this; | |
| } | |
| // if the current url has no dialog hash key proceed as normal | |
| // otherwise, if the page is a dialog simply tack on the hash key | |
| if ( url.indexOf( hashkey ) === -1 && !currentIsDialog ) { | |
| url = url + (url.indexOf( "#" ) > -1 ? hashkey : "#" + hashkey); | |
| } else { | |
| url = $.mobile.path.parseLocation().hash + hashkey; | |
| } | |
| // Tack on an extra hashkey if this is the first page and we've just reconstructed the initial hash | |
| if ( urlHistory.activeIndex === 0 && url === urlHistory.initialDst ) { | |
| url += hashkey; | |
| } | |
| // swallow the the initial navigation event, and bind for the next | |
| this.window.one( "beforenavigate", function( theEvent ) { | |
| theEvent.preventDefault(); | |
| self._open( options ); | |
| self._bindContainerClose(); | |
| }); | |
| this.urlAltered = true; | |
| $.mobile.navigate( url, { role: "dialog" } ); | |
| return this; | |
| }, | |
| close: function() { | |
| // make sure close is idempotent | |
| if ( $.mobile.popup.active !== this ) { | |
| return this; | |
| } | |
| this._scrollTop = this.window.scrollTop(); | |
| if ( this.options.history && this.urlAltered ) { | |
| $.mobile.back(); | |
| this.urlAltered = false; | |
| } else { | |
| // simulate the nav bindings having fired | |
| this._closePopup(); | |
| } | |
| return this; | |
| } | |
| }); | |
| // TODO this can be moved inside the widget | |
| $.mobile.popup.handleLink = function( $link ) { | |
| var offset, | |
| path = $.mobile.path, | |
| // NOTE make sure to get only the hash from the href because ie7 (wp7) | |
| // returns the absolute href in this case ruining the element selection | |
| popup = $( path.hashToSelector( path.parseUrl( $link.attr( "href" ) ).hash ) ).first(); | |
| if ( popup.length > 0 && popup.data( "mobile-popup" ) ) { | |
| offset = $link.offset(); | |
| popup.popup( "open", { | |
| x: offset.left + $link.outerWidth() / 2, | |
| y: offset.top + $link.outerHeight() / 2, | |
| transition: $link.jqmData( "transition" ), | |
| positionTo: $link.jqmData( "position-to" ) | |
| }); | |
| } | |
| //remove after delay | |
| setTimeout( function() { | |
| $link.removeClass( $.mobile.activeBtnClass ); | |
| }, 300 ); | |
| }; | |
| // TODO move inside _create | |
| $.mobile.document.on( "pagebeforechange", function( theEvent, data ) { | |
| if ( data.options.role === "popup" ) { | |
| $.mobile.popup.handleLink( data.options.link ); | |
| theEvent.preventDefault(); | |
| } | |
| }); | |
| })( jQuery ); | |
| /* | |
| * custom "selectmenu" plugin | |
| */ | |
| (function( $, undefined ) { | |
| var unfocusableItemSelector = ".ui-disabled,.ui-state-disabled,.ui-li-divider,.ui-screen-hidden,:jqmData(role='placeholder')", | |
| goToAdjacentItem = function( item, target, direction ) { | |
| var adjacent = item[ direction + "All" ]() | |
| .not( unfocusableItemSelector ) | |
| .first(); | |
| // if there's a previous option, focus it | |
| if ( adjacent.length ) { | |
| target | |
| .blur() | |
| .attr( "tabindex", "-1" ); | |
| adjacent.find( "a" ).first().focus(); | |
| } | |
| }; | |
| $.widget( "mobile.selectmenu", $.mobile.selectmenu, { | |
| _create: function() { | |
| var o = this.options; | |
| // Custom selects cannot exist inside popups, so revert the "nativeMenu" | |
| // option to true if a parent is a popup | |
| o.nativeMenu = o.nativeMenu || ( this.element.parents( ":jqmData(role='popup'),:mobile-popup" ).length > 0 ); | |
| return this._super(); | |
| }, | |
| _handleSelectFocus: function() { | |
| this.element.blur(); | |
| this.button.focus(); | |
| }, | |
| _handleKeydown: function( event ) { | |
| this._super( event ); | |
| this._handleButtonVclickKeydown( event ); | |
| }, | |
| _handleButtonVclickKeydown: function( event ) { | |
| if ( this.options.disabled || this.isOpen || this.options.nativeMenu ) { | |
| return; | |
| } | |
| if (event.type === "vclick" || | |
| event.keyCode && (event.keyCode === $.mobile.keyCode.ENTER || event.keyCode === $.mobile.keyCode.SPACE)) { | |
| this._decideFormat(); | |
| if ( this.menuType === "overlay" ) { | |
| this.button.attr( "href", "#" + this.popupId ).attr( "data-" + ( $.mobile.ns || "" ) + "rel", "popup" ); | |
| } else { | |
| this.button.attr( "href", "#" + this.dialogId ).attr( "data-" + ( $.mobile.ns || "" ) + "rel", "dialog" ); | |
| } | |
| this.isOpen = true; | |
| // Do not prevent default, so the navigation may have a chance to actually open the chosen format | |
| } | |
| }, | |
| _handleListFocus: function( e ) { | |
| var params = ( e.type === "focusin" ) ? | |
| { tabindex: "0", event: "vmouseover" }: | |
| { tabindex: "-1", event: "vmouseout" }; | |
| $( e.target ) | |
| .attr( "tabindex", params.tabindex ) | |
| .trigger( params.event ); | |
| }, | |
| _handleListKeydown: function( event ) { | |
| var target = $( event.target ), | |
| li = target.closest( "li" ); | |
| // switch logic based on which key was pressed | |
| switch ( event.keyCode ) { | |
| // up or left arrow keys | |
| case 38: | |
| goToAdjacentItem( li, target, "prev" ); | |
| return false; | |
| // down or right arrow keys | |
| case 40: | |
| goToAdjacentItem( li, target, "next" ); | |
| return false; | |
| // If enter or space is pressed, trigger click | |
| case 13: | |
| case 32: | |
| target.trigger( "click" ); | |
| return false; | |
| } | |
| }, | |
| _handleMenuPageHide: function() { | |
| // After the dialog's done, we may want to trigger change if the value has actually changed | |
| this._delayedTrigger(); | |
| // TODO centralize page removal binding / handling in the page plugin. | |
| // Suggestion from @jblas to do refcounting | |
| // | |
| // TODO extremely confusing dependency on the open method where the pagehide.remove | |
| // bindings are stripped to prevent the parent page from disappearing. The way | |
| // we're keeping pages in the DOM right now sucks | |
| // | |
| // rebind the page remove that was unbound in the open function | |
| // to allow for the parent page removal from actions other than the use | |
| // of a dialog sized custom select | |
| // | |
| // doing this here provides for the back button on the custom select dialog | |
| this.thisPage.page( "bindRemove" ); | |
| }, | |
| _handleHeaderCloseClick: function() { | |
| if ( this.menuType === "overlay" ) { | |
| this.close(); | |
| return false; | |
| } | |
| }, | |
| _handleListItemClick: function( event ) { | |
| var listItem = $( event.target ).closest( "li" ), | |
| // Index of option tag to be selected | |
| oldIndex = this.select[ 0 ].selectedIndex, | |
| newIndex = $.mobile.getAttribute( listItem, "option-index" ), | |
| option = this._selectOptions().eq( newIndex )[ 0 ]; | |
| // Toggle selected status on the tag for multi selects | |
| option.selected = this.isMultiple ? !option.selected : true; | |
| // Toggle checkbox class for multiple selects | |
| if ( this.isMultiple ) { | |
| listItem.find( "a" ) | |
| .toggleClass( "ui-checkbox-on", option.selected ) | |
| .toggleClass( "ui-checkbox-off", !option.selected ); | |
| } | |
| // If it's not a multiple select, trigger change after it has finished closing | |
| if ( !this.isMultiple && oldIndex !== newIndex ) { | |
| this._triggerChange = true; | |
| } | |
| // Trigger change if it's a multiple select | |
| // Hide custom select for single selects only - otherwise focus clicked item | |
| // We need to grab the clicked item the hard way, because the list may have been rebuilt | |
| if ( this.isMultiple ) { | |
| this.select.trigger( "change" ); | |
| this.list.find( "li:not(.ui-li-divider)" ).eq( newIndex ) | |
| .find( "a" ).first().focus(); | |
| } | |
| else { | |
| this.close(); | |
| } | |
| event.preventDefault(); | |
| }, | |
| build: function() { | |
| var selectId, popupId, dialogId, label, thisPage, isMultiple, menuId, | |
| themeAttr, overlayTheme, overlayThemeAttr, dividerThemeAttr, | |
| menuPage, listbox, list, header, headerTitle, menuPageContent, | |
| menuPageClose, headerClose, | |
| o = this.options; | |
| if ( o.nativeMenu ) { | |
| return this._super(); | |
| } | |
| selectId = this.selectId; | |
| popupId = selectId + "-listbox"; | |
| dialogId = selectId + "-dialog"; | |
| label = this.label; | |
| thisPage = this.element.closest( ".ui-page" ); | |
| isMultiple = this.element[ 0 ].multiple; | |
| menuId = selectId + "-menu"; | |
| themeAttr = o.theme ? ( " data-" + $.mobile.ns + "theme='" + o.theme + "'" ) : ""; | |
| overlayTheme = o.overlayTheme || o.theme || null; | |
| overlayThemeAttr = overlayTheme ? ( " data-" + $.mobile.ns + | |
| "overlay-theme='" + overlayTheme + "'" ) : ""; | |
| dividerThemeAttr = ( o.dividerTheme && isMultiple ) ? ( " data-" + $.mobile.ns + "divider-theme='" + o.dividerTheme + "'" ) : ""; | |
| menuPage = $( "<div data-" + $.mobile.ns + "role='dialog' class='ui-selectmenu' id='" + dialogId + "'" + themeAttr + overlayThemeAttr + ">" + | |
| "<div data-" + $.mobile.ns + "role='header'>" + | |
| "<div class='ui-title'></div>"+ | |
| "</div>"+ | |
| "<div data-" + $.mobile.ns + "role='content'></div>"+ | |
| "</div>" ); | |
| listbox = $( "<div" + themeAttr + overlayThemeAttr + " id='" + popupId + | |
| "' class='ui-selectmenu'></div>" ) | |
| .insertAfter( this.select ) | |
| .popup(); | |
| list = $( "<ul class='ui-selectmenu-list' id='" + menuId + "' role='listbox' aria-labelledby='" + this.buttonId + "'" + themeAttr + dividerThemeAttr + "></ul>" ).appendTo( listbox ); | |
| header = $( "<div class='ui-header ui-bar-" + ( o.theme ? o.theme : "inherit" ) + "'></div>" ).prependTo( listbox ); | |
| headerTitle = $( "<h1 class='ui-title'></h1>" ).appendTo( header ); | |
| if ( this.isMultiple ) { | |
| headerClose = $( "<a>", { | |
| "role": "button", | |
| "text": o.closeText, | |
| "href": "#", | |
| "class": "ui-btn ui-corner-all ui-btn-left ui-btn-icon-notext ui-icon-delete" | |
| }).appendTo( header ); | |
| } | |
| $.extend( this, { | |
| selectId: selectId, | |
| menuId: menuId, | |
| popupId: popupId, | |
| dialogId: dialogId, | |
| thisPage: thisPage, | |
| menuPage: menuPage, | |
| label: label, | |
| isMultiple: isMultiple, | |
| theme: o.theme, | |
| listbox: listbox, | |
| list: list, | |
| header: header, | |
| headerTitle: headerTitle, | |
| headerClose: headerClose, | |
| menuPageContent: menuPageContent, | |
| menuPageClose: menuPageClose, | |
| placeholder: "" | |
| }); | |
| // Create list from select, update state | |
| this.refresh(); | |
| if ( this._origTabIndex === undefined ) { | |
| // Map undefined to false, because this._origTabIndex === undefined | |
| // indicates that we have not yet checked whether the select has | |
| // originally had a tabindex attribute, whereas false indicates that | |
| // we have checked the select for such an attribute, and have found | |
| // none present. | |
| this._origTabIndex = ( this.select[ 0 ].getAttribute( "tabindex" ) === null ) ? false : this.select.attr( "tabindex" ); | |
| } | |
| this.select.attr( "tabindex", "-1" ); | |
| this._on( this.select, { focus : "_handleSelectFocus" } ); | |
| // Button events | |
| this._on( this.button, { | |
| vclick: "_handleButtonVclickKeydown" | |
| }); | |
| // Events for list items | |
| this.list.attr( "role", "listbox" ); | |
| this._on( this.list, { | |
| "focusin": "_handleListFocus", | |
| "focusout": "_handleListFocus", | |
| "keydown": "_handleListKeydown", | |
| "click li:not(.ui-disabled,.ui-state-disabled,.ui-li-divider)": "_handleListItemClick" | |
| }); | |
| // button refocus ensures proper height calculation | |
| // by removing the inline style and ensuring page inclusion | |
| this._on( this.menuPage, { pagehide: "_handleMenuPageHide" } ); | |
| // Events on the popup | |
| this._on( this.listbox, { popupafterclose: "_popupClosed" } ); | |
| // Close button on small overlays | |
| if ( this.isMultiple ) { | |
| this._on( this.headerClose, { click: "_handleHeaderCloseClick" } ); | |
| } | |
| return this; | |
| }, | |
| _popupClosed: function() { | |
| this.close(); | |
| this._delayedTrigger(); | |
| }, | |
| _delayedTrigger: function() { | |
| if ( this._triggerChange ) { | |
| this.element.trigger( "change" ); | |
| } | |
| this._triggerChange = false; | |
| }, | |
| _isRebuildRequired: function() { | |
| var list = this.list.find( "li" ), | |
| options = this._selectOptions().not( ".ui-screen-hidden" ); | |
| // TODO exceedingly naive method to determine difference | |
| // ignores value changes etc in favor of a forcedRebuild | |
| // from the user in the refresh method | |
| return options.text() !== list.text(); | |
| }, | |
| selected: function() { | |
| return this._selectOptions().filter( ":selected:not( :jqmData(placeholder='true') )" ); | |
| }, | |
| refresh: function( force ) { | |
| var self, indices; | |
| if ( this.options.nativeMenu ) { | |
| return this._super( force ); | |
| } | |
| self = this; | |
| if ( force || this._isRebuildRequired() ) { | |
| self._buildList(); | |
| } | |
| indices = this.selectedIndices(); | |
| self.setButtonText(); | |
| self.setButtonCount(); | |
| self.list.find( "li:not(.ui-li-divider)" ) | |
| .find( "a" ).removeClass( $.mobile.activeBtnClass ).end() | |
| .attr( "aria-selected", false ) | |
| .each(function( i ) { | |
| if ( $.inArray( i, indices ) > -1 ) { | |
| var item = $( this ); | |
| // Aria selected attr | |
| item.attr( "aria-selected", true ); | |
| // Multiple selects: add the "on" checkbox state to the icon | |
| if ( self.isMultiple ) { | |
| item.find( "a" ).removeClass( "ui-checkbox-off" ).addClass( "ui-checkbox-on" ); | |
| } else { | |
| if ( item.hasClass( "ui-screen-hidden" ) ) { | |
| item.next().find( "a" ).addClass( $.mobile.activeBtnClass ); | |
| } else { | |
| item.find( "a" ).addClass( $.mobile.activeBtnClass ); | |
| } | |
| } | |
| } | |
| }); | |
| }, | |
| close: function() { | |
| if ( this.options.disabled || !this.isOpen ) { | |
| return; | |
| } | |
| var self = this; | |
| if ( self.menuType === "page" ) { | |
| self.menuPage.dialog( "close" ); | |
| self.list.appendTo( self.listbox ); | |
| } else { | |
| self.listbox.popup( "close" ); | |
| } | |
| self._focusButton(); | |
| // allow the dialog to be closed again | |
| self.isOpen = false; | |
| }, | |
| open: function() { | |
| this.button.click(); | |
| }, | |
| _focusMenuItem: function() { | |
| var selector = this.list.find( "a." + $.mobile.activeBtnClass ); | |
| if ( selector.length === 0 ) { | |
| selector = this.list.find( "li:not(" + unfocusableItemSelector + ") a.ui-btn" ); | |
| } | |
| selector.first().focus(); | |
| }, | |
| _decideFormat: function() { | |
| var self = this, | |
| $window = this.window, | |
| selfListParent = self.list.parent(), | |
| menuHeight = selfListParent.outerHeight(), | |
| scrollTop = $window.scrollTop(), | |
| btnOffset = self.button.offset().top, | |
| screenHeight = $window.height(); | |
| if ( menuHeight > screenHeight - 80 || !$.support.scrollTop ) { | |
| self.menuPage.appendTo( $.mobile.pageContainer ).page(); | |
| self.menuPageContent = self.menuPage.find( ".ui-content" ); | |
| self.menuPageClose = self.menuPage.find( ".ui-header a" ); | |
| // prevent the parent page from being removed from the DOM, | |
| // otherwise the results of selecting a list item in the dialog | |
| // fall into a black hole | |
| self.thisPage.unbind( "pagehide.remove" ); | |
| //for WebOS/Opera Mini (set lastscroll using button offset) | |
| if ( scrollTop === 0 && btnOffset > screenHeight ) { | |
| self.thisPage.one( "pagehide", function() { | |
| $( this ).jqmData( "lastScroll", btnOffset ); | |
| }); | |
| } | |
| self.menuPage.one( { | |
| pageshow: $.proxy( this, "_focusMenuItem" ), | |
| pagehide: $.proxy( this, "close" ) | |
| }); | |
| self.menuType = "page"; | |
| self.menuPageContent.append( self.list ); | |
| self.menuPage | |
| .find( "div .ui-title" ) | |
| .text( self.label.getEncodedText() || self.placeholder ); | |
| } else { | |
| self.menuType = "overlay"; | |
| self.listbox.one( { popupafteropen: $.proxy( this, "_focusMenuItem" ) } ); | |
| } | |
| }, | |
| _buildList: function() { | |
| var self = this, | |
| o = this.options, | |
| placeholder = this.placeholder, | |
| needPlaceholder = true, | |
| dataIcon = "false", | |
| $options, numOptions, select, | |
| dataPrefix = "data-" + $.mobile.ns, | |
| dataIndexAttr = dataPrefix + "option-index", | |
| dataIconAttr = dataPrefix + "icon", | |
| dataRoleAttr = dataPrefix + "role", | |
| dataPlaceholderAttr = dataPrefix + "placeholder", | |
| fragment = document.createDocumentFragment(), | |
| isPlaceholderItem = false, | |
| optGroup, | |
| i, | |
| option, $option, parent, text, anchor, classes, | |
| optLabel, divider, item; | |
| self.list.empty().filter( ".ui-listview" ).listview( "destroy" ); | |
| $options = this._selectOptions(); | |
| numOptions = $options.length; | |
| select = this.select[ 0 ]; | |
| for ( i = 0; i < numOptions;i++, isPlaceholderItem = false) { | |
| option = $options[i]; | |
| $option = $( option ); | |
| // Do not create options based on ui-screen-hidden select options | |
| if ( $option.hasClass( "ui-screen-hidden" ) ) { | |
| continue; | |
| } | |
| parent = option.parentNode; | |
| text = $option.getEncodedText(); | |
| anchor = document.createElement( "a" ); | |
| classes = []; | |
| anchor.setAttribute( "href", "#" ); | |
| anchor.appendChild( document.createTextNode( text ) ); | |
| // Are we inside an optgroup? | |
| if ( parent !== select && parent.nodeName.toLowerCase() === "optgroup" ) { | |
| optLabel = parent.getAttribute( "label" ); | |
| if ( optLabel !== optGroup ) { | |
| divider = document.createElement( "li" ); | |
| divider.setAttribute( dataRoleAttr, "list-divider" ); | |
| divider.setAttribute( "role", "option" ); | |
| divider.setAttribute( "tabindex", "-1" ); | |
| divider.appendChild( document.createTextNode( optLabel ) ); | |
| fragment.appendChild( divider ); | |
| optGroup = optLabel; | |
| } | |
| } | |
| if ( needPlaceholder && ( !option.getAttribute( "value" ) || text.length === 0 || $option.jqmData( "placeholder" ) ) ) { | |
| needPlaceholder = false; | |
| isPlaceholderItem = true; | |
| // If we have identified a placeholder, record the fact that it was | |
| // us who have added the placeholder to the option and mark it | |
| // retroactively in the select as well | |
| if ( null === option.getAttribute( dataPlaceholderAttr ) ) { | |
| this._removePlaceholderAttr = true; | |
| } | |
| option.setAttribute( dataPlaceholderAttr, true ); | |
| if ( o.hidePlaceholderMenuItems ) { | |
| classes.push( "ui-screen-hidden" ); | |
| } | |
| if ( placeholder !== text ) { | |
| placeholder = self.placeholder = text; | |
| } | |
| } | |
| item = document.createElement( "li" ); | |
| if ( option.disabled ) { | |
| classes.push( "ui-state-disabled" ); | |
| item.setAttribute( "aria-disabled", true ); | |
| } | |
| item.setAttribute( dataIndexAttr, i ); | |
| item.setAttribute( dataIconAttr, dataIcon ); | |
| if ( isPlaceholderItem ) { | |
| item.setAttribute( dataPlaceholderAttr, true ); | |
| } | |
| item.className = classes.join( " " ); | |
| item.setAttribute( "role", "option" ); | |
| anchor.setAttribute( "tabindex", "-1" ); | |
| if ( this.isMultiple ) { | |
| $( anchor ).addClass( "ui-btn ui-checkbox-off ui-btn-icon-right" ); | |
| } | |
| item.appendChild( anchor ); | |
| fragment.appendChild( item ); | |
| } | |
| self.list[0].appendChild( fragment ); | |
| // Hide header if it's not a multiselect and there's no placeholder | |
| if ( !this.isMultiple && !placeholder.length ) { | |
| this.header.addClass( "ui-screen-hidden" ); | |
| } else { | |
| this.headerTitle.text( this.placeholder ); | |
| } | |
| // Now populated, create listview | |
| self.list.listview(); | |
| }, | |
| _button: function() { | |
| return this.options.nativeMenu ? | |
| this._super() : | |
| $( "<a>", { | |
| "href": "#", | |
| "role": "button", | |
| // TODO value is undefined at creation | |
| "id": this.buttonId, | |
| "aria-haspopup": "true", | |
| // TODO value is undefined at creation | |
| "aria-owns": this.menuId | |
| }); | |
| }, | |
| _destroy: function() { | |
| if ( !this.options.nativeMenu ) { | |
| this.close(); | |
| // Restore the tabindex attribute to its original value | |
| if ( this._origTabIndex !== undefined ) { | |
| if ( this._origTabIndex !== false ) { | |
| this.select.attr( "tabindex", this._origTabIndex ); | |
| } else { | |
| this.select.removeAttr( "tabindex" ); | |
| } | |
| } | |
| // Remove the placeholder attribute if we were the ones to add it | |
| if ( this._removePlaceholderAttr ) { | |
| this._selectOptions().removeAttr( "data-" + $.mobile.ns + "placeholder" ); | |
| } | |
| // Remove the popup | |
| this.listbox.remove(); | |
| // Remove the dialog | |
| this.menuPage.remove(); | |
| } | |
| // Chain up | |
| this._super(); | |
| } | |
| }); | |
| })( jQuery ); | |
| // buttonMarkup is deprecated as of 1.4.0 and will be removed in 1.5.0. | |
| (function( $, undefined ) { | |
| // General policy: Do not access data-* attributes except during enhancement. | |
| // In all other cases we determine the state of the button exclusively from its | |
| // className. That's why optionsToClasses expects a full complement of options, | |
| // and the jQuery plugin completes the set of options from the default values. | |
| // Map classes to buttonMarkup boolean options - used in classNameToOptions() | |
| var reverseBoolOptionMap = { | |
| "ui-shadow" : "shadow", | |
| "ui-corner-all" : "corners", | |
| "ui-btn-inline" : "inline", | |
| "ui-shadow-icon" : "iconshadow", /* TODO: Remove in 1.5 */ | |
| "ui-mini" : "mini" | |
| }, | |
| getAttrFixed = function() { | |
| var ret = $.mobile.getAttribute.apply( this, arguments ); | |
| return ( ret == null ? undefined : ret ); | |
| }, | |
| capitalLettersRE = /[A-Z]/g; | |
| // optionsToClasses: | |
| // @options: A complete set of options to convert to class names. | |
| // @existingClasses: extra classes to add to the result | |
| // | |
| // Converts @options to buttonMarkup classes and returns the result as an array | |
| // that can be converted to an element's className with .join( " " ). All | |
| // possible options must be set inside @options. Use $.fn.buttonMarkup.defaults | |
| // to get a complete set and use $.extend to override your choice of options | |
| // from that set. | |
| function optionsToClasses( options, existingClasses ) { | |
| var classes = existingClasses ? existingClasses : []; | |
| // Add classes to the array - first ui-btn | |
| classes.push( "ui-btn" ); | |
| // If there is a theme | |
| if ( options.theme ) { | |
| classes.push( "ui-btn-" + options.theme ); | |
| } | |
| // If there's an icon, add the icon-related classes | |
| if ( options.icon ) { | |
| classes = classes.concat([ | |
| "ui-icon-" + options.icon, | |
| "ui-btn-icon-" + options.iconpos | |
| ]); | |
| if ( options.iconshadow ) { | |
| classes.push( "ui-shadow-icon" ); /* TODO: Remove in 1.5 */ | |
| } | |
| } | |
| // Add the appropriate class for each boolean option | |
| if ( options.inline ) { | |
| classes.push( "ui-btn-inline" ); | |
| } | |
| if ( options.shadow ) { | |
| classes.push( "ui-shadow" ); | |
| } | |
| if ( options.corners ) { | |
| classes.push( "ui-corner-all" ); | |
| } | |
| if ( options.mini ) { | |
| classes.push( "ui-mini" ); | |
| } | |
| // Create a string from the array and return it | |
| return classes; | |
| } | |
| // classNameToOptions: | |
| // @classes: A string containing a .className-style space-separated class list | |
| // | |
| // Loops over @classes and calculates an options object based on the | |
| // buttonMarkup-related classes it finds. It records unrecognized classes in an | |
| // array. | |
| // | |
| // Returns: An object containing the following items: | |
| // | |
| // "options": buttonMarkup options found to be present because of the | |
| // presence/absence of corresponding classes | |
| // | |
| // "unknownClasses": a string containing all the non-buttonMarkup-related | |
| // classes found in @classes | |
| // | |
| // "alreadyEnhanced": A boolean indicating whether the ui-btn class was among | |
| // those found to be present | |
| function classNameToOptions( classes ) { | |
| var idx, map, unknownClass, | |
| alreadyEnhanced = false, | |
| noIcon = true, | |
| o = { | |
| icon: "", | |
| inline: false, | |
| shadow: false, | |
| corners: false, | |
| iconshadow: false, | |
| mini: false | |
| }, | |
| unknownClasses = []; | |
| classes = classes.split( " " ); | |
| // Loop over the classes | |
| for ( idx = 0 ; idx < classes.length ; idx++ ) { | |
| // Assume it's an unrecognized class | |
| unknownClass = true; | |
| // Recognize boolean options from the presence of classes | |
| map = reverseBoolOptionMap[ classes[ idx ] ]; | |
| if ( map !== undefined ) { | |
| unknownClass = false; | |
| o[ map ] = true; | |
| // Recognize the presence of an icon and establish the icon position | |
| } else if ( classes[ idx ].indexOf( "ui-btn-icon-" ) === 0 ) { | |
| unknownClass = false; | |
| noIcon = false; | |
| o.iconpos = classes[ idx ].substring( 12 ); | |
| // Establish which icon is present | |
| } else if ( classes[ idx ].indexOf( "ui-icon-" ) === 0 ) { | |
| unknownClass = false; | |
| o.icon = classes[ idx ].substring( 8 ); | |
| // Establish the theme - this recognizes one-letter theme swatch names | |
| } else if ( classes[ idx ].indexOf( "ui-btn-" ) === 0 && classes[ idx ].length === 8 ) { | |
| unknownClass = false; | |
| o.theme = classes[ idx ].substring( 7 ); | |
| // Recognize that this element has already been buttonMarkup-enhanced | |
| } else if ( classes[ idx ] === "ui-btn" ) { | |
| unknownClass = false; | |
| alreadyEnhanced = true; | |
| } | |
| // If this class has not been recognized, add it to the list | |
| if ( unknownClass ) { | |
| unknownClasses.push( classes[ idx ] ); | |
| } | |
| } | |
| // If a "ui-btn-icon-*" icon position class is absent there cannot be an icon | |
| if ( noIcon ) { | |
| o.icon = ""; | |
| } | |
| return { | |
| options: o, | |
| unknownClasses: unknownClasses, | |
| alreadyEnhanced: alreadyEnhanced | |
| }; | |
| } | |
| function camelCase2Hyphenated( c ) { | |
| return "-" + c.toLowerCase(); | |
| } | |
| // $.fn.buttonMarkup: | |
| // DOM: gets/sets .className | |
| // | |
| // @options: options to apply to the elements in the jQuery object | |
| // @overwriteClasses: boolean indicating whether to honour existing classes | |
| // | |
| // Calculates the classes to apply to the elements in the jQuery object based on | |
| // the options passed in. If @overwriteClasses is true, it sets the className | |
| // property of each element in the jQuery object to the buttonMarkup classes | |
| // it calculates based on the options passed in. | |
| // | |
| // If you wish to preserve any classes that are already present on the elements | |
| // inside the jQuery object, including buttonMarkup-related classes that were | |
| // added by a previous call to $.fn.buttonMarkup() or during page enhancement | |
| // then you should omit @overwriteClasses or set it to false. | |
| $.fn.buttonMarkup = function( options, overwriteClasses ) { | |
| var idx, data, el, retrievedOptions, optionKey, | |
| defaults = $.fn.buttonMarkup.defaults; | |
| for ( idx = 0 ; idx < this.length ; idx++ ) { | |
| el = this[ idx ]; | |
| data = overwriteClasses ? | |
| // Assume this element is not enhanced and ignore its classes | |
| { alreadyEnhanced: false, unknownClasses: [] } : | |
| // Otherwise analyze existing classes to establish existing options and | |
| // classes | |
| classNameToOptions( el.className ); | |
| retrievedOptions = $.extend( {}, | |
| // If the element already has the class ui-btn, then we assume that | |
| // it has passed through buttonMarkup before - otherwise, the options | |
| // returned by classNameToOptions do not correctly reflect the state of | |
| // the element | |
| ( data.alreadyEnhanced ? data.options : {} ), | |
| // Finally, apply the options passed in | |
| options ); | |
| // If this is the first call on this element, retrieve remaining options | |
| // from the data-attributes | |
| if ( !data.alreadyEnhanced ) { | |
| for ( optionKey in defaults ) { | |
| if ( retrievedOptions[ optionKey ] === undefined ) { | |
| retrievedOptions[ optionKey ] = getAttrFixed( el, | |
| optionKey.replace( capitalLettersRE, camelCase2Hyphenated ) | |
| ); | |
| } | |
| } | |
| } | |
| el.className = optionsToClasses( | |
| // Merge all the options and apply them as classes | |
| $.extend( {}, | |
| // The defaults form the basis | |
| defaults, | |
| // Add the computed options | |
| retrievedOptions | |
| ), | |
| // ... and re-apply any unrecognized classes that were found | |
| data.unknownClasses ).join( " " ); | |
| if ( el.tagName.toLowerCase() !== "button" ) { | |
| el.setAttribute( "role", "button" ); | |
| } | |
| } | |
| return this; | |
| }; | |
| // buttonMarkup defaults. This must be a complete set, i.e., a value must be | |
| // given here for all recognized options | |
| $.fn.buttonMarkup.defaults = { | |
| icon: "", | |
| iconpos: "left", | |
| theme: null, | |
| inline: false, | |
| shadow: true, | |
| corners: true, | |
| iconshadow: false, /* TODO: Remove in 1.5. Option deprecated in 1.4. */ | |
| mini: false | |
| }; | |
| $.extend( $.fn.buttonMarkup, { | |
| initSelector: "a:jqmData(role='button'), .ui-bar > a, .ui-bar > :jqmData(role='controlgroup') > a, button" | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.controlgroup", $.extend( { | |
| options: { | |
| enhanced: false, | |
| theme: null, | |
| shadow: false, | |
| corners: true, | |
| excludeInvisible: true, | |
| type: "vertical", | |
| mini: false | |
| }, | |
| _create: function() { | |
| var elem = this.element, | |
| opts = this.options; | |
| // Run buttonmarkup | |
| if ( $.fn.buttonMarkup ) { | |
| this.element.find( $.fn.buttonMarkup.initSelector ).buttonMarkup(); | |
| } | |
| // Enhance child widgets | |
| $.each( this._childWidgets, $.proxy( function( number, widgetName ) { | |
| if ( $.mobile[ widgetName ] ) { | |
| this.element.find( $.mobile[ widgetName ].initSelector ).not( $.mobile.page.prototype.keepNativeSelector() )[ widgetName ](); | |
| } | |
| }, this )); | |
| $.extend( this, { | |
| _ui: null, | |
| _initialRefresh: true | |
| }); | |
| if ( opts.enhanced ) { | |
| this._ui = { | |
| groupLegend: elem.children( ".ui-controlgroup-label" ).children(), | |
| childWrapper: elem.children( ".ui-controlgroup-controls" ) | |
| }; | |
| } else { | |
| this._ui = this._enhance(); | |
| } | |
| }, | |
| _childWidgets: [ "checkboxradio", "selectmenu", "button" ], | |
| _themeClassFromOption: function( value ) { | |
| return ( value ? ( value === "none" ? "" : "ui-group-theme-" + value ) : "" ); | |
| }, | |
| _enhance: function() { | |
| var elem = this.element, | |
| opts = this.options, | |
| ui = { | |
| groupLegend: elem.children( "legend" ), | |
| childWrapper: elem | |
| .addClass( "ui-controlgroup " + | |
| "ui-controlgroup-" + | |
| ( opts.type === "horizontal" ? "horizontal" : "vertical" ) + " " + | |
| this._themeClassFromOption( opts.theme ) + " " + | |
| ( opts.corners ? "ui-corner-all " : "" ) + | |
| ( opts.mini ? "ui-mini " : "" ) ) | |
| .wrapInner( "<div " + | |
| "class='ui-controlgroup-controls " + | |
| ( opts.shadow === true ? "ui-shadow" : "" ) + "'></div>" ) | |
| .children() | |
| }; | |
| if ( ui.groupLegend.length > 0 ) { | |
| $( "<div role='heading' class='ui-controlgroup-label'></div>" ) | |
| .append( ui.groupLegend ) | |
| .prependTo( elem ); | |
| } | |
| return ui; | |
| }, | |
| _init: function() { | |
| this.refresh(); | |
| }, | |
| _setOptions: function( options ) { | |
| var callRefresh, returnValue, | |
| elem = this.element; | |
| // Must have one of horizontal or vertical | |
| if ( options.type !== undefined ) { | |
| elem | |
| .removeClass( "ui-controlgroup-horizontal ui-controlgroup-vertical" ) | |
| .addClass( "ui-controlgroup-" + ( options.type === "horizontal" ? "horizontal" : "vertical" ) ); | |
| callRefresh = true; | |
| } | |
| if ( options.theme !== undefined ) { | |
| elem | |
| .removeClass( this._themeClassFromOption( this.options.theme ) ) | |
| .addClass( this._themeClassFromOption( options.theme ) ); | |
| } | |
| if ( options.corners !== undefined ) { | |
| elem.toggleClass( "ui-corner-all", options.corners ); | |
| } | |
| if ( options.mini !== undefined ) { | |
| elem.toggleClass( "ui-mini", options.mini ); | |
| } | |
| if ( options.shadow !== undefined ) { | |
| this._ui.childWrapper.toggleClass( "ui-shadow", options.shadow ); | |
| } | |
| if ( options.excludeInvisible !== undefined ) { | |
| this.options.excludeInvisible = options.excludeInvisible; | |
| callRefresh = true; | |
| } | |
| returnValue = this._super( options ); | |
| if ( callRefresh ) { | |
| this.refresh(); | |
| } | |
| return returnValue; | |
| }, | |
| container: function() { | |
| return this._ui.childWrapper; | |
| }, | |
| refresh: function() { | |
| var $el = this.container(), | |
| els = $el.find( ".ui-btn" ).not( ".ui-slider-handle" ), | |
| create = this._initialRefresh; | |
| if ( $.mobile.checkboxradio ) { | |
| $el.find( ":mobile-checkboxradio" ).checkboxradio( "refresh" ); | |
| } | |
| this._addFirstLastClasses( els, | |
| this.options.excludeInvisible ? this._getVisibles( els, create ) : els, | |
| create ); | |
| this._initialRefresh = false; | |
| }, | |
| // Caveat: If the legend is not the first child of the controlgroup at enhance | |
| // time, it will be after _destroy(). | |
| _destroy: function() { | |
| var ui, buttons, | |
| opts = this.options; | |
| if ( opts.enhanced ) { | |
| return this; | |
| } | |
| ui = this._ui; | |
| buttons = this.element | |
| .removeClass( "ui-controlgroup " + | |
| "ui-controlgroup-horizontal ui-controlgroup-vertical ui-corner-all ui-mini " + | |
| this._themeClassFromOption( opts.theme ) ) | |
| .find( ".ui-btn" ) | |
| .not( ".ui-slider-handle" ); | |
| this._removeFirstLastClasses( buttons ); | |
| ui.groupLegend.unwrap(); | |
| ui.childWrapper.children().unwrap(); | |
| } | |
| }, $.mobile.behaviors.addFirstLastClasses ) ); | |
| })(jQuery); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.toolbar", { | |
| initSelector: ":jqmData(role='footer'), :jqmData(role='header')", | |
| options: { | |
| theme: null, | |
| addBackBtn: false, | |
| backBtnTheme: null, | |
| backBtnText: "Back" | |
| }, | |
| _create: function() { | |
| var leftbtn, rightbtn, | |
| role = this.element.is( ":jqmData(role='header')" ) ? "header" : "footer", | |
| page = this.element.closest( ".ui-page" ); | |
| if ( page.length === 0 ) { | |
| page = false; | |
| this._on( this.document, { | |
| "pageshow": "refresh" | |
| }); | |
| } | |
| $.extend( this, { | |
| role: role, | |
| page: page, | |
| leftbtn: leftbtn, | |
| rightbtn: rightbtn | |
| }); | |
| this.element.attr( "role", role === "header" ? "banner" : "contentinfo" ).addClass( "ui-" + role ); | |
| this.refresh(); | |
| this._setOptions( this.options ); | |
| }, | |
| _setOptions: function( o ) { | |
| if ( o.addBackBtn !== undefined ) { | |
| this._updateBackButton(); | |
| } | |
| if ( o.backBtnTheme != null ) { | |
| this.element | |
| .find( ".ui-toolbar-back-btn" ) | |
| .addClass( "ui-btn ui-btn-" + o.backBtnTheme ); | |
| } | |
| if ( o.backBtnText !== undefined ) { | |
| this.element.find( ".ui-toolbar-back-btn .ui-btn-text" ).text( o.backBtnText ); | |
| } | |
| if ( o.theme !== undefined ) { | |
| var currentTheme = this.options.theme ? this.options.theme : "inherit", | |
| newTheme = o.theme ? o.theme : "inherit"; | |
| this.element.removeClass( "ui-bar-" + currentTheme ).addClass( "ui-bar-" + newTheme ); | |
| } | |
| this._super( o ); | |
| }, | |
| refresh: function() { | |
| if ( this.role === "header" ) { | |
| this._addHeaderButtonClasses(); | |
| } | |
| if ( !this.page ) { | |
| this._setRelative(); | |
| if ( this.role === "footer" ) { | |
| this.element.appendTo( "body" ); | |
| } else if ( this.role === "header" ) { | |
| this._updateBackButton(); | |
| } | |
| } | |
| this._addHeadingClasses(); | |
| this._btnMarkup(); | |
| }, | |
| //we only want this to run on non fixed toolbars so make it easy to override | |
| _setRelative: function() { | |
| $( "[data-"+ $.mobile.ns + "role='page']" ).css({ "position": "relative" }); | |
| }, | |
| // Deprecated in 1.4. As from 1.5 button classes have to be present in the markup. | |
| _btnMarkup: function() { | |
| this.element | |
| .children( "a" ) | |
| .filter( ":not([data-" + $.mobile.ns + "role='none'])" ) | |
| .attr( "data-" + $.mobile.ns + "role", "button" ); | |
| this.element.trigger( "create" ); | |
| }, | |
| // Deprecated in 1.4. As from 1.5 ui-btn-left/right classes have to be present in the markup. | |
| _addHeaderButtonClasses: function() { | |
| var headerAnchors = this.element.children( "a, button" ); | |
| // Do not mistake a back button for a left toolbar button | |
| this.leftbtn = headerAnchors.hasClass( "ui-btn-left" ) && | |
| !headerAnchors.hasClass( "ui-toolbar-back-btn" ); | |
| this.rightbtn = headerAnchors.hasClass( "ui-btn-right" ); | |
| // Filter out right buttons and back buttons | |
| this.leftbtn = this.leftbtn || | |
| headerAnchors.eq( 0 ) | |
| .not( ".ui-btn-right,.ui-toolbar-back-btn" ) | |
| .addClass( "ui-btn-left" ) | |
| .length; | |
| this.rightbtn = this.rightbtn || headerAnchors.eq( 1 ).addClass( "ui-btn-right" ).length; | |
| }, | |
| _updateBackButton: function() { | |
| var backButton, | |
| options = this.options, | |
| theme = options.backBtnTheme || options.theme; | |
| // Retrieve the back button or create a new, empty one | |
| backButton = this._backButton = ( this._backButton || {} ); | |
| // We add a back button only if the option to do so is on | |
| if ( this.options.addBackBtn && | |
| // This must also be a header toolbar | |
| this.role === "header" && | |
| // There must be multiple pages in the DOM | |
| $( ".ui-page" ).length > 1 && | |
| ( this.page ? | |
| // If the toolbar is internal the page's URL must differ from the hash | |
| ( this.page[ 0 ].getAttribute( "data-" + $.mobile.ns + "url" ) !== | |
| $.mobile.path.stripHash( location.hash ) ) : | |
| // Otherwise, if the toolbar is external there must be at least one | |
| // history item to which one can go back | |
| ( $.mobile.navigate && $.mobile.navigate.history && | |
| $.mobile.navigate.history.activeIndex > 0 ) ) && | |
| // The toolbar does not have a left button | |
| !this.leftbtn ) { | |
| // Skip back button creation if one is already present | |
| if ( !backButton.attached ) { | |
| backButton.element = ( backButton.element || | |
| $( "<a role='button' href='javascript:void(0);' " + | |
| "class='ui-btn ui-corner-all ui-shadow ui-btn-left " + | |
| ( theme ? "ui-btn-" + theme + " " : "" ) + | |
| "ui-toolbar-back-btn ui-icon-carat-l ui-btn-icon-left' " + | |
| "data-" + $.mobile.ns + "rel='back'>" + options.backBtnText + | |
| "</a>" ) ) | |
| .prependTo( this.element ); | |
| backButton.attached = true; | |
| } | |
| // If we are not adding a back button, then remove the one present, if any | |
| } else if ( backButton.element ) { | |
| backButton.element.detach(); | |
| backButton.attached = false; | |
| } | |
| }, | |
| _addHeadingClasses: function() { | |
| this.element.children( "h1, h2, h3, h4, h5, h6" ) | |
| .addClass( "ui-title" ) | |
| // Regardless of h element number in src, it becomes h1 for the enhanced page | |
| .attr({ | |
| "role": "heading", | |
| "aria-level": "1" | |
| }); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.toolbar", $.mobile.toolbar, { | |
| options: { | |
| position:null, | |
| visibleOnPageShow: true, | |
| disablePageZoom: true, | |
| transition: "slide", //can be none, fade, slide (slide maps to slideup or slidedown) | |
| fullscreen: false, | |
| tapToggle: true, | |
| tapToggleBlacklist: "a, button, input, select, textarea, .ui-header-fixed, .ui-footer-fixed, .ui-flipswitch, .ui-popup, .ui-panel, .ui-panel-dismiss-open", | |
| hideDuringFocus: "input, textarea, select", | |
| updatePagePadding: true, | |
| trackPersistentToolbars: true, | |
| // Browser detection! Weeee, here we go... | |
| // Unfortunately, position:fixed is costly, not to mention probably impossible, to feature-detect accurately. | |
| // Some tests exist, but they currently return false results in critical devices and browsers, which could lead to a broken experience. | |
| // Testing fixed positioning is also pretty obtrusive to page load, requiring injected elements and scrolling the window | |
| // The following function serves to rule out some popular browsers with known fixed-positioning issues | |
| // This is a plugin option like any other, so feel free to improve or overwrite it | |
| supportBlacklist: function() { | |
| return !$.support.fixedPosition; | |
| } | |
| }, | |
| _create: function() { | |
| this._super(); | |
| if ( this.options.position === "fixed" && !this.options.supportBlacklist() ) { | |
| this._makeFixed(); | |
| } | |
| }, | |
| _makeFixed: function() { | |
| this.element.addClass( "ui-"+ this.role +"-fixed" ); | |
| this.updatePagePadding(); | |
| this._addTransitionClass(); | |
| this._bindPageEvents(); | |
| this._bindToggleHandlers(); | |
| }, | |
| _setOptions: function( o ) { | |
| if ( o.position === "fixed" && this.options.position !== "fixed" ) { | |
| this._makeFixed(); | |
| } | |
| if ( this.options.position === "fixed" && !this.options.supportBlacklist() ) { | |
| var $page = ( !!this.page )? this.page: ( $(".ui-page-active").length > 0 )? $(".ui-page-active"): $(".ui-page").eq(0); | |
| if ( o.fullscreen !== undefined) { | |
| if ( o.fullscreen ) { | |
| this.element.addClass( "ui-"+ this.role +"-fullscreen" ); | |
| $page.addClass( "ui-page-" + this.role + "-fullscreen" ); | |
| } | |
| // If not fullscreen, add class to page to set top or bottom padding | |
| else { | |
| this.element.removeClass( "ui-"+ this.role +"-fullscreen" ); | |
| $page.removeClass( "ui-page-" + this.role + "-fullscreen" ).addClass( "ui-page-" + this.role+ "-fixed" ); | |
| } | |
| } | |
| } | |
| this._super(o); | |
| }, | |
| _addTransitionClass: function() { | |
| var tclass = this.options.transition; | |
| if ( tclass && tclass !== "none" ) { | |
| // use appropriate slide for header or footer | |
| if ( tclass === "slide" ) { | |
| tclass = this.element.hasClass( "ui-header" ) ? "slidedown" : "slideup"; | |
| } | |
| this.element.addClass( tclass ); | |
| } | |
| }, | |
| _bindPageEvents: function() { | |
| var page = ( !!this.page )? this.element.closest( ".ui-page" ): this.document; | |
| //page event bindings | |
| // Fixed toolbars require page zoom to be disabled, otherwise usability issues crop up | |
| // This method is meant to disable zoom while a fixed-positioned toolbar page is visible | |
| this._on( page , { | |
| "pagebeforeshow": "_handlePageBeforeShow", | |
| "webkitAnimationStart":"_handleAnimationStart", | |
| "animationstart":"_handleAnimationStart", | |
| "updatelayout": "_handleAnimationStart", | |
| "pageshow": "_handlePageShow", | |
| "pagebeforehide": "_handlePageBeforeHide" | |
| }); | |
| }, | |
| _handlePageBeforeShow: function( ) { | |
| var o = this.options; | |
| if ( o.disablePageZoom ) { | |
| $.mobile.zoom.disable( true ); | |
| } | |
| if ( !o.visibleOnPageShow ) { | |
| this.hide( true ); | |
| } | |
| }, | |
| _handleAnimationStart: function() { | |
| if ( this.options.updatePagePadding ) { | |
| this.updatePagePadding( ( !!this.page )? this.page: ".ui-page-active" ); | |
| } | |
| }, | |
| _handlePageShow: function() { | |
| this.updatePagePadding( ( !!this.page )? this.page: ".ui-page-active" ); | |
| if ( this.options.updatePagePadding ) { | |
| this._on( this.window, { "throttledresize": "updatePagePadding" } ); | |
| } | |
| }, | |
| _handlePageBeforeHide: function( e, ui ) { | |
| var o = this.options, | |
| thisFooter, thisHeader, nextFooter, nextHeader; | |
| if ( o.disablePageZoom ) { | |
| $.mobile.zoom.enable( true ); | |
| } | |
| if ( o.updatePagePadding ) { | |
| this._off( this.window, "throttledresize" ); | |
| } | |
| if ( o.trackPersistentToolbars ) { | |
| thisFooter = $( ".ui-footer-fixed:jqmData(id)", this.page ); | |
| thisHeader = $( ".ui-header-fixed:jqmData(id)", this.page ); | |
| nextFooter = thisFooter.length && ui.nextPage && $( ".ui-footer-fixed:jqmData(id='" + thisFooter.jqmData( "id" ) + "')", ui.nextPage ) || $(); | |
| nextHeader = thisHeader.length && ui.nextPage && $( ".ui-header-fixed:jqmData(id='" + thisHeader.jqmData( "id" ) + "')", ui.nextPage ) || $(); | |
| if ( nextFooter.length || nextHeader.length ) { | |
| nextFooter.add( nextHeader ).appendTo( $.mobile.pageContainer ); | |
| ui.nextPage.one( "pageshow", function() { | |
| nextHeader.prependTo( this ); | |
| nextFooter.appendTo( this ); | |
| }); | |
| } | |
| } | |
| }, | |
| _visible: true, | |
| // This will set the content element's top or bottom padding equal to the toolbar's height | |
| updatePagePadding: function( tbPage ) { | |
| var $el = this.element, | |
| header = ( this.role ==="header" ), | |
| pos = parseFloat( $el.css( header ? "top" : "bottom" ) ); | |
| // This behavior only applies to "fixed", not "fullscreen" | |
| if ( this.options.fullscreen ) { return; } | |
| // tbPage argument can be a Page object or an event, if coming from throttled resize. | |
| tbPage = ( tbPage && tbPage.type === undefined && tbPage ) || this.page || $el.closest( ".ui-page" ); | |
| tbPage = ( !!this.page )? this.page: ".ui-page-active"; | |
| $( tbPage ).css( "padding-" + ( header ? "top" : "bottom" ), $el.outerHeight() + pos ); | |
| }, | |
| _useTransition: function( notransition ) { | |
| var $win = this.window, | |
| $el = this.element, | |
| scroll = $win.scrollTop(), | |
| elHeight = $el.height(), | |
| pHeight = ( !!this.page )? $el.closest( ".ui-page" ).height():$(".ui-page-active").height(), | |
| viewportHeight = $.mobile.getScreenHeight(); | |
| return !notransition && | |
| ( this.options.transition && this.options.transition !== "none" && | |
| ( | |
| ( this.role === "header" && !this.options.fullscreen && scroll > elHeight ) || | |
| ( this.role === "footer" && !this.options.fullscreen && scroll + viewportHeight < pHeight - elHeight ) | |
| ) || this.options.fullscreen | |
| ); | |
| }, | |
| show: function( notransition ) { | |
| var hideClass = "ui-fixed-hidden", | |
| $el = this.element; | |
| if ( this._useTransition( notransition ) ) { | |
| $el | |
| .removeClass( "out " + hideClass ) | |
| .addClass( "in" ) | |
| .animationComplete(function () { | |
| $el.removeClass( "in" ); | |
| }); | |
| } | |
| else { | |
| $el.removeClass( hideClass ); | |
| } | |
| this._visible = true; | |
| }, | |
| hide: function( notransition ) { | |
| var hideClass = "ui-fixed-hidden", | |
| $el = this.element, | |
| // if it's a slide transition, our new transitions need the reverse class as well to slide outward | |
| outclass = "out" + ( this.options.transition === "slide" ? " reverse" : "" ); | |
| if ( this._useTransition( notransition ) ) { | |
| $el | |
| .addClass( outclass ) | |
| .removeClass( "in" ) | |
| .animationComplete(function() { | |
| $el.addClass( hideClass ).removeClass( outclass ); | |
| }); | |
| } | |
| else { | |
| $el.addClass( hideClass ).removeClass( outclass ); | |
| } | |
| this._visible = false; | |
| }, | |
| toggle: function() { | |
| this[ this._visible ? "hide" : "show" ](); | |
| }, | |
| _bindToggleHandlers: function() { | |
| var self = this, | |
| o = self.options, | |
| delayShow, delayHide, | |
| isVisible = true, | |
| page = ( !!this.page )? this.page: $(".ui-page"); | |
| // tap toggle | |
| page | |
| .bind( "vclick", function( e ) { | |
| if ( o.tapToggle && !$( e.target ).closest( o.tapToggleBlacklist ).length ) { | |
| self.toggle(); | |
| } | |
| }) | |
| .bind( "focusin focusout", function( e ) { | |
| //this hides the toolbars on a keyboard pop to give more screen room and prevent ios bug which | |
| //positions fixed toolbars in the middle of the screen on pop if the input is near the top or | |
| //bottom of the screen addresses issues #4410 Footer navbar moves up when clicking on a textbox in an Android environment | |
| //and issue #4113 Header and footer change their position after keyboard popup - iOS | |
| //and issue #4410 Footer navbar moves up when clicking on a textbox in an Android environment | |
| if ( screen.width < 1025 && $( e.target ).is( o.hideDuringFocus ) && !$( e.target ).closest( ".ui-header-fixed, .ui-footer-fixed" ).length ) { | |
| //Fix for issue #4724 Moving through form in Mobile Safari with "Next" and "Previous" system | |
| //controls causes fixed position, tap-toggle false Header to reveal itself | |
| // isVisible instead of self._visible because the focusin and focusout events fire twice at the same time | |
| // Also use a delay for hiding the toolbars because on Android native browser focusin is direclty followed | |
| // by a focusout when a native selects opens and the other way around when it closes. | |
| if ( e.type === "focusout" && !isVisible ) { | |
| isVisible = true; | |
| //wait for the stack to unwind and see if we have jumped to another input | |
| clearTimeout( delayHide ); | |
| delayShow = setTimeout( function() { | |
| self.show(); | |
| }, 0 ); | |
| } else if ( e.type === "focusin" && !!isVisible ) { | |
| //if we have jumped to another input clear the time out to cancel the show. | |
| clearTimeout( delayShow ); | |
| isVisible = false; | |
| delayHide = setTimeout( function() { | |
| self.hide(); | |
| }, 0 ); | |
| } | |
| } | |
| }); | |
| }, | |
| _setRelative: function() { | |
| if( this.options.position !== "fixed" ){ | |
| $( "[data-"+ $.mobile.ns + "role='page']" ).css({ "position": "relative" }); | |
| } | |
| }, | |
| _destroy: function() { | |
| var $el = this.element, | |
| header = $el.hasClass( "ui-header" ); | |
| $el.closest( ".ui-page" ).css( "padding-" + ( header ? "top" : "bottom" ), "" ); | |
| $el.removeClass( "ui-header-fixed ui-footer-fixed ui-header-fullscreen ui-footer-fullscreen in out fade slidedown slideup ui-fixed-hidden" ); | |
| $el.closest( ".ui-page" ).removeClass( "ui-page-header-fixed ui-page-footer-fixed ui-page-header-fullscreen ui-page-footer-fullscreen" ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.toolbar", $.mobile.toolbar, { | |
| _makeFixed: function() { | |
| this._super(); | |
| this._workarounds(); | |
| }, | |
| //check the browser and version and run needed workarounds | |
| _workarounds: function() { | |
| var ua = navigator.userAgent, | |
| platform = navigator.platform, | |
| // Rendering engine is Webkit, and capture major version | |
| wkmatch = ua.match( /AppleWebKit\/([0-9]+)/ ), | |
| wkversion = !!wkmatch && wkmatch[ 1 ], | |
| os = null, | |
| self = this; | |
| //set the os we are working in if it dosent match one with workarounds return | |
| if ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1 || platform.indexOf( "iPod" ) > -1 ) { | |
| os = "ios"; | |
| } else if ( ua.indexOf( "Android" ) > -1 ) { | |
| os = "android"; | |
| } else { | |
| return; | |
| } | |
| //check os version if it dosent match one with workarounds return | |
| if ( os === "ios" ) { | |
| //iOS workarounds | |
| self._bindScrollWorkaround(); | |
| } else if ( os === "android" && wkversion && wkversion < 534 ) { | |
| //Android 2.3 run all Android 2.3 workaround | |
| self._bindScrollWorkaround(); | |
| self._bindListThumbWorkaround(); | |
| } else { | |
| return; | |
| } | |
| }, | |
| //Utility class for checking header and footer positions relative to viewport | |
| _viewportOffset: function() { | |
| var $el = this.element, | |
| header = $el.hasClass( "ui-header" ), | |
| offset = Math.abs( $el.offset().top - this.window.scrollTop() ); | |
| if ( !header ) { | |
| offset = Math.round( offset - this.window.height() + $el.outerHeight() ) - 60; | |
| } | |
| return offset; | |
| }, | |
| //bind events for _triggerRedraw() function | |
| _bindScrollWorkaround: function() { | |
| var self = this; | |
| //bind to scrollstop and check if the toolbars are correctly positioned | |
| this._on( this.window, { scrollstop: function() { | |
| var viewportOffset = self._viewportOffset(); | |
| //check if the header is visible and if its in the right place | |
| if ( viewportOffset > 2 && self._visible ) { | |
| self._triggerRedraw(); | |
| } | |
| }}); | |
| }, | |
| //this addresses issue #4250 Persistent footer instability in v1.1 with long select lists in Android 2.3.3 | |
| //and issue #3748 Android 2.x: Page transitions broken when fixed toolbars used | |
| //the absolutely positioned thumbnail in a list view causes problems with fixed position buttons above in a nav bar | |
| //setting the li's to -webkit-transform:translate3d(0,0,0); solves this problem to avoide potential issues in other | |
| //platforms we scope this with the class ui-android-2x-fix | |
| _bindListThumbWorkaround: function() { | |
| this.element.closest( ".ui-page" ).addClass( "ui-android-2x-fixed" ); | |
| }, | |
| //this addresses issues #4337 Fixed header problem after scrolling content on iOS and Android | |
| //and device bugs project issue #1 Form elements can lose click hit area in position: fixed containers. | |
| //this also addresses not on fixed toolbars page in docs | |
| //adding 1px of padding to the bottom then removing it causes a "redraw" | |
| //which positions the toolbars correctly (they will always be visually correct) | |
| _triggerRedraw: function() { | |
| var paddingBottom = parseFloat( $( ".ui-page-active" ).css( "padding-bottom" ) ); | |
| //trigger page redraw to fix incorrectly positioned fixed elements | |
| $( ".ui-page-active" ).css( "padding-bottom", ( paddingBottom + 1 ) + "px" ); | |
| //if the padding is reset with out a timeout the reposition will not occure. | |
| //this is independant of JQM the browser seems to need the time to react. | |
| setTimeout( function() { | |
| $( ".ui-page-active" ).css( "padding-bottom", paddingBottom + "px" ); | |
| }, 0 ); | |
| }, | |
| destroy: function() { | |
| this._super(); | |
| //Remove the class we added to the page previously in android 2.x | |
| this.element.closest( ".ui-page-active" ).removeClass( "ui-android-2x-fix" ); | |
| } | |
| }); | |
| })( jQuery ); | |
| ( function( $, undefined ) { | |
| var ieHack = ( $.mobile.browser.oldIE && $.mobile.browser.oldIE <= 8 ), | |
| uiTemplate = $( | |
| "<div class='ui-popup-arrow-guide'></div>" + | |
| "<div class='ui-popup-arrow-container" + ( ieHack ? " ie" : "" ) + "'>" + | |
| "<div class='ui-popup-arrow'></div>" + | |
| "</div>" | |
| ); | |
| function getArrow() { | |
| var clone = uiTemplate.clone(), | |
| gd = clone.eq( 0 ), | |
| ct = clone.eq( 1 ), | |
| ar = ct.children(); | |
| return { arEls: ct.add( gd ), gd: gd, ct: ct, ar: ar }; | |
| } | |
| $.widget( "mobile.popup", $.mobile.popup, { | |
| options: { | |
| arrow: "" | |
| }, | |
| _create: function() { | |
| var ar, | |
| ret = this._super(); | |
| if ( this.options.arrow ) { | |
| this._ui.arrow = ar = this._addArrow(); | |
| } | |
| return ret; | |
| }, | |
| _addArrow: function() { | |
| var theme, | |
| opts = this.options, | |
| ar = getArrow(); | |
| theme = this._themeClassFromOption( "ui-body-", opts.theme ); | |
| ar.ar.addClass( theme + ( opts.shadow ? " ui-overlay-shadow" : "" ) ); | |
| ar.arEls.hide().appendTo( this.element ); | |
| return ar; | |
| }, | |
| _unenhance: function() { | |
| var ar = this._ui.arrow; | |
| if ( ar ) { | |
| ar.arEls.remove(); | |
| } | |
| return this._super(); | |
| }, | |
| // Pretend to show an arrow described by @p and @dir and calculate the | |
| // distance from the desired point. If a best-distance is passed in, return | |
| // the minimum of the one passed in and the one calculated. | |
| _tryAnArrow: function( p, dir, desired, s, best ) { | |
| var result, r, diff, desiredForArrow = {}, tip = {}; | |
| // If the arrow has no wiggle room along the edge of the popup, it cannot | |
| // be displayed along the requested edge without it sticking out. | |
| if ( s.arFull[ p.dimKey ] > s.guideDims[ p.dimKey ] ) { | |
| return best; | |
| } | |
| desiredForArrow[ p.fst ] = desired[ p.fst ] + | |
| ( s.arHalf[ p.oDimKey ] + s.menuHalf[ p.oDimKey ] ) * p.offsetFactor - | |
| s.contentBox[ p.fst ] + ( s.clampInfo.menuSize[ p.oDimKey ] - s.contentBox[ p.oDimKey ] ) * p.arrowOffsetFactor; | |
| desiredForArrow[ p.snd ] = desired[ p.snd ]; | |
| result = s.result || this._calculateFinalLocation( desiredForArrow, s.clampInfo ); | |
| r = { x: result.left, y: result.top }; | |
| tip[ p.fst ] = r[ p.fst ] + s.contentBox[ p.fst ] + p.tipOffset; | |
| tip[ p.snd ] = Math.max( result[ p.prop ] + s.guideOffset[ p.prop ] + s.arHalf[ p.dimKey ], | |
| Math.min( result[ p.prop ] + s.guideOffset[ p.prop ] + s.guideDims[ p.dimKey ] - s.arHalf[ p.dimKey ], | |
| desired[ p.snd ] ) ); | |
| diff = Math.abs( desired.x - tip.x ) + Math.abs( desired.y - tip.y ); | |
| if ( !best || diff < best.diff ) { | |
| // Convert tip offset to coordinates inside the popup | |
| tip[ p.snd ] -= s.arHalf[ p.dimKey ] + result[ p.prop ] + s.contentBox[ p.snd ]; | |
| best = { dir: dir, diff: diff, result: result, posProp: p.prop, posVal: tip[ p.snd ] }; | |
| } | |
| return best; | |
| }, | |
| _getPlacementState: function( clamp ) { | |
| var offset, gdOffset, | |
| ar = this._ui.arrow, | |
| state = { | |
| clampInfo: this._clampPopupWidth( !clamp ), | |
| arFull: { cx: ar.ct.width(), cy: ar.ct.height() }, | |
| guideDims: { cx: ar.gd.width(), cy: ar.gd.height() }, | |
| guideOffset: ar.gd.offset() | |
| }; | |
| offset = this.element.offset(); | |
| ar.gd.css( { left: 0, top: 0, right: 0, bottom: 0 } ); | |
| gdOffset = ar.gd.offset(); | |
| state.contentBox = { | |
| x: gdOffset.left - offset.left, | |
| y: gdOffset.top - offset.top, | |
| cx: ar.gd.width(), | |
| cy: ar.gd.height() | |
| }; | |
| ar.gd.removeAttr( "style" ); | |
| // The arrow box moves between guideOffset and guideOffset + guideDims - arFull | |
| state.guideOffset = { left: state.guideOffset.left - offset.left, top: state.guideOffset.top - offset.top }; | |
| state.arHalf = { cx: state.arFull.cx / 2, cy: state.arFull.cy / 2 }; | |
| state.menuHalf = { cx: state.clampInfo.menuSize.cx / 2, cy: state.clampInfo.menuSize.cy / 2 }; | |
| return state; | |
| }, | |
| _placementCoords: function( desired ) { | |
| var state, best, params, elOffset, bgRef, | |
| optionValue = this.options.arrow, | |
| ar = this._ui.arrow; | |
| if ( !ar ) { | |
| return this._super( desired ); | |
| } | |
| ar.arEls.show(); | |
| bgRef = {}; | |
| state = this._getPlacementState( true ); | |
| params = { | |
| "l": { fst: "x", snd: "y", prop: "top", dimKey: "cy", oDimKey: "cx", offsetFactor: 1, tipOffset: -state.arHalf.cx, arrowOffsetFactor: 0 }, | |
| "r": { fst: "x", snd: "y", prop: "top", dimKey: "cy", oDimKey: "cx", offsetFactor: -1, tipOffset: state.arHalf.cx + state.contentBox.cx, arrowOffsetFactor: 1 }, | |
| "b": { fst: "y", snd: "x", prop: "left", dimKey: "cx", oDimKey: "cy", offsetFactor: -1, tipOffset: state.arHalf.cy + state.contentBox.cy, arrowOffsetFactor: 1 }, | |
| "t": { fst: "y", snd: "x", prop: "left", dimKey: "cx", oDimKey: "cy", offsetFactor: 1, tipOffset: -state.arHalf.cy, arrowOffsetFactor: 0 } | |
| }; | |
| // Try each side specified in the options to see on which one the arrow | |
| // should be placed such that the distance between the tip of the arrow and | |
| // the desired coordinates is the shortest. | |
| $.each( ( optionValue === true ? "l,t,r,b" : optionValue ).split( "," ), | |
| $.proxy( function( key, value ) { | |
| best = this._tryAnArrow( params[ value ], value, desired, state, best ); | |
| }, this ) ); | |
| // Could not place the arrow along any of the edges - behave as if showing | |
| // the arrow was turned off. | |
| if ( !best ) { | |
| ar.arEls.hide(); | |
| return this._super( desired ); | |
| } | |
| // Move the arrow into place | |
| ar.ct | |
| .removeClass( "ui-popup-arrow-l ui-popup-arrow-t ui-popup-arrow-r ui-popup-arrow-b" ) | |
| .addClass( "ui-popup-arrow-" + best.dir ) | |
| .removeAttr( "style" ).css( best.posProp, best.posVal ) | |
| .show(); | |
| // Do not move/size the background div on IE, because we use the arrow div for background as well. | |
| if ( !ieHack ) { | |
| elOffset = this.element.offset(); | |
| bgRef[ params[ best.dir ].fst ] = ar.ct.offset(); | |
| bgRef[ params[ best.dir ].snd ] = { | |
| left: elOffset.left + state.contentBox.x, | |
| top: elOffset.top + state.contentBox.y | |
| }; | |
| } | |
| return best.result; | |
| }, | |
| _setOptions: function( opts ) { | |
| var newTheme, | |
| oldTheme = this.options.theme, | |
| ar = this._ui.arrow, | |
| ret = this._super( opts ); | |
| if ( opts.arrow !== undefined ) { | |
| if ( !ar && opts.arrow ) { | |
| this._ui.arrow = this._addArrow(); | |
| // Important to return here so we don't set the same options all over | |
| // again below. | |
| return; | |
| } else if ( ar && !opts.arrow ) { | |
| ar.arEls.remove(); | |
| this._ui.arrow = null; | |
| } | |
| } | |
| // Reassign with potentially new arrow | |
| ar = this._ui.arrow; | |
| if ( ar ) { | |
| if ( opts.theme !== undefined ) { | |
| oldTheme = this._themeClassFromOption( "ui-body-", oldTheme ); | |
| newTheme = this._themeClassFromOption( "ui-body-", opts.theme ); | |
| ar.ar.removeClass( oldTheme ).addClass( newTheme ); | |
| } | |
| if ( opts.shadow !== undefined ) { | |
| ar.ar.toggleClass( "ui-overlay-shadow", opts.shadow ); | |
| } | |
| } | |
| return ret; | |
| }, | |
| _destroy: function() { | |
| var ar = this._ui.arrow; | |
| if ( ar ) { | |
| ar.arEls.remove(); | |
| } | |
| return this._super(); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.panel", { | |
| options: { | |
| classes: { | |
| panel: "ui-panel", | |
| panelOpen: "ui-panel-open", | |
| panelClosed: "ui-panel-closed", | |
| panelFixed: "ui-panel-fixed", | |
| panelInner: "ui-panel-inner", | |
| modal: "ui-panel-dismiss", | |
| modalOpen: "ui-panel-dismiss-open", | |
| pageContainer: "ui-panel-page-container", | |
| pageWrapper: "ui-panel-wrapper", | |
| pageFixedToolbar: "ui-panel-fixed-toolbar", | |
| pageContentPrefix: "ui-panel-page-content", /* Used for wrapper and fixed toolbars position, display and open classes. */ | |
| animate: "ui-panel-animate" | |
| }, | |
| animate: true, | |
| theme: null, | |
| position: "left", | |
| dismissible: true, | |
| display: "reveal", //accepts reveal, push, overlay | |
| swipeClose: true, | |
| positionFixed: false | |
| }, | |
| _closeLink: null, | |
| _parentPage: null, | |
| _page: null, | |
| _modal: null, | |
| _panelInner: null, | |
| _wrapper: null, | |
| _fixedToolbars: null, | |
| _create: function() { | |
| var el = this.element, | |
| parentPage = el.closest( ".ui-page, :jqmData(role='page')" ); | |
| // expose some private props to other methods | |
| $.extend( this, { | |
| _closeLink: el.find( ":jqmData(rel='close')" ), | |
| _parentPage: ( parentPage.length > 0 ) ? parentPage : false, | |
| _openedPage: null, | |
| _page: this._getPage, | |
| _panelInner: this._getPanelInner(), | |
| _fixedToolbars: this._getFixedToolbars | |
| }); | |
| if ( this.options.display !== "overlay" ){ | |
| this._getWrapper(); | |
| } | |
| this._addPanelClasses(); | |
| // if animating, add the class to do so | |
| if ( $.support.cssTransform3d && !!this.options.animate ) { | |
| this.element.addClass( this.options.classes.animate ); | |
| } | |
| this._bindUpdateLayout(); | |
| this._bindCloseEvents(); | |
| this._bindLinkListeners(); | |
| this._bindPageEvents(); | |
| if ( !!this.options.dismissible ) { | |
| this._createModal(); | |
| } | |
| this._bindSwipeEvents(); | |
| }, | |
| _getPanelInner: function() { | |
| var panelInner = this.element.find( "." + this.options.classes.panelInner ); | |
| if ( panelInner.length === 0 ) { | |
| panelInner = this.element.children().wrapAll( "<div class='" + this.options.classes.panelInner + "' />" ).parent(); | |
| } | |
| return panelInner; | |
| }, | |
| _createModal: function() { | |
| var self = this, | |
| target = self._parentPage ? self._parentPage.parent() : self.element.parent(); | |
| self._modal = $( "<div class='" + self.options.classes.modal + "'></div>" ) | |
| .on( "mousedown", function() { | |
| self.close(); | |
| }) | |
| .appendTo( target ); | |
| }, | |
| _getPage: function() { | |
| var page = this._openedPage || this._parentPage || $( "." + $.mobile.activePageClass ); | |
| return page; | |
| }, | |
| _getWrapper: function() { | |
| var wrapper = this._page().find( "." + this.options.classes.pageWrapper ); | |
| if ( wrapper.length === 0 ) { | |
| wrapper = this._page().children( ".ui-header:not(.ui-header-fixed), .ui-content:not(.ui-popup), .ui-footer:not(.ui-footer-fixed)" ) | |
| .wrapAll( "<div class='" + this.options.classes.pageWrapper + "'></div>" ) | |
| .parent(); | |
| } | |
| this._wrapper = wrapper; | |
| }, | |
| _getFixedToolbars: function() { | |
| var extFixedToolbars = $( "body" ).children( ".ui-header-fixed, .ui-footer-fixed" ), | |
| intFixedToolbars = this._page().find( ".ui-header-fixed, .ui-footer-fixed" ), | |
| fixedToolbars = extFixedToolbars.add( intFixedToolbars ).addClass( this.options.classes.pageFixedToolbar ); | |
| return fixedToolbars; | |
| }, | |
| _getPosDisplayClasses: function( prefix ) { | |
| return prefix + "-position-" + this.options.position + " " + prefix + "-display-" + this.options.display; | |
| }, | |
| _getPanelClasses: function() { | |
| var panelClasses = this.options.classes.panel + | |
| " " + this._getPosDisplayClasses( this.options.classes.panel ) + | |
| " " + this.options.classes.panelClosed + | |
| " " + "ui-body-" + ( this.options.theme ? this.options.theme : "inherit" ); | |
| if ( !!this.options.positionFixed ) { | |
| panelClasses += " " + this.options.classes.panelFixed; | |
| } | |
| return panelClasses; | |
| }, | |
| _addPanelClasses: function() { | |
| this.element.addClass( this._getPanelClasses() ); | |
| }, | |
| _handleCloseClick: function( event ) { | |
| if ( !event.isDefaultPrevented() ) { | |
| this.close(); | |
| } | |
| }, | |
| _bindCloseEvents: function() { | |
| this._on( this._closeLink, { | |
| "click": "_handleCloseClick" | |
| }); | |
| this._on({ | |
| "click a:jqmData(ajax='false')": "_handleCloseClick" | |
| }); | |
| }, | |
| _positionPanel: function( scrollToTop ) { | |
| var self = this, | |
| panelInnerHeight = self._panelInner.outerHeight(), | |
| expand = panelInnerHeight > $.mobile.getScreenHeight(); | |
| if ( expand || !self.options.positionFixed ) { | |
| if ( expand ) { | |
| self._unfixPanel(); | |
| $.mobile.resetActivePageHeight( panelInnerHeight ); | |
| } | |
| if ( scrollToTop ) { | |
| this.window[ 0 ].scrollTo( 0, $.mobile.defaultHomeScroll ); | |
| } | |
| } else { | |
| self._fixPanel(); | |
| } | |
| }, | |
| _bindFixListener: function() { | |
| this._on( $( window ), { "throttledresize": "_positionPanel" }); | |
| }, | |
| _unbindFixListener: function() { | |
| this._off( $( window ), "throttledresize" ); | |
| }, | |
| _unfixPanel: function() { | |
| if ( !!this.options.positionFixed && $.support.fixedPosition ) { | |
| this.element.removeClass( this.options.classes.panelFixed ); | |
| } | |
| }, | |
| _fixPanel: function() { | |
| if ( !!this.options.positionFixed && $.support.fixedPosition ) { | |
| this.element.addClass( this.options.classes.panelFixed ); | |
| } | |
| }, | |
| _bindUpdateLayout: function() { | |
| var self = this; | |
| self.element.on( "updatelayout", function(/* e */) { | |
| if ( self._open ) { | |
| self._positionPanel(); | |
| } | |
| }); | |
| }, | |
| _bindLinkListeners: function() { | |
| this._on( "body", { | |
| "click a": "_handleClick" | |
| }); | |
| }, | |
| _handleClick: function( e ) { | |
| var link, | |
| panelId = this.element.attr( "id" ); | |
| if ( e.currentTarget.href.split( "#" )[ 1 ] === panelId && panelId !== undefined ) { | |
| e.preventDefault(); | |
| link = $( e.target ); | |
| if ( link.hasClass( "ui-btn" ) ) { | |
| link.addClass( $.mobile.activeBtnClass ); | |
| this.element.one( "panelopen panelclose", function() { | |
| link.removeClass( $.mobile.activeBtnClass ); | |
| }); | |
| } | |
| this.toggle(); | |
| } | |
| }, | |
| _bindSwipeEvents: function() { | |
| var self = this, | |
| area = self._modal ? self.element.add( self._modal ) : self.element; | |
| // on swipe, close the panel | |
| if ( !!self.options.swipeClose ) { | |
| if ( self.options.position === "left" ) { | |
| area.on( "swipeleft.panel", function(/* e */) { | |
| self.close(); | |
| }); | |
| } else { | |
| area.on( "swiperight.panel", function(/* e */) { | |
| self.close(); | |
| }); | |
| } | |
| } | |
| }, | |
| _bindPageEvents: function() { | |
| var self = this; | |
| this.document | |
| // Close the panel if another panel on the page opens | |
| .on( "panelbeforeopen", function( e ) { | |
| if ( self._open && e.target !== self.element[ 0 ] ) { | |
| self.close(); | |
| } | |
| }) | |
| // On escape, close? might need to have a target check too... | |
| .on( "keyup.panel", function( e ) { | |
| if ( e.keyCode === 27 && self._open ) { | |
| self.close(); | |
| } | |
| }); | |
| if ( !this._parentPage && this.options.display !== "overlay" ) { | |
| this._on( this.document, { | |
| "pageshow": "_getWrapper" | |
| }); | |
| } | |
| // Clean up open panels after page hide | |
| if ( self._parentPage ) { | |
| this.document.on( "pagehide", ":jqmData(role='page')", function() { | |
| if ( self._open ) { | |
| self.close( true ); | |
| } | |
| }); | |
| } else { | |
| this.document.on( "pagebeforehide", function() { | |
| if ( self._open ) { | |
| self.close( true ); | |
| } | |
| }); | |
| } | |
| }, | |
| // state storage of open or closed | |
| _open: false, | |
| _pageContentOpenClasses: null, | |
| _modalOpenClasses: null, | |
| open: function( immediate ) { | |
| if ( !this._open ) { | |
| var self = this, | |
| o = self.options, | |
| _openPanel = function() { | |
| self._off( self.document , "panelclose" ); | |
| self._page().jqmData( "panel", "open" ); | |
| if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) { | |
| self._wrapper.addClass( o.classes.animate ); | |
| self._fixedToolbars().addClass( o.classes.animate ); | |
| } | |
| if ( !immediate && $.support.cssTransform3d && !!o.animate ) { | |
| ( self._wrapper || self.element ) | |
| .animationComplete( complete, "transition" ); | |
| } else { | |
| setTimeout( complete, 0 ); | |
| } | |
| if ( o.theme && o.display !== "overlay" ) { | |
| self._page().parent() | |
| .addClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme ); | |
| } | |
| self.element | |
| .removeClass( o.classes.panelClosed ) | |
| .addClass( o.classes.panelOpen ); | |
| self._positionPanel( true ); | |
| self._pageContentOpenClasses = self._getPosDisplayClasses( o.classes.pageContentPrefix ); | |
| if ( o.display !== "overlay" ) { | |
| self._page().parent().addClass( o.classes.pageContainer ); | |
| self._wrapper.addClass( self._pageContentOpenClasses ); | |
| self._fixedToolbars().addClass( self._pageContentOpenClasses ); | |
| } | |
| self._modalOpenClasses = self._getPosDisplayClasses( o.classes.modal ) + " " + o.classes.modalOpen; | |
| if ( self._modal ) { | |
| self._modal | |
| .addClass( self._modalOpenClasses ) | |
| .height( Math.max( self._modal.height(), self.document.height() ) ); | |
| } | |
| }, | |
| complete = function() { | |
| // Bail if the panel was closed before the opening animation has completed | |
| if ( !self._open ) { | |
| return; | |
| } | |
| if ( o.display !== "overlay" ) { | |
| self._wrapper.addClass( o.classes.pageContentPrefix + "-open" ); | |
| self._fixedToolbars().addClass( o.classes.pageContentPrefix + "-open" ); | |
| } | |
| self._bindFixListener(); | |
| self._trigger( "open" ); | |
| self._openedPage = self._page(); | |
| }; | |
| self._trigger( "beforeopen" ); | |
| if ( self._page().jqmData( "panel" ) === "open" ) { | |
| self._on( self.document, { | |
| "panelclose": _openPanel | |
| }); | |
| } else { | |
| _openPanel(); | |
| } | |
| self._open = true; | |
| } | |
| }, | |
| close: function( immediate ) { | |
| if ( this._open ) { | |
| var self = this, | |
| o = this.options, | |
| _closePanel = function() { | |
| self.element.removeClass( o.classes.panelOpen ); | |
| if ( o.display !== "overlay" ) { | |
| self._wrapper.removeClass( self._pageContentOpenClasses ); | |
| self._fixedToolbars().removeClass( self._pageContentOpenClasses ); | |
| } | |
| if ( !immediate && $.support.cssTransform3d && !!o.animate ) { | |
| ( self._wrapper || self.element ) | |
| .animationComplete( complete, "transition" ); | |
| } else { | |
| setTimeout( complete, 0 ); | |
| } | |
| if ( self._modal ) { | |
| self._modal | |
| .removeClass( self._modalOpenClasses ) | |
| .height( "" ); | |
| } | |
| }, | |
| complete = function() { | |
| if ( o.theme && o.display !== "overlay" ) { | |
| self._page().parent().removeClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme ); | |
| } | |
| self.element.addClass( o.classes.panelClosed ); | |
| if ( o.display !== "overlay" ) { | |
| self._page().parent().removeClass( o.classes.pageContainer ); | |
| self._wrapper.removeClass( o.classes.pageContentPrefix + "-open" ); | |
| self._fixedToolbars().removeClass( o.classes.pageContentPrefix + "-open" ); | |
| } | |
| if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) { | |
| self._wrapper.removeClass( o.classes.animate ); | |
| self._fixedToolbars().removeClass( o.classes.animate ); | |
| } | |
| self._fixPanel(); | |
| self._unbindFixListener(); | |
| $.mobile.resetActivePageHeight(); | |
| self._page().jqmRemoveData( "panel" ); | |
| self._trigger( "close" ); | |
| self._openedPage = null; | |
| }; | |
| self._trigger( "beforeclose" ); | |
| _closePanel(); | |
| self._open = false; | |
| } | |
| }, | |
| toggle: function() { | |
| this[ this._open ? "close" : "open" ](); | |
| }, | |
| _destroy: function() { | |
| var otherPanels, | |
| o = this.options, | |
| multiplePanels = ( $( "body > :mobile-panel" ).length + $.mobile.activePage.find( ":mobile-panel" ).length ) > 1; | |
| if ( o.display !== "overlay" ) { | |
| // remove the wrapper if not in use by another panel | |
| otherPanels = $( "body > :mobile-panel" ).add( $.mobile.activePage.find( ":mobile-panel" ) ); | |
| if ( otherPanels.not( ".ui-panel-display-overlay" ).not( this.element ).length === 0 ) { | |
| this._wrapper.children().unwrap(); | |
| } | |
| if ( this._open ) { | |
| this._fixedToolbars().removeClass( o.classes.pageContentPrefix + "-open" ); | |
| if ( $.support.cssTransform3d && !!o.animate ) { | |
| this._fixedToolbars().removeClass( o.classes.animate ); | |
| } | |
| this._page().parent().removeClass( o.classes.pageContainer ); | |
| if ( o.theme ) { | |
| this._page().parent().removeClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme ); | |
| } | |
| } | |
| } | |
| if ( !multiplePanels ) { | |
| this.document.off( "panelopen panelclose" ); | |
| } | |
| if ( this._open ) { | |
| this._page().jqmRemoveData( "panel" ); | |
| } | |
| this._panelInner.children().unwrap(); | |
| this.element | |
| .removeClass( [ this._getPanelClasses(), o.classes.panelOpen, o.classes.animate ].join( " " ) ) | |
| .off( "swipeleft.panel swiperight.panel" ) | |
| .off( "panelbeforeopen" ) | |
| .off( "panelhide" ) | |
| .off( "keyup.panel" ) | |
| .off( "updatelayout" ); | |
| if ( this._modal ) { | |
| this._modal.remove(); | |
| } | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.table", { | |
| options: { | |
| classes: { | |
| table: "ui-table" | |
| }, | |
| enhanced: false | |
| }, | |
| _create: function() { | |
| if ( !this.options.enhanced ) { | |
| this.element.addClass( this.options.classes.table ); | |
| } | |
| // extend here, assign on refresh > _setHeaders | |
| $.extend( this, { | |
| // Expose headers and allHeaders properties on the widget | |
| // headers references the THs within the first TR in the table | |
| headers: undefined, | |
| // allHeaders references headers, plus all THs in the thead, which may | |
| // include several rows, or not | |
| allHeaders: undefined | |
| }); | |
| this._refresh( true ); | |
| }, | |
| _setHeaders: function() { | |
| var trs = this.element.find( "thead tr" ); | |
| this.headers = this.element.find( "tr:eq(0)" ).children(); | |
| this.allHeaders = this.headers.add( trs.children() ); | |
| }, | |
| refresh: function() { | |
| this._refresh(); | |
| }, | |
| rebuild: $.noop, | |
| _refresh: function( /* create */ ) { | |
| var table = this.element, | |
| trs = table.find( "thead tr" ); | |
| // updating headers on refresh (fixes #5880) | |
| this._setHeaders(); | |
| // Iterate over the trs | |
| trs.each( function() { | |
| var columnCount = 0; | |
| // Iterate over the children of the tr | |
| $( this ).children().each( function() { | |
| var span = parseInt( this.getAttribute( "colspan" ), 10 ), | |
| selector = ":nth-child(" + ( columnCount + 1 ) + ")", | |
| j; | |
| this.setAttribute( "data-" + $.mobile.ns + "colstart", columnCount + 1 ); | |
| if ( span ) { | |
| for( j = 0; j < span - 1; j++ ) { | |
| columnCount++; | |
| selector += ", :nth-child(" + ( columnCount + 1 ) + ")"; | |
| } | |
| } | |
| // Store "cells" data on header as a reference to all cells in the | |
| // same column as this TH | |
| $( this ).jqmData( "cells", table.find( "tr" ).not( trs.eq( 0 ) ).not( this ).children( selector ) ); | |
| columnCount++; | |
| }); | |
| }); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.table", $.mobile.table, { | |
| options: { | |
| mode: "columntoggle", | |
| columnBtnTheme: null, | |
| columnPopupTheme: null, | |
| columnBtnText: "Columns...", | |
| classes: $.extend( $.mobile.table.prototype.options.classes, { | |
| popup: "ui-table-columntoggle-popup", | |
| columnBtn: "ui-table-columntoggle-btn", | |
| priorityPrefix: "ui-table-priority-", | |
| columnToggleTable: "ui-table-columntoggle" | |
| }) | |
| }, | |
| _create: function() { | |
| this._super(); | |
| if ( this.options.mode !== "columntoggle" ) { | |
| return; | |
| } | |
| $.extend( this, { | |
| _menu: null | |
| }); | |
| if ( this.options.enhanced ) { | |
| this._menu = $( this.document[ 0 ].getElementById( this._id() + "-popup" ) ).children().first(); | |
| this._addToggles( this._menu, true ); | |
| } else { | |
| this._menu = this._enhanceColToggle(); | |
| this.element.addClass( this.options.classes.columnToggleTable ); | |
| } | |
| this._setupEvents(); | |
| this._setToggleState(); | |
| }, | |
| _id: function() { | |
| return ( this.element.attr( "id" ) || ( this.widgetName + this.uuid ) ); | |
| }, | |
| _setupEvents: function() { | |
| //NOTE: inputs are bound in bindToggles, | |
| // so it can be called on refresh, too | |
| // update column toggles on resize | |
| this._on( this.window, { | |
| throttledresize: "_setToggleState" | |
| }); | |
| this._on( this._menu, { | |
| "change input": "_menuInputChange" | |
| }); | |
| }, | |
| _addToggles: function( menu, keep ) { | |
| var inputs, | |
| checkboxIndex = 0, | |
| opts = this.options, | |
| container = menu.controlgroup( "container" ); | |
| // allow update of menu on refresh (fixes #5880) | |
| if ( keep ) { | |
| inputs = menu.find( "input" ); | |
| } else { | |
| container.empty(); | |
| } | |
| // create the hide/show toggles | |
| this.headers.not( "td" ).each( function() { | |
| var input, cells, | |
| header = $( this ), | |
| priority = $.mobile.getAttribute( this, "priority" ); | |
| if ( priority ) { | |
| cells = header.add( header.jqmData( "cells" ) ); | |
| cells.addClass( opts.classes.priorityPrefix + priority ); | |
| // Make sure the (new?) checkbox is associated with its header via .jqmData() and | |
| // that, vice versa, the header is also associated with the checkbox | |
| input = ( keep ? inputs.eq( checkboxIndex++ ) : | |
| $("<label><input type='checkbox' checked />" + | |
| ( header.children( "abbr" ).first().attr( "title" ) || | |
| header.text() ) + | |
| "</label>" ) | |
| .appendTo( container ) | |
| .children( 0 ) | |
| .checkboxradio( { | |
| theme: opts.columnPopupTheme | |
| }) ) | |
| // Associate the header with the checkbox | |
| .jqmData( "header", header ) | |
| .jqmData( "cells", cells ); | |
| // Associate the checkbox with the header | |
| header.jqmData( "input", input ); | |
| } | |
| }); | |
| // set bindings here | |
| if ( !keep ) { | |
| menu.controlgroup( "refresh" ); | |
| } | |
| }, | |
| _menuInputChange: function( evt ) { | |
| var input = $( evt.target ), | |
| checked = input[ 0 ].checked; | |
| input.jqmData( "cells" ) | |
| .toggleClass( "ui-table-cell-hidden", !checked ) | |
| .toggleClass( "ui-table-cell-visible", checked ); | |
| }, | |
| _unlockCells: function( cells ) { | |
| // allow hide/show via CSS only = remove all toggle-locks | |
| cells.removeClass( "ui-table-cell-hidden ui-table-cell-visible"); | |
| }, | |
| _enhanceColToggle: function() { | |
| var id , menuButton, popup, menu, | |
| table = this.element, | |
| opts = this.options, | |
| ns = $.mobile.ns, | |
| fragment = this.document[ 0 ].createDocumentFragment(); | |
| id = this._id() + "-popup"; | |
| menuButton = $( "<a href='#" + id + "' " + | |
| "class='" + opts.classes.columnBtn + " ui-btn " + | |
| "ui-btn-" + ( opts.columnBtnTheme || "a" ) + | |
| " ui-corner-all ui-shadow ui-mini' " + | |
| "data-" + ns + "rel='popup'>" + opts.columnBtnText + "</a>" ); | |
| popup = $( "<div class='" + opts.classes.popup + "' id='" + id + "'></div>" ); | |
| menu = $( "<fieldset></fieldset>" ).controlgroup(); | |
| // set extension here, send "false" to trigger build/rebuild | |
| this._addToggles( menu, false ); | |
| menu.appendTo( popup ); | |
| fragment.appendChild( popup[ 0 ] ); | |
| fragment.appendChild( menuButton[ 0 ] ); | |
| table.before( fragment ); | |
| popup.popup(); | |
| return menu; | |
| }, | |
| rebuild: function() { | |
| this._super(); | |
| if ( this.options.mode === "columntoggle" ) { | |
| // NOTE: rebuild passes "false", while refresh passes "undefined" | |
| // both refresh the table, but inside addToggles, !false will be true, | |
| // so a rebuild call can be indentified | |
| this._refresh( false ); | |
| } | |
| }, | |
| _refresh: function( create ) { | |
| var headers, hiddenColumns, index; | |
| // Calling _super() here updates this.headers | |
| this._super( create ); | |
| if ( !create && this.options.mode === "columntoggle" ) { | |
| headers = this.headers; | |
| hiddenColumns = []; | |
| // Find the index of the column header associated with each old checkbox among the | |
| // post-refresh headers and, if the header is still there, make sure the corresponding | |
| // column will be hidden if the pre-refresh checkbox indicates that the column is | |
| // hidden by recording its index in the array of hidden columns. | |
| this._menu.find( "input" ).each( function() { | |
| var input = $( this ), | |
| header = input.jqmData( "header" ), | |
| index = headers.index( header[ 0 ] ); | |
| if ( index > -1 && !input.prop( "checked" ) ) { | |
| // The column header associated with /this/ checkbox is still present in the | |
| // post-refresh table and the checkbox is not checked, so the column associated | |
| // with this column header is currently hidden. Let's record that. | |
| hiddenColumns.push( index ); | |
| } | |
| }); | |
| // columns not being replaced must be cleared from input toggle-locks | |
| this._unlockCells( this.element.find( ".ui-table-cell-hidden, " + | |
| ".ui-table-cell-visible" ) ); | |
| // update columntoggles and cells | |
| this._addToggles( this._menu, create ); | |
| // At this point all columns are visible, so uncheck the checkboxes that correspond to | |
| // those columns we've found to be hidden | |
| for ( index = hiddenColumns.length - 1 ; index > -1 ; index-- ) { | |
| headers.eq( hiddenColumns[ index ] ).jqmData( "input" ) | |
| .prop( "checked", false ) | |
| .checkboxradio( "refresh" ) | |
| .trigger( "change" ); | |
| } | |
| } | |
| }, | |
| _setToggleState: function() { | |
| this._menu.find( "input" ).each( function() { | |
| var checkbox = $( this ); | |
| this.checked = checkbox.jqmData( "cells" ).eq( 0 ).css( "display" ) === "table-cell"; | |
| checkbox.checkboxradio( "refresh" ); | |
| }); | |
| }, | |
| _destroy: function() { | |
| this._super(); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| $.widget( "mobile.table", $.mobile.table, { | |
| options: { | |
| mode: "reflow", | |
| classes: $.extend( $.mobile.table.prototype.options.classes, { | |
| reflowTable: "ui-table-reflow", | |
| cellLabels: "ui-table-cell-label" | |
| }) | |
| }, | |
| _create: function() { | |
| this._super(); | |
| // If it's not reflow mode, return here. | |
| if ( this.options.mode !== "reflow" ) { | |
| return; | |
| } | |
| if ( !this.options.enhanced ) { | |
| this.element.addClass( this.options.classes.reflowTable ); | |
| this._updateReflow(); | |
| } | |
| }, | |
| rebuild: function() { | |
| this._super(); | |
| if ( this.options.mode === "reflow" ) { | |
| this._refresh( false ); | |
| } | |
| }, | |
| _refresh: function( create ) { | |
| this._super( create ); | |
| if ( !create && this.options.mode === "reflow" ) { | |
| this._updateReflow( ); | |
| } | |
| }, | |
| _updateReflow: function() { | |
| var table = this, | |
| opts = this.options; | |
| // get headers in reverse order so that top-level headers are appended last | |
| $( table.allHeaders.get().reverse() ).each( function() { | |
| var cells = $( this ).jqmData( "cells" ), | |
| colstart = $.mobile.getAttribute( this, "colstart" ), | |
| hierarchyClass = cells.not( this ).filter( "thead th" ).length && " ui-table-cell-label-top", | |
| contents = $( this ).clone().contents(), | |
| iteration, filter; | |
| if ( contents.length > 0 ) { | |
| if ( hierarchyClass ) { | |
| iteration = parseInt( this.getAttribute( "colspan" ), 10 ); | |
| filter = ""; | |
| if ( iteration ) { | |
| filter = "td:nth-child("+ iteration +"n + " + ( colstart ) +")"; | |
| } | |
| table._addLabels( cells.filter( filter ), | |
| opts.classes.cellLabels + hierarchyClass, contents ); | |
| } else { | |
| table._addLabels( cells, opts.classes.cellLabels, contents ); | |
| } | |
| } | |
| }); | |
| }, | |
| _addLabels: function( cells, label, contents ) { | |
| // .not fixes #6006 | |
| cells | |
| .not( ":has(b." + label + ")" ) | |
| .prepend( $( "<b class='" + label + "'></b>" ).append( contents ) ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| // TODO rename filterCallback/deprecate and default to the item itself as the first argument | |
| var defaultFilterCallback = function( index, searchValue ) { | |
| return ( ( "" + ( $.mobile.getAttribute( this, "filtertext" ) || $( this ).text() ) ) | |
| .toLowerCase().indexOf( searchValue ) === -1 ); | |
| }; | |
| $.widget( "mobile.filterable", { | |
| initSelector: ":jqmData(filter='true')", | |
| options: { | |
| filterReveal: false, | |
| filterCallback: defaultFilterCallback, | |
| enhanced: false, | |
| input: null, | |
| children: "> li, > option, > optgroup option, > tbody tr, > .ui-controlgroup-controls > .ui-btn, > .ui-controlgroup-controls > .ui-checkbox, > .ui-controlgroup-controls > .ui-radio" | |
| }, | |
| _create: function() { | |
| var opts = this.options; | |
| $.extend( this, { | |
| _search: null, | |
| _timer: 0 | |
| }); | |
| this._setInput( opts.input ); | |
| if ( !opts.enhanced ) { | |
| this._filterItems( ( ( this._search && this._search.val() ) || "" ).toLowerCase() ); | |
| } | |
| }, | |
| _onKeyUp: function() { | |
| var val, lastval, | |
| search = this._search; | |
| if ( search ) { | |
| val = search.val().toLowerCase(), | |
| lastval = $.mobile.getAttribute( search[ 0 ], "lastval" ) + ""; | |
| if ( lastval && lastval === val ) { | |
| // Execute the handler only once per value change | |
| return; | |
| } | |
| if ( this._timer ) { | |
| window.clearTimeout( this._timer ); | |
| this._timer = 0; | |
| } | |
| this._timer = this._delay( function() { | |
| if ( this._trigger( "beforefilter", null, { input: search } ) === false ) { | |
| return false; | |
| } | |
| // Change val as lastval for next execution | |
| search[ 0 ].setAttribute( "data-" + $.mobile.ns + "lastval", val ); | |
| this._filterItems( val ); | |
| this._timer = 0; | |
| }, 250 ); | |
| } | |
| }, | |
| _getFilterableItems: function() { | |
| var elem = this.element, | |
| children = this.options.children, | |
| items = !children ? { length: 0 }: | |
| $.isFunction( children ) ? children(): | |
| children.nodeName ? $( children ): | |
| children.jquery ? children: | |
| this.element.find( children ); | |
| if ( items.length === 0 ) { | |
| items = elem.children(); | |
| } | |
| return items; | |
| }, | |
| _filterItems: function( val ) { | |
| var idx, callback, length, dst, | |
| show = [], | |
| hide = [], | |
| opts = this.options, | |
| filterItems = this._getFilterableItems(); | |
| if ( val != null ) { | |
| callback = opts.filterCallback || defaultFilterCallback; | |
| length = filterItems.length; | |
| // Partition the items into those to be hidden and those to be shown | |
| for ( idx = 0 ; idx < length ; idx++ ) { | |
| dst = ( callback.call( filterItems[ idx ], idx, val ) ) ? hide : show; | |
| dst.push( filterItems[ idx ] ); | |
| } | |
| } | |
| // If nothing is hidden, then the decision whether to hide or show the items | |
| // is based on the "filterReveal" option. | |
| if ( hide.length === 0 ) { | |
| filterItems[ ( opts.filterReveal && val.length === 0 ) ? | |
| "addClass" : "removeClass" ]( "ui-screen-hidden" ); | |
| } else { | |
| $( hide ).addClass( "ui-screen-hidden" ); | |
| $( show ).removeClass( "ui-screen-hidden" ); | |
| } | |
| this._refreshChildWidget(); | |
| this._trigger( "filter", null, { | |
| items: filterItems | |
| }); | |
| }, | |
| // The Default implementation of _refreshChildWidget attempts to call | |
| // refresh on collapsibleset, controlgroup, selectmenu, or listview | |
| _refreshChildWidget: function() { | |
| var widget, idx, | |
| recognizedWidgets = [ "collapsibleset", "selectmenu", "controlgroup", "listview" ]; | |
| for ( idx = recognizedWidgets.length - 1 ; idx > -1 ; idx-- ) { | |
| widget = recognizedWidgets[ idx ]; | |
| if ( $.mobile[ widget ] ) { | |
| widget = this.element.data( "mobile-" + widget ); | |
| if ( widget && $.isFunction( widget.refresh ) ) { | |
| widget.refresh(); | |
| } | |
| } | |
| } | |
| }, | |
| // TODO: When the input is not internal, do not even store it in this._search | |
| _setInput: function ( selector ) { | |
| var search = this._search; | |
| // Stop a pending filter operation | |
| if ( this._timer ) { | |
| window.clearTimeout( this._timer ); | |
| this._timer = 0; | |
| } | |
| if ( search ) { | |
| this._off( search, "keyup change input" ); | |
| search = null; | |
| } | |
| if ( selector ) { | |
| search = selector.jquery ? selector: | |
| selector.nodeName ? $( selector ): | |
| this.document.find( selector ); | |
| this._on( search, { | |
| keydown: "_onKeyDown", | |
| keypress: "_onKeyPress", | |
| keyup: "_onKeyUp", | |
| change: "_onKeyUp", | |
| input: "_onKeyUp" | |
| }); | |
| } | |
| this._search = search; | |
| }, | |
| // Prevent form submission | |
| _onKeyDown: function( event ) { | |
| if ( event.keyCode === $.ui.keyCode.ENTER ) { | |
| event.preventDefault(); | |
| this._preventKeyPress = true; | |
| } | |
| }, | |
| _onKeyPress: function( event ) { | |
| if ( this._preventKeyPress ) { | |
| event.preventDefault(); | |
| this._preventKeyPress = false; | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| var refilter = !( ( options.filterReveal === undefined ) && | |
| ( options.filterCallback === undefined ) && | |
| ( options.children === undefined ) ); | |
| this._super( options ); | |
| if ( options.input !== undefined ) { | |
| this._setInput( options.input ); | |
| refilter = true; | |
| } | |
| if ( refilter ) { | |
| this.refresh(); | |
| } | |
| }, | |
| _destroy: function() { | |
| var opts = this.options, | |
| items = this._getFilterableItems(); | |
| if ( opts.enhanced ) { | |
| items.toggleClass( "ui-screen-hidden", opts.filterReveal ); | |
| } else { | |
| items.removeClass( "ui-screen-hidden" ); | |
| } | |
| }, | |
| refresh: function() { | |
| if ( this._timer ) { | |
| window.clearTimeout( this._timer ); | |
| this._timer = 0; | |
| } | |
| this._filterItems( ( ( this._search && this._search.val() ) || "" ).toLowerCase() ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| // Create a function that will replace the _setOptions function of a widget, | |
| // and will pass the options on to the input of the filterable. | |
| var replaceSetOptions = function( self, orig ) { | |
| return function( options ) { | |
| orig.call( this, options ); | |
| self._syncTextInputOptions( options ); | |
| }; | |
| }, | |
| rDividerListItem = /(^|\s)ui-li-divider(\s|$)/, | |
| origDefaultFilterCallback = $.mobile.filterable.prototype.options.filterCallback; | |
| // Override the default filter callback with one that does not hide list dividers | |
| $.mobile.filterable.prototype.options.filterCallback = function( index, searchValue ) { | |
| return !this.className.match( rDividerListItem ) && | |
| origDefaultFilterCallback.call( this, index, searchValue ); | |
| }; | |
| $.widget( "mobile.filterable", $.mobile.filterable, { | |
| options: { | |
| filterPlaceholder: "Filter items...", | |
| filterTheme: null | |
| }, | |
| _create: function() { | |
| var idx, widgetName, | |
| elem = this.element, | |
| recognizedWidgets = [ "collapsibleset", "selectmenu", "controlgroup", "listview" ], | |
| createHandlers = {}; | |
| this._super(); | |
| $.extend( this, { | |
| _widget: null | |
| }); | |
| for ( idx = recognizedWidgets.length - 1 ; idx > -1 ; idx-- ) { | |
| widgetName = recognizedWidgets[ idx ]; | |
| if ( $.mobile[ widgetName ] ) { | |
| if ( this._setWidget( elem.data( "mobile-" + widgetName ) ) ) { | |
| break; | |
| } else { | |
| createHandlers[ widgetName + "create" ] = "_handleCreate"; | |
| } | |
| } | |
| } | |
| if ( !this._widget ) { | |
| this._on( elem, createHandlers ); | |
| } | |
| }, | |
| _handleCreate: function( evt ) { | |
| this._setWidget( this.element.data( "mobile-" + evt.type.substring( 0, evt.type.length - 6 ) ) ); | |
| }, | |
| _trigger: function( type, event, data ) { | |
| if ( this._widget && this._widget.widgetFullName === "mobile-listview" && | |
| type === "beforefilter" ) { | |
| // Also trigger listviewbeforefilter if this widget is also a listview | |
| this._widget._trigger( "beforefilter", event, data ); | |
| } | |
| // Passing back the response enables calling preventDefault() | |
| return this._super( type, event, data ); | |
| }, | |
| _setWidget: function( widget ) { | |
| if ( !this._widget && widget ) { | |
| this._widget = widget; | |
| this._widget._setOptions = replaceSetOptions( this, this._widget._setOptions ); | |
| } | |
| if ( !!this._widget ) { | |
| this._syncTextInputOptions( this._widget.options ); | |
| if ( this._widget.widgetName === "listview" ) { | |
| this._widget.options.hideDividers = true; | |
| this._widget.element.listview( "refresh" ); | |
| } | |
| } | |
| return !!this._widget; | |
| }, | |
| _isSearchInternal: function() { | |
| return ( this._search && this._search.jqmData( "ui-filterable-" + this.uuid + "-internal" ) ); | |
| }, | |
| _setInput: function( selector ) { | |
| var opts = this.options, | |
| updatePlaceholder = true, | |
| textinputOpts = {}; | |
| if ( !selector ) { | |
| if ( this._isSearchInternal() ) { | |
| // Ignore the call to set a new input if the selector goes to falsy and | |
| // the current textinput is already of the internally generated variety. | |
| return; | |
| } else { | |
| // Generating a new textinput widget. No need to set the placeholder | |
| // further down the function. | |
| updatePlaceholder = false; | |
| selector = $( "<input " + | |
| "data-" + $.mobile.ns + "type='search' " + | |
| "placeholder='" + opts.filterPlaceholder + "'></input>" ) | |
| .jqmData( "ui-filterable-" + this.uuid + "-internal", true ); | |
| $( "<form class='ui-filterable'></form>" ) | |
| .append( selector ) | |
| .submit( function( evt ) { | |
| evt.preventDefault(); | |
| selector.blur(); | |
| }) | |
| .insertBefore( this.element ); | |
| if ( $.mobile.textinput ) { | |
| if ( this.options.filterTheme != null ) { | |
| textinputOpts[ "theme" ] = opts.filterTheme; | |
| } | |
| selector.textinput( textinputOpts ); | |
| } | |
| } | |
| } | |
| this._super( selector ); | |
| if ( this._isSearchInternal() && updatePlaceholder ) { | |
| this._search.attr( "placeholder", this.options.filterPlaceholder ); | |
| } | |
| }, | |
| _setOptions: function( options ) { | |
| var ret = this._super( options ); | |
| // Need to set the filterPlaceholder after having established the search input | |
| if ( options.filterPlaceholder !== undefined ) { | |
| if ( this._isSearchInternal() ) { | |
| this._search.attr( "placeholder", options.filterPlaceholder ); | |
| } | |
| } | |
| if ( options.filterTheme !== undefined && this._search && $.mobile.textinput ) { | |
| this._search.textinput( "option", "theme", options.filterTheme ); | |
| } | |
| return ret; | |
| }, | |
| _destroy: function() { | |
| if ( this._isSearchInternal() ) { | |
| this._search.remove(); | |
| } | |
| this._super(); | |
| }, | |
| _syncTextInputOptions: function( options ) { | |
| var idx, | |
| textinputOptions = {}; | |
| // We only sync options if the filterable's textinput is of the internally | |
| // generated variety, rather than one specified by the user. | |
| if ( this._isSearchInternal() && $.mobile.textinput ) { | |
| // Apply only the options understood by textinput | |
| for ( idx in $.mobile.textinput.prototype.options ) { | |
| if ( options[ idx ] !== undefined ) { | |
| if ( idx === "theme" && this.options.filterTheme != null ) { | |
| textinputOptions[ idx ] = this.options.filterTheme; | |
| } else { | |
| textinputOptions[ idx ] = options[ idx ]; | |
| } | |
| } | |
| } | |
| this._search.textinput( "option", textinputOptions ); | |
| } | |
| } | |
| }); | |
| // Instantiate a filterable on a listview that has the data-filter="true" attribute | |
| // This is not necessary for static content, because the auto-enhance takes care of instantiating | |
| // the filterable upon encountering data-filter="true". However, because of 1.3.x it is expected | |
| // that a listview with data-filter="true" will be filterable even if you just instantiate a | |
| // listview on it. The extension below ensures that this continues to happen in 1.4.x. | |
| $.widget( "mobile.listview", $.mobile.listview, { | |
| options: { | |
| filter: false | |
| }, | |
| _create: function() { | |
| if ( this.options.filter === true && | |
| !this.element.data( "mobile-filterable" ) ) { | |
| this.element.filterable(); | |
| } | |
| return this._super(); | |
| }, | |
| _afterListviewRefresh: function() { | |
| var filterable = this.element.data( "mobile-filterable" ); | |
| if ( this.options.filter === true && filterable ) { | |
| this._preventRefreshLoop = true; | |
| filterable.refresh(); | |
| } | |
| }, | |
| // Eliminate infinite recursion caused by the fact that we call filterable.refresh() from | |
| // _afterListviewRefresh() above, which, in turn, calls _refreshChildWidget(), which, in | |
| // turn, calls listview refresh(), which would, in turn, calls _afterListviewRefresh() | |
| // above, if we wouldn't prevent that right here. | |
| refresh: function() { | |
| var returnValue; | |
| if ( !this._preventRefreshLoop ) { | |
| returnValue = this._superApply( arguments ); | |
| } | |
| this._preventRefreshLoop = false; | |
| return returnValue; | |
| } | |
| }); | |
| })( jQuery ); | |
| /*! | |
| * jQuery UI Tabs fadf2b312a05040436451c64bbfaf4814bc62c56 | |
| * http://jqueryui.com | |
| * | |
| * Copyright 2013 jQuery Foundation and other contributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| * http://api.jqueryui.com/tabs/ | |
| * | |
| * Depends: | |
| * jquery.ui.core.js | |
| * jquery.ui.widget.js | |
| */ | |
| (function( $, undefined ) { | |
| var tabId = 0, | |
| rhash = /#.*$/; | |
| function getNextTabId() { | |
| return ++tabId; | |
| } | |
| function isLocal( anchor ) { | |
| return anchor.hash.length > 1 && | |
| decodeURIComponent( anchor.href.replace( rhash, "" ) ) === | |
| decodeURIComponent( location.href.replace( rhash, "" ) ); | |
| } | |
| $.widget( "ui.tabs", { | |
| version: "fadf2b312a05040436451c64bbfaf4814bc62c56", | |
| delay: 300, | |
| options: { | |
| active: null, | |
| collapsible: false, | |
| event: "click", | |
| heightStyle: "content", | |
| hide: null, | |
| show: null, | |
| // callbacks | |
| activate: null, | |
| beforeActivate: null, | |
| beforeLoad: null, | |
| load: null | |
| }, | |
| _create: function() { | |
| var that = this, | |
| options = this.options; | |
| this.running = false; | |
| this.element | |
| .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" ) | |
| .toggleClass( "ui-tabs-collapsible", options.collapsible ) | |
| // Prevent users from focusing disabled tabs via click | |
| .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) { | |
| if ( $( this ).is( ".ui-state-disabled" ) ) { | |
| event.preventDefault(); | |
| } | |
| }) | |
| // support: IE <9 | |
| // Preventing the default action in mousedown doesn't prevent IE | |
| // from focusing the element, so if the anchor gets focused, blur. | |
| // We don't have to worry about focusing the previously focused | |
| // element since clicking on a non-focusable element should focus | |
| // the body anyway. | |
| .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() { | |
| if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) { | |
| this.blur(); | |
| } | |
| }); | |
| this._processTabs(); | |
| options.active = this._initialActive(); | |
| // Take disabling tabs via class attribute from HTML | |
| // into account and update option properly. | |
| if ( $.isArray( options.disabled ) ) { | |
| options.disabled = $.unique( options.disabled.concat( | |
| $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) { | |
| return that.tabs.index( li ); | |
| }) | |
| ) ).sort(); | |
| } | |
| // check for length avoids error when initializing empty list | |
| if ( this.options.active !== false && this.anchors.length ) { | |
| this.active = this._findActive( options.active ); | |
| } else { | |
| this.active = $(); | |
| } | |
| this._refresh(); | |
| if ( this.active.length ) { | |
| this.load( options.active ); | |
| } | |
| }, | |
| _initialActive: function() { | |
| var active = this.options.active, | |
| collapsible = this.options.collapsible, | |
| locationHash = location.hash.substring( 1 ); | |
| if ( active === null ) { | |
| // check the fragment identifier in the URL | |
| if ( locationHash ) { | |
| this.tabs.each(function( i, tab ) { | |
| if ( $( tab ).attr( "aria-controls" ) === locationHash ) { | |
| active = i; | |
| return false; | |
| } | |
| }); | |
| } | |
| // check for a tab marked active via a class | |
| if ( active === null ) { | |
| active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) ); | |
| } | |
| // no active tab, set to false | |
| if ( active === null || active === -1 ) { | |
| active = this.tabs.length ? 0 : false; | |
| } | |
| } | |
| // handle numbers: negative, out of range | |
| if ( active !== false ) { | |
| active = this.tabs.index( this.tabs.eq( active ) ); | |
| if ( active === -1 ) { | |
| active = collapsible ? false : 0; | |
| } | |
| } | |
| // don't allow collapsible: false and active: false | |
| if ( !collapsible && active === false && this.anchors.length ) { | |
| active = 0; | |
| } | |
| return active; | |
| }, | |
| _getCreateEventData: function() { | |
| return { | |
| tab: this.active, | |
| panel: !this.active.length ? $() : this._getPanelForTab( this.active ) | |
| }; | |
| }, | |
| _tabKeydown: function( event ) { | |
| var focusedTab = $( this.document[0].activeElement ).closest( "li" ), | |
| selectedIndex = this.tabs.index( focusedTab ), | |
| goingForward = true; | |
| if ( this._handlePageNav( event ) ) { | |
| return; | |
| } | |
| switch ( event.keyCode ) { | |
| case $.ui.keyCode.RIGHT: | |
| case $.ui.keyCode.DOWN: | |
| selectedIndex++; | |
| break; | |
| case $.ui.keyCode.UP: | |
| case $.ui.keyCode.LEFT: | |
| goingForward = false; | |
| selectedIndex--; | |
| break; | |
| case $.ui.keyCode.END: | |
| selectedIndex = this.anchors.length - 1; | |
| break; | |
| case $.ui.keyCode.HOME: | |
| selectedIndex = 0; | |
| break; | |
| case $.ui.keyCode.SPACE: | |
| // Activate only, no collapsing | |
| event.preventDefault(); | |
| clearTimeout( this.activating ); | |
| this._activate( selectedIndex ); | |
| return; | |
| case $.ui.keyCode.ENTER: | |
| // Toggle (cancel delayed activation, allow collapsing) | |
| event.preventDefault(); | |
| clearTimeout( this.activating ); | |
| // Determine if we should collapse or activate | |
| this._activate( selectedIndex === this.options.active ? false : selectedIndex ); | |
| return; | |
| default: | |
| return; | |
| } | |
| // Focus the appropriate tab, based on which key was pressed | |
| event.preventDefault(); | |
| clearTimeout( this.activating ); | |
| selectedIndex = this._focusNextTab( selectedIndex, goingForward ); | |
| // Navigating with control key will prevent automatic activation | |
| if ( !event.ctrlKey ) { | |
| // Update aria-selected immediately so that AT think the tab is already selected. | |
| // Otherwise AT may confuse the user by stating that they need to activate the tab, | |
| // but the tab will already be activated by the time the announcement finishes. | |
| focusedTab.attr( "aria-selected", "false" ); | |
| this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" ); | |
| this.activating = this._delay(function() { | |
| this.option( "active", selectedIndex ); | |
| }, this.delay ); | |
| } | |
| }, | |
| _panelKeydown: function( event ) { | |
| if ( this._handlePageNav( event ) ) { | |
| return; | |
| } | |
| // Ctrl+up moves focus to the current tab | |
| if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) { | |
| event.preventDefault(); | |
| this.active.focus(); | |
| } | |
| }, | |
| // Alt+page up/down moves focus to the previous/next tab (and activates) | |
| _handlePageNav: function( event ) { | |
| if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) { | |
| this._activate( this._focusNextTab( this.options.active - 1, false ) ); | |
| return true; | |
| } | |
| if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) { | |
| this._activate( this._focusNextTab( this.options.active + 1, true ) ); | |
| return true; | |
| } | |
| }, | |
| _findNextTab: function( index, goingForward ) { | |
| var lastTabIndex = this.tabs.length - 1; | |
| function constrain() { | |
| if ( index > lastTabIndex ) { | |
| index = 0; | |
| } | |
| if ( index < 0 ) { | |
| index = lastTabIndex; | |
| } | |
| return index; | |
| } | |
| while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) { | |
| index = goingForward ? index + 1 : index - 1; | |
| } | |
| return index; | |
| }, | |
| _focusNextTab: function( index, goingForward ) { | |
| index = this._findNextTab( index, goingForward ); | |
| this.tabs.eq( index ).focus(); | |
| return index; | |
| }, | |
| _setOption: function( key, value ) { | |
| if ( key === "active" ) { | |
| // _activate() will handle invalid values and update this.options | |
| this._activate( value ); | |
| return; | |
| } | |
| if ( key === "disabled" ) { | |
| // don't use the widget factory's disabled handling | |
| this._setupDisabled( value ); | |
| return; | |
| } | |
| this._super( key, value); | |
| if ( key === "collapsible" ) { | |
| this.element.toggleClass( "ui-tabs-collapsible", value ); | |
| // Setting collapsible: false while collapsed; open first panel | |
| if ( !value && this.options.active === false ) { | |
| this._activate( 0 ); | |
| } | |
| } | |
| if ( key === "event" ) { | |
| this._setupEvents( value ); | |
| } | |
| if ( key === "heightStyle" ) { | |
| this._setupHeightStyle( value ); | |
| } | |
| }, | |
| _tabId: function( tab ) { | |
| return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId(); | |
| }, | |
| _sanitizeSelector: function( hash ) { | |
| return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : ""; | |
| }, | |
| refresh: function() { | |
| var options = this.options, | |
| lis = this.tablist.children( ":has(a[href])" ); | |
| // get disabled tabs from class attribute from HTML | |
| // this will get converted to a boolean if needed in _refresh() | |
| options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) { | |
| return lis.index( tab ); | |
| }); | |
| this._processTabs(); | |
| // was collapsed or no tabs | |
| if ( options.active === false || !this.anchors.length ) { | |
| options.active = false; | |
| this.active = $(); | |
| // was active, but active tab is gone | |
| } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) { | |
| // all remaining tabs are disabled | |
| if ( this.tabs.length === options.disabled.length ) { | |
| options.active = false; | |
| this.active = $(); | |
| // activate previous tab | |
| } else { | |
| this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) ); | |
| } | |
| // was active, active tab still exists | |
| } else { | |
| // make sure active index is correct | |
| options.active = this.tabs.index( this.active ); | |
| } | |
| this._refresh(); | |
| }, | |
| _refresh: function() { | |
| this._setupDisabled( this.options.disabled ); | |
| this._setupEvents( this.options.event ); | |
| this._setupHeightStyle( this.options.heightStyle ); | |
| this.tabs.not( this.active ).attr({ | |
| "aria-selected": "false", | |
| tabIndex: -1 | |
| }); | |
| this.panels.not( this._getPanelForTab( this.active ) ) | |
| .hide() | |
| .attr({ | |
| "aria-expanded": "false", | |
| "aria-hidden": "true" | |
| }); | |
| // Make sure one tab is in the tab order | |
| if ( !this.active.length ) { | |
| this.tabs.eq( 0 ).attr( "tabIndex", 0 ); | |
| } else { | |
| this.active | |
| .addClass( "ui-tabs-active ui-state-active" ) | |
| .attr({ | |
| "aria-selected": "true", | |
| tabIndex: 0 | |
| }); | |
| this._getPanelForTab( this.active ) | |
| .show() | |
| .attr({ | |
| "aria-expanded": "true", | |
| "aria-hidden": "false" | |
| }); | |
| } | |
| }, | |
| _processTabs: function() { | |
| var that = this; | |
| this.tablist = this._getList() | |
| .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" ) | |
| .attr( "role", "tablist" ); | |
| this.tabs = this.tablist.find( "> li:has(a[href])" ) | |
| .addClass( "ui-state-default ui-corner-top" ) | |
| .attr({ | |
| role: "tab", | |
| tabIndex: -1 | |
| }); | |
| this.anchors = this.tabs.map(function() { | |
| return $( "a", this )[ 0 ]; | |
| }) | |
| .addClass( "ui-tabs-anchor" ) | |
| .attr({ | |
| role: "presentation", | |
| tabIndex: -1 | |
| }); | |
| this.panels = $(); | |
| this.anchors.each(function( i, anchor ) { | |
| var selector, panel, panelId, | |
| anchorId = $( anchor ).uniqueId().attr( "id" ), | |
| tab = $( anchor ).closest( "li" ), | |
| originalAriaControls = tab.attr( "aria-controls" ); | |
| // inline tab | |
| if ( isLocal( anchor ) ) { | |
| selector = anchor.hash; | |
| panel = that.element.find( that._sanitizeSelector( selector ) ); | |
| // remote tab | |
| } else { | |
| panelId = that._tabId( tab ); | |
| selector = "#" + panelId; | |
| panel = that.element.find( selector ); | |
| if ( !panel.length ) { | |
| panel = that._createPanel( panelId ); | |
| panel.insertAfter( that.panels[ i - 1 ] || that.tablist ); | |
| } | |
| panel.attr( "aria-live", "polite" ); | |
| } | |
| if ( panel.length) { | |
| that.panels = that.panels.add( panel ); | |
| } | |
| if ( originalAriaControls ) { | |
| tab.data( "ui-tabs-aria-controls", originalAriaControls ); | |
| } | |
| tab.attr({ | |
| "aria-controls": selector.substring( 1 ), | |
| "aria-labelledby": anchorId | |
| }); | |
| panel.attr( "aria-labelledby", anchorId ); | |
| }); | |
| this.panels | |
| .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" ) | |
| .attr( "role", "tabpanel" ); | |
| }, | |
| // allow overriding how to find the list for rare usage scenarios (#7715) | |
| _getList: function() { | |
| return this.element.find( "ol,ul" ).eq( 0 ); | |
| }, | |
| _createPanel: function( id ) { | |
| return $( "<div>" ) | |
| .attr( "id", id ) | |
| .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" ) | |
| .data( "ui-tabs-destroy", true ); | |
| }, | |
| _setupDisabled: function( disabled ) { | |
| if ( $.isArray( disabled ) ) { | |
| if ( !disabled.length ) { | |
| disabled = false; | |
| } else if ( disabled.length === this.anchors.length ) { | |
| disabled = true; | |
| } | |
| } | |
| // disable tabs | |
| for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) { | |
| if ( disabled === true || $.inArray( i, disabled ) !== -1 ) { | |
| $( li ) | |
| .addClass( "ui-state-disabled" ) | |
| .attr( "aria-disabled", "true" ); | |
| } else { | |
| $( li ) | |
| .removeClass( "ui-state-disabled" ) | |
| .removeAttr( "aria-disabled" ); | |
| } | |
| } | |
| this.options.disabled = disabled; | |
| }, | |
| _setupEvents: function( event ) { | |
| var events = { | |
| click: function( event ) { | |
| event.preventDefault(); | |
| } | |
| }; | |
| if ( event ) { | |
| $.each( event.split(" "), function( index, eventName ) { | |
| events[ eventName ] = "_eventHandler"; | |
| }); | |
| } | |
| this._off( this.anchors.add( this.tabs ).add( this.panels ) ); | |
| this._on( this.anchors, events ); | |
| this._on( this.tabs, { keydown: "_tabKeydown" } ); | |
| this._on( this.panels, { keydown: "_panelKeydown" } ); | |
| this._focusable( this.tabs ); | |
| this._hoverable( this.tabs ); | |
| }, | |
| _setupHeightStyle: function( heightStyle ) { | |
| var maxHeight, | |
| parent = this.element.parent(); | |
| if ( heightStyle === "fill" ) { | |
| maxHeight = parent.height(); | |
| maxHeight -= this.element.outerHeight() - this.element.height(); | |
| this.element.siblings( ":visible" ).each(function() { | |
| var elem = $( this ), | |
| position = elem.css( "position" ); | |
| if ( position === "absolute" || position === "fixed" ) { | |
| return; | |
| } | |
| maxHeight -= elem.outerHeight( true ); | |
| }); | |
| this.element.children().not( this.panels ).each(function() { | |
| maxHeight -= $( this ).outerHeight( true ); | |
| }); | |
| this.panels.each(function() { | |
| $( this ).height( Math.max( 0, maxHeight - | |
| $( this ).innerHeight() + $( this ).height() ) ); | |
| }) | |
| .css( "overflow", "auto" ); | |
| } else if ( heightStyle === "auto" ) { | |
| maxHeight = 0; | |
| this.panels.each(function() { | |
| maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() ); | |
| }).height( maxHeight ); | |
| } | |
| }, | |
| _eventHandler: function( event ) { | |
| var options = this.options, | |
| active = this.active, | |
| anchor = $( event.currentTarget ), | |
| tab = anchor.closest( "li" ), | |
| clickedIsActive = tab[ 0 ] === active[ 0 ], | |
| collapsing = clickedIsActive && options.collapsible, | |
| toShow = collapsing ? $() : this._getPanelForTab( tab ), | |
| toHide = !active.length ? $() : this._getPanelForTab( active ), | |
| eventData = { | |
| oldTab: active, | |
| oldPanel: toHide, | |
| newTab: collapsing ? $() : tab, | |
| newPanel: toShow | |
| }; | |
| event.preventDefault(); | |
| if ( tab.hasClass( "ui-state-disabled" ) || | |
| // tab is already loading | |
| tab.hasClass( "ui-tabs-loading" ) || | |
| // can't switch durning an animation | |
| this.running || | |
| // click on active header, but not collapsible | |
| ( clickedIsActive && !options.collapsible ) || | |
| // allow canceling activation | |
| ( this._trigger( "beforeActivate", event, eventData ) === false ) ) { | |
| return; | |
| } | |
| options.active = collapsing ? false : this.tabs.index( tab ); | |
| this.active = clickedIsActive ? $() : tab; | |
| if ( this.xhr ) { | |
| this.xhr.abort(); | |
| } | |
| if ( !toHide.length && !toShow.length ) { | |
| $.error( "jQuery UI Tabs: Mismatching fragment identifier." ); | |
| } | |
| if ( toShow.length ) { | |
| this.load( this.tabs.index( tab ), event ); | |
| } | |
| this._toggle( event, eventData ); | |
| }, | |
| // handles show/hide for selecting tabs | |
| _toggle: function( event, eventData ) { | |
| var that = this, | |
| toShow = eventData.newPanel, | |
| toHide = eventData.oldPanel; | |
| this.running = true; | |
| function complete() { | |
| that.running = false; | |
| that._trigger( "activate", event, eventData ); | |
| } | |
| function show() { | |
| eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" ); | |
| if ( toShow.length && that.options.show ) { | |
| that._show( toShow, that.options.show, complete ); | |
| } else { | |
| toShow.show(); | |
| complete(); | |
| } | |
| } | |
| // start out by hiding, then showing, then completing | |
| if ( toHide.length && this.options.hide ) { | |
| this._hide( toHide, this.options.hide, function() { | |
| eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" ); | |
| show(); | |
| }); | |
| } else { | |
| eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" ); | |
| toHide.hide(); | |
| show(); | |
| } | |
| toHide.attr({ | |
| "aria-expanded": "false", | |
| "aria-hidden": "true" | |
| }); | |
| eventData.oldTab.attr( "aria-selected", "false" ); | |
| // If we're switching tabs, remove the old tab from the tab order. | |
| // If we're opening from collapsed state, remove the previous tab from the tab order. | |
| // If we're collapsing, then keep the collapsing tab in the tab order. | |
| if ( toShow.length && toHide.length ) { | |
| eventData.oldTab.attr( "tabIndex", -1 ); | |
| } else if ( toShow.length ) { | |
| this.tabs.filter(function() { | |
| return $( this ).attr( "tabIndex" ) === 0; | |
| }) | |
| .attr( "tabIndex", -1 ); | |
| } | |
| toShow.attr({ | |
| "aria-expanded": "true", | |
| "aria-hidden": "false" | |
| }); | |
| eventData.newTab.attr({ | |
| "aria-selected": "true", | |
| tabIndex: 0 | |
| }); | |
| }, | |
| _activate: function( index ) { | |
| var anchor, | |
| active = this._findActive( index ); | |
| // trying to activate the already active panel | |
| if ( active[ 0 ] === this.active[ 0 ] ) { | |
| return; | |
| } | |
| // trying to collapse, simulate a click on the current active header | |
| if ( !active.length ) { | |
| active = this.active; | |
| } | |
| anchor = active.find( ".ui-tabs-anchor" )[ 0 ]; | |
| this._eventHandler({ | |
| target: anchor, | |
| currentTarget: anchor, | |
| preventDefault: $.noop | |
| }); | |
| }, | |
| _findActive: function( index ) { | |
| return index === false ? $() : this.tabs.eq( index ); | |
| }, | |
| _getIndex: function( index ) { | |
| // meta-function to give users option to provide a href string instead of a numerical index. | |
| if ( typeof index === "string" ) { | |
| index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) ); | |
| } | |
| return index; | |
| }, | |
| _destroy: function() { | |
| if ( this.xhr ) { | |
| this.xhr.abort(); | |
| } | |
| this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" ); | |
| this.tablist | |
| .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" ) | |
| .removeAttr( "role" ); | |
| this.anchors | |
| .removeClass( "ui-tabs-anchor" ) | |
| .removeAttr( "role" ) | |
| .removeAttr( "tabIndex" ) | |
| .removeUniqueId(); | |
| this.tabs.add( this.panels ).each(function() { | |
| if ( $.data( this, "ui-tabs-destroy" ) ) { | |
| $( this ).remove(); | |
| } else { | |
| $( this ) | |
| .removeClass( "ui-state-default ui-state-active ui-state-disabled " + | |
| "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" ) | |
| .removeAttr( "tabIndex" ) | |
| .removeAttr( "aria-live" ) | |
| .removeAttr( "aria-busy" ) | |
| .removeAttr( "aria-selected" ) | |
| .removeAttr( "aria-labelledby" ) | |
| .removeAttr( "aria-hidden" ) | |
| .removeAttr( "aria-expanded" ) | |
| .removeAttr( "role" ); | |
| } | |
| }); | |
| this.tabs.each(function() { | |
| var li = $( this ), | |
| prev = li.data( "ui-tabs-aria-controls" ); | |
| if ( prev ) { | |
| li | |
| .attr( "aria-controls", prev ) | |
| .removeData( "ui-tabs-aria-controls" ); | |
| } else { | |
| li.removeAttr( "aria-controls" ); | |
| } | |
| }); | |
| this.panels.show(); | |
| if ( this.options.heightStyle !== "content" ) { | |
| this.panels.css( "height", "" ); | |
| } | |
| }, | |
| enable: function( index ) { | |
| var disabled = this.options.disabled; | |
| if ( disabled === false ) { | |
| return; | |
| } | |
| if ( index === undefined ) { | |
| disabled = false; | |
| } else { | |
| index = this._getIndex( index ); | |
| if ( $.isArray( disabled ) ) { | |
| disabled = $.map( disabled, function( num ) { | |
| return num !== index ? num : null; | |
| }); | |
| } else { | |
| disabled = $.map( this.tabs, function( li, num ) { | |
| return num !== index ? num : null; | |
| }); | |
| } | |
| } | |
| this._setupDisabled( disabled ); | |
| }, | |
| disable: function( index ) { | |
| var disabled = this.options.disabled; | |
| if ( disabled === true ) { | |
| return; | |
| } | |
| if ( index === undefined ) { | |
| disabled = true; | |
| } else { | |
| index = this._getIndex( index ); | |
| if ( $.inArray( index, disabled ) !== -1 ) { | |
| return; | |
| } | |
| if ( $.isArray( disabled ) ) { | |
| disabled = $.merge( [ index ], disabled ).sort(); | |
| } else { | |
| disabled = [ index ]; | |
| } | |
| } | |
| this._setupDisabled( disabled ); | |
| }, | |
| load: function( index, event ) { | |
| index = this._getIndex( index ); | |
| var that = this, | |
| tab = this.tabs.eq( index ), | |
| anchor = tab.find( ".ui-tabs-anchor" ), | |
| panel = this._getPanelForTab( tab ), | |
| eventData = { | |
| tab: tab, | |
| panel: panel | |
| }; | |
| // not remote | |
| if ( isLocal( anchor[ 0 ] ) ) { | |
| return; | |
| } | |
| this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) ); | |
| // support: jQuery <1.8 | |
| // jQuery <1.8 returns false if the request is canceled in beforeSend, | |
| // but as of 1.8, $.ajax() always returns a jqXHR object. | |
| if ( this.xhr && this.xhr.statusText !== "canceled" ) { | |
| tab.addClass( "ui-tabs-loading" ); | |
| panel.attr( "aria-busy", "true" ); | |
| this.xhr | |
| .success(function( response ) { | |
| // support: jQuery <1.8 | |
| // http://bugs.jquery.com/ticket/11778 | |
| setTimeout(function() { | |
| panel.html( response ); | |
| that._trigger( "load", event, eventData ); | |
| }, 1 ); | |
| }) | |
| .complete(function( jqXHR, status ) { | |
| // support: jQuery <1.8 | |
| // http://bugs.jquery.com/ticket/11778 | |
| setTimeout(function() { | |
| if ( status === "abort" ) { | |
| that.panels.stop( false, true ); | |
| } | |
| tab.removeClass( "ui-tabs-loading" ); | |
| panel.removeAttr( "aria-busy" ); | |
| if ( jqXHR === that.xhr ) { | |
| delete that.xhr; | |
| } | |
| }, 1 ); | |
| }); | |
| } | |
| }, | |
| _ajaxSettings: function( anchor, event, eventData ) { | |
| var that = this; | |
| return { | |
| url: anchor.attr( "href" ), | |
| beforeSend: function( jqXHR, settings ) { | |
| return that._trigger( "beforeLoad", event, | |
| $.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) ); | |
| } | |
| }; | |
| }, | |
| _getPanelForTab: function( tab ) { | |
| var id = $( tab ).attr( "aria-controls" ); | |
| return this.element.find( this._sanitizeSelector( "#" + id ) ); | |
| } | |
| }); | |
| })( jQuery ); | |
| (function( $, undefined ) { | |
| })( jQuery ); | |
| (function( $, window ) { | |
| $.mobile.iosorientationfixEnabled = true; | |
| // This fix addresses an iOS bug, so return early if the UA claims it's something else. | |
| var ua = navigator.userAgent, | |
| zoom, | |
| evt, x, y, z, aig; | |
| if ( !( /iPhone|iPad|iPod/.test( navigator.platform ) && /OS [1-5]_[0-9_]* like Mac OS X/i.test( ua ) && ua.indexOf( "AppleWebKit" ) > -1 ) ) { | |
| $.mobile.iosorientationfixEnabled = false; | |
| return; | |
| } | |
| zoom = $.mobile.zoom; | |
| function checkTilt( e ) { | |
| evt = e.originalEvent; | |
| aig = evt.accelerationIncludingGravity; | |
| x = Math.abs( aig.x ); | |
| y = Math.abs( aig.y ); | |
| z = Math.abs( aig.z ); | |
| // If portrait orientation and in one of the danger zones | |
| if ( !window.orientation && ( x > 7 || ( ( z > 6 && y < 8 || z < 8 && y > 6 ) && x > 5 ) ) ) { | |
| if ( zoom.enabled ) { | |
| zoom.disable(); | |
| } | |
| } else if ( !zoom.enabled ) { | |
| zoom.enable(); | |
| } | |
| } | |
| $.mobile.document.on( "mobileinit", function() { | |
| if ( $.mobile.iosorientationfixEnabled ) { | |
| $.mobile.window | |
| .bind( "orientationchange.iosorientationfix", zoom.enable ) | |
| .bind( "devicemotion.iosorientationfix", checkTilt ); | |
| } | |
| }); | |
| }( jQuery, this )); | |
| (function( $, window, undefined ) { | |
| var $html = $( "html" ), | |
| $window = $.mobile.window; | |
| //remove initial build class (only present on first pageshow) | |
| function hideRenderingClass() { | |
| $html.removeClass( "ui-mobile-rendering" ); | |
| } | |
| // trigger mobileinit event - useful hook for configuring $.mobile settings before they're used | |
| $( window.document ).trigger( "mobileinit" ); | |
| // support conditions | |
| // if device support condition(s) aren't met, leave things as they are -> a basic, usable experience, | |
| // otherwise, proceed with the enhancements | |
| if ( !$.mobile.gradeA() ) { | |
| return; | |
| } | |
| // override ajaxEnabled on platforms that have known conflicts with hash history updates | |
| // or generally work better browsing in regular http for full page refreshes (BB5, Opera Mini) | |
| if ( $.mobile.ajaxBlacklist ) { | |
| $.mobile.ajaxEnabled = false; | |
| } | |
| // Add mobile, initial load "rendering" classes to docEl | |
| $html.addClass( "ui-mobile ui-mobile-rendering" ); | |
| // This is a fallback. If anything goes wrong (JS errors, etc), or events don't fire, | |
| // this ensures the rendering class is removed after 5 seconds, so content is visible and accessible | |
| setTimeout( hideRenderingClass, 5000 ); | |
| $.extend( $.mobile, { | |
| // find and enhance the pages in the dom and transition to the first page. | |
| initializePage: function() { | |
| // find present pages | |
| var path = $.mobile.path, | |
| $pages = $( ":jqmData(role='page'), :jqmData(role='dialog')" ), | |
| hash = path.stripHash( path.stripQueryParams(path.parseLocation().hash) ), | |
| theLocation = $.mobile.path.parseLocation(), | |
| hashPage = document.getElementById( hash ); | |
| // if no pages are found, create one with body's inner html | |
| if ( !$pages.length ) { | |
| $pages = $( "body" ).wrapInner( "<div data-" + $.mobile.ns + "role='page'></div>" ).children( 0 ); | |
| } | |
| // add dialogs, set data-url attrs | |
| $pages.each(function() { | |
| var $this = $( this ); | |
| // unless the data url is already set set it to the pathname | |
| if ( !$this[ 0 ].getAttribute( "data-" + $.mobile.ns + "url" ) ) { | |
| $this.attr( "data-" + $.mobile.ns + "url", $this.attr( "id" ) || | |
| theLocation.pathname + theLocation.search ); | |
| } | |
| }); | |
| // define first page in dom case one backs out to the directory root (not always the first page visited, but defined as fallback) | |
| $.mobile.firstPage = $pages.first(); | |
| // define page container | |
| $.mobile.pageContainer = $.mobile.firstPage | |
| .parent() | |
| .addClass( "ui-mobile-viewport" ) | |
| .pagecontainer(); | |
| // initialize navigation events now, after mobileinit has occurred and the page container | |
| // has been created but before the rest of the library is alerted to that fact | |
| $.mobile.navreadyDeferred.resolve(); | |
| // alert listeners that the pagecontainer has been determined for binding | |
| // to events triggered on it | |
| $window.trigger( "pagecontainercreate" ); | |
| // cue page loading message | |
| $.mobile.loading( "show" ); | |
| //remove initial build class (only present on first pageshow) | |
| hideRenderingClass(); | |
| // if hashchange listening is disabled, there's no hash deeplink, | |
| // the hash is not valid (contains more than one # or does not start with #) | |
| // or there is no page with that hash, change to the first page in the DOM | |
| // Remember, however, that the hash can also be a path! | |
| if ( ! ( $.mobile.hashListeningEnabled && | |
| $.mobile.path.isHashValid( location.hash ) && | |
| ( $( hashPage ).is( ":jqmData(role='page')" ) || | |
| $.mobile.path.isPath( hash ) || | |
| hash === $.mobile.dialogHashKey ) ) ) { | |
| // Store the initial destination | |
| if ( $.mobile.path.isHashValid( location.hash ) ) { | |
| $.mobile.navigate.history.initialDst = hash.replace( "#", "" ); | |
| } | |
| // make sure to set initial popstate state if it exists | |
| // so that navigation back to the initial page works properly | |
| if ( $.event.special.navigate.isPushStateEnabled() ) { | |
| $.mobile.navigate.navigator.squash( path.parseLocation().href ); | |
| } | |
| $.mobile.changePage( $.mobile.firstPage, { | |
| transition: "none", | |
| reverse: true, | |
| changeHash: false, | |
| fromHashChange: true | |
| }); | |
| } else { | |
| // trigger hashchange or navigate to squash and record the correct | |
| // history entry for an initial hash path | |
| if ( !$.event.special.navigate.isPushStateEnabled() ) { | |
| $window.trigger( "hashchange", [true] ); | |
| } else { | |
| // TODO figure out how to simplify this interaction with the initial history entry | |
| // at the bottom js/navigate/navigate.js | |
| $.mobile.navigate.history.stack = []; | |
| $.mobile.navigate( $.mobile.path.isPath( location.hash ) ? location.hash : location.href ); | |
| } | |
| } | |
| } | |
| }); | |
| $(function() { | |
| //Run inlineSVG support test | |
| $.support.inlineSVG(); | |
| // check which scrollTop value should be used by scrolling to 1 immediately at domready | |
| // then check what the scroll top is. Android will report 0... others 1 | |
| // note that this initial scroll won't hide the address bar. It's just for the check. | |
| // hide iOS browser chrome on load if hideUrlBar is true this is to try and do it as soon as possible | |
| if ( $.mobile.hideUrlBar ) { | |
| window.scrollTo( 0, 1 ); | |
| } | |
| // if defaultHomeScroll hasn't been set yet, see if scrollTop is 1 | |
| // it should be 1 in most browsers, but android treats 1 as 0 (for hiding addr bar) | |
| // so if it's 1, use 0 from now on | |
| $.mobile.defaultHomeScroll = ( !$.support.scrollTop || $.mobile.window.scrollTop() === 1 ) ? 0 : 1; | |
| //dom-ready inits | |
| if ( $.mobile.autoInitializePage ) { | |
| $.mobile.initializePage(); | |
| } | |
| // window load event | |
| // hide iOS browser chrome on load if hideUrlBar is true this is as fall back incase we were too early before | |
| if ( $.mobile.hideUrlBar ) { | |
| $window.load( $.mobile.silentScroll ); | |
| } | |
| if ( !$.support.cssPointerEvents ) { | |
| // IE and Opera don't support CSS pointer-events: none that we use to disable link-based buttons | |
| // by adding the 'ui-disabled' class to them. Using a JavaScript workaround for those browser. | |
| // https://github.com/jquery/jquery-mobile/issues/3558 | |
| // DEPRECATED as of 1.4.0 - remove ui-disabled after 1.4.0 release | |
| // only ui-state-disabled should be present thereafter | |
| $.mobile.document.delegate( ".ui-state-disabled,.ui-disabled", "vclick", | |
| function( e ) { | |
| e.preventDefault(); | |
| e.stopImmediatePropagation(); | |
| } | |
| ); | |
| } | |
| }); | |
| }( jQuery, this )); | |
| })); |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /*! jQuery Mobile 1.4.3 | Git HEADhash: b9c6473 <> 2014-07-01T15:37:36Z | (c) 2010, 2014 jQuery Foundation, Inc. | jquery.org/license */ | |
| .ui-icon-action:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M9%2C5v3l5-4L9%2C0v3c0%2C0-5%2C0-5%2C7C6%2C5%2C9%2C5%2C9%2C5z%20M11%2C12H2V5h1l2-2H0v11h13V7l-2%2C2V12z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-alert:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M7%2C0L0%2C12h14L7%2C0z%20M7%2C11c-0.553%2C0-1-0.447-1-1s0.447-1%2C1-1c0.553%2C0%2C1%2C0.447%2C1%2C1S7.553%2C11%2C7%2C11z%20M7%2C8%20C6.447%2C8%2C6%2C7.553%2C6%2C7V5c0-0.553%2C0.447-1%2C1-1c0.553%2C0%2C1%2C0.447%2C1%2C1v2C8%2C7.553%2C7.553%2C8%2C7%2C8z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-arrow-d-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2214%2C3%2011%2C0%203.5%2C7.5%200%2C4%200%2C14%2010%2C14%206.5%2C10.5%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-d-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2210.5%2C7.5%203%2C0%200%2C3%207.5%2C10.5%204%2C14%2014%2C14%2014%2C4%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-d:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%229%2C7%209%2C0%205%2C0%205%2C7%200%2C7%207%2C14%2014%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%227%2C5%207%2C0%200%2C7%207%2C14%207%2C9%2014%2C9%2014%2C5%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2214%2C7%207%2C0%207%2C5%200%2C5%200%2C9%207%2C9%207%2C14%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-u-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2214%2C11%206.5%2C3.5%2010%2C0%200%2C0%200%2C10%203.5%2C6.5%2011%2C14%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-u-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2214%2C0%204%2C0%207.5%2C3.5%200%2C11%203%2C14%2010.5%2C6.5%2014%2C10%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-arrow-u:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%227%2C0%200%2C7%205%2C7%205%2C14%209%2C14%209%2C7%2014%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-audio:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214.018px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014.018%2014%22%20style%3D%22enable-background%3Anew%200%200%2014.018%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M1%2C4C0.447%2C4%2C0%2C4.447%2C0%2C5v4c0%2C0.553%2C0.447%2C1%2C1%2C1h1l4%2C4V0L2%2C4H1z%20M10.346%2C7c0-1.699-1.042-3.154-2.546-3.867L6.982%2C4.68%20C7.885%2C5.107%2C8.51%2C5.98%2C8.51%2C7S7.885%2C8.893%2C6.982%2C9.32L7.8%2C10.867C9.304%2C10.154%2C10.346%2C8.699%2C10.346%2C7z%20M9.447%2C0.017L8.618%2C1.586%20C10.723%2C2.584%2C12.182%2C4.621%2C12.182%2C7s-1.459%2C4.416-3.563%2C5.414l0.829%2C1.569c2.707-1.283%2C4.57-3.925%2C4.57-6.983%20S12.154%2C1.3%2C9.447%2C0.017z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-back:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M5%2C3V0L1%2C4l4%2C4V5c0%2C0%2C6%2C0%2C6%2C3s-5%2C4-5%2C4v2c0%2C0%2C7-1%2C7-6C13%2C4%2C8%2C3%2C5%2C3z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-bars:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M1%2C4h12c0.553%2C0%2C1-0.447%2C1-1s-0.447-1-1-1H1C0.447%2C2%2C0%2C2.447%2C0%2C3S0.447%2C4%2C1%2C4z%20M13%2C6H1%20C0.447%2C6%2C0%2C6.447%2C0%2C7c0%2C0.553%2C0.447%2C1%2C1%2C1h12c0.553%2C0%2C1-0.447%2C1-1C14%2C6.447%2C13.553%2C6%2C13%2C6z%20M13%2C10H1c-0.553%2C0-1%2C0.447-1%2C1%20s0.447%2C1%2C1%2C1h12c0.553%2C0%2C1-0.447%2C1-1S13.553%2C10%2C13%2C10z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-bullets:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M5%2C4h8c0.553%2C0%2C1-0.447%2C1-1s-0.447-1-1-1H5C4.447%2C2%2C4%2C2.447%2C4%2C3S4.447%2C4%2C5%2C4z%20M13%2C6H5%20C4.447%2C6%2C4%2C6.447%2C4%2C7c0%2C0.553%2C0.447%2C1%2C1%2C1h8c0.553%2C0%2C1-0.447%2C1-1C14%2C6.447%2C13.553%2C6%2C13%2C6z%20M13%2C10H5c-0.553%2C0-1%2C0.447-1%2C1%20s0.447%2C1%2C1%2C1h8c0.553%2C0%2C1-0.447%2C1-1S13.553%2C10%2C13%2C10z%20M1%2C2C0.447%2C2%2C0%2C2.447%2C0%2C3s0.447%2C1%2C1%2C1s1-0.447%2C1-1S1.553%2C2%2C1%2C2z%20M1%2C6%20C0.447%2C6%2C0%2C6.447%2C0%2C7c0%2C0.553%2C0.447%2C1%2C1%2C1s1-0.447%2C1-1C2%2C6.447%2C1.553%2C6%2C1%2C6z%20M1%2C10c-0.553%2C0-1%2C0.447-1%2C1s0.447%2C1%2C1%2C1s1-0.447%2C1-1%20S1.553%2C10%2C1%2C10z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-calendar:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M0%2C8h2V6H0V8z%20M3%2C8h2V6H3V8z%20M6%2C8h2V6H6V8z%20M9%2C8h2V6H9V8z%20M12%2C8h2V6h-2V8z%20M0%2C11h2V9H0V11z%20M3%2C11h2V9H3V11z%20M6%2C11h2V9H6V11z%20%20M9%2C11h2V9H9V11z%20M12%2C11h2V9h-2V11z%20M0%2C14h2v-2H0V14z%20M3%2C14h2v-2H3V14z%20M6%2C14h2v-2H6V14z%20M9%2C14h2v-2H9V14z%20M12%2C1%20c0-0.553-0.447-1-1-1s-1%2C0.447-1%2C1H4c0-0.553-0.447-1-1-1S2%2C0.447%2C2%2C1H0v4h14V1H12z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-camera:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M12%2C2.5H9.908c-0.206-0.581-0.756-1-1.408-1h-3c-0.652%2C0-1.202%2C0.419-1.408%2C1H2c-1.104%2C0-2%2C0.896-2%2C2%20v6c0%2C1.104%2C0.896%2C2%2C2%2C2h10c1.104%2C0%2C2-0.896%2C2-2v-6C14%2C3.396%2C13.104%2C2.5%2C12%2C2.5z%20M7%2C10.5c-1.657%2C0-3-1.344-3-3c0-1.657%2C1.343-3%2C3-3%20s3%2C1.343%2C3%2C3C10%2C9.156%2C8.657%2C10.5%2C7%2C10.5z%20M7%2C5.5c-1.104%2C0-2%2C0.896-2%2C2c0%2C1.104%2C0.896%2C2%2C2%2C2c1.104%2C0%2C2-0.896%2C2-2%20C9%2C6.396%2C8.104%2C5.5%2C7%2C5.5z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-carat-d:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%2211.949%2C3.404%207%2C8.354%202.05%2C3.404%20-0.071%2C5.525%207%2C12.596%2014.07%2C5.525%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-carat-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%2210.596%2C11.949%205.646%2C7%2010.596%2C2.05%208.475%2C-0.071%201.404%2C7%208.475%2C14.07%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-carat-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%223.404%2C2.051%208.354%2C7%203.404%2C11.95%205.525%2C14.07%2012.596%2C7%205.525%2C-0.071%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-carat-u:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%222.051%2C10.596%207%2C5.646%2011.95%2C10.596%2014.07%2C8.475%207%2C1.404%20-0.071%2C8.475%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-check:after,html .ui-btn.ui-checkbox-on.ui-checkbox-on:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%2214%2C4%2011%2C1%205.003%2C6.997%203%2C5%200%2C8%204.966%2C13%204.983%2C12.982%205%2C13%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-clock:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M7%2C0C3.134%2C0%2C0%2C3.134%2C0%2C7s3.134%2C7%2C7%2C7s7-3.134%2C7-7S10.866%2C0%2C7%2C0z%20M7%2C12c-2.762%2C0-5-2.238-5-5s2.238-5%2C5-5s5%2C2.238%2C5%2C5%20S9.762%2C12%2C7%2C12z%20M9%2C6H8V4c0-0.553-0.447-1-1-1S6%2C3.447%2C6%2C4v3c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1S9.553%2C6%2C9%2C6z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-cloud:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M14%2C9.5c0-0.793-0.465-1.473-1.134-1.795C12.949%2C7.484%2C13%2C7.249%2C13%2C7c0-1.104-0.896-2-2-2%20c-0.158%2C0-0.311%2C0.023-0.457%2C0.058C9.816%2C3.549%2C8.286%2C2.5%2C6.5%2C2.5c-2.33%2C0-4.224%2C1.777-4.454%2C4.046C0.883%2C6.76%2C0%2C7.773%2C0%2C9%20c0%2C1.381%2C1.119%2C2.5%2C2.5%2C2.5h10v-0.07C13.361%2C11.206%2C14%2C10.432%2C14%2C9.5z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-comment:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M12%2C0H2C0.896%2C0%2C0%2C0.896%2C0%2C2v7c0%2C1.104%2C0.896%2C2%2C2%2C2h1v3l3-3h6c1.104%2C0%2C2-0.896%2C2-2V2C14%2C0.896%2C13.104%2C0%2C12%2C0z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-delete:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2214%2C3%2011%2C0%207%2C4%203%2C0%200%2C3%204%2C7%200%2C11%203%2C14%207%2C10%2011%2C14%2014%2C11%2010%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-edit:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M1%2C10l-1%2C4l4-1l7-7L8%2C3L1%2C10z%20M11%2C0L9%2C2l3%2C3l2-2L11%2C0z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-eye:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M7%2C2C3%2C2%2C0%2C7%2C0%2C7s3%2C5%2C7%2C5s7-5%2C7-5S11%2C2%2C7%2C2z%20M7%2C10c-1.657%2C0-3-1.344-3-3c0-1.657%2C1.343-3%2C3-3%20s3%2C1.343%2C3%2C3C10%2C8.656%2C8.657%2C10%2C7%2C10z%20M7%2C6C6.448%2C6%2C6%2C6.447%2C6%2C7c0%2C0.553%2C0.448%2C1%2C1%2C1s1-0.447%2C1-1C8%2C6.447%2C7.552%2C6%2C7%2C6z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-forbidden:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M12.601%2C11.187C13.476%2C10.018%2C14%2C8.572%2C14%2C7c0-3.866-3.134-7-7-7C5.428%2C0%2C3.982%2C0.524%2C2.813%2C1.399L2.757%2C1.343L2.053%2C2.048%20L2.048%2C2.053L1.343%2C2.758l0.056%2C0.056C0.524%2C3.982%2C0%2C5.428%2C0%2C7c0%2C3.866%2C3.134%2C7%2C7%2C7c1.572%2C0%2C3.018-0.524%2C4.187-1.399l0.056%2C0.057%20l0.705-0.705l0.005-0.005l0.705-0.705L12.601%2C11.187z%20M7%2C2c2.761%2C0%2C5%2C2.238%2C5%2C5c0%2C1.019-0.308%2C1.964-0.832%2C2.754L4.246%2C2.832%20C5.036%2C2.308%2C5.981%2C2%2C7%2C2z%20M7%2C12c-2.761%2C0-5-2.238-5-5c0-1.019%2C0.308-1.964%2C0.832-2.754l6.922%2C6.922C8.964%2C11.692%2C8.019%2C12%2C7%2C12z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-forward:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M13%2C4L9%2C0v3C6%2C3%2C1%2C4%2C1%2C8c0%2C5%2C7%2C6%2C7%2C6v-2c0%2C0-5-1-5-4s6-3%2C6-3v3L13%2C4z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-gear:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M13.621%2C5.904l-1.036-0.259c-0.168-0.042-0.303-0.168-0.355-0.332c-0.092-0.284-0.205-0.559-0.339-0.82%20c-0.079-0.153-0.073-0.337%2C0.017-0.486l0.549-0.915c0.118-0.196%2C0.088-0.448-0.075-0.61l-0.862-0.863%20c-0.162-0.163-0.414-0.193-0.611-0.075l-0.916%2C0.55C9.844%2C2.182%2C9.659%2C2.188%2C9.506%2C2.109C9.244%2C1.975%2C8.97%2C1.861%2C8.686%2C1.77%20c-0.165-0.052-0.29-0.187-0.332-0.354L8.095%2C0.379C8.039%2C0.156%2C7.839%2C0%2C7.609%2C0H6.391c-0.229%2C0-0.43%2C0.156-0.485%2C0.379L5.646%2C1.415%20C5.604%2C1.582%2C5.479%2C1.718%2C5.313%2C1.77c-0.284%2C0.092-0.559%2C0.206-0.82%2C0.34C4.339%2C2.188%2C4.155%2C2.182%2C4.007%2C2.093L3.092%2C1.544%20c-0.196-0.118-0.448-0.087-0.61%2C0.075L1.619%2C2.481C1.457%2C2.644%2C1.426%2C2.896%2C1.544%2C3.093l0.549%2C0.914%20c0.089%2C0.148%2C0.095%2C0.332%2C0.017%2C0.486C1.975%2C4.755%2C1.861%2C5.029%2C1.77%2C5.314c-0.053%2C0.164-0.188%2C0.29-0.354%2C0.332L0.379%2C5.905%20C0.156%2C5.961%2C0%2C6.161%2C0%2C6.391v1.219c0%2C0.229%2C0.156%2C0.43%2C0.379%2C0.485l1.036%2C0.26C1.582%2C8.396%2C1.717%2C8.521%2C1.77%2C8.687%20c0.092%2C0.284%2C0.205%2C0.559%2C0.34%2C0.82C2.188%2C9.66%2C2.182%2C9.844%2C2.093%2C9.993l-0.549%2C0.915c-0.118%2C0.195-0.087%2C0.448%2C0.075%2C0.61%20l0.862%2C0.862c0.162%2C0.163%2C0.414%2C0.193%2C0.61%2C0.075l0.915-0.549c0.148-0.089%2C0.332-0.095%2C0.486-0.017%20c0.262%2C0.135%2C0.536%2C0.248%2C0.82%2C0.34c0.165%2C0.053%2C0.291%2C0.187%2C0.332%2C0.354l0.259%2C1.036C5.96%2C13.844%2C6.16%2C14%2C6.39%2C14h1.22%20c0.229%2C0%2C0.43-0.156%2C0.485-0.379l0.259-1.036c0.042-0.167%2C0.168-0.302%2C0.333-0.354c0.284-0.092%2C0.559-0.205%2C0.82-0.34%20c0.154-0.078%2C0.338-0.072%2C0.486%2C0.017l0.914%2C0.549c0.197%2C0.118%2C0.449%2C0.088%2C0.611-0.074l0.862-0.863%20c0.163-0.162%2C0.193-0.415%2C0.075-0.611l-0.549-0.915c-0.089-0.148-0.096-0.332-0.017-0.485c0.134-0.263%2C0.248-0.536%2C0.339-0.82%20c0.053-0.165%2C0.188-0.291%2C0.355-0.333l1.036-0.259C13.844%2C8.039%2C14%2C7.839%2C14%2C7.609V6.39C14%2C6.16%2C13.844%2C5.96%2C13.621%2C5.904z%20M7%2C10%20c-1.657%2C0-3-1.343-3-3s1.343-3%2C3-3s3%2C1.343%2C3%2C3S8.657%2C10%2C7%2C10z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-grid:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M3%2C0H1C0.447%2C0%2C0%2C0.447%2C0%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V1C4%2C0.447%2C3.553%2C0%2C3%2C0z%20M8%2C0H6%20C5.447%2C0%2C5%2C0.447%2C5%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V1C9%2C0.447%2C8.553%2C0%2C8%2C0z%20M13%2C0h-2c-0.553%2C0-1%2C0.447-1%2C1v2%20c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V1C14%2C0.447%2C13.553%2C0%2C13%2C0z%20M3%2C5H1C0.447%2C5%2C0%2C5.447%2C0%2C6v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2%20c0.553%2C0%2C1-0.447%2C1-1V6C4%2C5.447%2C3.553%2C5%2C3%2C5z%20M8%2C5H6C5.447%2C5%2C5%2C5.447%2C5%2C6v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V6%20C9%2C5.447%2C8.553%2C5%2C8%2C5z%20M13%2C5h-2c-0.553%2C0-1%2C0.447-1%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V6C14%2C5.447%2C13.553%2C5%2C13%2C5z%20M3%2C10%20H1c-0.553%2C0-1%2C0.447-1%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1v-2C4%2C10.447%2C3.553%2C10%2C3%2C10z%20M8%2C10H6c-0.553%2C0-1%2C0.447-1%2C1v2%20c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1v-2C9%2C10.447%2C8.553%2C10%2C8%2C10z%20M13%2C10h-2c-0.553%2C0-1%2C0.447-1%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2%20c0.553%2C0%2C1-0.447%2C1-1v-2C14%2C10.447%2C13.553%2C10%2C13%2C10z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-heart:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M7%2C1.872c-2-3-7-2-7%2C2c0%2C3%2C4%2C7%2C4%2C7s2.417%2C2.479%2C3%2C3c0.583-0.521%2C3-3%2C3-3s4-4%2C4-7%20C14-0.128%2C9-1.128%2C7%2C1.872z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-home:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%227%2C0%200%2C7%202%2C7%202%2C14%205%2C14%205%2C9%209%2C9%209%2C14%2012%2C14%2012%2C7%2014%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-info:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M7%2C0C3.134%2C0%2C0%2C3.134%2C0%2C7s3.134%2C7%2C7%2C7s7-3.134%2C7-7S10.866%2C0%2C7%2C0z%20M7%2C2c0.552%2C0%2C1%2C0.447%2C1%2C1S7.552%2C4%2C7%2C4S6%2C3.553%2C6%2C3%20S6.448%2C2%2C7%2C2z%20M9%2C11H5v-1h1V6H5V5h3v5h1V11z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-location:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M7%2C0C4.791%2C0%2C3%2C1.791%2C3%2C4c0%2C2%2C4%2C10%2C4%2C10s4-8%2C4-10C11%2C1.791%2C9.209%2C0%2C7%2C0z%20M7%2C6C5.896%2C6%2C5%2C5.104%2C5%2C4%20s0.896-2%2C2-2c1.104%2C0%2C2%2C0.896%2C2%2C2S8.104%2C6%2C7%2C6z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-lock:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M12%2C6V5c0-2.762-2.238-5-5-5C4.239%2C0%2C2%2C2.238%2C2%2C5v1H1v8h12V6H12z%20M7.5%2C9.848V12h-1V9.848%20C6.207%2C9.673%2C6%2C9.366%2C6%2C9c0-0.553%2C0.448-1%2C1-1s1%2C0.447%2C1%2C1C8%2C9.366%2C7.793%2C9.673%2C7.5%2C9.848z%20M10%2C6H4V5c0-1.657%2C1.343-3%2C3-3%20s3%2C1.343%2C3%2C3V6z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-mail:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M0%2C3.75V12h14V3.75L7%2C9L0%2C3.75z%20M14%2C2H0l7%2C5L14%2C2z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-minus:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Crect%20y%3D%225%22%20style%3D%22fill%3A%23FFFFFF%3B%22%20width%3D%2214%22%20height%3D%224%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-navigation:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%2213%2C1%200%2C6%207%2C7%208%2C14%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-phone:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%22-0.01%200.008%2014%2014%22%20style%3D%22enable-background%3Anew%20-0.01%200.008%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M6.939%2C9.189C6.165%2C8.557%2C5.271%2C7.705%2C4.497%2C6.744C3.953%2C6.071%2C3.473%2C5.363%2C3.969%2C4.866l-3.482-3.48%20C-0.021%2C2.02-1.146%2C5.04%2C3.675%2C9.984c5.08%2C5.211%2C8.356%2C4.097%2C8.92%2C3.511l-3.396-3.4C8.725%2C10.568%2C8.113%2C10.146%2C6.939%2C9.189z%20%20M13.82%2C11.519v-0.004c0%2C0-2.648-2.646-2.649-2.647c-0.21-0.211-0.546-0.205-0.754%2C0.002L9.455%2C9.831l3.403%2C3.407%20c0%2C0%2C0.962-0.96%2C0.961-0.961l0.002-0.001C14.043%2C12.056%2C14.021%2C11.721%2C13.82%2C11.519z%20M5.192%2C3.644V3.642%20c0.222-0.222%2C0.2-0.557%2C0-0.758V2.881c0%2C0-2.726-2.725-2.727-2.726C2.255-0.055%2C1.92-0.05%2C1.712%2C0.156L0.751%2C1.121l3.479%2C3.482%20C4.231%2C4.604%2C5.192%2C3.645%2C5.192%2C3.644z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-plus:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23FFF%22%20points%3D%2214%2C5%209%2C5%209%2C0%205%2C0%205%2C5%200%2C5%200%2C9%205%2C9%205%2C14%209%2C14%209%2C9%2014%2C9%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-power:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M11.243%2C2.408c-0.392-0.401-1.024-0.401-1.415%2C0c-0.391%2C0.401-0.391%2C1.054%2C0%2C1.455%20C10.584%2C4.642%2C11%2C5.675%2C11%2C6.773s-0.416%2C2.133-1.172%2C2.91c-1.512%2C1.558-4.145%2C1.558-5.656%2C0C3.416%2C8.904%2C3%2C7.872%2C3%2C6.773%20C3%2C5.673%2C3.416%2C4.64%2C4.172%2C3.863c0.39-0.401%2C0.39-1.054%2C0-1.455c-0.391-0.401-1.024-0.401-1.415%2C0C1.624%2C3.574%2C1%2C5.125%2C1%2C6.773%20c0%2C1.647%2C0.624%2C3.199%2C1.757%2C4.365c1.134%2C1.166%2C2.64%2C1.809%2C4.243%2C1.809c1.604%2C0%2C3.109-0.645%2C4.243-1.811%20C12.376%2C9.975%2C13%2C8.423%2C13%2C6.773C13%2C5.125%2C12.376%2C3.574%2C11.243%2C2.408z%20M7%2C8.053c0.553%2C0%2C1-0.445%2C1-1v-6c0-0.553-0.447-1-1-1%20c-0.553%2C0-1%2C0.447-1%2C1v6C6%2C7.604%2C6.447%2C8.053%2C7%2C8.053z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-recycle:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M3%2C7h1L2%2C4L0%2C7h1c0%2C3.313%2C2.687%2C6%2C6%2C6c0.702%2C0%2C1.374-0.127%2C2-0.35v-2.205C8.41%2C10.789%2C7.732%2C11%2C7%2C11%20C4.791%2C11%2C3%2C9.209%2C3%2C7z%20M13%2C7c0-3.313-2.688-6-6-6C6.298%2C1%2C5.626%2C1.127%2C5%2C1.349v2.206C5.59%2C3.211%2C6.268%2C3%2C7%2C3c2.209%2C0%2C4%2C1.791%2C4%2C4%20h-1l2%2C3l2-3H13z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-refresh:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214.001px%22%20height%3D%2214.002px%22%20viewBox%3D%220%200%2014.001%2014.002%22%20style%3D%22enable-background%3Anew%200%200%2014.001%2014.002%3B%22%20%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M14.001%2C6.001v-6l-2.06%2C2.06c-0.423-0.424-0.897-0.809-1.44-1.122C7.153-0.994%2C2.872%2C0.153%2C0.939%2C3.501%20c-1.933%2C3.348-0.786%2C7.629%2C2.562%2C9.562c3.348%2C1.933%2C7.629%2C0.785%2C9.562-2.562l-1.732-1c-1.381%2C2.392-4.438%2C3.211-6.83%2C1.83%20s-3.211-4.438-1.83-6.83s4.438-3.211%2C6.83-1.83c0.389%2C0.225%2C0.718%2C0.506%2C1.02%2C0.81l-2.52%2C2.52H14.001z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-search:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M10.171%2C8.766c0.617-0.888%2C0.979-1.964%2C0.979-3.126c0-3.037-2.463-5.5-5.5-5.5s-5.5%2C2.463-5.5%2C5.5%20s2.463%2C5.5%2C5.5%2C5.5c1.152%2C0%2C2.223-0.355%2C3.104-0.962l3.684%2C3.683l1.414-1.414L10.171%2C8.766z%20M5.649%2C9.14c-1.933%2C0-3.5-1.567-3.5-3.5%20c0-1.933%2C1.567-3.5%2C3.5-3.5c1.933%2C0%2C3.5%2C1.567%2C3.5%2C3.5C9.149%2C7.572%2C7.582%2C9.14%2C5.649%2C9.14z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-shop:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M10%2C4V3c0-1.657-1.343-3-3-3S4%2C1.343%2C4%2C3v1H1v10h12V4H10z%20M4.5%2C6C4.224%2C6%2C4%2C5.776%2C4%2C5.5%20S4.224%2C5%2C4.5%2C5S5%2C5.224%2C5%2C5.5S4.776%2C6%2C4.5%2C6z%20M5%2C3c0-1.104%2C0.896-2%2C2-2c1.104%2C0%2C2%2C0.896%2C2%2C2v1H5V3z%20M9.5%2C6C9.225%2C6%2C9%2C5.776%2C9%2C5.5%20S9.225%2C5%2C9.5%2C5S10%2C5.224%2C10%2C5.5S9.775%2C6%2C9.5%2C6z%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-star:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20style%3D%22fill%3A%23FFFFFF%3B%22%20points%3D%2214%2C5%209%2C5%207%2C0%205%2C5%200%2C5%204%2C8%202.625%2C13%207%2C10%2011.375%2C13%2010%2C8%20%22%2F%3E%3C%2Fsvg%3E")}.ui-icon-tag:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M5%2C0H0v5l9%2C9l5-5L5%2C0z%20M3%2C4C2.447%2C4%2C2%2C3.553%2C2%2C3s0.447-1%2C1-1s1%2C0.447%2C1%2C1S3.553%2C4%2C3%2C4z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-user:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23FFF%22%20d%3D%22M8.851%2C10.101c-0.18-0.399-0.2-0.763-0.153-1.104C9.383%2C8.49%2C9.738%2C7.621%2C9.891%2C6.465C10.493%2C6.355%2C10.5%2C5.967%2C10.5%2C5.5%20c0-0.437-0.008-0.804-0.502-0.94C9.999%2C4.539%2C10%2C4.521%2C10%2C4.5c0-2.103-1-4-2-4C8%2C0.5%2C7.5%2C0%2C6.5%2C0C5%2C0%2C4%2C1.877%2C4%2C4.5%20c0%2C0.021%2C0.001%2C0.039%2C0.002%2C0.06C3.508%2C4.696%2C3.5%2C5.063%2C3.5%2C5.5c0%2C0.467%2C0.007%2C0.855%2C0.609%2C0.965%20C4.262%2C7.621%2C4.617%2C8.49%2C5.303%2C8.997c0.047%2C0.341%2C0.026%2C0.704-0.153%2C1.104C1.503%2C10.503%2C0%2C12%2C0%2C12v2h14v-2%20C14%2C12%2C12.497%2C10.503%2C8.851%2C10.101z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-icon-video:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%20-2%2014%2014%22%20style%3D%22enable-background%3Anew%200%20-2%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20style%3D%22fill%3A%23FFFFFF%3B%22%20d%3D%22M8%2C0H2C0.896%2C0%2C0%2C0.896%2C0%2C2v6c0%2C1.104%2C0.896%2C2%2C2%2C2h6c1.104%2C0%2C2-0.896%2C2-2V5V2C10%2C0.896%2C9.104%2C0%2C8%2C0z%20%20M10%2C5l4%2C4V1L10%2C5z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-action:after,.ui-alt-icon .ui-icon-action:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M9%2C5v3l5-4L9%2C0v3c0%2C0-5%2C0-5%2C7C6%2C5%2C9%2C5%2C9%2C5z%20M11%2C12H2V5h1l2-2H0v11h13V7l-2%2C2V12z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-alert:after,.ui-alt-icon .ui-icon-alert:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M7%2C0L0%2C12h14L7%2C0z%20M7%2C11c-0.553%2C0-1-0.447-1-1s0.447-1%2C1-1c0.553%2C0%2C1%2C0.447%2C1%2C1S7.553%2C11%2C7%2C11z%20M7%2C8C6.447%2C8%2C6%2C7.553%2C6%2C7V5%20c0-0.553%2C0.447-1%2C1-1c0.553%2C0%2C1%2C0.447%2C1%2C1v2C8%2C7.553%2C7.553%2C8%2C7%2C8z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-d:after,.ui-alt-icon .ui-icon-arrow-d:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%229%2C7%209%2C0%205%2C0%205%2C7%200%2C7%207%2C14%2014%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-d-l:after,.ui-alt-icon .ui-icon-arrow-d-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C3%2011%2C0%203.5%2C7.5%200%2C4%200%2C14%2010%2C14%206.5%2C10.5%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-d-r:after,.ui-alt-icon .ui-icon-arrow-d-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2210.5%2C7.5%203%2C0%200%2C3%207.5%2C10.5%204%2C14%2014%2C14%2014%2C4%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-l:after,.ui-alt-icon .ui-icon-arrow-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%227%2C5%207%2C0%200%2C7%207%2C14%207%2C9%2014%2C9%2014%2C5%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-r:after,.ui-alt-icon .ui-icon-arrow-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C7%207%2C0%207%2C5%200%2C5%200%2C9%207%2C9%207%2C14%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-u:after,.ui-alt-icon .ui-icon-arrow-u:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%227%2C0%200%2C7%205%2C7%205%2C14%209%2C14%209%2C7%2014%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-u-l:after,.ui-alt-icon .ui-icon-arrow-u-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C11%206.5%2C3.5%2010%2C0%200%2C0%200%2C10%203.5%2C6.5%2011%2C14%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-arrow-u-r:after,.ui-alt-icon .ui-icon-arrow-u-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C0%204%2C0%207.5%2C3.5%200%2C11%203%2C14%2010.5%2C6.5%2014%2C10%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-audio:after,.ui-alt-icon .ui-icon-audio:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214.018px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014.018%2014%22%20style%3D%22enable-background%3Anew%200%200%2014.018%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M1%2C4C0.447%2C4%2C0%2C4.447%2C0%2C5v4c0%2C0.553%2C0.447%2C1%2C1%2C1h1l4%2C4V0L2%2C4H1z%20M10.346%2C7c0-1.699-1.042-3.154-2.546-3.867L6.982%2C4.68%20C7.885%2C5.107%2C8.51%2C5.98%2C8.51%2C7S7.885%2C8.893%2C6.982%2C9.32L7.8%2C10.867C9.304%2C10.154%2C10.346%2C8.699%2C10.346%2C7z%20M9.447%2C0.017L8.618%2C1.586%20C10.723%2C2.584%2C12.182%2C4.621%2C12.182%2C7s-1.459%2C4.416-3.563%2C5.414l0.829%2C1.569c2.707-1.283%2C4.57-3.925%2C4.57-6.983%20S12.154%2C1.3%2C9.447%2C0.017z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-back:after,.ui-alt-icon .ui-icon-back:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M5%2C3V0L1%2C4l4%2C4V5c0%2C0%2C6%2C0%2C6%2C3s-5%2C4-5%2C4v2c0%2C0%2C7-1%2C7-6C13%2C4%2C8%2C3%2C5%2C3z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-bars:after,.ui-alt-icon .ui-icon-bars:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M1%2C4h12c0.553%2C0%2C1-0.447%2C1-1s-0.447-1-1-1H1C0.447%2C2%2C0%2C2.447%2C0%2C3S0.447%2C4%2C1%2C4z%20M13%2C6H1C0.447%2C6%2C0%2C6.447%2C0%2C7%20c0%2C0.553%2C0.447%2C1%2C1%2C1h12c0.553%2C0%2C1-0.447%2C1-1C14%2C6.447%2C13.553%2C6%2C13%2C6z%20M13%2C10H1c-0.553%2C0-1%2C0.447-1%2C1s0.447%2C1%2C1%2C1h12%20c0.553%2C0%2C1-0.447%2C1-1S13.553%2C10%2C13%2C10z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-bullets:after,.ui-alt-icon .ui-icon-bullets:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M5%2C4h8c0.553%2C0%2C1-0.447%2C1-1s-0.447-1-1-1H5C4.447%2C2%2C4%2C2.447%2C4%2C3S4.447%2C4%2C5%2C4z%20M13%2C6H5C4.447%2C6%2C4%2C6.447%2C4%2C7%20c0%2C0.553%2C0.447%2C1%2C1%2C1h8c0.553%2C0%2C1-0.447%2C1-1C14%2C6.447%2C13.553%2C6%2C13%2C6z%20M13%2C10H5c-0.553%2C0-1%2C0.447-1%2C1s0.447%2C1%2C1%2C1h8%20c0.553%2C0%2C1-0.447%2C1-1S13.553%2C10%2C13%2C10z%20M1%2C2C0.447%2C2%2C0%2C2.447%2C0%2C3s0.447%2C1%2C1%2C1s1-0.447%2C1-1S1.553%2C2%2C1%2C2z%20M1%2C6C0.447%2C6%2C0%2C6.447%2C0%2C7%20c0%2C0.553%2C0.447%2C1%2C1%2C1s1-0.447%2C1-1C2%2C6.447%2C1.553%2C6%2C1%2C6z%20M1%2C10c-0.553%2C0-1%2C0.447-1%2C1s0.447%2C1%2C1%2C1s1-0.447%2C1-1S1.553%2C10%2C1%2C10z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-calendar:after,.ui-alt-icon .ui-icon-calendar:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M0%2C8h2V6H0V8z%20M3%2C8h2V6H3V8z%20M6%2C8h2V6H6V8z%20M9%2C8h2V6H9V8z%20M12%2C8h2V6h-2V8z%20M0%2C11h2V9H0V11z%20M3%2C11h2V9H3V11z%20M6%2C11h2V9H6V11z%20%20M9%2C11h2V9H9V11z%20M12%2C11h2V9h-2V11z%20M0%2C14h2v-2H0V14z%20M3%2C14h2v-2H3V14z%20M6%2C14h2v-2H6V14z%20M9%2C14h2v-2H9V14z%20M12%2C1%20c0-0.553-0.447-1-1-1s-1%2C0.447-1%2C1H4c0-0.553-0.447-1-1-1S2%2C0.447%2C2%2C1H0v4h14V1H12z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-camera:after,.ui-alt-icon .ui-icon-camera:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M12%2C2.5H9.908c-0.206-0.581-0.756-1-1.408-1h-3c-0.652%2C0-1.202%2C0.419-1.408%2C1H2c-1.104%2C0-2%2C0.896-2%2C2v6c0%2C1.104%2C0.896%2C2%2C2%2C2%20h10c1.104%2C0%2C2-0.896%2C2-2v-6C14%2C3.396%2C13.104%2C2.5%2C12%2C2.5z%20M7%2C10.5c-1.657%2C0-3-1.344-3-3c0-1.657%2C1.343-3%2C3-3s3%2C1.343%2C3%2C3%20C10%2C9.156%2C8.657%2C10.5%2C7%2C10.5z%20M7%2C5.5c-1.104%2C0-2%2C0.896-2%2C2c0%2C1.104%2C0.896%2C2%2C2%2C2c1.104%2C0%2C2-0.896%2C2-2C9%2C6.396%2C8.104%2C5.5%2C7%2C5.5z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-carat-d:after,.ui-alt-icon .ui-icon-carat-d:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2211.949%2C3.404%207%2C8.354%202.05%2C3.404%20-0.071%2C5.525%207%2C12.596%2014.07%2C5.525%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-carat-l:after,.ui-alt-icon .ui-icon-carat-l:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2210.596%2C11.949%205.646%2C7%2010.596%2C2.05%208.475%2C-0.071%201.404%2C7%208.475%2C14.07%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-carat-r:after,.ui-alt-icon .ui-icon-carat-r:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%223.404%2C2.051%208.354%2C7%203.404%2C11.95%205.525%2C14.07%2012.596%2C7%205.525%2C-0.071%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-carat-u:after,.ui-alt-icon .ui-icon-carat-u:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%222.051%2C10.596%207%2C5.646%2011.95%2C10.596%2014.07%2C8.475%207%2C1.404%20-0.071%2C8.475%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-check:after,.ui-alt-icon .ui-icon-check:after,html .ui-alt-icon.ui-btn.ui-checkbox-on:after,html .ui-alt-icon .ui-btn.ui-checkbox-on:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C4%2011%2C1%205.003%2C6.997%203%2C5%200%2C8%204.966%2C13%204.983%2C12.982%205%2C13%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-clock:after,.ui-alt-icon .ui-icon-clock:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M7%2C0C3.134%2C0%2C0%2C3.134%2C0%2C7s3.134%2C7%2C7%2C7s7-3.134%2C7-7S10.866%2C0%2C7%2C0z%20M7%2C12c-2.762%2C0-5-2.238-5-5s2.238-5%2C5-5s5%2C2.238%2C5%2C5%20S9.762%2C12%2C7%2C12z%20M9%2C6H8V4c0-0.553-0.447-1-1-1S6%2C3.447%2C6%2C4v3c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1S9.553%2C6%2C9%2C6z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-cloud:after,.ui-alt-icon .ui-icon-cloud:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M14%2C9.5c0-0.793-0.465-1.473-1.134-1.795C12.949%2C7.484%2C13%2C7.249%2C13%2C7c0-1.104-0.896-2-2-2c-0.158%2C0-0.311%2C0.023-0.457%2C0.058%20C9.816%2C3.549%2C8.286%2C2.5%2C6.5%2C2.5c-2.33%2C0-4.224%2C1.777-4.454%2C4.046C0.883%2C6.76%2C0%2C7.773%2C0%2C9c0%2C1.381%2C1.119%2C2.5%2C2.5%2C2.5h10v-0.07%20C13.361%2C11.206%2C14%2C10.432%2C14%2C9.5z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-comment:after,.ui-alt-icon .ui-icon-comment:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M12%2C0H2C0.896%2C0%2C0%2C0.896%2C0%2C2v7c0%2C1.104%2C0.896%2C2%2C2%2C2h1v3l3-3h6c1.104%2C0%2C2-0.896%2C2-2V2C14%2C0.896%2C13.104%2C0%2C12%2C0z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-delete:after,.ui-alt-icon .ui-icon-delete:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C3%2011%2C0%207%2C4%203%2C0%200%2C3%204%2C7%200%2C11%203%2C14%207%2C10%2011%2C14%2014%2C11%2010%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-edit:after,.ui-alt-icon .ui-icon-edit:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M1%2C10l-1%2C4l4-1l7-7L8%2C3L1%2C10z%20M11%2C0L9%2C2l3%2C3l2-2L11%2C0z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-eye:after,.ui-alt-icon .ui-icon-eye:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M7%2C2C3%2C2%2C0%2C7%2C0%2C7s3%2C5%2C7%2C5s7-5%2C7-5S11%2C2%2C7%2C2z%20M7%2C10c-1.657%2C0-3-1.344-3-3c0-1.657%2C1.343-3%2C3-3s3%2C1.343%2C3%2C3%20C10%2C8.656%2C8.657%2C10%2C7%2C10z%20M7%2C6C6.448%2C6%2C6%2C6.447%2C6%2C7c0%2C0.553%2C0.448%2C1%2C1%2C1s1-0.447%2C1-1C8%2C6.447%2C7.552%2C6%2C7%2C6z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-forbidden:after,.ui-alt-icon .ui-icon-forbidden:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M12.601%2C11.187C13.476%2C10.018%2C14%2C8.572%2C14%2C7c0-3.866-3.134-7-7-7C5.428%2C0%2C3.982%2C0.524%2C2.813%2C1.399L2.757%2C1.343L2.053%2C2.048%20L2.048%2C2.053L1.343%2C2.758l0.056%2C0.056C0.524%2C3.982%2C0%2C5.428%2C0%2C7c0%2C3.866%2C3.134%2C7%2C7%2C7c1.572%2C0%2C3.018-0.524%2C4.187-1.399l0.056%2C0.057%20l0.705-0.705l0.005-0.005l0.705-0.705L12.601%2C11.187z%20M7%2C2c2.761%2C0%2C5%2C2.238%2C5%2C5c0%2C1.019-0.308%2C1.964-0.832%2C2.754L4.246%2C2.832%20C5.036%2C2.308%2C5.981%2C2%2C7%2C2z%20M7%2C12c-2.761%2C0-5-2.238-5-5c0-1.019%2C0.308-1.964%2C0.832-2.754l6.922%2C6.922C8.964%2C11.692%2C8.019%2C12%2C7%2C12z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-forward:after,.ui-alt-icon .ui-icon-forward:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M13%2C4L9%2C0v3C6%2C3%2C1%2C4%2C1%2C8c0%2C5%2C7%2C6%2C7%2C6v-2c0%2C0-5-1-5-4s6-3%2C6-3v3L13%2C4z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-gear:after,.ui-alt-icon .ui-icon-gear:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M13.621%2C5.904l-1.036-0.259c-0.168-0.042-0.303-0.168-0.355-0.332c-0.092-0.284-0.205-0.559-0.339-0.82%20c-0.079-0.153-0.073-0.337%2C0.017-0.486l0.549-0.915c0.118-0.196%2C0.088-0.448-0.075-0.61l-0.862-0.863%20c-0.162-0.163-0.414-0.193-0.611-0.075l-0.916%2C0.55C9.844%2C2.182%2C9.659%2C2.188%2C9.506%2C2.109C9.244%2C1.975%2C8.97%2C1.861%2C8.686%2C1.77%20c-0.165-0.052-0.29-0.187-0.332-0.354L8.095%2C0.379C8.039%2C0.156%2C7.839%2C0%2C7.609%2C0H6.391c-0.229%2C0-0.43%2C0.156-0.485%2C0.379L5.646%2C1.415%20C5.604%2C1.582%2C5.479%2C1.718%2C5.313%2C1.77c-0.284%2C0.092-0.559%2C0.206-0.82%2C0.34C4.339%2C2.188%2C4.155%2C2.182%2C4.007%2C2.093L3.092%2C1.544%20c-0.196-0.118-0.448-0.087-0.61%2C0.075L1.619%2C2.481C1.457%2C2.644%2C1.426%2C2.896%2C1.544%2C3.093l0.549%2C0.914%20c0.089%2C0.148%2C0.095%2C0.332%2C0.017%2C0.486C1.975%2C4.755%2C1.861%2C5.029%2C1.77%2C5.314c-0.053%2C0.164-0.188%2C0.29-0.354%2C0.332L0.379%2C5.905%20C0.156%2C5.961%2C0%2C6.161%2C0%2C6.391v1.219c0%2C0.229%2C0.156%2C0.43%2C0.379%2C0.485l1.036%2C0.26C1.582%2C8.396%2C1.717%2C8.521%2C1.77%2C8.687%20c0.092%2C0.284%2C0.205%2C0.559%2C0.34%2C0.82C2.188%2C9.66%2C2.182%2C9.844%2C2.093%2C9.993l-0.549%2C0.915c-0.118%2C0.195-0.087%2C0.448%2C0.075%2C0.61%20l0.862%2C0.862c0.162%2C0.163%2C0.414%2C0.193%2C0.61%2C0.075l0.915-0.549c0.148-0.089%2C0.332-0.095%2C0.486-0.017%20c0.262%2C0.135%2C0.536%2C0.248%2C0.82%2C0.34c0.165%2C0.053%2C0.291%2C0.187%2C0.332%2C0.354l0.259%2C1.036C5.96%2C13.844%2C6.16%2C14%2C6.39%2C14h1.22%20c0.229%2C0%2C0.43-0.156%2C0.485-0.379l0.259-1.036c0.042-0.167%2C0.168-0.302%2C0.333-0.354c0.284-0.092%2C0.559-0.205%2C0.82-0.34%20c0.154-0.078%2C0.338-0.072%2C0.486%2C0.017l0.914%2C0.549c0.197%2C0.118%2C0.449%2C0.088%2C0.611-0.074l0.862-0.863%20c0.163-0.162%2C0.193-0.415%2C0.075-0.611l-0.549-0.915c-0.089-0.148-0.096-0.332-0.017-0.485c0.134-0.263%2C0.248-0.536%2C0.339-0.82%20c0.053-0.165%2C0.188-0.291%2C0.355-0.333l1.036-0.259C13.844%2C8.039%2C14%2C7.839%2C14%2C7.609V6.39C14%2C6.16%2C13.844%2C5.96%2C13.621%2C5.904z%20M7%2C10%20c-1.657%2C0-3-1.343-3-3s1.343-3%2C3-3s3%2C1.343%2C3%2C3S8.657%2C10%2C7%2C10z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-grid:after,.ui-alt-icon .ui-icon-grid:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M3%2C0H1C0.447%2C0%2C0%2C0.447%2C0%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V1C4%2C0.447%2C3.553%2C0%2C3%2C0z%20M8%2C0H6%20C5.447%2C0%2C5%2C0.447%2C5%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V1C9%2C0.447%2C8.553%2C0%2C8%2C0z%20M13%2C0h-2c-0.553%2C0-1%2C0.447-1%2C1v2%20c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V1C14%2C0.447%2C13.553%2C0%2C13%2C0z%20M3%2C5H1C0.447%2C5%2C0%2C5.447%2C0%2C6v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2%20c0.553%2C0%2C1-0.447%2C1-1V6C4%2C5.447%2C3.553%2C5%2C3%2C5z%20M8%2C5H6C5.447%2C5%2C5%2C5.447%2C5%2C6v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V6%20C9%2C5.447%2C8.553%2C5%2C8%2C5z%20M13%2C5h-2c-0.553%2C0-1%2C0.447-1%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1V6C14%2C5.447%2C13.553%2C5%2C13%2C5z%20M3%2C10%20H1c-0.553%2C0-1%2C0.447-1%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1v-2C4%2C10.447%2C3.553%2C10%2C3%2C10z%20M8%2C10H6c-0.553%2C0-1%2C0.447-1%2C1v2%20c0%2C0.553%2C0.447%2C1%2C1%2C1h2c0.553%2C0%2C1-0.447%2C1-1v-2C9%2C10.447%2C8.553%2C10%2C8%2C10z%20M13%2C10h-2c-0.553%2C0-1%2C0.447-1%2C1v2c0%2C0.553%2C0.447%2C1%2C1%2C1h2%20c0.553%2C0%2C1-0.447%2C1-1v-2C14%2C10.447%2C13.553%2C10%2C13%2C10z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-heart:after,.ui-alt-icon .ui-icon-heart:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M7%2C1.958c-2-3-7-2.128-7%2C1.872c0%2C3%2C4%2C7%2C4%2C7s2.417%2C2.48%2C3%2C3c0.583-0.52%2C3-3%2C3-3s4-4%2C4-7C14-0.169%2C9-1.042%2C7%2C1.958z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-home:after,.ui-alt-icon .ui-icon-home:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%227%2C0%200%2C7%202%2C7%202%2C14%205%2C14%205%2C9%209%2C9%209%2C14%2012%2C14%2012%2C7%2014%2C7%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-info:after,.ui-alt-icon .ui-icon-info:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M7%2C0C3.134%2C0%2C0%2C3.134%2C0%2C7s3.134%2C7%2C7%2C7s7-3.134%2C7-7S10.866%2C0%2C7%2C0z%20M7%2C2c0.552%2C0%2C1%2C0.447%2C1%2C1S7.552%2C4%2C7%2C4S6%2C3.553%2C6%2C3%20S6.448%2C2%2C7%2C2z%20M9%2C11H5v-1h1V6H5V5h3v5h1V11z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-location:after,.ui-alt-icon .ui-icon-location:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M7%2C0C4.791%2C0%2C3%2C1.791%2C3%2C4c0%2C2%2C4%2C10%2C4%2C10s4-8%2C4-10C11%2C1.791%2C9.209%2C0%2C7%2C0z%20M7%2C6C5.896%2C6%2C5%2C5.104%2C5%2C4s0.896-2%2C2-2%20c1.104%2C0%2C2%2C0.896%2C2%2C2S8.104%2C6%2C7%2C6z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-lock:after,.ui-alt-icon .ui-icon-lock:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M12%2C6V5c0-2.762-2.238-5-5-5C4.239%2C0%2C2%2C2.238%2C2%2C5v1H1v8h12V6H12z%20M7.5%2C9.848V12h-1V9.848C6.207%2C9.673%2C6%2C9.366%2C6%2C9%20c0-0.553%2C0.448-1%2C1-1s1%2C0.447%2C1%2C1C8%2C9.366%2C7.793%2C9.673%2C7.5%2C9.848z%20M10%2C6H4V5c0-1.657%2C1.343-3%2C3-3s3%2C1.343%2C3%2C3V6z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-mail:after,.ui-alt-icon .ui-icon-mail:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M0%2C3.75V12h14V3.75L7%2C9L0%2C3.75z%20M14%2C2H0l7%2C5L14%2C2z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-minus:after,.ui-alt-icon .ui-icon-minus:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Crect%20y%3D%225%22%20width%3D%2214%22%20height%3D%224%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-navigation:after,.ui-alt-icon .ui-icon-navigation:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2213%2C1%200%2C6%207%2C7%208%2C14%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-phone:after,.ui-alt-icon .ui-icon-phone:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M6.949%2C9.182C6.175%2C8.549%2C5.281%2C7.697%2C4.507%2C6.736C3.963%2C6.063%2C3.483%2C5.355%2C3.979%2C4.858l-3.482-3.48%20c-0.508%2C0.634-1.633%2C3.654%2C3.188%2C8.598c5.08%2C5.211%2C8.356%2C4.097%2C8.92%2C3.511l-3.396-3.399C8.734%2C10.561%2C8.123%2C10.139%2C6.949%2C9.182z%20%20M13.83%2C11.512v-0.004c0%2C0-2.648-2.646-2.649-2.647c-0.21-0.212-0.546-0.205-0.754%2C0.002L9.465%2C9.823l3.402%2C3.407%20c0%2C0%2C0.963-0.961%2C0.961-0.961l0.002-0.002C14.053%2C12.049%2C14.031%2C11.713%2C13.83%2C11.512z%20M5.202%2C3.636V3.634%20c0.222-0.222%2C0.2-0.557%2C0-0.758V2.873c0%2C0-2.726-2.725-2.727-2.726c-0.21-0.21-0.545-0.205-0.753%2C0.001L0.761%2C1.113L4.24%2C4.595%20C4.241%2C4.596%2C5.202%2C3.637%2C5.202%2C3.636z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-plus:after,.ui-alt-icon .ui-icon-plus:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C5%209%2C5%209%2C0%205%2C0%205%2C5%200%2C5%200%2C9%205%2C9%205%2C14%209%2C14%209%2C9%2014%2C9%20%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-power:after,.ui-alt-icon .ui-icon-power:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M11.243%2C2.408c-0.392-0.401-1.024-0.401-1.415%2C0c-0.391%2C0.401-0.391%2C1.054%2C0%2C1.455C10.584%2C4.642%2C11%2C5.675%2C11%2C6.773%20s-0.416%2C2.133-1.172%2C2.91c-1.512%2C1.558-4.145%2C1.558-5.656%2C0C3.416%2C8.904%2C3%2C7.872%2C3%2C6.773C3%2C5.673%2C3.416%2C4.64%2C4.172%2C3.863%20c0.39-0.401%2C0.39-1.054%2C0-1.455c-0.391-0.401-1.024-0.401-1.415%2C0C1.624%2C3.574%2C1%2C5.125%2C1%2C6.773c0%2C1.647%2C0.624%2C3.199%2C1.757%2C4.365%20c1.134%2C1.166%2C2.64%2C1.809%2C4.243%2C1.809c1.604%2C0%2C3.109-0.645%2C4.243-1.811C12.376%2C9.975%2C13%2C8.423%2C13%2C6.773%20C13%2C5.125%2C12.376%2C3.574%2C11.243%2C2.408z%20M7%2C8.053c0.553%2C0%2C1-0.445%2C1-1v-6c0-0.553-0.447-1-1-1c-0.553%2C0-1%2C0.447-1%2C1v6%20C6%2C7.604%2C6.447%2C8.053%2C7%2C8.053z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-recycle:after,.ui-alt-icon .ui-icon-recycle:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M3%2C7h1L2%2C4L0%2C7h1c0%2C3.313%2C2.687%2C6%2C6%2C6c0.702%2C0%2C1.374-0.127%2C2-0.35v-2.205C8.41%2C10.789%2C7.732%2C11%2C7%2C11C4.791%2C11%2C3%2C9.209%2C3%2C7z%20%20M13%2C7c0-3.313-2.688-6-6-6C6.298%2C1%2C5.626%2C1.127%2C5%2C1.349v2.206C5.59%2C3.211%2C6.268%2C3%2C7%2C3c2.209%2C0%2C4%2C1.791%2C4%2C4h-1l2%2C3l2-3H13z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-refresh:after,.ui-alt-icon .ui-icon-refresh:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214.001px%22%20height%3D%2214.002px%22%20viewBox%3D%220%200%2014.001%2014.002%22%20style%3D%22enable-background%3Anew%200%200%2014.001%2014.002%3B%22%20%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M14.001%2C6.001v-6l-2.06%2C2.06c-0.423-0.424-0.897-0.809-1.44-1.122C7.153-0.994%2C2.872%2C0.153%2C0.939%2C3.501%20c-1.933%2C3.348-0.786%2C7.629%2C2.562%2C9.562c3.348%2C1.933%2C7.629%2C0.785%2C9.562-2.562l-1.732-1c-1.381%2C2.392-4.438%2C3.211-6.83%2C1.83%20s-3.211-4.438-1.83-6.83s4.438-3.211%2C6.83-1.83c0.389%2C0.225%2C0.718%2C0.506%2C1.02%2C0.81l-2.52%2C2.52H14.001z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-search:after,.ui-alt-icon .ui-icon-search:after,.ui-input-search:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M10.171%2C8.766c0.617-0.888%2C0.979-1.964%2C0.979-3.126c0-3.037-2.463-5.5-5.5-5.5s-5.5%2C2.463-5.5%2C5.5s2.463%2C5.5%2C5.5%2C5.5%20c1.152%2C0%2C2.223-0.355%2C3.104-0.962l3.684%2C3.683l1.414-1.414L10.171%2C8.766z%20M5.649%2C9.14c-1.933%2C0-3.5-1.567-3.5-3.5%20c0-1.933%2C1.567-3.5%2C3.5-3.5c1.933%2C0%2C3.5%2C1.567%2C3.5%2C3.5C9.149%2C7.572%2C7.582%2C9.14%2C5.649%2C9.14z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-shop:after,.ui-alt-icon .ui-icon-shop:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M10%2C4V3c0-1.657-1.343-3-3-3S4%2C1.343%2C4%2C3v1H1v10h12V4H10z%20M4.5%2C6C4.224%2C6%2C4%2C5.776%2C4%2C5.5S4.224%2C5%2C4.5%2C5S5%2C5.224%2C5%2C5.5%20S4.776%2C6%2C4.5%2C6z%20M5%2C3c0-1.104%2C0.896-2%2C2-2c1.104%2C0%2C2%2C0.896%2C2%2C2v1H5V3z%20M9.5%2C6C9.225%2C6%2C9%2C5.776%2C9%2C5.5S9.225%2C5%2C9.5%2C5S10%2C5.224%2C10%2C5.5%20S9.775%2C6%2C9.5%2C6z%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-star:after,.ui-alt-icon .ui-icon-star:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20points%3D%2214%2C5%209%2C5%207%2C0%205%2C5%200%2C5%204%2C8%202.625%2C13%207%2C10%2011.375%2C13%2010%2C8%20%22%2F%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-tag:after,.ui-alt-icon .ui-icon-tag:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M5%2C0H0v5l9%2C9l5-5L5%2C0z%20M3%2C4C2.447%2C4%2C2%2C3.553%2C2%2C3s0.447-1%2C1-1s1%2C0.447%2C1%2C1S3.553%2C4%2C3%2C4z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-user:after,.ui-alt-icon .ui-icon-user:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%200%2014%2014%22%20style%3D%22enable-background%3Anew%200%200%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M8.851%2C10.101c-0.18-0.399-0.2-0.763-0.153-1.104C9.383%2C8.49%2C9.738%2C7.621%2C9.891%2C6.465C10.493%2C6.355%2C10.5%2C5.967%2C10.5%2C5.5%20c0-0.437-0.008-0.804-0.502-0.94C9.999%2C4.539%2C10%2C4.521%2C10%2C4.5c0-2.103-1-4-2-4C8%2C0.5%2C7.5%2C0%2C6.5%2C0C5%2C0%2C4%2C1.877%2C4%2C4.5%20c0%2C0.021%2C0.001%2C0.039%2C0.002%2C0.06C3.508%2C4.696%2C3.5%2C5.063%2C3.5%2C5.5c0%2C0.467%2C0.007%2C0.855%2C0.609%2C0.965%20C4.262%2C7.621%2C4.617%2C8.49%2C5.303%2C8.997c0.047%2C0.341%2C0.026%2C0.704-0.153%2C1.104C1.503%2C10.503%2C0%2C12%2C0%2C12v2h14v-2%20C14%2C12%2C12.497%2C10.503%2C8.851%2C10.101z%22%2F%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3Cg%3E%3C%2Fg%3E%3C%2Fsvg%3E")}.ui-alt-icon.ui-icon-video:after,.ui-alt-icon .ui-icon-video:after{background-image:url("data:image/svg+xml;charset=US-ASCII,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22iso-8859-1%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%201.1%2F%2FEN%22%20%22http%3A%2F%2Fwww.w3.org%2FGraphics%2FSVG%2F1.1%2FDTD%2Fsvg11.dtd%22%3E%3Csvg%20version%3D%221.1%22%20id%3D%22Layer_1%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20x%3D%220px%22%20y%3D%220px%22%20%20width%3D%2214px%22%20height%3D%2214px%22%20viewBox%3D%220%20-2%2014%2014%22%20style%3D%22enable-background%3Anew%200%20-2%2014%2014%3B%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20d%3D%22M8%2C0H2C0.896%2C0%2C0%2C0.896%2C0%2C2v6c0%2C1.104%2C0.896%2C2%2C2%2C2h6c1.104%2C0%2C2-0.896%2C2-2V5V2C10%2C0.896%2C9.104%2C0%2C8%2C0z%20M10%2C5l4%2C4V1L10%2C5z%22%2F%3E%3C%2Fsvg%3E")}.ui-nosvg .ui-icon-action:after{background-image:url(images/icons-png/action-white.png)}.ui-nosvg .ui-icon-alert:after{background-image:url(images/icons-png/alert-white.png)}.ui-nosvg .ui-icon-arrow-d-l:after{background-image:url(images/icons-png/arrow-d-l-white.png)}.ui-nosvg .ui-icon-arrow-d-r:after{background-image:url(images/icons-png/arrow-d-r-white.png)}.ui-nosvg .ui-icon-arrow-d:after{background-image:url(images/icons-png/arrow-d-white.png)}.ui-nosvg .ui-icon-arrow-l:after{background-image:url(images/icons-png/arrow-l-white.png)}.ui-nosvg .ui-icon-arrow-r:after{background-image:url(images/icons-png/arrow-r-white.png)}.ui-nosvg .ui-icon-arrow-u-l:after{background-image:url(images/icons-png/arrow-u-l-white.png)}.ui-nosvg .ui-icon-arrow-u-r:after{background-image:url(images/icons-png/arrow-u-r-white.png)}.ui-nosvg .ui-icon-arrow-u:after{background-image:url(images/icons-png/arrow-u-white.png)}.ui-nosvg .ui-icon-audio:after{background-image:url(images/icons-png/audio-white.png)}.ui-nosvg .ui-icon-back:after{background-image:url(images/icons-png/back-white.png)}.ui-nosvg .ui-icon-bars:after{background-image:url(images/icons-png/bars-white.png)}.ui-nosvg .ui-icon-bullets:after{background-image:url(images/icons-png/bullets-white.png)}.ui-nosvg .ui-icon-calendar:after{background-image:url(images/icons-png/calendar-white.png)}.ui-nosvg .ui-icon-camera:after{background-image:url(images/icons-png/camera-white.png)}.ui-nosvg .ui-icon-carat-d:after{background-image:url(images/icons-png/carat-d-white.png)}.ui-nosvg .ui-icon-carat-l:after{background-image:url(images/icons-png/carat-l-white.png)}.ui-nosvg .ui-icon-carat-r:after{background-image:url(images/icons-png/carat-r-white.png)}.ui-nosvg .ui-icon-carat-u:after{background-image:url(images/icons-png/carat-u-white.png)}.ui-nosvg .ui-icon-check:after,html.ui-nosvg .ui-btn.ui-checkbox-on:after{background-image:url(images/icons-png/check-white.png)}.ui-nosvg .ui-icon-clock:after{background-image:url(images/icons-png/clock-white.png)}.ui-nosvg .ui-icon-cloud:after{background-image:url(images/icons-png/cloud-white.png)}.ui-nosvg .ui-icon-comment:after{background-image:url(images/icons-png/comment-white.png)}.ui-nosvg .ui-icon-delete:after{background-image:url(images/icons-png/delete-white.png)}.ui-nosvg .ui-icon-edit:after{background-image:url(images/icons-png/edit-white.png)}.ui-nosvg .ui-icon-eye:after{background-image:url(images/icons-png/eye-white.png)}.ui-nosvg .ui-icon-forbidden:after{background-image:url(images/icons-png/forbidden-white.png)}.ui-nosvg .ui-icon-forward:after{background-image:url(images/icons-png/forward-white.png)}.ui-nosvg .ui-icon-gear:after{background-image:url(images/icons-png/gear-white.png)}.ui-nosvg .ui-icon-grid:after{background-image:url(images/icons-png/grid-white.png)}.ui-nosvg .ui-icon-heart:after{background-image:url(images/icons-png/heart-white.png)}.ui-nosvg .ui-icon-home:after{background-image:url(images/icons-png/home-white.png)}.ui-nosvg .ui-icon-info:after{background-image:url(images/icons-png/info-white.png)}.ui-nosvg .ui-icon-location:after{background-image:url(images/icons-png/location-white.png)}.ui-nosvg .ui-icon-lock:after{background-image:url(images/icons-png/lock-white.png)}.ui-nosvg .ui-icon-mail:after{background-image:url(images/icons-png/mail-white.png)}.ui-nosvg .ui-icon-minus:after{background-image:url(images/icons-png/minus-white.png)}.ui-nosvg .ui-icon-navigation:after{background-image:url(images/icons-png/navigation-white.png)}.ui-nosvg .ui-icon-phone:after{background-image:url(images/icons-png/phone-white.png)}.ui-nosvg .ui-icon-plus:after{background-image:url(images/icons-png/plus-white.png)}.ui-nosvg .ui-icon-power:after{background-image:url(images/icons-png/power-white.png)}.ui-nosvg .ui-icon-recycle:after{background-image:url(images/icons-png/recycle-white.png)}.ui-nosvg .ui-icon-refresh:after{background-image:url(images/icons-png/refresh-white.png)}.ui-nosvg .ui-icon-search:after{background-image:url(images/icons-png/search-white.png)}.ui-nosvg .ui-icon-shop:after{background-image:url(images/icons-png/shop-white.png)}.ui-nosvg .ui-icon-star:after{background-image:url(images/icons-png/star-white.png)}.ui-nosvg .ui-icon-tag:after{background-image:url(images/icons-png/tag-white.png)}.ui-nosvg .ui-icon-user:after{background-image:url(images/icons-png/user-white.png)}.ui-nosvg .ui-icon-video:after{background-image:url(images/icons-png/video-white.png)}.ui-nosvg .ui-alt-icon.ui-icon-action:after,.ui-nosvg .ui-alt-icon .ui-icon-action:after{background-image:url(images/icons-png/action-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-alert:after,.ui-nosvg .ui-alt-icon .ui-icon-alert:after{background-image:url(images/icons-png/alert-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-d:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-d:after{background-image:url(images/icons-png/arrow-d-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-d-l:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-d-l:after{background-image:url(images/icons-png/arrow-d-l-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-d-r:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-d-r:after{background-image:url(images/icons-png/arrow-d-r-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-l:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-l:after{background-image:url(images/icons-png/arrow-l-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-r:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-r:after{background-image:url(images/icons-png/arrow-r-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-u:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-u:after{background-image:url(images/icons-png/arrow-u-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-u-l:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-u-l:after{background-image:url(images/icons-png/arrow-u-l-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-arrow-u-r:after,.ui-nosvg .ui-alt-icon .ui-icon-arrow-u-r:after{background-image:url(images/icons-png/arrow-u-r-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-audio:after,.ui-nosvg .ui-alt-icon .ui-icon-audio:after{background-image:url(images/icons-png/audio-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-back:after,.ui-nosvg .ui-alt-icon .ui-icon-back:after{background-image:url(images/icons-png/back-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-bars:after,.ui-nosvg .ui-alt-icon .ui-icon-bars:after{background-image:url(images/icons-png/bars-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-bullets:after,.ui-nosvg .ui-alt-icon .ui-icon-bullets:after{background-image:url(images/icons-png/bullets-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-calendar:after,.ui-nosvg .ui-alt-icon .ui-icon-calendar:after{background-image:url(images/icons-png/calendar-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-camera:after,.ui-nosvg .ui-alt-icon .ui-icon-camera:after{background-image:url(images/icons-png/camera-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-carat-d:after,.ui-nosvg .ui-alt-icon .ui-icon-carat-d:after{background-image:url(images/icons-png/carat-d-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-carat-l:after,.ui-nosvg .ui-alt-icon .ui-icon-carat-l:after{background-image:url(images/icons-png/carat-l-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-carat-r:after,.ui-nosvg .ui-alt-icon .ui-icon-carat-r:after{background-image:url(images/icons-png/carat-r-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-carat-u:after,.ui-nosvg .ui-alt-icon .ui-icon-carat-u:after{background-image:url(images/icons-png/carat-u-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-check:after,.ui-nosvg .ui-alt-icon .ui-icon-check:after,.ui-nosvg .ui-alt-icon.ui-btn.ui-checkbox-on:after,.ui-nosvg .ui-alt-icon .ui-btn.ui-checkbox-on:after{background-image:url(images/icons-png/check-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-clock:after,.ui-nosvg .ui-alt-icon .ui-icon-clock:after{background-image:url(images/icons-png/clock-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-cloud:after,.ui-nosvg .ui-alt-icon .ui-icon-cloud:after{background-image:url(images/icons-png/cloud-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-comment:after,.ui-nosvg .ui-alt-icon .ui-icon-comment:after{background-image:url(images/icons-png/comment-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-delete:after,.ui-nosvg .ui-alt-icon .ui-icon-delete:after{background-image:url(images/icons-png/delete-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-edit:after,.ui-nosvg .ui-alt-icon .ui-icon-edit:after{background-image:url(images/icons-png/edit-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-eye:after,.ui-nosvg .ui-alt-icon .ui-icon-eye:after{background-image:url(images/icons-png/eye-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-forbidden:after,.ui-nosvg .ui-alt-icon .ui-icon-forbidden:after{background-image:url(images/icons-png/forbidden-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-forward:after,.ui-nosvg .ui-alt-icon .ui-icon-forward:after{background-image:url(images/icons-png/forward-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-gear:after,.ui-nosvg .ui-alt-icon .ui-icon-gear:after{background-image:url(images/icons-png/gear-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-grid:after,.ui-nosvg .ui-alt-icon .ui-icon-grid:after{background-image:url(images/icons-png/grid-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-heart:after,.ui-nosvg .ui-alt-icon .ui-icon-heart:after{background-image:url(images/icons-png/heart-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-home:after,.ui-nosvg .ui-alt-icon .ui-icon-home:after{background-image:url(images/icons-png/home-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-info:after,.ui-nosvg .ui-alt-icon .ui-icon-info:after{background-image:url(images/icons-png/info-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-location:after,.ui-nosvg .ui-alt-icon .ui-icon-location:after{background-image:url(images/icons-png/location-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-lock:after,.ui-nosvg .ui-alt-icon .ui-icon-lock:after{background-image:url(images/icons-png/lock-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-mail:after,.ui-nosvg .ui-alt-icon .ui-icon-mail:after{background-image:url(images/icons-png/mail-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-minus:after,.ui-nosvg .ui-alt-icon .ui-icon-minus:after{background-image:url(images/icons-png/minus-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-navigation:after,.ui-nosvg .ui-alt-icon .ui-icon-navigation:after{background-image:url(images/icons-png/navigation-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-phone:after,.ui-nosvg .ui-alt-icon .ui-icon-phone:after{background-image:url(images/icons-png/phone-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-plus:after,.ui-nosvg .ui-alt-icon .ui-icon-plus:after{background-image:url(images/icons-png/plus-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-power:after,.ui-nosvg .ui-alt-icon .ui-icon-power:after{background-image:url(images/icons-png/power-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-recycle:after,.ui-nosvg .ui-alt-icon .ui-icon-recycle:after{background-image:url(images/icons-png/recycle-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-refresh:after,.ui-nosvg .ui-alt-icon .ui-icon-refresh:after{background-image:url(images/icons-png/refresh-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-search:after,.ui-nosvg .ui-alt-icon .ui-icon-search:after,.ui-nosvg .ui-input-search:after{background-image:url(images/icons-png/search-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-shop:after,.ui-nosvg .ui-alt-icon .ui-icon-shop:after{background-image:url(images/icons-png/shop-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-star:after,.ui-nosvg .ui-alt-icon .ui-icon-star:after{background-image:url(images/icons-png/star-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-tag:after,.ui-nosvg .ui-alt-icon .ui-icon-tag:after{background-image:url(images/icons-png/tag-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-user:after,.ui-nosvg .ui-alt-icon .ui-icon-user:after{background-image:url(images/icons-png/user-black.png)}.ui-nosvg .ui-alt-icon.ui-icon-video:after,.ui-nosvg .ui-alt-icon .ui-icon-video:after{background-image:url(images/icons-png/video-black.png)} |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /*! jQuery Mobile 1.4.3 | Git HEADhash: b9c6473 <> 2014-07-01T15:37:36Z | (c) 2010, 2014 jQuery Foundation, Inc. | jquery.org/license */ | |
| .ui-mobile,.ui-mobile body{height:99.9%}.ui-mobile fieldset,.ui-page{padding:0;margin:0}.ui-mobile a img,.ui-mobile fieldset{border-width:0}.ui-mobile fieldset{min-width:0}@-moz-document url-prefix(){.ui-mobile fieldset{display:table-column;vertical-align:middle}}.ui-mobile-viewport{margin:0;overflow-x:visible;-webkit-text-size-adjust:100%;-ms-text-size-adjust:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}body.ui-mobile-viewport,div.ui-mobile-viewport{overflow-x:hidden}.ui-mobile [data-role=page],.ui-mobile [data-role=dialog],.ui-page{top:0;left:0;width:100%;min-height:100%;position:absolute;display:none;border:0}.ui-page{outline:0}.ui-mobile .ui-page-active{display:block;overflow:visible;overflow-x:hidden}@media screen and (orientation:portrait){.ui-mobile .ui-page{min-height:420px}}@media screen and (orientation:landscape){.ui-mobile .ui-page{min-height:300px}}.ui-mobile-rendering>*{visibility:hidden}.ui-nojs{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-loading .ui-loader{display:block}.ui-loader{display:none;z-index:9999999;position:fixed;top:50%;left:50%;border:0}.ui-loader-default{background:0;filter:Alpha(Opacity=18);opacity:.18;width:2.875em;height:2.875em;margin-left:-1.4375em;margin-top:-1.4375em}.ui-loader-verbose{width:12.5em;filter:Alpha(Opacity=88);opacity:.88;box-shadow:0 1px 1px -1px #fff;height:auto;margin-left:-6.875em;margin-top:-2.6875em;padding:.625em}.ui-loader-default h1{font-size:0;width:0;height:0;overflow:hidden}.ui-loader-verbose h1{font-size:1em;margin:0;text-align:center}.ui-loader .ui-icon-loading{background-color:#000;display:block;margin:0;width:2.75em;height:2.75em;padding:.0625em;-webkit-border-radius:2.25em;border-radius:2.25em}.ui-loader-verbose .ui-icon-loading{margin:0 auto .625em;filter:Alpha(Opacity=75);opacity:.75}.ui-loader-textonly{padding:.9375em;margin-left:-7.1875em}.ui-loader-textonly .ui-icon-loading{display:none}.ui-loader-fakefix{position:absolute}.ui-bar,.ui-body{position:relative;padding:.4em 1em;overflow:hidden;display:block;clear:both}.ui-bar h1,.ui-bar h2,.ui-bar h3,.ui-bar h4,.ui-bar h5,.ui-bar h6{margin:0;padding:0;font-size:1em;display:inline-block}.ui-header,.ui-footer{border-width:1px 0;border-style:solid;position:relative}.ui-header:empty,.ui-footer:empty{min-height:2.6875em}.ui-header .ui-title,.ui-footer .ui-title{font-size:1em;min-height:1.1em;text-align:center;display:block;margin:0 30%;padding:.7em 0;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;outline:0!important}.ui-footer .ui-title{margin:0 1em}.ui-content{border-width:0;overflow:visible;overflow-x:hidden;padding:1em}.ui-corner-all>.ui-header:first-child,.ui-corner-all>.ui-content:first-child,.ui-corner-all>.ui-footer:first-child{-webkit-border-top-left-radius:inherit;border-top-left-radius:inherit;-webkit-border-top-right-radius:inherit;border-top-right-radius:inherit}.ui-corner-all>.ui-header:last-child,.ui-corner-all>.ui-content:last-child,.ui-corner-all>.ui-footer:last-child{-webkit-border-bottom-left-radius:inherit;border-bottom-left-radius:inherit;-webkit-border-bottom-right-radius:inherit;border-bottom-right-radius:inherit}.ui-btn{font-size:16px;margin:.5em 0;padding:.7em 1em;display:block;position:relative;text-align:center;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.ui-btn-icon-notext,.ui-header button.ui-btn.ui-btn-icon-notext,.ui-footer button.ui-btn.ui-btn-icon-notext{padding:0;width:1.75em;height:1.75em;text-indent:-9999px;white-space:nowrap!important}.ui-mini{font-size:12.5px}.ui-mini .ui-btn{font-size:inherit}.ui-header .ui-btn,.ui-footer .ui-btn{font-size:12.5px;display:inline-block;vertical-align:middle}.ui-header .ui-controlgroup .ui-btn-icon-notext,.ui-footer .ui-controlgroup .ui-btn-icon-notext{font-size:12.5px}.ui-header .ui-btn-left,.ui-header .ui-btn-right{font-size:12.5px}.ui-mini.ui-btn-icon-notext,.ui-mini .ui-btn-icon-notext,.ui-header .ui-btn-icon-notext,.ui-footer .ui-btn-icon-notext{font-size:16px;padding:0}.ui-btn-inline{display:inline-block;vertical-align:middle;margin-right:.625em}.ui-btn-icon-left{padding-left:2.5em}.ui-btn-icon-right{padding-right:2.5em}.ui-btn-icon-top{padding-top:2.5em}.ui-btn-icon-bottom{padding-bottom:2.5em}.ui-header .ui-btn-icon-top,.ui-footer .ui-btn-icon-top,.ui-header .ui-btn-icon-bottom,.ui-footer .ui-btn-icon-bottom{padding-left:.3125em;padding-right:.3125em}.ui-btn-icon-left:after,.ui-btn-icon-right:after,.ui-btn-icon-top:after,.ui-btn-icon-bottom:after,.ui-btn-icon-notext:after{content:"";position:absolute;display:block;width:22px;height:22px}.ui-btn-icon-notext:after,.ui-btn-icon-left:after,.ui-btn-icon-right:after{top:50%;margin-top:-11px}.ui-btn-icon-left:after{left:.5625em}.ui-btn-icon-right:after{right:.5625em}.ui-mini.ui-btn-icon-left:after,.ui-mini .ui-btn-icon-left:after,.ui-header .ui-btn-icon-left:after,.ui-footer .ui-btn-icon-left:after{left:.37em}.ui-mini.ui-btn-icon-right:after,.ui-mini .ui-btn-icon-right:after,.ui-header .ui-btn-icon-right:after,.ui-footer .ui-btn-icon-right:after{right:.37em}.ui-btn-icon-notext:after,.ui-btn-icon-top:after,.ui-btn-icon-bottom:after{left:50%;margin-left:-11px}.ui-btn-icon-top:after{top:.5625em}.ui-btn-icon-bottom:after{top:auto;bottom:.5625em}.ui-header .ui-btn-left,.ui-header .ui-btn-right,.ui-btn-left>[class*=ui-],.ui-btn-right>[class*=ui-]{margin:0}.ui-btn-left,.ui-btn-right{position:absolute;top:.24em}.ui-btn-left{left:.4em}.ui-btn-right{right:.4em}.ui-btn-icon-notext.ui-btn-left{top:.3125em;left:.3125em}.ui-btn-icon-notext.ui-btn-right{top:.3125em;right:.3125em}button.ui-btn,.ui-controlgroup-controls button.ui-btn-icon-notext{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-appearance:none;-moz-appearance:none;width:100%}button.ui-btn-inline,.ui-header button.ui-btn,.ui-footer button.ui-btn{width:auto}button.ui-btn::-moz-focus-inner{border:0}button.ui-btn-icon-notext,.ui-controlgroup-horizontal .ui-controlgroup-controls button.ui-btn{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;width:1.75em}.ui-mobile label,.ui-controlgroup-label{display:block;margin:0 0 .4em}.ui-hide-label>label,.ui-hide-label .ui-controlgroup-label,.ui-hide-label .ui-rangeslider label,.ui-hidden-accessible{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-screen-hidden{display:none!important}.ui-mobile-viewport-transitioning,.ui-mobile-viewport-transitioning .ui-page{width:100%;height:100%;overflow:hidden;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.ui-page-pre-in{opacity:0}.in{-webkit-animation-timing-function:ease-out;-webkit-animation-duration:350ms;-moz-animation-timing-function:ease-out;-moz-animation-duration:350ms;animation-timing-function:ease-out;animation-duration:350ms}.out{-webkit-animation-timing-function:ease-in;-webkit-animation-duration:225ms;-moz-animation-timing-function:ease-in;-moz-animation-duration:225ms;animation-timing-function:ease-in;animation-duration:225ms}@-webkit-keyframes fadein{from{opacity:0}to{opacity:1}}@-moz-keyframes fadein{from{opacity:0}to{opacity:1}}@keyframes fadein{from{opacity:0}to{opacity:1}}@-webkit-keyframes fadeout{from{opacity:1}to{opacity:0}}@-moz-keyframes fadeout{from{opacity:1}to{opacity:0}}@keyframes fadeout{from{opacity:1}to{opacity:0}}.fade.out{opacity:0;-webkit-animation-duration:125ms;-webkit-animation-name:fadeout;-moz-animation-duration:125ms;-moz-animation-name:fadeout;animation-duration:125ms;animation-name:fadeout}.fade.in{opacity:1;-webkit-animation-duration:225ms;-webkit-animation-name:fadein;-moz-animation-duration:225ms;-moz-animation-name:fadein;animation-duration:225ms;animation-name:fadein}.pop{-webkit-transform-origin:50% 50%;-moz-transform-origin:50% 50%;transform-origin:50% 50%}.pop.in{-webkit-transform:scale(1);-webkit-animation-name:popin;-webkit-animation-duration:350ms;-moz-transform:scale(1);-moz-animation-name:popin;-moz-animation-duration:350ms;transform:scale(1);animation-name:popin;animation-duration:350ms;opacity:1}.pop.out{-webkit-animation-name:fadeout;-webkit-animation-duration:100ms;-moz-animation-name:fadeout;-moz-animation-duration:100ms;animation-name:fadeout;animation-duration:100ms;opacity:0}.pop.in.reverse{-webkit-animation-name:fadein;-moz-animation-name:fadein;animation-name:fadein}.pop.out.reverse{-webkit-transform:scale(.8);-webkit-animation-name:popout;-moz-transform:scale(.8);-moz-animation-name:popout;transform:scale(.8);animation-name:popout}@-webkit-keyframes popin{from{-webkit-transform:scale(.8);opacity:0}to{-webkit-transform:scale(1);opacity:1}}@-moz-keyframes popin{from{-moz-transform:scale(.8);opacity:0}to{-moz-transform:scale(1);opacity:1}}@keyframes popin{from{transform:scale(.8);opacity:0}to{transform:scale(1);opacity:1}}@-webkit-keyframes popout{from{-webkit-transform:scale(1);opacity:1}to{-webkit-transform:scale(.8);opacity:0}}@-moz-keyframes popout{from{-moz-transform:scale(1);opacity:1}to{-moz-transform:scale(.8);opacity:0}}@keyframes popout{from{transform:scale(1);opacity:1}to{transform:scale(.8);opacity:0}}@-webkit-keyframes slideinfromright{from{-webkit-transform:translate3d(100%,0,0)}to{-webkit-transform:translate3d(0,0,0)}}@-moz-keyframes slideinfromright{from{-moz-transform:translateX(100%)}to{-moz-transform:translateX(0)}}@keyframes slideinfromright{from{transform:translateX(100%)}to{transform:translateX(0)}}@-webkit-keyframes slideinfromleft{from{-webkit-transform:translate3d(-100%,0,0)}to{-webkit-transform:translate3d(0,0,0)}}@-moz-keyframes slideinfromleft{from{-moz-transform:translateX(-100%)}to{-moz-transform:translateX(0)}}@keyframes slideinfromleft{from{transform:translateX(-100%)}to{transform:translateX(0)}}@-webkit-keyframes slideouttoleft{from{-webkit-transform:translate3d(0,0,0)}to{-webkit-transform:translate3d(-100%,0,0)}}@-moz-keyframes slideouttoleft{from{-moz-transform:translateX(0)}to{-moz-transform:translateX(-100%)}}@keyframes slideouttoleft{from{transform:translateX(0)}to{transform:translateX(-100%)}}@-webkit-keyframes slideouttoright{from{-webkit-transform:translate3d(0,0,0)}to{-webkit-transform:translate3d(100%,0,0)}}@-moz-keyframes slideouttoright{from{-moz-transform:translateX(0)}to{-moz-transform:translateX(100%)}}@keyframes slideouttoright{from{transform:translateX(0)}to{transform:translateX(100%)}}.slide.out,.slide.in{-webkit-animation-timing-function:ease-out;-webkit-animation-duration:350ms;-moz-animation-timing-function:ease-out;-moz-animation-duration:350ms;animation-timing-function:ease-out;animation-duration:350ms}.slide.out{-webkit-transform:translate3d(-100%,0,0);-webkit-animation-name:slideouttoleft;-moz-transform:translateX(-100%);-moz-animation-name:slideouttoleft;transform:translateX(-100%);animation-name:slideouttoleft}.slide.in{-webkit-transform:translate3d(0,0,0);-webkit-animation-name:slideinfromright;-moz-transform:translateX(0);-moz-animation-name:slideinfromright;transform:translateX(0);animation-name:slideinfromright}.slide.out.reverse{-webkit-transform:translate3d(100%,0,0);-webkit-animation-name:slideouttoright;-moz-transform:translateX(100%);-moz-animation-name:slideouttoright;transform:translateX(100%);animation-name:slideouttoright}.slide.in.reverse{-webkit-transform:translate3d(0,0,0);-webkit-animation-name:slideinfromleft;-moz-transform:translateX(0);-moz-animation-name:slideinfromleft;transform:translateX(0);animation-name:slideinfromleft}.slidefade.out{-webkit-transform:translateX(-100%);-webkit-animation-name:slideouttoleft;-webkit-animation-duration:225ms;-moz-transform:translateX(-100%);-moz-animation-name:slideouttoleft;-moz-animation-duration:225ms;transform:translateX(-100%);animation-name:slideouttoleft;animation-duration:225ms}.slidefade.in{-webkit-transform:translateX(0);-webkit-animation-name:fadein;-webkit-animation-duration:200ms;-moz-transform:translateX(0);-moz-animation-name:fadein;-moz-animation-duration:200ms;transform:translateX(0);animation-name:fadein;animation-duration:200ms}.slidefade.out.reverse{-webkit-transform:translateX(100%);-webkit-animation-name:slideouttoright;-webkit-animation-duration:200ms;-moz-transform:translateX(100%);-moz-animation-name:slideouttoright;-moz-animation-duration:200ms;transform:translateX(100%);animation-name:slideouttoright;animation-duration:200ms}.slidefade.in.reverse{-webkit-transform:translateX(0);-webkit-animation-name:fadein;-webkit-animation-duration:200ms;-moz-transform:translateX(0);-moz-animation-name:fadein;-moz-animation-duration:200ms;transform:translateX(0);animation-name:fadein;animation-duration:200ms}.slidedown.out{-webkit-animation-name:fadeout;-webkit-animation-duration:100ms;-moz-animation-name:fadeout;-moz-animation-duration:100ms;animation-name:fadeout;animation-duration:100ms}.slidedown.in{-webkit-transform:translateY(0);-webkit-animation-name:slideinfromtop;-webkit-animation-duration:250ms;-moz-transform:translateY(0);-moz-animation-name:slideinfromtop;-moz-animation-duration:250ms;transform:translateY(0);animation-name:slideinfromtop;animation-duration:250ms}.slidedown.in.reverse{-webkit-animation-name:fadein;-webkit-animation-duration:150ms;-moz-animation-name:fadein;-moz-animation-duration:150ms;animation-name:fadein;animation-duration:150ms}.slidedown.out.reverse{-webkit-transform:translateY(-100%);-webkit-animation-name:slideouttotop;-webkit-animation-duration:200ms;-moz-transform:translateY(-100%);-moz-animation-name:slideouttotop;-moz-animation-duration:200ms;transform:translateY(-100%);animation-name:slideouttotop;animation-duration:200ms}@-webkit-keyframes slideinfromtop{from{-webkit-transform:translateY(-100%)}to{-webkit-transform:translateY(0)}}@-moz-keyframes slideinfromtop{from{-moz-transform:translateY(-100%)}to{-moz-transform:translateY(0)}}@keyframes slideinfromtop{from{transform:translateY(-100%)}to{transform:translateY(0)}}@-webkit-keyframes slideouttotop{from{-webkit-transform:translateY(0)}to{-webkit-transform:translateY(-100%)}}@-moz-keyframes slideouttotop{from{-moz-transform:translateY(0)}to{-moz-transform:translateY(-100%)}}@keyframes slideouttotop{from{transform:translateY(0)}to{transform:translateY(-100%)}}.slideup.out{-webkit-animation-name:fadeout;-webkit-animation-duration:100ms;-moz-animation-name:fadeout;-moz-animation-duration:100ms;animation-name:fadeout;animation-duration:100ms}.slideup.in{-webkit-transform:translateY(0);-webkit-animation-name:slideinfrombottom;-webkit-animation-duration:250ms;-moz-transform:translateY(0);-moz-animation-name:slideinfrombottom;-moz-animation-duration:250ms;transform:translateY(0);animation-name:slideinfrombottom;animation-duration:250ms}.slideup.in.reverse{-webkit-animation-name:fadein;-webkit-animation-duration:150ms;-moz-animation-name:fadein;-moz-animation-duration:150ms;animation-name:fadein;animation-duration:150ms}.slideup.out.reverse{-webkit-transform:translateY(100%);-webkit-animation-name:slideouttobottom;-webkit-animation-duration:200ms;-moz-transform:translateY(100%);-moz-animation-name:slideouttobottom;-moz-animation-duration:200ms;transform:translateY(100%);animation-name:slideouttobottom;animation-duration:200ms}@-webkit-keyframes slideinfrombottom{from{-webkit-transform:translateY(100%)}to{-webkit-transform:translateY(0)}}@-moz-keyframes slideinfrombottom{from{-moz-transform:translateY(100%)}to{-moz-transform:translateY(0)}}@keyframes slideinfrombottom{from{transform:translateY(100%)}to{transform:translateY(0)}}@-webkit-keyframes slideouttobottom{from{-webkit-transform:translateY(0)}to{-webkit-transform:translateY(100%)}}@-moz-keyframes slideouttobottom{from{-moz-transform:translateY(0)}to{-moz-transform:translateY(100%)}}@keyframes slideouttobottom{from{transform:translateY(0)}to{transform:translateY(100%)}}.viewport-flip{-webkit-perspective:1000;-moz-perspective:1000;perspective:1000;position:absolute}.flip{-webkit-backface-visibility:hidden;-webkit-transform:translateX(0);-moz-backface-visibility:hidden;-moz-transform:translateX(0);backface-visibility:hidden;transform:translateX(0)}.flip.out{-webkit-transform:rotateY(-90deg) scale(.9);-webkit-animation-name:flipouttoleft;-webkit-animation-duration:175ms;-moz-transform:rotateY(-90deg) scale(.9);-moz-animation-name:flipouttoleft;-moz-animation-duration:175ms;transform:rotateY(-90deg) scale(.9);animation-name:flipouttoleft;animation-duration:175ms}.flip.in{-webkit-animation-name:flipintoright;-webkit-animation-duration:225ms;-moz-animation-name:flipintoright;-moz-animation-duration:225ms;animation-name:flipintoright;animation-duration:225ms}.flip.out.reverse{-webkit-transform:rotateY(90deg) scale(.9);-webkit-animation-name:flipouttoright;-moz-transform:rotateY(90deg) scale(.9);-moz-animation-name:flipouttoright;transform:rotateY(90deg) scale(.9);animation-name:flipouttoright}.flip.in.reverse{-webkit-animation-name:flipintoleft;-moz-animation-name:flipintoleft;animation-name:flipintoleft}@-webkit-keyframes flipouttoleft{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(-90deg) scale(.9)}}@-moz-keyframes flipouttoleft{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(-90deg) scale(.9)}}@keyframes flipouttoleft{from{transform:rotateY(0)}to{transform:rotateY(-90deg) scale(.9)}}@-webkit-keyframes flipouttoright{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(90deg) scale(.9)}}@-moz-keyframes flipouttoright{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(90deg) scale(.9)}}@keyframes flipouttoright{from{transform:rotateY(0)}to{transform:rotateY(90deg) scale(.9)}}@-webkit-keyframes flipintoleft{from{-webkit-transform:rotateY(-90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoleft{from{-moz-transform:rotateY(-90deg) scale(.9)}to{-moz-transform:rotateY(0)}}@keyframes flipintoleft{from{transform:rotateY(-90deg) scale(.9)}to{transform:rotateY(0)}}@-webkit-keyframes flipintoright{from{-webkit-transform:rotateY(90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoright{from{-moz-transform:rotateY(90deg) scale(.9)}to{-moz-transform:rotateY(0)}}@keyframes flipintoright{from{transform:rotateY(90deg) scale(.9)}to{transform:rotateY(0)}}.viewport-turn{-webkit-perspective:200px;-moz-perspective:200px;-ms-perspective:200px;perspective:200px;position:absolute}.turn{-webkit-backface-visibility:hidden;-webkit-transform:translateX(0);-webkit-transform-origin:0;-moz-backface-visibility:hidden;-moz-transform:translateX(0);-moz-transform-origin:0;backface-visibility:hidden;transform:translateX(0);transform-origin:0}.turn.out{-webkit-transform:rotateY(-90deg) scale(.9);-webkit-animation-name:flipouttoleft;-webkit-animation-duration:125ms;-moz-transform:rotateY(-90deg) scale(.9);-moz-animation-name:flipouttoleft;-moz-animation-duration:125ms;transform:rotateY(-90deg) scale(.9);animation-name:flipouttoleft;animation-duration:125ms}.turn.in{-webkit-animation-name:flipintoright;-webkit-animation-duration:250ms;-moz-animation-name:flipintoright;-moz-animation-duration:250ms;animation-name:flipintoright;animation-duration:250ms}.turn.out.reverse{-webkit-transform:rotateY(90deg) scale(.9);-webkit-animation-name:flipouttoright;-moz-transform:rotateY(90deg) scale(.9);-moz-animation-name:flipouttoright;transform:rotateY(90deg) scale(.9);animation-name:flipouttoright}.turn.in.reverse{-webkit-animation-name:flipintoleft;-moz-animation-name:flipintoleft;animation-name:flipintoleft}@-webkit-keyframes flipouttoleft{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(-90deg) scale(.9)}}@-moz-keyframes flipouttoleft{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(-90deg) scale(.9)}}@keyframes flipouttoleft{from{transform:rotateY(0)}to{transform:rotateY(-90deg) scale(.9)}}@-webkit-keyframes flipouttoright{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(90deg) scale(.9)}}@-moz-keyframes flipouttoright{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(90deg) scale(.9)}}@keyframes flipouttoright{from{transform:rotateY(0)}to{transform:rotateY(90deg) scale(.9)}}@-webkit-keyframes flipintoleft{from{-webkit-transform:rotateY(-90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoleft{from{-moz-transform:rotateY(-90deg) scale(.9)}to{-moz-transform:rotateY(0)}}@keyframes flipintoleft{from{transform:rotateY(-90deg) scale(.9)}to{transform:rotateY(0)}}@-webkit-keyframes flipintoright{from{-webkit-transform:rotateY(90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoright{from{-moz-transform:rotateY(90deg) scale(.9)}to{-moz-transform:rotateY(0)}}@keyframes flipintoright{from{transform:rotateY(90deg) scale(.9)}to{transform:rotateY(0)}}.flow{-webkit-transform-origin:50% 30%;-webkit-box-shadow:0 0 20px rgba(0,0,0,.4);-moz-transform-origin:50% 30%;-moz-box-shadow:0 0 20px rgba(0,0,0,.4);transform-origin:50% 30%;box-shadow:0 0 20px rgba(0,0,0,.4)}.ui-dialog.flow{-webkit-transform-origin:none;-webkit-box-shadow:none;-moz-transform-origin:none;-moz-box-shadow:none;transform-origin:none;box-shadow:none}.flow.out{-webkit-transform:translateX(-100%) scale(.7);-webkit-animation-name:flowouttoleft;-webkit-animation-timing-function:ease;-webkit-animation-duration:350ms;-moz-transform:translateX(-100%) scale(.7);-moz-animation-name:flowouttoleft;-moz-animation-timing-function:ease;-moz-animation-duration:350ms;transform:translateX(-100%) scale(.7);animation-name:flowouttoleft;animation-timing-function:ease;animation-duration:350ms}.flow.in{-webkit-transform:translateX(0) scale(1);-webkit-animation-name:flowinfromright;-webkit-animation-timing-function:ease;-webkit-animation-duration:350ms;-moz-transform:translateX(0) scale(1);-moz-animation-name:flowinfromright;-moz-animation-timing-function:ease;-moz-animation-duration:350ms;transform:translateX(0) scale(1);animation-name:flowinfromright;animation-timing-function:ease;animation-duration:350ms}.flow.out.reverse{-webkit-transform:translateX(100%);-webkit-animation-name:flowouttoright;-moz-transform:translateX(100%);-moz-animation-name:flowouttoright;transform:translateX(100%);animation-name:flowouttoright}.flow.in.reverse{-webkit-animation-name:flowinfromleft;-moz-animation-name:flowinfromleft;animation-name:flowinfromleft}@-webkit-keyframes flowouttoleft{0%{-webkit-transform:translateX(0) scale(1)}60%,70%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(-100%) scale(.7)}}@-moz-keyframes flowouttoleft{0%{-moz-transform:translateX(0) scale(1)}60%,70%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(-100%) scale(.7)}}@keyframes flowouttoleft{0%{transform:translateX(0) scale(1)}60%,70%{transform:translateX(0) scale(.7)}100%{transform:translateX(-100%) scale(.7)}}@-webkit-keyframes flowouttoright{0%{-webkit-transform:translateX(0) scale(1)}60%,70%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(100%) scale(.7)}}@-moz-keyframes flowouttoright{0%{-moz-transform:translateX(0) scale(1)}60%,70%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(100%) scale(.7)}}@keyframes flowouttoright{0%{transform:translateX(0) scale(1)}60%,70%{transform:translateX(0) scale(.7)}100%{transform:translateX(100%) scale(.7)}}@-webkit-keyframes flowinfromleft{0%{-webkit-transform:translateX(-100%) scale(.7)}30%,40%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(0) scale(1)}}@-moz-keyframes flowinfromleft{0%{-moz-transform:translateX(-100%) scale(.7)}30%,40%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(0) scale(1)}}@keyframes flowinfromleft{0%{transform:translateX(-100%) scale(.7)}30%,40%{transform:translateX(0) scale(.7)}100%{transform:translateX(0) scale(1)}}@-webkit-keyframes flowinfromright{0%{-webkit-transform:translateX(100%) scale(.7)}30%,40%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(0) scale(1)}}@-moz-keyframes flowinfromright{0%{-moz-transform:translateX(100%) scale(.7)}30%,40%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(0) scale(1)}}@keyframes flowinfromright{0%{transform:translateX(100%) scale(.7)}30%,40%{transform:translateX(0) scale(.7)}100%{transform:translateX(0) scale(1)}}.ui-field-contain,.ui-mobile fieldset.ui-field-contain{display:block;position:relative;overflow:visible;clear:both;padding:.8em 0}.ui-field-contain>label~[class*=ui-],.ui-field-contain .ui-controlgroup-controls{margin:0}.ui-field-contain:last-child{border-bottom-width:0}@media (min-width:28em){.ui-field-contain,.ui-mobile fieldset.ui-field-contain{padding:0;margin:1em 0;border-bottom-width:0}.ui-field-contain:before,.ui-field-contain:after{content:"";display:table}.ui-field-contain:after{clear:both}.ui-field-contain>label,.ui-field-contain .ui-controlgroup-label,.ui-field-contain>.ui-rangeslider>label{float:left;width:20%;margin:.5em 2% 0 0}.ui-popup .ui-field-contain>label,.ui-popup .ui-field-contain .ui-controlgroup-label,.ui-popup .ui-field-contain>.ui-rangeslider>label{float:none;width:auto;margin:0 0 .4em}.ui-field-contain>label~[class*=ui-],.ui-field-contain .ui-controlgroup-controls{float:left;width:78%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.ui-hide-label>label~[class*=ui-],.ui-hide-label .ui-controlgroup-controls,.ui-popup .ui-field-contain>label~[class*=ui-],.ui-popup .ui-field-contain .ui-controlgroup-controls{float:none;width:100%}.ui-field-contain>label~.ui-btn-inline{width:auto;margin-right:.625em}}.ui-grid-a,.ui-grid-b,.ui-grid-c,.ui-grid-d,.ui-grid-solo{overflow:hidden}.ui-block-a,.ui-block-b,.ui-block-c,.ui-block-d,.ui-block-e{margin:0;padding:0;border:0;float:left;min-height:1px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.ui-block-a{clear:left}ul.ui-grid-a,ul.ui-grid-b,ul.ui-grid-c,ul.ui-grid-d,ul.ui-grid-solo,li.ui-block-a,li.ui-block-b,li.ui-block-c,li.ui-block-d,li.ui-block-e{margin-left:0;margin-right:0;padding:0;list-style:none}[class*=ui-block-]>button.ui-btn{margin-right:0;margin-left:0}[class*=ui-block-]>.ui-btn,[class*=ui-block-]>.ui-select,[class*=ui-block-]>.ui-checkbox,[class*=ui-block-]>.ui-radio,[class*=ui-block-]>button.ui-btn-inline,[class*=ui-block-]>button.ui-btn-icon-notext,.ui-header [class*=ui-block-]>button.ui-btn,.ui-footer [class*=ui-block-]>button.ui-btn{margin-right:.3125em;margin-left:.3125em}.ui-grid-a>.ui-block-a,.ui-grid-a>.ui-block-b{width:50%}.ui-grid-b>.ui-block-a,.ui-grid-b>.ui-block-b,.ui-grid-b>.ui-block-c{width:33.333%}.ui-grid-c>.ui-block-a,.ui-grid-c>.ui-block-b,.ui-grid-c>.ui-block-c,.ui-grid-c>.ui-block-d{width:25%}.ui-grid-d>.ui-block-a,.ui-grid-d>.ui-block-b,.ui-grid-d>.ui-block-c,.ui-grid-d>.ui-block-d,.ui-grid-d>.ui-block-e{width:20%}.ui-grid-solo>.ui-block-a{width:100%;float:none}@media (max-width:35em){.ui-responsive>.ui-block-a,.ui-responsive>.ui-block-b,.ui-responsive>.ui-block-c,.ui-responsive>.ui-block-d,.ui-responsive>.ui-block-e{width:100%;float:none}}.ui-header-fixed,.ui-footer-fixed{left:0;right:0;width:100%;position:fixed;z-index:1000}.ui-header-fixed{top:-1px;padding-top:1px}.ui-header-fixed.ui-fixed-hidden{top:0;padding-top:0}.ui-header-fixed .ui-btn-left,.ui-header-fixed .ui-btn-right{margin-top:1px}.ui-header-fixed.ui-fixed-hidden .ui-btn-left,.ui-header-fixed.ui-fixed-hidden .ui-btn-right{margin-top:0}.ui-footer-fixed{bottom:-1px;padding-bottom:1px}.ui-footer-fixed.ui-fixed-hidden{bottom:0;padding-bottom:0}.ui-header-fullscreen,.ui-footer-fullscreen{filter:Alpha(Opacity=90);opacity:.9}.ui-page-header-fixed{padding-top:2.8125em}.ui-page-footer-fixed{padding-bottom:2.8125em}.ui-page-header-fullscreen>.ui-content,.ui-page-footer-fullscreen>.ui-content{padding:0}.ui-fixed-hidden{position:absolute}.ui-footer-fixed.ui-fixed-hidden{display:none}.ui-page .ui-footer-fixed.ui-fixed-hidden{display:block}.ui-page-header-fullscreen .ui-fixed-hidden,.ui-page-footer-fullscreen .ui-fixed-hidden{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-header-fixed .ui-btn,.ui-footer-fixed .ui-btn{z-index:10}.ui-android-2x-fixed .ui-li-has-thumb{-webkit-transform:translate3d(0,0,0)}.ui-navbar{max-width:100%}.ui-navbar ul:before,.ui-navbar ul:after{content:"";display:table}.ui-navbar ul:after{clear:both}.ui-navbar ul{list-style:none;margin:0;padding:0;position:relative;display:block;border:0;max-width:100%;overflow:visible}.ui-navbar li .ui-btn{font-size:12.5px;display:block;margin:0;border-right-width:0}.ui-navbar .ui-btn:focus{z-index:1}.ui-navbar li:last-child .ui-btn{margin-right:-4px}.ui-navbar li:last-child .ui-btn:after{margin-right:4px}.ui-content .ui-navbar li:last-child .ui-btn,.ui-content .ui-navbar .ui-grid-duo .ui-block-b .ui-btn{border-right-width:1px;margin-right:0}.ui-content .ui-navbar li:last-child .ui-btn:after,.ui-content .ui-navbar .ui-grid-duo .ui-block-b .ui-btn:after{margin-right:0}.ui-navbar .ui-grid-duo .ui-block-a:last-child .ui-btn{border-right-width:1px;margin-right:-1px}.ui-navbar .ui-grid-duo .ui-block-a:last-child .ui-btn:after{margin-right:1px}.ui-navbar .ui-grid-duo .ui-btn{border-top-width:0}.ui-navbar .ui-grid-duo .ui-block-a:first-child .ui-btn,.ui-navbar .ui-grid-duo .ui-block-a:first-child+.ui-block-b .ui-btn{border-top-width:1px}.ui-header .ui-navbar .ui-btn,.ui-footer .ui-navbar .ui-btn{border-top-width:0;border-bottom-width:0}.ui-header .ui-navbar .ui-grid-duo .ui-block-a:first-child .ui-btn,.ui-footer .ui-navbar .ui-grid-duo .ui-block-a:first-child .ui-btn,.ui-header .ui-navbar .ui-grid-duo .ui-block-a:first-child+.ui-block-b .ui-btn,.ui-footer .ui-navbar .ui-grid-duo .ui-block-a:first-child+.ui-block-b .ui-btn{border-top-width:0}.ui-header .ui-title~.ui-navbar .ui-btn,.ui-footer .ui-title~.ui-navbar .ui-btn,.ui-header .ui-navbar .ui-grid-duo .ui-btn,.ui-footer .ui-navbar .ui-grid-duo .ui-btn,.ui-header .ui-title~.ui-navbar .ui-grid-duo .ui-block-a:first-child .ui-btn,.ui-footer .ui-title~.ui-navbar .ui-grid-duo .ui-block-a:first-child .ui-btn,.ui-header .ui-title~.ui-navbar .ui-grid-duo .ui-block-a:first-child+.ui-block-b .ui-btn,.ui-footer .ui-title~.ui-navbar .ui-grid-duo .ui-block-a:first-child+.ui-block-b .ui-btn{border-top-width:1px}.ui-input-btn input{position:absolute;top:0;left:0;width:100%;height:100%;padding:0;border:0;outline:0;-webkit-border-radius:inherit;border-radius:inherit;-webkit-appearance:none;-moz-appearance:none;cursor:pointer;background:#fff;background:rgba(255,255,255,0);filter:Alpha(Opacity=0);opacity:.1;font-size:1px;text-indent:-9999px;z-index:2}.ui-input-btn.ui-state-disabled input{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-collapsible{margin:0 -1em}.ui-collapsible-inset,.ui-collapsible-set{margin:.5em 0}.ui-collapsible-heading{display:block;margin:0;padding:0;position:relative}.ui-collapsible-heading .ui-btn{text-align:left;margin:0;border-left-width:0;border-right-width:0}.ui-collapsible-heading .ui-btn-icon-top,.ui-collapsible-heading .ui-btn-icon-bottom{text-align:center}.ui-collapsible-inset .ui-collapsible-heading .ui-btn{border-right-width:1px;border-left-width:1px}.ui-collapsible-collapsed+.ui-collapsible:not(.ui-collapsible-inset)>.ui-collapsible-heading .ui-btn{border-top-width:0}.ui-collapsible-set .ui-collapsible:not(.ui-collapsible-inset) .ui-collapsible-heading .ui-btn{border-top-width:1px}.ui-collapsible-heading-status{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-collapsible-content{display:block;margin:0;padding:.5em 1em}.ui-collapsible-themed-content .ui-collapsible-content{border-left-width:0;border-right-width:0;border-top-width:0;border-bottom-width:1px;border-style:solid}.ui-collapsible-inset.ui-collapsible-themed-content .ui-collapsible-content{border-left-width:1px;border-right-width:1px}.ui-collapsible-inset .ui-collapsible-content{margin:0}.ui-collapsible-content-collapsed{display:none}.ui-collapsible-set>.ui-collapsible.ui-corner-all{-webkit-border-radius:0;border-radius:0}.ui-collapsible-heading,.ui-collapsible-heading>.ui-btn{-webkit-border-radius:inherit;border-radius:inherit}.ui-collapsible-set .ui-collapsible.ui-first-child{-webkit-border-top-right-radius:inherit;border-top-right-radius:inherit;-webkit-border-top-left-radius:inherit;border-top-left-radius:inherit}.ui-collapsible-content,.ui-collapsible-set .ui-collapsible.ui-last-child{-webkit-border-bottom-right-radius:inherit;border-bottom-right-radius:inherit;-webkit-border-bottom-left-radius:inherit;border-bottom-left-radius:inherit}.ui-collapsible-themed-content:not(.ui-collapsible-collapsed)>.ui-collapsible-heading{-webkit-border-bottom-right-radius:0;border-bottom-right-radius:0;-webkit-border-bottom-left-radius:0;border-bottom-left-radius:0}.ui-collapsible-set .ui-collapsible{margin:-1px -1em 0}.ui-collapsible-set .ui-collapsible-inset{margin:-1px 0 0}.ui-collapsible-set .ui-collapsible.ui-first-child{margin-top:0}.ui-controlgroup,fieldset.ui-controlgroup{padding:0;margin:.5em 0}.ui-field-contain .ui-controlgroup,.ui-field-contain fieldset.ui-controlgroup{margin:0}.ui-mini .ui-controlgroup-label{font-size:16px}.ui-controlgroup.ui-mini .ui-btn-icon-notext,.ui-controlgroup .ui-mini.ui-btn-icon-notext{font-size:inherit}.ui-controlgroup-controls .ui-btn,.ui-controlgroup-controls .ui-checkbox,.ui-controlgroup-controls .ui-radio,.ui-controlgroup-controls .ui-select{margin:0}.ui-controlgroup-controls .ui-btn:focus,.ui-controlgroup-controls .ui-btn.ui-focus{z-index:1}.ui-controlgroup-controls li{list-style:none}.ui-controlgroup-horizontal .ui-controlgroup-controls{display:inline-block;vertical-align:middle}.ui-controlgroup-horizontal .ui-controlgroup-controls:before,.ui-controlgroup-horizontal .ui-controlgroup-controls:after{content:"";display:table}.ui-controlgroup-horizontal .ui-controlgroup-controls:after{clear:both}.ui-controlgroup-horizontal .ui-controlgroup-controls>.ui-btn,.ui-controlgroup-horizontal .ui-controlgroup-controls li>.ui-btn,.ui-controlgroup-horizontal .ui-controlgroup-controls .ui-checkbox,.ui-controlgroup-horizontal .ui-controlgroup-controls .ui-radio,.ui-controlgroup-horizontal .ui-controlgroup-controls .ui-select{float:left;clear:none}.ui-controlgroup-horizontal .ui-controlgroup-controls button.ui-btn,.ui-controlgroup-controls .ui-btn-icon-notext{width:auto}.ui-controlgroup-horizontal .ui-controlgroup-controls .ui-btn-icon-notext,.ui-controlgroup-horizontal .ui-controlgroup-controls button.ui-btn-icon-notext{width:1.5em}.ui-controlgroup-controls .ui-btn-icon-notext{height:auto;padding:.7em 1em}.ui-controlgroup-vertical .ui-controlgroup-controls .ui-btn{border-bottom-width:0}.ui-controlgroup-vertical .ui-controlgroup-controls .ui-btn.ui-last-child{border-bottom-width:1px}.ui-controlgroup-horizontal .ui-controlgroup-controls .ui-btn{border-right-width:0}.ui-controlgroup-horizontal .ui-controlgroup-controls .ui-btn.ui-last-child{border-right-width:1px}.ui-controlgroup-controls .ui-btn-corner-all,.ui-controlgroup-controls .ui-btn.ui-corner-all{-webkit-border-radius:0;border-radius:0}.ui-controlgroup-controls,.ui-controlgroup-controls .ui-radio,.ui-controlgroup-controls .ui-checkbox,.ui-controlgroup-controls .ui-select,.ui-controlgroup-controls li{-webkit-border-radius:inherit;border-radius:inherit}.ui-controlgroup-vertical .ui-btn.ui-first-child{-webkit-border-top-left-radius:inherit;border-top-left-radius:inherit;-webkit-border-top-right-radius:inherit;border-top-right-radius:inherit}.ui-controlgroup-vertical .ui-btn.ui-last-child{-webkit-border-bottom-left-radius:inherit;border-bottom-left-radius:inherit;-webkit-border-bottom-right-radius:inherit;border-bottom-right-radius:inherit}.ui-controlgroup-horizontal .ui-btn.ui-first-child{-webkit-border-top-left-radius:inherit;border-top-left-radius:inherit;-webkit-border-bottom-left-radius:inherit;border-bottom-left-radius:inherit}.ui-controlgroup-horizontal .ui-btn.ui-last-child{-webkit-border-top-right-radius:inherit;border-top-right-radius:inherit;-webkit-border-bottom-right-radius:inherit;border-bottom-right-radius:inherit}.ui-controlgroup-controls a.ui-shadow:not(:focus),.ui-controlgroup-controls button.ui-shadow:not(:focus),.ui-controlgroup-controls div.ui-shadow:not(.ui-focus){-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none}.ui-controlgroup-label legend{max-width:100%}.ui-controlgroup-controls>label{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-dialog{background:none!important}.ui-dialog-contain{width:92.5%;max-width:500px;margin:10% auto 1em;padding:0;position:relative;top:-1em}.ui-dialog-contain>.ui-header,.ui-dialog-contain>.ui-content,.ui-dialog-contain>.ui-footer{display:block;position:relative;width:auto;margin:0}.ui-dialog-contain>.ui-header{overflow:hidden;z-index:10;padding:0;border-top-width:0}.ui-dialog-contain>.ui-footer{z-index:10;padding:0 1em;border-bottom-width:0}.ui-popup-open .ui-header-fixed,.ui-popup-open .ui-footer-fixed{position:absolute!important}.ui-popup-screen{background-image:url("data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==");top:0;left:0;right:0;bottom:1px;position:absolute;filter:Alpha(Opacity=0);opacity:0;z-index:1099}.ui-popup-screen.in{opacity:.5;filter:Alpha(Opacity=50)}.ui-popup-screen.out{opacity:0;filter:Alpha(Opacity=0)}.ui-popup-container{z-index:1100;display:inline-block;position:absolute;padding:0;outline:0}.ui-popup{position:relative}.ui-popup.ui-body-inherit{border-width:1px;border-style:solid}.ui-popup-hidden{left:0;top:0;position:absolute!important;visibility:hidden}.ui-popup-truncate{height:1px;width:1px;margin:-1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-popup.ui-content,.ui-popup .ui-content{overflow:visible}.ui-popup>.ui-header{border-top-width:0}.ui-popup>.ui-footer{border-bottom-width:0}.ui-popup>p,.ui-popup>h1,.ui-popup>h2,.ui-popup>h3,.ui-popup>h4,.ui-popup>h5,.ui-popup>h6{margin:.5em .4375em}.ui-popup>span{display:block;margin:.5em .4375em}.ui-popup-container .ui-content>p,.ui-popup-container .ui-content>h1,.ui-popup-container .ui-content>h2,.ui-popup-container .ui-content>h3,.ui-popup-container .ui-content>h4,.ui-popup-container .ui-content>h5,.ui-popup-container .ui-content>h6{margin:.5em 0}.ui-popup-container .ui-content>span{margin:0}.ui-popup-container .ui-content>p:first-child,.ui-popup-container .ui-content>h1:first-child,.ui-popup-container .ui-content>h2:first-child,.ui-popup-container .ui-content>h3:first-child,.ui-popup-container .ui-content>h4:first-child,.ui-popup-container .ui-content>h5:first-child,.ui-popup-container .ui-content>h6:first-child{margin-top:0}.ui-popup-container .ui-content>p:last-child,.ui-popup-container .ui-content>h1:last-child,.ui-popup-container .ui-content>h2:last-child,.ui-popup-container .ui-content>h3:last-child,.ui-popup-container .ui-content>h4:last-child,.ui-popup-container .ui-content>h5:last-child,.ui-popup-container .ui-content>h6:last-child{margin-bottom:0}.ui-popup>img{max-width:100%;max-height:100%;vertical-align:middle}.ui-popup:not(.ui-content)>img:only-child,.ui-popup:not(.ui-content)>.ui-btn-left:first-child+img:last-child,.ui-popup:not(.ui-content)>.ui-btn-right:first-child+img:last-child{-webkit-border-radius:inherit;border-radius:inherit}.ui-popup iframe{vertical-align:middle}.ui-popup>.ui-btn-left,.ui-popup>.ui-btn-right{position:absolute;top:-11px;margin:0;z-index:1101}.ui-popup>.ui-btn-left{left:-11px}.ui-popup>.ui-btn-right{right:-11px}.ui-popup-arrow-container{width:20px;height:20px}.ui-popup-arrow-container.ui-popup-arrow-l{left:-10px;clip:rect(-1000px,10px,2000px,-1000px)}.ui-popup-arrow-container.ui-popup-arrow-t{top:-10px;clip:rect(-1000px,2000px,10px,-1000px)}.ui-popup-arrow-container.ui-popup-arrow-r{right:-10px;clip:rect(-1000px,2000px,2000px,10px)}.ui-popup-arrow-container.ui-popup-arrow-b{bottom:-10px;clip:rect(10px,2000px,1000px,-1000px)}.ui-popup-arrow-container .ui-popup-arrow{width:28.284271247px;height:28.284271247px;border-width:1px;border-style:solid}.ui-popup-arrow-container.ui-popup-arrow-t .ui-popup-arrow{left:-4.142135623px;top:5.857864376px}.ui-popup-arrow-container.ui-popup-arrow-b .ui-popup-arrow{left:-4.142135623px;top:-14.142135623px}.ui-popup-arrow-container.ui-popup-arrow-l .ui-popup-arrow{left:5.857864376px;top:-4.142135623px}.ui-popup-arrow-container.ui-popup-arrow-r .ui-popup-arrow{left:-14.142135623px;top:-4.142135623px}.ui-popup-arrow-container.ui-popup-arrow-t.ie .ui-popup-arrow{margin-left:-5.857864376269049px;margin-top:-7.0710678118654755px}.ui-popup-arrow-container.ui-popup-arrow-b.ie .ui-popup-arrow{margin-left:-5.857864376269049px;margin-top:-4.142135623730951px}.ui-popup-arrow-container.ui-popup-arrow-l.ie .ui-popup-arrow{margin-left:-7.0710678118654755px;margin-top:-5.857864376269049px}.ui-popup-arrow-container.ui-popup-arrow-r.ie .ui-popup-arrow{margin-left:-4.142135623730951px;margin-top:-5.857864376269049px}.ui-popup>.ui-popup-arrow-guide{position:absolute;left:0;right:0;top:0;bottom:0;visibility:hidden}.ui-popup-arrow-container{position:absolute}.ui-popup-arrow{-webkit-transform:rotate(45deg);-moz-transform:rotate(45deg);-ms-transform:rotate(45deg);transform:rotate(45deg);position:absolute;overflow:hidden;box-sizing:border-box}.ui-popup-arrow-container.ie .ui-popup-arrow{-ms-filter:"progid:DXImageTransform.Microsoft.Matrix(M11=0.7071067811865474, M12=-0.7071067811865477, M21=0.7071067811865477, M22=0.7071067811865474, SizingMethod='auto expand')";filter:progid:DXImageTransform.Microsoft.Matrix(M11=.7071067811865474, M12=-.7071067811865477, M21=.7071067811865477, M22=.7071067811865474, SizingMethod='auto expand')}.ui-checkbox,.ui-radio{margin:.5em 0;position:relative}.ui-checkbox .ui-btn,.ui-radio .ui-btn{margin:0;text-align:left;white-space:normal;z-index:2}.ui-controlgroup .ui-checkbox .ui-btn.ui-focus,.ui-controlgroup .ui-radio .ui-btn.ui-focus{z-index:3}.ui-checkbox .ui-btn-icon-top,.ui-radio .ui-btn-icon-top,.ui-checkbox .ui-btn-icon-bottom,.ui-radio .ui-btn-icon-bottom{text-align:center}.ui-controlgroup-horizontal .ui-checkbox .ui-btn:after,.ui-controlgroup-horizontal .ui-radio .ui-btn:after{content:none;display:none}.ui-checkbox input,.ui-radio input{position:absolute;left:.466em;top:50%;width:22px;height:22px;margin:-11px 0 0 0;outline:0!important;z-index:1}.ui-controlgroup-horizontal .ui-checkbox input,.ui-controlgroup-horizontal .ui-radio input{left:50%;margin-left:-9px}.ui-checkbox input:disabled,.ui-radio input:disabled{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-select{margin-top:.5em;margin-bottom:.5em;position:relative}.ui-select>select{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-select .ui-btn{margin:0;opacity:1}.ui-select .ui-btn select{position:absolute;top:0;left:0;width:100%;min-height:1.5em;min-height:100%;height:3em;max-height:100%;outline:0;-webkit-border-radius:inherit;border-radius:inherit;-webkit-appearance:none;-moz-appearance:none;cursor:pointer;filter:Alpha(Opacity=0);opacity:0;z-index:2}@-moz-document url-prefix(){.ui-select .ui-btn select{opacity:.0001}}.ui-select .ui-state-disabled select{display:none}.ui-select span.ui-state-disabled{filter:Alpha(Opacity=100);opacity:1}.ui-select .ui-btn.ui-select-nativeonly{border-radius:0;border:0}.ui-select .ui-btn.ui-select-nativeonly select{opacity:1;text-indent:0;display:block}.ui-select .ui-li-has-count.ui-btn{padding-right:2.8125em}.ui-select .ui-li-has-count.ui-btn-icon-right{padding-right:4.6875em}.ui-select .ui-btn-icon-right .ui-li-count{right:3.2em}.ui-select .ui-btn>span:not(.ui-li-count){display:block;text-overflow:ellipsis;overflow:hidden!important;white-space:nowrap}.ui-selectmenu.ui-popup{min-width:11em}.ui-selectmenu .ui-dialog-contain{overflow:hidden}.ui-selectmenu .ui-header{margin:0;padding:0;border-width:0}.ui-selectmenu.ui-dialog .ui-header{z-index:1;position:relative}.ui-selectmenu.ui-popup .ui-header{-webkit-border-bottom-right-radius:0;border-bottom-right-radius:0;-webkit-border-bottom-left-radius:0;border-bottom-left-radius:0}.ui-selectmenu.ui-popup .ui-header h1:after{content:'.';visibility:hidden}.ui-selectmenu .ui-header .ui-title{margin:0 2.875em}.ui-selectmenu.ui-dialog .ui-content{overflow:visible;z-index:1}.ui-selectmenu .ui-selectmenu-list{margin:0;-webkit-border-radius:inherit;border-radius:inherit}.ui-header:not(.ui-screen-hidden)+.ui-selectmenu-list{-webkit-border-top-right-radius:0;border-top-right-radius:0;-webkit-border-top-left-radius:0;border-top-left-radius:0}.ui-header.ui-screen-hidden+.ui-selectmenu-list li.ui-first-child .ui-btn{border-top-width:0}.ui-selectmenu .ui-selectmenu-list li.ui-last-child .ui-btn{border-bottom-width:0}.ui-selectmenu .ui-btn.ui-li-divider{cursor:default}.ui-selectmenu .ui-selectmenu-placeholder{display:none}.ui-listview,.ui-listview>li{margin:0;padding:0;list-style:none}.ui-content .ui-listview,.ui-panel-inner>.ui-listview{margin:-1em}.ui-content .ui-listview-inset,.ui-panel-inner>.ui-listview-inset{margin:1em 0}.ui-collapsible-content>.ui-listview{margin:-.5em -1em}.ui-collapsible-content>.ui-listview-inset{margin:.5em 0}.ui-listview>li{display:block;position:relative;overflow:visible}.ui-listview>.ui-li-static,.ui-listview>.ui-li-divider,.ui-listview>li>a.ui-btn{margin:0;display:block;position:relative;text-align:left;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.ui-listview>li>.ui-btn:focus{z-index:1}.ui-listview>.ui-li-static,.ui-listview>.ui-li-divider,.ui-listview>li>a.ui-btn{border-width:1px 0 0;border-style:solid}.ui-listview-inset>.ui-li-static,.ui-listview-inset>.ui-li-divider,.ui-listview-inset>li>a.ui-btn{border-right-width:1px;border-left-width:1px}.ui-listview>.ui-li-static.ui-last-child,.ui-listview>.ui-li-divider.ui-last-child,.ui-listview>li.ui-last-child>a.ui-btn{border-bottom-width:1px}.ui-collapsible-content>.ui-listview:not(.ui-listview-inset)>li.ui-first-child,.ui-collapsible-content>.ui-listview:not(.ui-listview-inset)>li.ui-first-child>a.ui-btn{border-top-width:0}.ui-collapsible-themed-content .ui-listview:not(.ui-listview-inset)>li.ui-last-child,.ui-collapsible-themed-content .ui-listview:not(.ui-listview-inset)>li.ui-last-child>a.ui-btn{border-bottom-width:0}.ui-listview>li.ui-first-child,.ui-listview>li.ui-first-child>a.ui-btn{-webkit-border-top-right-radius:inherit;border-top-right-radius:inherit;-webkit-border-top-left-radius:inherit;border-top-left-radius:inherit}.ui-listview>li.ui-last-child,.ui-listview>li.ui-last-child>a.ui-btn{-webkit-border-bottom-right-radius:inherit;border-bottom-right-radius:inherit;-webkit-border-bottom-left-radius:inherit;border-bottom-left-radius:inherit}.ui-listview>li.ui-li-has-alt>a.ui-btn{-webkit-border-top-right-radius:0;border-top-right-radius:0;-webkit-border-bottom-right-radius:0;border-bottom-right-radius:0}.ui-listview>li.ui-first-child>a.ui-btn+a.ui-btn{-webkit-border-top-left-radius:0;border-top-left-radius:0;-webkit-border-top-right-radius:inherit;border-top-right-radius:inherit}.ui-listview>li.ui-last-child>a.ui-btn+a.ui-btn{-webkit-border-bottom-left-radius:0;border-bottom-left-radius:0;-webkit-border-bottom-right-radius:inherit;border-bottom-right-radius:inherit}.ui-listview>li.ui-first-child img:first-child:not(.ui-li-icon){-webkit-border-top-left-radius:inherit;border-top-left-radius:inherit}.ui-listview>li.ui-last-child img:first-child:not(.ui-li-icon){-webkit-border-bottom-left-radius:inherit;border-bottom-left-radius:inherit}.ui-collapsible-content>.ui-listview:not(.ui-listview-inset){-webkit-border-radius:inherit;border-radius:inherit}.ui-listview>.ui-li-static{padding:.7em 1em}.ui-listview>.ui-li-divider{padding:.5em 1.143em;font-size:14px;font-weight:700;cursor:default;outline:0}.ui-listview>.ui-li-has-count>.ui-btn,.ui-listview>.ui-li-static.ui-li-has-count,.ui-listview>.ui-li-divider.ui-li-has-count{padding-right:2.8125em}.ui-listview>.ui-li-has-count>.ui-btn-icon-right{padding-right:4.6875em}.ui-listview>.ui-li-has-thumb>.ui-btn,.ui-listview>.ui-li-static.ui-li-has-thumb{min-height:3.625em;padding-left:6.25em}.ui-listview>.ui-li-has-icon>.ui-btn,.ui-listview>.ui-li-static.ui-li-has-icon{min-height:1.25em;padding-left:2.5em}.ui-li-count{position:absolute;font-size:12.5px;font-weight:700;text-align:center;border-width:1px;border-style:solid;padding:0 .48em;line-height:1.6em;min-height:1.6em;min-width:.64em;right:.8em;top:50%;margin-top:-.88em}.ui-listview .ui-btn-icon-right .ui-li-count{right:3.2em}.ui-listview .ui-li-has-thumb>img:first-child,.ui-listview .ui-li-has-thumb>.ui-btn>img:first-child,.ui-listview .ui-li-has-thumb .ui-li-thumb{position:absolute;left:0;top:0;max-height:5em;max-width:5em}.ui-listview>.ui-li-has-icon>img:first-child,.ui-listview>.ui-li-has-icon>.ui-btn>img:first-child{position:absolute;left:.625em;top:.9em;max-height:1em;max-width:1em}.ui-listview>li h1,.ui-listview>li h2,.ui-listview>li h3,.ui-listview>li h4,.ui-listview>li h5,.ui-listview>li h6{font-size:1em;font-weight:700;display:block;margin:.45em 0;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.ui-listview>li p{font-size:.75em;font-weight:400;display:block;margin:.6em 0;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.ui-listview .ui-li-aside{position:absolute;top:1em;right:3.333em;margin:0;text-align:right}.ui-listview>li.ui-li-has-alt>.ui-btn{margin-right:2.5em;border-right-width:0}.ui-listview>li.ui-li-has-alt>.ui-btn+.ui-btn{position:absolute;width:2.5em;height:100%;min-height:auto;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;border-left-width:1px;top:0;right:0;margin:0;padding:0;z-index:2}.ui-listview-inset>li.ui-li-has-alt>.ui-btn+.ui-btn{border-right-width:1px}.ui-listview>li.ui-li-has-alt>.ui-btn+.ui-btn:focus{z-index:3}ol.ui-listview,ol.ui-listview>.ui-li-divider{counter-reset:listnumbering}ol.ui-listview>li>.ui-btn,ol.ui-listview>li.ui-li-static{vertical-align:middle}ol.ui-listview>li>.ui-btn:first-child:before,ol.ui-listview>li.ui-li-static:before,ol.ui-listview>li.ui-field-contain>label:before,ol.ui-listview>li.ui-field-contain>.ui-controlgroup-label:before{display:inline-block;font-size:.9em;font-weight:400;padding-right:.3em;min-width:1.4em;line-height:1.5;vertical-align:middle;counter-increment:listnumbering;content:counter(listnumbering) "."}ol.ui-listview>li.ui-field-contain:before{content:none;display:none}ol.ui-listview>li h1:first-child,ol.ui-listview>li h2:first-child,ol.ui-listview>li h3:first-child,ol.ui-listview>li h4:first-child,ol.ui-listview>li h5:first-child,ol.ui-listview>li h6:first-child,ol.ui-listview>li p:first-child,ol.ui-listview>li img:first-child+*{display:inline-block;vertical-align:middle}ol.ui-listview>li h1:first-child~*,ol.ui-listview>li h2:first-child~*,ol.ui-listview>li h3:first-child~*,ol.ui-listview>li h4:first-child~*,ol.ui-listview>li h5:first-child~*,ol.ui-listview>li h6:first-child~*,ol.ui-listview>li p:first-child~*,ol.ui-listview>li img:first-child+*~*{margin-top:0;text-indent:2.04em}html .ui-filterable+.ui-listview,html .ui-filterable.ui-listview{margin-top:.5em}.ui-collapsible-content>form.ui-filterable{margin-top:-.5em}.ui-collapsible-content>.ui-input-search.ui-filterable{margin-top:0}.ui-collapsible-content>.ui-filterable+.ui-listview:not(.ui-listview-inset)>li.ui-first-child,.ui-collapsible-content>.ui-filterable+.ui-listview:not(.ui-listview-inset)>li.ui-first-child>a.ui-btn,.ui-collapsible-content>.ui-filterable.ui-listview:not(.ui-listview-inset)>li.ui-first-child,.ui-collapsible-content>.ui-filterable.ui-listview:not(.ui-listview-inset)>li.ui-first-child>a.ui-btn{border-top-width:1px}div.ui-slider{height:30px;margin:.5em 0;padding:0;-ms-touch-action:pan-y pinch-zoom double-tap-zoom}div.ui-slider:before,div.ui-slider:after{content:"";display:table}div.ui-slider:after{clear:both}input.ui-slider-input{display:block;float:left;font-size:14px;font-weight:700;margin:0;padding:4px;width:40px;height:20px;line-height:20px;border-width:1px;border-style:solid;outline:0;text-align:center;vertical-align:text-bottom;-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.ui-slider-input::-webkit-outer-spin-button,.ui-slider-input::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}.ui-slider-track{position:relative;overflow:visible;border-width:1px;border-style:solid;height:15px;margin:0 15px 0 68px;top:6px}.ui-slider-track.ui-mini{height:12px;top:8px}.ui-slider-track .ui-slider-bg{height:100%}.ui-slider-track .ui-btn.ui-slider-handle{position:absolute;z-index:1;top:50%;width:28px;height:28px;margin:-15px 0 0 -15px;outline:0;padding:0}.ui-slider-track.ui-mini .ui-slider-handle{height:14px;width:14px;margin:-8px 0 0 -8px}select.ui-slider-switch{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}div.ui-slider-switch{display:inline-block;height:32px;width:5.8em;top:0}div.ui-slider-switch:before,div.ui-slider-switch:after{display:none;clear:none}div.ui-slider-switch.ui-mini{height:29px;top:0}.ui-slider-inneroffset{margin:0 16px;position:relative;z-index:1}.ui-slider-switch.ui-mini .ui-slider-inneroffset{margin:0 15px 0 14px}.ui-slider-switch .ui-btn.ui-slider-handle{margin:1px 0 0 -15px}.ui-slider-switch.ui-mini .ui-slider-handle{width:25px;height:25px;margin:1px 0 0 -13px;padding:0}.ui-slider-handle-snapping{-webkit-transition:left 70ms linear;-moz-transition:left 70ms linear;transition:left 70ms linear}.ui-slider-switch .ui-slider-label{position:absolute;text-align:center;width:100%;overflow:hidden;font-size:16px;top:0;line-height:2;min-height:100%;white-space:nowrap;cursor:pointer}.ui-slider-switch.ui-mini .ui-slider-label{font-size:14px}.ui-slider-switch .ui-slider-label-a{z-index:1;left:0;text-indent:-1.5em}.ui-slider-switch .ui-slider-label-b{z-index:0;right:0;text-indent:1.5em}.ui-slider-track .ui-slider-bg,.ui-slider-switch .ui-slider-label,.ui-slider-switch .ui-slider-inneroffset,.ui-slider-handle{-webkit-border-radius:inherit;border-radius:inherit}.ui-field-contain div.ui-slider-switch{margin:0}.ui-field-contain div.ui-slider-switch,.ui-field-contain.ui-hide-label div.ui-slider-switch,html .ui-popup .ui-field-contain div.ui-slider-switch{display:inline-block;width:5.8em}.ui-slider-popup{width:64px;height:64px;font-size:36px;padding-top:14px;opacity:.8}.ui-slider-popup{position:absolute!important;text-align:center;z-index:100}.ui-slider-track .ui-btn.ui-slider-handle{font-size:.9em;line-height:30px}.ui-rangeslider{margin:.5em 0}.ui-rangeslider:before,.ui-rangeslider:after{content:"";display:table}.ui-rangeslider:after{clear:both}.ui-rangeslider .ui-slider-input.ui-rangeslider-last{float:right}.ui-rangeslider .ui-rangeslider-sliders{position:relative;overflow:visible;height:30px;margin:0 68px}.ui-rangeslider .ui-rangeslider-sliders .ui-slider-track{position:absolute;top:6px;right:0;left:0;margin:0}.ui-rangeslider.ui-mini .ui-rangeslider-sliders .ui-slider-track{top:8px}.ui-rangeslider .ui-slider-track:first-child .ui-slider-bg{display:none}.ui-rangeslider .ui-rangeslider-sliders .ui-slider-track:first-child{background-color:transparent;background:0;border-width:0;height:0}html >body .ui-rangeslider .ui-rangeslider-sliders .ui-slider-track:first-child{height:15px;border-width:1px}html >body .ui-rangeslider.ui-mini .ui-rangeslider-sliders .ui-slider-track:first-child{height:12px}div.ui-rangeslider label{position:absolute!important;height:1px;width:1px;overflow:hidden;clip:rect(1px,1px,1px,1px)}.ui-field-contain .ui-rangeslider input.ui-slider-input,.ui-field-contain .ui-rangeslider.ui-mini input.ui-slider-input,.ui-field-contain .ui-rangeslider .ui-rangeslider-sliders,.ui-field-contain .ui-rangeslider.ui-mini .ui-rangeslider-sliders{margin-top:0;margin-bottom:0}.ui-input-text,.ui-input-search{margin:.5em 0;border-width:1px;border-style:solid}.ui-input-text input,.ui-input-search input,textarea.ui-input-text{padding:.4em;line-height:1.4em;display:block;width:100%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;outline:0}.ui-input-text input,.ui-input-search input{margin:0;min-height:2.2em;text-align:left;border:0;background:transparent none;-webkit-appearance:none;-webkit-border-radius:inherit;border-radius:inherit}textarea.ui-input-text{overflow:auto;resize:vertical}.ui-mini .ui-input-text input,.ui-mini .ui-input-search input,.ui-input-text.ui-mini input,.ui-input-search.ui-mini input,.ui-mini textarea.ui-input-text,textarea.ui-mini{font-size:14px}.ui-mini textarea.ui-input-text,textarea.ui-mini{margin:.446em 0}.ui-input-has-clear,.ui-input-search{position:relative}.ui-input-has-clear{padding-right:2.375em}.ui-mini.ui-input-has-clear{padding-right:2.923em}.ui-input-has-clear input{padding-right:0;-webkit-border-top-right-radius:0;border-top-right-radius:0;-webkit-border-bottom-right-radius:0;border-bottom-right-radius:0}.ui-input-search input{padding-left:1.75em}.ui-input-search:after{position:absolute;left:.3125em;top:50%;margin-top:-7px;content:"";background-position:center center;background-repeat:no-repeat;width:14px;height:14px;filter:Alpha(Opacity=50);opacity:.5}.ui-input-search.ui-input-has-clear .ui-btn.ui-input-clear,.ui-input-text.ui-input-has-clear .ui-btn.ui-input-clear{position:absolute;right:0;top:50%;margin:-14px .3125em 0;border:0;background-color:transparent}.ui-input-search .ui-input-clear-hidden,.ui-input-text .ui-input-clear-hidden{display:none}.ui-input-text input::-moz-placeholder,.ui-input-search input::-moz-placeholder,textarea.ui-input-text::-moz-placeholder{color:#aaa}.ui-input-text input:-ms-input-placeholder,.ui-input-search input:-ms-input-placeholder,textarea.ui-input-text:-ms-input-placeholder{color:#aaa}.ui-input-text input[type=number]::-webkit-outer-spin-button{margin:0}.ui-input-text input::-ms-clear,.ui-input-search input::-ms-clear{display:none}.ui-input-text input:focus,.ui-input-search input:focus{-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none}textarea.ui-input-text.ui-textinput-autogrow{overflow:hidden}.ui-textinput-autogrow-resize{-webkit-transition:height .25s;-o-transition:height .25s;-moz-transition:height .25s;transition:height .25s}.ui-flipswitch{display:inline-block;vertical-align:middle;width:5.875em;height:1.875em;border-width:1px;border-style:solid;margin:.5em 0;overflow:hidden;-webkit-transition-property:padding,width,background-color,color,border-color;-moz-transition-property:padding,width,background-color,color,border-color;-o-transition-property:padding,width,background-color,color,border-color;transition-property:padding,width,background-color,color,border-color;-webkit-transition-duration:100ms;-moz-transition-duration:100ms;-o-transition-duration:100ms;transition-duration:100ms;-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer}.ui-flipswitch.ui-flipswitch-active{padding-left:4em;width:1.875em}.ui-flipswitch-input{position:absolute;height:1px;width:1px;margin:-1px;overflow:hidden;clip:rect(1px,1px,1px,1px);border:0;outline:0;filter:Alpha(Opacity=0);opacity:0}.ui-flipswitch .ui-btn.ui-flipswitch-on,.ui-flipswitch .ui-flipswitch-off{float:left;height:1.75em;margin:.0625em;line-height:1.65em}.ui-flipswitch .ui-btn.ui-flipswitch-on{width:1.75em;padding:0;text-indent:-2.6em;text-align:left;border-width:1px;border-style:solid;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;border-radius:inherit;overflow:visible;color:inherit;text-shadow:inherit}.ui-flipswitch .ui-flipswitch-off{padding:1px;text-indent:1em}html .ui-field-contain>label+.ui-flipswitch,html .ui-popup .ui-field-contain>label+.ui-flipswitch{display:inline-block;width:5.875em;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.ui-field-contain .ui-flipswitch.ui-flipswitch-active,.ui-popup .ui-field-contain .ui-flipswitch.ui-flipswitch-active{width:1.875em}.ui-table{border:0;border-collapse:collapse;padding:0;width:100%}.ui-table th,.ui-table td{line-height:1.5em;text-align:left;padding:.4em .5em;vertical-align:top}.ui-table th .ui-btn,.ui-table td .ui-btn{line-height:normal}.ui-table th{font-weight:700}.ui-table caption{text-align:left;margin-bottom:1.4em;opacity:.5}.ui-table-columntoggle-btn{float:right;margin-bottom:.8em}.ui-table-columntoggle-popup fieldset{margin:0}.ui-table-columntoggle{clear:both}@media only all{th.ui-table-priority-6,td.ui-table-priority-6,th.ui-table-priority-5,td.ui-table-priority-5,th.ui-table-priority-4,td.ui-table-priority-4,th.ui-table-priority-3,td.ui-table-priority-3,th.ui-table-priority-2,td.ui-table-priority-2,th.ui-table-priority-1,td.ui-table-priority-1{display:none}}@media screen and (min-width:20em){.ui-table-columntoggle.ui-responsive th.ui-table-priority-1,.ui-table-columntoggle.ui-responsive td.ui-table-priority-1{display:table-cell}}@media screen and (min-width:30em){.ui-table-columntoggle.ui-responsive th.ui-table-priority-2,.ui-table-columntoggle.ui-responsive td.ui-table-priority-2{display:table-cell}}@media screen and (min-width:40em){.ui-table-columntoggle.ui-responsive th.ui-table-priority-3,.ui-table-columntoggle.ui-responsive td.ui-table-priority-3{display:table-cell}}@media screen and (min-width:50em){.ui-table-columntoggle.ui-responsive th.ui-table-priority-4,.ui-table-columntoggle.ui-responsive td.ui-table-priority-4{display:table-cell}}@media screen and (min-width:60em){.ui-table-columntoggle.ui-responsive th.ui-table-priority-5,.ui-table-columntoggle.ui-responsive td.ui-table-priority-5{display:table-cell}}@media screen and (min-width:70em){.ui-table-columntoggle.ui-responsive th.ui-table-priority-6,.ui-table-columntoggle.ui-responsive td.ui-table-priority-6{display:table-cell}}.ui-table-columntoggle th.ui-table-cell-hidden,.ui-table-columntoggle td.ui-table-cell-hidden,.ui-table-columntoggle.ui-responsive th.ui-table-cell-hidden,.ui-table-columntoggle.ui-responsive td.ui-table-cell-hidden{display:none}.ui-table-columntoggle th.ui-table-cell-visible,.ui-table-columntoggle td.ui-table-cell-visible,.ui-table-columntoggle.ui-responsive th.ui-table-cell-visible,.ui-table-columntoggle.ui-responsive td.ui-table-cell-visible{display:table-cell}.ui-table-reflow td .ui-table-cell-label,.ui-table-reflow th .ui-table-cell-label{display:none}@media only all{.ui-table-reflow thead td,.ui-table-reflow thead th{display:none}.ui-table-reflow td,.ui-table-reflow th{text-align:left;display:block}.ui-table-reflow tbody th{margin-top:3em}.ui-table-reflow td .ui-table-cell-label,.ui-table-reflow th .ui-table-cell-label{padding:.4em;min-width:30%;display:inline-block;margin:-.4em 1em -.4em -.4em}.ui-table-reflow th .ui-table-cell-label-top,.ui-table-reflow td .ui-table-cell-label-top{display:block;padding:.4em 0;margin:.4em 0;text-transform:uppercase;font-size:.9em;font-weight:400}}@media (min-width:35em){.ui-table-reflow.ui-responsive td,.ui-table-reflow.ui-responsive th,.ui-table-reflow.ui-responsive tbody th,.ui-table-reflow.ui-responsive tbody td,.ui-table-reflow.ui-responsive thead td,.ui-table-reflow.ui-responsive thead th{display:table-cell;margin:0}.ui-table-reflow.ui-responsive td .ui-table-cell-label,.ui-table-reflow.ui-responsive th .ui-table-cell-label{display:none}}@media (max-width:35em){.ui-table-reflow.ui-responsive td,.ui-table-reflow.ui-responsive th{width:100%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;float:left;clear:left}}.ui-panel{width:17em;min-height:100%;max-height:none;border-width:0;position:absolute;top:0;display:block}.ui-panel-closed{width:0;max-height:100%;overflow:hidden;visibility:hidden}.ui-panel-fixed{position:fixed;bottom:-1px;padding-bottom:1px}.ui-panel-display-reveal{z-index:1}.ui-panel-display-push{z-index:999}.ui-panel-display-overlay{z-index:1001}.ui-panel-inner{padding:1em}.ui-panel-page-container{overflow-x:visible}.ui-panel-page-container-themed .ui-page-active{background:0}.ui-panel-wrapper{position:relative;min-height:inherit;border:0;overflow-x:hidden;z-index:999}.ui-panel-fixed-toolbar{overflow-x:hidden}.ui-panel-dismiss{position:absolute;top:0;left:0;right:0;height:100%;z-index:1002;display:none}.ui-panel-dismiss-open{display:block}.ui-panel-animate{-webkit-transition:-webkit-transform 300ms ease;-webkit-transition-duration:300ms;-moz-transition:-moz-transform 300ms ease;transition:transform 300ms ease}@media screen and (max-device-width:768px){.ui-page-header-fixed .ui-panel-animate.ui-panel-wrapper,.ui-page-footer-fixed .ui-panel-animate.ui-panel-wrapper,.ui-panel-animate.ui-panel-fixed-toolbar{-ms-transition:none}.ui-panel-animate.ui-panel-fixed-toolbar{-ms-transition:-ms-transform 1ms;-ms-transform:rotate(0deg)}}.ui-panel-animate.ui-panel:not(.ui-panel-display-reveal){-webkit-backface-visibility:hidden;-webkit-transform:translate3d(0,0,0)}.ui-panel-position-left{left:-17em}.ui-panel-animate.ui-panel-position-left.ui-panel-display-overlay,.ui-panel-animate.ui-panel-position-left.ui-panel-display-push{left:0;-webkit-transform:translate3d(-17em,0,0);-moz-transform:translate3d(-17em,0,0);transform:translate3d(-17em,0,0)}.ui-panel-position-left.ui-panel-display-reveal,.ui-panel-open.ui-panel-position-left{left:0}.ui-panel-animate.ui-panel-open.ui-panel-position-left.ui-panel-display-overlay,.ui-panel-animate.ui-panel-open.ui-panel-position-left.ui-panel-display-push{-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0);-moz-transform:none}.ui-panel-position-right{right:-17em}.ui-panel-animate.ui-panel-position-right.ui-panel-display-overlay,.ui-panel-animate.ui-panel-position-right.ui-panel-display-push{right:0;-webkit-transform:translate3d(17em,0,0);-moz-transform:translate3d(17em,0,0);transform:translate3d(17em,0,0)}.ui-panel-position-right.ui-panel-display-reveal,.ui-panel-position-right.ui-panel-open{right:0}.ui-panel-animate.ui-panel-open.ui-panel-position-right.ui-panel-display-overlay,.ui-panel-animate.ui-panel-open.ui-panel-position-right.ui-panel-display-push{-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0);-moz-transform:none}.ui-panel-page-content-position-left{left:17em;right:-17em}.ui-panel-animate.ui-panel-page-content-position-left{left:0;right:0;-webkit-transform:translate3d(17em,0,0);-moz-transform:translate3d(17em,0,0);transform:translate3d(17em,0,0)}.ui-panel-page-content-position-right{left:-17em;right:17em}.ui-panel-animate.ui-panel-page-content-position-right{left:0;right:0;-webkit-transform:translate3d(-17em,0,0);-moz-transform:translate3d(-17em,0,0);transform:translate3d(-17em,0,0)}.ui-panel-dismiss-open.ui-panel-dismiss-position-left{left:17em}.ui-panel-dismiss-open.ui-panel-dismiss-position-right{right:17em}.ui-panel-display-reveal{-webkit-box-shadow:inset -5px 0 5px rgba(0,0,0,.15);-moz-box-shadow:inset -5px 0 5px rgba(0,0,0,.15);box-shadow:inset -5px 0 5px rgba(0,0,0,.15)}.ui-panel-position-right.ui-panel-display-reveal{-webkit-box-shadow:inset 5px 0 5px rgba(0,0,0,.15);-moz-box-shadow:inset 5px 0 5px rgba(0,0,0,.15);box-shadow:inset 5px 0 5px rgba(0,0,0,.15)}.ui-panel-display-overlay{-webkit-box-shadow:5px 0 5px rgba(0,0,0,.15);-moz-box-shadow:5px 0 5px rgba(0,0,0,.15);box-shadow:5px 0 5px rgba(0,0,0,.15)}.ui-panel-position-right.ui-panel-display-overlay{-webkit-box-shadow:-5px 0 5px rgba(0,0,0,.15);-moz-box-shadow:-5px 0 5px rgba(0,0,0,.15);box-shadow:-5px 0 5px rgba(0,0,0,.15)}.ui-panel-open.ui-panel-position-left.ui-panel-display-push{border-right-width:1px;margin-right:-1px}.ui-panel-page-content-position-left.ui-panel-page-content-display-push{margin-left:1px;width:auto}.ui-panel-open.ui-panel-position-right.ui-panel-display-push{border-left-width:1px;margin-left:-1px}.ui-panel-page-content-position-right.ui-panel-page-content-display-push{margin-right:1px;width:auto}@media (min-width:55em){.ui-responsive-panel .ui-panel-page-content-open.ui-panel-page-content-position-left{margin-right:17em}.ui-responsive-panel .ui-panel-page-content-open.ui-panel-page-content-position-right{margin-left:17em}.ui-responsive-panel .ui-panel-page-content-open{width:auto}.ui-responsive-panel .ui-panel-dismiss-display-push,.ui-responsive-panel.ui-page-active~.ui-panel-dismiss-display-push{display:none}}.ui-tabs{position:relative;padding:.2em} |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /*! | |
| * jQuery Mobile 1.4.3 | |
| * Git HEAD hash: b9c6473e3d90af26570e6f14e5a0307897ab385c <> Date: Tue Jul 1 2014 15:37:36 UTC | |
| * http://jquerymobile.com | |
| * | |
| * Copyright 2010, 2014 jQuery Foundation, Inc. and othercontributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| */ | |
| /* Globals */ | |
| /* Font | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| html { | |
| font-size: 100%; | |
| } | |
| body, | |
| input, | |
| select, | |
| textarea, | |
| button, | |
| .ui-btn { | |
| font-size: 1em; | |
| line-height: 1.3; | |
| font-family: sans-serif /*{global-font-family}*/; | |
| } | |
| legend, | |
| .ui-input-text input, | |
| .ui-input-search input { | |
| color: inherit; | |
| text-shadow: inherit; | |
| } | |
| /* Form labels (overrides font-weight bold in bars, and mini font-size) */ | |
| .ui-mobile label, | |
| div.ui-controlgroup-label { | |
| font-weight: normal; | |
| font-size: 16px; | |
| } | |
| /* Separators | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| /* Field contain separator (< 28em) */ | |
| .ui-field-contain { | |
| border-bottom-color: #828282; | |
| border-bottom-color: rgba(0,0,0,.15); | |
| border-bottom-width: 1px; | |
| border-bottom-style: solid; | |
| } | |
| /* Table opt-in classes: strokes between each row, and alternating row stripes */ | |
| /* Classes table-stroke and table-stripe are deprecated in 1.4. */ | |
| .table-stroke thead th, | |
| .table-stripe thead th, | |
| .table-stripe tbody tr:last-child { | |
| border-bottom: 1px solid #d6d6d6; /* non-RGBA fallback */ | |
| border-bottom: 1px solid rgba(0,0,0,.1); | |
| } | |
| .table-stroke tbody th, | |
| .table-stroke tbody td { | |
| border-bottom: 1px solid #e6e6e6; /* non-RGBA fallback */ | |
| border-bottom: 1px solid rgba(0,0,0,.05); | |
| } | |
| .table-stripe.table-stroke tbody tr:last-child th, | |
| .table-stripe.table-stroke tbody tr:last-child td { | |
| border-bottom: 0; | |
| } | |
| .table-stripe tbody tr:nth-child(odd) td, | |
| .table-stripe tbody tr:nth-child(odd) th { | |
| background-color: #eeeeee; /* non-RGBA fallback */ | |
| background-color: rgba(0,0,0,.04); | |
| } | |
| /* Buttons | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| .ui-btn, | |
| label.ui-btn { | |
| font-weight: bold; | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| .ui-btn { | |
| text-decoration: none !important; | |
| } | |
| .ui-btn-active { | |
| cursor: pointer; | |
| } | |
| /* Corner rounding | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| /* Class ui-btn-corner-all deprecated in 1.4 */ | |
| .ui-corner-all { | |
| -webkit-border-radius: 0.1em /*{global-radii-blocks}*/; | |
| border-radius: 0.1em /*{global-radii-blocks}*/; | |
| } | |
| /* Buttons */ | |
| .ui-btn-corner-all, | |
| .ui-btn.ui-corner-all, | |
| /* Slider track */ | |
| .ui-slider-track.ui-corner-all, | |
| /* Flipswitch */ | |
| .ui-flipswitch.ui-corner-all, | |
| /* Count bubble */ | |
| .ui-li-count { | |
| -webkit-border-radius: 0.1em /*{global-radii-buttons}*/; | |
| border-radius: 0.1em /*{global-radii-buttons}*/; | |
| } | |
| /* Icon-only buttons */ | |
| .ui-btn-icon-notext.ui-btn-corner-all, | |
| .ui-btn-icon-notext.ui-corner-all { | |
| -webkit-border-radius: 1em; | |
| border-radius: 1em; | |
| } | |
| /* Radius clip workaround for cleaning up corner trapping */ | |
| .ui-btn-corner-all, | |
| .ui-corner-all { | |
| -webkit-background-clip: padding; | |
| background-clip: padding-box; | |
| } | |
| /* Popup arrow */ | |
| .ui-popup.ui-corner-all > .ui-popup-arrow-guide { | |
| left: 0.1em /*{global-radii-blocks}*/; | |
| right: 0.1em /*{global-radii-blocks}*/; | |
| top: 0.1em /*{global-radii-blocks}*/; | |
| bottom: 0.1em /*{global-radii-blocks}*/; | |
| } | |
| /* Shadow | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| .ui-shadow { | |
| -webkit-box-shadow: 0 1px 3px /*{global-box-shadow-size}*/ rgba(0,0,0,0) /*{global-box-shadow-color}*/; | |
| -moz-box-shadow: 0 1px 3px /*{global-box-shadow-size}*/ rgba(0,0,0,0) /*{global-box-shadow-color}*/; | |
| box-shadow: 0 1px 3px /*{global-box-shadow-size}*/ rgba(0,0,0,0) /*{global-box-shadow-color}*/; | |
| } | |
| .ui-shadow-inset { | |
| -webkit-box-shadow: inset 0 1px 3px /*{global-box-shadow-size}*/ rgba(0,0,0,0) /*{global-box-shadow-color}*/; | |
| -moz-box-shadow: inset 0 1px 3px /*{global-box-shadow-size}*/ rgba(0,0,0,0) /*{global-box-shadow-color}*/; | |
| box-shadow: inset 0 1px 3px /*{global-box-shadow-size}*/ rgba(0,0,0,0) /*{global-box-shadow-color}*/; | |
| } | |
| .ui-overlay-shadow { | |
| -webkit-box-shadow: 0 0 12px rgba(0,0,0,.6); | |
| -moz-box-shadow: 0 0 12px rgba(0,0,0,.6); | |
| box-shadow: 0 0 12px rgba(0,0,0,.6); | |
| } | |
| /* Icons | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| .ui-btn-icon-left:after, | |
| .ui-btn-icon-right:after, | |
| .ui-btn-icon-top:after, | |
| .ui-btn-icon-bottom:after, | |
| .ui-btn-icon-notext:after { | |
| background-color: transparent /*{global-icon-color}*/; | |
| background-color: transparent /*{global-icon-disc}*/; | |
| background-position: center center; | |
| background-repeat: no-repeat; | |
| -webkit-border-radius: 1em; | |
| border-radius: 1em; | |
| } | |
| /* Alt icons */ | |
| .ui-alt-icon.ui-btn:after, | |
| .ui-alt-icon .ui-btn:after, | |
| html .ui-alt-icon.ui-checkbox-off:after, | |
| html .ui-alt-icon.ui-radio-off:after, | |
| html .ui-alt-icon .ui-checkbox-off:after, | |
| html .ui-alt-icon .ui-radio-off:after { | |
| background-color: transparent /*{global-icon-color}*/; | |
| background-color: transparent /*{global-icon-disc}*/; | |
| } | |
| /* No disc */ | |
| .ui-nodisc-icon.ui-btn:after, | |
| .ui-nodisc-icon .ui-btn:after { | |
| background-color: transparent; | |
| } | |
| /* Icon shadow */ | |
| .ui-shadow-icon.ui-btn:after, | |
| .ui-shadow-icon .ui-btn:after { | |
| -webkit-box-shadow: 0 1px 0 transparent /*{global-icon-shadow}*/; | |
| -moz-box-shadow: 0 1px 0 transparent /*{global-icon-shadow}*/; | |
| box-shadow: 0 1px 0 transparent /*{global-icon-shadow}*/; | |
| } | |
| /* Checkbox and radio */ | |
| .ui-btn.ui-checkbox-off:after, | |
| .ui-btn.ui-checkbox-on:after, | |
| .ui-btn.ui-radio-off:after, | |
| .ui-btn.ui-radio-on:after { | |
| display: block; | |
| width: 18px; | |
| height: 18px; | |
| margin: -9px 2px 0 2px; | |
| } | |
| .ui-checkbox-off:after, | |
| .ui-btn.ui-radio-off:after { | |
| filter: Alpha(Opacity=30); | |
| opacity: .3; | |
| } | |
| .ui-btn.ui-checkbox-off:after, | |
| .ui-btn.ui-checkbox-on:after { | |
| -webkit-border-radius: .1875em; | |
| border-radius: .1875em; | |
| } | |
| .ui-btn.ui-checkbox-off:after { | |
| background-color: #666; | |
| background-color: rgba(0,0,0,.3); | |
| } | |
| .ui-radio .ui-btn.ui-radio-on:after { | |
| background-image: none; | |
| background-color: #fff; | |
| width: 8px; | |
| height: 8px; | |
| border-width: 5px; | |
| border-style: solid; | |
| } | |
| .ui-alt-icon.ui-btn.ui-radio-on:after, | |
| .ui-alt-icon .ui-btn.ui-radio-on:after { | |
| background-color: #000; | |
| } | |
| /* Loader */ | |
| .ui-icon-loading { | |
| background: url("images/ajax-loader.gif"); | |
| background-size: 2.875em 2.875em; | |
| } | |
| /* Swatches */ | |
| /* A | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| /* Bar: Toolbars, dividers, slider track */ | |
| .ui-bar-a, | |
| .ui-page-theme-a .ui-bar-inherit, | |
| html .ui-bar-a .ui-bar-inherit, | |
| html .ui-body-a .ui-bar-inherit, | |
| html body .ui-group-theme-a .ui-bar-inherit { | |
| background-color: #e9e9e9 /*{a-bar-background-color}*/; | |
| border-color: #dddddd /*{a-bar-border}*/; | |
| color: #333333 /*{a-bar-color}*/; | |
| text-shadow: 0 /*{a-bar-shadow-x}*/ 0 /*{a-bar-shadow-y}*/ 0 /*{a-bar-shadow-radius}*/ #eeeeee /*{a-bar-shadow-color}*/; | |
| font-weight: bold; | |
| } | |
| .ui-bar-a { | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| /* Page and overlay */ | |
| .ui-overlay-a, | |
| .ui-page-theme-a, | |
| .ui-page-theme-a .ui-panel-wrapper { | |
| background-color: #f9f9f9 /*{a-page-background-color}*/; | |
| border-color: #bbbbbb /*{a-page-border}*/; | |
| color: #333333 /*{a-page-color}*/; | |
| text-shadow: 0 /*{a-page-shadow-x}*/ 0 /*{a-page-shadow-y}*/ 0 /*{a-page-shadow-radius}*/ #f3f3f3 /*{a-page-shadow-color}*/; | |
| } | |
| /* Body: Read-only lists, text inputs, collapsible content */ | |
| .ui-body-a, | |
| .ui-page-theme-a .ui-body-inherit, | |
| html .ui-bar-a .ui-body-inherit, | |
| html .ui-body-a .ui-body-inherit, | |
| html body .ui-group-theme-a .ui-body-inherit, | |
| html .ui-panel-page-container-a { | |
| background-color: #ffffff /*{a-body-background-color}*/; | |
| border-color: #dddddd /*{a-body-border}*/; | |
| color: #333333 /*{a-body-color}*/; | |
| text-shadow: 0 /*{a-body-shadow-x}*/ 0 /*{a-body-shadow-y}*/ 0 /*{a-body-shadow-radius}*/ #f3f3f3 /*{a-body-shadow-color}*/; | |
| } | |
| .ui-body-a { | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| /* Links */ | |
| .ui-page-theme-a a, | |
| html .ui-bar-a a, | |
| html .ui-body-a a, | |
| html body .ui-group-theme-a a { | |
| color: #3388cc /*{a-link-color}*/; | |
| font-weight: bold; | |
| } | |
| .ui-page-theme-a a:visited, | |
| html .ui-bar-a a:visited, | |
| html .ui-body-a a:visited, | |
| html body .ui-group-theme-a a:visited { | |
| color: #3388cc /*{a-link-visited}*/; | |
| } | |
| .ui-page-theme-a a:hover, | |
| html .ui-bar-a a:hover, | |
| html .ui-body-a a:hover, | |
| html body .ui-group-theme-a a:hover { | |
| color: #005599 /*{a-link-hover}*/; | |
| } | |
| .ui-page-theme-a a:active, | |
| html .ui-bar-a a:active, | |
| html .ui-body-a a:active, | |
| html body .ui-group-theme-a a:active { | |
| color: #005599 /*{a-link-active}*/; | |
| } | |
| /* Button up */ | |
| .ui-page-theme-a .ui-btn, | |
| html .ui-bar-a .ui-btn, | |
| html .ui-body-a .ui-btn, | |
| html body .ui-group-theme-a .ui-btn, | |
| html head + body .ui-btn.ui-btn-a, | |
| /* Button visited */ | |
| .ui-page-theme-a .ui-btn:visited, | |
| html .ui-bar-a .ui-btn:visited, | |
| html .ui-body-a .ui-btn:visited, | |
| html body .ui-group-theme-a .ui-btn:visited, | |
| html head + body .ui-btn.ui-btn-a:visited { | |
| background-color: #f6f6f6 /*{a-bup-background-color}*/; | |
| border-color: #dddddd /*{a-bup-border}*/; | |
| color: #333333 /*{a-bup-color}*/; | |
| text-shadow: 0 /*{a-bup-shadow-x}*/ 0 /*{a-bup-shadow-y}*/ 0 /*{a-bup-shadow-radius}*/ #f3f3f3 /*{a-bup-shadow-color}*/; | |
| } | |
| /* Button hover */ | |
| .ui-page-theme-a .ui-btn:hover, | |
| html .ui-bar-a .ui-btn:hover, | |
| html .ui-body-a .ui-btn:hover, | |
| html body .ui-group-theme-a .ui-btn:hover, | |
| html head + body .ui-btn.ui-btn-a:hover { | |
| background-color: #ededed /*{a-bhover-background-color}*/; | |
| border-color: #dddddd /*{a-bhover-border}*/; | |
| color: #333333 /*{a-bhover-color}*/; | |
| text-shadow: 0 /*{a-bhover-shadow-x}*/ 0 /*{a-bhover-shadow-y}*/ 0 /*{a-bhover-shadow-radius}*/ #f3f3f3 /*{a-bhover-shadow-color}*/; | |
| } | |
| /* Button down */ | |
| .ui-page-theme-a .ui-btn:active, | |
| html .ui-bar-a .ui-btn:active, | |
| html .ui-body-a .ui-btn:active, | |
| html body .ui-group-theme-a .ui-btn:active, | |
| html head + body .ui-btn.ui-btn-a:active { | |
| background-color: #e8e8e8 /*{a-bdown-background-color}*/; | |
| border-color: #dddddd /*{a-bdown-border}*/; | |
| color: #333333 /*{a-bdown-color}*/; | |
| text-shadow: 0 /*{a-bdown-shadow-x}*/ 0 /*{a-bdown-shadow-y}*/ 0 /*{a-bdown-shadow-radius}*/ #f3f3f3 /*{a-bdown-shadow-color}*/; | |
| } | |
| /* Active button */ | |
| .ui-page-theme-a .ui-btn.ui-btn-active, | |
| html .ui-bar-a .ui-btn.ui-btn-active, | |
| html .ui-body-a .ui-btn.ui-btn-active, | |
| html body .ui-group-theme-a .ui-btn.ui-btn-active, | |
| html head + body .ui-btn.ui-btn-a.ui-btn-active, | |
| /* Active checkbox icon */ | |
| .ui-page-theme-a .ui-checkbox-on:after, | |
| html .ui-bar-a .ui-checkbox-on:after, | |
| html .ui-body-a .ui-checkbox-on:after, | |
| html body .ui-group-theme-a .ui-checkbox-on:after, | |
| .ui-btn.ui-checkbox-on.ui-btn-a:after, | |
| /* Active flipswitch background */ | |
| .ui-page-theme-a .ui-flipswitch-active, | |
| html .ui-bar-a .ui-flipswitch-active, | |
| html .ui-body-a .ui-flipswitch-active, | |
| html body .ui-group-theme-a .ui-flipswitch-active, | |
| html body .ui-flipswitch.ui-bar-a.ui-flipswitch-active, | |
| /* Active slider track */ | |
| .ui-page-theme-a .ui-slider-track .ui-btn-active, | |
| html .ui-bar-a .ui-slider-track .ui-btn-active, | |
| html .ui-body-a .ui-slider-track .ui-btn-active, | |
| html body .ui-group-theme-a .ui-slider-track .ui-btn-active, | |
| html body div.ui-slider-track.ui-body-a .ui-btn-active { | |
| background-color: #3388cc /*{a-active-background-color}*/; | |
| border-color: #3388cc /*{a-active-border}*/; | |
| color: #ffffff /*{a-active-color}*/; | |
| text-shadow: 0 /*{a-active-shadow-x}*/ 0 /*{a-active-shadow-y}*/ 0 /*{a-active-shadow-radius}*/ #005599 /*{a-active-shadow-color}*/; | |
| } | |
| /* Active radio button icon */ | |
| .ui-page-theme-a .ui-radio-on:after, | |
| html .ui-bar-a .ui-radio-on:after, | |
| html .ui-body-a .ui-radio-on:after, | |
| html body .ui-group-theme-a .ui-radio-on:after, | |
| .ui-btn.ui-radio-on.ui-btn-a:after { | |
| border-color: #3388cc /*{a-active-background-color}*/; | |
| } | |
| /* Focus */ | |
| .ui-page-theme-a .ui-btn:focus, | |
| html .ui-bar-a .ui-btn:focus, | |
| html .ui-body-a .ui-btn:focus, | |
| html body .ui-group-theme-a .ui-btn:focus, | |
| html head + body .ui-btn.ui-btn-a:focus, | |
| /* Focus buttons and text inputs with div wrap */ | |
| .ui-page-theme-a .ui-focus, | |
| html .ui-bar-a .ui-focus, | |
| html .ui-body-a .ui-focus, | |
| html body .ui-group-theme-a .ui-focus, | |
| html head + body .ui-btn-a.ui-focus, | |
| html head + body .ui-body-a.ui-focus { | |
| -webkit-box-shadow: 0 0 12px #3388cc /*{a-active-background-color}*/; | |
| -moz-box-shadow: 0 0 12px #3388cc /*{a-active-background-color}*/; | |
| box-shadow: 0 0 12px #3388cc /*{a-active-background-color}*/; | |
| } | |
| /* B | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| /* Bar: Toolbars, dividers, slider track */ | |
| .ui-bar-b, | |
| .ui-page-theme-b .ui-bar-inherit, | |
| html .ui-bar-b .ui-bar-inherit, | |
| html .ui-body-b .ui-bar-inherit, | |
| html body .ui-group-theme-b .ui-bar-inherit { | |
| background-color: #1abc9c /*{b-bar-background-color}*/; | |
| border-color: #1abc9c /*{b-bar-border}*/; | |
| color: #ffffff /*{b-bar-color}*/; | |
| text-shadow: 0 /*{b-bar-shadow-x}*/ 0 /*{b-bar-shadow-y}*/ 0 /*{b-bar-shadow-radius}*/ #eeeeee /*{b-bar-shadow-color}*/; | |
| font-weight: bold; | |
| } | |
| .ui-bar-b { | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| /* Page and overlay */ | |
| .ui-overlay-b, | |
| .ui-page-theme-b, | |
| .ui-page-theme-b .ui-panel-wrapper { | |
| background-color: #f9f9f9 /*{b-page-background-color}*/; | |
| border-color: #bbbbbb /*{b-page-border}*/; | |
| color: #333333 /*{b-page-color}*/; | |
| text-shadow: 0 /*{b-page-shadow-x}*/ 0 /*{b-page-shadow-y}*/ 0 /*{b-page-shadow-radius}*/ #f3f3f3 /*{b-page-shadow-color}*/; | |
| } | |
| /* Body: Read-only lists, text inputs, collapsible content */ | |
| .ui-body-b, | |
| .ui-page-theme-b .ui-body-inherit, | |
| html .ui-bar-b .ui-body-inherit, | |
| html .ui-body-b .ui-body-inherit, | |
| html body .ui-group-theme-b .ui-body-inherit, | |
| html .ui-panel-page-container-b { | |
| background-color: #1abc9c /*{b-body-background-color}*/; | |
| border-color: #1abc9c /*{b-body-border}*/; | |
| color: #ffffff /*{b-body-color}*/; | |
| text-shadow: 0 /*{b-body-shadow-x}*/ 0 /*{b-body-shadow-y}*/ 0 /*{b-body-shadow-radius}*/ #444444 /*{b-body-shadow-color}*/; | |
| } | |
| .ui-body-b { | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| /* Links */ | |
| .ui-page-theme-b a, | |
| html .ui-bar-b a, | |
| html .ui-body-b a, | |
| html body .ui-group-theme-b a { | |
| color: #3388cc /*{b-link-color}*/; | |
| font-weight: bold; | |
| } | |
| .ui-page-theme-b a:visited, | |
| html .ui-bar-b a:visited, | |
| html .ui-body-b a:visited, | |
| html body .ui-group-theme-b a:visited { | |
| color: #3388cc /*{b-link-visited}*/; | |
| } | |
| .ui-page-theme-b a:hover, | |
| html .ui-bar-b a:hover, | |
| html .ui-body-b a:hover, | |
| html body .ui-group-theme-b a:hover { | |
| color: #005599 /*{b-link-hover}*/; | |
| } | |
| .ui-page-theme-b a:active, | |
| html .ui-bar-b a:active, | |
| html .ui-body-b a:active, | |
| html body .ui-group-theme-b a:active { | |
| color: #005599 /*{b-link-active}*/; | |
| } | |
| /* Button up */ | |
| .ui-page-theme-b .ui-btn, | |
| html .ui-bar-b .ui-btn, | |
| html .ui-body-b .ui-btn, | |
| html body .ui-group-theme-b .ui-btn, | |
| html head + body .ui-btn.ui-btn-b, | |
| /* Button visited */ | |
| .ui-page-theme-b .ui-btn:visited, | |
| html .ui-bar-b .ui-btn:visited, | |
| html .ui-body-b .ui-btn:visited, | |
| html body .ui-group-theme-b .ui-btn:visited, | |
| html head + body .ui-btn.ui-btn-b:visited { | |
| background-color: #1abc9c /*{b-bup-background-color}*/; | |
| border-color: #1abc9c /*{b-bup-border}*/; | |
| color: #ffffff /*{b-bup-color}*/; | |
| text-shadow: 0 /*{b-bup-shadow-x}*/ 0 /*{b-bup-shadow-y}*/ 0 /*{b-bup-shadow-radius}*/ #444444 /*{b-bup-shadow-color}*/; | |
| } | |
| /* Button hover */ | |
| .ui-page-theme-b .ui-btn:hover, | |
| html .ui-bar-b .ui-btn:hover, | |
| html .ui-body-b .ui-btn:hover, | |
| html body .ui-group-theme-b .ui-btn:hover, | |
| html head + body .ui-btn.ui-btn-b:hover { | |
| background-color: #1abc9c /*{b-bhover-background-color}*/; | |
| border-color: #1abc9c /*{b-bhover-border}*/; | |
| color: #ffffff /*{b-bhover-color}*/; | |
| text-shadow: 0 /*{b-bhover-shadow-x}*/ 0 /*{b-bhover-shadow-y}*/ 0 /*{b-bhover-shadow-radius}*/ #444444 /*{b-bhover-shadow-color}*/; | |
| } | |
| /* Button down */ | |
| .ui-page-theme-b .ui-btn:active, | |
| html .ui-bar-b .ui-btn:active, | |
| html .ui-body-b .ui-btn:active, | |
| html body .ui-group-theme-b .ui-btn:active, | |
| html head + body .ui-btn.ui-btn-b:active { | |
| background-color: #e8e8e8 /*{b-bdown-background-color}*/; | |
| border-color: #e8e8e8 /*{b-bdown-border}*/; | |
| color: #000000 /*{b-bdown-color}*/; | |
| text-shadow: 0 /*{b-bdown-shadow-x}*/ 0 /*{b-bdown-shadow-y}*/ 0 /*{b-bdown-shadow-radius}*/ #eeeeee /*{b-bdown-shadow-color}*/; | |
| } | |
| /* Active button */ | |
| .ui-page-theme-b .ui-btn.ui-btn-active, | |
| html .ui-bar-b .ui-btn.ui-btn-active, | |
| html .ui-body-b .ui-btn.ui-btn-active, | |
| html body .ui-group-theme-b .ui-btn.ui-btn-active, | |
| html head + body .ui-btn.ui-btn-b.ui-btn-active, | |
| /* Active checkbox icon */ | |
| .ui-page-theme-b .ui-checkbox-on:after, | |
| html .ui-bar-b .ui-checkbox-on:after, | |
| html .ui-body-b .ui-checkbox-on:after, | |
| html body .ui-group-theme-b .ui-checkbox-on:after, | |
| .ui-btn.ui-checkbox-on.ui-btn-b:after, | |
| /* Active flipswitch background */ | |
| .ui-page-theme-b .ui-flipswitch-active, | |
| html .ui-bar-b .ui-flipswitch-active, | |
| html .ui-body-b .ui-flipswitch-active, | |
| html body .ui-group-theme-b .ui-flipswitch-active, | |
| html body .ui-flipswitch.ui-bar-b.ui-flipswitch-active, | |
| /* Active slider track */ | |
| .ui-page-theme-b .ui-slider-track .ui-btn-active, | |
| html .ui-bar-b .ui-slider-track .ui-btn-active, | |
| html .ui-body-b .ui-slider-track .ui-btn-active, | |
| html body .ui-group-theme-b .ui-slider-track .ui-btn-active, | |
| html body div.ui-slider-track.ui-body-b .ui-btn-active { | |
| background-color: #3388cc /*{b-active-background-color}*/; | |
| border-color: #3388cc /*{b-active-border}*/; | |
| color: #ffffff /*{b-active-color}*/; | |
| text-shadow: 0 /*{b-active-shadow-x}*/ 0 /*{b-active-shadow-y}*/ 0 /*{b-active-shadow-radius}*/ #005599 /*{b-active-shadow-color}*/; | |
| } | |
| /* Active radio button icon */ | |
| .ui-page-theme-b .ui-radio-on:after, | |
| html .ui-bar-b .ui-radio-on:after, | |
| html .ui-body-b .ui-radio-on:after, | |
| html body .ui-group-theme-b .ui-radio-on:after, | |
| .ui-btn.ui-radio-on.ui-btn-b:after { | |
| border-color: #3388cc /*{b-active-background-color}*/; | |
| } | |
| /* Focus */ | |
| .ui-page-theme-b .ui-btn:focus, | |
| html .ui-bar-b .ui-btn:focus, | |
| html .ui-body-b .ui-btn:focus, | |
| html body .ui-group-theme-b .ui-btn:focus, | |
| html head + body .ui-btn.ui-btn-b:focus, | |
| /* Focus buttons and text inputs with div wrap */ | |
| .ui-page-theme-b .ui-focus, | |
| html .ui-bar-b .ui-focus, | |
| html .ui-body-b .ui-focus, | |
| html body .ui-group-theme-b .ui-focus, | |
| html head + body .ui-btn-b.ui-focus, | |
| html head + body .ui-body-b.ui-focus { | |
| -webkit-box-shadow: 0 0 12px #3388cc /*{b-active-background-color}*/; | |
| -moz-box-shadow: 0 0 12px #3388cc /*{b-active-background-color}*/; | |
| box-shadow: 0 0 12px #3388cc /*{b-active-background-color}*/; | |
| } | |
| /* C | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| /* Bar: Toolbars, dividers, slider track */ | |
| .ui-bar-c, | |
| .ui-page-theme-c .ui-bar-inherit, | |
| html .ui-bar-c .ui-bar-inherit, | |
| html .ui-body-c .ui-bar-inherit, | |
| html body .ui-group-theme-c .ui-bar-inherit { | |
| background-color: #1abc9c /*{c-bar-background-color}*/; | |
| border-color: #1abc9c /*{c-bar-border}*/; | |
| color: #ffffff /*{c-bar-color}*/; | |
| text-shadow: 0 /*{c-bar-shadow-x}*/ 0 /*{c-bar-shadow-y}*/ 0 /*{c-bar-shadow-radius}*/ #eeeeee /*{c-bar-shadow-color}*/; | |
| font-weight: bold; | |
| } | |
| .ui-bar-c { | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| /* Page and overlay */ | |
| .ui-overlay-c, | |
| .ui-page-theme-c, | |
| .ui-page-theme-c .ui-panel-wrapper { | |
| background-color: #f9f9f9 /*{c-page-background-color}*/; | |
| border-color: #bbbbbb /*{c-page-border}*/; | |
| color: #333333 /*{c-page-color}*/; | |
| text-shadow: 0 /*{c-page-shadow-x}*/ 0 /*{c-page-shadow-y}*/ 0 /*{c-page-shadow-radius}*/ #f3f3f3 /*{c-page-shadow-color}*/; | |
| } | |
| /* Body: Read-only lists, text inputs, collapsible content */ | |
| .ui-body-c, | |
| .ui-page-theme-c .ui-body-inherit, | |
| html .ui-bar-c .ui-body-inherit, | |
| html .ui-body-c .ui-body-inherit, | |
| html body .ui-group-theme-c .ui-body-inherit, | |
| html .ui-panel-page-container-c { | |
| background-color: #ffffff /*{c-body-background-color}*/; | |
| border-color: #dddddd /*{c-body-border}*/; | |
| color: #333333 /*{c-body-color}*/; | |
| text-shadow: 0 /*{c-body-shadow-x}*/ 0 /*{c-body-shadow-y}*/ 0 /*{c-body-shadow-radius}*/ #f3f3f3 /*{c-body-shadow-color}*/; | |
| } | |
| .ui-body-c { | |
| border-width: 1px; | |
| border-style: solid; | |
| } | |
| /* Links */ | |
| .ui-page-theme-c a, | |
| html .ui-bar-c a, | |
| html .ui-body-c a, | |
| html body .ui-group-theme-c a { | |
| color: #3388cc /*{c-link-color}*/; | |
| font-weight: bold; | |
| } | |
| .ui-page-theme-c a:visited, | |
| html .ui-bar-c a:visited, | |
| html .ui-body-c a:visited, | |
| html body .ui-group-theme-c a:visited { | |
| color: #3388cc /*{c-link-visited}*/; | |
| } | |
| .ui-page-theme-c a:hover, | |
| html .ui-bar-c a:hover, | |
| html .ui-body-c a:hover, | |
| html body .ui-group-theme-c a:hover { | |
| color: #005599 /*{c-link-hover}*/; | |
| } | |
| .ui-page-theme-c a:active, | |
| html .ui-bar-c a:active, | |
| html .ui-body-c a:active, | |
| html body .ui-group-theme-c a:active { | |
| color: #005599 /*{c-link-active}*/; | |
| } | |
| /* Button up */ | |
| .ui-page-theme-c .ui-btn, | |
| html .ui-bar-c .ui-btn, | |
| html .ui-body-c .ui-btn, | |
| html body .ui-group-theme-c .ui-btn, | |
| html head + body .ui-btn.ui-btn-c, | |
| /* Button visited */ | |
| .ui-page-theme-c .ui-btn:visited, | |
| html .ui-bar-c .ui-btn:visited, | |
| html .ui-body-c .ui-btn:visited, | |
| html body .ui-group-theme-c .ui-btn:visited, | |
| html head + body .ui-btn.ui-btn-c:visited { | |
| background-color: #f6f6f6 /*{c-bup-background-color}*/; | |
| border-color: #dddddd /*{c-bup-border}*/; | |
| color: #333333 /*{c-bup-color}*/; | |
| text-shadow: 0 /*{c-bup-shadow-x}*/ 0 /*{c-bup-shadow-y}*/ 0 /*{c-bup-shadow-radius}*/ #f3f3f3 /*{c-bup-shadow-color}*/; | |
| } | |
| /* Button hover */ | |
| .ui-page-theme-c .ui-btn:hover, | |
| html .ui-bar-c .ui-btn:hover, | |
| html .ui-body-c .ui-btn:hover, | |
| html body .ui-group-theme-c .ui-btn:hover, | |
| html head + body .ui-btn.ui-btn-c:hover { | |
| background-color: #ededed /*{c-bhover-background-color}*/; | |
| border-color: #dddddd /*{c-bhover-border}*/; | |
| color: #333333 /*{c-bhover-color}*/; | |
| text-shadow: 0 /*{c-bhover-shadow-x}*/ 0 /*{c-bhover-shadow-y}*/ 0 /*{c-bhover-shadow-radius}*/ #f3f3f3 /*{c-bhover-shadow-color}*/; | |
| } | |
| /* Button down */ | |
| .ui-page-theme-c .ui-btn:active, | |
| html .ui-bar-c .ui-btn:active, | |
| html .ui-body-c .ui-btn:active, | |
| html body .ui-group-theme-c .ui-btn:active, | |
| html head + body .ui-btn.ui-btn-c:active { | |
| background-color: #e8e8e8 /*{c-bdown-background-color}*/; | |
| border-color: #dddddd /*{c-bdown-border}*/; | |
| color: #333333 /*{c-bdown-color}*/; | |
| text-shadow: 0 /*{c-bdown-shadow-x}*/ 0 /*{c-bdown-shadow-y}*/ 0 /*{c-bdown-shadow-radius}*/ #f3f3f3 /*{c-bdown-shadow-color}*/; | |
| } | |
| /* Active button */ | |
| .ui-page-theme-c .ui-btn.ui-btn-active, | |
| html .ui-bar-c .ui-btn.ui-btn-active, | |
| html .ui-body-c .ui-btn.ui-btn-active, | |
| html body .ui-group-theme-c .ui-btn.ui-btn-active, | |
| html head + body .ui-btn.ui-btn-c.ui-btn-active, | |
| /* Active checkbox icon */ | |
| .ui-page-theme-c .ui-checkbox-on:after, | |
| html .ui-bar-c .ui-checkbox-on:after, | |
| html .ui-body-c .ui-checkbox-on:after, | |
| html body .ui-group-theme-c .ui-checkbox-on:after, | |
| .ui-btn.ui-checkbox-on.ui-btn-c:after, | |
| /* Active flipswitch background */ | |
| .ui-page-theme-c .ui-flipswitch-active, | |
| html .ui-bar-c .ui-flipswitch-active, | |
| html .ui-body-c .ui-flipswitch-active, | |
| html body .ui-group-theme-c .ui-flipswitch-active, | |
| html body .ui-flipswitch.ui-bar-c.ui-flipswitch-active, | |
| /* Active slider track */ | |
| .ui-page-theme-c .ui-slider-track .ui-btn-active, | |
| html .ui-bar-c .ui-slider-track .ui-btn-active, | |
| html .ui-body-c .ui-slider-track .ui-btn-active, | |
| html body .ui-group-theme-c .ui-slider-track .ui-btn-active, | |
| html body div.ui-slider-track.ui-body-c .ui-btn-active { | |
| background-color: #3388cc /*{c-active-background-color}*/; | |
| border-color: #3388cc /*{c-active-border}*/; | |
| color: #ffffff /*{c-active-color}*/; | |
| text-shadow: 0 /*{c-active-shadow-x}*/ 0 /*{c-active-shadow-y}*/ 0 /*{c-active-shadow-radius}*/ #005599 /*{c-active-shadow-color}*/; | |
| } | |
| /* Active radio button icon */ | |
| .ui-page-theme-c .ui-radio-on:after, | |
| html .ui-bar-c .ui-radio-on:after, | |
| html .ui-body-c .ui-radio-on:after, | |
| html body .ui-group-theme-c .ui-radio-on:after, | |
| .ui-btn.ui-radio-on.ui-btn-c:after { | |
| border-color: #3388cc /*{c-active-background-color}*/; | |
| } | |
| /* Focus */ | |
| .ui-page-theme-c .ui-btn:focus, | |
| html .ui-bar-c .ui-btn:focus, | |
| html .ui-body-c .ui-btn:focus, | |
| html body .ui-group-theme-c .ui-btn:focus, | |
| html head + body .ui-btn.ui-btn-c:focus, | |
| /* Focus buttons and text inputs with div wrap */ | |
| .ui-page-theme-c .ui-focus, | |
| html .ui-bar-c .ui-focus, | |
| html .ui-body-c .ui-focus, | |
| html body .ui-group-theme-c .ui-focus, | |
| html head + body .ui-btn-c.ui-focus, | |
| html head + body .ui-body-c.ui-focus { | |
| -webkit-box-shadow: 0 0 12px #3388cc /*{c-active-background-color}*/; | |
| -moz-box-shadow: 0 0 12px #3388cc /*{c-active-background-color}*/; | |
| box-shadow: 0 0 12px #3388cc /*{c-active-background-color}*/; | |
| } | |
| /* Structure */ | |
| /* Disabled | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| /* Class ui-disabled deprecated in 1.4. :disabled not supported by IE8 so we use [disabled] */ | |
| .ui-disabled, | |
| .ui-state-disabled, | |
| button[disabled], | |
| .ui-select .ui-btn.ui-state-disabled { | |
| filter: Alpha(Opacity=30); | |
| opacity: .3; | |
| cursor: default !important; | |
| pointer-events: none; | |
| } | |
| /* Focus state outline | |
| -----------------------------------------------------------------------------------------------------------*/ | |
| .ui-btn:focus, | |
| .ui-btn.ui-focus { | |
| outline: 0; | |
| } | |
| /* Unset box-shadow in browsers that don't do it right */ | |
| .ui-noboxshadow .ui-shadow, | |
| .ui-noboxshadow .ui-shadow-inset, | |
| .ui-noboxshadow .ui-overlay-shadow, | |
| .ui-noboxshadow .ui-shadow-icon.ui-btn:after, | |
| .ui-noboxshadow .ui-shadow-icon .ui-btn:after, | |
| .ui-noboxshadow .ui-focus, | |
| .ui-noboxshadow .ui-btn:focus, | |
| .ui-noboxshadow input:focus, | |
| .ui-noboxshadow .ui-panel { | |
| -webkit-box-shadow: none !important; | |
| -moz-box-shadow: none !important; | |
| box-shadow: none !important; | |
| } | |
| .ui-noboxshadow .ui-btn:focus, | |
| .ui-noboxshadow .ui-focus { | |
| outline-width: 1px; | |
| outline-style: auto; | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment