JAVASCRIPT   98

popup js

Guest on 23rd May 2022 01:58:39 AM

  1. /**
  2.  * Copyright (c) Matt Kruse
  3.  *
  4.  * Dual licensed under the MIT and GPL licenses.
  5.  * This basically means you can use this code however you want for
  6.  * free, but don't claim to have written it yourself!
  7.  *
  8.  * Please do not link to the .js files on javascripttoolbox.com from
  9.  * your site. Copy the files locally to your server instead.
  10.  *
  11.  */
  12. /* ******************************************************************* */
  13. /*   UTIL FUNCTIONS                                                    */
  14. /* ******************************************************************* */
  15. var Util = {'$VERSION':1.06};
  16.  
  17. // Util functions - these are GLOBAL so they
  18. // look like built-in functions.
  19.  
  20. // Determine if an object is an array
  21. function isArray(o) {
  22.         return (o!=null && typeof(o)=="object" && typeof(o.length)=="number" && (o.length==0 || defined(o[0])));
  23. };
  24.  
  25. // Determine if an object is an Object
  26. function isObject(o) {
  27.         return (o!=null && typeof(o)=="object" && defined(o.constructor) && o.constructor==Object && !defined(o.nodeName));
  28. };
  29.  
  30. // Determine if a reference is defined
  31. function defined(o) {
  32.         return (typeof(o)!="undefined");
  33. };
  34.  
  35. // Iterate over an array, object, or list of items and run code against each item
  36. // Similar functionality to Perl's map() function
  37. function map(func) {
  38.         var i,j,o;
  39.         var results = [];
  40.         if (typeof(func)=="string") {
  41.                 func = new Function('$_',func);
  42.         }
  43.         for (i=1; i<arguments.length; i++) {
  44.                 o = arguments[i];
  45.                 if (isArray(o)) {
  46.                         for (j=0; j<o.length; j++) {
  47.                                 results[results.length] = func(o[j]);
  48.                         }
  49.                 }
  50.                 else if (isObject(o)) {
  51.                         for (j in o) {
  52.                                 results[results.length] = func(o[j]);
  53.                         }
  54.                 }
  55.                 else {
  56.                         results[results.length] = func(o);
  57.                 }
  58.         }
  59.         return results;
  60. };
  61.  
  62. // Set default values in an object if they are undefined
  63. function setDefaultValues(o,values) {
  64.         if (!defined(o) || o==null) {
  65.                 o = {};
  66.         }
  67.         if (!defined(values) || values==null) {
  68.                 return o;
  69.         }
  70.         for (var val in values) {
  71.                 if (!defined(o[val])) {
  72.                         o[val] = values[val];
  73.                 }
  74.         }
  75.         return o;
  76. };
  77.  
  78. /* ******************************************************************* */
  79. /*   DEFAULT OBJECT PROTOTYPE ENHANCEMENTS                             */
  80. /* ******************************************************************* */
  81. // These functions add useful functionality to built-in objects
  82. Array.prototype.contains = function(o) {
  83.         var i,l;
  84.         if (!(l = this.length)) { return false; }
  85.         for (i=0; i<l; i++) {
  86.                 if (o==this[i]) {
  87.                         return true;
  88.                 }
  89.         }
  90. };
  91.  
  92. /* ******************************************************************* */
  93. /*   DOM FUNCTIONS                                                     */
  94. /* ******************************************************************* */
  95. var DOM = (function() {
  96.         var dom = {};
  97.        
  98.         // Get a parent tag with a given nodename
  99.         dom.getParentByTagName = function(o,tagNames) {
  100.                 if(o==null) { return null; }
  101.                 if (isArray(tagNames)) {
  102.                         tagNames = map("return $_.toUpperCase()",tagNames);
  103.                         while (o=o.parentNode) {
  104.                                 if (o.nodeName && tagNames.contains(o.nodeName)) {
  105.                                         return o;
  106.                                 }
  107.                         }
  108.                 }
  109.                 else {
  110.                         tagNames = tagNames.toUpperCase();
  111.                         while (o=o.parentNode) {
  112.                                 if (o.nodeName && tagNames==o.nodeName) {
  113.                                         return o;
  114.                                 }
  115.                         }
  116.                 }
  117.                 return null;
  118.         };
  119.        
  120.         // Remove a node from its parent
  121.         dom.removeNode = function(o) {
  122.                 if (o!=null && o.parentNode && o.parentNode.removeChild) {
  123.                         // First remove all attributes which are func references, to avoid memory leaks
  124.                         for (var i in o) {
  125.                                 if (typeof(o[i])=="function") {
  126.                                         o[i] = null;
  127.                                 }
  128.                         }
  129.                         o.parentNode.removeChild(o);
  130.                         return true;
  131.                 }
  132.                 return false;
  133.         };
  134.  
  135.         // Get the outer width in pixels of an object, including borders, padding, and margin
  136.         dom.getOuterWidth = function(o) {
  137.                 if (defined(o.offsetWidth)) {
  138.                         return o.offsetWidth;
  139.                 }
  140.                 return null;
  141.         };
  142.  
  143.         // Get the outer height in pixels of an object, including borders, padding, and margin
  144.         dom.getOuterHeight = function(o) {
  145.                 if (defined(o.offsetHeight)) {
  146.                         return o.offsetHeight;
  147.                 }
  148.                 return null;
  149.         };
  150.  
  151.         // Resolve an item, an array of items, or an object of items
  152.         dom.resolve = function() {
  153.                 var results = new Array();
  154.                 var i,j,o;
  155.                 for (var i=0; i<arguments.length; i++) {
  156.                         var o = arguments[i];
  157.                         if (o==null) {
  158.                                 if (arguments.length==1) {
  159.                                         return null;
  160.                                 }
  161.                                 results[results.length] = null;
  162.                         }
  163.                         else if (typeof(o)=='string') {
  164.                                 if (document.getElementById) {
  165.                                         o = document.getElementById(o);
  166.                                 }
  167.                                 else if (document.all) {
  168.                                         o = document.all[o];
  169.                                 }
  170.                                 if (arguments.length==1) {
  171.                                         return o;
  172.                                 }
  173.                                 results[results.length] = o;
  174.                         }
  175.                         else if (isArray(o)) {
  176.                                 for (j=0; j<o.length; j++) {
  177.                                         results[results.length] = o[j];
  178.                                 }
  179.                         }
  180.                         else if (isObject(o)) {
  181.                                 for (j in o) {
  182.                                         results[results.length] = o[j];
  183.                                 }
  184.                         }
  185.                         else if (arguments.length==1) {
  186.                                 return o;
  187.                         }
  188.                         else {
  189.                                 results[results.length] = o;
  190.                         }
  191.           }
  192.           return results;
  193.         };
  194.         dom.$ = dom.resolve;
  195.        
  196.         return dom;
  197. })();
  198.  
  199. /* ******************************************************************* */
  200. /*   CSS FUNCTIONS                                                     */
  201. /* ******************************************************************* */
  202. var CSS = (function(){
  203.         var css = {};
  204.  
  205.         // Convert an RGB string in the form "rgb (255, 255, 255)" to "#ffffff"
  206.         css.rgb2hex = function(rgbString) {
  207.                 if (typeof(rgbString)!="string" || !defined(rgbString.match)) { return null; }
  208.                 var result = rgbString.match(/^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*/);
  209.                 if (result==null) { return rgbString; }
  210.                 var rgb = +result[1] << 16 | +result[2] << 8 | +result[3];
  211.                 var hex = "";
  212.                 var digits = "0123456789abcdef";
  213.                 while(rgb!=0) {
  214.                         hex = digits.charAt(rgb&0xf)+hex;
  215.                         rgb>>>=4;
  216.                 }
  217.                 while(hex.length<6) { hex='0'+hex; }
  218.                 return "#" + hex;
  219.         };
  220.  
  221.         // Convert hyphen style names like border-width to camel case like borderWidth
  222.         css.hyphen2camel = function(property) {
  223.                 if (!defined(property) || property==null) { return null; }
  224.                 if (property.indexOf("-")<0) { return property; }
  225.                 var str = "";
  226.                 var c = null;
  227.                 var l = property.length;
  228.                 for (var i=0; i<l; i++) {
  229.                         c = property.charAt(i);
  230.                         str += (c!="-")?c:property.charAt(++i).toUpperCase();
  231.                 }
  232.                 return str;
  233.         };
  234.        
  235.         // Determine if an object or class string contains a given class.
  236.         css.hasClass = function(obj,className) {
  237.                 if (!defined(obj) || obj==null || !RegExp) { return false; }
  238.                 var re = new RegExp("(^|\\s)" + className + "(\\s|$)");
  239.                 if (typeof(obj)=="string") {
  240.                         return re.test(obj);
  241.                 }
  242.                 else if (typeof(obj)=="object" && obj.className) {
  243.                         return re.test(obj.className);
  244.                 }
  245.                 return false;
  246.         };
  247.        
  248.         // Add a class to an object
  249.         css.addClass = function(obj,className) {
  250.                 if (typeof(obj)!="object" || obj==null || !defined(obj.className)) { return false; }
  251.                 if (obj.className==null || obj.className=='') {
  252.                         obj.className = className;
  253.                         return true;
  254.                 }
  255.                 if (css.hasClass(obj,className)) { return true; }
  256.                 obj.className = obj.className + " " + className;
  257.                 return true;
  258.         };
  259.        
  260.         // Remove a class from an object
  261.         css.removeClass = function(obj,className) {
  262.                 if (typeof(obj)!="object" || obj==null || !defined(obj.className) || obj.className==null) { return false; }
  263.                 if (!css.hasClass(obj,className)) { return false; }
  264.                 var re = new RegExp("(^|\\s+)" + className + "(\\s+|$)");
  265.                 obj.className = obj.className.replace(re,' ');
  266.                 return true;
  267.         };
  268.        
  269.         // Fully replace a class with a new one
  270.         css.replaceClass = function(obj,className,newClassName) {
  271.                 if (typeof(obj)!="object" || obj==null || !defined(obj.className) || obj.className==null) { return false; }
  272.                 css.removeClass(obj,className);
  273.                 css.addClass(obj,newClassName);
  274.                 return true;
  275.         };
  276.        
  277.         // Get the currently-applied style of an object
  278.         css.getStyle = function(o, property) {
  279.                 if (o==null) { return null; }
  280.                 var val = null;
  281.                 var camelProperty = css.hyphen2camel(property);
  282.                 // Handle "float" property as a special case
  283.                 if (property=="float") {
  284.                         val = css.getStyle(o,"cssFloat");
  285.                         if (val==null) {
  286.                                 val = css.getStyle(o,"styleFloat");
  287.                         }
  288.                 }
  289.                 else if (o.currentStyle && defined(o.currentStyle[camelProperty])) {
  290.                         val = o.currentStyle[camelProperty];
  291.                 }
  292.                 else if (window.getComputedStyle) {
  293.                         val = window.getComputedStyle(o,null).getPropertyValue(property);
  294.                 }
  295.                 else if (o.style && defined(o.style[camelProperty])) {
  296.                         val = o.style[camelProperty];
  297.                 }
  298.                 // For color values, make the value consistent across browsers
  299.                 // Convert rgb() colors back to hex for consistency
  300.                 if (/^\s*rgb\s*\(/.test(val)) {
  301.                         val = css.rgb2hex(val);
  302.                 }
  303.                 // Lowercase all #hex values
  304.                 if (/^#/.test(val)) {
  305.                         val = val.toLowerCase();
  306.                 }
  307.                 return val;
  308.         };
  309.         css.get = css.getStyle;
  310.  
  311.         // Set a style on an object
  312.         css.setStyle = function(o, property, value) {
  313.                 if (o==null || !defined(o.style) || !defined(property) || property==null || !defined(value)) { return false; }
  314.                 if (property=="float") {
  315.                         o.style["cssFloat"] = value;
  316.                         o.style["styleFloat"] = value;
  317.                 }
  318.                 else if (property=="opacity") {
  319.                         o.style['-moz-opacity'] = value;
  320.                         o.style['-khtml-opacity'] = value;
  321.                         o.style.opacity = value;
  322.                         if (defined(o.style.filter)) {
  323.                                 o.style.filter = "alpha(opacity=" + value*100 + ")";
  324.                         }
  325.                 }
  326.                 else {
  327.                         o.style[css.hyphen2camel(property)] = value;
  328.                 }
  329.                 return true;
  330.         };
  331.         css.set = css.setStyle;
  332.        
  333.         // Get a unique ID which doesn't already exist on the page
  334.         css.uniqueIdNumber=1000;
  335.         css.createId = function(o) {
  336.                 if (defined(o) && o!=null && defined(o.id) && o.id!=null && o.id!="") {
  337.                         return o.id;
  338.                 }
  339.                 var id = null;
  340.                 while (id==null || document.getElementById(id)!=null) {
  341.                         id = "ID_"+(css.uniqueIdNumber++);
  342.                 }
  343.                 if (defined(o) && o!=null && (!defined(o.id)||o.id=="")) {
  344.                         o.id = id;
  345.                 }
  346.                 return id;
  347.         };
  348.        
  349.         return css;
  350. })();
  351.  
  352. /* ******************************************************************* */
  353. /*   EVENT FUNCTIONS                                                   */
  354. /* ******************************************************************* */
  355.  
  356. var Event = (function(){
  357.         var ev = {};
  358.        
  359.         // Resolve an event using IE's window.event if necessary
  360.         // --------------------------------------------------------------------
  361.         ev.resolve = function(e) {
  362.                 if (!defined(e) && defined(window.event)) {
  363.                         e = window.event;
  364.                 }
  365.                 return e;
  366.         };
  367.        
  368.         // Add an event handler to a function
  369.         // Note: Don't use 'this' within functions added using this method, since
  370.         // the attachEvent and addEventListener models differ.
  371.         // --------------------------------------------------------------------
  372.         ev.add = function( obj, type, fn, capture ) {
  373.                 if (obj.addEventListener) {
  374.                         obj.addEventListener( type, fn, capture );
  375.                         return true;
  376.                 }
  377.                 else if (obj.attachEvent) {
  378.                         obj.attachEvent( "on"+type, fn );
  379.                         return true;
  380.                 }
  381.                 return false;
  382.         };
  383.  
  384.         // Get the mouse position of an event
  385.         // --------------------------------------------------------------------
  386.         // PageX/Y, where they exist, are more reliable than ClientX/Y because
  387.         // of some browser bugs in Opera/Safari
  388.         ev.getMouseX = function(e) {
  389.                 e = ev.resolve(e);
  390.                 if (defined(e.pageX)) {
  391.                         return e.pageX;
  392.                 }
  393.                 if (defined(e.clientX)) {
  394.                         return e.clientX+Screen.getScrollLeft();
  395.                 }
  396.                 return null;
  397.         };
  398.         ev.getMouseY = function(e) {
  399.                 e = ev.resolve(e);
  400.                 if (defined(e.pageY)) {
  401.                         return e.pageY;
  402.                 }
  403.                 if (defined(e.clientY)) {
  404.                         return e.clientY+Screen.getScrollTop();
  405.                 }
  406.                 return null;
  407.         };
  408.  
  409.         // Stop the event from bubbling up to parent elements.
  410.         // Two method names map to the same function
  411.         // --------------------------------------------------------------------
  412.         ev.cancelBubble = function(e) {
  413.                 e = ev.resolve(e);
  414.                 if (typeof(e.stopPropagation)=="function") { e.stopPropagation(); }
  415.                 if (defined(e.cancelBubble)) { e.cancelBubble = true; }
  416.         };
  417.         ev.stopPropagation = ev.cancelBubble;
  418.  
  419.         // Prevent the default handling of the event to occur
  420.         // --------------------------------------------------------------------
  421.         ev.preventDefault = function(e) {
  422.                 e = ev.resolve(e);
  423.                 if (typeof(e.preventDefault)=="function") { e.preventDefault(); }
  424.                 if (defined(e.returnValue)) { e.returnValue = false; }
  425.         };
  426.        
  427.         return ev;
  428. })();
  429.  
  430. /* ******************************************************************* */
  431. /*   SCREEN FUNCTIONS                                                  */
  432. /* ******************************************************************* */
  433. var Screen = (function() {
  434.         var screen = {};
  435.  
  436.         // Get a reference to the body
  437.         // --------------------------------------------------------------------
  438.         screen.getBody = function() {
  439.                 if (document.body) {
  440.                         return document.body;
  441.                 }
  442.                 if (document.getElementsByTagName) {
  443.                         var bodies = document.getElementsByTagName("BODY");
  444.                         if (bodies!=null && bodies.length>0) {
  445.                                 return bodies[0];
  446.                         }
  447.                 }
  448.                 return null;
  449.         };
  450.  
  451.         // Get the amount that the main document has scrolled from top
  452.         // --------------------------------------------------------------------
  453.         screen.getScrollTop = function() {
  454.                 if (document.documentElement && defined(document.documentElement.scrollTop) && document.documentElement.scrollTop>0) {
  455.                         return document.documentElement.scrollTop;
  456.                 }
  457.                 if (document.body && defined(document.body.scrollTop)) {
  458.                         return document.body.scrollTop;
  459.                 }
  460.                 return null;
  461.         };
  462.        
  463.         // Get the amount that the main document has scrolled from left
  464.         // --------------------------------------------------------------------
  465.         screen.getScrollLeft = function() {
  466.                 if (document.documentElement && defined(document.documentElement.scrollLeft) && document.documentElement.scrollLeft>0) {
  467.                         return document.documentElement.scrollLeft;
  468.                 }
  469.                 if (document.body && defined(document.body.scrollLeft)) {
  470.                         return document.body.scrollLeft;
  471.                 }
  472.                 return null;
  473.         };
  474.        
  475.         // Util function to default a bad number to 0
  476.         // --------------------------------------------------------------------
  477.         screen.zero = function(n) {
  478.                 return (!defined(n) || isNaN(n))?0:n;
  479.         };
  480.  
  481.         // Get the width of the entire document
  482.         // --------------------------------------------------------------------
  483.         screen.getDocumentWidth = function() {
  484.                 var width = 0;
  485.                 var body = screen.getBody();
  486.                 if (document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {
  487.                     var rightMargin = parseInt(CSS.get(body,'marginRight'),10) || 0;
  488.                     var leftMargin = parseInt(CSS.get(body,'marginLeft'), 10) || 0;
  489.                         width = Math.max(body.offsetWidth + leftMargin + rightMargin, document.documentElement.clientWidth);
  490.                 }
  491.                 else {
  492.                         width =  Math.max(body.clientWidth, body.scrollWidth);
  493.                 }
  494.                 if (isNaN(width) || width==0) {
  495.                         width = screen.zero(self.innerWidth);
  496.                 }
  497.                 return width;
  498.         };
  499.        
  500.         // Get the height of the entire document
  501.         // --------------------------------------------------------------------
  502.         screen.getDocumentHeight = function() {
  503.                 var body = screen.getBody();
  504.                 var innerHeight = (defined(self.innerHeight)&&!isNaN(self.innerHeight))?self.innerHeight:0;
  505.                 if (document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {
  506.                     var topMargin = parseInt(CSS.get(body,'marginTop'),10) || 0;
  507.                     var bottomMargin = parseInt(CSS.get(body,'marginBottom'), 10) || 0;
  508.                         return Math.max(body.offsetHeight + topMargin + bottomMargin, document.documentElement.clientHeight, document.documentElement.scrollHeight, screen.zero(self.innerHeight));
  509.                 }
  510.                 return Math.max(body.scrollHeight, body.clientHeight, screen.zero(self.innerHeight));
  511.         };
  512.        
  513.         // Get the width of the viewport (viewable area) in the browser window
  514.         // --------------------------------------------------------------------
  515.         screen.getViewportWidth = function() {
  516.                 if (document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {
  517.                         return document.documentElement.clientWidth;
  518.                 }
  519.                 else if (document.compatMode && document.body) {
  520.                         return document.body.clientWidth;
  521.                 }
  522.                 return screen.zero(self.innerWidth);
  523.         };
  524.        
  525.         // Get the height of the viewport (viewable area) in the browser window
  526.         // --------------------------------------------------------------------
  527.         screen.getViewportHeight = function() {
  528.                 if (!window.opera && document.documentElement && (!document.compatMode || document.compatMode=="CSS1Compat")) {
  529.                         return document.documentElement.clientHeight;
  530.                 }
  531.                 else if (document.compatMode && !window.opera && document.body) {
  532.                         return document.body.clientHeight;
  533.                 }
  534.                 return screen.zero(self.innerHeight);
  535.         };
  536.  
  537.         return screen;
  538. })();var Sort = (function(){
  539.         var sort = {};
  540.         sort.AlphaNumeric = function(a,b) {
  541.                 if (a==b) { return 0; }
  542.                 if (a<b) { return -1; }
  543.                 return 1;
  544.         };
  545.  
  546.         sort.Default = sort.AlphaNumeric;
  547.        
  548.         sort.NumericConversion = function(val) {
  549.                 if (typeof(val)!="number") {
  550.                         if (typeof(val)=="string") {
  551.                                 val = parseFloat(val.replace(/,/g,''));
  552.                                 if (isNaN(val) || val==null) { val=0; }
  553.                         }
  554.                         else {
  555.                                 val = 0;
  556.                         }
  557.                 }
  558.                 return val;
  559.         };
  560.        
  561.         sort.Numeric = function(a,b) {
  562.                 return sort.NumericConversion(a)-sort.NumericConversion(b);
  563.         };
  564.  
  565.         sort.IgnoreCaseConversion = function(val) {
  566.                 if (val==null) { val=""; }
  567.                 return (""+val).toLowerCase();
  568.         };
  569.  
  570.         sort.IgnoreCase = function(a,b) {
  571.                 return sort.AlphaNumeric(sort.IgnoreCaseConversion(a),sort.IgnoreCaseConversion(b));
  572.         };
  573.  
  574.         sort.CurrencyConversion = function(val) {
  575.                 if (typeof(val)=="string") {
  576.                         val = val.replace(/^[^\d\.]/,'');
  577.                 }
  578.                 return sort.NumericConversion(val);
  579.         };
  580.        
  581.         sort.Currency = function(a,b) {
  582.                 return sort.Numeric(sort.CurrencyConversion(a),sort.CurrencyConversion(b));
  583.         };
  584.        
  585.         sort.DateConversion = function(val) {
  586.                 // inner util function to parse date formats
  587.                 function getdate(str) {
  588.                         // inner util function to convert 2-digit years to 4
  589.                         function fixYear(yr) {
  590.                                 yr = +yr;
  591.                                 if (yr<50) { yr += 2000; }
  592.                                 else if (yr<100) { yr += 1900; }
  593.                                 return yr;
  594.                         };
  595.                         var ret;
  596.                         // YYYY-MM-DD
  597.                         if (ret=str.match(/(\d{2,4})-(\d{1,2})-(\d{1,2})/)) {
  598.                                 return (fixYear(ret[1])*10000) + (ret[2]*100) + (+ret[3]);
  599.                         }
  600.                         // MM/DD/YY[YY] or MM-DD-YY[YY]
  601.                         if (ret=str.match(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{2,4})/)) {
  602.                                 return (fixYear(ret[3])*10000) + (ret[1]*100) + (+ret[2]);
  603.                         }
  604.                         return 99999999; // So non-parsed dates will be last, not first
  605.                 };
  606.                 return getdate(val);
  607.         };
  608.  
  609.         sort.Date = function(a,b) {
  610.                 return sort.Numeric(sort.DateConversion(a),sort.DateConversion(b));
  611.         };
  612.  
  613.         return sort;
  614. })();
  615.  
  616. var Position = (function() {
  617.         // Resolve a string identifier to an object
  618.         // ========================================
  619.         function resolveObject(s) {
  620.                 if (document.getElementById && document.getElementById(s)!=null) {
  621.                         return document.getElementById(s);
  622.                 }
  623.                 else if (document.all && document.all[s]!=null) {
  624.                         return document.all[s];
  625.                 }
  626.                 else if (document.anchors && document.anchors.length && document.anchors.length>0 && document.anchors[0].x) {
  627.                         for (var i=0; i<document.anchors.length; i++) {
  628.                                 if (document.anchors[i].name==s) {
  629.                                         return document.anchors[i]
  630.                                 }
  631.                         }
  632.                 }
  633.         }
  634.        
  635.         var pos = {};
  636.         pos.$VERSION = 1.0;
  637.        
  638.         // Set the position of an object
  639.         // =============================
  640.         pos.set = function(o,left,top) {
  641.                 if (typeof(o)=="string") {
  642.                         o = resolveObject(o);
  643.                 }
  644.                 if (o==null || !o.style) {
  645.                         return false;
  646.                 }
  647.                
  648.                 // If the second parameter is an object, it is assumed to be the result of getPosition()
  649.                 if (typeof(left)=="object") {
  650.                         var pos = left;
  651.                         left = pos.left;
  652.                         top = pos.top;
  653.                 }
  654.                
  655.                 o.style.left = left + "px";
  656.                 o.style.top = top + "px";
  657.                 return true;
  658.         };
  659.        
  660.         // Retrieve the position and size of an object
  661.         // ===========================================
  662.         pos.get = function(o) {
  663.                 var fixBrowserQuirks = true;
  664.                         // If a string is passed in instead of an object ref, resolve it
  665.                 if (typeof(o)=="string") {
  666.                         o = resolveObject(o);
  667.                 }
  668.                
  669.                 if (o==null) {
  670.                         return null;
  671.                 }
  672.                
  673.                 var left = 0;
  674.                 var top = 0;
  675.                 var width = 0;
  676.                 var height = 0;
  677.                 var parentNode = null;
  678.                 var offsetParent = null;
  679.        
  680.                
  681.                 offsetParent = o.offsetParent;
  682.                 var originalObject = o;
  683.                 var el = o; // "el" will be nodes as we walk up, "o" will be saved for offsetParent references
  684.                 while (el.parentNode!=null) {
  685.                         el = el.parentNode;
  686.                         if (el.offsetParent==null) {
  687.                         }
  688.                         else {
  689.                                 var considerScroll = true;
  690.                                 /*
  691.                                 In Opera, if parentNode of the first object is scrollable, then offsetLeft/offsetTop already
  692.                                 take its scroll position into account. If elements further up the chain are scrollable, their
  693.                                 scroll offsets still need to be added in. And for some reason, TR nodes have a scrolltop value
  694.                                 which must be ignored.
  695.                                 */
  696.                                 if (fixBrowserQuirks && window.opera) {
  697.                                         if (el==originalObject.parentNode || el.nodeName=="TR") {
  698.                                                 considerScroll = false;
  699.                                         }
  700.                                 }
  701.                                 if (considerScroll) {
  702.                                         if (el.scrollTop && el.scrollTop>0) {
  703.                                                 top -= el.scrollTop;
  704.                                         }
  705.                                         if (el.scrollLeft && el.scrollLeft>0) {
  706.                                                 left -= el.scrollLeft;
  707.                                         }
  708.                                 }
  709.                         }
  710.                         // If this node is also the offsetParent, add on the offsets and reset to the new offsetParent
  711.                         if (el == offsetParent) {
  712.                                 left += o.offsetLeft;
  713.                                 if (el.clientLeft && el.nodeName!="TABLE") {
  714.                                         left += el.clientLeft;
  715.                                 }
  716.                                 top += o.offsetTop;
  717.                                 if (el.clientTop && el.nodeName!="TABLE") {
  718.                                         top += el.clientTop;
  719.                                 }
  720.                                 o = el;
  721.                                 if (o.offsetParent==null) {
  722.                                         if (o.offsetLeft) {
  723.                                                 left += o.offsetLeft;
  724.                                         }
  725.                                         if (o.offsetTop) {
  726.                                                 top += o.offsetTop;
  727.                                         }
  728.                                 }
  729.                                 offsetParent = o.offsetParent;
  730.                         }
  731.                 }
  732.                
  733.        
  734.                 if (originalObject.offsetWidth) {
  735.                         width = originalObject.offsetWidth;
  736.                 }
  737.                 if (originalObject.offsetHeight) {
  738.                         height = originalObject.offsetHeight;
  739.                 }
  740.                
  741.                 return {'left':left, 'top':top, 'width':width, 'height':height
  742.                                 };
  743.         };
  744.        
  745.         // Retrieve the position of an object's center point
  746.         // =================================================
  747.         pos.getCenter = function(o) {
  748.                 var c = this.get(o);
  749.                 if (c==null) { return null; }
  750.                 c.left = c.left + (c.width/2);
  751.                 c.top = c.top + (c.height/2);
  752.                 return c;
  753.         };
  754.        
  755.         return pos;
  756. })();// CLASS CONSTRUCTOR
  757. // --------------------------------------------------------------------
  758. var Popup = function(div, options) {
  759.         this.div = defined(div)?div:null;
  760.         this.index = Popup.maxIndex++;
  761.         this.ref = "Popup.objects["+this.index+"]";
  762.         Popup.objects[this.index] = this;
  763.         // Store a reference to the DIV by id, also
  764.         if (typeof(this.div)=="string") {
  765.                 Popup.objectsById[this.div] = this;
  766.         }
  767.         if (defined(this.div) && this.div!=null && defined(this.div.id)) {
  768.                 Popup.objectsById[this.div.id] = this.div.id;
  769.         }
  770.         // Apply passed-in options
  771.         if (defined(options) && options!=null && typeof(options)=="object") {
  772.                 for (var i in options) {
  773.                         this[i] = options[i];
  774.                 }
  775.         }
  776.         return this;
  777. };
  778.  
  779. // CLASS PROPERTIES
  780. // --------------------------------------------------------------------
  781. // Index of popup objects, to maintain a global reference if necessary
  782. Popup.maxIndex = 0;
  783. Popup.objects = {};
  784. Popup.objectsById = {};
  785.  
  786. // The z-index value that popups will start at
  787. Popup.minZIndex = 101;
  788.  
  789. // Class names to assign to other objects
  790. Popup.screenClass = "PopupScreen";
  791. Popup.iframeClass = "PopupIframe";
  792. Popup.screenIframeClass = "PopupScreenIframe";
  793.  
  794. // CLASS METHODS
  795. // --------------------------------------------------------------------
  796.  
  797. // Hide all currently-visible non-modal dialogs
  798. Popup.hideAll = function() {
  799.         for (var i in Popup.objects) {
  800.                 var p = Popup.objects[i];
  801.                 if (!p.modal && p.autoHide) {
  802.                         p.hide();
  803.                 }
  804.         }
  805. };
  806. // Catch global events as a trigger to hide auto-hide popups
  807. Event.add(document, "mouseup", Popup.hideAll, false);
  808.  
  809. // A simple class method to show a popup without creating an instance
  810. Popup.show = function(divObject, referenceObject, position, options, modal) {
  811.         var popup;
  812.         if (defined(divObject)) {
  813.                 popup = new Popup(divObject);
  814.         }
  815.         else {
  816.                 popup = new Popup();
  817.                 popup.destroyDivOnHide = true;
  818.         }
  819.         if (defined(referenceObject)) { popup.reference = DOM.resolve(referenceObject); }
  820.         if (defined(position)) { popup.position = position; }
  821.         if (defined(options) && options!=null && typeof(options)=="object") {
  822.                 for (var i in options) {
  823.                         popup[i] = options[i];
  824.                 }
  825.         }
  826.         if (typeof(modal)=="boolean") {
  827.                 popup.modal = modal;
  828.         }
  829.         popup.destroyObjectsOnHide = true;
  830.         popup.show();
  831.         return popup;
  832. };
  833.  
  834. // A simple class method to show a modal popup
  835. Popup.showModal = function(divObject, referenceObject, position, options) {
  836.         Popup.show(divObject, referenceObject, position, options, true);
  837. };
  838.  
  839. // A method to retrieve a popup object based on a div ID
  840. Popup.get = function(divId) {
  841.         if (defined(Popup.objectsById[divId])) {
  842.                 return Popup.objectsById[divId];
  843.         }
  844.         return null;
  845. };
  846.  
  847. // A method to hide a popup based on a div id
  848. Popup.hide = function(divId) {
  849.         var popup = Popup.get(divId);
  850.         if (popup!=null) {
  851.                 popup.hide();
  852.         }
  853. };
  854.  
  855. // PROTOTYPE PROPERTIES
  856. // --------------------------------------------------------------------
  857. Popup.prototype.content = null;
  858. Popup.prototype.className = "PopupDiv";
  859. Popup.prototype.style = null; // Styles to be applied to the DIV
  860. Popup.prototype.width = null;
  861. Popup.prototype.height = null;
  862. Popup.prototype.top = null;
  863. Popup.prototype.left = null;
  864. Popup.prototype.offsetLeft = 0;
  865. Popup.prototype.offsetTop = 0;
  866. Popup.prototype.constrainToScreen = true;
  867. Popup.prototype.autoHide = true;
  868. Popup.prototype.useIframeShim = false; /*@cc_on @*/ /*@if (@_win32) {Popup.prototype.useIframeShim = true;} @end @*/
  869. Popup.prototype.iframe = null;
  870. Popup.prototype.position = null; // vertical: "above top center bottom below", horizontal: "adjacent-left,left,center,right,adjacent-right"
  871. Popup.prototype.reference = null;
  872. Popup.prototype.modal = false;
  873. Popup.prototype.destroyDivOnHide = false;
  874. Popup.prototype.destroyObjectsOnHide = false;
  875. Popup.prototype.screen = null;
  876. Popup.prototype.screenIframeShim = null;
  877. Popup.prototype.screenOpacity=.4;
  878. Popup.prototype.screenColor="#cccccc";
  879.  
  880. // INSTANCE METHODS
  881. // --------------------------------------------------------------------
  882.  
  883. // Show the popup
  884. // --------------------------------------------------------------------
  885. Popup.prototype.show = function(options, modal) {
  886.         this.modal = this.modal || (typeof(modal)=="boolean" && modal);
  887.         if (defined(options) && options!=null && typeof(options)=="object") {
  888.                 for (var i in options) {
  889.                         this[i] = options[i];
  890.                 }
  891.         }
  892.         this.div = DOM.resolve(this.div);
  893.         CSS.setStyle(this.div,'position','absolute');
  894.        
  895.         // If there is no div pre-defined to use, create one
  896.         if (this.div==null) {
  897.                 this.div = this.createDiv();
  898.         }
  899.         if (this.content!=null) {
  900.                 this.div.innerHTML = this.content;
  901.                 this.content = null;
  902.         }
  903.         if (this.className!=null) {
  904.                 this.div.className = this.className;
  905.         }
  906.         if (this.style!=null) {
  907.                 this.applyStyle();
  908.         }
  909.         if (this.width!=null) {
  910.                 this.div.style.width = this.width+"px";
  911.                 this.div.style.overflowX="auto";
  912.         }
  913.         if (this.height!=null) {
  914.                 this.div.style.height = this.height+"px";
  915.                 this.div.style.overflowY="auto";
  916.         }
  917.  
  918.         // Do the actual display - this is a separate method so display transitions can be implemented
  919.         this.transition();
  920.        
  921.         // Make sure clicks on the DIV don't bubble up to the document
  922.         this.div.onclick = function(e) {
  923.                 Event.cancelBubble(Event.resolve(e));
  924.         };
  925.         this.div.onmouseup = this.div.onclick;
  926.        
  927.         // Focus to the DIV if possible
  928.         if (this.modal && this.div.focus) {
  929.                 this.div.focus();
  930.         }
  931. };
  932.  
  933. // Show the popup but make it modal
  934. // --------------------------------------------------------------------
  935. Popup.prototype.transition = function() {
  936.         if (this.modal) {
  937.                 this.addScreen();
  938.         }
  939.        
  940.         // Make the DIV displayed but hidden so its size can be measured
  941.         CSS.setStyle(this.div,'visibility','hidden');
  942.         CSS.setStyle(this.div,'display','block');
  943.  
  944.         // Position the popup
  945.         this.setPosition();
  946.  
  947.         // Add the shim if necessary   
  948.         if (this.useIframeShim) {
  949.                 this.addIframeShim();
  950.         }
  951.  
  952.         // Make sure the DIV is higher than the shim
  953.         this.div.style.zIndex = Popup.minZIndex++;
  954.  
  955.         CSS.setStyle(this.div,'display','block');
  956.         CSS.setStyle(this.div,'visibility','visible');
  957. };
  958.  
  959. // Show the popup but make it modal
  960. // --------------------------------------------------------------------
  961. Popup.prototype.showModal = function(options) {
  962.         this.show(options,true);
  963. };
  964.  
  965. // Apply user styles to the DIV
  966. // --------------------------------------------------------------------
  967. Popup.prototype.applyStyle = function() {
  968.         if (this.div!=null && this.style!=null && typeof(this.style)=="object") {
  969.                 for (var i in this.style) {
  970.                         this.div.style[i] = this.style[i];
  971.                 }
  972.         }
  973. };
  974.  
  975. // Hide the popup
  976. // --------------------------------------------------------------------
  977. Popup.prototype.hide = function() {
  978.         // If this was a temp object creating on-the-fly, then remove objects from the DOM so
  979.         // The document doesn't get littered with extra objects
  980.         if (this.destroyDivOnHide) {
  981.                 DOM.removeNode(this.div);
  982.                 this.div = null;
  983.                 delete Popup.objects[this.id];
  984.         }
  985.         else if (this.div!=null) {
  986.                 CSS.setStyle(this.div,'display','none');
  987.         }
  988.  
  989.         if (this.destroyObjectsOnHide) {
  990.                 DOM.removeNode(this.iframe);
  991.                 DOM.removeNode(this.screen);
  992.                 DOM.removeNode(this.screenIframeShim);
  993.         }
  994.         else {
  995.                 if (this.iframe!=null) {
  996.                         this.iframe.style.display = "none";
  997.                 }
  998.                 if (this.screen!=null) {
  999.                         this.screen.style.display = "none";
  1000.                 }
  1001.                 if (this.screenIframeShim!=null) {
  1002.                         this.screenIframeShim.style.display = "none";
  1003.                 }
  1004.         }
  1005. };
  1006.  
  1007. // Util funcs for position
  1008. // --------------------------------------------------------------------
  1009. Popup.prototype.setTop = function(top) {
  1010.         this.div.style.top = top+"px";
  1011. };
  1012. Popup.prototype.setLeft = function(left) {
  1013.         this.div.style.left = left+"px";
  1014. };
  1015. Popup.prototype.getTop = function() {
  1016.         return parseInt(CSS.getStyle(this.div,"top"),10);
  1017. };
  1018. Popup.prototype.getLeft = function() {
  1019.         return parseInt(CSS.getStyle(this.div,"left"),10);
  1020. };
  1021.  
  1022. // All the logic to position the popup based on various criteria
  1023. // --------------------------------------------------------------------
  1024. Popup.prototype.setPosition = function() {
  1025.         if (this.position!=null) {
  1026.                 var m = this.position.match(/^(\S+)\s+(\S+)/);
  1027.                 if (m!=null && m.length==3) {
  1028.                         var v = m[1];
  1029.                         var h = m[2];
  1030.  
  1031.                         var ref = this.reference;
  1032.                         if (ref==null) { ref = Screen.getBody(); }
  1033.                         var p = Position.get(ref);
  1034.                         var refTop = p.top;
  1035.                         var refLeft = p.left;
  1036.                         var refWidth = DOM.getOuterWidth(ref);
  1037.                         var refHeight = DOM.getOuterHeight(ref);
  1038.                        
  1039.                         var width = DOM.getOuterWidth(this.div);
  1040.                         var height = DOM.getOuterHeight(this.div);
  1041.                        
  1042.                         var scrollLeft = Screen.getScrollLeft();
  1043.                         var scrollTop = Screen.getScrollTop();
  1044.  
  1045.                         // Set vertical position relative to reference object
  1046.                         if (v=="above") { this.setTop(refTop-height+this.offsetTop); }
  1047.                         else if (v=="top") { this.setTop(refTop+this.offsetTop); }
  1048.                         else if (v=="center") { this.setTop(refTop+(refHeight/2)-(height/2)+this.offsetTop); }
  1049.                         else if (v=="bottom") { this.setTop(refTop+refHeight-height+this.offsetTop); }
  1050.                         else if (v=="below") { this.setTop(refTop+refHeight+this.offsetTop); }
  1051.  
  1052.                         // Set horizontal position relative to reference object
  1053.                         if (h=="adjacent-left") { this.setLeft(refLeft-width+this.offsetLeft); }
  1054.                         else if (h=="left") { this.setLeft(refLeft+this.offsetLeft); }
  1055.                         else if (h=="center") { this.setLeft(refLeft+(refWidth/2)-(width/2)+this.offsetLeft); }
  1056.                         else if (h=="right") { this.setLeft(refLeft+refWidth-width+this.offsetLeft); }
  1057.                         else if (h=="adjacent-right") { this.setLeft(refLeft+refWidth+this.offsetLeft); }
  1058.                 }
  1059.         }
  1060.         else if (this.top==null && this.left==null) {
  1061.                 this.center();
  1062.         }
  1063.         else {
  1064.                 if (this.top==null) { this.top=0; }
  1065.                 if (this.left==null) { this.left=0; }
  1066.                 this.div.style.top = this.top+this.offsetTop+"px";
  1067.                 this.div.style.left = this.left+this.offsetLeft+"px";
  1068.         }
  1069.  
  1070.         // Re-position to make sure it stays on the screen
  1071.         if (this.constrainToScreen) {
  1072.                 this.fitToScreen();
  1073.         }
  1074. };
  1075.  
  1076. // Append an object to the body
  1077. // --------------------------------------------------------------------
  1078. Popup.prototype.appendToBody = function(o) {
  1079.         var body = Screen.getBody();
  1080.         if (body && body.appendChild) {
  1081.                 body.appendChild(o);
  1082.         }
  1083. };
  1084.  
  1085. // Create a new DIV object to be used for a popup
  1086. // --------------------------------------------------------------------
  1087. Popup.prototype.createDiv = function() {
  1088.         if (document.createElement) {
  1089.                 var d = document.createElement("DIV");
  1090.                 d.style.position="absolute";
  1091.                 d.style.display="block";
  1092.                 d.style.visibility="hidden";
  1093.                 this.appendToBody(d);
  1094.                 return d;
  1095.         }
  1096.         alert("ERROR: Couldn't create DIV element in Popup.prototype.createDiv()");
  1097.         return null;
  1098. };
  1099.  
  1100. // Create a new IFRAME object to be used behind the popup
  1101. // --------------------------------------------------------------------
  1102. Popup.prototype.createIframe = function() {
  1103.         if (document.createElement) {
  1104.                 var i= document.createElement("IFRAME");
  1105.                 i.style.position="absolute";
  1106.                 i.style.display="block";
  1107.                 i.style.visibility="hidden";
  1108.                 i.style.background="none";
  1109.                 this.appendToBody(i);
  1110.                 return i;
  1111.         }
  1112.         else {
  1113.                 alert("ERROR: Couldn't create IFRAME object in Popup.prototype.createIframe()");
  1114.         }
  1115. };
  1116.  
  1117. // Add an IFRAME shim for the DIV
  1118. // --------------------------------------------------------------------
  1119. Popup.prototype.addIframeShim = function() {
  1120.         if (this.iframe==null) {
  1121.                 this.iframe = this.createIframe();
  1122.         }
  1123.         this.iframe.className = Popup.iframeClass;
  1124.         CSS.setStyle(this.iframe,'top',this.getTop()+"px");
  1125.         CSS.setStyle(this.iframe,'left',this.getLeft()+"px");
  1126.         CSS.setStyle(this.iframe,'width',DOM.getOuterWidth(this.div) + "px");
  1127.         CSS.setStyle(this.iframe,'height',DOM.getOuterHeight(this.div) + "px");
  1128.         CSS.setStyle(this.iframe,'zIndex',Popup.minZIndex++);
  1129.         CSS.setStyle(this.iframe,'opacity',0);
  1130.         CSS.setStyle(this.iframe,'visibility','visible');
  1131.         CSS.setStyle(this.iframe,'display','block');
  1132. };
  1133.  
  1134. // Create a "screen" to make a popup modal
  1135. // --------------------------------------------------------------------
  1136. Popup.prototype.addScreen = function() {
  1137.         if (this.screen==null) {
  1138.                 this.screen = this.createDiv();
  1139.                 this.screen.style.top="0px";
  1140.                 this.screen.style.left="0px";
  1141.                 this.screen.style.backgroundColor = this.screenColor;
  1142.                 this.screen.className=Popup.screenClass;;
  1143.                 CSS.setStyle(this.screen,"opacity",this.screenOpacity);
  1144.                 this.screen.onclick = function(e) { Event.cancelBubble(Event.resolve(e)); }
  1145.         }
  1146.         if (this.screenIframeShim==null) {
  1147.                 this.screenIframeShim = this.createIframe();
  1148.                 this.screenIframeShim.style.top="0px";
  1149.                 this.screenIframeShim.style.left="0px";
  1150.                 this.screenIframeShim.className=Popup.screenIframeClass;
  1151.                 CSS.setStyle(this.screenIframeShim,"opacity",0);
  1152.         }
  1153.         this.screen.style.width = Screen.getDocumentWidth()+"px";
  1154.         this.screen.style.height = Screen.getDocumentHeight()+"px";
  1155.         this.screenIframeShim.style.width = Screen.getDocumentWidth()+"px";
  1156.         this.screenIframeShim.style.height = Screen.getDocumentHeight()+"px";
  1157.         this.screenIframeShim.style.zIndex = Popup.minZIndex++;
  1158.         this.screenIframeShim.style.visibility="visible";
  1159.         this.screenIframeShim.style.display="block";
  1160.         this.screen.style.zIndex = Popup.minZIndex++;
  1161.         this.screen.style.visibility="visible";
  1162.         this.screen.style.display="block";
  1163. };
  1164.  
  1165. // Re-position the DIV so it stays on the screen
  1166. // --------------------------------------------------------------------
  1167. Popup.prototype.fitToScreen = function() {
  1168.         var width = DOM.getOuterWidth(this.div);
  1169.         var height = DOM.getOuterHeight(this.div);
  1170.         var top = this.getTop();
  1171.         var left = this.getLeft();
  1172.        
  1173.         var clientWidth = Screen.getViewportWidth();
  1174.         var clientHeight = Screen.getViewportHeight();
  1175.        
  1176.         var scrollLeft = Screen.getScrollLeft();
  1177.         var scrollTop = Screen.getScrollTop();
  1178.  
  1179.         if (top-scrollTop+height>clientHeight) {
  1180.                 top = top - ((top+height) - (scrollTop+clientHeight));
  1181.                 this.div.style.top = top + "px";
  1182.         }
  1183.         if (left-scrollLeft+width>clientWidth) {
  1184.                 left = left - ((left+width) - (scrollLeft+clientWidth));
  1185.                 this.div.style.left = left + "px";
  1186.         }
  1187.         if (top<scrollTop) {
  1188.                 this.div.style.top=scrollTop+"px";
  1189.         }
  1190.         if (left<scrollLeft) {
  1191.                 this.div.style.left=scrollLeft+"px";
  1192.         }
  1193. };
  1194.  
  1195. // Center the DIV object
  1196. // --------------------------------------------------------------------
  1197. Popup.prototype.center = function() {
  1198.         var left = DOM.getOuterWidth(this.div);
  1199.         var top = DOM.getOuterHeight(this.div);
  1200.         if (isNaN(left)) { left=0; }
  1201.         if (isNaN(top)) { top=0; }     
  1202.         var clientW = Screen.getViewportWidth();
  1203.         var clientH = Screen.getViewportHeight();
  1204.         if (clientW!=null && clientH!=null) {
  1205.                 top = (clientH-top)/2;
  1206.                 left = (clientW-left)/2;
  1207.         }
  1208.         top += Screen.getScrollTop();
  1209.         left += Screen.getScrollLeft();
  1210.        
  1211.         this.div.style.top = top+this.offsetTop+"px";
  1212.         this.div.style.left = left+this.offsetLeft+"px";
  1213. };

Raw Paste


Login or Register to edit or fork this paste. It's free.