mirror of
https://github.com/Hopiu/jquery-mobile.git
synced 2026-03-18 15:00:23 +00:00
084bbbd839
fix for issue 1530: Page title is changing when I use popup select menu (Dropdown). Thanks marcoos.
882 lines
26 KiB
JavaScript
882 lines
26 KiB
JavaScript
/*
|
|
* jQuery Mobile Framework : core utilities for auto ajax navigation, base tag mgmt,
|
|
* Copyright (c) jQuery Project
|
|
* Dual licensed under the MIT or GPL Version 2 licenses.
|
|
* http://jquery.org/license
|
|
*/
|
|
( function( $, undefined ) {
|
|
|
|
//define vars for interal use
|
|
var $window = $( window ),
|
|
$html = $( "html" ),
|
|
$head = $( "head" ),
|
|
|
|
//url path helpers for use in relative url management
|
|
path = {
|
|
|
|
//get path from current hash, or from a file path
|
|
get: function( newPath ) {
|
|
if( newPath === undefined ) {
|
|
newPath = location.hash;
|
|
}
|
|
return path.stripHash( newPath ).replace( /[^\/]*\.[^\/*]+$/, "" );
|
|
},
|
|
|
|
//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];
|
|
},
|
|
|
|
//set location hash to path
|
|
set: function( path ) {
|
|
location.hash = path;
|
|
},
|
|
|
|
//location pathname from intial directory request
|
|
origin: "",
|
|
|
|
setOrigin: function() {
|
|
path.origin = path.get( location.protocol + "//" + location.host + location.pathname );
|
|
},
|
|
|
|
// prefix a relative url with the current path
|
|
// TODO force old relative deeplinks into new absolute path
|
|
makeAbsolute: function( url ) {
|
|
var isHashPath = path.isPath( location.hash );
|
|
|
|
if( path.isQuery( url ) ) {
|
|
// if the path is a list of query params and the hash is a path
|
|
// append the query params to the hash (without params or dialog keys).
|
|
// otherwise use the pathname and append the query params
|
|
return ( isHashPath ? path.cleanHash( location.hash ) : location.pathname ) + url;
|
|
}
|
|
|
|
// If the hash is a path, even if its not absolute, use it to prepend to the url
|
|
// otherwise use the path with the trailing segement removed
|
|
return ( isHashPath ? path.get() : path.get( location.pathname ) ) + url;
|
|
},
|
|
|
|
// test if a given url (string) is a path
|
|
// NOTE might be exceptionally naive
|
|
isPath: function( url ) {
|
|
return ( /\// ).test( url );
|
|
},
|
|
|
|
isQuery: function( url ) {
|
|
return ( /^\?/ ).test( url );
|
|
},
|
|
|
|
//return a url path with the window's location protocol/hostname/pathname removed
|
|
clean: function( url ) {
|
|
// Replace the protocol host only once at the beginning of the url to avoid
|
|
// problems when it's included as a part of a param
|
|
var leadingUrlRootRegex = new RegExp( "^" + location.protocol + "//" + location.host );
|
|
return url.replace( leadingUrlRootRegex, "" );
|
|
},
|
|
|
|
//just return the url without an initial #
|
|
stripHash: 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, "" ) );
|
|
},
|
|
|
|
//check whether a url is referencing the same domain, or an external domain or different protocol
|
|
//could be mailto, etc
|
|
isExternal: function( url ) {
|
|
return path.hasProtocol( path.clean( url ) );
|
|
},
|
|
|
|
hasProtocol: function( url ) {
|
|
return ( /^(:?\w+:)/ ).test( url );
|
|
},
|
|
|
|
//check if the url is relative
|
|
isRelative: function( url ) {
|
|
return ( /^[^\/|#]/ ).test( url ) && !path.hasProtocol( url );
|
|
},
|
|
|
|
isEmbeddedPage: function( url ) {
|
|
return ( /^#/ ).test( url );
|
|
}
|
|
},
|
|
|
|
//will be defined when a link is clicked and given an active class
|
|
$activeClickedLink = null,
|
|
|
|
//urlHistory is purely here to make guesses at whether the back or forward button was clicked
|
|
//and provide an appropriate transition
|
|
urlHistory = {
|
|
//array of pages that are visited during a single page load. each has a url and optional transition
|
|
stack: [],
|
|
|
|
//maintain an index number for the active page in the stack
|
|
activeIndex: 0,
|
|
|
|
//get active
|
|
getActive: function() {
|
|
return urlHistory.stack[ urlHistory.activeIndex ];
|
|
},
|
|
|
|
getPrev: function() {
|
|
return urlHistory.stack[ urlHistory.activeIndex - 1 ];
|
|
},
|
|
|
|
getNext: function() {
|
|
return urlHistory.stack[ urlHistory.activeIndex + 1 ];
|
|
},
|
|
|
|
// addNew is used whenever a new page is added
|
|
addNew: function( url, transition, title, storedTo ) {
|
|
//if there's forward history, wipe it
|
|
if( urlHistory.getNext() ) {
|
|
urlHistory.clearForward();
|
|
}
|
|
|
|
urlHistory.stack.push(
|
|
{
|
|
url : url,
|
|
transition: transition,
|
|
title: title,
|
|
page: storedTo
|
|
}
|
|
);
|
|
|
|
urlHistory.activeIndex = urlHistory.stack.length - 1;
|
|
},
|
|
|
|
//wipe urls ahead of active index
|
|
clearForward: function() {
|
|
urlHistory.stack = urlHistory.stack.slice( 0, urlHistory.activeIndex + 1 );
|
|
},
|
|
|
|
directHashChange: function( opts ) {
|
|
var back , forward, newActiveIndex;
|
|
|
|
// check if url isp in history and if it's ahead or behind current page
|
|
$.each( urlHistory.stack, function( i, historyEntry ) {
|
|
|
|
//if the url is in the stack, it's a forward or a back
|
|
if( opts.currentUrl === historyEntry.url ) {
|
|
//define back and forward by whether url is older or newer than current page
|
|
back = i < urlHistory.activeIndex;
|
|
forward = !back;
|
|
newActiveIndex = i;
|
|
}
|
|
});
|
|
|
|
// save new page index, null check to prevent falsey 0 result
|
|
this.activeIndex = newActiveIndex !== undefined ? newActiveIndex : this.activeIndex;
|
|
|
|
if( back ) {
|
|
opts.isBack();
|
|
} else if( forward ) {
|
|
opts.isForward();
|
|
}
|
|
},
|
|
|
|
//disable hashchange event listener internally to ignore one change
|
|
//toggled internally when location.hash is updated to match the url of a successful page load
|
|
ignoreNextHashChange: true
|
|
},
|
|
|
|
//define first selector to receive focus when a page is shown
|
|
focusable = "[tabindex],a,button:visible,select:visible,input",
|
|
|
|
//contains role for next page, if defined on clicked link via data-rel
|
|
nextPageRole = null,
|
|
|
|
//queue to hold simultanious page transitions
|
|
pageTransitionQueue = [],
|
|
|
|
// indicates whether or not page is in process of transitioning
|
|
isPageTransitioning = false,
|
|
|
|
//nonsense hash change key for dialogs, so they create a history entry
|
|
dialogHashKey = "&ui-state=dialog",
|
|
|
|
//existing base tag?
|
|
$base = $head.children( "base" ),
|
|
|
|
//get domain path
|
|
//(note: use explicit protocol here, protocol-relative urls won't work as expected on localhost)
|
|
docBase = location.protocol + "//" + location.host,
|
|
|
|
//initialPath for first page load without hash. pathname (href - search)
|
|
initialPath = docBase + location.pathname;
|
|
|
|
//already a base element?
|
|
if ( $base.length ) {
|
|
var href = $base.attr( "href" );
|
|
if ( href ) {
|
|
if ( href.search( /^[^:\/]+:\/\/[^\/]+\/?/ ) === -1 ) {
|
|
//the href is not absolute, we need to turn it into one
|
|
docBase = docBase + href;
|
|
}
|
|
else {
|
|
//the href is an absolute url
|
|
docBase = href;
|
|
}
|
|
}
|
|
|
|
//make sure docBase ends with a slash
|
|
docBase = docBase + ( docBase.charAt( docBase.length - 1 ) === "/" ? " " : "/" );
|
|
}
|
|
|
|
//base element management, defined depending on dynamic base tag support
|
|
var base = $.support.dynamicBaseTag ? {
|
|
|
|
//define base element, for use in routing asset urls that are referenced in Ajax-requested markup
|
|
element: ( $base.length ? $base : $( "<base>", { href: initialPath } ).prependTo( $head ) ),
|
|
|
|
//set the generated BASE element's href attribute to a new page's base path
|
|
set: function( href ) {
|
|
base.element.attr( "href", docBase + path.get( href ) );
|
|
},
|
|
|
|
//set the generated BASE element's href attribute to a new page's base path
|
|
reset: function() {
|
|
base.element.attr( "href", initialPath );
|
|
}
|
|
|
|
} : undefined;
|
|
|
|
//set location pathname from intial directory request
|
|
path.setOrigin();
|
|
|
|
/*
|
|
internal utility functions
|
|
--------------------------------------*/
|
|
|
|
//direct focus to the page title, or otherwise first focusable element
|
|
function reFocus( page ) {
|
|
var lastClicked = page.jqmData( "lastClicked" );
|
|
|
|
if( lastClicked && lastClicked.length ) {
|
|
lastClicked.focus();
|
|
}
|
|
else {
|
|
var pageTitle = page.find( ".ui-title:eq(0)" );
|
|
|
|
if( pageTitle.length ) {
|
|
pageTitle.focus();
|
|
}
|
|
else{
|
|
page.find( focusable ).eq( 0 ).focus();
|
|
}
|
|
}
|
|
}
|
|
|
|
//remove active classes after page transition or error
|
|
function removeActiveLinkClass( forceRemoval ) {
|
|
if( !!$activeClickedLink && ( !$activeClickedLink.closest( ".ui-page-active" ).length || forceRemoval ) ) {
|
|
$activeClickedLink.removeClass( $.mobile.activeBtnClass );
|
|
}
|
|
$activeClickedLink = null;
|
|
}
|
|
|
|
//animation complete callback
|
|
$.fn.animationComplete = function( callback ) {
|
|
if( $.support.cssTransitions ) {
|
|
return $( this ).one( "webkitAnimationEnd", callback );
|
|
}
|
|
else{
|
|
// defer execution for consistency between webkit/non webkit
|
|
setTimeout( callback, 0 );
|
|
return $( this );
|
|
}
|
|
};
|
|
|
|
/* exposed $.mobile methods */
|
|
|
|
//update location.hash, with or without triggering hashchange event
|
|
//TODO - deprecate this one at 1.0
|
|
$.mobile.updateHash = path.set;
|
|
|
|
//expose path object on $.mobile
|
|
$.mobile.path = path;
|
|
|
|
//expose base object on $.mobile
|
|
$.mobile.base = base;
|
|
|
|
//url stack, useful when plugins need to be aware of previous pages viewed
|
|
//TODO: deprecate this one at 1.0
|
|
$.mobile.urlstack = urlHistory.stack;
|
|
|
|
//history stack
|
|
$.mobile.urlHistory = urlHistory;
|
|
|
|
//default non-animation transition handler
|
|
$.mobile.noneTransitionHandler = function( name, reverse, $to, $from ) {
|
|
if ( $from ) {
|
|
$from.removeClass( $.mobile.activePageClass );
|
|
}
|
|
$to.addClass( $.mobile.activePageClass );
|
|
|
|
return $.Deferred().resolve( name, reverse, $to, $from ).promise();
|
|
};
|
|
|
|
//default handler for unknown transitions
|
|
$.mobile.defaultTransitionHandler = $.mobile.noneTransitionHandler;
|
|
|
|
//transition handler dictionary for 3rd party transitions
|
|
$.mobile.transitionHandlers = {
|
|
none: $.mobile.defaultTransitionHandler
|
|
};
|
|
|
|
//enable cross-domain page support
|
|
$.mobile.allowCrossDomainPages = false;
|
|
|
|
// changepage function
|
|
$.mobile.changePage = function( to, transition, reverse, changeHash, fromHashChange ) {
|
|
//from is always the currently viewed page
|
|
var toType = $.type( to ),
|
|
toIsArray = toType === "array",
|
|
toIsObject = toType === "object",
|
|
from = toIsArray ? to[0] : $.mobile.activePage;
|
|
|
|
to = toIsArray ? to[1] : to;
|
|
|
|
var url = $.type( to ) === "string" ? path.stripHash( to ) : "",
|
|
fileUrl = url,
|
|
data,
|
|
type = "get",
|
|
isFormRequest = false,
|
|
duplicateCachedPage = null,
|
|
active = urlHistory.getActive(),
|
|
back = false,
|
|
forward = false,
|
|
pageTitle = document.title;
|
|
|
|
// If we are trying to transition to the same page that we are currently on ignore the request.
|
|
// an illegal same page request is defined by the current page being the same as the url, as long as there's history
|
|
// and to is not an array or object (those are allowed to be "same")
|
|
if( urlHistory.stack.length > 0
|
|
&& active.page.jqmData( "url" ) === url
|
|
&& !toIsArray && !toIsObject ) {
|
|
return;
|
|
}
|
|
else if( isPageTransitioning ) {
|
|
pageTransitionQueue.unshift( arguments );
|
|
return;
|
|
}
|
|
|
|
isPageTransitioning = true;
|
|
|
|
// if the changePage was sent from a hashChange event guess if it came from the history menu
|
|
// and match the transition accordingly
|
|
if( fromHashChange ) {
|
|
urlHistory.directHashChange( {
|
|
currentUrl: url,
|
|
isBack: function() {
|
|
forward = !( back = true );
|
|
reverse = true;
|
|
transition = transition || active.transition;
|
|
},
|
|
isForward: function() {
|
|
forward = !( back = false );
|
|
transition = transition || urlHistory.getActive().transition;
|
|
}
|
|
});
|
|
|
|
//TODO forward = !back was breaking for some reason
|
|
}
|
|
|
|
if( toIsObject && to.url ) {
|
|
url = to.url;
|
|
data = to.data;
|
|
type = to.type;
|
|
isFormRequest = true;
|
|
//make get requests bookmarkable
|
|
if( data && type === "get" ) {
|
|
if( $.type( data ) === "object" ) {
|
|
data = $.param( data );
|
|
}
|
|
|
|
url += "?" + data;
|
|
data = undefined;
|
|
}
|
|
}
|
|
|
|
//reset base to pathname for new request
|
|
if( base ) { base.reset(); }
|
|
|
|
//kill the keyboard
|
|
$( window.document.activeElement || "" ).add( "input:focus, textarea:focus, select:focus" ).blur();
|
|
|
|
function defaultTransition() {
|
|
if( transition === undefined ) {
|
|
transition = ( nextPageRole && nextPageRole === "dialog" ) ? "pop" : $.mobile.defaultTransition;
|
|
}
|
|
}
|
|
|
|
function releasePageTransitionLock() {
|
|
isPageTransitioning = false;
|
|
if( pageTransitionQueue.length>0 ) {
|
|
$.mobile.changePage.apply( $.mobile, pageTransitionQueue.pop() );
|
|
}
|
|
}
|
|
|
|
//function for transitioning between two existing pages
|
|
function transitionPages() {
|
|
$.mobile.silentScroll();
|
|
|
|
//get current scroll distance
|
|
var currScroll = $window.scrollTop();
|
|
|
|
//support deep-links to generated sub-pages
|
|
if( url.indexOf( "&" + $.mobile.subPageUrlKey ) > -1 ) {
|
|
to = $( ":jqmData(url='" + url + "')" );
|
|
}
|
|
|
|
if( from ) {
|
|
//set as data for returning to that spot
|
|
from
|
|
.jqmData( "lastScroll", currScroll )
|
|
.jqmData( "lastClicked", $activeClickedLink );
|
|
//trigger before show/hide events
|
|
from.data( "page" )._trigger( "beforehide", null, { nextPage: to } );
|
|
}
|
|
to.data( "page" )._trigger( "beforeshow", null, { prevPage: from || $( "" ) } );
|
|
|
|
function pageChangeComplete() {
|
|
|
|
if( changeHash !== false && url ) {
|
|
//disable hash listening temporarily
|
|
urlHistory.ignoreNextHashChange = false;
|
|
//update hash and history
|
|
path.set( url );
|
|
}
|
|
|
|
//if title element wasn't found, try the page div data attr too
|
|
var newPageTitle = to.jqmData( "title" ) || to.find( ":jqmData(role='header') .ui-title" ).text();
|
|
if( !!newPageTitle && pageTitle === document.title ) {
|
|
pageTitle = newPageTitle;
|
|
}
|
|
|
|
//add page to history stack if it's not back or forward
|
|
if( !back && !forward ) {
|
|
urlHistory.addNew( url, transition, pageTitle, to );
|
|
}
|
|
|
|
//set page title
|
|
document.title = urlHistory.getActive().title;
|
|
|
|
removeActiveLinkClass();
|
|
|
|
//jump to top or prev scroll, sometimes on iOS the page has not rendered yet. I could only get by this with a setTimeout, but would like to avoid that.
|
|
$.mobile.silentScroll( to.jqmData( "lastScroll" ) );
|
|
$( document ).one( "silentscroll", function() { reFocus( to ); });
|
|
|
|
//trigger show/hide events
|
|
if( from ) {
|
|
from.data( "page" )._trigger( "hide", null, { nextPage: to } );
|
|
}
|
|
//trigger pageshow, define prevPage as either from or empty jQuery obj
|
|
to.data( "page" )._trigger( "show", null, { prevPage: from || $( "" ) } );
|
|
|
|
//set "to" as activePage
|
|
$.mobile.activePage = to;
|
|
|
|
//if there's a duplicateCachedPage, remove it from the DOM now that it's hidden
|
|
if ( duplicateCachedPage !== null ) {
|
|
duplicateCachedPage.remove();
|
|
}
|
|
|
|
//remove initial build class (only present on first pageshow)
|
|
$html.removeClass( "ui-mobile-rendering" );
|
|
|
|
releasePageTransitionLock();
|
|
}
|
|
|
|
//clear page loader
|
|
$.mobile.pageLoading( true );
|
|
|
|
//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.
|
|
var th = $.mobile.transitionHandlers[transition || "none"] || $.mobile.defaultTransitionHandler,
|
|
deferred = th( transition, reverse, to, from );
|
|
|
|
//register a done callback on the transition so we can do some book-keeping cleanup.
|
|
deferred.done( function() {
|
|
pageChangeComplete();
|
|
});
|
|
}
|
|
|
|
//shared page enhancements
|
|
function enhancePage() {
|
|
|
|
//set next page role, if defined
|
|
if ( nextPageRole || to.jqmData( "role" ) === "dialog" ) {
|
|
url = urlHistory.getActive().url + dialogHashKey;
|
|
if( nextPageRole ) {
|
|
to.attr( "data-" + $.mobile.ns + "role", nextPageRole );
|
|
nextPageRole = null;
|
|
}
|
|
}
|
|
|
|
//run page plugin
|
|
to.page();
|
|
}
|
|
|
|
//if url is a string
|
|
if( url ) {
|
|
to = $( ":jqmData(url='" + url + "')" );
|
|
fileUrl = path.getFilePath( url );
|
|
}
|
|
else{ //find base url of element, if avail
|
|
var toID = to.attr( "data-" + $.mobile.ns + "url" ),
|
|
toIDfileurl = path.getFilePath( toID );
|
|
|
|
if( toID !== toIDfileurl ) {
|
|
fileUrl = toIDfileurl;
|
|
}
|
|
}
|
|
|
|
// ensure a transition has been set where pop is undefined
|
|
defaultTransition();
|
|
|
|
// find the "to" page, either locally existing in the dom or by creating it through ajax
|
|
if ( to.length && !isFormRequest ) {
|
|
if( fileUrl && base ) {
|
|
base.set( fileUrl );
|
|
}
|
|
enhancePage();
|
|
transitionPages();
|
|
} else {
|
|
|
|
//if to exists in DOM, save a reference to it in duplicateCachedPage for removal after page change
|
|
if( to.length ) {
|
|
duplicateCachedPage = to;
|
|
}
|
|
|
|
$.mobile.pageLoading();
|
|
|
|
$.ajax({
|
|
url: fileUrl,
|
|
type: type,
|
|
data: data,
|
|
dataType: "html",
|
|
success: function( html ) {
|
|
//pre-parse html to check for a data-url,
|
|
//use it as the new fileUrl, base path, etc
|
|
var all = $( "<div></div>" ),
|
|
redirectLoc,
|
|
|
|
//page title regexp
|
|
newPageTitle = html.match( /<title[^>]*>([^<]*)/ ) && RegExp.$1,
|
|
|
|
// TODO handle dialogs again
|
|
pageElemRegex = new RegExp( "(<[^>]+\\bdata-" + $.mobile.ns + "role=[\"']?page[\"']?[^>]*>)" ),
|
|
dataUrlRegex = new RegExp( "\\bdata-" + $.mobile.ns + "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 ) {
|
|
redirectLoc = RegExp.$1;
|
|
}
|
|
|
|
if( redirectLoc ) {
|
|
if( base ) {
|
|
base.set( redirectLoc );
|
|
}
|
|
url = fileUrl = path.getFilePath( redirectLoc );
|
|
}
|
|
else {
|
|
if( base ) {
|
|
base.set( fileUrl );
|
|
}
|
|
}
|
|
|
|
//workaround to allow scripts to execute when included in page divs
|
|
all.get( 0 ).innerHTML = html;
|
|
to = all.find( ":jqmData(role='page'), :jqmData(role='dialog')" ).first();
|
|
|
|
//finally, if it's defined now, set the page title for storage in urlHistory
|
|
if( newPageTitle ) {
|
|
pageTitle = newPageTitle;
|
|
}
|
|
|
|
//rewrite src and href attrs to use a base url
|
|
if( !$.support.dynamicBaseTag ) {
|
|
var newPath = path.get( fileUrl );
|
|
to.find( "[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]" ).each( function() {
|
|
var attrs = [ "href", "src", "action" ],
|
|
thisAttr = undefined,
|
|
thisUrl = undefined;
|
|
|
|
for (var i = 0; i < attrs.length; i++) {
|
|
var a = attrs[i],
|
|
v = $( this ).attr( a );
|
|
if (v) {
|
|
thisAttr = a;
|
|
thisUrl = v;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( thisAttr && thisUrl ) {
|
|
//if full path exists and is same, chop it - helps IE out
|
|
thisUrl = thisUrl.replace( location.protocol + "//" + location.host + location.pathname, "" );
|
|
|
|
if( ! /^(\w+:|#|\/)/.test( thisUrl ) ) {
|
|
$( this ).attr( thisAttr, newPath + thisUrl );
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
//append to page and enhance
|
|
to
|
|
.attr( "data-" + $.mobile.ns + "url", fileUrl )
|
|
.appendTo( $.mobile.pageContainer );
|
|
|
|
enhancePage();
|
|
setTimeout( function() { transitionPages(); }, 0 );
|
|
},
|
|
error: function() {
|
|
|
|
//remove loading message
|
|
$.mobile.pageLoading( true );
|
|
|
|
//clear out the active button state
|
|
removeActiveLinkClass( true );
|
|
|
|
//set base back to current path
|
|
if( base ) {
|
|
base.set( path.get() );
|
|
}
|
|
|
|
//release transition lock so navigation is free again
|
|
releasePageTransitionLock();
|
|
|
|
//show error message
|
|
$( "<div class='ui-loader ui-overlay-shadow ui-body-e ui-corner-all'><h1>" + $.mobile.pageLoadErrorMessage + "</h1></div>" )
|
|
.css({ "display": "block", "opacity": 0.96, "top": $( window ).scrollTop() + 100 })
|
|
.appendTo( $.mobile.pageContainer )
|
|
.delay( 800 )
|
|
.fadeOut( 400, function() {
|
|
$( this ).remove();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
};
|
|
|
|
/* Event Bindings - hashchange, submit, and click */
|
|
|
|
//bind to form submit events, handle with Ajax
|
|
$( "form" ).live( "submit", function( event ) {
|
|
if( !$.mobile.ajaxEnabled ||
|
|
//TODO: deprecated - remove at 1.0
|
|
!$.mobile.ajaxFormsEnabled ||
|
|
$( this ).is( ":jqmData(ajax='false')" ) ) {
|
|
return;
|
|
}
|
|
|
|
var type = $( this ).attr( "method" ),
|
|
url = path.clean( $( this ).attr( "action" ) ),
|
|
target = $( this ).attr( "target" );
|
|
|
|
//external submits use regular HTTP
|
|
if( path.isExternal( url ) || target ) {
|
|
return;
|
|
}
|
|
|
|
//if it's a relative href, prefix href with base url
|
|
if( path.isRelative( url ) ) {
|
|
url = path.makeAbsolute( url );
|
|
}
|
|
|
|
$.mobile.changePage({
|
|
url: url.length && url || path.get(),
|
|
type: type.length && type.toLowerCase() || "get",
|
|
data: $( this ).serialize()
|
|
},
|
|
$( this ).jqmData( "transition" ),
|
|
$( this ).jqmData( "direction" ),
|
|
true
|
|
);
|
|
event.preventDefault();
|
|
});
|
|
|
|
function findClosestLink( ele ) {
|
|
while ( ele ) {
|
|
if ( ele.nodeName.toLowerCase() === "a" ) {
|
|
break;
|
|
}
|
|
ele = ele.parentNode;
|
|
}
|
|
return ele;
|
|
}
|
|
|
|
//add active state on vclick
|
|
$( document ).bind( "vclick", function( event ) {
|
|
var link = findClosestLink( event.target );
|
|
if ( link ) {
|
|
var url = path.clean( link.getAttribute( "href" ) || "#" );
|
|
if ( url !== "#" && url.replace( path.get(), "" ) !== "#" ) {
|
|
$( link ).closest( ".ui-btn" ).not( ".ui-disabled" ).addClass( $.mobile.activeBtnClass );
|
|
}
|
|
}
|
|
});
|
|
|
|
//click routing - direct to HTTP or Ajax, accordingly
|
|
$( document ).bind( "click", function( event ) {
|
|
var link = findClosestLink( event.target );
|
|
if ( !link ) {
|
|
return;
|
|
}
|
|
|
|
var $link = $( link ),
|
|
|
|
//get href, if defined, otherwise fall to null #
|
|
href = $link.attr( "href" ) || "#",
|
|
|
|
//cache a check for whether the link had a protocol
|
|
//if this is true and the link was same domain, we won't want
|
|
//to prefix the url with a base (esp helpful in IE, where every
|
|
//url is absolute
|
|
hadProtocol = path.hasProtocol( href ),
|
|
|
|
//get href, remove same-domain protocol and host
|
|
url = path.clean( href ),
|
|
|
|
//rel set to external
|
|
isRelExternal = $link.is( "[rel='external']" ),
|
|
|
|
//rel set to external
|
|
isEmbeddedPage = path.isEmbeddedPage( url ),
|
|
|
|
// 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.
|
|
isCrossDomainPageLoad = ( $.mobile.allowCrossDomainPages && location.protocol === "file:" && url.search( /^https?:/ ) !== -1 ),
|
|
|
|
//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 = ( path.isExternal( url ) && !isCrossDomainPageLoad ) || ( isRelExternal && !isEmbeddedPage ),
|
|
|
|
//if target attr is specified we mimic _blank... for now
|
|
hasTarget = $link.is( "[target]" ),
|
|
|
|
//if data-ajax attr is set to false, use the default behavior of a link
|
|
hasAjaxDisabled = $link.is( ":jqmData(ajax='false')" );
|
|
|
|
//if there's a data-rel=back attr, go back in history
|
|
if( $link.is( ":jqmData(rel='back')" ) ) {
|
|
window.history.back();
|
|
return false;
|
|
}
|
|
|
|
//prevent # urls from bubbling
|
|
//path.get() is replaced to combat abs url prefixing in IE
|
|
if( url.replace( path.get(), "" ) === "#" ) {
|
|
//for links created purely for interaction - ignore
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
$activeClickedLink = $link.closest( ".ui-btn" );
|
|
|
|
if( isExternal || hasAjaxDisabled || hasTarget || !$.mobile.ajaxEnabled ||
|
|
// TODO: deprecated - remove at 1.0
|
|
!$.mobile.ajaxLinksEnabled ) {
|
|
//remove active link class if external (then it won't be there if you come back)
|
|
window.setTimeout( function() { removeActiveLinkClass( true ); }, 200 );
|
|
|
|
//use default click handling
|
|
return;
|
|
}
|
|
|
|
//use ajax
|
|
var transition = $link.jqmData( "transition" ),
|
|
direction = $link.jqmData( "direction" ),
|
|
reverse = ( direction && direction === "reverse" ) ||
|
|
// deprecated - remove by 1.0
|
|
$link.jqmData( "back" );
|
|
|
|
//this may need to be more specific as we use data-rel more
|
|
nextPageRole = $link.attr( "data-" + $.mobile.ns + "rel" );
|
|
|
|
//if it's a relative href, prefix href with base url
|
|
if( path.isRelative( url ) && !hadProtocol ) {
|
|
url = path.makeAbsolute( url );
|
|
}
|
|
|
|
url = path.stripHash( url );
|
|
|
|
$.mobile.changePage( url, transition, reverse );
|
|
event.preventDefault();
|
|
});
|
|
|
|
//hashchange event handler
|
|
$window.bind( "hashchange", function( e, triggered ) {
|
|
//find first page via hash
|
|
var to = path.stripHash( location.hash ),
|
|
//transition is false if it's the first page, undefined otherwise (and may be overridden by default)
|
|
transition = $.mobile.urlHistory.stack.length === 0 ? false : undefined;
|
|
|
|
//if listening is disabled (either globally or temporarily), or it's a dialog hash
|
|
if( !$.mobile.hashListeningEnabled || !urlHistory.ignoreNextHashChange ) {
|
|
if( !urlHistory.ignoreNextHashChange ) {
|
|
urlHistory.ignoreNextHashChange = true;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// special case for dialogs
|
|
if( urlHistory.stack.length > 1 && to.indexOf( dialogHashKey ) > -1 ) {
|
|
|
|
// If current active page is not a dialog skip the dialog and continue
|
|
// in the same direction
|
|
if( !$.mobile.activePage.is( ".ui-dialog" ) ) {
|
|
//determine if we're heading forward or backward and continue accordingly past
|
|
//the current dialog
|
|
urlHistory.directHashChange({
|
|
currentUrl: to,
|
|
isBack: function() {
|
|
window.history.back();
|
|
},
|
|
isForward: function() {
|
|
window.history.forward();
|
|
}
|
|
});
|
|
|
|
// prevent changepage
|
|
return;
|
|
} else {
|
|
var setTo = function() {
|
|
to = $.mobile.urlHistory.getActive().page;
|
|
};
|
|
// if the current active page is a dialog and we're navigating
|
|
// to a dialog use the dialog objected saved in the stack
|
|
urlHistory.directHashChange({
|
|
currentUrl: to,
|
|
isBack: setTo,
|
|
isForward: setTo
|
|
});
|
|
}
|
|
}
|
|
|
|
//if to is defined, load it
|
|
if ( to ) {
|
|
$.mobile.changePage( to, transition, undefined, false, true );
|
|
} else {
|
|
//there's no hash, go to the first page in the dom
|
|
$.mobile.changePage( $.mobile.firstPage, transition, true, false, true );
|
|
}
|
|
});
|
|
|
|
})( jQuery );
|