corpus_parole: comparison cms/drupal/modules/overlay/overlay-parent.js

Mercurial Mercurial > corpus_parole / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

cms/drupal/modules/overlay/overlay-parent.js

changeset 541

e756a8c72c3d

equal deleted inserted replaced

-:07239de796bb
+:e756a8c72c3d
+/**
+* @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);

corpus_parole