upgrade to OpenPublish 7.x-1.0-alpha9
[eupraxis:fsrn.git] / openpublish / modules / overlay / overlay-parent.js
1 (function ($) {
2
3 /**
4  * Open the overlay, or load content into it, when an admin link is clicked.
5  */
6 Drupal.behaviors.overlayParent = {
7   attach: function (context, settings) {
8     if (Drupal.overlay.isOpen) {
9       Drupal.overlay.makeDocumentUntabbable(context);
10     }
11
12     if (this.processed) {
13       return;
14     }
15     this.processed = true;
16
17     $(window)
18       // When the hash (URL fragment) changes, open the overlay if needed.
19       .bind('hashchange.drupal-overlay', $.proxy(Drupal.overlay, 'eventhandlerOperateByURLFragment'))
20       // Trigger the hashchange handler once, after the page is loaded, so that
21       // permalinks open the overlay.
22       .triggerHandler('hashchange.drupal-overlay');
23
24     $(document)
25       // Instead of binding a click event handler to every link we bind one to
26       // the document and only handle events that bubble up. This allows other
27       // scripts to bind their own handlers to links and also to prevent
28       // overlay's handling.
29       .bind('click.drupal-overlay mouseup.drupal-overlay', $.proxy(Drupal.overlay, 'eventhandlerOverrideLink'));
30   }
31 };
32
33 /**
34  * Overlay object for parent windows.
35  *
36  * Events
37  * Overlay triggers a number of events that can be used by other scripts.
38  * - drupalOverlayOpen: This event is triggered when the overlay is opened.
39  * - drupalOverlayBeforeClose: This event is triggered when the overlay attempts
40  *   to close. If an event handler returns false, the close will be prevented.
41  * - drupalOverlayClose: This event is triggered when the overlay is closed.
42  * - drupalOverlayBeforeLoad: This event is triggered right before a new URL
43  *   is loaded into the overlay.
44  * - drupalOverlayReady: This event is triggered when the DOM of the overlay
45  *   child document is fully loaded.
46  * - drupalOverlayLoad: This event is triggered when the overlay is finished
47  *   loading.
48  * - drupalOverlayResize: This event is triggered when the overlay is being
49  *   resized to match the parent window.
50  */
51 Drupal.overlay = Drupal.overlay || {
52   isOpen: false,
53   isOpening: false,
54   isClosing: false,
55   isLoading: false
56 };
57
58 Drupal.overlay.prototype = {};
59
60 /**
61  * Open the overlay.
62  *
63  * @param url
64  *   The URL of the page to open in the overlay.
65  *
66  * @return
67  *   TRUE if the overlay was opened, FALSE otherwise.
68  */
69 Drupal.overlay.open = function (url) {
70   // Just one overlay is allowed.
71   if (this.isOpen || this.isOpening) {
72     return this.load(url);
73   }
74   this.isOpening = true;
75   // Store the original document title.
76   this.originalTitle = document.title;
77
78   // Create the dialog and related DOM elements.
79   this.create();
80
81   this.isOpening = false;
82   this.isOpen = true;
83   $(document.documentElement).addClass('overlay-open');
84   this.makeDocumentUntabbable();
85
86   // Allow other scripts to respond to this event.
87   $(document).trigger('drupalOverlayOpen');
88
89   return this.load(url);
90 };
91
92 /**
93  * Create the underlying markup and behaviors for the overlay.
94  */
95 Drupal.overlay.create = function () {
96   this.$container = $(Drupal.theme('overlayContainer'))
97     .appendTo(document.body);
98
99   // Overlay uses transparent iframes that cover the full parent window.
100   // When the overlay is open the scrollbar of the parent window is hidden.
101   // Because some browsers show a white iframe background for a short moment
102   // while loading a page into an iframe, overlay uses two iframes. By loading
103   // the page in a hidden (inactive) iframe the user doesn't see the white
104   // background. When the page is loaded the active and inactive iframes
105   // are switched.
106   this.activeFrame = this.$iframeA = $(Drupal.theme('overlayElement'))
107     .appendTo(this.$container);
108
109   this.inactiveFrame = this.$iframeB = $(Drupal.theme('overlayElement'))
110     .appendTo(this.$container);
111
112   this.$iframeA.bind('load.drupal-overlay', { self: this.$iframeA[0], sibling: this.$iframeB }, $.proxy(this, 'loadChild'));
113   this.$iframeB.bind('load.drupal-overlay', { self: this.$iframeB[0], sibling: this.$iframeA }, $.proxy(this, 'loadChild'));
114
115   // Add a second class "drupal-overlay-open" to indicate these event handlers
116   // should only be bound when the overlay is open.
117   var eventClass = '.drupal-overlay.drupal-overlay-open';
118   $(window)
119     .bind('resize' + eventClass, $.proxy(this, 'eventhandlerOuterResize'));
120   $(document)
121     .bind('drupalOverlayLoad' + eventClass, $.proxy(this, 'eventhandlerOuterResize'))
122     .bind('drupalOverlayReady' + eventClass +
123           ' drupalOverlayClose' + eventClass, $.proxy(this, 'eventhandlerSyncURLFragment'))
124     .bind('drupalOverlayClose' + eventClass, $.proxy(this, 'eventhandlerRefreshPage'))
125     .bind('drupalOverlayBeforeClose' + eventClass +
126           ' drupalOverlayBeforeLoad' + eventClass +
127           ' drupalOverlayResize' + eventClass, $.proxy(this, 'eventhandlerDispatchEvent'));
128
129   if ($('.overlay-displace-top, .overlay-displace-bottom').length) {
130     $(document)
131       .bind('drupalOverlayResize' + eventClass, $.proxy(this, 'eventhandlerAlterDisplacedElements'))
132       .bind('drupalOverlayClose' + eventClass, $.proxy(this, 'eventhandlerRestoreDisplacedElements'));
133   }
134 };
135
136 /**
137  * Load the given URL into the overlay iframe.
138  *
139  * Use this method to change the URL being loaded in the overlay if it is
140  * already open.
141  *
142  * @return
143  *   TRUE if URL is loaded into the overlay, FALSE otherwise.
144  */
145 Drupal.overlay.load = function (url) {
146   if (!this.isOpen) {
147     return false;
148   }
149
150   // Allow other scripts to respond to this event.
151   $(document).trigger('drupalOverlayBeforeLoad');
152
153   $(document.documentElement).addClass('overlay-loading');
154
155   // The contentDocument property is not supported in IE until IE8.
156   var iframeDocument = this.inactiveFrame[0].contentDocument || this.inactiveFrame[0].contentWindow.document;
157
158   // location.replace doesn't create a history entry. location.href does.
159   // In this case, we want location.replace, as we're creating the history
160   // entry using URL fragments.
161   iframeDocument.location.replace(url);
162
163   return true;
164 };
165
166 /**
167  * Close the overlay and remove markup related to it from the document.
168  *
169  * @return
170  *   TRUE if the overlay was closed, FALSE otherwise.
171  */
172 Drupal.overlay.close = function () {
173   // Prevent double execution when close is requested more than once.
174   if (!this.isOpen || this.isClosing) {
175     return false;
176   }
177
178   // Allow other scripts to respond to this event.
179   var event = $.Event('drupalOverlayBeforeClose');
180   $(document).trigger(event);
181   // If a handler returned false, the close will be prevented.
182   if (event.isDefaultPrevented()) {
183     return false;
184   }
185
186   this.isClosing = true;
187   this.isOpen = false;
188   $(document.documentElement).removeClass('overlay-open');
189   // Restore the original document title.
190   document.title = this.originalTitle;
191   this.makeDocumentTabbable();
192
193   // Allow other scripts to respond to this event.
194   $(document).trigger('drupalOverlayClose');
195
196   // When the iframe is still loading don't destroy it immediately but after
197   // the content is loaded (see Drupal.overlay.loadChild).
198   if (!this.isLoading) {
199     this.destroy();
200     this.isClosing = false;
201   }
202   return true;
203 };
204
205 /**
206  * Destroy the overlay.
207  */
208 Drupal.overlay.destroy = function () {
209   $([document, window]).unbind('.drupal-overlay-open');
210   this.$container.remove();
211
212   this.$container = null;
213   this.$iframeA = null;
214   this.$iframeB = null;
215
216   this.iframeWindow = null;
217 };
218
219 /**
220  * Redirect the overlay parent window to the given URL.
221  *
222  * @param url
223  *   Can be an absolute URL or a relative link to the domain root.
224  */
225 Drupal.overlay.redirect = function (url) {
226   // Create a native Link object, so we can use its object methods.
227   var link = $(url.link(url)).get(0);
228
229   // If the link is already open, force the hashchange event to simulate reload.
230   if (window.location.href == link.href) {
231     $(window).triggerHandler('hashchange.drupal-overlay');
232   }
233
234   window.location.href = link.href;
235   return true;
236 };
237
238 /**
239  * Bind the child window.
240  *
241  * Note that this function is fired earlier than Drupal.overlay.loadChild.
242  */
243 Drupal.overlay.bindChild = function (iframeWindow, isClosing) {
244   this.iframeWindow = iframeWindow;
245
246   // We are done if the child window is closing.
247   if (isClosing || this.isClosing || !this.isOpen) {
248     return;
249   }
250
251   // Allow other scripts to respond to this event.
252   $(document).trigger('drupalOverlayReady');
253 };
254
255 /**
256  * Event handler: load event handler for the overlay iframe.
257  *
258  * @param event
259  *   Event being triggered, with the following restrictions:
260  *   - event.type: load
261  *   - event.currentTarget: iframe
262  */
263 Drupal.overlay.loadChild = function (event) {
264   var iframe = event.data.self;
265   var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
266   var iframeWindow = iframeDocument.defaultView || iframeDocument.parentWindow;
267   if (iframeWindow.location == 'about:blank') {
268     return;
269   }
270
271   this.isLoading = false;
272   $(document.documentElement).removeClass('overlay-loading');
273   event.data.sibling.removeClass('overlay-active').attr({ 'tabindex': -1 });
274
275   // Only continue when overlay is still open and not closing.
276   if (this.isOpen && !this.isClosing) {
277     // And child document is an actual overlayChild.
278     if (iframeWindow.Drupal && iframeWindow.Drupal.overlayChild) {
279       // Replace the document title with title of iframe.
280       document.title = iframeWindow.document.title;
281
282       this.activeFrame = $(iframe)
283         .addClass('overlay-active')
284         // Add a title attribute to the iframe for accessibility.
285         .attr('title', Drupal.t('@title dialog', { '@title': iframeWindow.jQuery('#overlay-title').text() })).removeAttr('tabindex');
286       this.inactiveFrame = event.data.sibling;
287
288       // Load an empty document into the inactive iframe.
289       (this.inactiveFrame[0].contentDocument || this.inactiveFrame[0].contentWindow.document).location.replace('about:blank');
290
291       // Move the focus to just before the "skip to main content" link inside
292       // the overlay.
293       this.activeFrame.focus();
294       var skipLink = iframeWindow.jQuery('a:first');
295       Drupal.overlay.setFocusBefore(skipLink, iframeWindow.document);
296
297       // Allow other scripts to respond to this event.
298       $(document).trigger('drupalOverlayLoad');
299     }
300     else {
301       window.location = iframeWindow.location.href.replace(/([?&]?)render=overlay&?/g, '$1').replace(/\?$/, '');
302     }
303   }
304   else {
305     this.destroy();
306   }
307 };
308
309 /**
310  * Creates a placeholder element to receive document focus.
311  *
312  * Setting the document focus to a link will make it visible, even if it's a
313  * "skip to main content" link that should normally be visible only when the
314  * user tabs to it. This function can be used to set the document focus to
315  * just before such an invisible link.
316  *
317  * @param $element
318  *   The jQuery element that should receive focus on the next tab press.
319  * @param document
320  *   The iframe window element to which the placeholder should be added. The
321  *   placeholder element has to be created inside the same iframe as the element
322  *   it precedes, to keep IE happy. (http://bugs.jquery.com/ticket/4059)
323  */
324 Drupal.overlay.setFocusBefore = function ($element, document) {
325   // Create an anchor inside the placeholder document.
326   var placeholder = document.createElement('a');
327   var $placeholder = $(placeholder).addClass('element-invisible').attr('href', '#');
328   // Put the placeholder where it belongs, and set the document focus to it.
329   $placeholder.insertBefore($element);
330   $placeholder.focus();
331   // Make the placeholder disappear as soon as it loses focus, so that it
332   // doesn't appear in the tab order again.
333   $placeholder.one('blur', function () {
334     $(this).remove();
335   });
336 };
337
338 /**
339  * Check if the given link is in the administrative section of the site.
340  *
341  * @param url
342  *   The url to be tested.
343  *
344  * @return boolean
345  *   TRUE if the URL represents an administrative link, FALSE otherwise.
346  */
347 Drupal.overlay.isAdminLink = function (url) {
348   if (Drupal.overlay.isExternalLink(url)) {
349     return false;
350   }
351
352   var path = this.getPath(url);
353
354   // Turn the list of administrative paths into a regular expression.
355   if (!this.adminPathRegExp) {
356     var prefix = '';
357     if (Drupal.settings.overlay.pathPrefixes.length) {
358       // Allow path prefixes used for language negatiation followed by slash,
359       // and the empty string.
360       prefix = '(' + Drupal.settings.overlay.pathPrefixes.join('/|') + '/|)';
361     }
362     var adminPaths = '^' + prefix + '(' + Drupal.settings.overlay.paths.admin.replace(/\s+/g, '|') + ')$';
363     var nonAdminPaths = '^' + prefix + '(' + Drupal.settings.overlay.paths.non_admin.replace(/\s+/g, '|') + ')$';
364     adminPaths = adminPaths.replace(/\*/g, '.*');
365     nonAdminPaths = nonAdminPaths.replace(/\*/g, '.*');
366     this.adminPathRegExp = new RegExp(adminPaths);
367     this.nonAdminPathRegExp = new RegExp(nonAdminPaths);
368   }
369
370   return this.adminPathRegExp.exec(path) && !this.nonAdminPathRegExp.exec(path);
371 };
372
373 /**
374  * Determine whether a link is external to the site.
375  *
376  * @param url
377  *   The url to be tested.
378  *
379  * @return boolean
380  *   TRUE if the URL is external to the site, FALSE otherwise.
381  */
382 Drupal.overlay.isExternalLink = function (url) {
383   var re = RegExp('^((f|ht)tps?:)?//(?!' + window.location.host + ')');
384   return re.test(url);
385 };
386
387 /**
388  * Event handler: resizes overlay according to the size of the parent window.
389  *
390  * @param event
391  *   Event being triggered, with the following restrictions:
392  *   - event.type: any
393  *   - event.currentTarget: any
394  */
395 Drupal.overlay.eventhandlerOuterResize = function (event) {
396   // Proceed only if the overlay still exists.
397   if (!(this.isOpen || this.isOpening) || this.isClosing || !this.iframeWindow) {
398     return;
399   }
400
401   // IE6 uses position:absolute instead of position:fixed.
402   if (typeof document.body.style.maxHeight != 'string') {
403     this.activeFrame.height($(window).height());
404   }
405
406   // Allow other scripts to respond to this event.
407   $(document).trigger('drupalOverlayResize');
408 };
409
410 /**
411  * Event handler: resizes displaced elements so they won't overlap the scrollbar
412  * of overlay's iframe.
413  *
414  * @param event
415  *   Event being triggered, with the following restrictions:
416  *   - event.type: any
417  *   - event.currentTarget: any
418  */
419 Drupal.overlay.eventhandlerAlterDisplacedElements = function (event) {
420   // Proceed only if the overlay still exists.
421   if (!(this.isOpen || this.isOpening) || this.isClosing || !this.iframeWindow) {
422     return;
423   }
424
425   $(this.iframeWindow.document.body).css({
426     marginTop: Drupal.overlay.getDisplacement('top'),
427     marginBottom: Drupal.overlay.getDisplacement('bottom')
428   })
429   // IE7 isn't reflowing the document immediately.
430   // @todo This might be fixed in a cleaner way.
431   .addClass('overlay-trigger-reflow').removeClass('overlay-trigger-reflow');
432
433   var documentHeight = this.iframeWindow.document.body.clientHeight;
434   var documentWidth = this.iframeWindow.document.body.clientWidth;
435   // IE6 doesn't support maxWidth, use width instead.
436   var maxWidthName = (typeof document.body.style.maxWidth == 'string') ? 'maxWidth' : 'width';
437
438   if (Drupal.overlay.leftSidedScrollbarOffset === undefined && $(document.documentElement).attr('dir') === 'rtl') {
439     // We can't use element.clientLeft to detect whether scrollbars are placed
440     // on the left side of the element when direction is set to "rtl" as most
441     // browsers dont't support it correctly.
442     // http://www.gtalbot.org/BugzillaSection/DocumentAllDHTMLproperties.html
443     // There seems to be absolutely no way to detect whether the scrollbar
444     // is on the left side in Opera; always expect scrollbar to be on the left.
445     if ($.browser.opera) {
446       Drupal.overlay.leftSidedScrollbarOffset = document.documentElement.clientWidth - this.iframeWindow.document.documentElement.clientWidth + this.iframeWindow.document.documentElement.clientLeft;
447     }
448     else if (this.iframeWindow.document.documentElement.clientLeft) {
449       Drupal.overlay.leftSidedScrollbarOffset = this.iframeWindow.document.documentElement.clientLeft;
450     }
451     else {
452       var el1 = $('<div style="direction: rtl; overflow: scroll;"></div>').appendTo(document.body);
453       var el2 = $('<div></div>').appendTo(el1);
454       Drupal.overlay.leftSidedScrollbarOffset = parseInt(el2[0].offsetLeft - el1[0].offsetLeft);
455       el1.remove();
456     }
457   }
458
459   // Consider any element that should be visible above the overlay (such as
460   // a toolbar).
461   $('.overlay-displace-top, .overlay-displace-bottom').each(function () {
462     var data = $(this).data();
463     var maxWidth = documentWidth;
464     // In IE, Shadow filter makes element to overlap the scrollbar with 1px.
465     if (this.filters && this.filters.length && this.filters.item('DXImageTransform.Microsoft.Shadow')) {
466       maxWidth -= 1;
467     }
468
469     if (Drupal.overlay.leftSidedScrollbarOffset) {
470       $(this).css('left', Drupal.overlay.leftSidedScrollbarOffset);
471     }
472
473     // Prevent displaced elements overlapping window's scrollbar.
474     var currentMaxWidth = parseInt($(this).css(maxWidthName));
475     if ((data.drupalOverlay && data.drupalOverlay.maxWidth) || isNaN(currentMaxWidth) || currentMaxWidth > maxWidth || currentMaxWidth <= 0) {
476       $(this).css(maxWidthName, maxWidth);
477       (data.drupalOverlay = data.drupalOverlay || {}).maxWidth = true;
478     }
479
480     // Use a more rigorous approach if the displaced element still overlaps
481     // window's scrollbar; clip the element on the right.
482     var offset = $(this).offset();
483     var offsetRight = offset.left + $(this).outerWidth();
484     if ((data.drupalOverlay && data.drupalOverlay.clip) || offsetRight > maxWidth) {
485       if (Drupal.overlay.leftSidedScrollbarOffset) {
486         $(this).css('clip', 'rect(auto, auto, ' + (documentHeight - offset.top) + 'px, ' + (Drupal.overlay.leftSidedScrollbarOffset + 2) + 'px)');
487       }
488       else {
489         $(this).css('clip', 'rect(auto, ' + (maxWidth - offset.left) + 'px, ' + (documentHeight - offset.top) + 'px, auto)');
490       }
491       (data.drupalOverlay = data.drupalOverlay || {}).clip = true;
492     }
493   });
494 };
495
496 /**
497  * Event handler: restores size of displaced elements as they were before
498  * overlay was opened.
499  *
500  * @param event
501  *   Event being triggered, with the following restrictions:
502  *   - event.type: any
503  *   - event.currentTarget: any
504  */
505 Drupal.overlay.eventhandlerRestoreDisplacedElements = function (event) {
506   var $displacedElements = $('.overlay-displace-top, .overlay-displace-bottom');
507   try {
508     $displacedElements.css({ maxWidth: '', clip: '' });
509   }
510   // IE bug that doesn't allow unsetting style.clip (http://dev.jquery.com/ticket/6512).
511   catch (err) {
512     $displacedElements.attr('style', function (index, attr) {
513       return attr.replace(/clip\s*:\s*rect\([^)]+\);?/i, '');
514     });
515   }
516 };
517
518 /**
519  * Event handler: overrides href of administrative links to be opened in
520  * the overlay.
521  *
522  * This click event handler should be bound to any document (for example the
523  * overlay iframe) of which you want links to open in the overlay.
524  *
525  * @param event
526  *   Event being triggered, with the following restrictions:
527  *   - event.type: click, mouseup
528  *   - event.currentTarget: document
529  *
530  * @see Drupal.overlayChild.behaviors.addClickHandler
531  */
532 Drupal.overlay.eventhandlerOverrideLink = function (event) {
533   // In some browsers the click event isn't fired for right-clicks. Use the
534   // mouseup event for right-clicks and the click event for everything else.
535   if ((event.type == 'click' && event.button == 2) || (event.type == 'mouseup' && event.button != 2)) {
536     return;
537   }
538
539   var $target = $(event.target);
540
541   // Only continue if clicked target (or one of its parents) is a link.
542   if (!$target.is('a')) {
543     $target = $target.closest('a');
544     if (!$target.length) {
545       return;
546     }
547   }
548
549   // Never open links in the overlay that contain the overlay-exclude class.
550   if ($target.hasClass('overlay-exclude')) {
551     return;
552   }
553
554   // Close the overlay when the link contains the overlay-close class.
555   if ($target.hasClass('overlay-close')) {
556     // Clearing the overlay URL fragment will close the overlay.
557     $.bbq.removeState('overlay');
558     return;
559   }
560
561   var target = $target[0];
562   var href = target.href;
563   // Only handle links that have an href attribute and use the http(s) protocol.
564   if (href != undefined && href != '' && target.protocol.match(/^https?\:/)) {
565     var anchor = href.replace(target.ownerDocument.location.href, '');
566     // Skip anchor links.
567     if (anchor.length == 0 || anchor.charAt(0) == '#') {
568       return;
569     }
570     // Open admin links in the overlay.
571     else if (this.isAdminLink(href)) {
572       // If the link contains the overlay-restore class and the overlay-context
573       // state is set, also update the parent window's location.
574       var parentLocation = ($target.hasClass('overlay-restore') && typeof $.bbq.getState('overlay-context') == 'string')
575         ? Drupal.settings.basePath + $.bbq.getState('overlay-context')
576         : null;
577       href = this.fragmentizeLink($target.get(0), parentLocation);
578       // Only override default behavior when left-clicking and user is not
579       // pressing the ALT, CTRL, META (Command key on the Macintosh keyboard)
580       // or SHIFT key.
581       if (event.button == 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey) {
582         // Redirect to a fragmentized href. This will trigger a hashchange event.
583         this.redirect(href);
584         // Prevent default action and further propagation of the event.
585         return false;
586       }
587       // Otherwise alter clicked link's href. This is being picked up by
588       // the default action handler.
589       else {
590         $target
591           // Restore link's href attribute on blur or next click.
592           .one('blur mousedown', { target: target, href: target.href }, function (event) { $(event.data.target).attr('href', event.data.href); })
593           .attr('href', href);
594       }
595     }
596     // Non-admin links should close the overlay and open in the main window,
597     // which is the default action for a link. We only need to handle them
598     // if the overlay is open and the clicked link is inside the overlay iframe.
599     else if (this.isOpen && target.ownerDocument === this.iframeWindow.document) {
600       // Open external links in the immediate parent of the frame, unless the
601       // link already has a different target.
602       if (target.hostname != window.location.hostname) {
603         if (!$target.attr('target')) {
604           $target.attr('target', '_parent');
605         }
606       }
607       else {
608         // Add the overlay-context state to the link, so "overlay-restore" links
609         // can restore the context.
610         $target.attr('href', $.param.fragment(href, { 'overlay-context': this.getPath(window.location) + window.location.search }));
611
612         // When the link has a destination query parameter and that destination
613         // is an admin link we need to fragmentize it. This will make it reopen
614         // in the overlay.
615         var params = $.deparam.querystring(href);
616         if (params.destination && this.isAdminLink(params.destination)) {
617           var fragmentizedDestination = $.param.fragment(this.getPath(window.location), { overlay: params.destination });
618           $target.attr('href', $.param.querystring(href, { destination: fragmentizedDestination }));
619         }
620
621         // Make the link open in the immediate parent of the frame.
622         $target.attr('target', '_parent');
623       }
624     }
625   }
626 };
627
628 /**
629  * Event handler: opens or closes the overlay based on the current URL fragment.
630  *
631  * @param event
632  *   Event being triggered, with the following restrictions:
633  *   - event.type: hashchange
634  *   - event.currentTarget: document
635  */
636 Drupal.overlay.eventhandlerOperateByURLFragment = function (event) {
637   // If we changed the hash to reflect an internal redirect in the overlay,
638   // its location has already been changed, so don't do anything.
639   if ($.data(window.location, window.location.href) === 'redirect') {
640     $.data(window.location, window.location.href, null);
641     return;
642   }
643
644   // Get the overlay URL from the current URL fragment.
645   var state = $.bbq.getState('overlay');
646   if (state) {
647     // Append render variable, so the server side can choose the right
648     // rendering and add child frame code to the page if needed.
649     var url = $.param.querystring(Drupal.settings.basePath + state, { render: 'overlay' });
650
651     this.open(url);
652     this.resetActiveClass(this.getPath(Drupal.settings.basePath + state));
653   }
654   // If there is no overlay URL in the fragment and the overlay is (still)
655   // open, close the overlay.
656   else if (this.isOpen && !this.isClosing) {
657     this.close();
658     this.resetActiveClass(this.getPath(window.location));
659   }
660 };
661
662 /**
663  * Event handler: makes sure the internal overlay URL is reflected in the parent
664  * URL fragment.
665  *
666  * Normally the parent URL fragment determines the overlay location. However, if
667  * the overlay redirects internally, the parent doesn't get informed, and the
668  * parent URL fragment will be out of date. This is a sanity check to make
669  * sure we're in the right place.
670  *
671  * The parent URL fragment is also not updated automatically when overlay's
672  * open, close or load functions are used directly (instead of through
673  * eventhandlerOperateByURLFragment).
674  *
675  * @param event
676  *   Event being triggered, with the following restrictions:
677  *   - event.type: drupalOverlayReady, drupalOverlayClose
678  *   - event.currentTarget: document
679  */
680 Drupal.overlay.eventhandlerSyncURLFragment = function (event) {
681   if (this.isOpen) {
682     var expected = $.bbq.getState('overlay');
683     // This is just a sanity check, so we're comparing paths, not query strings.
684     if (this.getPath(Drupal.settings.basePath + expected) != this.getPath(this.iframeWindow.document.location)) {
685       // There may have been a redirect inside the child overlay window that the
686       // parent wasn't aware of. Update the parent URL fragment appropriately.
687       var newLocation = Drupal.overlay.fragmentizeLink(this.iframeWindow.document.location);
688       // Set a 'redirect' flag on the new location so the hashchange event handler
689       // knows not to change the overlay's content.
690       $.data(window.location, newLocation, 'redirect');
691       // Use location.replace() so we don't create an extra history entry.
692       window.location.replace(newLocation);
693     }
694   }
695   else {
696     $.bbq.removeState('overlay');
697   }
698 };
699
700 /**
701  * Event handler: if the child window suggested that the parent refresh on
702  * close, force a page refresh.
703  *
704  * @param event
705  *   Event being triggered, with the following restrictions:
706  *   - event.type: drupalOverlayClose
707  *   - event.currentTarget: document
708  */
709 Drupal.overlay.eventhandlerRefreshPage = function (event) {
710   if (Drupal.overlay.refreshPage) {
711     window.location.reload(true);
712   }
713 };
714
715 /**
716  * Event handler: dispatches events to the overlay document.
717  *
718  * @param event
719  *   Event being triggered, with the following restrictions:
720  *   - event.type: any
721  *   - event.currentTarget: any
722  */
723 Drupal.overlay.eventhandlerDispatchEvent = function (event) {
724   if (this.iframeWindow && this.iframeWindow.document) {
725     this.iframeWindow.jQuery(this.iframeWindow.document).trigger(event);
726   }
727 };
728
729 /**
730  * Make a regular admin link into a URL that will trigger the overlay to open.
731  *
732  * @param link
733  *   A JavaScript Link object (i.e. an <a> element).
734  * @param parentLocation
735  *   (optional) URL to override the parent window's location with.
736  *
737  * @return
738  *   A URL that will trigger the overlay (in the form
739  *   /node/1#overlay=admin/config).
740  */
741 Drupal.overlay.fragmentizeLink = function (link, parentLocation) {
742   // Don't operate on links that are already overlay-ready.
743   var params = $.deparam.fragment(link.href);
744   if (params.overlay) {
745     return link.href;
746   }
747
748   // Determine the link's original destination. Set ignorePathFromQueryString to
749   // true to prevent transforming this link into a clean URL while clean URLs
750   // may be disabled.
751   var path = this.getPath(link, true);
752   // Preserve existing query and fragment parameters in the URL, except for
753   // "render=overlay" which is re-added in Drupal.overlay.eventhandlerOperateByURLFragment.
754   var destination = path + link.search.replace(/&?render=overlay/, '').replace(/\?$/, '') + link.hash;
755
756   // Assemble and return the overlay-ready link.
757   return $.param.fragment(parentLocation || window.location.href, { overlay: destination });
758 };
759
760 /**
761  * Refresh any regions of the page that are displayed outside the overlay.
762  *
763  * @param data
764  *   An array of objects with information on the page regions to be refreshed.
765  *   For each object, the key is a CSS class identifying the region to be
766  *   refreshed, and the value represents the section of the Drupal $page array
767  *   corresponding to this region.
768  */
769 Drupal.overlay.refreshRegions = function (data) {
770   $.each(data, function () {
771     var region_info = this;
772     $.each(region_info, function (regionClass) {
773       var regionName = region_info[regionClass];
774       var regionSelector = '.' + regionClass;
775       // Allow special behaviors to detach.
776       Drupal.detachBehaviors($(regionSelector));
777       $.get(Drupal.settings.basePath + Drupal.settings.overlay.ajaxCallback + '/' + regionName, function (newElement) {
778         $(regionSelector).replaceWith($(newElement));
779         Drupal.attachBehaviors($(regionSelector), Drupal.settings);
780       });
781     });
782   });
783 };
784
785 /**
786  * Reset the active class on links in displaced elements according to
787  * given path.
788  *
789  * @param activePath
790  *   Path to match links against.
791  */
792 Drupal.overlay.resetActiveClass = function(activePath) {
793   var self = this;
794   var windowDomain = window.location.protocol + window.location.hostname;
795
796   $('.overlay-displace-top, .overlay-displace-bottom')
797   .find('a[href]')
798   // Remove active class from all links in displaced elements.
799   .removeClass('active')
800   // Add active class to links that match activePath.
801   .each(function () {
802     var linkDomain = this.protocol + this.hostname;
803     var linkPath = self.getPath(this);
804
805     // A link matches if it is part of the active trail of activePath, except
806     // for frontpage links.
807     if (linkDomain == windowDomain && (activePath + '/').indexOf(linkPath + '/') === 0 && (linkPath !== '' || activePath === '')) {
808       $(this).addClass('active');
809     }
810   });
811 };
812
813 /**
814  * Helper function to get the (corrected) Drupal path of a link.
815  *
816  * @param link
817  *   Link object or string to get the Drupal path from.
818  * @param ignorePathFromQueryString
819  *   Boolean whether to ignore path from query string if path appears empty.
820  *
821  * @return
822  *   The Drupal path.
823  */
824 Drupal.overlay.getPath = function (link, ignorePathFromQueryString) {
825   if (typeof link == 'string') {
826     // Create a native Link object, so we can use its object methods.
827     link = $(link.link(link)).get(0);
828   }
829
830   var path = link.pathname;
831   // Ensure a leading slash on the path, omitted in some browsers.
832   if (path.charAt(0) != '/') {
833     path = '/' + path;
834   }
835   path = path.replace(new RegExp(Drupal.settings.basePath + '(?:index.php)?'), '');
836   if (path == '' && !ignorePathFromQueryString) {
837     // If the path appears empty, it might mean the path is represented in the
838     // query string (clean URLs are not used).
839     var match = new RegExp('([?&])q=(.+)([&#]|$)').exec(link.search);
840     if (match && match.length == 4) {
841       path = match[2];
842     }
843   }
844
845   return path;
846 };
847
848 /**
849  * Get the total displacement of given region.
850  *
851  * @param region
852  *   Region name. Either "top" or "bottom".
853  *
854  * @return
855  *   The total displacement of given region in pixels.
856  */
857 Drupal.overlay.getDisplacement = function (region) {
858   var displacement = 0;
859   var lastDisplaced = $('.overlay-displace-' + region + ':last');
860   if (lastDisplaced.length) {
861     displacement = lastDisplaced.offset().top + lastDisplaced.outerHeight();
862
863     // In modern browsers (including IE9), when box-shadow is defined, use the
864     // normal height.
865     var cssBoxShadowValue = lastDisplaced.css('box-shadow');
866     var boxShadow = (typeof cssBoxShadowValue !== 'undefined' && cssBoxShadowValue !== 'none');
867     // In IE8 and below, we use the shadow filter to apply box-shadow styles to
868     // the toolbar. It adds some extra height that we need to remove.
869     if (!boxShadow && /DXImageTransform\.Microsoft\.Shadow/.test(lastDisplaced.css('filter'))) {
870       displacement -= lastDisplaced[0].filters.item('DXImageTransform.Microsoft.Shadow').strength;
871       displacement = Math.max(0, displacement);
872     }
873   }
874   return displacement;
875 };
876
877 /**
878  * Makes elements outside the overlay unreachable via the tab key.
879  *
880  * @param context
881  *   The part of the DOM that should have its tabindexes changed. Defaults to
882  *   the entire page.
883  */
884 Drupal.overlay.makeDocumentUntabbable = function (context) {
885   // Manipulating tabindexes for the entire document is unacceptably slow in IE6
886   // and IE7, so in those browsers, the underlying page will still be reachable
887   // via the tab key. However, we still make the links within the Disable
888   // message unreachable, because the same message also exists within the
889   // child document. The duplicate copy in the underlying document is only for
890   // assisting screen-reader users navigating the document with reading commands
891   // that follow markup order rather than tab order.
892   if (jQuery.browser.msie && parseInt(jQuery.browser.version, 10) < 8) {
893     $('#overlay-disable-message a', context).attr('tabindex', -1);
894     return;
895   }
896
897   context = context || document.body;
898   var $overlay, $tabbable, $hasTabindex;
899
900   // Determine which elements on the page already have a tabindex.
901   $hasTabindex = $('[tabindex] :not(.overlay-element)', context);
902   // Record the tabindex for each element, so we can restore it later.
903   $hasTabindex.each(Drupal.overlay._recordTabindex);
904   // Add the tabbable elements from the current context to any that we might
905   // have previously recorded.
906   Drupal.overlay._hasTabindex = $hasTabindex.add(Drupal.overlay._hasTabindex);
907
908   // Set tabindex to -1 on everything outside the overlay and toolbars, so that
909   // the underlying page is unreachable.
910
911   // By default, browsers make a, area, button, input, object, select, textarea,
912   // and iframe elements reachable via the tab key.
913   $tabbable = $('a, area, button, input, object, select, textarea, iframe');
914   // If another element (like a div) has a tabindex, it's also tabbable.
915   $tabbable = $tabbable.add($hasTabindex);
916   // Leave links inside the overlay and toolbars alone.
917   $overlay = $('.overlay-element, #overlay-container, .overlay-displace-top, .overlay-displace-bottom').find('*');
918   $tabbable = $tabbable.not($overlay);
919   // We now have a list of everything in the underlying document that could
920   // possibly be reachable via the tab key. Make it all unreachable.
921   $tabbable.attr('tabindex', -1);
922 };
923
924 /**
925  * Restores the original tabindex value of a group of elements.
926  *
927  * @param context
928  *   The part of the DOM that should have its tabindexes restored. Defaults to
929  *   the entire page.
930  */
931 Drupal.overlay.makeDocumentTabbable = function (context) {
932   // Manipulating tabindexes is unacceptably slow in IE6 and IE7. In those
933   // browsers, the underlying page was never made unreachable via tab, so
934   // there is no work to be done here.
935   if (jQuery.browser.msie && parseInt(jQuery.browser.version, 10) < 8) {
936     return;
937   }
938
939   var $needsTabindex;
940   context = context || document.body;
941
942   // Make the underlying document tabbable again by removing all existing
943   // tabindex attributes.
944   var $tabindex = $('[tabindex]', context);
945   if (jQuery.browser.msie && parseInt(jQuery.browser.version, 10) < 8) {
946     // removeAttr('tabindex') is broken in IE6-7, but the DOM function
947     // removeAttribute works.
948     var i;
949     var length = $tabindex.length;
950     for (i = 0; i < length; i++) {
951       $tabindex[i].removeAttribute('tabIndex');
952     }
953   }
954   else {
955     $tabindex.removeAttr('tabindex');
956   }
957
958   // Restore the tabindex attributes that existed before the overlay was opened.
959   $needsTabindex = $(Drupal.overlay._hasTabindex, context);
960   $needsTabindex.each(Drupal.overlay._restoreTabindex);
961   Drupal.overlay._hasTabindex = Drupal.overlay._hasTabindex.not($needsTabindex);
962 };
963
964 /**
965  * Record the tabindex for an element, using $.data.
966  *
967  * Meant to be used as a jQuery.fn.each callback.
968  */
969 Drupal.overlay._recordTabindex = function () {
970   var $element = $(this);
971   var tabindex = $(this).attr('tabindex');
972   $element.data('drupalOverlayOriginalTabIndex', tabindex);
973 };
974
975 /**
976  * Restore an element's original tabindex.
977  *
978  * Meant to be used as a jQuery.fn.each callback.
979  */
980 Drupal.overlay._restoreTabindex = function () {
981   var $element = $(this);
982   var tabindex = $element.data('drupalOverlayOriginalTabIndex');
983   $element.attr('tabindex', tabindex);
984 };
985
986 /**
987  * Theme function to create the overlay iframe element.
988  */
989 Drupal.theme.prototype.overlayContainer = function () {
990   return '<div id="overlay-container"><div class="overlay-modal-background"></div></div>';
991 };
992
993 /**
994  * Theme function to create an overlay iframe element.
995  */
996 Drupal.theme.prototype.overlayElement = function (url) {
997   return '<iframe class="overlay-element" frameborder="0" scrolling="auto" allowtransparency="true"></iframe>';
998 };
999
1000 })(jQuery);