d7_to_d10_migration/drupal7/web/modules/overlay/overlay-parent.js

1042 lines
38 KiB
JavaScript
Raw Normal View History

2024-07-23 03:38:34 +00:00
/**
* @file
* Attaches the behaviors for the Overlay parent pages.
*/
(function ($) {
/**
* Open the overlay, or load content into it, when an admin link is clicked.
*/
Drupal.behaviors.overlayParent = {
attach: function (context, settings) {
if (Drupal.overlay.isOpen) {
Drupal.overlay.makeDocumentUntabbable(context);
}
if (this.processed) {
return;
}
this.processed = true;
$(window)
// When the hash (URL fragment) changes, open the overlay if needed.
.bind('hashchange.drupal-overlay', $.proxy(Drupal.overlay, 'eventhandlerOperateByURLFragment'))
// Trigger the hashchange handler once, after the page is loaded, so that
// permalinks open the overlay.
.triggerHandler('hashchange.drupal-overlay');
$(document)
// Instead of binding a click event handler to every link we bind one to
// the document and only handle events that bubble up. This allows other
// scripts to bind their own handlers to links and also to prevent
// overlay's handling.
.bind('click.drupal-overlay mouseup.drupal-overlay', $.proxy(Drupal.overlay, 'eventhandlerOverrideLink'));
}
};
/**
* Overlay object for parent windows.
*
* Events
* Overlay triggers a number of events that can be used by other scripts.
* - drupalOverlayOpen: This event is triggered when the overlay is opened.
* - drupalOverlayBeforeClose: This event is triggered when the overlay attempts
* to close. If an event handler returns false, the close will be prevented.
* - drupalOverlayClose: This event is triggered when the overlay is closed.
* - drupalOverlayBeforeLoad: This event is triggered right before a new URL
* is loaded into the overlay.
* - drupalOverlayReady: This event is triggered when the DOM of the overlay
* child document is fully loaded.
* - drupalOverlayLoad: This event is triggered when the overlay is finished
* loading.
* - drupalOverlayResize: This event is triggered when the overlay is being
* resized to match the parent window.
*/
Drupal.overlay = Drupal.overlay || {
isOpen: false,
isOpening: false,
isClosing: false,
isLoading: false
};
Drupal.overlay.prototype = {};
/**
* Open the overlay.
*
* @param url
* The URL of the page to open in the overlay.
*
* @return
* TRUE if the overlay was opened, FALSE otherwise.
*/
Drupal.overlay.open = function (url) {
// Just one overlay is allowed.
if (this.isOpen || this.isOpening) {
return this.load(url);
}
this.isOpening = true;
// Store the original document title.
this.originalTitle = document.title;
// Create the dialog and related DOM elements.
this.create();
this.isOpening = false;
this.isOpen = true;
$(document.documentElement).addClass('overlay-open');
this.makeDocumentUntabbable();
// Allow other scripts to respond to this event.
$(document).trigger('drupalOverlayOpen');
return this.load(url);
};
/**
* Create the underlying markup and behaviors for the overlay.
*/
Drupal.overlay.create = function () {
this.$container = $(Drupal.theme('overlayContainer'))
.appendTo(document.body);
// Overlay uses transparent iframes that cover the full parent window.
// When the overlay is open the scrollbar of the parent window is hidden.
// Because some browsers show a white iframe background for a short moment
// while loading a page into an iframe, overlay uses two iframes. By loading
// the page in a hidden (inactive) iframe the user doesn't see the white
// background. When the page is loaded the active and inactive iframes
// are switched.
this.activeFrame = this.$iframeA = $(Drupal.theme('overlayElement'))
.appendTo(this.$container);
this.inactiveFrame = this.$iframeB = $(Drupal.theme('overlayElement'))
.appendTo(this.$container);
this.$iframeA.bind('load.drupal-overlay', { self: this.$iframeA[0], sibling: this.$iframeB }, $.proxy(this, 'loadChild'));
this.$iframeB.bind('load.drupal-overlay', { self: this.$iframeB[0], sibling: this.$iframeA }, $.proxy(this, 'loadChild'));
// Add a second class "drupal-overlay-open" to indicate these event handlers
// should only be bound when the overlay is open.
var eventClass = '.drupal-overlay.drupal-overlay-open';
$(window)
.bind('resize' + eventClass, $.proxy(this, 'eventhandlerOuterResize'));
$(document)
.bind('drupalOverlayLoad' + eventClass, $.proxy(this, 'eventhandlerOuterResize'))
.bind('drupalOverlayReady' + eventClass +
' drupalOverlayClose' + eventClass, $.proxy(this, 'eventhandlerSyncURLFragment'))
.bind('drupalOverlayClose' + eventClass, $.proxy(this, 'eventhandlerRefreshPage'))
.bind('drupalOverlayBeforeClose' + eventClass +
' drupalOverlayBeforeLoad' + eventClass +
' drupalOverlayResize' + eventClass, $.proxy(this, 'eventhandlerDispatchEvent'));
if ($('.overlay-displace-top, .overlay-displace-bottom').length) {
$(document)
.bind('drupalOverlayResize' + eventClass, $.proxy(this, 'eventhandlerAlterDisplacedElements'))
.bind('drupalOverlayClose' + eventClass, $.proxy(this, 'eventhandlerRestoreDisplacedElements'));
}
};
/**
* Load the given URL into the overlay iframe.
*
* Use this method to change the URL being loaded in the overlay if it is
* already open.
*
* @return
* TRUE if URL is loaded into the overlay, FALSE otherwise.
*/
Drupal.overlay.load = function (url) {
if (!this.isOpen) {
return false;
}
// Allow other scripts to respond to this event.
$(document).trigger('drupalOverlayBeforeLoad');
$(document.documentElement).addClass('overlay-loading');
// The contentDocument property is not supported in IE until IE8.
var iframeDocument = this.inactiveFrame[0].contentDocument || this.inactiveFrame[0].contentWindow.document;
// location.replace doesn't create a history entry. location.href does.
// In this case, we want location.replace, as we're creating the history
// entry using URL fragments.
iframeDocument.location.replace(url);
return true;
};
/**
* Close the overlay and remove markup related to it from the document.
*
* @return
* TRUE if the overlay was closed, FALSE otherwise.
*/
Drupal.overlay.close = function () {
// Prevent double execution when close is requested more than once.
if (!this.isOpen || this.isClosing) {
return false;
}
// Allow other scripts to respond to this event.
var event = $.Event('drupalOverlayBeforeClose');
$(document).trigger(event);
// If a handler returned false, the close will be prevented.
if (event.isDefaultPrevented()) {
return false;
}
this.isClosing = true;
this.isOpen = false;
$(document.documentElement).removeClass('overlay-open');
// Restore the original document title.
document.title = this.originalTitle;
this.makeDocumentTabbable();
// Allow other scripts to respond to this event.
$(document).trigger('drupalOverlayClose');
// When the iframe is still loading don't destroy it immediately but after
// the content is loaded (see Drupal.overlay.loadChild).
if (!this.isLoading) {
this.destroy();
this.isClosing = false;
}
return true;
};
/**
* Destroy the overlay.
*/
Drupal.overlay.destroy = function () {
$([document, window]).unbind('.drupal-overlay-open');
this.$container.remove();
this.$container = null;
this.$iframeA = null;
this.$iframeB = null;
this.iframeWindow = null;
};
/**
* Redirect the overlay parent window to the given URL.
*
* @param url
* Can be an absolute URL or a relative link to the domain root.
*/
Drupal.overlay.redirect = function (url) {
// Create a native Link object, so we can use its object methods.
var link = $(url.link(url)).get(0);
// If the link is already open, force the hashchange event to simulate reload.
if (window.location.href == link.href) {
$(window).triggerHandler('hashchange.drupal-overlay');
}
window.location.href = link.href;
return true;
};
/**
* Bind the child window.
*
* Note that this function is fired earlier than Drupal.overlay.loadChild.
*/
Drupal.overlay.bindChild = function (iframeWindow, isClosing) {
this.iframeWindow = iframeWindow;
// We are done if the child window is closing.
if (isClosing || this.isClosing || !this.isOpen) {
return;
}
// Allow other scripts to respond to this event.
$(document).trigger('drupalOverlayReady');
};
/**
* Event handler: load event handler for the overlay iframe.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: load
* - event.currentTarget: iframe
*/
Drupal.overlay.loadChild = function (event) {
var iframe = event.data.self;
var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
var iframeWindow = iframeDocument.defaultView || iframeDocument.parentWindow;
if (iframeWindow.location == 'about:blank') {
return;
}
this.isLoading = false;
$(document.documentElement).removeClass('overlay-loading');
event.data.sibling.removeClass('overlay-active').attr({ 'tabindex': -1 });
// Only continue when overlay is still open and not closing.
if (this.isOpen && !this.isClosing) {
// And child document is an actual overlayChild.
if (iframeWindow.Drupal && iframeWindow.Drupal.overlayChild) {
// Replace the document title with title of iframe.
document.title = iframeWindow.document.title;
this.activeFrame = $(iframe)
.addClass('overlay-active')
// Add a title attribute to the iframe for accessibility.
.attr('title', Drupal.t('@title dialog', { '@title': iframeWindow.jQuery('#overlay-title').text() })).removeAttr('tabindex');
this.inactiveFrame = event.data.sibling;
// Load an empty document into the inactive iframe.
(this.inactiveFrame[0].contentDocument || this.inactiveFrame[0].contentWindow.document).location.replace('about:blank');
// Move the focus to just before the "skip to main content" link inside
// the overlay.
this.activeFrame.focus();
var skipLink = iframeWindow.jQuery('a:first');
Drupal.overlay.setFocusBefore(skipLink, iframeWindow.document);
// Allow other scripts to respond to this event.
$(document).trigger('drupalOverlayLoad');
}
else {
window.location = iframeWindow.location.href.replace(/([?&]?)render=overlay&?/g, '$1').replace(/\?$/, '');
}
}
else {
this.destroy();
}
};
/**
* Creates a placeholder element to receive document focus.
*
* Setting the document focus to a link will make it visible, even if it's a
* "skip to main content" link that should normally be visible only when the
* user tabs to it. This function can be used to set the document focus to
* just before such an invisible link.
*
* @param $element
* The jQuery element that should receive focus on the next tab press.
* @param document
* The iframe window element to which the placeholder should be added. The
* placeholder element has to be created inside the same iframe as the element
* it precedes, to keep IE happy. (http://bugs.jquery.com/ticket/4059)
*/
Drupal.overlay.setFocusBefore = function ($element, document) {
// Create an anchor inside the placeholder document.
var placeholder = document.createElement('a');
var $placeholder = $(placeholder).addClass('element-invisible').attr('href', '#');
// Put the placeholder where it belongs, and set the document focus to it.
$placeholder.insertBefore($element);
$placeholder.focus();
// Make the placeholder disappear as soon as it loses focus, so that it
// doesn't appear in the tab order again.
$placeholder.one('blur', function () {
$(this).remove();
});
};
/**
* Check if the given link is in the administrative section of the site.
*
* @param url
* The URL to be tested.
*
* @return boolean
* TRUE if the URL represents an administrative link, FALSE otherwise.
*/
Drupal.overlay.isAdminLink = function (url) {
if (!Drupal.urlIsLocal(url)) {
return false;
}
var path = this.getPath(url);
// Turn the list of administrative paths into a regular expression.
if (!this.adminPathRegExp) {
var prefix = '';
if (Drupal.settings.overlay.pathPrefixes.length) {
// Allow path prefixes used for language negatiation followed by slash,
// and the empty string.
prefix = '(' + Drupal.settings.overlay.pathPrefixes.join('/|') + '/|)';
}
var adminPaths = '^' + prefix + '(' + Drupal.settings.overlay.paths.admin.replace(/\s+/g, '|') + ')$';
var nonAdminPaths = '^' + prefix + '(' + Drupal.settings.overlay.paths.non_admin.replace(/\s+/g, '|') + ')$';
adminPaths = adminPaths.replace(/\*/g, '.*');
nonAdminPaths = nonAdminPaths.replace(/\*/g, '.*');
this.adminPathRegExp = new RegExp(adminPaths);
this.nonAdminPathRegExp = new RegExp(nonAdminPaths);
}
return this.adminPathRegExp.exec(path) && !this.nonAdminPathRegExp.exec(path);
};
/**
* Determine whether a link is external to the site.
*
* Deprecated. Use Drupal.urlIsLocal() instead.
*
* @param url
* The URL to be tested.
*
* @return boolean
* TRUE if the URL is external to the site, FALSE otherwise.
*/
Drupal.overlay.isExternalLink = function (url) {
return !Drupal.urlIsLocal(url);
};
/**
* Constructs an internal URL (relative to this site) from the provided path.
*
* For example, if the provided path is 'admin' and the site is installed at
* http://example.com/drupal, this function will return '/drupal/admin'.
*
* @param path
* The internal path, without any leading slash.
*
* @return
* The internal URL derived from the provided path, or null if a valid
* internal path cannot be constructed (for example, if an attempt to create
* an external link is detected).
*/
Drupal.overlay.getInternalUrl = function (path) {
var url = Drupal.settings.basePath + path;
if (Drupal.urlIsLocal(url)) {
return url;
}
};
/**
* Event handler: resizes overlay according to the size of the parent window.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: any
* - event.currentTarget: any
*/
Drupal.overlay.eventhandlerOuterResize = function (event) {
// Proceed only if the overlay still exists.
if (!(this.isOpen || this.isOpening) || this.isClosing || !this.iframeWindow) {
return;
}
// IE6 uses position:absolute instead of position:fixed.
if (typeof document.body.style.maxHeight != 'string') {
this.activeFrame.height($(window).height());
}
// Allow other scripts to respond to this event.
$(document).trigger('drupalOverlayResize');
};
/**
* Event handler: resizes displaced elements so they won't overlap the scrollbar
* of overlay's iframe.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: any
* - event.currentTarget: any
*/
Drupal.overlay.eventhandlerAlterDisplacedElements = function (event) {
// Proceed only if the overlay still exists.
if (!(this.isOpen || this.isOpening) || this.isClosing || !this.iframeWindow) {
return;
}
$(this.iframeWindow.document.body).css({
marginTop: Drupal.overlay.getDisplacement('top'),
marginBottom: Drupal.overlay.getDisplacement('bottom')
})
// IE7 isn't reflowing the document immediately.
// @todo This might be fixed in a cleaner way.
.addClass('overlay-trigger-reflow').removeClass('overlay-trigger-reflow');
var documentHeight = this.iframeWindow.document.body.clientHeight;
var documentWidth = this.iframeWindow.document.body.clientWidth;
// IE6 doesn't support maxWidth, use width instead.
var maxWidthName = (typeof document.body.style.maxWidth == 'string') ? 'maxWidth' : 'width';
if (Drupal.overlay.leftSidedScrollbarOffset === undefined && $(document.documentElement).attr('dir') === 'rtl') {
// We can't use element.clientLeft to detect whether scrollbars are placed
// on the left side of the element when direction is set to "rtl" as most
// browsers dont't support it correctly.
// http://www.gtalbot.org/BugzillaSection/DocumentAllDHTMLproperties.html
// There seems to be absolutely no way to detect whether the scrollbar
// is on the left side in Opera; always expect scrollbar to be on the left.
if ($.browser.opera) {
Drupal.overlay.leftSidedScrollbarOffset = document.documentElement.clientWidth - this.iframeWindow.document.documentElement.clientWidth + this.iframeWindow.document.documentElement.clientLeft;
}
else if (this.iframeWindow.document.documentElement.clientLeft) {
Drupal.overlay.leftSidedScrollbarOffset = this.iframeWindow.document.documentElement.clientLeft;
}
else {
var el1 = $('<div style="direction: rtl; overflow: scroll;"></div>').appendTo(document.body);
var el2 = $('<div></div>').appendTo(el1);
Drupal.overlay.leftSidedScrollbarOffset = parseInt(el2[0].offsetLeft - el1[0].offsetLeft);
el1.remove();
}
}
// Consider any element that should be visible above the overlay (such as
// a toolbar).
$('.overlay-displace-top, .overlay-displace-bottom').each(function () {
var data = $(this).data();
var maxWidth = documentWidth;
// In IE, Shadow filter makes element to overlap the scrollbar with 1px.
if (this.filters && this.filters.length && this.filters.item('DXImageTransform.Microsoft.Shadow')) {
maxWidth -= 1;
}
if (Drupal.overlay.leftSidedScrollbarOffset) {
$(this).css('left', Drupal.overlay.leftSidedScrollbarOffset);
}
// Prevent displaced elements overlapping window's scrollbar.
var currentMaxWidth = parseInt($(this).css(maxWidthName));
if ((data.drupalOverlay && data.drupalOverlay.maxWidth) || isNaN(currentMaxWidth) || currentMaxWidth > maxWidth || currentMaxWidth <= 0) {
$(this).css(maxWidthName, maxWidth);
(data.drupalOverlay = data.drupalOverlay || {}).maxWidth = true;
}
// Use a more rigorous approach if the displaced element still overlaps
// window's scrollbar; clip the element on the right.
var offset = $(this).offset();
var offsetRight = offset.left + $(this).outerWidth();
if ((data.drupalOverlay && data.drupalOverlay.clip) || offsetRight > maxWidth) {
if (Drupal.overlay.leftSidedScrollbarOffset) {
$(this).css('clip', 'rect(auto, auto, ' + (documentHeight - offset.top) + 'px, ' + (Drupal.overlay.leftSidedScrollbarOffset + 2) + 'px)');
}
else {
$(this).css('clip', 'rect(auto, ' + (maxWidth - offset.left) + 'px, ' + (documentHeight - offset.top) + 'px, auto)');
}
(data.drupalOverlay = data.drupalOverlay || {}).clip = true;
}
});
};
/**
* Event handler: restores size of displaced elements as they were before
* overlay was opened.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: any
* - event.currentTarget: any
*/
Drupal.overlay.eventhandlerRestoreDisplacedElements = function (event) {
var $displacedElements = $('.overlay-displace-top, .overlay-displace-bottom');
try {
$displacedElements.css({ maxWidth: '', clip: '' });
}
// IE bug that doesn't allow unsetting style.clip (http://dev.jquery.com/ticket/6512).
catch (err) {
$displacedElements.attr('style', function (index, attr) {
return attr.replace(/clip\s*:\s*rect\([^)]+\);?/i, '');
});
}
};
/**
* Event handler: overrides href of administrative links to be opened in
* the overlay.
*
* This click event handler should be bound to any document (for example the
* overlay iframe) of which you want links to open in the overlay.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: click, mouseup
* - event.currentTarget: document
*
* @see Drupal.overlayChild.behaviors.addClickHandler
*/
Drupal.overlay.eventhandlerOverrideLink = function (event) {
// In some browsers the click event isn't fired for right-clicks. Use the
// mouseup event for right-clicks and the click event for everything else.
if ((event.type == 'click' && event.button == 2) || (event.type == 'mouseup' && event.button != 2)) {
return;
}
var $target = $(event.target);
// Only continue if clicked target (or one of its parents) is a link.
if (!$target.is('a')) {
$target = $target.closest('a');
if (!$target.length) {
return;
}
}
// Never open links in the overlay that contain the overlay-exclude class.
if ($target.hasClass('overlay-exclude')) {
return;
}
// Close the overlay when the link contains the overlay-close class.
if ($target.hasClass('overlay-close')) {
// Clearing the overlay URL fragment will close the overlay.
$.bbq.removeState('overlay');
return;
}
var target = $target[0];
var href = target.href;
// Only handle links that have an href attribute and use the HTTP(S) protocol.
if (href != undefined && href != '' && target.protocol.match(/^https?\:/)) {
var anchor = href.replace(target.ownerDocument.location.href, '');
// Skip anchor links.
if (anchor.length == 0 || anchor.charAt(0) == '#') {
return;
}
// Open admin links in the overlay.
else if (this.isAdminLink(href)) {
// If the link contains the overlay-restore class and the overlay-context
// state is set, also update the parent window's location.
var parentLocation = ($target.hasClass('overlay-restore') && typeof $.bbq.getState('overlay-context') == 'string')
? this.getInternalUrl($.bbq.getState('overlay-context'))
: null;
href = this.fragmentizeLink($target.get(0), parentLocation);
// Only override default behavior when left-clicking and user is not
// pressing the ALT, CTRL, META (Command key on the Macintosh keyboard)
// or SHIFT key.
if (event.button == 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey) {
// Redirect to a fragmentized href. This will trigger a hashchange event.
this.redirect(href);
// Prevent default action and further propagation of the event.
return false;
}
// Otherwise alter clicked link's href. This is being picked up by
// the default action handler.
else {
$target
// Restore link's href attribute on blur or next click.
.one('blur mousedown', { target: target, href: target.href }, function (event) { $(event.data.target).attr('href', event.data.href); })
.attr('href', href);
}
}
// Non-admin links should close the overlay and open in the main window,
// which is the default action for a link. We only need to handle them
// if the overlay is open and the clicked link is inside the overlay iframe.
else if (this.isOpen && target.ownerDocument === this.iframeWindow.document) {
// Open external links in the immediate parent of the frame, unless the
// link already has a different target.
if (target.hostname != window.location.hostname) {
if (!$target.attr('target')) {
$target.attr('target', '_parent');
}
}
else {
// Add the overlay-context state to the link, so "overlay-restore" links
// can restore the context.
if ($target[0].hash) {
// Leave links with an existing fragment alone. Adding an extra
// parameter to a link like "node/1#section-1" breaks the link.
}
else {
// For links with no existing fragment, add the overlay context.
$target.attr('href', $.param.fragment(href, { 'overlay-context': this.getPath(window.location) + window.location.search }));
}
// When the link has a destination query parameter and that destination
// is an admin link we need to fragmentize it. This will make it reopen
// in the overlay.
var params = $.deparam.querystring(href);
if (params.destination && this.isAdminLink(params.destination)) {
var fragmentizedDestination = $.param.fragment(this.getPath(window.location), { overlay: params.destination });
$target.attr('href', $.param.querystring(href, { destination: fragmentizedDestination }));
}
// Make the link open in the immediate parent of the frame, unless the
// link already has a different target.
if (!$target.attr('target')) {
$target.attr('target', '_parent');
}
}
}
}
};
/**
* Event handler: opens or closes the overlay based on the current URL fragment.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: hashchange
* - event.currentTarget: document
*/
Drupal.overlay.eventhandlerOperateByURLFragment = function (event) {
// If we changed the hash to reflect an internal redirect in the overlay,
// its location has already been changed, so don't do anything.
if ($.data(window.location, window.location.href) === 'redirect') {
$.data(window.location, window.location.href, null);
return;
}
// Get the overlay URL from the current URL fragment.
var internalUrl = null;
var state = $.bbq.getState('overlay');
if (state) {
internalUrl = this.getInternalUrl(state);
}
if (internalUrl) {
// Append render variable, so the server side can choose the right
// rendering and add child frame code to the page if needed.
var url = $.param.querystring(internalUrl, { render: 'overlay' });
this.open(url);
this.resetActiveClass(this.getPath(Drupal.settings.basePath + state));
}
// If there is no overlay URL in the fragment and the overlay is (still)
// open, close the overlay.
else if (this.isOpen && !this.isClosing) {
this.close();
this.resetActiveClass(this.getPath(window.location));
}
};
/**
* Event handler: makes sure the internal overlay URL is reflected in the parent
* URL fragment.
*
* Normally the parent URL fragment determines the overlay location. However, if
* the overlay redirects internally, the parent doesn't get informed, and the
* parent URL fragment will be out of date. This is a sanity check to make
* sure we're in the right place.
*
* The parent URL fragment is also not updated automatically when overlay's
* open, close or load functions are used directly (instead of through
* eventhandlerOperateByURLFragment).
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: drupalOverlayReady, drupalOverlayClose
* - event.currentTarget: document
*/
Drupal.overlay.eventhandlerSyncURLFragment = function (event) {
if (this.isOpen) {
var expected = $.bbq.getState('overlay');
// This is just a sanity check, so we're comparing paths, not query strings.
if (this.getPath(Drupal.settings.basePath + expected) != this.getPath(this.iframeWindow.document.location)) {
// There may have been a redirect inside the child overlay window that the
// parent wasn't aware of. Update the parent URL fragment appropriately.
var newLocation = Drupal.overlay.fragmentizeLink(this.iframeWindow.document.location);
// Set a 'redirect' flag on the new location so the hashchange event handler
// knows not to change the overlay's content.
$.data(window.location, newLocation, 'redirect');
// Use location.replace() so we don't create an extra history entry.
window.location.replace(newLocation);
}
}
else {
$.bbq.removeState('overlay');
}
};
/**
* Event handler: if the child window suggested that the parent refresh on
* close, force a page refresh.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: drupalOverlayClose
* - event.currentTarget: document
*/
Drupal.overlay.eventhandlerRefreshPage = function (event) {
if (Drupal.overlay.refreshPage) {
window.location.reload(true);
}
};
/**
* Event handler: dispatches events to the overlay document.
*
* @param event
* Event being triggered, with the following restrictions:
* - event.type: any
* - event.currentTarget: any
*/
Drupal.overlay.eventhandlerDispatchEvent = function (event) {
if (this.iframeWindow && this.iframeWindow.document) {
this.iframeWindow.jQuery(this.iframeWindow.document).trigger(event);
}
};
/**
* Make a regular admin link into a URL that will trigger the overlay to open.
*
* @param link
* A JavaScript Link object (i.e. an <a> element).
* @param parentLocation
* (optional) URL to override the parent window's location with.
*
* @return
* A URL that will trigger the overlay (in the form
* /node/1#overlay=admin/config).
*/
Drupal.overlay.fragmentizeLink = function (link, parentLocation) {
// Don't operate on links that are already overlay-ready.
var params = $.deparam.fragment(link.href);
if (params.overlay) {
return link.href;
}
// Determine the link's original destination. Set ignorePathFromQueryString to
// true to prevent transforming this link into a clean URL while clean URLs
// may be disabled.
var path = this.getPath(link, true);
// Preserve existing query and fragment parameters in the URL, except for
// "render=overlay" which is re-added in Drupal.overlay.eventhandlerOperateByURLFragment.
var destination = path + link.search.replace(/&?render=overlay/, '').replace(/\?$/, '') + link.hash;
// Assemble and return the overlay-ready link.
return $.param.fragment(parentLocation || window.location.href, { overlay: destination });
};
/**
* Refresh any regions of the page that are displayed outside the overlay.
*
* @param data
* An array of objects with information on the page regions to be refreshed.
* For each object, the key is a CSS class identifying the region to be
* refreshed, and the value represents the section of the Drupal $page array
* corresponding to this region.
*/
Drupal.overlay.refreshRegions = function (data) {
$.each(data, function () {
var region_info = this;
$.each(region_info, function (regionClass) {
var regionName = region_info[regionClass];
var regionSelector = '.' + regionClass;
// Allow special behaviors to detach.
Drupal.detachBehaviors($(regionSelector));
$.get(Drupal.settings.basePath + Drupal.settings.overlay.ajaxCallback + '/' + regionName, function (newElement) {
$(regionSelector).replaceWith($(newElement));
Drupal.attachBehaviors($(regionSelector), Drupal.settings);
});
});
});
};
/**
* Reset the active class on links in displaced elements according to
* given path.
*
* @param activePath
* Path to match links against.
*/
Drupal.overlay.resetActiveClass = function(activePath) {
var self = this;
var windowDomain = window.location.protocol + window.location.hostname;
$('.overlay-displace-top, .overlay-displace-bottom')
.find('a[href]')
// Remove active class from all links in displaced elements.
.removeClass('active')
// Add active class to links that match activePath.
.each(function () {
var linkDomain = this.protocol + this.hostname;
var linkPath = self.getPath(this);
// A link matches if it is part of the active trail of activePath, except
// for frontpage links.
if (linkDomain == windowDomain && (activePath + '/').indexOf(linkPath + '/') === 0 && (linkPath !== '' || activePath === '')) {
$(this).addClass('active');
}
});
};
/**
* Helper function to get the (corrected) Drupal path of a link.
*
* @param link
* Link object or string to get the Drupal path from.
* @param ignorePathFromQueryString
* Boolean whether to ignore path from query string if path appears empty.
*
* @return
* The Drupal path.
*/
Drupal.overlay.getPath = function (link, ignorePathFromQueryString) {
if (typeof link == 'string') {
// Create a native Link object, so we can use its object methods.
link = $(link.link(link)).get(0);
}
var path = link.pathname;
// Ensure a leading slash on the path, omitted in some browsers.
if (path.charAt(0) != '/') {
path = '/' + path;
}
path = path.replace(new RegExp(Drupal.settings.basePath + '(?:index.php)?'), '');
if (path == '' && !ignorePathFromQueryString) {
// If the path appears empty, it might mean the path is represented in the
// query string (clean URLs are not used).
var match = new RegExp('([?&])q=(.+)([&#]|$)').exec(link.search);
if (match && match.length == 4) {
path = match[2];
}
}
return path;
};
/**
* Get the total displacement of given region.
*
* @param region
* Region name. Either "top" or "bottom".
*
* @return
* The total displacement of given region in pixels.
*/
Drupal.overlay.getDisplacement = function (region) {
var displacement = 0;
var lastDisplaced = $('.overlay-displace-' + region + ':last');
if (lastDisplaced.length) {
displacement = lastDisplaced.offset().top + lastDisplaced.outerHeight();
// In modern browsers (including IE9), when box-shadow is defined, use the
// normal height.
var cssBoxShadowValue = lastDisplaced.css('box-shadow');
var boxShadow = (typeof cssBoxShadowValue !== 'undefined' && cssBoxShadowValue !== 'none');
// In IE8 and below, we use the shadow filter to apply box-shadow styles to
// the toolbar. It adds some extra height that we need to remove.
if (!boxShadow && /DXImageTransform\.Microsoft\.Shadow/.test(lastDisplaced.css('filter'))) {
displacement -= lastDisplaced[0].filters.item('DXImageTransform.Microsoft.Shadow').strength;
displacement = Math.max(0, displacement);
}
}
return displacement;
};
/**
* Makes elements outside the overlay unreachable via the tab key.
*
* @param context
* The part of the DOM that should have its tabindexes changed. Defaults to
* the entire page.
*/
Drupal.overlay.makeDocumentUntabbable = function (context) {
// Manipulating tabindexes for the entire document is unacceptably slow in IE6
// and IE7, so in those browsers, the underlying page will still be reachable
// via the tab key. However, we still make the links within the Disable
// message unreachable, because the same message also exists within the
// child document. The duplicate copy in the underlying document is only for
// assisting screen-reader users navigating the document with reading commands
// that follow markup order rather than tab order.
if (jQuery.browser.msie && parseInt(jQuery.browser.version, 10) < 8) {
$('#overlay-disable-message a', context).attr('tabindex', -1);
return;
}
context = context || document.body;
var $overlay, $tabbable, $hasTabindex;
// Determine which elements on the page already have a tabindex.
$hasTabindex = $('[tabindex] :not(.overlay-element)', context);
// Record the tabindex for each element, so we can restore it later.
$hasTabindex.each(Drupal.overlay._recordTabindex);
// Add the tabbable elements from the current context to any that we might
// have previously recorded.
Drupal.overlay._hasTabindex = $hasTabindex.add(Drupal.overlay._hasTabindex);
// Set tabindex to -1 on everything outside the overlay and toolbars, so that
// the underlying page is unreachable.
// By default, browsers make a, area, button, input, object, select, textarea,
// and iframe elements reachable via the tab key.
$tabbable = $('a, area, button, input, object, select, textarea, iframe');
// If another element (like a div) has a tabindex, it's also tabbable.
$tabbable = $tabbable.add($hasTabindex);
// Leave links inside the overlay and toolbars alone.
$overlay = $('.overlay-element, #overlay-container, .overlay-displace-top, .overlay-displace-bottom').find('*');
$tabbable = $tabbable.not($overlay);
// We now have a list of everything in the underlying document that could
// possibly be reachable via the tab key. Make it all unreachable.
$tabbable.attr('tabindex', -1);
};
/**
* Restores the original tabindex value of a group of elements.
*
* @param context
* The part of the DOM that should have its tabindexes restored. Defaults to
* the entire page.
*/
Drupal.overlay.makeDocumentTabbable = function (context) {
// Manipulating tabindexes is unacceptably slow in IE6 and IE7. In those
// browsers, the underlying page was never made unreachable via tab, so
// there is no work to be done here.
if (jQuery.browser.msie && parseInt(jQuery.browser.version, 10) < 8) {
return;
}
var $needsTabindex;
context = context || document.body;
// Make the underlying document tabbable again by removing all existing
// tabindex attributes.
var $tabindex = $('[tabindex]', context);
if (jQuery.browser.msie && parseInt(jQuery.browser.version, 10) < 8) {
// removeAttr('tabindex') is broken in IE6-7, but the DOM function
// removeAttribute works.
var i;
var length = $tabindex.length;
for (i = 0; i < length; i++) {
$tabindex[i].removeAttribute('tabIndex');
}
}
else {
$tabindex.removeAttr('tabindex');
}
// Restore the tabindex attributes that existed before the overlay was opened.
$needsTabindex = $(Drupal.overlay._hasTabindex, context);
$needsTabindex.each(Drupal.overlay._restoreTabindex);
Drupal.overlay._hasTabindex = Drupal.overlay._hasTabindex.not($needsTabindex);
};
/**
* Record the tabindex for an element, using $.data.
*
* Meant to be used as a jQuery.fn.each callback.
*/
Drupal.overlay._recordTabindex = function () {
var $element = $(this);
var tabindex = $(this).attr('tabindex');
$element.data('drupalOverlayOriginalTabIndex', tabindex);
};
/**
* Restore an element's original tabindex.
*
* Meant to be used as a jQuery.fn.each callback.
*/
Drupal.overlay._restoreTabindex = function () {
var $element = $(this);
var tabindex = $element.data('drupalOverlayOriginalTabIndex');
$element.attr('tabindex', tabindex);
};
/**
* Theme function to create the overlay iframe element.
*/
Drupal.theme.prototype.overlayContainer = function () {
return '<div id="overlay-container"><div class="overlay-modal-background"></div></div>';
};
/**
* Theme function to create an overlay iframe element.
*/
Drupal.theme.prototype.overlayElement = function (url) {
return '<iframe class="overlay-element" frameborder="0" scrolling="auto" allowtransparency="true"></iframe>';
};
})(jQuery);