]*> <\/p><\/p>/ig, "]*?\/>/ig, "").replace(/<(p|div)[^>]*?> <\/(\1)[^>]*?>/ig, "").replace(/<(p|div)[^>]*?><\/(\1)[^>]*?>/ig, "");
+
+ // remove some attributes
+ do {
+ old_ret = ret;
+ ret = ret.replace(/<([^>]*)(?:class|size|lang|face|start|type|border|[ovwxp]:\w+)=(?:\'[^\']*\'|\"[^\"]*\"|[^> ]+)([^>]*)>/ig, "<$1$2>");
+ } while(ret != old_ret)
+
+ // remain enabled tags only
+
+ var div = document.createElement("div");
+
+ div.innerHTML = ret;
+
+ function diver(elem) {
+ var n = elem.childNodes.length;
+
+ for(var i = 0; i < elem.childNodes.length; i++) {
+ var child = elem.childNodes.item(i);
+
+ if(child.nodeType == 1) {
+ if(child.tagName.indexOf("/") >= 0) {
+ i--;
+ child.parentNode.removeChild(child);
+ } else {
+ var search = child.tagName.toLowerCase(),
+ found = false,
+ nn = Sys.Extended.UI.HtmlEditor.enabledWordTags.length;
+
+ for(var j = 0; j < nn; j++)
+ if(Sys.Extended.UI.HtmlEditor.enabledWordTags[j] == search) {
+ found = true;
+ break;
+ }
+
+ diver(child);
+ if(!found) {
+ i += child.childNodes.length;
+ while(child.firstChild)
+ child.parentNode.insertBefore(child.firstChild, child);
+
+ child.parentNode.removeChild(child);
+ i--;
+ } else {
+ var s_background_color = child.style.backgroundColor,
+ s_color = child.style.color;
+
+ child.style.cssText = "";
+ child.removeAttribute("style");
+
+ if(child.getAttribute("width") && child.getAttribute("width").length > 0)
+ child.style.width = child.getAttribute("width");
+ if(child.width && child.width.length > 0)
+ child.style.width = child.width;
+
+ child.width = "";
+ try {
+ child.removeAttribute("width");
+ } catch(e) { }
+
+ if(child.getAttribute("height") && child.getAttribute("height").length > 0)
+ child.style.height = child.getAttribute("height");
+ if(child.height && child.height.length > 0)
+ child.style.height = child.height;
+
+ child.height = "";
+ try {
+ child.removeAttribute("height");
+ } catch(e) { }
+
+ if(search == "table") {
+ child.style.borderLeftWidth = "1px";
+ child.style.borderLeftColor = "black";
+ child.style.borderLeftStyle = "solid";
+ child.style.borderTopWidth = "1px";
+ child.style.borderTopColor = "black";
+ child.style.borderTopStyle = "solid";
+
+ child.style.backgroundColor = s_background_color;
+ child.style.color = s_color;
+ }
+
+ if(search == "td") {
+ child.style.borderRightWidth = "1px";
+ child.style.borderRightColor = "black";
+ child.style.borderRightStyle = "solid";
+ child.style.borderBottomWidth = "1px";
+ child.style.borderBottomColor = "black";
+ child.style.borderBottomStyle = "solid";
+
+ child.style.backgroundColor = s_background_color;
+ child.style.color = s_color;
+ }
+
+ if(search == "font" || search == "span") {
+ child.style.backgroundColor = s_background_color;
+ child.style.color = s_color;
+
+ var attrs = child.attributes,
+ n = 0;
+
+ for(var m = 0; m < attrs.length; ++m) {
+ var a = attrs.item(m);
+ if(!a.specified)
+ continue;
+ n++;
+ }
+
+ if(n == 0 && child.style.cssText == "") {
+ i += child.childNodes.length;
+ while(child.firstChild)
+ child.parentNode.insertBefore(child.firstChild, child);
+
+ child.parentNode.removeChild(child);
+ i--;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ diver(div);
+ ret = Sys.Extended.UI.HtmlEditor.Trim(div.innerHTML);
+ delete div;
+
+ ret = ret.replace(/<[\/]?(xml|del|ins)[^>]*?>/ig, "") // remove some tags (content should be remained)
+ .replace(/<(p|div)[^>]*?>/ig, "") // remove P, DIV tags (content should be remained) <\/b>/ig, "").replace(/<\/i>/ig, "").replace(/<\/u>/ig, "").replace(/<\/strong>/ig, "").replace(/<\/em>/ig, "").replace(/<\/sub>/ig, "").replace(/<\/sup>/ig, "");
+ ret = ret.replace(/]*?><\/span>/ig, "").replace(/([^<]+?)<\/span>/ig, "$1");
+ ret = ret.replace(/]*?><\/font>/ig, "").replace(/([^<]+?)<\/font>/ig, "$1");
+ } while(ret != old_ret)
+
+ // replace all Microsoft special characters
+ ret = ret.replace(/’/g, "'")
+ .replace(/‘/g, "'")
+ .replace(/–/g, "-")
+ .replace(/—/g, "-")
+ .replace(/…/g, "...")
+ .replace(/"/g, "\"")
+ .replace(/“/g, "\"")
+ .replace(/”/g, "\"")
+ .replace(//g, "")
+ .replace(/•/g, "")
+ .replace(/[ \s]+/g, " ").replace(/(( )+)/g, " "); // remove extra spaces
+
+ if(document.all)
+ ret = ret.replace(/^[\x00-\x1F]* /, "");
+
+ return ret;
+};
+
+Sys.Extended.UI.HtmlEditor.spanJoiner = function(element, doc, sFrom, sTo, nobr) {
+ var sIndex = 0,
+ sLength = element.childNodes.length;
+
+ if(typeof sFrom != "undefined" && sFrom != null)
+ sIndex = sFrom;
+ if(typeof sTo != "undefined" && sTo != null)
+ sLength = sTo;
+
+ for(var i = sIndex; i < sLength && i < element.childNodes.length; i++) {
+ var child = element.childNodes.item(i)
+ if(child.parentNode != element)
+ continue;
+
+ switch(child.nodeType) {
+ case 1: // Node.ELEMENT_NODE
+ if(child.childNodes.length == 0 && Sys.Extended.UI.HtmlEditor.isStyleTag(child.tagName) && child.tagName.toUpperCase() != "A" && !(child.className.length > 0 || (child.getAttribute("class") && child.getAttribute("class").length > 0)) && !Sys.Extended.UI.HtmlEditor.isTempElement(child)) {
+ element.removeChild(child);
+ i--;
+ sLength--;
+ continue;
+ }
+
+ if(child.tagName.toUpperCase() == "SPAN") {
+ while(child.childNodes.length == 1 && child.firstChild.nodeType == 1) {
+ if(child.firstChild.tagName.toUpperCase() == "SPAN" && !Sys.Extended.UI.HtmlEditor.isTempElement(child.firstChild)) {
+ var attrs = Sys.Extended.UI.HtmlEditor.differAttr(child.firstChild, []),
+ styles = Sys.Extended.UI.HtmlEditor.differStyle(child.firstChild),
+ oldSpan = child.firstChild,
+ chieldren = oldSpan.childNodes;
+
+ while(oldSpan.firstChild != null)
+ child.insertBefore(oldSpan.firstChild, oldSpan);
+
+ for(var j = 0; j < styles.length; j++) {
+ if(styles[j][1]) {
+ try {
+ if(child.style[styles[j][0]]) {
+ if(styles[j][0].toLowerCase().indexOf("color") >= 0) {
+ child.style[styles[j][0]] = styles[j][1];
+ } else {
+ try {
+ var sv = child.style[styles[j][0]];
+
+ child.style[styles[j][0]] = child.style[styles[j][0]] + " " + styles[j][1];
+
+ if(sv == child.style[styles[j][0]])
+ child.style[styles[j][0]] = styles[j][1];
+ } catch(e) {
+ child.style[styles[j][0]] = styles[j][1];
+ }
+ }
+ } else {
+ child.style[styles[j][0]] = styles[j][1];
+ }
+ } catch(ee) { }
+ }
+ }
+
+ for(var j = 0; j < attrs.length; j++)
+ if(attrs[j][1])
+ child.setAttribute(attrs[j][0], attrs[j][1]);
+
+ child.removeChild(oldSpan);
+ continue;
+ } else {
+ if(child.firstChild.tagName.toUpperCase() == "SPAN" && Sys.Extended.UI.HtmlEditor.isTempElement(child.firstChild)) {
+ var svv = child.firstChild;
+
+ child.parentNode.insertBefore(child.firstChild, child);
+ child.parentNode.removeChild(child);
+ child = svv;
+ }
+ }
+
+ break;
+ }
+
+ var tempArr = [],
+ nextChild = child.nextSibling;
+
+ while(!Sys.Extended.UI.HtmlEditor.isTempElement(child) && nextChild && i + 1 < sLength && (nextChild.nodeType == 3 || (nextChild.nodeType == 1 &&
+ (nextChild.tagName.toUpperCase() == "SPAN" || (nextChild.tagName.toUpperCase() == "BR") && typeof nobr == "undefined") &&
+ !Sys.Extended.UI.HtmlEditor.isTempElement(nextChild)))) {
+ if(nextChild.nodeType == 3) {
+ if(("" + nextChild.data + "").length == 0) {
+ nextChild.parentNode.removeChild(nextChild);
+ nextChild = child.nextSibling;
+ sLength--;
+ } else {
+ break;
+ }
+ } else {
+ if(nextChild.tagName.toUpperCase() == "BR") {
+ tempArr.push(nextChild);
+ nextChild = nextChild.nextSibling;
+ } else {
+ var attrs = Sys.Extended.UI.HtmlEditor.differAttr(child, [], nextChild),
+ styles = Sys.Extended.UI.HtmlEditor.differStyle(child, nextChild);
+
+ if(attrs.length == 0 && styles.length == 0 && child.className == nextChild.className) {
+ var n = tempArr.length;
+
+ for(var j = 0; j < n; j++) {
+ child.appendChild(tempArr[j]);
+ sLength--;
+ }
+ tempArr = [];
+
+ while(nextChild.firstChild)
+ child.appendChild(nextChild.firstChild);
+
+ nextChild.parentNode.removeChild(nextChild);
+ nextChild = child.nextSibling;
+ sLength--;
+ } else {
+ break;
+ }
+ }
+ }
+ }
+
+ if(!Sys.Extended.UI.HtmlEditor.isTempElement(child) && child.className.length == 0) {
+ var attrs = Sys.Extended.UI.HtmlEditor.differAttr(child, []),
+ styles = Sys.Extended.UI.HtmlEditor.differStyle(child);
+
+ if(attrs.length == 0 && styles.length == 0) {
+ i--;
+ sLength--;
+
+ while(child.firstChild) {
+ child.parentNode.insertBefore(child.firstChild, child);
+ sLength++;
+ }
+ child.parentNode.removeChild(child);
+
+ continue;
+ }
+ }
+ }
+
+ if(child.parentNode != null) {
+ if(child.childNodes.length == 0 && Sys.Extended.UI.HtmlEditor.isStyleTag(child.tagName) && child.tagName.toUpperCase() != "A" && !(child.className.length > 0 || (child.getAttribute("class") && child.getAttribute("class").length > 0)) && !Sys.Extended.UI.HtmlEditor.isTempElement(child)) {
+ element.removeChild(child);
+ i--;
+ sLength--;
+
+ continue;
+ } else {
+ Sys.Extended.UI.HtmlEditor.spanJoiner(child, doc);
+ }
+ }
+ break;
+ }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor._styleTags = [
+ "strong",
+ "em",
+ "u",
+ "strike",
+ "s",
+ "span",
+ "font",
+ "b",
+ "sub",
+ "sup",
+ "a",
+ "i"
+];
+
+Sys.Extended.UI.HtmlEditor.isStyleTag = function(tag) {
+ if(!tag)
+ return false;
+
+ for(var i = 0; i < Sys.Extended.UI.HtmlEditor._styleTags.length; i++)
+ if(Sys.Extended.UI.HtmlEditor._styleTags[i].toLowerCase() == tag.toLowerCase())
+ return true;
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor.smartClassName = "MSIEparagraph";
+Sys.Extended.UI.HtmlEditor.noContextMenuAttribute = "obout-no-contextmenu";
+
+Sys.Extended.UI.HtmlEditor.isTempElement = function(el) {
+ if(el.id && el.id.length > 0 && el.id.indexOf(Sys.Extended.UI.HtmlEditor.smartClassName) >= 0)
+ return true;
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor.differAttr = function(element, pr, comp) {
+ var result = [],
+ parent = element.parentNode;
+
+ if(typeof comp != "undefined")
+ parent = comp;
+
+ if(!parent || !parent.tagName || !Sys.Extended.UI.HtmlEditor.isStyleTag(parent.tagName))
+ parent = null;
+
+ if(element.attributes)
+ for(var i = 0; i < element.attributes.length; i++) {
+ var attr = element.attributes[i],
+ brk = false;
+
+ for(var j = 0; j < pr.length; j++)
+ if(attr.name.toUpperCase() == pr[j].toUpperCase()) {
+ brk = true;
+ break;
+ }
+
+ if(brk)
+ continue;
+
+ if(attr.name.toUpperCase() == "STYLE")
+ continue;
+ if(attr.name.toUpperCase().substr(0, 4) == "_MOZ")
+ continue;
+
+ if(attr.specified)
+ if(parent && parent.attributes && parent.attributes[attr.name]) {
+ var pattr = parent.attributes[attr.name];
+
+ if(pattr)
+ if(attr.name != pattr.name || attr.value != pattr.value)
+ result.push([attr.name, attr.value]);
+ } else {
+ if(attr.name.toUpperCase() == "CLASS" && attr.value == "")
+ continue;
+
+ result.push([attr.name, attr.value]);
+ }
+ }
+
+ return result;
+};
+
+Sys.Extended.UI.HtmlEditor.differStyle = function(element, comp) {
+ var result = [],
+ parent = element.parentNode;
+
+ if(typeof comp != "undefined")
+ parent = comp;
+
+ if(!parent || !parent.tagName || !Sys.Extended.UI.HtmlEditor.isStyleTag(parent.tagName))
+ parent = null;
+
+ function _putStyle(i, _style) {
+ _style = "" + _style;
+
+ if(i.toLowerCase() == "textdecoration") {
+ var _arr = _style.split(" ");
+
+ for(var j = 0; j < _arr.length; j++)
+ result.push([i, Sys.Extended.UI.HtmlEditor.Trim(_arr[j])]);
+ } else {
+ result.push([i, _style]);
+ }
+ }
+
+ for(var i in element.style) {
+ if(i && typeof i == "string" && i != "accelerator") {
+ var ii = i;
+
+ if(!isNaN(parseInt(i))) {
+ if(!Sys.Extended.UI.HtmlEditor.isSafari)
+ continue;
+
+ ii = element.style[i];
+ }
+
+ var style = element.style[ii];
+
+ if(style && typeof style == "string" && style != "accelerator") {
+ if(parent && parent.style) {
+ var pstyle = parent.style[ii];
+
+ if(ii.toLowerCase() != "csstext" && ii.toLowerCase() != "length")
+ if(style != pstyle)
+ _putStyle(ii, style);
+ } else {
+ if(ii.toLowerCase() != "csstext" && ii.toLowerCase() != "length")
+ _putStyle(ii, style);
+ }
+ }
+ }
+ }
+
+ if(typeof comp != "undefined")
+ for(var i in parent.style) {
+ if(i && typeof i == "string" && i != "accelerator") {
+ var ii = i;
+
+ if(!isNaN(parseInt(i))) {
+ if(!Sys.Extended.UI.HtmlEditor.isSafari)
+ continue;
+
+ ii = element.style[i];
+ }
+
+ var style = parent.style[ii];
+ if(style && typeof style == "string" && style != "accelerator") {
+ var pstyle = element.style[ii];
+
+ if(i.toLowerCase() != "csstext" && ii.toLowerCase() != "length")
+ if(style != pstyle)
+ _putStyle(ii, style);
+ }
+ }
+ }
+
+ return result;
+};
+
+Sys.Extended.UI.HtmlEditor.brXHTML = function(str) {
+ return str.replace(/]/ig.test(innerHTML)))
+ return;
+
+ for(var i = 0; i < root.childNodes.length; i++) {
+ var child = root.childNodes.item(i);
+
+ if(child.nodeType == 1) {
+ var found = null,
+ childTagName = child.tagName.toLowerCase();
+
+ for(var j = 0; j < Sys.Extended.UI.HtmlEditor.replacingRules.length; j++)
+ if(Sys.Extended.UI.HtmlEditor.replacingRules[j][0].toLowerCase() == childTagName) {
+ found = Sys.Extended.UI.HtmlEditor.replacingRules[j];
+ break;
+ }
+
+ if(found) {
+ var span = editor._doc.createElement("SPAN");
+
+ span.style["cssText"] = child.style["cssText"];
+
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ span.style[found[1]] = found[2];
+ else
+ span.style[found[1].replace(/\-(\w)/g, function(strMatch, p1) { return p1.toUpperCase(); })] = found[2];
+
+ while(child.firstChild)
+ span.appendChild(child.firstChild);
+
+ root.insertBefore(span, child);
+ root.removeChild(child);
+ child = span;
+ } else {
+ if(childTagName == "font") {
+ var span = editor._doc.createElement("SPAN"),
+ save = child.size;
+
+ span.style["cssText"] = child.style["cssText"];
+
+ if(child.color)
+ span.style.color = child.color;
+
+ if(child.face)
+ span.style.fontFamily = child.face;
+
+ while(child.firstChild)
+ span.appendChild(child.firstChild);
+
+ root.insertBefore(span, child);
+ root.removeChild(child);
+
+ if(save) {
+ var font = editor._doc.createElement("FONT");
+ font.size = save;
+ root.insertBefore(font, span);
+
+ if(span.style["cssText"].length > 0) {
+ font.appendChild(span);
+ child = span;
+ } else {
+ while(span.firstChild)
+ font.appendChild(span.firstChild);
+
+ root.removeChild(span);
+ child = font;
+ }
+ } else {
+ child = span;
+ }
+ }
+ }
+ Sys.Extended.UI.HtmlEditor.replaceOldTags(child, editor);
+ }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.getStyle = function(oElm, strCssRule) {
+ var strValue = "";
+
+ if(oElm.nodeType == 1) {
+ if(oElm.ownerDocument && oElm.ownerDocument.defaultView && oElm.ownerDocument.defaultView.getComputedStyle) {
+ strValue = oElm.ownerDocument.defaultView.getComputedStyle(oElm, "").getPropertyValue(strCssRule);
+ } else if(oElm.currentStyle) {
+ try {
+ strCssRule = strCssRule.replace(/\-(\w)/g, function(strMatch, p1) { return p1.toUpperCase(); });
+ strValue = oElm.currentStyle[strCssRule];
+ } catch(ex) {
+ strValue = oElm.style[strCssRule];
+ }
+ } else {
+ strValue = oElm.style[strCssRule];
+ }
+ }
+
+ return strValue;
+};
+
+Sys.Extended.UI.HtmlEditor._Marker = function(editor, rng, sel) {
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ this._nArr = Sys.Extended.UI.HtmlEditor.getNames(editor._doc.body);
+ this._save = editor._doc.body.innerHTML;
+ this._tree = null;
+
+ if(sel.type.toLowerCase() == "control") {
+ try {
+ var el = rng.item(0);
+ this._tree = [];
+
+ while(el && (el.nodeType == 3 || !el.tagName || el.tagName.toUpperCase() != "BODY")) {
+ var n = 0;
+
+ while(el.previousSibling) {
+ n++;
+ el = el.previousSibling;
+ }
+
+ this._tree.push(n);
+ el = el.parentNode;
+ }
+ } catch(e) { }
+ } else {
+ this._offsetLeft = rng.offsetLeft;
+ this._offsetTop = rng.offsetTop;
+ }
+ } else {
+ if(Sys.Extended.UI.HtmlEditor.isOpera)
+ this._save = Sys.Extended.UI.HtmlEditor.Trim(editor._doc.body.innerHTML);
+ else
+ this._save = editor._doc.body.cloneNode(true);
+
+ this._tree = [];
+ this._offset = 0;
+
+ try {
+ var el = rng.startContainer;
+ this._offset = rng.startOffset;
+
+ if(el && el.nodeType == 1 && el.tagName.toUpperCase() == "HTML") {
+ el = editor._doc.body;
+
+ setTimeout(function() {
+ try {
+ sel = editor._getSelection();
+ rng = editor._createRange();
+ editor._removeAllRanges(sel);
+
+ rng.setStart(el, 0);
+ rng.setEnd(el, 0);
+ editor._selectRange(sel, rng);
+ } catch(e) { }
+ }, 0);
+ }
+
+ while(el && el.nodeType && (el.nodeType == 3 || !el.tagName || el.tagName.toUpperCase() != "BODY")) {
+ var n = 0;
+
+ while(el.previousSibling) {
+ n++;
+
+ if(Sys.Extended.UI.HtmlEditor.isOpera)
+ if(el.nodeType == 3 && el.previousSibling != null && el.previousSibling.nodeType == 3)
+ n--;
+
+ el = el.previousSibling;
+ }
+
+ this._tree.push(n);
+ el = el.parentNode;
+ }
+ } catch(e) { }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.__stackMaxSize = 30;
+
+Sys.Extended.UI.HtmlEditor.getNames = function(el) {
+ var aList = el.all,
+ mArr = [],
+ nArr = []
+
+ for(var i = 0; i < aList.length; i++) {
+ var a = aList[i];
+
+ if(a.name && a.name.length > 0) {
+ var tag = a.tagName,
+ coll = el.getElementsByTagName(tag),
+ n = 0;
+
+ for(var j = 0; j < coll.length; j++)
+ if(coll[j] == a) {
+ n = j;
+
+ break;
+ }
+
+ nArr[tag] = n;
+ mArr.push([tag, nArr[tag], a.name]);
+ }
+ }
+
+ return mArr;
+};
+
+Sys.Extended.UI.HtmlEditor.setNames = function(el, mArr) {
+ for(var i = 0; i < mArr.length; i++)
+ if(el.getElementsByTagName(mArr[i][0]).length > mArr[i][1])
+ el.getElementsByTagName(mArr[i][0])[mArr[i][1]].name = mArr[i][2];
+};
+
+Sys.Extended.UI.HtmlEditor._lookChild = function(root, seek) {
+ for(var i = 0; i < root.childNodes.length; i++) {
+ var child = root.childNodes.item(i);
+
+ if(child == seek)
+ return i;
+
+ if(child.nodeType == 1)
+ if(Sys.Extended.UI.HtmlEditor._lookChild(child, seek) >= 0)
+ return i;
+ }
+
+ return -1;
+};
+
+Sys.Extended.UI.HtmlEditor.getHrefsText = function(txt) {
+ var result = []
+
+ function regRepl(p0, p1, p2, p3, p4, p5, p6, p7) {
+ var tag = p1.replace(/^<([^\s>]+)/, "$1"),
+ insert = true,
+ i = 0;
+
+ for(; i < result.length; i++)
+ if(result[i][0] == tag) {
+ insert = false;
+ break;
+ }
+
+ if(insert)
+ result[i] = [tag];
+
+ result[i].push(p5);
+ };
+
+ var reg = new RegExp("(<[^\\s><]+)([^><]*?)(href=)(\"|')([^\\4]*?)(\\4)((?:[^><]*?)>)", "ig");
+ txt.replace(reg, regRepl);
+
+ return result;
+};
+
+Sys.Extended.UI.HtmlEditor.setHrefsText = function(el, mArr) {
+ for(var j = 0; j < mArr.length; j++) {
+ var aList = el.getElementsByTagName(mArr[j][0]),
+ k = 1;
+
+ for(var i = 0; i < aList.length; i++) {
+ if(!aList[i].href)
+ continue;
+
+ if(mArr[j][k] && mArr[j][k].length > 0) {
+ var trickIE;
+
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ trickIE = aList[i].innerHTML;
+
+ aList[i].href = mArr[j][k].replace(/&/ig, "&");
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ aList[i].innerHTML = trickIE;
+ }
+ k++;
+ }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.getImagesText = function(txt) {
+ var mArr = [];
+
+ function regRepl(p0, p1, p2, p3, p4, p5) {
+ mArr.push(p3);
+
+ return p0;
+ }
+
+ txt.replace(/()/ig, regRepl);
+
+ return mArr;
+};
+
+Sys.Extended.UI.HtmlEditor.setImagesText = function(el, mArr) {
+ var aList = el.getElementsByTagName("IMG"),
+ k = 0;
+
+ for(var i = 0; i < aList.length; i++) {
+ if(!aList[i].src)
+ continue;
+
+ if(mArr[k] && mArr[k].length > 0)
+ aList[i].src = mArr[k].replace(/&/ig, "&");
+
+ k++;
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.canHaveChildren = function(elem) {
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ return elem.canHaveChildren;
+ else
+ return !/^(area|base|basefont|col|frame|hr|img|br|input|isindex|link|meta|param)$/.test(elem.tagName.toLowerCase());
+};
+
+Sys.Extended.UI.HtmlEditor._setCursor = function(el1, editor) {
+ var el = el1;
+
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ var sel = editor._getSelection(),
+ range = editor._createRange(sel);
+
+ if(sel.type.toLowerCase() == "control") {
+ range.remove(0);
+ sel.empty();
+ range = editor._createRange();
+ }
+
+ var isText = (el.nodeType == 3),
+ span;
+
+ if(isText) {
+ span = editor._doc.createElement("SPAN");
+ span.innerHTML = " ";
+
+ el.parentNode.insertBefore(span, el);
+ el = span;
+ }
+
+ var location = $common.getLocation(el),
+ _left = location.x, _top = location.y;
+
+ if(isText)
+ span.parentNode.removeChild(span);
+
+ try {
+ range.moveToPoint(_left, _top);
+ } catch(e) { }
+
+ range.select();
+ } else {
+ var sel = editor._getSelection(),
+ range = editor._createRange();
+
+ range.setStart(el, 0);
+ range.setEnd(el, 0);
+
+ editor._removeAllRanges(sel);
+ editor._selectRange(sel, range);
+ editor.focusEditor();
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.myClone = function(el, doc, prize) {
+ var ela;
+
+ if(Sys.Extended.UI.HtmlEditor.isIE && el.tagName && (el.tagName.toUpperCase() == "EMBED" || el.tagName.toUpperCase() == "OBJECT")) {
+ var div = doc.createElement("DIV");
+
+ try {
+ div.innerHTML = el.outerHTML;
+ ela = div.firstChild;
+ } catch(e) {
+ ela = el;
+ }
+
+ delete div;
+ } else {
+ ela = el.cloneNode(prize);
+ }
+
+ return ela;
+};
+
+Sys.Extended.UI.HtmlEditor.unStyle = function(el) {
+ var _prn = (el.parentNode != null && typeof el.parentNode != "undefined") ? el.parentNode : null;
+
+ if(_prn) {
+ var _fnd = null;
+
+ while(_prn && _prn.tagName && _prn.tagName.toUpperCase() != "BODY" && Sys.Extended.UI.HtmlEditor.isStyleTag(_prn.tagName) &&
+ (_prn.tagName.toUpperCase() != "A")) {
+ _fnd = _prn;
+ _prn = _prn.parentNode;
+ }
+
+ if(_fnd) {
+ function diver(add, el, rpr, before, prize) {
+ var par = rpr.cloneNode(false);
+
+ if(add)
+ if(add.push && typeof add.push == "function")
+ for(var iii = 0; iii < add.length; iii++)
+ par.appendChild(add[iii]);
+ else
+ par.appendChild(add);
+
+ if(prize) {
+ par.appendChild(el);
+ } else {
+ while(el) {
+ var elSibling = before ? el.previousSibling : el.nextSibling;
+
+ if(el.nodeType == 1 || (el.nodeType == 3 && Sys.Extended.UI.HtmlEditor.Trim("" + el.data + "").length > 0)) {
+ if(el.nodeType == 1)
+ if(el.tagName && Sys.Extended.UI.HtmlEditor.isStyleTag(el.tagName) && el.childNodes.length == 0 && !Sys.Extended.UI.HtmlEditor.isTempElement(el))
+ el = null;
+
+ if(el) {
+ if(par.childNodes.length == 0 || !before)
+ par.appendChild(el);
+ else
+ par.insertBefore(el, par.firstChild);
+ }
+ }
+
+ el = elSibling;
+ }
+ }
+
+ if(par.childNodes.length == 0) {
+ delete par;
+ par = null;
+ } else if(par.childNodes.length == 1 && par.firstChild.nodeType == 3 && ("" + par.firstChild.data + "").length == 0) {
+ delete par;
+ par = null;
+ } else {
+ if(!prize && par.tagName && Sys.Extended.UI.HtmlEditor.isStyleTag(par.tagName) && (par.tagName.toUpperCase() != "A") && !Sys.Extended.UI.HtmlEditor.isTempElement(par)) {
+ var elNumber = par.childNodes.length;
+
+ for(var cnt = 0; cnt < par.childNodes.length; cnt++) {
+ var inn = par.childNodes.item(cnt);
+
+ if(inn.nodeType == 1 && inn.tagName && !Sys.Extended.UI.HtmlEditor.isStyleTag(inn.tagName) &&
+ (inn.tagName.toUpperCase() == "BR" || inn.tagName.toUpperCase() == "TABLE" ||
+ Sys.Extended.UI.HtmlEditor.isTempElement(inn)))
+ elNumber--;
+ }
+
+ if(elNumber == 0) {
+ var parr = [];
+
+ while(par.firstChild) {
+ var inn = par.removeChild(par.firstChild);
+ parr.push(inn);
+ }
+ par = parr;
+ }
+ }
+ }
+
+ if(rpr == _fnd) {
+ return par;
+ } else {
+ if(!prize)
+ return diver(par, before ? rpr.previousSibling : rpr.nextSibling, rpr.parentNode, before, prize);
+ else
+ return diver(null, par, rpr.parentNode, before, prize);
+ }
+ };
+
+ _prn = el.parentNode;
+
+ if(el.previousSibling == null && el.nextSibling == null &&
+ _prn && _prn.tagName && _prn.tagName.toUpperCase() != "BODY" && Sys.Extended.UI.HtmlEditor.isStyleTag(_prn.tagName) &&
+ Sys.Extended.UI.HtmlEditor.differAttr(_prn, ["class", "color", "face", "size"]).length > 0)
+ el = _prn;
+
+ var p1 = diver(null, el.previousSibling, el.parentNode, true, false),
+ p2 = diver(null, el.nextSibling, el.parentNode, false, false);
+
+ var par = _fnd.parentNode;
+ if(p1) {
+ if(p1.push && typeof p1.push == "function") {
+ for(var iii = 0; iii < p1.length; iii++)
+ par.insertBefore(p1[iii], _fnd);
+ } else {
+ par.insertBefore(p1, _fnd);
+ }
+ }
+
+ if(el.nodeType == 1 && el.tagName &&
+ (el.tagName.toUpperCase() == "BR" || el.tagName.toUpperCase() == "TABLE" ||
+ Sys.Extended.UI.HtmlEditor.isTempElement(el))) {
+ par.insertBefore(el, _fnd);
+ } else {
+ var p3 = diver(null, el, el.parentNode, false, true);
+
+ par.insertBefore(p3, _fnd);
+ }
+
+ if(p2) {
+ if(p2.push && typeof p2.push == "function") {
+ for(var iii = 0; iii < p2.length; iii++)
+ par.insertBefore(p2[iii], _fnd);
+ } else {
+ par.insertBefore(p2, _fnd);
+ }
+ }
+ par.removeChild(_fnd);
+ }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.isTempElement = function(el) {
+ if(el.id && el.id.length > 0 && el.id.indexOf(Sys.Extended.UI.HtmlEditor.smartClassName) >= 0)
+ return true;
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor._moveTagsUp = function(lBound, rBound) {
+ function _dive(next) {
+ if(!Sys.Extended.UI.HtmlEditor.isInlineElement(next) || next.nodeType == 3) {
+ Sys.Extended.UI.HtmlEditor.unStyle(next);
+ } else if(next.tagName && Sys.Extended.UI.HtmlEditor.isStyleTag(next.tagName) && (next.tagName.toUpperCase() != "A") && !Sys.Extended.UI.HtmlEditor.isTempElement(next)) {
+ var nnn = next.firstChild;
+
+ while(nnn != null) {
+ var nnnNext = nnn.nextSibling;
+
+ _dive(nnn);
+ nnn = nnnNext;
+ }
+ }
+ }
+
+ var next = lBound;
+ while(next != null && next != rBound) {
+ var nextSibling = next.nextSibling;
+ _dive(next);
+ next = nextSibling;
+ }
+};
+
+Sys.Extended.UI.HtmlEditor._commonTotalParent = function(first, last) {
+ var ret = null,
+ par = first.parentNode,
+ fst = first;
+
+ while(par) {
+ if(par.tagName && !Sys.Extended.UI.HtmlEditor.isStyleTag(par.tagName)) {
+ var indexLast = Sys.Extended.UI.HtmlEditor._lookChild(par, last);
+
+ if(indexLast >= 0) {
+ var indexFirst = 0;
+
+ for(var i = 0; i < par.childNodes.length; i++)
+ if(par.childNodes.item(i) == fst) {
+ indexFirst = i;
+ break;
+ }
+
+ return { parent: par, indexFirst: indexFirst, indexLast: indexLast };
+ }
+ }
+
+ fst = par;
+ par = par.parentNode;
+ }
+
+ return ret;
+};
+
+Sys.Extended.UI.HtmlEditor._commonParent = function(first, last) {
+ var ret = null,
+ par = first.parentNode,
+ fst = first;
+
+ while(par && par.tagName.toUpperCase() != "BODY" && Sys.Extended.UI.HtmlEditor.isStyleTag(par.tagName)) {
+ var indexLast = Sys.Extended.UI.HtmlEditor._lookChild(par, last);
+
+ if(indexLast >= 0) {
+ var indexFirst = 0;
+
+ for(var i = 0; i < par.childNodes.length; i++) {
+ if(par.childNodes.item(i) == fst) {
+ indexFirst = i;
+ break;
+ }
+ }
+
+ return { parent: par, indexFirst: indexFirst, indexLast: indexLast };
+ }
+
+ fst = par;
+ par = par.parentNode;
+ }
+
+ return ret;
+};
+
+Sys.Extended.UI.HtmlEditor.positionInParagraph = function(marker, el, left, par, wordBound) {
+ while(true) {
+ var result = Sys.Extended.UI.HtmlEditor.positionInParagraphLevel(marker, el, left, wordBound);
+
+ if(result != null)
+ return result;
+
+ if(par.tagName && Sys.Extended.UI.HtmlEditor.isStyleTag(par.tagName) && (par.tagName.toUpperCase() != "A") && !Sys.Extended.UI.HtmlEditor.isTempElement(par)) {
+ el = left ? par.previousSibling : par.nextSibling;
+ par = par.parentNode;
+ } else {
+ if(!left || par.firstChild == null)
+ par.appendChild(marker);
+ else
+ par.insertBefore(marker, par.firstChild);
+
+ return marker;
+ }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.positionInParagraphLevel = function(marker, el, left, wordBound) {
+ while(el) {
+ var elSibling = left ? el.previousSibling : el.nextSibling;
+
+ if(!Sys.Extended.UI.HtmlEditor.isInlineElement(el)) {
+ var par = el.parentNode;
+
+ if(!left) {
+ par.insertBefore(marker, el);
+ } else {
+ if(el.nextSibling)
+ par.insertBefore(marker, el.nextSibling);
+ else
+ par.appendChild(marker);
+ }
+
+ return marker;
+ } else if(typeof wordBound == "function" && el.nodeType == 3) {
+ var j, str = "" + el.data + "";
+
+ if(left) {
+ for(j = str.length - 1; j >= 0; j--)
+ if(wordBound(str.substr(j, 1)))
+ break;
+ } else {
+ for(j = 0; j < str.length; j++)
+ if(wordBound(str.substr(j, 1)))
+ break;
+ }
+
+ if(j >= 0 && j < str.length) {
+ var par = el.parentNode,
+ newNode;
+
+ if((j > 0 || (left && j == 0)) && (j < str.length - 1 || (!left && j == str.length - 1))) {
+ if(left)
+ newNode = el.splitText(j + 1);
+ else
+ newNode = el.splitText(j);
+
+ par.insertBefore(marker, newNode);
+ } else {
+ if(!left) {
+ par.insertBefore(marker, el);
+ } else {
+ if(el.nextSibling)
+ par.insertBefore(marker, el.nextSibling);
+ else
+ par.appendChild(marker);
+ }
+ }
+
+ return marker;
+ }
+ }
+
+ el = left ? el.lastChild : el.firstChild;
+
+ if(el) {
+ var result = Sys.Extended.UI.HtmlEditor.positionInParagraphLevel(marker, el, left, wordBound);
+
+ if(result != null)
+ return result;
+ }
+ el = elSibling;
+ }
+
+ return null;
+};
+
+Sys.Extended.UI.HtmlEditor._addEvent = function(el, evname, func) {
+ if(el.attachEvent)
+ el.attachEvent("on" + evname, func);
+ else if(el.addEventListener)
+ el.addEventListener(evname, func, true);
+};
+
+Sys.Extended.UI.HtmlEditor._addEvents = function(el, evs, func) {
+ for(var i = 0; i < evs.length; i++)
+ Sys.Extended.UI.HtmlEditor._addEvent(el, evs[i], func);
+};
+
+Sys.Extended.UI.HtmlEditor._removeEvent = function(el, evname, func) {
+ if(el.detachEvent)
+ el.detachEvent("on" + evname, func);
+ else if(el.removeEventListener)
+ el.removeEventListener(evname, func, true);
+};
+
+Sys.Extended.UI.HtmlEditor._removeEvents = function(el, evs, func) {
+ for(var i = 0; i < evs.length; i++)
+ Sys.Extended.UI.HtmlEditor._removeEvent(el, evs[i], func);
+};
+
+Sys.Extended.UI.HtmlEditor._stopEvent = function(ev) {
+ if(ev) {
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ ev.cancelBubble = true;
+ ev.returnValue = false;
+ } else {
+ ev.preventDefault();
+ ev.stopPropagation();
+ }
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.restrictedTags = ["DIV", "P", "TD", "TR", "TABLE", "TBODY", "LI", "OL", "UL", "FORM", "INPUT"]; // this list can be increased
+
+Sys.Extended.UI.HtmlEditor.isRestricted = function(element) {
+ var elementTagName = element.tagName.toUpperCase();
+ for(var i = 0; i < Sys.Extended.UI.HtmlEditor.restrictedTags.length; i++)
+ if(Sys.Extended.UI.HtmlEditor.restrictedTags[i].toUpperCase() == elementTagName)
+ return true;
+
+ if(Sys.Extended.UI.HtmlEditor.isIE && element.scopeName.toUpperCase() != "HTML")
+ return true;
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor.jsDocument = function(noExtraLf) {
+ this.noExtraLf = (typeof noExtraLf != "undefined" && noExtraLf);
+ this.text = []; //array to store the string
+
+ this.write = function(str) {
+ if(!this.noExtraLf || (this.text.length == 0 && str != "\n") || (this.text.length > 0 && (this.text[this.text.length - 1] != "\n" || str != "\n")))
+ this.text[this.text.length] = str;
+ };
+
+ this.append = this.write;
+
+ this.writeln = function(str) {
+ this.text[this.text.length] = str + "\n";
+ }
+
+ this.toString = function() {
+ return this.text.join("");
+ }
+
+ this.clear = function() {
+ delete this.text;
+ this.text = null;
+ this.text = new Array;
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.isHeader = function(el) {
+ var name = el.tagName.toUpperCase();
+
+ if(name.length == 2)
+ if(name.substr(0, 1) == "H" && parseInt(name.substr(1, 1)) > 0)
+ return true;
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor._getReallyFirst = function(root) {
+ if(typeof root.firstChild != "undefined" && root.firstChild != null)
+ if(typeof root.firstChild.childNodes != "undefined" && root.firstChild.childNodes != null)
+ return Sys.Extended.UI.HtmlEditor._getReallyFirst(root.firstChild)
+
+ return root;
+};
+
+Sys.Extended.UI.HtmlEditor._getReallyLast = function(root) {
+ if(typeof root.lastChild != "undefined" && root.lastChild != null)
+ if(typeof root.lastChild.childNodes != "undefined" && root.lastChild.childNodes != null)
+ return Sys.Extended.UI.HtmlEditor._getReallyLast(root.lastChild)
+
+ return root;
+};
+
+Sys.Extended.UI.HtmlEditor._reallyFirst = function(root, seek) {
+ if(root.firstChild) {
+ if(root.firstChild == seek)
+ return true;
+
+ if(root.firstChild.childNodes)
+ if(Sys.Extended.UI.HtmlEditor._lookChild(root.firstChild, seek) == 0)
+ return Sys.Extended.UI.HtmlEditor._reallyFirst(root.firstChild, seek)
+ }
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor._reallyLast = function(root, seek) {
+ if(root.lastChild) {
+ if(root.lastChild == seek)
+ return true;
+
+ if(root.lastChild.childNodes)
+ if(Sys.Extended.UI.HtmlEditor._lookChild(root.lastChild, seek) == root.lastChild.childNodes.length - 1)
+ return Sys.Extended.UI.HtmlEditor._reallyLast(root.lastChild, seek)
+ }
+
+ return false;
+};
+
+Sys.Extended.UI.HtmlEditor.getContainer = function(container, el) {
+ if(el == container)
+ return container;
+
+ if(container.nodeType == 1) {
+ for(var i = 0; i < container.childNodes.length; i++) {
+ var child = container.childNodes.item(i);
+
+ if(el == child)
+ return child;
+
+ if(child.nodeType == 1) {
+ var ind = Sys.Extended.UI.HtmlEditor._lookChild(child, el);
+
+ if(ind >= 0) {
+ if(child.tagName && Sys.Extended.UI.HtmlEditor.isStyleTag(child.tagName) && (child.tagName.toUpperCase() != "A") && !Sys.Extended.UI.HtmlEditor.isTempElement(child))
+ return Sys.Extended.UI.HtmlEditor.getContainer(child, el);
+ else
+ return child;
+ }
+ }
+ }
+ }
+
+ return null;
+};
+
+Sys.Extended.UI.HtmlEditor._TryTransformFromPxToPt = function(fontSize, editor, _id) {
+ var ret = fontSize.replace(/^(\d+)\.(\d+)px/i, "$1px");
+
+ if(!Sys.Extended.UI.HtmlEditor.isIE) {
+ if(ret && ret.length > 0) {
+ var seek = ret.toLowerCase().split(",")[0];
+
+ if(typeof _id != "undefined") {
+ var el = document.getElementById(_id);
+
+ if(el != null) {
+ var i;
+
+ for(i = 0; i < el.options.length; i++) {
+ var cur = Sys.Extended.UI.HtmlEditor.fontSizeSeek(el.options.item(i).value.toLowerCase().split(",")[0]);
+
+ if(cur == seek)
+ break;
+ }
+
+ if(i == el.options.length) {
+ var span = editor._doc.createElement("SPAN");
+ editor._doc.body.appendChild(span);
+
+ for(i = 1; i < 100; i++) {
+ span.style.fontSize = i + "pt";
+
+ if(Sys.Extended.UI.HtmlEditor.getStyle(span, "font-size").replace(/^(\d+)\.(\d+)px/i, "$1px") == seek) {
+ seek = i + "pt";
+ break;
+ }
+ }
+ span.parentNode.removeChild(span);
+ }
+ }
+ }
+ ret = seek;
+ }
+ }
+
+ return ret;
+};
+
+Sys.Extended.UI.HtmlEditor.fontSizeSeek = function(val) {
+ var seek = val.toString();
+
+ switch(seek) {
+ case "1":
+ seek = "8pt";
+ break;
+ case "2":
+ seek = "10pt";
+ break;
+ case "3":
+ seek = "12pt";
+ break;
+ case "4":
+ seek = "14pt";
+ break;
+ case "5":
+ seek = "18pt";
+ break;
+ case "6":
+ seek = "24pt";
+ break;
+ case "7":
+ seek = "36pt";
+ break;
+ }
+
+ return seek;
+};
+
+Sys.Extended.UI.HtmlEditor.getOwnerDocument = function(node) {
+ return node.nodeType == 9 ? node : node.ownerDocument || node.document;
+};
+
+Sys.Extended.UI.HtmlEditor.getClientViewportElement = function(opt_node) {
+ var doc;
+
+ if(opt_node.nodeType == 9)
+ doc = opt_node;
+ else
+ doc = Sys.Extended.UI.HtmlEditor.getOwnerDocument(opt_node);
+
+ if(Sys.Extended.UI.HtmlEditor.isIE && doc.compatMode != 'CSS1Compat')
+ return doc.body;
+
+ return doc.documentElement;
+};
+
+Sys.Extended.UI.HtmlEditor.isReallyVisible = function(el) {
+ var elem = el,
+ real_visible = true;
+
+ while(elem) {
+ if(elem.style && Sys.Extended.UI.HtmlEditor.getStyle(elem, "display") == "none") {
+ real_visible = false;
+ break;
+ }
+ elem = elem.parentNode;
+ }
+
+ return real_visible;
+}
+
+
+Sys.Extended.UI.HtmlEditor.setSelectionRange = function(input, selectionStart, selectionEnd) {
+ input.focus();
+
+ if(input.setSelectionRange) {
+ input.setSelectionRange(selectionStart, selectionEnd);
+ } else if(input.createTextRange) {
+ var range = input.createTextRange();
+
+ range.collapse(true);
+ range.moveEnd('character', selectionEnd);
+ range.moveStart('character', selectionStart);
+ range.select();
+ }
+};
+
+Sys.Extended.UI.HtmlEditor.setElementVisibility = function(element) {
+ var ret = new Array(),
+ elem = element;
+
+ while(elem && elem.nodeType == 1 && elem.tagName.toUpperCase() != "BODY") {
+ var display = elem.style.display,
+ visibility = elem.style.visibility;
+
+ if(elem.style && (display == "none" || visibility == "hidden")) {
+ ret.push({ element: elem, display: display, visibility: visibility });
+ elem.style.display = "";
+ elem.style.visibility = "visible";
+ }
+ elem = elem.parentNode;
+ }
+
+ return ret;
+};
+
+Sys.Extended.UI.HtmlEditor.restoreElementVisibility = function(arr) {
+ for(var i = 0; i < arr.length; i++) {
+ var item = arr[i],
+ style = item.element.style;
+
+ style.display = item.display;
+ style.visibility = item.visibility;
+ }
+};
+
+if(!Sys.Extended.UI.HtmlEditor.isIE) {
+ try { //not all such browsers support getter/setter
+ Sys.Extended.UI.HtmlEditor.__MozillaGetInnerText = function(node, html) {
+ var els = node.childNodes;
+
+ for(var i = 0; i < els.length; i++) {
+ var elem = els[i];
+
+ if(elem.nodeType == 3)
+ html.write(elem.nodeValue.replace("\n", ""));
+
+ if(elem.nodeType == 1) {
+ var display = Sys.Extended.UI.HtmlEditor.getStyle(elem, "display"),
+ visibility = Sys.Extended.UI.HtmlEditor.getStyle(elem, "visibility");
+
+ if(Sys.Extended.UI.HtmlEditor.__needLineBreakBefore(elem))
+ html.write("\n");
+
+ if(Sys.Extended.UI.HtmlEditor.__needTabBefore(elem))
+ html.write("\t");
+
+ if(display != "none" && visibility != "hidden")
+ Sys.Extended.UI.HtmlEditor.__MozillaGetInnerText(elem, html);
+
+ if(Sys.Extended.UI.HtmlEditor.__needLineBreakAfter(elem))
+ html.write("\n");
+ }
+ }
+ };
+
+ Sys.Extended.UI.HtmlEditor.__needLineBreakBefore = function(el) {
+ var _Tags = " div table p pre ol ul blockquote form fieldset ";
+
+ return (_Tags.indexOf(" " + el.tagName.toLowerCase() + " ") != -1);
+ };
+
+ Sys.Extended.UI.HtmlEditor.__needLineBreakAfter = function(el) {
+ var _Tags = " br div table tr p pre ol ul li hr blockquote form fieldset legend ";
+
+ return (_Tags.indexOf(" " + el.tagName.toLowerCase() + " ") != -1);
+ };
+
+ Sys.Extended.UI.HtmlEditor.__needTabBefore = function(el) {
+ var _Tags = " td li ";
+
+ return (_Tags.indexOf(" " + el.tagName.toLowerCase() + " ") != -1);
+ };
+
+ } catch(ex) { }
+}
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.HtmlPanel.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.HtmlPanel.debug.js
new file mode 100644
index 000000000..cf44314c5
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.HtmlPanel.debug.js
@@ -0,0 +1,123 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor");
+
+Sys.Extended.UI.HtmlEditor.HtmlPanel = function(element) {
+ Sys.Extended.UI.HtmlEditor.HtmlPanel.initializeBase(this, [element]);
+ this._onfocus$delegate = Function.createDelegate(this, this._onfocus);
+
+ if(Sys.Extended.UI.HtmlEditor.isIE && document.compatMode != "BackCompat")
+ this._onresize$delegate = Function.createDelegate(this, this._onresize);
+}
+
+Sys.Extended.UI.HtmlEditor.HtmlPanel.prototype = {
+
+ _activate: function(value) {
+ this._shouldResize = false;
+ var element = this.get_element();
+
+ if(Sys.Extended.UI.HtmlEditor.isIE && Sys.Browser.version > 6 && document.compatMode != "BackCompat" && element.parentNode.clientHeight > 0)
+ this._shouldResize = true;
+
+ Sys.Extended.UI.HtmlEditor.HtmlPanel.callBaseMethod(this, "_activate");
+
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ element.value = "";
+ var panel = this;
+
+ setTimeout(function() {
+ element.value = value;
+ }, 0);
+ } else {
+ element.value = value;
+ }
+
+ $addHandlers(element, {
+ focus: this._onfocus$delegate
+ });
+
+ if(this._shouldResize)
+ $addHandlers(element, {
+ resize: this._onresize$delegate
+ });
+
+ this._activateFinished();
+ },
+
+ _deactivate: function() {
+ var element = this.get_element();
+
+ if(this._shouldResize)
+ $common.removeHandlers(element, {
+ resize: this._onresize$delegate
+ });
+
+ this._shouldResize = false;
+
+ $common.removeHandlers(element, {
+ focus: this._onfocus$delegate
+ });
+
+ element.value = "";
+ Sys.Extended.UI.HtmlEditor.HtmlPanel.callBaseMethod(this, "_deactivate");
+ },
+
+ _getContent: function() {
+ return this.get_element().value;
+ },
+
+ _setContent: function(value) {
+ this.get_element().value = value;
+
+ if(Sys.Extended.UI.HtmlEditor.isReallyVisible(this.get_element().parentNode)) {
+ try { // some browsers fail when invisible
+ var textarea = this.get_element();
+ textarea.focus();
+ setTimeout(function() {
+ try {
+ Sys.Extended.UI.HtmlEditor.setSelectionRange(textarea, 0, 0);
+ } catch(e) { }
+ }, 0);
+ } catch(e) { }
+ }
+ },
+
+ _focus: function() {
+ if(Sys.Extended.UI.HtmlEditor.isReallyVisible(this.get_element().parentNode)) {
+ try { // some browsers fail when invisible
+ var textarea = this.get_element();
+ textarea.focus();
+
+ setTimeout(function() {
+ try {
+ Sys.Extended.UI.HtmlEditor.setSelectionRange(textarea, 0, 0);
+ } catch(e) { }
+ }, 0);
+ } catch(e) { }
+ }
+ var panel = this;
+
+ setTimeout(function() {
+ panel._focused();
+ }, 0);
+ },
+
+ _onfocus: function(e) {
+ this._really_focused();
+ var textarea = this.get_element();
+
+ setTimeout(function() {
+ textarea.focus();
+ }, 0);
+
+ return true;
+ },
+
+ _onresize: function(e) {
+ var element = this.get_element();
+ var clientHeight = element.parentNode.clientHeight;
+
+ if(clientHeight > 0)
+ element.style.height = clientHeight + "px";
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.HtmlPanel.registerClass("Sys.Extended.UI.HtmlEditor.HtmlPanel", Sys.Extended.UI.HtmlEditor.ModePanel);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.ModePanel.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.ModePanel.debug.js
new file mode 100644
index 000000000..85928bf5a
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.ModePanel.debug.js
@@ -0,0 +1,123 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor");
+
+Sys.Extended.UI.HtmlEditor.ModePanel = function(element) {
+ Sys.Extended.UI.HtmlEditor.ModePanel.initializeBase(this, [element]);
+
+ this._activated = false;
+ this._isActivating = false;
+ this._editPanel = null;
+ this._cachedContent = null;
+ this._onbeforeunload$delegate = Function.createDelegate(this, this._onbeforeunload);
+}
+
+Sys.Extended.UI.HtmlEditor.ModePanel.prototype = {
+
+ set_editPanel: function(value) {
+ this._editPanel = value;
+ },
+
+ get_content: function() {
+ if(this._activated) {
+ return this._getContent();
+ } else {
+ if(this._cachedContent != null)
+ return this._cachedContent;
+ else
+ return "";
+ }
+ },
+
+ set_content: function(value) {
+ this._cachedContent = value;
+
+ if(!this._activated && !this._isActivating) {
+ this._activate(value);
+ } else {
+ if(!this._isActivating) {
+ this._setContent(value);
+ } else {
+ var panel = this;
+ setTimeout(function() {
+ panel.set_content(value);
+ }, 10);
+
+ return false;
+ }
+ }
+ return true;
+ },
+
+ _activate: function() {
+ this.get_element().style.display = "";
+ this._isActivating = true;
+ },
+
+ _activateFinished: function() {
+ this._activated = true;
+ this._isActivating = false;
+ this._editPanel._setActive();
+
+ if(this._editPanel.get_autofocus())
+ this._focus();
+ },
+
+ _deactivate: function() {
+ this.get_element().style.display = "none";
+ this._activated = false;
+ this._isActivating = false;
+ },
+
+ initialize: function() {
+ Sys.Extended.UI.HtmlEditor.ModePanel.callBaseMethod(this, "initialize");
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ $addHandlers(window, { beforeunload: this._onbeforeunload$delegate });
+ },
+
+ dispose: function() {
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ $common.removeHandlers(window, { beforeunload: this._onbeforeunload$delegate });
+
+ if(this._activated) {
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ this._onbeforeunload();
+
+ this._deactivate();
+ }
+
+ Sys.Extended.UI.HtmlEditor.ModePanel.callBaseMethod(this, "dispose");
+ },
+
+ _onbeforeunload: function() {
+ if(this._activated)
+ if(!this._editPanel._contentPrepared) {
+ this._editPanel._prepareContentForPostback(this.get_content());
+ this._editPanel._contentPrepared = true;
+ }
+ },
+
+ _getContent: function() {
+ if(this._cachedContent != null)
+ return this._cachedContent;
+ else
+ return "";
+ },
+
+ _setContent: function(value) {
+ },
+
+ _focus: function() {
+ this._focused();
+ },
+
+ _focused: function(prize) {
+ this._editPanel._focused(prize);
+ this._editPanel.set_autofocus(true);
+ },
+
+ _really_focused: function() {
+ this._editPanel._really_focused();
+ this._editPanel.set_autofocus(true);
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.ModePanel.registerClass("Sys.Extended.UI.HtmlEditor.ModePanel", Sys.UI.Control);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.AttachedPopup.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.AttachedPopup.debug.js
new file mode 100644
index 000000000..fcff6cac3
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.AttachedPopup.debug.js
@@ -0,0 +1,83 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.initializeBase(this, [element]);
+
+ this._relatedElement = null;
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.prototype = {
+
+ get_relatedElement: function() {
+ return this._relatedElement;
+ },
+
+ set_relatedElement: function(value) {
+ this._relatedElement = value;
+ },
+
+ open: function(callback) {
+ if(this._relatedElement != null) {
+ var popup = this;
+
+ if(!this.checkCorrectLoaded(function() { popup.open(callback); }))
+ return;
+
+ var location = $common.getLocation(this._relatedElement),
+ x = location.x,
+ y = location.y + this._relatedElement.offsetHeight;
+
+ var element = this.get_element().parentNode;
+ while(element && element.tagName && element.tagName.toUpperCase() != "BODY") {
+ var position = Sys.Extended.UI.HtmlEditor.getStyle(element, "position");
+
+ if(position == "absolute" || position == "fixed") {
+ var top = parseInt(Sys.Extended.UI.HtmlEditor.getStyle(element, "top")),
+ left = parseInt(Sys.Extended.UI.HtmlEditor.getStyle(element, "left"));
+
+ if(!isNaN(top) && !isNaN(left)) {
+ x -= left;
+ y -= top;
+ }
+ break;
+ } else if(position == "relative") {
+ var relativeLocation = $common.getLocation(element);
+
+ x -= relativeLocation.x;
+ y -= relativeLocation.y;
+ }
+ element = element.parentNode;
+ }
+
+ var viewportElement = Sys.Extended.UI.HtmlEditor.getClientViewportElement(this._iframe),
+ theVisibleWidth = viewportElement.clientWidth + viewportElement.scrollLeft,
+ theVisibleHeight = viewportElement.clientHeight + viewportElement.scrollTop;
+
+ if(y < viewportElement.scrollTop)
+ y = viewportElement.scrollTop;
+ if(x < viewportElement.scrollLeft)
+ x = viewportElement.scrollLeft;
+
+ if(y + this._iframe.offsetHeight > theVisibleHeight)
+ y -= y + this._iframe.offsetHeight - theVisibleHeight;
+ if(x + this._iframe.offsetWidth > theVisibleWidth)
+ x -= x + this._iframe.offsetWidth - theVisibleWidth;
+
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.callBaseMethod(this, "open", [callback, y, x]);
+ }
+ },
+
+ close: function(callback) {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.callBaseMethod(this, "close", [callback]);
+ },
+
+ initialize: function() {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.callBaseMethod(this, "initialize");
+ },
+
+ dispose: function() {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.callBaseMethod(this, "dispose");
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup.registerClass("Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup", Sys.Extended.UI.HtmlEditor.Popups.Popup);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.AttachedTemplatePopup.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.AttachedTemplatePopup.debug.js
new file mode 100644
index 000000000..7133e7c1a
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.AttachedTemplatePopup.debug.js
@@ -0,0 +1,29 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup.initializeBase(this, [element]);
+
+ this._contentDiv = null;
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup.prototype = {
+
+ get_contentDiv: function() {
+ return this._contentDiv;
+ },
+
+ set_contentDiv: function(value) {
+ this._contentDiv = value;
+ },
+
+ initialize: function() {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup.callBaseMethod(this, "initialize");
+ this.set_initialContent(this._contentDiv.innerHTML);
+ },
+
+ dispose: function() {
+ Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup.callBaseMethod(this, "dispose");
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup.registerClass("Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup", Sys.Extended.UI.HtmlEditor.Popups.AttachedPopup);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.BaseColorsPopup.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.BaseColorsPopup.debug.js
new file mode 100644
index 000000000..261bc6e0b
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.BaseColorsPopup.debug.js
@@ -0,0 +1,10 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.BaseColorsPopup = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.BaseColorsPopup.initializeBase(this, [element]);
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.BaseColorsPopup.prototype = {
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.BaseColorsPopup.registerClass("Sys.Extended.UI.HtmlEditor.Popups.BaseColorsPopup", Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.LinkProperties.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.LinkProperties.debug.js
new file mode 100644
index 000000000..d06d25e1a
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.LinkProperties.debug.js
@@ -0,0 +1,22 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.LinkProperties = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.LinkProperties.initializeBase(this, [element]);
+
+ this._defaultTarget = "_self";
+ this._targetTextHolder = null;
+ this._urlTextHolder = null;
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.LinkProperties.prototype = {
+
+ get_defaultTarget: function() {
+ return this._defaultTarget;
+ },
+
+ set_defaultTarget: function(value) {
+ this._defaultTarget = value;
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.LinkProperties.registerClass("Sys.Extended.UI.HtmlEditor.Popups.LinkProperties", Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.OkCancelAttachedTemplatePopup.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.OkCancelAttachedTemplatePopup.debug.js
new file mode 100644
index 000000000..61ff6ce3e
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.OkCancelAttachedTemplatePopup.debug.js
@@ -0,0 +1,18 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup.initializeBase(this, [element]);
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup.prototype = {
+
+ initialize: function() {
+ Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup.callBaseMethod(this, "initialize");
+ },
+
+ dispose: function() {
+ Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup.callBaseMethod(this, "dispose");
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup.registerClass("Sys.Extended.UI.HtmlEditor.Popups.OkCancelAttachedTemplatePopup", Sys.Extended.UI.HtmlEditor.Popups.AttachedTemplatePopup);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.Popup.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.Popup.debug.js
new file mode 100644
index 000000000..8c3d740bc
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.Popup.debug.js
@@ -0,0 +1,323 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.Popup = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.Popup.initializeBase(this, [element]);
+
+ this._iframe = null;
+ this._top = 0;
+ this._left = 0;
+ this._doc = null;
+ this._initialContent = "";
+ this._cssPath = "";
+ this._autoDimensions = true;
+ this._registeredFields = [];
+ this._registeredHandlers = [];
+ this._app_onload$delegate = Function.createDelegate(this, this._app_onload);
+ this.isOpened = false;
+ this.isLoaded = false;
+ this.isLoading = false;
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.Popup.prototype = {
+
+ getDocument: function() {
+ return this._doc;
+ },
+
+ getPopupMediator: function() {
+ if(this._iframe.contentWindow && this._iframe.contentWindow.popupMediator)
+ return this._iframe.contentWindow.popupMediator;
+ else
+ return null;
+ },
+
+ get_registeredFields: function() {
+ return this._registeredFields;
+ },
+
+ set_registeredFields: function(value) {
+ this._registeredFields = eval(value);
+ },
+
+ get_registeredHandlers: function() {
+ return this._registeredHandlers;
+ },
+
+ set_registeredHandlers: function(value) {
+ this._registeredHandlers = eval(value);
+ },
+
+ get_initialContent: function() {
+ return this._initialContent;
+ },
+
+ set_initialContent: function(value) {
+ this._initialContent = value;
+ },
+
+ get_cssPath: function() {
+ return this._cssPath;
+ },
+
+ set_cssPath: function(value) {
+ this._cssPath = value;
+ },
+
+ get_autoDimensions: function() {
+ return this._autoDimensions;
+ },
+
+ set_autoDimensions: function(value) {
+ this._autoDimensions = value;
+ },
+
+ get_iframe: function() {
+ return this._iframe;
+ },
+
+ set_iframe: function(value) {
+ this._iframe = value;
+ },
+
+ checkCorrectLoaded: function(func) {
+ var popup = this;
+ if(popup.isLoaded && (popup._iframe.style.height == "0px" || popup._iframe.style.width == "0px"))
+ this.isLoaded = false;
+
+ if(!this.isLoaded) {
+ if(!this.isLoading)
+ this.reload();
+
+ if(typeof func != "undefined")
+ setTimeout(func, 10);
+
+ return false;
+ }
+
+ return true;
+ },
+
+ _baseOpen: function(callback, top, left) {
+ var popup = this;
+
+ if(!this.checkCorrectLoaded(function() { popup._baseOpen(callback, top, left); }))
+ return;
+
+ var element = this.get_element();
+
+ if(typeof left != "undefined")
+ this._left = parseInt(left);
+ if(typeof top != "undefined")
+ this._top = parseInt(top);
+
+ element.style.top = this._top + "px";
+ element.style.left = this._left + "px";
+
+ setTimeout(function() {
+ if(typeof callback == "function")
+ popup._onDocumentLoaded(callback);
+
+ popup.isOpened = true;
+ }, 0);
+ },
+
+ open: function(callback, top, left) {
+ this._baseOpen(callback, top, left);
+ },
+
+ close: function(callback) {
+ var element = this.get_element();
+ this.isOpened = false;
+
+ element.style.top = "-2000px";
+ element.style.left = "-2000px";
+
+ if(typeof callback == "function")
+ callback();
+ },
+
+ reload: function() {
+ this.isLoading = true;
+ var element = this.get_element();
+ var _parentNode_ = element.parentNode;
+
+ document.body.appendChild(element);
+ _parentNode_.appendChild(this.get_element());
+
+ this._doc = this._iframe.contentWindow.document;
+ this._doc.open();
+ var html = new Sys.StringBuilder();
+
+ html.append("");
+ if(this._cssPath.length > 0)
+ html.append("");
+
+ html.append(this._initialContent);
+ if(this._autoDimensions)
+ html.append("
");
+
+ html.append("");
+
+ this._doc.write(html.toString());
+ this._doc.close();
+
+ this.isLoaded = false;
+ this._afterReload();
+ },
+
+ _afterReload: function() {
+ var contentWindow = this._iframe.contentWindow,
+ popup = this;
+
+ this.isLoaded = contentWindow.__loaded__;
+
+ if(!(popup._doc.body && popup._doc.body.innerHTML))
+ this.isLoaded = false;
+
+ if(!this.isLoaded) {
+ setTimeout(function() {
+ popup._afterReload()
+ }, 10); // waiting for loading
+ return;
+ }
+
+ this.isLoaded = false;
+ contentWindow.popupMediator = {};
+ contentWindow.popupMediator.registeredFields = this._registeredFields;
+ contentWindow.popupMediator.registeredHandlers = this._registeredHandlers;
+
+ contentWindow.popupMediator.get_callMethodByName = function(name) {
+ var handlers = contentWindow.popupMediator.registeredHandlers;
+
+ for(var i = 0; i < handlers.length; i++) {
+ var handler = handlers[i];
+
+ if(handler.name == name)
+ return handler.callMethod;
+ }
+
+ return null;
+ };
+
+ contentWindow.popupMediator.set_callMethodByName = function(name, value) {
+ var handlers = contentWindow.popupMediator.registeredHandlers;
+
+ for(var i = 0; i < handlers.length; i++) {
+ var handler = handlers[i];
+
+ if(handler.name == name)
+ handler.callMethod = value;
+ }
+ };
+
+ contentWindow.popupMediator.getField = function(name) {
+ var registeredFields = contentWindow.popupMediator.registeredFields;
+
+ for(var i = 0; i < registeredFields.length; i++) {
+ var registeredField = registeredFields[i];
+
+ if(registeredField.name == name)
+ return contentWindow.document.getElementById(registeredField.clientID);
+ }
+
+ return null;
+ };
+
+ contentWindow.Sys = Sys;
+
+ for(var i = 0; i < this._registeredHandlers.length; i++)
+ $find(this._registeredHandlers[i].clientID).activate(contentWindow.document.getElementById(this._registeredHandlers[i].clientID));
+
+
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ popup._doc.onselectstart = function() {
+ var event = popup._iframe.contentWindow.event;
+ var tagName = event.srcElement.tagName.toUpperCase();
+
+ if(tagName == "INPUT" || tagName == "TEXTAREA")
+ return true;
+
+ return false;
+ };
+ } else {
+ popup._doc.onmousedown = function disableselect(e) {
+ var tagName = e.target.tagName.toUpperCase();
+
+ if(tagName == "INPUT" || tagName == "TEXTAREA" || tagName == "SELECT")
+ return true;
+ if(Sys.Extended.UI.HtmlEditor.isSafari)
+ if(tagName == "TABLE" || tagName == "TR" || tagName == "TD" || tagName == "DIV")
+ return true;
+
+ return false;
+ };
+
+ var aInp = popup._doc.getElementsByTagName('input');
+ for(var i = 0; i < aInp.length; i++)
+ aInp[i].setAttribute('autocomplete', 'off')
+ }
+
+ if(this._autoDimensions) {
+ popup._iframe.style.height = "1000px";
+ popup._iframe.style.width = "1000px";
+
+ setTimeout(function() {
+ popup._iframe.style.height = popup._doc.body.firstChild.offsetHeight + "px";
+ popup._iframe.style.width = popup._doc.body.firstChild.offsetWidth + "px";
+ popup.isLoaded = true;
+ popup.isLoading = false;
+ }, 0);
+ } else {
+ popup.isLoaded = true;
+ popup.isLoading = false;
+ }
+ },
+
+ _onDocumentLoaded: function(callback) {
+ var popup = this;
+ if(!this.isLoaded) {
+ setTimeout(function() {
+ popup._onDocumentLoaded(callback)
+ }, 10); // waiting for loading
+ return;
+ }
+
+ this.isLoaded = true;
+ callback(this._iframe.contentWindow);
+ },
+
+ initialize: function() {
+ this.__appLoaded__ = false;
+
+ Sys.Extended.UI.HtmlEditor.Popups.Popup.callBaseMethod(this, "initialize");
+ Sys.Application.add_load(this._app_onload$delegate);
+ },
+
+ dispose: function() {
+ Sys.Application.remove_load(this._app_onload$delegate);
+
+ if(this.isOpened)
+ this.close();
+
+ Sys.Extended.UI.HtmlEditor.Popups.Popup.callBaseMethod(this, "dispose");
+ },
+
+ _app_onload: function(sender, e) {
+ if(this.__appLoaded__)
+ return;
+
+ this.__appLoaded__ = true;
+ var element = this.get_element();
+
+ if(Sys.Extended.UI.HtmlEditor.isReallyVisible(element)) {
+ this._parentNode_ = element.parentNode;
+ this.reload();
+ }
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.Popup.registerClass("Sys.Extended.UI.HtmlEditor.Popups.Popup", Sys.UI.Control);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupBGIButton.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupBGIButton.debug.js
new file mode 100644
index 000000000..9731f4c73
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupBGIButton.debug.js
@@ -0,0 +1,10 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupBGIButton = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.PopupBGIButton.initializeBase(this, [element]);
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupBGIButton.prototype = {
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupBGIButton.registerClass("Sys.Extended.UI.HtmlEditor.Popups.PopupBGIButton", Sys.Extended.UI.HtmlEditor.Popups.PopupBoxButton);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupBoxButton.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupBoxButton.debug.js
new file mode 100644
index 000000000..fde9708a9
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupBoxButton.debug.js
@@ -0,0 +1,12 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupBoxButton = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.PopupBoxButton.initializeBase(this, [element]);
+
+ this._designPanel = null;
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupBoxButton.prototype = {
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupBoxButton.registerClass("Sys.Extended.UI.HtmlEditor.Popups.PopupBoxButton", Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupCommonButton.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupCommonButton.debug.js
new file mode 100644
index 000000000..a394cac5d
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.Popups.PopupCommonButton.debug.js
@@ -0,0 +1,195 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor.Popups");
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton = function(element) {
+ Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton.initializeBase(this, [element]);
+
+ this._loaded = false;
+ this._activated = null;
+ this._app_onload$delegate = Function.createDelegate(this, this._app_onload);
+ this._cssClass = "";
+ this._name = "";
+
+ this._onmouseover$delegate = Function.createDelegate(this, this._onmouseover);
+ this._onmouseout$delegate = Function.createDelegate(this, this._onmouseout);
+ this._onmousedown$delegate = Function.createDelegate(this, this._onmousedown);
+ this._onmouseup$delegate = Function.createDelegate(this, this._onmouseup);
+ this._onclick$delegate = Function.createDelegate(this, this._onclick);
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton.prototype = {
+
+ isImage: function() {
+ return true;
+ },
+
+ set_toolTip: function(value) {
+ this.get_element().title = value;
+ },
+
+ get_toolTip: function() {
+ return this.get_element().title;
+ },
+
+ set_name: function(value) {
+ this._name = value;
+ },
+
+ get_name: function() {
+ return this._name;
+ },
+
+ initialize: function() {
+ var element = this.get_element();
+
+ Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton.callBaseMethod(this, "initialize");
+ Sys.Application.add_load(this._app_onload$delegate);
+ this._cssClass = element.className.split(" ")[0];
+
+ if(this.isImage()) {
+ $addHandlers(element, {
+ mouseover: this._onmouseover$delegate,
+ mouseout: this._onmouseout$delegate,
+ mousedown: this._onmousedown$delegate,
+ mouseup: this._onmouseup$delegate,
+ click: this._onclick$delegate
+ });
+ }
+
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ function diveSelectable(el) {
+ if(el.nodeType == 1 && el.tagName) {
+ var tag = el.tagName.toUpperCase();
+
+ if(tag != "INPUT" && tag != "TEXTAREA" && tag != "IFRAME")
+ el.unselectable = "on";
+
+ for(var k = 0; k < el.childNodes.length; k++)
+ diveSelectable(el.childNodes.item(k));
+ }
+ }
+
+ diveSelectable(element);
+ } else {
+ try {
+ element.style.MozUserSelect = "none";
+ element.parentNode.style.MozUserSelect = "none";
+ } catch(ex) { }
+ }
+ },
+
+ activate: function(element) {
+ this._activated = element;
+
+ if(this.isImage()) {
+ Sys.Extended.UI.HtmlEditor._addEvent(this._activated, "mouseover", this._onmouseover$delegate);
+ Sys.Extended.UI.HtmlEditor._addEvent(this._activated, "mouseout", this._onmouseout$delegate);
+ Sys.Extended.UI.HtmlEditor._addEvent(this._activated, "mousedown", this._onmousedown$delegate);
+ Sys.Extended.UI.HtmlEditor._addEvent(this._activated, "mouseup", this._onmouseup$delegate);
+ Sys.Extended.UI.HtmlEditor._addEvent(this._activated, "click", this._onclick$delegate);
+ }
+ },
+
+ dispose: function() {
+ if(this.isImage() && this._activated != null) {
+ Sys.Extended.UI.HtmlEditor._removeEvent(this._activated, "mouseover", this._onmouseover$delegate);
+ Sys.Extended.UI.HtmlEditor._removeEvent(this._activated, "mouseout", this._onmouseout$delegate);
+ Sys.Extended.UI.HtmlEditor._removeEvent(this._activated, "mousedown", this._onmousedown$delegate);
+ Sys.Extended.UI.HtmlEditor._removeEvent(this._activated, "mouseup", this._onmouseup$delegate);
+ Sys.Extended.UI.HtmlEditor._removeEvent(this._activated, "click", this._onclick$delegate);
+ }
+ this._activated = null;
+ this._loaded = false;
+
+ Sys.Application.remove_load(this._app_onload$delegate);
+ Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton.callBaseMethod(this, "dispose");
+ },
+
+ _app_onload: function(sender, e) {
+ if(this._loaded)
+ return;
+
+ this.onButtonLoaded();
+ this._loaded = true;
+ },
+
+ onButtonLoaded: function() {
+ },
+
+ _onmouseover: function(e) {
+ if(!this.isEnable())
+ return false;
+
+ Sys.UI.DomElement.addCssClass(this._activated, this._cssClass + "_hover");
+
+ return true;
+ },
+
+ _onmouseout: function(e) {
+ if(!this.isEnable())
+ return false;
+
+ var _target1 = e.toElement || e.relatedTarget;
+
+ try {
+ while(_target1 && typeof _target1 != "undefined")
+ if(_target1 == this._activated)
+ break;
+ else
+ _target1 = _target1.parentNode;
+ } catch(e) {
+ _target1 = null;
+ }
+
+ if(_target1 != null)
+ return true;
+
+ Sys.UI.DomElement.removeCssClass(this._activated, this._cssClass + "_hover");
+ Sys.UI.DomElement.removeCssClass(this._activated, this._cssClass + "_mousedown");
+
+ return true;
+ },
+
+ _onmousedown: function(e) {
+ if(!this.isEnable())
+ return null;
+
+ Sys.UI.DomElement.addCssClass(this._activated, this._cssClass + "_mousedown");
+
+ return false;
+ },
+
+ _onmouseup: function(e) {
+ if(!this.isEnable())
+ return false;
+
+ Sys.UI.DomElement.removeCssClass(this._activated, this._cssClass + "_mousedown");
+
+ return true;
+ },
+
+ _onclick: function(e) {
+ if(!this.isEnable())
+ return false;
+
+ this.callMethod(e);
+
+ return true;
+ },
+
+ callMethod: function(e) {
+ var doc = this._activated.ownerDocument || this._activated.document || target,
+ contWin = doc.defaultView || doc.parentWindow,
+ method = contWin.popupMediator.get_callMethodByName(this._name);
+
+ Function.createDelegate(this, method)(contWin);
+ },
+
+ isEnable: function() {
+ if(!this._loaded)
+ return false;
+
+ return true;
+ }
+}
+
+Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton.registerClass("Sys.Extended.UI.HtmlEditor.Popups.PopupCommonButton", Sys.UI.Control);
\ No newline at end of file
diff --git a/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.PreviewPanel.debug.js b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.PreviewPanel.debug.js
new file mode 100644
index 000000000..564e84edb
--- /dev/null
+++ b/packages/AjaxControlToolkit.StaticResources.15.1.4.0/Content/Scripts/AjaxControlToolkit/Debug/HtmlEditor.PreviewPanel.debug.js
@@ -0,0 +1,98 @@
+Type.registerNamespace("Sys.Extended.UI.HtmlEditor");
+
+Sys.Extended.UI.HtmlEditor.PreviewPanel = function(element) {
+ Sys.Extended.UI.HtmlEditor.PreviewPanel.initializeBase(this, [element]);
+
+ this._focus$delegate = Function.createDelegate(this, this._focus_event);
+ this._blur$delegate = Function.createDelegate(this, this._blur_event);
+ this._doc = null;
+ this._content = "";
+ this._panel_timer = null;
+}
+
+Sys.Extended.UI.HtmlEditor.PreviewPanel.prototype = {
+
+ _focus: function() {
+ try { // some browsers fail when invisible
+ this.get_element().contentWindow.focus();
+ } catch(e) { }
+
+ this._focused();
+ },
+
+ _focus_event: function() {
+ if(this._panel_timer == null) {
+ var contentWindow = this.get_element().contentWindow;
+ var panel = this;
+
+ this._really_focused();
+ this._panel_timer = setTimeout(function() { contentWindow.focus(); panel._really_focused(); panel._panel_timer = null; }, 0);
+ }
+
+ return true;
+ },
+
+ _blur_event: function() {
+ if(this._panel_timer != null) {
+ clearTimeout(this._panel_timer);
+ this._panel_timer = null;
+ }
+
+ return true;
+ },
+
+ _activate: function(value) {
+ Sys.Extended.UI.HtmlEditor.PreviewPanel.callBaseMethod(this, "_activate");
+
+ this._content = value;
+ this._wasFocused = false;
+ this._initIframe(value);
+
+ Sys.Extended.UI.HtmlEditor._addEvents(this.get_element().contentWindow, ["focus"], this._focus$delegate);
+ Sys.Extended.UI.HtmlEditor._addEvents(this.get_element().contentWindow, ["blur"], this._blur$delegate);
+
+ this._activateFinished();
+ },
+
+ _deactivate: function() {
+ Sys.Extended.UI.HtmlEditor._removeEvents(this.get_element().contentWindow, ["blur"], this._blur$delegate);
+ Sys.Extended.UI.HtmlEditor._removeEvents(this.get_element().contentWindow, ["focus"], this._focus$delegate);
+
+ if(Sys.Extended.UI.HtmlEditor.isIE) {
+ try { // if src changed (with link in document) - security exception can occur in IE
+ this._doc.open();
+ this._doc.write("");
+ this._doc.close();
+ this.get_element().src = "javascript:false;";
+ } catch(ex) { }
+ }
+
+ this._doc = null;
+ this._content = "";
+
+ Sys.Extended.UI.HtmlEditor.PreviewPanel.callBaseMethod(this, "_deactivate");
+ },
+
+ _initIframe: function(value) {
+ var str = Sys.Extended.UI.HtmlEditor.Trim(value);
+ this._doc = this.get_element().contentWindow.document;
+
+ if(Sys.Extended.UI.HtmlEditor.isIE)
+ str = str.replace(/&/ig, "&");
+
+ this._doc.open();
+ this._doc.write("
+ /// Flag indicating that HtmlEditorExtender content is changed
+ ///
+ /// get_isDirty
+ ///
+ /// Determines whether or not to display a source view tab/button to see the source view of HtmlEditorExtender
+ ///
+ /// get_displaySourceTab
+ /// set_displaySourceTab
+ ///
+ /// Button width in pixels
+ ///
+ /// get_buttonWidth
+ /// set_buttonWidth
+ ///
+ /// Button height in pixels
+ ///
+ /// get_buttonHeight
+ /// set_buttonHeight
+ ///
+ /// A collection of toolbar buttons
+ ///
+ /// get_toolbarButtons
+ /// set_toolbarButtons
+ /// ]*)/g; //non double quoted attributes
+
+ return tag.replace(sQA, '="$1"').replace(nQA, '=$1');
+ } else {
+ return tag;
+ }
+ });
+ }
+
+ //convert rgb colors to hex
+ var fixRGB = this._rgbToHex;
+ var replaceRGB = function() {
+ html = html.replace(/(\<[^\>]+)(rgb\s?\(\d{1,3}\s?\,\s?\d{1,3}\s?\,\s?\d{1,3}\s?\))([^\>]*\>)/gi, function(text, p1, p2, p3) {
+ return (p1 || '') + ((p2 && fixRGB(p2)) || '') + (p3 || '');
+ });
+ };
+
+ //twice in case a tag has more than one rgb color in it;
+ replaceRGB();
+ replaceRGB();
+
+ // remove empty class and id attributes
+ html = html.replace(/\sclass\=\"\"/gi, '').replace(/\sid\=\"\"/gi, '');
+
+ //converter to convert different tags into Html5 standard tags
+ html = html.replace(/\<(\/?)strong\>/gi, '<$1b>').replace(/\<(\/?)em\>/gi, '<$1i>');
+
+ //encode for safe transport
+ html = html.replace(/&(?!g|lt;)/ig, '&').replace(/\xA0/ig, ' ');
+ html = html.replace(//ig, '>').replace(/\'/ig, ''').replace(/\"/ig, '"');
+
+ return html;
+ },
+
+ _editableDiv_submit: function() {
+ var char = 0,
+ selection = null;
+
+ setTimeout(function() {
+ if(this._editableDiv != null)
+ this._editableDiv.focus();
+ }, 0);
+
+ if(Sys.Browser.agent != Sys.Browser.Firefox) {
+ if(document.selection) {
+ selection = document.selection.createRange();
+ selection.moveStart('character', char);
+ selection.select();
+ } else {
+ selection = window.getSelection();
+
+ if(this._editableDiv.firstChild !== null)
+ selection.collapse(this._editableDiv.firstChild, char);
+ }
+ }
+
+ this._textbox._element.value = this._encodeHtml();
+ },
+
+ _isHtmlElement: function (obj) {
+ if(obj instanceof HTMLElement)
+ return true;
+
+ return false;
+ },
+
+ isValidTarget: function(target)
+ {
+ if (target.name == undefined
+ ||
+ target.name == ""
+ ||
+ target.tagName.toLowerCase() == "select")
+ return false;
+
+ return true;
+ },
+
+ _executeCommand: function(command) {
+ if(!this.isValidTarget(command.target))
+ return;
+
+ var isFireFox = Sys.Browser.agent == Sys.Browser.Firefox,
+ delcolorPicker_onchange = Function.createDelegate(this, this._colorPicker_onchange);
+
+ if(isFireFox)
+ document.execCommand('styleWithCSS', false, false);
+
+ var map = {
+ JustifyRight: 1,
+ JustifyLeft: 1,
+ JustifyCenter: 1,
+ JustifyFull: 1,
+ Indent: 1,
+ Outdent: 1
+ };
+
+ if(map[command.target.name]) {
+ try {
+ document.execCommand(command.target.name, false, null);
+ } catch(e) {
+ //special case for Mozilla Bug #442186
+ if(e && e.result == 2147500037) {
+ //probably firefox bug 442186 - workaround
+ var range = window.getSelection().getRangeAt(0),
+ dummy = document.createElement('div');
+
+ //To restore the range after collapsing for triple click bug...
+ var restoreSelection = false;
+ dummy.style.height = '1px;';
+
+ //Triple Click selection Problem in mozilla, the selection contains the content editable div, which creates a problem for some reason, so we collapse the selection to the end, and then re-select everything...
+ if(range.startContainer.contentEditable == 'true') {
+ window.getSelection().collapseToEnd();
+ restoreSelection = true;
+ }
+
+ var ceNode = window.getSelection().getRangeAt(0).startContainer;
+
+ while(ceNode && ceNode.contentEditable != 'true')
+ ceNode = ceNode.parentNode;
+
+ if(!ceNode)
+ throw 'Selected node is not editable!';
+
+ ceNode.insertBefore(dummy, ceNode.childNodes[0]);
+ document.execCommand(command.target.name, false, null);
+ dummy.parentNode.removeChild(dummy);
+
+ //RestoreSelection if we changed it...
+ if(restoreSelection)
+ window.getSelection().addRange(range);
+ } else if(window.console && window.console.log) {
+ window.console.log(e);
+ }
+ }
+ } else if(command.target.name == "createLink") {
+ var url = prompt('Please insert URL', '');
+ if(url)
+ document.execCommand('createLink', false, url);
+ } else if(command.target.name == 'ForeColor') {
+ this._commandName = command.target.name;
+ this.saveSelection();
+
+ if(!this._foreColorPicker) {
+ this._foreColorPicker = $create(Sys.Extended.UI.ColorPickerBehavior, {}, {}, {}, this._foreColor);
+ this._foreColorPicker.set_sample(this._foreColor.parentNode);
+ this._foreColorPicker.add_colorSelectionChanged(delcolorPicker_onchange);
+ }
+ this._foreColorPicker.show();
+ } else if(command.target.name == 'BackColor') {
+ this._commandName = command.target.name;
+ this.saveSelection();
+
+ if(!this._backColorPicker) {
+ this._backColorPicker = $create(Sys.Extended.UI.ColorPickerBehavior, {}, {}, {}, this._backColor);
+ this._backColorPicker.set_sample(this._backColor.parentNode);
+ this._backColorPicker.add_colorSelectionChanged(delcolorPicker_onchange);
+ }
+ this._backColorPicker.show();
+ } else if(command.target.name == 'UnSelect') {
+ if(isFireFox) {
+ this._editableDiv.focus();
+ var sel = window.getSelection();
+ sel.collapse(this._editableDiv.firstChild, 0);
+ } else {
+ document.execCommand(command.target.name, false, null);
+ }
+ } else if(command.target.name == 'InsertImage') {
+ // if focus in not at editable div then dom error occurs
+ if(!this._isFocusInEditableDiv)
+ this._editableDiv.focus();
+
+ this.saveSelection();
+
+ var components = Sys.Application.getComponents();
+
+ for(var i = 0; i < components.length; i++) {
+ var component = components[i];
+
+ if(Sys.Extended.UI.HtmlEditorExtenderBehavior.isInstanceOfType(component))
+ if(component._popupBehavior._visible)
+ return;
+ }
+
+ this._elementVisible(this._popupDiv, true);
+ this._popupBehavior.show();
+
+ $common.setStyle(this._popupDiv, {
+ position: 'fixed',
+ top: '',
+ left: '',
+ opacity: '1'
+ });
+ } else {
+ document.execCommand(command.target.name, false, null);
+ }
+ },
+
+ // BackColor & ForeColor colorpicker onchange, fill color to selected text
+ _colorPicker_onchange: function(e) {
+ this.restoreSelection();
+
+ if(/backcolor/i.test(this._commandName)) {
+ var isFireFox = Sys.Browser.agent == Sys.Browser.Firefox;
+ if(isFireFox) {
+ document.execCommand('stylewithcss', false, true);
+ document.execCommand("hilitecolor", false, "#" + e._selectedColor);
+ document.execCommand('stylewithcss', false, false);
+ } else {
+ document.execCommand("backcolor", false, "#" + e._selectedColor);
+ }
+ } else
+ document.execCommand(this._commandName, false, "#" + e._selectedColor);
+ },
+
+ ///
+ /// Saves selected text
+ ///
+ ///
+ /// Restores selected text
+ ///
+ ///
+ /// Fires when text change occurs
+ ///
+ ///
+ /// Whether or not show series values.
+ ///
+ /// get_displayValues
+ /// set_displayValues
+ /// {2} ', parseInt(this._chartWidth) / 2 - (this._chartTitle.length * this.charLength), parseInt(this._chartHeight) * 5 / 100, this._chartTitle, this._chartTitleColor);
+
+ svgContents = svgContents + this.drawBackgroundHorizontalLines();
+ svgContents = svgContents + this.drawBackgroundVerticalLines();
+ svgContents = svgContents + this.drawBaseLines();
+ svgContents = svgContents + this.drawLegendArea();
+ svgContents = svgContents + this.drawAxisValues();
+
+ this._parentDiv.innerHTML = this._parentDiv.innerHTML + svgContents;
+ this.drawLines();
+ },
+
+ ///
+ /// Calculates a distance interval for the value axis
+ ///
+ ///
+ /// Calculates minimum and maximum values of specified data
+ ///
+ ///
+ /// Calculates label values for the value axis to display on the chart
+ ///
+ ///
+ /// Draws background horizontal lines of the chart
+ ///
+ ///
+ /// Draws background vertical lines of the chart
+ ///
+ ///
+ /// Draws base lines of the chart
+ ///
+ ///
+ /// Draws legends of the chart
+ ///
+ /// ';
+ legendContents = legendContents + String.format('{2} ', startText, legendAreaStartHeight + 15, this._series[i].Name);
+
+ if(this._series[i].Name.length > 10) {
+ nextStartLegend = startLegend + (this._series[i].Name.length * 5) + legendBoxWidth + (spaceInLegendContents * 2);
+ nextStartText = startText + (this._series[i].Name.length * 5) + legendBoxWidth + (spaceInLegendContents * 2);
+ } else {
+ nextStartLegend = nextStartLegend + (this._series[i].Name.length * 6) + legendBoxWidth + (spaceInLegendContents * 2);
+ nextStartText = nextStartText + (this._series[i].Name.length * 6) + legendBoxWidth + (spaceInLegendContents * 2);
+ }
+ }
+ legendContents = legendContents + ' ';
+
+ return legendContents;
+ },
+
+ ///
+ /// Writes horizontal and vertical axis values of the chart
+ ///
+ /// {2} ', Math.round(this.startX + (this.xInterval * i) + (this.xInterval * 50 / 100) - (textLength)), this.startY + Math.round(this.yInterval * 65 / 100), this.arrXAxis[i]);
+ }
+
+ for(var i = 0; i <= this._valueAxisLines; i++)
+ axisContents = axisContents + String.format('{2} ', this.startX - ((this.roundedTickRange * 10 * i / 10).toString().length * 5.5) - 10, this.startY - (this.yInterval * i) + 3.5, this.roundedTickRange * 10 * i / 10);
+
+ if(this.yMin < 0)
+ for(var i = 1; i <= this._valueAxisLines; i++)
+ axisContents = axisContents + String.format('-{2} ', this.startX - ((this.roundedTickRange * 10 * i / 10).toString().length * 5.5) - 15, this.startY + (this.yInterval * i), this.roundedTickRange * 10 * i / 10);
+
+ return axisContents;
+ },
+
+ ///
+ /// Creates SVG and its initial content
+ ///
+ /// ', this._chartWidth, this._chartHeight);
+ svgContents = svgContents + '';
+ svgContents = svgContents + '';
+ svgContents = svgContents + ' ';
+ svgContents = svgContents + ' ';
+
+ svgContents = svgContents + String.format('
+ /// Draws lines on the chart
+ ///
+ /// ', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) - 7.5, displayValues ? yVal : "");
+ else
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) - 7.5, displayValues ? yVal : "");
+ } else {
+ if(index > 0)
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) + 7.5, displayValues ? yVal : "");
+ else
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) + 7.5, displayValues ? yVal : "");
+ }
+ } else {
+ if(yVal > 0) {
+ if(index > 0)
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) - 7.5, displayValues ? yVal : "");
+ else
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) - 7.5, displayValues ? yVal : "");
+ } else {
+ if(index > 0)
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) + 7.5, displayValues ? yVal : "");
+ else
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace('', '') + String.format('{2} ', me.startX + (me.xInterval * index) + (me.xInterval * 20 / 100), me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange)) + 7.5, displayValues ? yVal : "");
+ }
+ }
+
+ lastStartX[j] = me.startX + (me.xInterval * index) + (me.xInterval / 2) + 3;
+ lastStartY[j] = me.startY - Math.round(yVal * (me.yInterval / me.roundedTickRange));
+ }
+
+ index++;
+
+ if(index < me.arrXAxisLength)
+ setTimeout(function() {
+ me.animateLines(me, lastStartX, lastStartY, 0, index);
+ }, 400);
+ },
+
+ get_displayValues: function () {
+ return this._displayValues;
+ },
+ set_displayValues: function (value) {
+ this._displayValues = value;
+ },
+
+ ///
+ /// Enables you to customize chart width
+ ///
+ /// get_chartWidth
+ /// set_chartWidth
+ ///
+ /// Enables you to customize chart height
+ ///
+ /// get_chartHeight
+ /// set_chartHeight
+ ///
+ /// Enables you to set the chart's title
+ ///
+ /// get_chartTitle
+ /// set_chartTitle
+ ///
+ /// Provides a set of values for the category axis to create a line chart
+ ///
+ /// get_categoriesAxis
+ /// set_categoriesAxis
+ ///
+ /// Provides a list of series
+ ///
+ /// get_clientSeries
+ /// set_clientSeries
+ ///
+ /// Enables you to render two types of line charts: Basic or Stacked
+ ///
+ /// get_chartType
+ /// set_chartType
+ ///
+ /// Enables you to control the appearance of a line chart with a CSS file
+ ///
+ /// get_theme
+ /// set_theme
+ ///
+ /// Enables you to set interval size for a value axis line
+ ///
+ /// get_valueAxisLines
+ /// set_valueAxisLines
+ ///
+ /// Enables you to set a font color of the chart's title
+ ///
+ /// get_chartTitleColor
+ /// set_chartTitleColor
+ ///
+ /// Enables you to set a color of a value axis line
+ ///
+ /// get_valueAxisLineColor
+ /// set_valueAxisLineColor
+ ///
+ /// Enables you to set a color of category axis lines
+ ///
+ /// get_categoryAxisLineColor
+ /// set_categoryAxisLineColor
+ ///
+ /// Enables you to set a color of the chart's base lines
+ ///
+ /// get_baseLineColor
+ /// set_baseLineColor
+ ///
+ /// Enables you to set a background color of the tooltip box
+ ///
+ /// get_tooltipBackgroundColor
+ /// set_tooltipBackgroundColor
+ ///
+ /// Enables you to set a font color of the tooltip box
+ ///
+ /// get_tooltipFontColor
+ /// set_tooltipFontColor
+ ///
+ /// Enables you to set a border color of the tooltip box
+ ///
+ /// get_tooltipBorderColor
+ /// set_tooltipBorderColor
+ ///
+ /// Enables you to set text/label that will be shown in the tooltip and describe a area data value
+ ///
+ /// get_areaDataLabel
+ /// set_areaDataLabel
+ ///
+ /// A JSON definition of generic OnShow animation
+ ///
+ /// get_onShow
+ /// set_onShow
+ ///
+ /// The Sys.Extended.UI.Animation.GenericAnimationBehavior object containing generic OnShow animation behavior
+ ///
+ /// get_onShowBehavior
+ ///
+ /// Plays OnShow animation
+ ///
+ ///
+ /// A JSON definition of generic OnHide animation
+ ///
+ /// get_onHide
+ /// set_onHide
+ ///
+ /// The Sys.Extended.UI.Animation.GenericAnimationBehavior object containing generic OnHide animation behavior
+ ///
+ /// get_onHideBehavior
+ ///
+ /// Plays OnHide animation
+ ///
+ ///
+ /// Prompt text displayed when a user clicks the list
+ ///
+ /// get_promptText
+ /// set_promptText
+ ///
+ /// A CSS class applied to prompt when a user clicks the list
+ ///
+ /// get_promptCssClass
+ /// set_promptCssClass
+ ///
+ /// A Sys.Extended.UI.ListSearchPromptPosition value used to determine where the prompt
+ /// should be positioned relative to the target control (Top (default) or Bottom)
+ /// Can be Top (default) or Bottom
+ ///
+ /// get_promptPosition
+ /// set_promptPosition
+ ///
+ /// A Boolean value indicating whether or not the OnChange event should be raised as soon as
+ /// the selected element is changed when the list loses focus or when a user hits Enter
+ ///
+ /// get_raiseImmediateOnChange
+ /// set_raiseImmediateOnChange
+ ///
+ /// The number indicating timeout in milliseconds upon which the search query will be cleared.
+ /// Zero means no auto reset
+ ///
+ /// get_queryTimeout
+ /// set_queryTimeout
+ ///
+ /// A Boolean value used to determine whether or not the list has been sorted upon population
+ ///
+ ///
+ /// True indicates that all values in the List are already sorted upon population
+ ///
+ /// get_isSorted
+ /// set_isSorted
+ ///
+ /// A Sys.Extended.UI.ListSearchQueryPattern value used to determine the search query pattern
+ /// to be used to find items (StartsWith (default) or Contains)
+ ///
+ /// get_queryPattern
+ /// set_queryPattern
+ ///
+ /// Sets the CSS class from MaskedEdit
+ ///
+ ///
+ /// Shows or hides the message tip
+ ///
+ ///
+ /// Inserts AM/PM symbol
+ ///
+ ///
+ /// Inserts symbol negative
+ ///
+ ///
+ /// Sets Cursor at position in TextBox
+ ///
+ ///
+ /// Mask to be applied to target TextBox
+ ///
+ /// get_mask
+ /// set_mask
+ ///
+ /// Valid characters for mask type "C" (case-sensitive)
+ ///
+ /// get_filtered
+ /// set_filtered
+ ///
+ /// Text input direction
+ ///
+ ///
+ /// Possible values:
+ /// LeftToRight - Left to Right
+ /// RightToLeft - Right to left
+ ///
+ /// get_inputDirection
+ /// set_inputDirection
+ ///
+ /// Prompt character
+ ///
+ /// get_promptCharacter
+ /// set_promptCharacter
+ ///
+ /// CSS class used when the TextBox receives focus
+ ///
+ /// get_onFocusCssClass
+ /// set_onFocusCssClass
+ ///
+ /// CSS class used when the text is not valid
+ ///
+ /// get_onInvalidCssClass
+ /// set_onInvalidCssClass
+ ///
+ /// Name of culture to use (overrides the default page culture)
+ ///
+ /// get_cultureName
+ /// set_cultureName
+ ///
+ /// Culture override
+ ///
+ /// get_cultureDatePlaceholder
+ /// set_cultureDatePlaceholder
+ ///
+ /// Culture override
+ ///
+ /// get_cultureTimePlaceholder
+ /// set_cultureTimePlaceholder
+ ///
+ /// Culture override
+ ///
+ /// get_cultureDecimalPlaceholder
+ /// set_cultureDecimalPlaceholder
+ ///
+ /// Culture override
+ ///
+ /// get_cultureThousandsPlaceholder
+ /// set_cultureThousandsPlaceholder
+ ///
+ /// Culture override
+ ///
+ /// get_cultureDateFormat
+ /// set_cultureDateFormat
+ ///
+ /// Culture override
+ ///
+ /// get_cultureCurrencySymbolPlaceholder
+ /// set_cultureCurrencySymbolPlaceholder
+ ///
+ /// Culture override
+ ///
+ /// get_cultureAMPMPlaceholder
+ /// set_cultureAMPMPlaceholder
+ ///
+ /// Returns culture's first AMPM letters
+ ///
+ /// First AMPM letters
+ ///
+ /// Returns culture's first AM letter
+ ///
+ /// First AM letter
+ ///
+ /// Returns culture's first PM letter
+ ///
+ /// First PM letter
+ ///
+ /// True to remove the mask when the TextBox loses focus
+ ///
+ /// get_clearMaskOnLostFocus
+ /// set_clearMaskOnLostFocus
+ ///
+ /// Message displayed when editing in TextBox
+ ///
+ /// get_messageValidatorTip
+ /// set_messageValidatorTip
+ ///
+ /// Whether or not AM/PM is accepted on times. The default value is false
+ ///
+ /// get_acceptAMPM
+ /// set_acceptAMPM
+ ///
+ /// True if the negative sign (-) is allowed
+ ///
+ ///
+ /// Possible values:
+ /// None - Do not show the negative sign
+ /// Left - Show the negative sign on the left of the mask
+ /// Right - Show the negative sign on the right of the mask
+ ///
+ /// get_acceptNegative
+ /// set_acceptNegative
+ ///
+ /// Specifies how the currency symbol is displayed
+ ///
+ ///
+ /// Possible values:
+ /// None - Do not show the currency symbol
+ /// Left - Show the currency symbol on the left of the mask
+ /// Right - Show the currency symbol on the right of the mask
+ ///
+ /// get_displayMoney
+ /// set_displayMoney
+ ///
+ /// CSS class used when the TextBox gets focus with a negative value
+ ///
+ /// get_onFocusCssNegative
+ /// set_onFocusCssNegative
+ ///
+ /// CSS class used when the TextBox loses focus with a negative value
+ ///
+ /// get_onBlurCssNegative
+ /// set_onBlurCssNegative
+ ///
+ /// Default century used when a date mask only has two digits for the year
+ ///
+ /// get_century
+ /// set_century
+ ///
+ /// True to automatically fill in empty mask characters not specified by the user
+ ///
+ ///
+ /// MaskType=Number - Empty mask characters will be filled with zeros
+ /// MaskType=Time - Empty mask characters will be filled with the current time
+ /// MaskType=Date - Empty mask characters will be filled with the current date
+ /// MaskType=DateTime - Empty mask characters will be filled with the current date/time
+ ///
+ /// get_autoComplete
+ /// set_autoComplete
+ ///
+ /// Default character to use when AutoComplete is enabled
+ ///
+ /// get_autoCompleteValue
+ /// set_autoCompleteValue
+ ///
+ /// Type of validation to perform
+ ///
+ ///
+ /// Possible values:
+ /// None - No validation
+ /// Number - Number validation
+ /// Date - Date validation
+ /// Time - Time validation
+ /// DateTime - Date and time validation
+ ///
+ /// get_maskType
+ /// set_maskType
+ ///
+ /// True to clear the TextBox when invalid text is entered
+ ///
+ /// get_clearTextOnInvalid
+ /// set_clearTextOnInvalid
+ ///
+ /// Prompt text to use when a clipboard paste is performed
+ ///
+ /// get_clipboardText
+ /// set_clipboardText
+ ///
+ /// True to allow copy/paste with the clipboard
+ ///
+ /// get_clipboardEnabled
+ /// set_clipboardEnabled
+ ///
+ /// True to show a tooltip message when the mouse hovers over an invalid TextBox
+ ///
+ /// get_errorTooltipEnabled
+ /// set_errorTooltipEnabled
+ ///
+ /// CSS class for the tooltip message
+ ///
+ /// get_errorTooltipCssClass
+ /// set_errorTooltipCssClass
+ ///
+ /// Custom date format
+ ///
+ /// get_userDateFormat
+ /// set_userDateFormat
+ ///
+ /// Custom time format
+ ///
+ /// get_userTimeFormat
+ /// set_userTimeFormat
+ /// type, so pick arbitrarily
+ if(this._backgroundCssClass)
+ this._backgroundElement.className = this._backgroundCssClass;
+
+ this._foregroundElement.parentNode.appendChild(this._backgroundElement);
+ this._foregroundElement.style.display = 'none';
+ this._foregroundElement.style.position = 'fixed';
+
+ this._showHandler = Function.createDelegate(this, this._onShow);
+ $addHandler(this.get_element(), 'click', this._showHandler);
+
+ if(this._okControlID) {
+ this._okHandler = Function.createDelegate(this, this._onOk);
+ $addHandler($get(this._okControlID), 'click', this._okHandler);
+ }
+
+ if(this._cancelControlID) {
+ this._cancelHandler = Function.createDelegate(this, this._onCancel);
+ $addHandler($get(this._cancelControlID), 'click', this._cancelHandler);
+ }
+
+ this._scrollHandler = Function.createDelegate(this, this._onLayout);
+ this._resizeHandler = Function.createDelegate(this, this._onLayout);
+
+ // Need to know when partial updates complete
+ this.registerPartialUpdateEvents();
+
+ // We initally set it to the element, but needs to be targeted at
+ // the popup contorl
+ this._resetAnimationsTarget();
+
+ // attach to animation end events to signal hiding animation completed
+ // an call hide()/show() to hide/show the popup.
+ if(this._onHiding.get_animation()) {
+ this._hidingAnimationEndedHandler = Function.createDelegate(this, function() {
+ this._isAnimationJustEnded = true;
+ this.hide();
+ });
+ this._onHiding.get_animation().add_ended(this._hidingAnimationEndedHandler);
+ }
+
+ if(this._onShowing.get_animation()) {
+ this._showingAnimationEndedHandler = Function.createDelegate(this, function() {
+ this._isAnimationJustEnded = true;
+ this.show();
+ });
+ this._onShowing.get_animation().add_ended(this._showingAnimationEndedHandler);
+ }
+ },
+
+ dispose: function() {
+ // Going away; restore any changes to the page
+ this._hideImplementation();
+
+ if(this._foregroundElement && this._foregroundElement.parentNode) {
+ // Remove background we added to the DOM
+ this._foregroundElement.parentNode.removeChild(this._backgroundElement);
+
+ if(this._dropShadow) {
+ // Remove DIV wrapper added in initialize
+ this._foregroundElement.parentNode.appendChild(this._popupElement);
+ this._foregroundElement.parentNode.removeChild(this._foregroundElement);
+ }
+ }
+
+ this._scrollHandler = null;
+ this._resizeHandler = null;
+
+ if(this._cancelHandler && $get(this._cancelControlID)) {
+ $removeHandler($get(this._cancelControlID), 'click', this._cancelHandler);
+ this._cancelHandler = null;
+ }
+
+ if(this._okHandler && $get(this._okControlID)) {
+ $removeHandler($get(this._okControlID), 'click', this._okHandler);
+ this._okHandler = null;
+ }
+
+ if(this._showHandler) {
+ $removeHandler(this.get_element(), 'click', this._showHandler);
+ this._showHandler = null;
+ }
+
+ if(this._hidingAnimationEndedHandler) {
+ this._onHiding.get_animation().remove_ended(this._hidingAnimationEndedHandler);
+ }
+
+ if(this._showingAnimationEndedHandler) {
+ this._onShowing.get_animation().remove_ended(this._showingAnimationEndedHandler);
+ }
+
+ Sys.Extended.UI.ModalPopupBehavior.callBaseMethod(this, 'dispose');
+ },
+
+ _attachPopup: function() {
+ if(this._dropShadow && !this._dropShadowBehavior)
+ this._dropShadowBehavior = $create(Sys.Extended.UI.DropShadowBehavior, {}, null, null, this._popupElement);
+
+ if(this._dragHandleElement && !this._dragBehavior)
+ this._dragBehavior = $create(Sys.Extended.UI.FloatingBehavior, { "handle": this._dragHandleElement }, null, null, this._foregroundElement);
+
+ $addHandler(window, 'resize', this._resizeHandler);
+ $addHandler(window, 'scroll', this._scrollHandler);
+
+ this._windowHandlersAttached = true;
+ },
+
+ _detachPopup: function() {
+ if(this._windowHandlersAttached) {
+ if(this._scrollHandler)
+ $removeHandler(window, 'scroll', this._scrollHandler);
+
+ if(this._resizeHandler)
+ $removeHandler(window, 'resize', this._resizeHandler);
+
+ this._windowHandlersAttached = false;
+ }
+
+ if(this._dragBehavior) {
+ this._dragBehavior.dispose();
+ this._dragBehavior = null;
+ }
+
+ if(this._dropShadowBehavior) {
+ this._dropShadowBehavior.dispose();
+ this._dropShadowBehavior = null;
+ }
+ },
+
+ _onShow: function(e) {
+ // Handler for the target's click event
+ if(!this.get_element().disabled) {
+ this.show();
+ e.preventDefault();
+
+ return false;
+ }
+ },
+
+ _onOk: function(e) {
+ // Handler for the modal dialog's OK button click
+ var element = $get(this._okControlID);
+
+ if(element && !element.disabled) {
+ if(this.hide() && this._onOkScript)
+ window.setTimeout(this._onOkScript, 0);
+
+ e.preventDefault();
+
+ return false;
+ }
+ },
+
+ _onCancel: function(e) {
+ // Handler for the modal dialog's Cancel button click
+ var element = $get(this._cancelControlID);
+
+ if(element && !element.disabled) {
+ if(this.hide() && this._onCancelScript)
+ window.setTimeout(this._onCancelScript, 0);
+
+ e.preventDefault();
+
+ return false;
+ }
+ },
+
+ _onLayout: function(e) {
+ // Handler for scrolling and resizing events that would require a repositioning of the modal dialog
+ var positioning = this.get_repositionMode();
+
+ if(((positioning === Sys.Extended.UI.ModalPopupRepositionMode.RepositionOnWindowScroll) ||
+ (positioning === Sys.Extended.UI.ModalPopupRepositionMode.RepositionOnWindowResizeAndScroll)) && (e.type === 'scroll')) {
+ this._layout();
+ } else if(((positioning === Sys.Extended.UI.ModalPopupRepositionMode.RepositionOnWindowResize) ||
+ (positioning === Sys.Extended.UI.ModalPopupRepositionMode.RepositionOnWindowResizeAndScroll)) && (e.type === 'resize')) {
+ this._layout();
+ } else {
+ // Layout background element again to make sure it covers the whole background.
+ // This needs to be called separately since _layout will not be always called
+ // to reposition the popup depending on the RepositionMode but the background needs
+ // to handle the resize/scroll every time.
+ this._layoutBackgroundElement();
+ }
+ },
+
+ ///
+ /// Displays an element that is referenced by the PopupControlID property as a modal dialog box
+ ///
+ ///
+ /// Changes tab indices so that tabbing moves focus only through the modal dialog box
+ ///
+ ///
+ /// Restores tab indices from the page
+ ///
+ ///
+ /// Hides an element that is referenced by the PopupControlID property
+ ///
+ /// Whether the popup was hidden
+ ///
+ /// ID of an element to display as a modal popup
+ ///
+ /// get_popupControlID
+ /// set_popupControlID
+ ///
+ /// The distance from the left side of the modal popup to the left border of the browser window in pixels
+ ///
+ /// get_x
+ /// set_x
+ ///
+ /// The distance from the top side of the modal popup to the top border of the browser window in pixels
+ ///
+ /// get_y
+ /// set_y
+ ///
+ /// ID of an element to display as a drag handle for the modal popup
+ ///
+ /// get_popupDragHandleControlID
+ /// set_popupDragHandleControlID
+ ///
+ /// A CSS class to apply to the background when the modal popup is displayed
+ ///
+ /// get_backgroundCssClass
+ /// set_backgroundCssClass
+ ///
+ /// A Boolean value that specifies whether or not a drop shadow should be added to the modal popup
+ ///
+ /// get_dropShadow
+ /// set_dropShadow
+ ///
+ /// A Boolean value that specifies whether or not the modal popup can be dragged
+ ///
+ ///
+ /// This property is obsolete.
+ ///
+ /// get_drag
+ /// set_drag
+ ///
+ /// ID of an element that dismisses the modal popup
+ ///
+ /// get_okControlID
+ /// set_okControlID
+ ///
+ /// ID of an element that cancels the modal popup
+ ///
+ /// get_cancelControlID
+ /// set_cancelControlID
+ ///
+ /// A script to run when the modal popup is dismissed by the element specified using the okControlID property
+ ///
+ /// get_onOkScript
+ /// set_onOkScript
+ ///
+ /// A script to run when the modal popup is dismissed by the element specified using the cancelControlID property
+ ///
+ /// get_onCancelScript
+ /// set_onCancelScript
+ ///
+ /// The Sys.Extended.UI.ModalPopupRepositionMode object that determines whether the modal
+ /// popup should be repositioned on window resize or scroll
+ ///
+ /// get_repositionMode
+ /// set_repositionMode
+ ///
+ /// A JSON definition of generic OnShowing Animation. Played before the Popup is being shown
+ ///
+ /// get_onShowing
+ /// set_onShowing
+ ///
+ /// A JSON definition of generic OnShowing Animation. Played before the Popup is shown
+ ///
+ /// get_onShown
+ /// set_onShown
+ ///
+ /// A JSON definition of generic OnShowing Animation. Played before the Popup is being hidden
+ ///
+ /// get_onHiding
+ /// set_onHiding
+ ///
+ /// A JSON definition of generic OnShowing Animation. Played before the Popup is hidden
+ ///
+ /// get_onHidden
+ /// set_onHidden
+ ///
+ /// Fires when the popup is being shown
+ ///
+ ///
+ /// Fires when the popup is shown
+ ///
+ ///
+ /// Fires when the popup is being hidden
+ ///
+ ///
+ /// Fires when the popup is hidden
+ ///
+ ///
+ /// Determines whether or not this slider is initialized
+ ///
+ ///
+ /// For backward compatibility with the original slider
+ ///
+ /// get_sliderInitialized
+ ///
+ /// Returns a value of a specific slider handle programmatically by index
+ ///
+ /// Slider handle value
+ ///
+ /// Sets a value of a specific slider handle programmatically by index
+ ///
+ ///
+ /// A list of all handle values as a comma-delimited string
+ ///
+ ///
+ /// This is required for automated toolkit test behavior.
+ /// Returns a comma-delimited string of handle values
+ ///
+ /// get_values
+ ///
+ /// Raises the OnDragStart event
+ ///
+ ///
+ /// Raises the OnDrag event
+ ///
+ ///
+ /// Raises the OnDragEnd event
+ ///
+ ///
+ /// A value of a single bound control for backward compatibility of the existing slider and tests.
+ /// Can be used only in this context
+ ///
+ /// get_value
+ /// set_value
+ ///
+ /// The lowest value on the slider
+ ///
+ /// get_minimum
+ /// set_minimum
+ ///
+ /// The highest value on the slider
+ ///
+ /// get_maximum
+ /// set_maximum
+ ///
+ /// The slider rail length in pixels
+ ///
+ /// get_length
+ /// set_length
+ ///
+ /// Determines the number of discrete locations on the slider. Otherwise, the slider is continous
+ ///
+ /// get_steps
+ /// set_steps
+ ///
+ /// Determines if the slider's orientation is horizontal or vertical
+ ///
+ /// get_orientation
+ /// set_orientation
+ ///
+ /// Determines if the slider handles display an animation effect when the position is changed
+ ///
+ /// get_enableHandleAnimation
+ /// set_enableHandleAnimation
+ ///
+ /// Determines the total duration of the animation effect in seconds
+ ///
+ /// get_handleAnimationDuration
+ /// set_handleAnimationDuration
+ ///
+ /// Determines if changes events to the slider's values are raised during dragging.
+ /// Otherwise, they are raised when dragging is completed
+ ///
+ /// get_raiseChangeOnlyOnMouseUp
+ /// set_raiseChangeOnlyOnMouseUp
+ ///
+ /// Determines if the slider will show an inner selected range rail. Otherwise,
+ /// it will be displayed as a uniform rail
+ ///
+ /// get_showInnerRail
+ /// set_showInnerRail
+ ///
+ /// Determines if the slider handles will show a style effect when they are hovered over
+ ///
+ /// get_showHandleHoverStyle
+ /// set_showHandleHoverStyle
+ ///
+ /// Determines if the slider handles will show a style effect when they are being dragged
+ ///
+ /// get_showHandleDragStyle
+ /// set_showHandleDragStyle
+ ///
+ /// Determines how the inner rail style is handled
+ ///
+ /// get_innerRailStyle
+ /// set_innerRailStyle
+ ///
+ /// Determines if the inner rail range can be dragged as a whole moving both handles defining it
+ ///
+ /// get_enableInnerRangeDrag
+ /// set_enableInnerRangeDrag
+ ///
+ /// Determines if clicking the rail will detect and move the closest handle
+ ///
+ /// get_enableRailClick
+ /// set_enableRailClick
+ ///
+ /// Determines if the slider and its values can be manipulated
+ ///
+ /// get_isReadOnly
+ /// set_isReadOnly
+ ///
+ /// Determines if the slider will respond to arrow keys when it has focus
+ ///
+ /// get_enableKeyboard
+ /// set_enableKeyboard
+ ///
+ /// Determines if the slider will respond to the mouse wheel when it has focus
+ ///
+ /// get_enableMouseWheel
+ /// set_enableMouseWheel
+ ///
+ /// Determines the number of slider points to increment or decrement using the keyboard or mouse wheel.
+ /// It is ignored if the steps property is used
+ ///
+ /// get_increment
+ /// set_increment
+ ///
+ /// Determines the text to display as a tooltip; {0} denotes the current
+ /// handle's value in the format string
+ ///
+ /// get_tooltipText
+ /// set_tooltipText
+ ///
+ /// The list of controls used to bind slider handle values. These should be Label or TextBox controls
+ ///
+ /// get_multiHandleSliderTargets
+ /// set_multiHandleSliderTargets
+ ///
+ /// A master style to apply to slider graphical elements
+ ///
+ /// get_cssClass
+ /// set_cssClass
+ ///
+ /// ID of a control to use for a single handle
+ ///
+ /// get_boundControlID
+ /// set_boundControlID
+ ///
+ /// A CSS class of a single handle
+ ///
+ /// get_handleCssClass
+ /// set_handleCssClass
+ ///
+ /// URL for an image to display in the slider's handle
+ ///
+ /// get_handleImageUrl
+ /// set_handleImageUrl
+ ///
+ /// A CSS class for the slider's rail element
+ ///
+ /// get_railCssClass
+ /// set_railCssClass
+ ///
+ /// The number of decimal digits in a single slider's value
+ ///
+ /// get_decimals
+ /// set_decimals
+ ///
+ /// The event is raised when the slider is completely loaded on the page
+ ///
+ ///
+ /// The event is raised when a user initiates the drag operation on the slider
+ ///
+ ///
+ /// The event is raised when the user drags the slider
+ ///
+ ///
+ /// The event is raised when the user drops the slider
+ ///
+ ///
+ /// The event is raised when the slider changes its state
+ ///
+ ///
+ /// A unique key to use to associate check boxes
+ ///
+ /// get_key
+ /// set_key
+ ///
+ /// Fires when the check box is checked
+ ///
+ ///
+ /// Challenge script.
+ ///
+ /// get_challengeScript
+ /// set_challengeScript
+ ///
+ /// Fires when the current textbox value changes
+ ///
+ ///
+ /// Reads a value of the associated textbox
+ ///
+ ///
+ /// Sets a value of the associated textbox
+ ///
+ ///
+ /// Combined size of the TextBox and Up/Down buttons. Minimum value 25
+ ///
+ ///
+ /// This property is not used if you provide custom buttons
+ ///
+ /// get_width
+ /// set_width
+ ///
+ /// Custom parameter to pass to the Web Service
+ ///
+ /// get_tag
+ /// set_tag
+ ///
+ /// A reference to a custom Up button
+ ///
+ /// get_targetButtonUpID
+ /// set_targetButtonUpID
+ ///
+ /// A reference to a custom Down button
+ ///
+ /// get_targetButtonDownID
+ /// set_targetButtonDownID
+ ///
+ /// A path to a web service that returns data used to get the next value
+ ///
+ ///
+ /// If the ServiceUpPath property is empty, the PageMethod will be used instead of the Web service
+ ///
+ /// get_serviceUpPath
+ /// set_serviceUpPath
+ ///
+ /// A name of the method to call on the Web service (or the name of the PageMethod) to get the next value
+ ///
+ /// get_serviceUpMethod
+ /// set_serviceUpMethod
+ ///
+ /// A path to a Web service that returns data used to get the previous value
+ ///
+ ///
+ /// If the ServiceDownPath property is empty, the PageMethod will be used instead of the Web service
+ ///
+ /// get_serviceDownPath
+ /// set_serviceDownPath
+ ///
+ /// A name of the method to call on the Web service (or the name of the PageMethod) to get the previous value
+ ///
+ /// get_serviceDownMethod
+ /// set_serviceDownMethod
+ ///
+ /// A list of strings separated by semicolons (;) to be used as an enumeration by NumericUpDown
+ ///
+ /// get_refValues
+ /// set_refValues
+ ///
+ /// A step used for simple numeric incrementing and decrementing. The default value is 1
+ ///
+ /// get_step
+ /// set_step
+ ///
+ /// The minimum value allowed by the extender
+ ///
+ ///
+ /// Currently, it does not prevent out of range values from being entered into the textbox
+ /// even if Minimum or Maximum are specified on the extender, but using the up/down buttons
+ /// should bring the value into the allowed range when clicked
+ ///
+ /// get_minimum
+ /// set_minimum
+ ///
+ /// The maximum value allowed by the extender
+ ///
+ /// get_maximum
+ /// set_maximum
+ ///
+ /// Fires when the selected index changes
+ ///
+ ///
+ /// DOM elements of the indices
+ ///
+ /// get_tabIndex
+ ///
+ /// DOM elements of items to display for each index
+ ///
+ /// get_tabValue
+ ///
+ /// Bulleted list height
+ ///
+ /// get_height
+ /// set_height
+ ///
+ /// The number of characters in the index headings (ignored if MaxItemPerPage is set)
+ ///
+ /// get_indexSize
+ /// set_indexSize
+ ///
+ /// Maximum number of items per page (ignores the IndexSize property)
+ ///
+ /// get_maxItemPerPage
+ /// set_maxItemPerPage
+ ///
+ /// Separator text to be placed between indices
+ ///
+ /// get_separator
+ /// set_separator
+ ///
+ /// Determines whether or not items should be sorted on the client side
+ ///
+ /// get_clientSort
+ /// set_clientSort
+ ///
+ /// A CSS class for the selected index
+ ///
+ /// get_selectIndexCssClass
+ /// set_selectIndexCssClass
+ ///
+ /// A CSS class for indices that aren't selected
+ ///
+ /// get_unselectIndexCssClass
+ /// set_unselectIndexCssClass
+ ///
+ /// Preferred length of the password
+ ///
+ ///
+ /// Passwords could be less than this amount but wont reach the 100% calculation
+ /// if less than this count. This is used to calculate 50% of the percentage strength of the password
+ /// Ideally, a password should be 20 characters in length to be a strong password.
+ ///
+ /// get_preferredPasswordLength
+ /// set_preferredPasswordLength
+ ///
+ /// Minimum number of numeric characters
+ ///
+ ///
+ /// If there are less than this property, then the password is not
+ /// considered strong. If there are equal to or more than this value,
+ /// then this will contribute 15% to the overall password strength percentage value.
+ ///
+ /// get_minimumNumericCharacters
+ /// set_minimumNumericCharacters
+ ///
+ /// Minimum number of symbol characters (ex. $ ^ *)
+ ///
+ ///
+ /// If there are less than this property, then the password is not considered strong.
+ /// If there are equal to or more than this value, then this will contribute 15% to the overall
+ /// password strength percentage value.
+ ///
+ /// get_minimumSymbolCharacters
+ /// set_minimumSymbolCharacters
+ ///
+ /// Specifies whether mixed case characters are required
+ ///
+ ///
+ /// Determines if mixed case passwords are required to be considered strong.
+ /// If true, then there must be at least one occurrence of mixed case
+ /// (upper and lower) letters in the password to be considered strong. If there is,
+ /// this will contribute 20% to the overall password strength percentage value.
+ ///
+ /// get_requiresUpperAndLowerCaseCharacters
+ /// set_requiresUpperAndLowerCaseCharacters
+ ///
+ /// CSS class applied to the text display when StrengthIndicatorType=Text
+ ///
+ /// get_textCssClass
+ /// set_textCssClass
+ ///
+ /// CSS class applied to the bar indicator's border when StrengthIndicatorType=BarIndicator
+ ///
+ /// get_barBorderCssClass
+ /// set_barBorderCssClass
+ ///
+ /// CSS class applied to the bar indicator's inner bar when StrengthIndicatorType=BarIndicator
+ ///
+ /// get_barIndicatorCssClass
+ /// set_barIndicatorCssClass
+ ///
+ /// Positioning of the strength indicator relative to the target control
+ ///
+ /// get_displayPosition
+ /// set_displayPosition
+ ///
+ /// Text prefixed to the display text when StrengthIndicatorType=Text
+ ///
+ /// get_prefixText
+ /// set_prefixText
+ ///
+ /// Strength indicator type (Text or BarIndicator)
+ ///
+ ///
+ /// BarIndicator - progress bar indicating password strength
+ /// Text - low, medium, high or excellent
+ ///
+ /// get_strengthIndicatorType
+ /// set_strengthIndicatorType
+ ///
+ /// List of semi-colon separated descriptions used when StrengthIndicatorType=Text
+ /// (Minimum of 2, maximum of 10; order is weakest to strongest)
+ ///
+ ///
+ /// Example: None;Weak;Medium;Strong;Excellent
+ ///
+ /// get_textStrengthDescriptions
+ /// set_textStrengthDescriptions
+ ///
+ /// List of semi-colon separated CSS classes that are used depending on the password's strength.
+ ///
+ ///
+ /// This property will override the BarIndicatorCssClass / TextIndicatorCssClass property if present.
+ /// The BarIndicatorCssClass / TextIndicatorCssClass property differs in that it attributes one
+ /// CSS style to the BarIndicator or Text Strength indicator (depending on which type is chosen)
+ /// regardless of password strength. This property will cause the style to change based on the password
+ /// strength and also to the number of styles specified in this property. For example, if 2 styles are
+ /// defined like StrengthStyles="style1;style2" then style1 is applied when the password strength is less
+ /// than 50%, and style2 is applied when password strength is >= 50%. This property can have up to 10 styles.
+ ///
+ /// get_strengthStyles
+ /// set_strengthStyles
+ ///
+ /// A semi-colon delimited string that specifies the styles applicable to each
+ /// string descriptions for the password strength when using a textual display
+ ///
+ ///
+ /// Deprecated. Use StrengthStyles instead
+ ///
+ /// get_TextStrengthDescriptionStyles
+ /// set_TextStrengthDescriptionStyles
+ ///
+ /// CSS class applied to the help element used to display a dialog box
+ /// describing the password requirements
+ ///
+ ///
+ /// This is used so that the user can click on this image and get a display
+ /// on what is required to make the password strong according to the current properties
+ ///
+ /// get_helpHandleCssClass
+ /// set_helpHandleCssClass
+ ///
+ /// Positioning of the help handle element relative to the target control
+ ///
+ /// get_helpHandlePosition
+ /// set_helpHandlePosition
+ ///
+ /// List of semi-colon separated numeric values used to determine the weighting of a strength characteristic.
+ ///
+ ///
+ /// There must be 4 values specified which must total 100.
+ /// The default weighting values are defined as 50;15;15;20.
+ /// This corresponds to password length is 50% of the strength calculation, Numeric criteria is 15% of
+ /// strength calculation, casing criteria is 15% of calculation, and symbol criteria is 20% of calculation.
+ /// So the format is 'A;B;C;D' where A = length weighting, B = numeric weighting, C = casing weighting, D = symbol weighting.
+ ///
+ /// get_calculationWeightings
+ /// set_calculationWeightings
+ ///
+ /// Help text to show
+ ///
+ /// get_helpText
+ /// set_helpText
+ ///
+ /// Minimum number of lowercase characters required when requiring mixed case
+ /// characters as part of your password strength considerations
+ ///
+ ///
+ /// Only in effect if RequiresUpperAndLowerCaseCharacters property is true.
+ /// The default value is 0 which means this property is not in effect and
+ /// there is no minimum limit.
+ ///
+ /// get_minimumLowerCaseCharacters
+ /// set_minimumLowerCaseCharacters
+ ///
+ /// Minimum number of uppercase characters required when requiring mixed case
+ /// characters as part of your password strength considerations.
+ ///
+ ///
+ /// Only in effect if RequiresUpperAndLowerCaseCharacters property is true.
+ /// The default value is 0 which means this property is not in effect and
+ /// there is no minimum limit.
+ ///
+ /// get_minimumUpperCaseCharacters
+ /// set_minimumUpperCaseCharacters
+ ///
+ /// Control ID of the label used to display help text
+ ///
+ /// get_helpStatusLabelID
+ /// set_helpStatusLabelID
+ /// ', this._chartWidth, this._chartHeight);
+ svgContents = svgContents + '';
+ svgContents = svgContents + String.format('', radius, startX, startY);
+ svgContents = svgContents + ' ';
+ svgContents = svgContents + ' ';
+ svgContents = svgContents + String.format('{2} ', parseInt(this._chartWidth) / 2 - (this._chartTitle.length * this.charLength), parseInt(this._chartHeight) * 5 / 100, this._chartTitle, this._chartTitleColor);
+
+ // Legend Area
+ var legendAreaStartHeight = (parseInt(this._chartHeight) * 82 / 100) + 5,
+ legendBoxWidth = 7.5,
+ legendBoxHeight = 7.5,
+ spaceInLegendContents = 5;
+
+ // Get length of text to display in legend
+ var legendCharLength = 0;
+ for(var i = 0; i < this._pieChartClientValues.length; i++)
+ legendCharLength = legendCharLength + this._pieChartClientValues[i].Category.length;
+
+ var legendAreaWidth = Math.round((legendCharLength * 5) / 2) + Math.round((legendBoxWidth + (spaceInLegendContents * 2)) * this._pieChartClientValues.length),
+ isLegendNextLine = false;
+
+ if(legendAreaWidth > parseInt(this._chartWidth) / 2) {
+ legendAreaWidth = legendAreaWidth / 2;
+ isLegendNextLine = true;
+ }
+
+ svgContents = svgContents + '';
+ svgContents = svgContents + String.format('{2} ', startText, legendAreaStartHeight + 15, this._pieChartClientValues[i].Category);
+
+ if(this._pieChartClientValues[i].Category.length > 10) {
+ nextStartLegend = startLegend + (this._pieChartClientValues[i].Category.length * 5.5) + legendBoxWidth + (spaceInLegendContents * 2);
+ nextStartText = startText + (this._pieChartClientValues[i].Category.length * 5.5) + legendBoxWidth + (spaceInLegendContents * 2);
+ } else {
+ nextStartLegend = nextStartLegend + (this._pieChartClientValues[i].Category.length * 6) + legendBoxWidth + (spaceInLegendContents * 2);
+ nextStartText = nextStartText + (this._pieChartClientValues[i].Category.length * 6) + legendBoxWidth + (spaceInLegendContents * 2);
+ }
+ }
+ svgContents = svgContents + ' ';
+
+ // Draw PieChart
+ var categoryValue = 0,
+ totalValue = 0,
+ angle = 0,
+ radAngle = 0,
+ textRadAngle = 0,
+ endX = 0,
+ endY = 0,
+ arc = 0,
+ lastEndX = startX,
+ lastEndY = startY - radius,
+ textX = startX,
+ textY = startY - radius;
+
+ for(var i = 0; i < this._pieChartClientValues.length; i++)
+ totalValue = totalValue + Math.abs(parseFloat(this._pieChartClientValues[i].Data));
+
+ this._parentDiv.innerHTML = svgContents;
+ this.drawSegments(this, 0, categoryValue, totalValue, radius, angle, radAngle, textRadAngle, startX, endX, startY, endY, textX, textY, lastEndX, lastEndY, arc);
+ },
+
+ drawSegments: function (me, index, categoryValue, totalValue, radius, angle, radAngle, textRadAngle, startX, endX, startY, endY, textX, textY, lastEndX, lastEndY, arc) {
+ var absClientValues = Math.abs(parseFloat(me._pieChartClientValues[index].Data));
+ categoryValue = categoryValue + absClientValues;
+ angle = (categoryValue / totalValue) * 360;
+ radAngle = angle * (Math.PI / 180);
+ textRadAngle = (categoryValue - absClientValues / 2) / totalValue * 360;
+ textRadAngle = textRadAngle * (Math.PI / 180);
+ endX = parseFloat(Math.sin(radAngle) * radius);
+ endY = parseFloat(Math.cos(radAngle) * radius);
+ textX = parseFloat(Math.sin(textRadAngle) * (radius + 10));
+ textY = parseFloat(Math.cos(textRadAngle) * (radius + 10));
+
+ textX = (startX + textX) > startX ? startX + textX : (startX + textX) - (me._pieChartClientValues[index].Data.toString().length * this.charLength);
+ textY = (startY + (-1 * textY)) < startY ? startY + (-1 * textY) : startY + (-1 * textY) + 10;
+ if (absClientValues > totalValue / 2) {
+ arc = 1;
+ }
+ else {
+ arc = 0;
+ }
+ me._parentDiv.innerHTML = me._parentDiv.innerHTML.replace(' ', '') + String.format('{2}
+ /// Width of the chart
+ ///
+ /// get_chartWidth
+ /// set_chartWidth
+ ///
+ /// Height of the chart
+ ///
+ /// get_chartHeight
+ /// set_chartHeight
+ ///
+ /// A title of the chart
+ ///
+ /// get_chartTitle
+ /// set_chartTitle
+ ///
+ /// Provides the list of PieChartValues
+ ///
+ /// get_pieChartClientValues
+ /// set_pieChartClientValues
+ ///
+ /// A theme of the chart
+ ///
+ /// get_theme
+ /// set_theme
+ ///
+ /// Font color of the chart title
+ ///
+ /// get_chartTitleColor
+ /// set_chartTitleColor
+ ///
+ /// Shows the popup
+ ///
+ ///
+ /// Hides the popup
+ ///
+ ///
+ /// A JSON definition of generic OnShow Animation
+ ///
+ /// get_onShow
+ /// set_onShow
+ ///
+ /// Generic OnShow Animation behavior
+ ///
+ /// get_onShowBehavior
+ ///
+ /// Plays OnShow animation
+ ///
+ ///
+ /// A JSON definition of generic OnHide Animation
+ ///
+ /// get_onHide
+ /// set_onHide
+ ///
+ /// Generic OnHide Animation behavior
+ ///
+ /// get_onHideBehavior
+ ///
+ /// Plays OnHide animation
+ ///
+ ///
+ /// The ID of the control to display
+ ///
+ /// get_popupControlID
+ /// set_popupControlID
+ ///
+ /// The property of a control being extended that should be set with the result of the popup
+ ///
+ /// get_commitProperty
+ /// set_commitProperty
+ ///
+ /// An additional script to run after the result of the popup is set
+ ///
+ /// get_commitScript
+ /// set_commitScript
+ ///
+ /// Determines where the popup should be positioned relative to the target control
+ /// (Left, Right, Top, Bottom, or Center)
+ ///
+ /// get_position
+ /// set_position
+ ///
+ /// The ID of the extender control
+ ///
+ /// get_extenderControlID
+ /// set_extenderControlID
+ ///
+ /// The number of pixels to horizontally offset the Popup from its default position
+ ///
+ /// get_offsetX
+ /// set_offsetX
+ ///
+ /// The number of pixels to vertically offset the Popup from its default position
+ ///
+ /// get_offsetY
+ /// set_offsetY
+ ///
+ /// Determines whether or not the popup is visible
+ ///
+ /// get_popupVisible
+ ///
+ /// Fires when the popup is being shown
+ ///
+ ///
+ /// Fires after the popup is shown
+ ///
+ ///
+ /// Fires when the popup is being hidden
+ ///
+ ///
+ /// Firs after the popup is hidden
+ ///
+ ///
+ /// Fires when rating has been marked
+ ///
+ ///
+ /// Fires when mouse is over the Rating control
+ ///
+ ///
+ /// Fires when mouse pointer leaves the Rating element
+ ///
+ ///
+ /// Fires when rating is changed
+ ///
+ ///
+ /// Set to True to cause a postback on rating item click
+ ///
+ /// get_autoPostBack
+ /// set_autoPostBack
+ ///
+ /// An array of stars
+ ///
+ /// get_stars
+ ///
+ /// A custom parameter to pass to the ClientCallBack
+ ///
+ /// get_tag
+ /// set_tag
+ ///
+ /// ID of the callback
+ ///
+ /// get_callbackID
+ /// set_callbackID
+ ///
+ /// Orientation of stars (LeftToRightTopToBottom or RightToLeftBottomToTop)
+ ///
+ /// get_ratingDirection
+ /// set_ratingDirection
+ ///
+ /// A CSS class for a star in empty mode
+ ///
+ /// get_emptyStarCssClass
+ /// set_emptyStarCssClass
+ ///
+ /// A CSS class for star in filled mode
+ ///
+ /// get_filledStarCssClass
+ /// set_filledStarCssClass
+ ///
+ /// A CSS class for a star in waiting mode
+ ///
+ /// get_waitingStarCssClass
+ /// set_waitingStarCssClass
+ ///
+ /// A current rating value
+ ///
+ /// get_rating
+ /// set_rating
+ ///
+ /// A maximum rating value
+ ///
+ /// get_maxRating
+ /// set_maxRating
+ ///
+ /// Whether or not the rating can be changed
+ ///
+ /// get_readOnly
+ /// set_readOnly
+ ///
+ /// A CSS class for a visible star
+ ///
+ /// get_starCssClass
+ /// set_starCssClass
+ ///
+ /// The name of the CSS class to apply to the resize handle
+ ///
+ /// get_handleCssClass
+ /// set_handleCssClass
+ ///
+ /// The name of the CSS class to apply to the element when resizing
+ ///
+ /// get_resizableCssClass
+ /// set_resizableCssClass
+ ///
+ /// X-Offset to apply to the location of the resize handle
+ ///
+ /// get_handleOffsetX
+ /// set_handleOffsetX
+ ///
+ /// Y-Offset to apply to the location of the resize handle
+ ///
+ /// get_handleOffsetY
+ /// set_handleOffsetY
+ ///
+ /// Minimum width of the resizable element
+ ///
+ /// get_minimumWidth
+ /// set_minimumWidth
+ ///
+ /// Minimum height of the resizable element
+ ///
+ /// get_minimumHeight
+ /// set_minimumHeight
+ ///
+ /// Maximum width of the resizable element
+ ///
+ /// get_maximumWidth
+ /// set_maximumWidth
+ ///
+ /// Maximum height of the resizable element
+ ///
+ /// get_maximumHeight
+ /// set_maximumHeight
+ ///
+ /// Fires as the element is being resized
+ ///
+ ///
+ /// The Resizing event handler
+ ///
+ /// get_resizing
+ /// set_resizing
+ ///
+ /// Fires when the element has been resized
+ ///
+ ///
+ /// The Resize event handler
+ ///
+ /// get_resize
+ /// set_resize
+ ///
+ /// Fires when the element starts being resized
+ ///
+ ///
+ /// The ResizeBegin event handler
+ ///
+ /// get_resizeBegin
+ /// set_resizeBegin
+ ///
+ /// Size of the target (of the form {width, height})
+ ///
+ /// get_size
+ /// set_size
+ ///
+ /// Returns the background color of the target element
+ ///
+ /// String contains the color of the target element
+ ///
+ /// Checks whether a flag for this corner has been set
+ ///
+ /// True if the corner has been set; otherwise, false
+ ///
+ /// Sets a corner as one that should be rounded
+ ///
+ ///
+ /// A string that contains the background color of the rounded corner areas
+ ///
+ ///
+ /// By default, this property gets the background color of the panel that it is attached to
+ ///
+ /// get_color
+ /// set_color
+ ///
+ /// An integer value that specifies the radius of the corners (and the height of the added area). The default is 5
+ /// The default is 5
+ ///
+ /// get_radius
+ /// set_radius
+ ///
+ /// A Sys.Extended.UI.BoxCorners object that specifies which corners should be rounded
+ ///
+ /// get_corners
+ /// set_corners
+ ///
+ /// A string that contains the color of the border and therefore of the rounded corners
+ ///
+ /// get_borderColor
+ /// set_borderColor
+ /// ');
+ // the text-align:left guards against incorrect centering in IE
+ html.push('
+ /// Returns a navigation control of the viewer
+ ///
+ /// Navigation control
+ ///
+ /// An XML path
+ ///
+ /// get_xmlPath
+ /// set_xmlPath
+ ///
+ /// Determines whether or not the debug mode is enabled
+ ///
+ /// get_debugMode
+ /// set_debugMode
+ ///
+ /// The amount of time in seconds that animations should last. Default is 1.5
+ ///
+ /// get_animationTime
+ /// set_animationTime
+ ///
+ /// The amount of time in seconds that new tiles take to blend from transparent to opaque.
+ /// Default is 0.5
+ ///
+ /// get_blendTime
+ /// set_blendTime
+ ///
+ /// Determines whether or not tiles should always blend in and out, not just when they're first loaded.
+ /// Default is false
+ ///
+ /// get_alwaysBlend
+ /// set_alwaysBlend
+ ///
+ /// Determines whether or not controls should be automatically hidden when a user
+ /// moves the mouse away from the viewer and the image has stopped animating.
+ /// Default is true
+ ///
+ /// get_autoHideControl
+ /// set_autoHideControl
+ ///
+ /// Determines whether or not the most appropriate tiles should always be rendered before any
+ /// low-resolution tiles are rendered. The sharpening effect is lost, and instead a visible
+ /// tiling effect occurs. Default is false
+ ///
+ /// get_immediateRender
+ /// set_immediateRender
+ ///
+ /// Determines whether or not the control uses horizontal wrapping
+ ///
+ /// get_wrapHorizontal
+ /// set_wrapHorizontal
+ ///
+ /// Determines whether or not the control uses vertical wrapping
+ ///
+ /// get_wrapVertical
+ /// set_wrapVertical
+ ///
+ /// Minimum size (in screen pixels) of a dimension that can be obtained from zooming out.
+ /// Default is 16
+ ///
+ /// get_minZoomDimension
+ /// set_minZoomDimension
+ ///
+ /// Maximum pixel ratio (screen pixel to content pixel) that can be obtained from zooming in.
+ /// Default is 4
+ ///
+ /// get_maxZoomPixelRation
+ /// set_maxZoomPixelRation
+ ///
+ /// Minimum portion of the viewport that must show visible content in both dimensions.
+ /// Default is 0.1
+ ///
+ /// get_visibilityRatio
+ /// set_visibilityRatio
+ ///
+ /// Determines how sharply springs used for animations move.
+ /// Default is 5.0
+ ///
+ /// get_springStiffness
+ /// set_springStiffness
+ ///
+ /// Maximum number of concurrent image downloads that can be performed by each viewer.
+ /// Default is 2
+ ///
+ /// get_imageLoaderLimit
+ /// set_imageLoaderLimit
+ ///
+ /// Maximum number of milliseconds that can pass between a mousedown and mouseup for an
+ /// action to be considered as a quick click. Default is 200
+ ///
+ /// get_clickTimeThreshold
+ /// set_clickTimeThreshold
+ ///
+ /// Maximum number of pixels the mouse can move between a mousedown and mouseup fo
+ /// an action to be considered as a quick click. Default is 5
+ ///
+ /// get_clickDistThreshold
+ /// set_clickDistThreshold
+ ///
+ /// The factor by which images should zoom in on being clicked. Default is 2
+ ///
+ /// get_zoomPerClick
+ /// set_zoomPerClick
+ ///
+ /// The factor by which images should zoom in each second the zoom buttons are held down.
+ /// Default is 2
+ ///
+ /// get_zoomPerSecond
+ /// set_zoomPerSecond
+ ///
+ /// Maximum number of cached images
+ ///
+ /// get_maxImageCacheCount
+ /// set_maxImageCacheCount
+ ///
+ /// Determines whether or not navigation buttons should be shown
+ ///
+ /// get_showNavigationControl
+ /// set_showNavigationControl
+ ///
+ /// Minimum pixel ratio
+ ///
+ /// get_minPixelRatio
+ /// set_minPixelRatio
+ ///
+ /// Determines whether or not mouse navigation is enabled
+ ///
+ /// get_mouseNavEnabled
+ /// set_mouseNavEnabled
+ ///
+ /// A list of controls
+ ///
+ /// get_controls
+ /// set_controls
+ ///
+ /// A list of overlay controls
+ ///
+ /// get_overlays
+ /// set_overlays
+ ///
+ /// Prefix URL
+ ///
+ /// get_prefixUrl
+ /// set_prefixUrl
+ ///
+ /// Fires when the viewer opens
+ ///
+ ///
+ /// Fires when the error occurs
+ ///
+ ///
+ /// Fires when the ignore event occurs
+ ///
+ ///
+ /// Fires on viewer resizing
+ ///
+ ///
+ /// Fires when animation starts
+ ///
+ ///
+ /// Fires when animation ends
+ ///
+ /// with subpixel rendering.
+// update: safari 4 does too now! update: and chrome 2!
+var subpixelRenders = browser == Seadragon.Browser.FIREFOX ||
+ browser == Seadragon.Browser.OPERA ||
+ (browser == Seadragon.Browser.SAFARI && browserVer >= 4) ||
+ (browser == Seadragon.Browser.CHROME && browserVer >= 2);
+
+// make sure browser supports , and only use it if we know browser
+// does subpixel rendering with (that's the main advantage)
+var useCanvas =
+ typeof (document.createElement("canvas").getContext) == "function" &&
+ subpixelRenders;
+Sys.Extended.UI.Seadragon.Tile = function(level, x, y, bounds, exists, url) {
+ // Core
+ this.level = level;
+ this.x = x;
+ this.y = y;
+ this.bounds = bounds; // where this tile fits, in normalized coordinates
+ this.exists = exists; // part of sparse image? tile hasn't failed to load?
+ this.loaded = false; // is this tile loaded?
+ this.loading = false; // or is this tile loading?
+
+ // Image
+ this.elmt = null; // the HTML element for this tile
+ this.image = null; // the Image object for this tile
+ this.url = url; // the URL of this tile's image
+
+ // Drawing
+ this.style = null; // alias of this.elmt.style
+ this.position = null; // this tile's position on screen, in pixels
+ this.size = null; // this tile's size on screen, in pixels
+ this.blendStart = null; // the start time of this tile's blending
+ this.opacity = null; // the current opacity this tile should be
+ this.distance = null; // the distance of this tile to the viewport center
+ this.visibility = null; // the visibility score of this tile
+
+ // Caching
+ this.beingDrawn = false; // whether this tile is currently being drawn
+ this.lastTouchTime = 0; // the time that tile was last touched
+};
+Sys.Extended.UI.Seadragon.Tile.prototype = {
+ dispose: function() {
+ },
+ toString: function() {
+ return this.level + "/" + this.x + "_" + this.y;
+ },
+ drawHTML: function(container) {
+ if(!this.loaded) {
+ Seadragon.Debug.error("Attempting to draw tile " + this.toString() +
+ " when it's not yet loaded.");
+ return;
+ }
+
+ // initialize if first time
+ if(!this.elmt) {
+ this.elmt = Seadragon.Utils.makeNeutralElement("img");
+ this.elmt.src = this.url;
+ this.style = this.elmt.style;
+ this.style.position = "absolute";
+ this.style.msInterpolationMode = "nearest-neighbor";
+ // IE only property. bicubic is ideal, but it causes seams.
+ // explicitly use nearest-neighbor so it's not overridden to
+ // bicubic on page zoom.
+ }
+
+ var elmt = this.elmt;
+ var style = this.style;
+ var position = this.position.apply(Math.floor);
+ var size = this.size.apply(Math.ceil);
+
+ // this was an alternate idea to hopefully make the rendering more
+ // accurate, by prioritizing the edges of the image and not the size,
+ // but it hasn't seemed to make any difference.
+ //var topLeft = this.position;
+ //var bottomRight = topLeft.plus(this.size);
+ //var position = topLeft.apply(Math.floor);
+ //var size = bottomRight.minus(topLeft).apply(Math.floor);
+
+ if(elmt.parentNode != container)
+ container.appendChild(elmt);
+
+ style.left = position.x + "px";
+ style.top = position.y + "px";
+ style.width = size.x + "px";
+ style.height = size.y + "px";
+
+ Seadragon.Utils.setElementOpacity(elmt, this.opacity);
+ },
+ drawCanvas: function(context) {
+ if(!this.loaded) {
+ Seadragon.Debug.error("Attempting to draw tile " + this.toString() +
+ " when it's not yet loaded.");
+ return;
+ }
+
+ var position = this.position;
+ var size = this.size;
+
+ context.globalAlpha = this.opacity;
+ context.drawImage(this.image, position.x, position.y, size.x, size.y);
+ },
+ unload: function() {
+ if(this.elmt && this.elmt.parentNode)
+ this.elmt.parentNode.removeChild(this.elmt);
+
+ this.elmt = null;
+ this.image = null;
+ this.loaded = false;
+ this.loading = false;
+ }
+};
+Sys.Extended.UI.Seadragon.Tile.registerClass('Sys.Extended.UI.Seadragon.Tile', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.Overlay = function(elmt, loc, placement) {
+ // Core
+ this.elmt = elmt;
+ this.scales = (loc instanceof Sys.Extended.UI.Seadragon.Rect);
+ this.bounds = new Sys.Extended.UI.Seadragon.Rect(loc.x, loc.y, loc.width, loc.height);
+ // Drawing
+ this.placement = loc instanceof Sys.Extended.UI.Seadragon.Point ? placement : Sys.Extended.UI.Seadragon.OverlayPlacement.TOP_LEFT; // rects are always top-left
+ this.position = new Sys.Extended.UI.Seadragon.Point(loc.x, loc.y);
+ this.size = new Sys.Extended.UI.Seadragon.Point(loc.width, loc.height);
+ this.style = elmt.style;
+};
+Sys.Extended.UI.Seadragon.Overlay.prototype = {
+
+ adjust: function(position, size) {
+ switch(this.placement) {
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.TOP_LEFT:
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.TOP:
+ position.x -= size.x / 2;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.TOP_RIGHT:
+ position.x -= size.x;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.RIGHT:
+ position.x -= size.x;
+ position.y -= size.y / 2;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.BOTTOM_RIGHT:
+ position.x -= size.x;
+ position.y -= size.y;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.BOTTOM:
+ position.x -= size.x / 2;
+ position.y -= size.y;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.BOTTOM_LEFT:
+ position.y -= size.y;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.LEFT:
+ position.y -= size.y / 2;
+ break;
+ case Sys.Extended.UI.Seadragon.OverlayPlacement.CENTER:
+ default:
+ position.x -= size.x / 2;
+ position.y -= size.y / 2;
+ break;
+ }
+ },
+ destroy: function() {
+ var elmt = this.elmt;
+ var style = this.style;
+
+ if(elmt.parentNode)
+ elmt.parentNode.removeChild(elmt);
+
+ style.top = "";
+ style.left = "";
+ style.position = "";
+
+ if(this.scales) {
+ style.width = "";
+ style.height = "";
+ }
+ },
+ drawHTML: function(container) {
+ var elmt = this.elmt;
+ var style = this.style;
+ var scales = this.scales;
+
+ if(elmt.parentNode != container)
+ container.appendChild(elmt);
+
+ // override calculated size if this element doesn't scale with image
+ if(!scales)
+ this.size = Seadragon.Utils.getElementSize(elmt);
+
+ var position = this.position;
+ var size = this.size;
+
+ // adjust position based on placement (default is center)
+ this.adjust(position, size);
+
+ position = position.apply(Math.floor);
+ size = size.apply(Math.ceil);
+
+ style.left = position.x + "px";
+ style.top = position.y + "px";
+ style.position = "absolute";
+
+ if(scales) {
+ style.width = size.x + "px";
+ style.height = size.y + "px";
+ }
+ },
+ update: function(loc, placement) {
+ this.scales = (loc instanceof Sys.Extended.UI.Seadragon.Rect);
+ this.bounds = new Sys.Extended.UI.Seadragon.Rect(loc.x, loc.y, loc.width, loc.height);
+ this.placement = loc instanceof Sys.Extended.UI.Seadragon.Point ?
+ placement : Sys.Extended.UI.Seadragon.OverlayPlacement.TOP_LEFT; // rects are always top-left
+ }
+
+};
+Sys.Extended.UI.Seadragon.Overlay.registerClass('Sys.Extended.UI.Seadragon.Overlay', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.Drawer = function(source, viewport, elmt) {
+ this._container = Seadragon.Utils.getElement(elmt);
+ this._canvas = Seadragon.Utils.makeNeutralElement(useCanvas ? "canvas" : "div");
+ this._context = useCanvas ? this._canvas.getContext("2d") : null;
+ this._viewport = viewport;
+ this._source = source;
+ this.config = this._viewport.config;
+
+ this._imageLoader = new Sys.Extended.UI.Seadragon.ImageLoader(this.config.imageLoaderLimit);
+ this._profiler = new Sys.Extended.UI.Seadragon.Profiler();
+
+ this._minLevel = source.minLevel;
+ this._maxLevel = source.maxLevel;
+ this._tileSize = source.tileSize;
+ this._tileOverlap = source.tileOverlap;
+ this._normHeight = source.dimensions.y / source.dimensions.x;
+
+ this._cacheNumTiles = {}; // 1d dictionary [level] --> Point
+ this._cachePixelRatios = {}; // 1d dictionary [level] --> Point
+ this._tilesMatrix = {}; // 3d dictionary [level][x][y] --> Tile
+ this._tilesLoaded = []; // unordered list of Tiles with loaded images
+ this._coverage = {}; // 3d dictionary [level][x][y] --> Boolean
+
+ this._overlays = []; // unordered list of Overlays added
+ this._lastDrawn = []; // unordered list of Tiles drawn last frame
+ this._lastResetTime = 0;
+ this._midUpdate = false;
+ this._updateAgain = true;
+
+ // Properties
+ this.elmt = this._container;
+
+ // Constructor
+ this._init();
+};
+Sys.Extended.UI.Seadragon.Drawer.prototype = {
+ dispose: function() {
+ },
+ _init: function() {
+ this._canvas.style.width = "100%";
+ this._canvas.style.height = "100%";
+ this._canvas.style.position = "absolute";
+ this._container.style.textAlign = "left"; // explicit left-align
+ this._container.appendChild(this._canvas);
+ },
+ _compareTiles: function(prevBest, tile) {
+ // figure out if this tile is better than the previous best tile...
+ // note that if there is no prevBest, this is automatically better.
+ if(!prevBest)
+ return tile;
+
+ if(tile.visibility > prevBest.visibility)
+ return tile;
+ else if(tile.visibility == prevBest.visibility)
+ if(tile.distance < prevBest.distance)
+ return tile;
+
+ return prevBest;
+ },
+ _getNumTiles: function(level) {
+ if(!this._cacheNumTiles[level])
+ this._cacheNumTiles[level] = this._source.getNumTiles(level);
+
+ return this._cacheNumTiles[level];
+ },
+
+ _getPixelRatio: function(level) {
+ if(!this._cachePixelRatios[level])
+ this._cachePixelRatios[level] = this._source.getPixelRatio(level);
+
+ return this._cachePixelRatios[level];
+ },
+
+ // Helpers -- TILES
+
+ _getTile: function(level, x, y, time, numTilesX, numTilesY) {
+ if(!this._tilesMatrix[level])
+ this._tilesMatrix[level] = {};
+
+ if(!this._tilesMatrix[level][x])
+ this._tilesMatrix[level][x] = {};
+
+ // initialize tile object if first time
+ if(!this._tilesMatrix[level][x][y]) {
+ // where applicable, adjust x and y to support wrapping.
+ var xMod = (numTilesX + (x % numTilesX)) % numTilesX;
+ var yMod = (numTilesY + (y % numTilesY)) % numTilesY;
+ var bounds = this._source.getTileBounds(level, xMod, yMod);
+ var exists = this._source.tileExists(level, xMod, yMod);
+ var url = this._source.getTileUrl(level, xMod, yMod);
+
+ // also adjust bounds to support wrapping.
+ bounds.x += 1.0 * (x - xMod) / numTilesX;
+ bounds.y += this._normHeight * (y - yMod) / numTilesY;
+
+ this._tilesMatrix[level][x][y] = new Sys.Extended.UI.Seadragon.Tile(level, x, y, bounds, exists, url);
+ }
+
+ var tile = this._tilesMatrix[level][x][y];
+
+ // mark tile as touched so we don't reset it too soon
+ tile.lastTouchTime = time;
+
+ return tile;
+ },
+
+ _loadTile: function(tile, time) {
+ tile.loading = this._imageLoader.loadImage(tile.url,
+ Seadragon.Utils.createCallback(null, Function.createDelegate(this, this._onTileLoad), tile, time));
+ },
+
+ _onTileLoad: function(tile, time, image) {
+ tile.loading = false;
+
+ if(this._midUpdate) {
+ Seadragon.Debug.error("Tile load callback in middle of drawing routine.");
+ return;
+ } else if(!image) {
+ Seadragon.Debug.log("Tile " + tile + " failed to load: " + tile.url);
+ tile.exists = false;
+ return;
+ } else if(time < this._lastResetTime) {
+ Seadragon.Debug.log("Ignoring tile " + tile + " loaded before reset: " + tile.url);
+ return;
+ }
+
+ tile.loaded = true;
+ tile.image = image;
+
+ var insertionIndex = this._tilesLoaded.length;
+
+ if(this._tilesLoaded.length >= QUOTA) {
+ var cutoff = Math.ceil(Math.log(this._tileSize) / Math.log(2));
+ // don't delete any single-tile levels. this takes priority.
+
+ var worstTile = null;
+ var worstTileIndex = -1;
+
+ for(var i = this._tilesLoaded.length - 1; i >= 0; i--) {
+ var prevTile = this._tilesLoaded[i];
+
+ if(prevTile.level <= this._cutoff || prevTile.beingDrawn) {
+ continue;
+ } else if(!worstTile) {
+ worstTile = prevTile;
+ worstTileIndex = i;
+ continue;
+ }
+
+ var prevTime = prevTile.lastTouchTime;
+ var worstTime = worstTile.lastTouchTime;
+ var prevLevel = prevTile.level;
+ var worstLevel = worstTile.level;
+
+ if(prevTime < worstTime ||
+ (prevTime == worstTime && prevLevel > worstLevel)) {
+ worstTile = prevTile;
+ worstTileIndex = i;
+ }
+ }
+
+ if(worstTile && worstTileIndex >= 0) {
+ worstTile.unload();
+ insertionIndex = worstTileIndex;
+ // note: we don't want or need to delete the actual Tile
+ // object from tilesMatrix; that's negligible memory.
+ }
+ }
+
+ this._tilesLoaded[insertionIndex] = tile;
+ this._updateAgain = true;
+ },
+
+ _clearTiles: function() {
+ this._tilesMatrix = {};
+ this._tilesLoaded = [];
+ },
+
+ // Helpers -- COVERAGE
+
+ // Coverage scheme: it's required that in the draw routine, coverage for
+ // every tile within the viewport is initially explicitly set to false.
+ // This way, if a given level's coverage has been initialized, and a tile
+ // isn't found, it means it's offscreen and thus provides coverage (since
+ // there's no content needed to be covered). And if every tile that is found
+ // does provide coverage, the entire visible level provides coverage.
+
+ // Returns true if the given tile provides coverage to lower-level tiles of
+ // lower resolution representing the same content. If neither x nor y is
+ // given, returns true if the entire visible level provides coverage.
+ //
+ // Note that out-of-bounds tiles provide coverage in this sense, since
+ // there's no content that they would need to cover. Tiles at non-existent
+ // levels that are within the image bounds, however, do not.
+ _providesCoverage: function(level, x, y) {
+ if(!this._coverage[level])
+ return false;
+
+ if(x === undefined || y === undefined) {
+ // check that every visible tile provides coverage.
+ // update: protecting against properties added to the Object
+ // class's prototype, which can definitely (and does) happen.
+ var rows = this._coverage[level];
+ for(var i in rows)
+ if(rows.hasOwnProperty(i)) {
+ var cols = rows[i];
+ for(var j in cols)
+ if(cols.hasOwnProperty(j) && !cols[j])
+ return false;
+ }
+
+ return true;
+ }
+
+ return (this._coverage[level][x] === undefined ||
+ this._coverage[level][x][y] === undefined ||
+ this._coverage[level][x][y] === true);
+ },
+
+ // Returns true if the given tile is completely covered by higher-level
+ // tiles of higher resolution representing the same content. If neither x
+ // nor y is given, returns true if the entire visible level is covered.
+ _isCovered: function(level, x, y) {
+ if(x === undefined || y === undefined)
+ return this._providesCoverage(level + 1);
+ else
+ return (this._providesCoverage(level + 1, 2 * x, 2 * y) &&
+ this._providesCoverage(level + 1, 2 * x, 2 * y + 1) &&
+ this._providesCoverage(level + 1, 2 * x + 1, 2 * y) &&
+ this._providesCoverage(level + 1, 2 * x + 1, 2 * y + 1));
+ },
+
+ // Sets whether the given tile provides coverage or not.
+ _setCoverage: function(level, x, y, covers) {
+ if(!this._coverage[level]) {
+ Seadragon.Debug.error("Setting coverage for a tile before its " +
+ "level's coverage has been reset: " + level);
+ return;
+ }
+
+ if(!this._coverage[level][x])
+ this._coverage[level][x] = {};
+
+ this._coverage[level][x][y] = covers;
+ },
+
+ // Resets coverage information for the given level. This should be called
+ // after every draw routine. Note that at the beginning of the next draw
+ // routine, coverage for every visible tile should be explicitly set.
+ _resetCoverage: function(level) {
+ this._coverage[level] = {};
+ },
+
+ // Helpers -- SCORING
+
+ _compareTiles: function(prevBest, tile) {
+ // figure out if this tile is better than the previous best tile...
+ // note that if there is no prevBest, this is automatically better.
+ if(!prevBest)
+ return tile;
+
+ if(tile.visibility > prevBest.visibility)
+ return tile;
+ else if(tile.visibility == prevBest.visibility)
+ if(tile.distance < prevBest.distance)
+ return tile;
+
+ return prevBest;
+ },
+
+ // Helpers -- OVERLAYS
+
+ _getOverlayIndex: function(elmt) {
+ for(var i = this._overlays.length - 1; i >= 0; i--)
+ if(this._overlays[i].elmt == elmt)
+ return i;
+
+ return -1;
+ },
+
+ // Helpers -- CORE
+
+ _updateActual: function() {
+ // assume we won't need to update again after this update.
+ // we'll set this if we find a reason to update again.
+ this._updateAgain = false;
+
+ // make local references to variables & functions referenced in
+ // loops in order to improve perf
+ var _canvas = this._canvas,
+ _context = this._context,
+ _container = this._container,
+ _useCanvas = useCanvas,
+ _lastDrawn = this._lastDrawn;
+
+ // the tiles that were drawn last frame, but won't be this frame,
+ // can be cleared from the cache, so they should be marked as such.
+ while(_lastDrawn.length > 0) {
+ var tile = _lastDrawn.pop();
+ tile.beingDrawn = false;
+ }
+
+ // we need the size of the viewport (in pixels) in multiple places
+ var viewportSize = this._viewport.getContainerSize(),
+ viewportWidth = viewportSize.x,
+ viewportHeight = viewportSize.y;
+
+ // clear canvas, whether in mode or HTML mode.
+ // this is important as scene may be empty this frame.
+ _canvas.innerHTML = "";
+ if(_useCanvas) {
+ _canvas.width = viewportWidth;
+ _canvas.height = viewportHeight;
+ _context.clearRect(0, 0, viewportWidth, viewportHeight);
+ // this last line shouldn't be needed. setting the width and
+ // height should clear , but Firefox doesn't always.
+ }
+
+ // if viewport is off image entirely, don't bother drawing.
+ // UPDATE: logic modified to support horizontal/vertical wrapping.
+ var viewportBounds = this._viewport.getBounds(true),
+ viewportTL = viewportBounds.getTopLeft(),
+ viewportBR = viewportBounds.getBottomRight();
+ if(!this.config.wrapHorizontal && (viewportBR.x < 0 || viewportTL.x > 1))
+ // we're not wrapping horizontally, and viewport is off in x
+ return;
+ else if(!this.config.wrapVertical && (viewportBR.y < 0 || viewportTL.y > this._normHeight))
+ // we're not wrapping vertically, and viewport is off in y
+ return;
+
+ // the below section is commented out because it's more relevant to
+ // collections, where you don't want 10 items to all load their xml
+ // at the same time when 9 of them won't be in the viewport soon.
+
+ // same for Math functions
+ var _abs = Math.abs,
+ _ceil = Math.ceil,
+ _floor = Math.floor,
+ _log = Math.log,
+ _max = Math.max,
+ _min = Math.min;
+
+ var alwaysBlend = this.config.alwaysBlend,
+ blendTimeMillis = 1000 * this.config.blendTime,
+ immediateRender = this.config.immediateRender,
+ minDimension = this.config.minZoomDimension, // for backwards compatibility
+ minImageRatio = this.config.minImageRatio,
+ wrapHorizontal = this.config.wrapHorizontal,
+ wrapVertical = this.config.wrapVertical;
+
+ // restrain bounds of viewport relative to image.
+ // UPDATE: logic modified to support horizontal/vertical wrapping.
+ if(!wrapHorizontal) {
+ viewportTL.x = _max(viewportTL.x, 0);
+ viewportBR.x = _min(viewportBR.x, 1);
+ }
+ if(!wrapVertical) {
+ viewportTL.y = _max(viewportTL.y, 0);
+ viewportBR.y = _min(viewportBR.y, this._normHeight);
+ }
+
+ var best = null,
+ haveDrawn = false,
+ currentTime = new Date().getTime();
+
+ // calculate values for scoring -- this is based on TARGET values
+ var viewportCenter = this._viewport.pixelFromPoint(this._viewport.getCenter()),
+ zeroRatioT = this._viewport.deltaPixelsFromPoints(this._source.getPixelRatio(0), false).x,
+ optimalPixelRatio = immediateRender ? 1 : zeroRatioT;
+
+ // adjust levels to iterate over -- this is based on CURRENT values
+ // TODO change this logic to use minImageRatio, but for backwards
+ // compatibility, use minDimension if it's been explicitly set.
+ // TEMP for now, original minDimension logic with default 64.
+ minDimension = minDimension || 64;
+ var lowestLevel = _max(this._minLevel, _floor(_log(minDimension) / _log(2))),
+ zeroRatioC = this._viewport.deltaPixelsFromPoints(this._source.getPixelRatio(0), true).x,
+ highestLevel = _min(this._maxLevel, _floor(_log(zeroRatioC / MIN_PIXEL_RATIO) / _log(2)));
+
+ // with very small images, this edge case can occur...
+ lowestLevel = _min(lowestLevel, highestLevel);
+
+ for(var level = highestLevel; level >= lowestLevel; level--) {
+ var drawLevel = false;
+ var renderPixelRatioC = this._viewport.deltaPixelsFromPoints(this._source.getPixelRatio(level), true).x; // note the .x!
+
+ // if we haven't drawn yet, only draw level if tiles are big enough
+ if((!haveDrawn && renderPixelRatioC >= MIN_PIXEL_RATIO) || level == lowestLevel) {
+ drawLevel = true;
+ haveDrawn = true;
+ } else if(!haveDrawn) {
+ continue;
+ }
+
+ this._resetCoverage(level);
+
+ // calculate scores applicable to all tiles on this level --
+ // note that we're basing visibility on the TARGET pixel ratio
+ var levelOpacity = _min(1, (renderPixelRatioC - 0.5) / 0.5),
+ renderPixelRatioT = this._viewport.deltaPixelsFromPoints(this._source.getPixelRatio(level), false).x,
+ levelVisibility = optimalPixelRatio / _abs(optimalPixelRatio - renderPixelRatioT);
+
+ // only iterate over visible tiles
+ var tileTL = this._source.getTileAtPoint(level, viewportTL),
+ tileBR = this._source.getTileAtPoint(level, viewportBR),
+ numTiles = this._getNumTiles(level),
+ numTilesX = numTiles.x,
+ numTilesY = numTiles.y;
+
+ if(!wrapHorizontal)
+ tileBR.x = _min(tileBR.x, numTilesX - 1);
+ if(!wrapVertical)
+ tileBR.y = _min(tileBR.y, numTilesY - 1);
+
+ for(var x = tileTL.x; x <= tileBR.x; x++) {
+ for(var y = tileTL.y; y <= tileBR.y; y++) {
+ var tile = this._getTile(level, x, y, currentTime, numTilesX, numTilesY);
+ var drawTile = drawLevel;
+
+ // assume this tile doesn't cover initially
+ this._setCoverage(level, x, y, false);
+
+ if(!tile.exists)
+ // not part of sparse image, or failed to load
+ continue;
+
+ // if we've drawn a higher-resolution level and we're not
+ // going to draw this level, then say this tile does cover
+ // if it's covered by higher-resolution tiles. if we're not
+ // covered, then we should draw this tile regardless.
+ if(haveDrawn && !drawTile)
+ if(this._isCovered(level, x, y))
+ this._setCoverage(level, x, y, true);
+ else
+ drawTile = true;
+
+ if(!drawTile)
+ continue;
+
+ // calculate tile's position and size in pixels
+ var boundsTL = tile.bounds.getTopLeft(),
+ boundsSize = tile.bounds.getSize(),
+ positionC = this._viewport.pixelFromPoint(boundsTL, true),
+ sizeC = this._viewport.deltaPixelsFromPoints(boundsSize, true);
+
+ // if there is no tile overlap, we need to oversize the
+ // tiles by 1px to prevent seams at imperfect zooms.
+ // fortunately, this is not an issue with regular dzi's
+ // created from Deep Zoom Composer, which uses overlap.
+ if(!this._tileOverlap)
+ sizeC = sizeC.plus(new Sys.Extended.UI.Seadragon.Point(1, 1));
+
+ // calculate distance from center of viewport -- note
+ // that this is based on tile's TARGET position
+ var positionT = this._viewport.pixelFromPoint(boundsTL, false),
+ sizeT = this._viewport.deltaPixelsFromPoints(boundsSize, false),
+ tileCenter = positionT.plus(sizeT.divide(2)),
+ tileDistance = viewportCenter.distanceTo(tileCenter);
+
+ // update tile's scores and values
+ tile.position = positionC;
+ tile.size = sizeC;
+ tile.distance = tileDistance;
+ tile.visibility = levelVisibility;
+
+ if(tile.loaded) {
+ if(!tile.blendStart)
+ // image was just added, blend it
+ tile.blendStart = currentTime;
+
+ var deltaTime = currentTime - tile.blendStart;
+ var opacity = _min(1, deltaTime / blendTimeMillis);
+
+ if(alwaysBlend)
+ opacity *= levelOpacity;
+
+ tile.opacity = opacity;
+
+ // queue tile for drawing in reverse order
+ _lastDrawn.push(tile);
+
+ // if fully blended in, this tile now provides coverage,
+ // otherwise we need to update again to keep blending
+ if(opacity == 1)
+ this._setCoverage(level, x, y, true);
+ else if(deltaTime < blendTimeMillis)
+ updateAgain = true;
+ } else if(tile.Loading) {
+ // nothing to see here, move on
+ } else {
+ // means tile isn't loaded yet, so score it
+ best = this._compareTiles(best, tile);
+ }
+ }
+ }
+
+ // we may not need to draw any more lower-res levels
+ if(this._providesCoverage(level))
+ break;
+ }
+
+ // now draw the tiles, but in reverse order since we want higher-res
+ // tiles to be drawn on top of lower-res ones. also mark each tile
+ // as being drawn so it won't get cleared from the cache.
+ for(var i = _lastDrawn.length - 1; i >= 0; i--) {
+ var tile = _lastDrawn[i];
+
+ if(_useCanvas)
+ tile.drawCanvas(_context);
+ else
+ tile.drawHTML(_canvas);
+
+ tile.beingDrawn = true;
+ }
+
+ // draw the overlays -- TODO optimize based on viewport like tiles,
+ // but this is tricky for non-scaling overlays like pins...
+ var numOverlays = this._overlays.length;
+ for(var i = 0; i < numOverlays; i++) {
+ var overlay = this._overlays[i],
+ bounds = overlay.bounds;
+
+ overlay.position = this._viewport.pixelFromPoint(bounds.getTopLeft(), true);
+ overlay.size = this._viewport.deltaPixelsFromPoints(bounds.getSize(), true);
+ overlay.drawHTML(_container);
+ }
+
+ // load next tile if there is one to load
+ if(best) {
+ this._loadTile(best, currentTime);
+ this._updateAgain = true; // because we haven't finished drawing, so
+ // we should be re-evaluating and re-scoring
+ }
+ },
+
+ // Methods -- OVERLAYS
+
+ addOverlay: function(elmt, loc, placement) {
+ var elmt = Seadragon.Utils.getElement(elmt);
+
+ if(this._getOverlayIndex(elmt) >= 0)
+ return; // they're trying to add a duplicate overlay
+
+ this._overlays.push(new Sys.Extended.UI.Seadragon.Overlay(elmt, loc, placement));
+ this._updateAgain = true;
+ },
+
+ updateOverlay: function(elmt, loc, placement) {
+ var elmt = Seadragon.Utils.getElement(elmt),
+ i = this._getOverlayIndex(elmt);
+
+ if(i >= 0) {
+ this._overlays[i].update(loc, placement);
+ this._updateAgain = true;
+ }
+ },
+
+ removeOverlay: function(elmt) {
+ var elmt = Seadragon.Utils.getElement(elmt),
+ i = this._getOverlayIndex(elmt);
+
+ if(i >= 0) {
+ this._overlays[i].destroy();
+ this._overlays.splice(i, 1);
+ this._updateAgain = true;
+ }
+ },
+
+ clearOverlays: function() {
+ while(this._overlays.length > 0) {
+ this._overlays.pop().destroy();
+ this._updateAgain = true;
+ }
+ },
+
+ // Methods -- CORE
+
+ needsUpdate: function() {
+ return this._updateAgain;
+ },
+
+ numTilesLoaded: function() {
+ return this._tilesLoaded.length;
+ },
+
+ reset: function() {
+ this._clearTiles();
+ this._lastResetTime = new Date().getTime();
+ this._updateAgain = true;
+ },
+
+ update: function() {
+ this._profiler.beginUpdate();
+ this._midUpdate = true;
+ this._updateActual();
+ this._midUpdate = false;
+ this._profiler.endUpdate();
+ },
+
+ idle: function() {
+ // TODO idling function
+ }
+};
+Sys.Extended.UI.Seadragon.Drawer.registerClass('Sys.Extended.UI.Seadragon.Drawer', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.TileSource = function(width, height, tileSize, tileOverlap, minLevel, maxLevel) {
+ this.aspectRatio = width / height;
+ this.dimensions = new Sys.Extended.UI.Seadragon.Point(width, height);
+ this.minLevel = minLevel ? minLevel : 0;
+ this.maxLevel = maxLevel ? maxLevel : Math.ceil(Math.log(Math.max(width, height)) / Math.log(2));
+ this.tileSize = tileSize ? tileSize : 0;
+ this.tileOverlap = tileOverlap ? tileOverlap : 0;
+};
+Sys.Extended.UI.Seadragon.TileSource.prototype = {
+ getLevelScale: function(level) {
+ // equivalent to Math.pow(0.5, numLevels - level);
+ return 1 / (1 << (this.maxLevel - level));
+ },
+
+ getNumTiles: function(level) {
+ var scale = this.getLevelScale(level),
+ x = Math.ceil(scale * this.dimensions.x / this.tileSize),
+ y = Math.ceil(scale * this.dimensions.y / this.tileSize);
+
+ return new Sys.Extended.UI.Seadragon.Point(x, y);
+ },
+
+ getPixelRatio: function(level) {
+ var imageSizeScaled = this.dimensions.times(this.getLevelScale(level)),
+ rx = 1.0 / imageSizeScaled.x,
+ ry = 1.0 / imageSizeScaled.y;
+
+ return new Sys.Extended.UI.Seadragon.Point(rx, ry);
+ },
+
+ getTileAtPoint: function(level, point) {
+ var pixel = point.times(this.dimensions.x).times(this.getLevelScale(level));
+
+ var tx = Math.floor(pixel.x / this.tileSize),
+ ty = Math.floor(pixel.y / this.tileSize);
+
+ return new Sys.Extended.UI.Seadragon.Point(tx, ty);
+ },
+
+ getTileBounds: function(level, x, y) {
+ // work in scaled pixels for this level
+ var dimensionsScaled = this.dimensions.times(this.getLevelScale(level));
+
+ // find position, adjust for no overlap data on top and left edges
+ var px = (x === 0) ? 0 : this.tileSize * x - this.tileOverlap,
+ py = (y === 0) ? 0 : this.tileSize * y - this.tileOverlap;
+
+ // find size, adjust for no overlap data on top and left edges
+ var sx = this.tileSize + (x === 0 ? 1 : 2) * this.tileOverlap,
+ sy = this.tileSize + (y === 0 ? 1 : 2) * this.tileOverlap;
+
+ // adjust size for single-tile levels where the image size is smaller
+ // than the regular tile size, and for tiles on the bottom and right
+ // edges that would exceed the image bounds
+ sx = Math.min(sx, dimensionsScaled.x - px);
+ sy = Math.min(sy, dimensionsScaled.y - py);
+
+ // finally, normalize...
+ // note that isotropic coordinates ==> only dividing by scaled x!
+ var scale = 1.0 / dimensionsScaled.x;
+
+ return new Sys.Extended.UI.Seadragon.Rect(px * scale, py * scale, sx * scale, sy * scale);
+ },
+
+ getTileUrl: function(level, x, y) {
+ throw new Error("Method not implemented.");
+ },
+
+ tileExists: function(level, x, y) {
+ var numTiles = this.getNumTiles(level);
+ return level >= this.minLevel && level <= this.maxLevel &&
+ x >= 0 && y >= 0 && x < numTiles.x && y < numTiles.y;
+ }
+};
+Sys.Extended.UI.Seadragon.TileSource.registerClass('Sys.Extended.UI.Seadragon.TileSource', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.DziError = function(message) {
+ Sys.Extended.UI.Seadragon.DziError.initializeBase(this, [message]);
+ this.message = message;
+};
+Sys.Extended.UI.Seadragon.DziError.registerClass('Sys.Extended.UI.Seadragon.DziError', Error);
+
+Sys.Extended.UI.Seadragon.DziTileSource = function(width, height, tileSize, tileOverlap, tilesUrl, fileFormat, displayRects) {
+ Sys.Extended.UI.Seadragon.DziTileSource.initializeBase(this, [width, height, tileSize, tileOverlap, null, null]);
+ this._levelRects = {};
+ this.tilesUrl = tilesUrl;
+
+ this.fileFormat = fileFormat;
+ this.displayRects = displayRects;
+ this._init();
+};
+Sys.Extended.UI.Seadragon.DziTileSource.prototype = {
+ _init: function() {
+ if(!this.displayRects)
+ return;
+
+ for(var i = this.displayRects.length - 1; i >= 0; i--) {
+ var rect = this.displayRects[i];
+ for(var level = rect.minLevel; level <= rect.maxLevel; level++) {
+ if(!this._levelRects[level])
+ this._levelRects[level] = [];
+ this._levelRects[level].push(rect);
+ }
+ }
+ },
+ getTileUrl: function(level, x, y) {
+ // using array join because it's faster than string concatenation
+ return [this.tilesUrl, level, '/', x, '_', y, '.', this.fileFormat].join('');
+ },
+
+ tileExists: function(level, x, y) {
+ var rects = this._levelRects[level];
+
+ if(!rects || !rects.length)
+ return true;
+
+ for(var i = rects.length - 1; i >= 0; i--) {
+ var rect = rects[i];
+
+ // check level
+ if(level < rect.minLevel || level > rect.maxLevel)
+ continue;
+
+ // transform rectangle coordinates to this level
+ var scale = this.getLevelScale(level),
+ xMin = rect.x * scale,
+ yMin = rect.y * scale,
+ xMax = xMin + rect.width * scale,
+ yMax = yMin + rect.height * scale;
+
+ // convert to rows and columns -- note that we're ignoring tile
+ // overlap, but it's a reasonable approximation. it errs on the side
+ // of false positives, which is much better than false negatives.
+ xMin = Math.floor(xMin / this.tileSize);
+ yMin = Math.floor(yMin / this.tileSize);
+ xMax = Math.ceil(xMax / this.tileSize);
+ yMax = Math.ceil(yMax / this.tileSize);
+
+ if(xMin <= x && x < xMax && yMin <= y && y < yMax)
+ return true;
+ }
+
+ return false;
+ }
+};
+Sys.Extended.UI.Seadragon.DziTileSource.registerClass('Sys.Extended.UI.Seadragon.DziTileSource', Sys.Extended.UI.Seadragon.TileSource);
+Sys.Extended.UI.Seadragon._DziTileSourceHelper = function() {
+
+};
+Sys.Extended.UI.Seadragon._DziTileSourceHelper.prototype = {
+ createFromXml: function(xmlUrl, xmlString, callback) {
+ var async = typeof (callback) == "function",
+ error = null;
+
+ if(!xmlUrl) {
+ this.error = Seadragon.Strings.getString("Errors.Empty");
+ if(async) {
+ window.setTimeout(function() {
+ callback(null, error);
+ }, 1);
+ return null;
+ }
+ throw new Sys.Extended.UI.Seadragon.DziError(error);
+ }
+
+ // extract tile url
+ var urlParts = xmlUrl.split('/'),
+ filename = urlParts[urlParts.length - 1],
+ lastDot = filename.lastIndexOf('.');
+
+ if(lastDot > -1)
+ urlParts[urlParts.length - 1] = filename.slice(0, lastDot);
+
+ var tilesUrl = urlParts.join('/') + "_files/";
+ function finish(func, obj) {
+ try {
+ return func(obj, tilesUrl);
+ } catch(e) {
+ if(async) {
+ error = this.getError(e).message;
+ return null;
+ } else {
+ throw this.getError(e);
+ }
+ }
+ }
+
+ if(async) {
+ if(xmlString) {
+ var handler = Function.createDelegate(this, this.processResponse);
+ window.setTimeout(function() {
+ var source = finish(handler, Seadragon.Utils.parseXml(xmlString));
+ callback(source, error); // call after finish sets error
+ }, 1);
+ } else {
+ var handler = Function.createDelegate(this, this.processResponse);
+ Seadragon.Utils.makeAjaxRequest(xmlUrl, function(xhr) {
+ var source = finish(handler, xhr);
+ callback(source, error); // call after finish sets error
+ });
+ }
+
+ return null;
+ }
+
+ // synchronous version
+ if(xmlString)
+ return finish(Function.createDelegate(this, this.processXml), Seadragon.Utils.parseXml(xmlString));
+ else
+ return finish(Function.createDelegate(this, this.processResponse), Seadragon.Utils.makeAjaxRequest(xmlUrl));
+ },
+ processResponse: function(xhr, tilesUrl) {
+ if(!xhr) {
+ throw new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.Security"));
+ } else if(xhr.status !== 200 && xhr.status !== 0) {
+ // chrome has bug where it sends "OK" for 404
+ var status = xhr.status;
+ var statusText = (status == 404) ? "Not Found" : xhr.statusText;
+ throw new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.Status", status, statusText));
+ }
+
+ var doc = null;
+
+ if(xhr.responseXML && xhr.responseXML.documentElement)
+ doc = xhr.responseXML;
+ else if(xhr.responseText)
+ doc = Seadragon.Utils.parseXml(xhr.responseText);
+
+ return this.processXml(doc, tilesUrl);
+ },
+
+ processXml: function(xmlDoc, tilesUrl) {
+ if(!xmlDoc || !xmlDoc.documentElement)
+ throw new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.Xml"));
+
+ var root = xmlDoc.documentElement,
+ rootName = root.tagName;
+
+ if(rootName == "Image")
+ try {
+ return this.processDzi(root, tilesUrl);
+ } catch(e) {
+ var defMsg = Seadragon.Strings.getString("Errors.Dzi");
+ throw (e instanceof Sys.Extended.UI.Seadragon.DziError) ? e : new Sys.Extended.UI.Seadragon.DziError(defMsg);
+ }
+ else if(rootName == "Collection")
+ throw new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.Dzc"));
+ else if(rootName == "Error")
+ return this.processError(root);
+
+ throw new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.Dzi"));
+ },
+
+ processDzi: function(imageNode, tilesUrl) {
+ var fileFormat = imageNode.getAttribute("Format");
+
+ if(!Seadragon.Utils.imageFormatSupported(fileFormat))
+ throw new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.ImageFormat", fileFormat.toUpperCase()));
+
+ var sizeNode = imageNode.getElementsByTagName("Size")[0],
+ dispRectNodes = imageNode.getElementsByTagName("DisplayRect");
+
+ var width = parseInt(sizeNode.getAttribute("Width"), 10),
+ height = parseInt(sizeNode.getAttribute("Height"), 10),
+ tileSize = parseInt(imageNode.getAttribute("TileSize")),
+ tileOverlap = parseInt(imageNode.getAttribute("Overlap")),
+ dispRects = [];
+
+ for(var i = 0; i < dispRectNodes.length; i++) {
+ var dispRectNode = dispRectNodes[i],
+ rectNode = dispRectNode.getElementsByTagName("Rect")[0];
+
+ dispRects.push(new Seadragon.DisplayRect(
+ parseInt(rectNode.getAttribute("X"), 10),
+ parseInt(rectNode.getAttribute("Y"), 10),
+ parseInt(rectNode.getAttribute("Width"), 10),
+ parseInt(rectNode.getAttribute("Height"), 10),
+ 0, // ignore MinLevel attribute, bug in Deep Zoom Composer
+ parseInt(dispRectNode.getAttribute("MaxLevel"), 10)
+ ));
+ }
+ return new Sys.Extended.UI.Seadragon.DziTileSource(width, height, tileSize, tileOverlap,
+ tilesUrl, fileFormat, dispRects);
+ },
+
+ processError: function(errorNode) {
+ var messageNode = errorNode.getElementsByTagName("Message")[0],
+ message = messageNode.firstChild.nodeValue;
+
+ throw new Sys.Extended.UI.Seadragon.DziError(message);
+ },
+ getError: function(e) {
+ if(!(e instanceof DziError)) {
+ // shouldn't happen, but if it does, fail fast or at least log it
+ Seadragon.Debug.error(e.name + " while creating DZI from XML: " + e.message);
+ e = new Sys.Extended.UI.Seadragon.DziError(Seadragon.Strings.getString("Errors.Unknown"));
+ }
+
+ }
+};
+//Static objects
+Sys.Extended.UI.Seadragon.DziTileSourceHelper = new Sys.Extended.UI.Seadragon._DziTileSourceHelper();
+
+Sys.Extended.UI.Seadragon.Rect = function(x, y, width, height) {
+ // Properties
+ this.x = typeof (x) == "number" ? x : 0;
+ this.y = typeof (y) == "number" ? y : 0;
+ this.width = typeof (width) == "number" ? width : 0;
+ this.height = typeof (height) == "number" ? height : 0;
+};
+Sys.Extended.UI.Seadragon.Rect.prototype = {
+ getAspectRatio: function() {
+ return this.width / this.height;
+ },
+
+ getTopLeft: function() {
+ return new Sys.Extended.UI.Seadragon.Point(this.x, this.y);
+ },
+
+ getBottomRight: function() {
+ return new Sys.Extended.UI.Seadragon.Point(this.x + this.width, this.y + this.height);
+ },
+
+ getCenter: function() {
+ return new Sys.Extended.UI.Seadragon.Point(this.x + this.width / 2.0, this.y + this.height / 2.0);
+ },
+
+ getSize: function() {
+ return new Sys.Extended.UI.Seadragon.Point(this.width, this.height);
+ },
+
+ equals: function(other) {
+ return (other instanceof Seadragon.Rect) &&
+ (this.x === other.x) && (this.y === other.y) &&
+ (this.width === other.width) && (this.height === other.height);
+ },
+
+ toString: function() {
+ return "[" + this.x + "," + this.y + "," + this.width + "x" + this.height + "]";
+ }
+};
+Sys.Extended.UI.Seadragon.Rect.registerClass('Sys.Extended.UI.Seadragon.Rect', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.Job = function(src, callback) {
+ this._image = null;
+ this._timeout = null;
+ this._src = src;
+ this._callback = callback;
+ this.TIMEOUT = 5000;
+};
+Sys.Extended.UI.Seadragon.Job.prototype = {
+ _finish: function(success) {
+ this._image.onload = null;
+ this._image.onabort = null;
+ this._image.onerror = null;
+
+ if(this._timeout)
+ window.clearTimeout(this._timeout);
+
+ // call on a timeout to ensure asynchronous behavior
+ var image = this._image,
+ callback = this._callback;
+
+ window.setTimeout(function() {
+ callback(this._src, success ? image : null);
+ }, 1);
+ },
+ _onloadHandler: function() {
+ this._finish(true);
+ },
+ _onerrorHandler: function() {
+ this._finish(false);
+ },
+ start: function() {
+ this._image = new Image();
+ this._image.onload = Function.createDelegate(this, this._onloadHandler);
+ this._image.onabort = Function.createDelegate(this, this._onerrorHandler);
+ this._image.onerror = Function.createDelegate(this, this._onerrorHandler);
+
+ // consider it a failure if the image times out.
+ this._timeout = window.setTimeout(Function.createDelegate(this, this._onerrorHandler), this.TIMEOUT);
+
+ this._image.src = this._src;
+ }
+};
+Sys.Extended.UI.Seadragon.Job.registerClass('Sys.Extended.UI.Seadragon.Job', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.ImageLoader = function(imageLoaderLimit) {
+ this._downloading = 0;
+ this.imageLoaderLimit = imageLoaderLimit;
+};
+Sys.Extended.UI.Seadragon.ImageLoader.prototype = {
+ _onComplete: function(callback, src, image) {
+ this._downloading--;
+ if(typeof (callback) == "function")
+ try {
+ callback(image);
+ } catch(e) {
+ Seadragon.Debug.error(e.name + " while executing " + src + " callback: " + e.message, e);
+ }
+ },
+ loadImage: function(src, callback) {
+ if(this._downloading >= this.imageLoaderLimit)
+ return false;
+
+ var func = Seadragon.Utils.createCallback(null, Function.createDelegate(this, this._onComplete), callback),
+ job = new Sys.Extended.UI.Seadragon.Job(src, func);
+
+ this._downloading++;
+ job.start();
+
+ return true;
+ }
+};
+Sys.Extended.UI.Seadragon.ImageLoader.registerClass('Sys.Extended.UI.Seadragon.ImageLoader', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.Profiler = function() {
+ this._midUpdate = false;
+ this._numUpdates = 0;
+
+ this._lastBeginTime = null;
+ this._lastEndTime = null;
+
+ this._minUpdateTime = Infinity;
+ this._avgUpdateTime = 0;
+ this._maxUpdateTime = 0;
+
+ this._minIdleTime = Infinity;
+ this._avgIdleTime = 0;
+ this._maxIdleTime = 0;
+};
+Sys.Extended.UI.Seadragon.Profiler.prototype = {
+ // Methods -- UPDATE TIME ACCESSORS
+
+ getAvgUpdateTime: function() {
+ return this._avgUpdateTime;
+ },
+
+ getMinUpdateTime: function() {
+ return this._minUpdateTime;
+ },
+
+ getMaxUpdateTime: function() {
+ return this._maxUpdateTime;
+ },
+
+ // Methods -- IDLING TIME ACCESSORS
+
+ getAvgIdleTime: function() {
+ return this._avgIdleTime;
+ },
+
+ getMinIdleTime: function() {
+ return this._minIdleTime;
+ },
+
+ getMaxIdleTime: function() {
+ return this._maxIdleTime;
+ },
+
+ // Methods -- GENERAL ACCESSORS
+
+ isMidUpdate: function() {
+ return this._midUpdate;
+ },
+
+ getNumUpdates: function() {
+ return this._numUpdates;
+ },
+
+ // Methods -- MODIFIERS
+
+ beginUpdate: function() {
+ if(this._midUpdate)
+ this.endUpdate();
+
+ this._midUpdate = true;
+ this._lastBeginTime = new Date().getTime();
+
+ if(this._numUpdates < 1)
+ return; // this is the first update
+
+ var time = this._lastBeginTime - this._lastEndTime;
+
+ this._avgIdleTime = (this._avgIdleTime * (this._numUpdates - 1) + time) / this._numUpdates;
+
+ if(time < this._minIdleTime)
+ this._minIdleTime = time;
+ if(time > this._maxIdleTime)
+ this._maxIdleTime = time;
+ },
+
+ endUpdate: function() {
+ if(!this._midUpdate)
+ return;
+
+ this._lastEndTime = new Date().getTime();
+ this._midUpdate = false;
+
+ var time = this._lastEndTime - this._lastBeginTime;
+
+ this._numUpdates++;
+ this._avgUpdateTime = (this._avgUpdateTime * (this._numUpdates - 1) + time) / this._numUpdates;
+
+ if(time < this._minUpdateTime)
+ this._minUpdateTime = time;
+ if(time > this._maxUpdateTime)
+ this._maxUpdateTime = time;
+ },
+
+ clearProfile: function() {
+ this._midUpdate = false;
+ this._numUpdates = 0;
+
+ this._lastBeginTime = null;
+ this._lastEndTime = null;
+
+ this._minUpdateTime = Infinity;
+ this._avgUpdateTime = 0;
+ this._maxUpdateTime = 0;
+
+ this._minIdleTime = Infinity;
+ this._avgIdleTime = 0;
+ this._maxIdleTime = 0;
+ }
+};
+Sys.Extended.UI.Seadragon.Profiler.registerClass('Sys.Extended.UI.Seadragon.Profiler', null, Sys.IDisposable);
+
+Seadragon.Spring = Sys.Extended.UI.Seadragon.Spring = function(initialValue, config) {
+ this._currentValue = typeof (initialValue) == "number" ? initialValue : 0;
+ this._startValue = this._currentValue;
+ this._targetValue = this._currentValue;
+ this.config = config;
+
+ this._currentTime = new Date().getTime(); // always work in milliseconds
+ this._startTime = this._currentTime;
+ this._targetTime = this._currentTime;
+};
+Sys.Extended.UI.Seadragon.Spring.prototype = {
+ _transform: function(x) {
+ var s = this.config.springStiffness;
+ return (1.0 - Math.exp(-x * s)) / (1.0 - Math.exp(-s));
+ },
+ getCurrent: function() {
+ return this._currentValue;
+ },
+
+ getTarget: function() {
+ return this._targetValue;
+ },
+
+ resetTo: function(target) {
+ this._targetValue = target;
+ this._targetTime = this._currentTime;
+ this._startValue = this._targetValue;
+ this._startTime = this._targetTime;
+ },
+
+ springTo: function(target) {
+ this._startValue = this._currentValue;
+ this._startTime = this._currentTime;
+ this._targetValue = target;
+ this._targetTime = this._startTime + 1000 * this.config.animationTime;
+ },
+
+ shiftBy: function(delta) {
+ this._startValue += delta;
+ this._targetValue += delta;
+ },
+
+ update: function() {
+ this._currentTime = new Date().getTime();
+ this._currentValue = (this._currentTime >= this._targetTime) ? this._targetValue :
+ this._startValue + (this._targetValue - this._startValue) *
+ this._transform((this._currentTime - this._startTime) / (this._targetTime - this._startTime));
+ }
+};
+Sys.Extended.UI.Seadragon.Spring.registerClass('Sys.Extended.UI.Seadragon.Spring', null, Sys.IDisposable);
+
+Sys.Extended.UI.Seadragon.Viewport = function(containerSize, contentSize, config) {
+ this.zoomPoint = null;
+ this.config = config;
+ this._containerSize = containerSize;
+ this._contentSize = contentSize;
+ this._contentAspect = contentSize.x / contentSize.y;
+ this._contentHeight = contentSize.y / contentSize.x;
+ this._centerSpringX = new Seadragon.Spring(0, this.config);
+ this._centerSpringY = new Seadragon.Spring(0, this.config);
+ this._zoomSpring = new Seadragon.Spring(1, this.config);
+ this._homeBounds = new Sys.Extended.UI.Seadragon.Rect(0, 0, 1, this._contentHeight);
+ this.goHome(true);
+ this.update();
+};
+Sys.Extended.UI.Seadragon.Viewport.prototype = {
+ _getHomeZoom: function() {
+ var aspectFactor = this._contentAspect / this.getAspectRatio();
+ // if content is wider, we'll fit width, otherwise height
+ return (aspectFactor >= 1) ? 1 : aspectFactor;
+ },
+
+ _getMinZoom: function() {
+ var homeZoom = this._getHomeZoom();
+
+ // for backwards compatibility, respect minZoomDimension if present
+ if(this.config.minZoomDimension)
+ var zoom = (this._contentSize.x <= this._contentSize.y) ?
+ this.config.minZoomDimension / this._containerSize.x :
+ this.config.minZoomDimension / (this._containerSize.x * this._contentHeight);
+ else
+ var zoom = this.config.minZoomImageRatio * homeZoom;
+
+ return Math.min(zoom, homeZoom);
+ },
+
+ _getMaxZoom: function() {
+ var zoom = this._contentSize.x * this.config.maxZoomPixelRatio / this._containerSize.x;
+ return Math.max(zoom, this._getHomeZoom());
+ },
+
+ ///
+ /// Returns viewport aspect ratio
+ ///
+ /// Aspect ratio
+ ///
+ /// Returns viewport container size
+ ///
+ /// Container size
+ ///
+ /// Returns viewport bounds
+ ///
+ /// Viewport bounds
+ ///
+ /// Returns viewport center point
+ ///
+ /// Viewport center point
+ ///
+ /// Returns viewport current zoom level
+ ///
+ /// Viewport current zoom level
+ ///
+ /// Fires when a slide changes
+ ///
+ ///
+ /// Fires when a slide begins to change
+ ///
+ ///
+ /// User/page specific context provided to an optional overload of the web
+ /// method described by ServiceMethod/ServicePath
+ ///
+ ///
+ /// If the context key is used, it should have the same signature with an
+ /// additional parameter named contextKey of the string type
+ ///
+ /// get_contextKey
+ /// set_contextKey
+ ///
+ /// Whether or not the ContextKey property should be used
+ ///
+ ///
+ /// This will be automatically enabled if the ContextKey property is ever set
+ /// (on either the client or the server). If the context key is used, it should have
+ /// the same signature with an additional parameter named contextKey of the string type
+ ///
+ /// get_useContextKey
+ /// set_useContextKey
+ ///
+ /// Width of the image container to animate slides smoothly from left to right or right to left
+ ///
+ /// get_imageWidth
+ /// set_imageWidth
+ ///
+ /// Height of the image container to animate slides smoothly from up to down or down to up
+ ///
+ /// get_imageHeight
+ /// set_imageHeight
+ ///
+ /// Gets handles to various slideshow controls if specified
+ ///
+ ///
+ /// Maintains various button states
+ ///
+ ///
+ /// Maintains the play button state to reflect whether the slideshow is in play mode
+ ///
+ ///
+ /// Maintains a slideshow current image
+ ///
+ ///
+ /// Updates a slideshow current image
+ ///
+ ///
+ /// Sets a slideshow image
+ ///
+ ///
+ /// ID of Label describing the current picture
+ ///
+ /// get_imageDescriptionLabelID
+ /// set_imageDescriptionLabelID
+ ///
+ /// ID of Label displaying the current picture's title
+ ///
+ /// get_imageTitleLabelID
+ /// set_imageTitleLabelID
+ ///
+ /// ID of the button that will allow you to see the next picture
+ ///
+ /// get_nextButtonID
+ /// set_nextButtonID
+ ///
+ /// ID of the button that will allow you to play/stop the slideshow
+ ///
+ /// get_playButtonID
+ /// set_playButtonID
+ ///
+ /// The text to be shown in the play button to play the slideshow
+ ///
+ /// get_playButtonText
+ /// set_playButtonText
+ ///
+ /// The text to be shown in the play button to stop the slideshow
+ ///
+ /// get_stopButtonText
+ /// set_stopButtonText
+ ///
+ /// An interval in milliseconds between slide transitions in play mode
+ ///
+ /// get_playInterval
+ /// set_playInterval
+ ///
+ /// ID of the button that will allow you to see the previous picture
+ ///
+ /// get_previousButtonID
+ /// set_previousButtonID
+ ///
+ /// The path to the webservice that the extender will pull the images from
+ ///
+ /// get_slideShowServicePath
+ /// set_slideShowServicePath
+ ///
+ /// The webservice method that will be called to supply images
+ ///
+ /// get_slideShowServiceMethod
+ /// set_slideShowServiceMethod
+ ///
+ /// Setting it to true will allow displaying pictures in cycle
+ ///
+ /// get_loop
+ /// set_loop
+ ///
+ /// Setting it to true will play the slideshow automatically on render
+ ///
+ /// get_autoPlay
+ /// set_autoPlay
+ ///
+ /// Type of animation used on changing one slide to another
+ ///
+ ///
+ /// If you set SlideShowAnimationType to either SlideDown or SlideRight, then you must
+ /// set both the Height and Width properties on the Image control being extended by
+ /// the SlideShow extender
+ ///
+ /// get_slideShowAnimationType
+ /// set_slideShowAnimationType
+ ///
+ /// Maintains a slideshow current slide
+ ///
+ ///
+ /// Whether a slideshow supports a given animation name
+ ///
+ /// Boolean value indicates that given animation name is supported
+ ///
';
+ this._handle = this._railElement.childNodes[0];
+ this._handle.style.overflow = 'hidden';
+ this._handle.style.position = 'absolute';
+
+ if(Sys.Browser.agent == Sys.Browser.Opera) {
+ this._handle.style.left = '0px';
+ this._handle.style.top = '0px';
+ }
+
+ var textBoxElement = this.get_element();
+ var textBoxElementBounds = $common.getBounds(textBoxElement);
+ textBoxElement.parentNode.insertBefore(this._railElement, textBoxElement);
+
+ this._isHorizontal = (this._orientation == Sys.Extended.UI.SliderOrientation.Horizontal);
+
+ var defaultRailCssClass = (this._isHorizontal) ? 'ajax__slider_h_rail' : 'ajax__slider_v_rail';
+ var defaultHandleCssClass = (this._isHorizontal) ? 'ajax__slider_h_handle' : 'ajax__slider_v_handle';
+ var defaultHandleImageUrl = (this._isHorizontal)
+ ? Sys.Extended.UI.Images["Slider.Handle-Horizontal.gif"]
+ : Sys.Extended.UI.Images["Slider.Handle-Vertical.gif"];
+
+ this._railElement.className = (this._railCssClass) ? this._railCssClass : defaultRailCssClass;
+ this._handle.className = (this._handleCssClass) ? this._handleCssClass : defaultHandleCssClass;
+ if(!this._handleImageUrl)
+ this._handleImageUrl = defaultHandleImageUrl;
+
+ if(this._isHorizontal) {
+ if(this._length)
+ this._railElement.style.width = this._length;
+ }
+ else {
+ if(this._length)
+ this._railElement.style.height = this._length;
+ }
+
+ this._loadHandleImage();
+ this._enforceTextBoxElementPositioning();
+ this._hideTextBoxElement();
+ this._initializeSlider();
+ },
+
+ _enforceTextBoxElementPositioning: function() {
+ var tbPosition = {
+ position: this.get_element().style.position,
+ top: this.get_element().style.top,
+ right: this.get_element().style.right,
+ bottom: this.get_element().style.bottom,
+ left: this.get_element().style.left
+ };
+
+ if(tbPosition.position != '')
+ this._railElement.style.position = tbPosition.position;
+ if(tbPosition.top != '')
+ this._railElement.style.top = tbPosition.top;
+ if(tbPosition.right != '')
+ this._railElement.style.right = tbPosition.right;
+ if(tbPosition.bottom != '')
+ this._railElement.style.bottom = tbPosition.bottom;
+ if(tbPosition.left != '')
+ this._railElement.style.left = tbPosition.left;
+ },
+
+ _hideTextBoxElement: function() {
+ var textBoxElement = this.get_element();
+
+ textBoxElement.readOnly = true;
+
+ var dimension = '0px';
+
+ if(Sys.Browser.agent == Sys.Browser.Safari)
+ dimension = '1px';
+
+ textBoxElement.style.width = dimension;
+ textBoxElement.style.height = dimension;
+ textBoxElement.style.border = '0px';
+ textBoxElement.style.padding = '0px';
+ textBoxElement.style.margin = '0px';
+ textBoxElement.style.fontSize = '1px';
+ textBoxElement.style.lineHeight = '1px';
+ textBoxElement.style.outline = '0';
+
+ textBoxElement.style.position = 'absolute';
+ },
+
+ _loadHandleImage: function() {
+ this._handleImage = document.createElement('IMG');
+ this._handleImage.id = this.get_id() + '_handleImage';
+ this._handle.appendChild(this._handleImage);
+ this._handleImage.src = this._handleImageUrl;
+ },
+
+ _initializeSlider: function() {
+ this._initializeBoundControl();
+
+ var _elementValue;
+ try {
+ _elementValue = parseFloat(this.get_element().value);
+ } catch(ex) {
+ _elementValue = Number.NaN;
+ }
+
+ this.set_value(_elementValue);
+ this._setHandleOffset(this._value);
+ this._initializeDragHandle();
+
+ Sys.Extended.UI.SliderDragDropManagerInternal.registerDropTarget(this);
+
+ this._initializeHandlers();
+ this._initializeHandleAnimation();
+
+ this._isInitializedInternal = true;
+ this._raiseEvent('sliderInitialized');
+ },
+
+ _initializeBoundControl: function() {
+ if(this._boundControl) {
+ var isInputElement = this._boundControl.nodeName == 'INPUT';
+
+ if(isInputElement) {
+ this._boundControlChangeHandler = Function.createDelegate(this, this._onBoundControlChange);
+ this._boundControlKeyPressHandler = Function.createDelegate(this, this._onBoundControlKeyPress);
+
+ $addHandler(this._boundControl, 'change', this._boundControlChangeHandler);
+ $addHandler(this._boundControl, 'keypress', this._boundControlKeyPressHandler);
+ }
+ }
+ },
+
+ _disposeBoundControl: function() {
+ if(this._boundControl) {;
+ var isInputElement = this._boundControl.nodeName == 'INPUT';
+
+ if(isInputElement) {
+ $removeHandler(this._boundControl, 'change', this._boundControlChangeHandler);
+ $removeHandler(this._boundControl, 'keypress', this._boundControlKeyPressHandler);
+ }
+ }
+ },
+
+ _onBoundControlChange: function(evt) {
+ this._animationPending = true;
+ this._setValueFromBoundControl();
+ },
+
+ _onBoundControlKeyPress: function(evt) {
+ if(evt.charCode == 13) {
+ this._animationPending = true;
+ this._setValueFromBoundControl();
+ evt.preventDefault();
+ }
+ },
+
+ _setValueFromBoundControl: function() {
+ this._isUpdatingInternal = true;
+
+ if(this._boundControlID)
+ this._calcValue($get(this._boundControlID).value);
+
+ this._isUpdatingInternal = false;
+ },
+
+ _initializeHandleAnimation: function() {
+ if(this._steps > 0) {
+ this._enableHandleAnimation = false;
+ return;
+ }
+
+ if(this._enableHandleAnimation)
+ this._handleAnimation = new Sys.Extended.UI.Animation.LengthAnimation(
+ this._handle, this._handleAnimationDuration, 100, 'style');
+ },
+
+ _ensureBinding: function() {
+ if(this._boundControl) {
+ var value = this._value;
+
+ if(value >= this._minimum || value <= this._maximum) {
+ var isInputElement = this._boundControl.nodeName == 'INPUT';
+
+ if(isInputElement)
+ this._boundControl.value = value;
+ else if(this._boundControl)
+ this._boundControl.innerHTML = value;
+ }
+ }
+ },
+
+ _getBoundsInternal: function(element) {
+ var bounds = $common.getBounds(element);
+
+ function hasSize() {
+ return bounds.width > 0 && bounds.height > 0;
+ }
+
+ if(!hasSize()) {
+ bounds.width = parseInt($common.getCurrentStyle(element, 'width'));
+ bounds.height = parseInt($common.getCurrentStyle(element, 'height'));
+
+ if(!hasSize()) {
+ var tempNode = element.cloneNode(true);
+ tempNode.visibility = 'hidden';
+ document.body.appendChild(tempNode);
+
+ bounds.width = parseInt($common.getCurrentStyle(tempNode, 'width'));
+ bounds.height = parseInt($common.getCurrentStyle(tempNode, 'height'));
+ document.body.removeChild(tempNode);
+
+ if(!hasSize())
+ throw Error.argument('element size', Sys.Extended.UI.Resources.Slider_NoSizeProvided);
+ }
+ }
+
+ if(this._orientation == Sys.Extended.UI.SliderOrientation.Vertical) {
+ bounds = {
+ x: bounds.y,
+ y: bounds.x,
+ height: bounds.width,
+ width: bounds.height,
+ right: bounds.right,
+ bottom: bounds.bottom,
+ location: { x: bounds.y, y: bounds.x },
+ size: { width: bounds.height, height: bounds.width }
+ };
+ }
+
+ return bounds;
+ },
+
+ _getRailBounds: function() {
+ var bounds = this._getBoundsInternal(this._railElement);
+
+ return bounds;
+ },
+
+ _getHandleBounds: function() {
+ return this._getBoundsInternal(this._handle);
+ },
+
+ _initializeDragHandle: function() {
+ var dh = this._dragHandle = document.createElement('DIV');
+
+ dh.style.position = 'absolute';
+ dh.style.width = '1px';
+ dh.style.height = '1px';
+ dh.style.overflow = 'hidden';
+ dh.style.zIndex = Sys.Extended.UI.zIndex.SliderDragHandle;
+ dh.style.background = 'none';
+
+ document.body.appendChild(this._dragHandle);
+ },
+
+ _resetDragHandle: function() {
+ var handleBounds = $common.getBounds(this._handle);
+
+ $common.setLocation(this._dragHandle, { x: handleBounds.x, y: handleBounds.y });
+ },
+
+ _initializeHandlers: function() {
+ this._selectstartHandler = Function.createDelegate(this, this._onSelectStart);
+ this._mouseupHandler = Function.createDelegate(this, this._onMouseUp);
+
+ this._keyDownHandler = Function.createDelegate(this, this._onKeyDown);
+
+ $addHandler(document, 'mouseup', this._mouseupHandler);
+
+ $addHandler(this.get_element(), 'keydown', this._keyDownHandler);
+
+ $addHandlers(this._handle, {
+ 'mousedown': this._onMouseDown,
+ 'dragstart': this._IEDragDropHandler,
+ 'drag': this._IEDragDropHandler,
+ 'dragend': this._IEDragDropHandler
+ },
+ this);
+
+ $addHandlers(this._railElement, {
+ 'click': this._onRailClick
+ },
+ this);
+ },
+
+ _disposeHandlers: function() {
+ $clearHandlers(this._handle);
+ $clearHandlers(this._railElement);
+
+ $removeHandler(this.get_element(), 'keydown', this._keyDownHandler);
+
+ $removeHandler(document, 'mouseup', this._mouseupHandler);
+
+ this._keyDownHandler = null;
+ this._mouseupHandler = null;
+ this._selectstartHandler = null;
+ },
+
+ startDragDrop: function(dragVisual) {
+ this._resetDragHandle();
+
+ Sys.Extended.UI.SliderDragDropManagerInternal.startDragDrop(this, dragVisual, null);
+ },
+
+ _onMouseDown: function(evt) {
+ window._event = evt;
+ evt.preventDefault();
+
+ if(!Sys.Extended.UI.SliderBehavior.DropPending) {
+ Sys.Extended.UI.SliderBehavior.DropPending = this;
+
+ $addHandler(document, 'selectstart', this._selectstartHandler);
+ this._selectstartPending = true;
+
+ this.startDragDrop(this._dragHandle);
+ }
+ },
+
+ _onMouseUp: function(evt) {
+ var srcElement = evt.target;
+
+ if(Sys.Extended.UI.SliderBehavior.DropPending == this) {
+ Sys.Extended.UI.SliderBehavior.DropPending = null;
+
+ if(this._selectstartPending)
+ $removeHandler(document, 'selectstart', this._selectstartHandler);
+ }
+ },
+
+ _onKeyDown: function(e) {
+ if(this._enableKeyboard) {
+ var evt = new Sys.UI.DomEvent(e);
+
+ switch(evt.keyCode || evt.rawEvent.keyCode) {
+ case Sys.UI.Key.up:
+ case Sys.UI.Key.left:
+ this._handleSlide(true);
+ evt.preventDefault();
+ return;
+ case Sys.UI.Key.down:
+ case Sys.UI.Key.right:
+ this._handleSlide(false);
+ evt.preventDefault();
+ return false;
+ default:
+ return false;
+ }
+ }
+ },
+
+ _handleSlide: function(decrement) {
+ this._animationPending = true;
+
+ this._isUpdatingInternal = true;
+
+ var currentValue = this.get_value();
+ var increment;
+
+ if(this._steps > 0) {
+ var extent = this._maximum - this._minimum;
+
+ var delta = (extent / (this._steps - 1)).toFixed(this._decimals);
+
+ increment = delta;
+ } else {
+ increment = this._decimals == 0 ? 1 : 1 / Math.pow(10, this._decimals);
+ }
+
+ if(decrement)
+ increment = 0 - increment
+
+ this._calcValue(parseFloat(currentValue) + parseFloat(increment));
+ this._isUpdatingInternal = false;
+ this._fireTextBoxChangeEvent();
+ },
+
+ _onRailClick: function(evt) {
+ if(evt.target == this._railElement) {
+ this._animationPending = true;
+ this._onRailClicked(evt);
+ }
+ },
+
+ _IEDragDropHandler: function(evt) {
+ evt.preventDefault();
+ },
+
+ _onSelectStart: function(evt) {
+ evt.preventDefault();
+ },
+
+ _calcValue: function(value, mouseOffset) {
+ var val;
+
+ if(value != null) {
+ if(!Number.isInstanceOfType(value)) {
+ try {
+ value = parseFloat(value);
+ } catch(ex) {
+ value = Number.NaN;
+ }
+ }
+
+ if(isNaN(value))
+ value = this._minimum;
+
+ val = (value < this._minimum) ? this._minimum
+ : (value > this._maximum) ? this._maximum
+ : value;
+ }
+ else {
+ var _minimum = this._minimum;
+ var _maximum = this._maximum;
+ var handleBounds = this._getHandleBounds();
+ var sliderBounds = this._getRailBounds();
+ var handleX = (mouseOffset) ? mouseOffset - handleBounds.width / 2
+ : handleBounds.x - sliderBounds.x;
+ var extent = sliderBounds.width - handleBounds.width;
+ var percent = handleX / extent;
+
+ val = (handleX == 0) ? _minimum
+ : (handleX == (sliderBounds.width - handleBounds.width)) ? _maximum
+ : _minimum + percent * (_maximum - _minimum);
+ }
+
+ if(this._steps > 0)
+ val = this._getNearestStepValue(val);
+
+ val = (val < this._minimum) ? this._minimum
+ : (val > this._maximum) ? this._maximum
+ : val;
+
+ this._isUpdatingInternal = true;
+ this.set_value(val);
+ this._isUpdatingInternal = false;
+
+ return val;
+ },
+
+ _setHandleOffset: function(value, playHandleAnimation) {
+ var _minimum = this._minimum;
+ var _maximum = this._maximum;
+ var handleBounds = this._getHandleBounds();
+ var sliderBounds = this._getRailBounds();
+
+ var extent = _maximum - _minimum;
+ var fraction = (value - _minimum) / extent;
+ var hypOffset = Math.round(fraction * (sliderBounds.width - handleBounds.width));
+
+ var offset = (value == _minimum) ? 0
+ : (value == _maximum) ? (sliderBounds.width - handleBounds.width)
+ : hypOffset;
+
+ if(playHandleAnimation) {
+ this._handleAnimation.set_startValue(handleBounds.x - sliderBounds.x);
+ this._handleAnimation.set_endValue(offset);
+ this._handleAnimation.set_propertyKey((this._isHorizontal) ? 'left' : 'top');
+ this._handleAnimation.play();
+
+ this._animationPending = false;
+ }
+ else {
+ if(this._isHorizontal)
+ this._handle.style.left = offset + 'px';
+ else
+ this._handle.style.top = offset + 'px';
+ }
+ },
+
+ _getNearestStepValue: function(value) {
+ if(this._steps == 0)
+ return value;
+
+ var extent = this._maximum - this._minimum;
+ if(extent == 0)
+ return value;
+
+ var delta = extent / (this._steps - 1);
+
+ return Math.round(value / delta) * delta;
+ },
+
+ _onHandleReleased: function() {
+ if(this._raiseChangeOnlyOnMouseUp)
+ this._fireTextBoxChangeEvent();
+
+ this._raiseEvent('slideEnd');
+ },
+
+ _onRailClicked: function(evt) {
+ var handleBounds = this._getHandleBounds();
+ var sliderBounds = this._getRailBounds();
+ var offset = (this._isHorizontal) ? evt.offsetX : evt.offsetY;
+ var minOffset = handleBounds.width / 2;
+ var maxOffset = sliderBounds.width - minOffset;
+
+ offset = (offset < minOffset) ? minOffset
+ : (offset > maxOffset) ? maxOffset
+ : offset;
+
+ this._calcValue(null, offset, true);
+
+ this._fireTextBoxChangeEvent();
+ },
+
+ _fireTextBoxChangeEvent: function() {
+ if(document.createEvent) {
+ var onchangeEvent = document.createEvent('HTMLEvents');
+ onchangeEvent.initEvent('change', true, false);
+
+ this.get_element().dispatchEvent(onchangeEvent);
+ }
+ else if(document.createEventObject) {
+ this.get_element().fireEvent('onchange');
+ }
+ },
+
+ ///
+ /// A slider drag data type
+ ///
+ /// get_dragDataType
+ ///
+ /// Returns slider data
+ ///
+ ///
+ /// Slider dra mode
+ ///
+ /// dragMode
+ ///
+ /// A slider drop target element
+ ///
+ /// get_dropTargetElement
+ ///
+ /// Fires when the slider is initialized
+ ///
+ ///
+ /// Fires when the slider value changes
+ ///
+ ///
+ /// Fires when sliding starts
+ ///
+ ///
+ /// Fires when sliding ends
+ ///
+ ///
+ /// A slider current value
+ ///
+ /// get_value
+ /// set_value
+ ///
+ /// A CSS class for the slider's rail
+ ///
+ /// get_railCssClass
+ /// set_railCssClass
+ ///
+ /// The URL of an image to display as the slider's handle
+ ///
+ /// get_handleImageUrl
+ /// set_handleImageUrl
+ ///
+ /// A CSS class for the slider's handle
+ ///
+ /// get_handleCssClass
+ /// set_handleCssClass
+ ///
+ /// Minimum value allowed
+ ///
+ /// get_minimum
+ /// set_minimum
+ ///
+ /// Maximum value allowed
+ ///
+ /// get_maximum
+ /// set_maximum
+ ///
+ /// Slider orientation
+ ///
+ /// get_orientation
+ /// set_orientation
+ ///
+ /// A number of discrete values inside the slider's range
+ ///
+ /// get_steps
+ /// set_steps
+ ///
+ /// A number of decimal digits for the value
+ ///
+ /// get_decimals
+ /// set_decimals
+ ///
+ /// Enable/disable the handle animation
+ ///
+ /// get_enableHandleAnimation
+ /// set_enableHandleAnimation
+ ///
+ /// Duration of the handle animation
+ ///
+ /// get_handleAnimationDuration
+ /// set_handleAnimationDuration
+ ///
+ /// ID of the TextBox or Label that dynamically displays the slider's value
+ ///
+ /// get_boundControlID
+ /// set_boundControlID
+ ///
+ /// Width/height of a horizontal/vertical slider when the default layout is used
+ ///
+ /// get_length
+ /// set_length
+ ///
+ /// Determines whether the slider is initialized
+ ///
+ /// Boolean value indicates whether slider is initialized
+ ///
+ /// If true, fires the change event on the extended TextBox only when the left mouse button is released
+ /// mouse button is released
+ ///
+ /// get_raiseChangeOnlyOnMouseUp
+ /// set_raiseChangeOnlyOnMouseUp
+ ///
+ /// Text to display in a tooltip when the handle is hovered
+ ///
+ ///
+ /// The {0} placeholder in the text is replaced with the current value of the slider
+ ///
+ /// get_tooltipText
+ /// set_tooltipText
+ ///
+ /// Determines if the slider will respond to arrow keys when it has focus
+ ///
+ /// get_enableKeyboard
+ /// set_enableKeyboard
+ ///
+ /// A client state
+ ///
+ /// get_clientState
+ /// set_clientState
+ ///
+ /// Fires when a tab is changed
+ ///
+ ///
+ /// The first tab to show
+ ///
+ /// get_activeTabIndex
+ /// set_activeTabIndex
+ ///
+ /// A collection of tabs
+ ///
+ /// get_tabs
+ ///
+ /// The currently active tab
+ ///
+ /// get_activeTab
+ /// set_activeTab
+ ///
+ /// AutoPostback ID
+ ///
+ /// get_autoPostBackId
+ /// set_autoPostBackId
+ ///
+ /// Determines whether or not to display scrollbars (None, Horizontal, Vertical, Both, Auto)
+ /// in the TabContainer body
+ ///
+ /// get_scrollBars
+ /// set_scrollBars
+ ///
+ /// Determines whether or not to render tabs on top of the container or below (Top, Bottom)
+ ///
+ /// get_tabStripPlacement
+ /// set_tabStripPlacement
+ ///
+ /// Determines whether or not to render tabs on the left or right side of the container
+ ///
+ /// get_useVerticalStripPlacement
+ /// set_useVerticalStripPlacement
+ ///
+ /// Determines whether or not to render/load tabs on demand or all tabs on page load
+ ///
+ /// get_onDemand
+ /// set_onDemand
+ ///
+ /// Returns TabContainer's first tab
+ ///
+ /// First tab
+ ///
+ /// Returns TabContainer's last tab
+ ///
+ /// Last tab
+ ///
+ /// Returns TabContainer's next tab
+ ///
+ /// Next tab
+ ///
+ /// Returns TabContainer's previous tab
+ ///
+ /// Previous tab
+ ///
+ /// Returns TabContainer's nearest tab
+ ///
+ ///
+ /// Saves JSON state serialized on the client side
+ ///
+ /// Client state
+ ///
+ /// Fires on a click
+ ///
+ ///
+ /// Fires when tab populating begins
+ ///
+ ///
+ /// Fires when tab populating is performed
+ ///
+ ///
+ /// Text to display in the tab
+ ///
+ /// get_headerText
+ /// set_headerText
+ ///
+ /// A header tab
+ ///
+ /// get_headerTab
+ /// set_headerTab
+ ///
+ /// Determines whether or not to display the tab for the TabPanel by default
+ ///
+ /// get_enabled
+ /// set_enabled
+ ///
+ /// The owner TabContainer
+ ///
+ /// get_owner
+ /// set_owner
+ ///
+ /// The ID of the owner TabContainer element
+ ///
+ /// get_ownerID
+ /// set_ownerID
+ ///
+ /// Determines whether or not to display scrollbars (None, Horizontal, Vertical, Both, Auto) in the body of the TabPanel
+ ///
+ /// get_scrollBars
+ /// set_scrollBars
+ ///
+ /// Determines whether or not to load the tab (Always, Once, None) when the container's onDemand property is true
+ ///
+ /// get_onDemandMode
+ /// set_onDemandMode
+ ///
+ /// The current tab index
+ ///
+ /// get_tabIndex
+ ///
+ /// An arbitrary string value to be passed to the dynamically populated web method
+ ///
+ /// get_dynamicContextKey
+ /// set_dynamicContextKey
+ ///
+ /// The URL of the web service to call
+ ///
+ /// get_dynamicServicePath
+ /// set_dynamicServicePath
+ ///
+ /// The name of the method to call on the page or web service
+ ///
+ /// get_dynamicServiceMethod
+ /// set_dynamicServiceMethod
+ ///
+ /// ID of the panel to update
+ ///
+ /// get_updatePanelID
+ /// set_updatePanelID
+ ///
+ /// Determines the loading status of the tab in Once demand mode
+ ///
+ /// get_wasLoadedOnce
+ /// set_wasLoadedOnce
+ ///
+ /// Clears the text from the target
+ ///
+ ///
+ /// A method to call to be assigned to Sys.Preview.UI.TextBox if any
+ ///
+ ///
+ /// This method must be called manually if Sys.Preview.UI.TextBox
+ /// is added after TextBoxWatermarkBehavior is initialized
+ ///
+ ///
+ /// Text to show when the control has no value
+ ///
+ /// get_watermarkText
+ /// set_watermarkText
+ ///
+ /// A CSS class to apply to the TextBox when it has no value (e.g. watermark text is shown)
+ ///
+ /// get_watermarkCssClass
+ /// set_watermarkCssClass
+ ///
+ /// Text of the target TextBox
+ ///
+ /// get_text
+ /// set_text
+ ///
+ /// The width of an image
+ ///
+ /// get_imageWidth
+ /// set_imageWidth
+ ///
+ /// The height of an image
+ ///
+ /// get_imageHeight
+ /// set_imageHeight
+ ///
+ /// The URL of an image to show when the toggle button is in the unchecked state
+ ///
+ /// get_uncheckedImageUrl
+ /// set_uncheckedImageUrl
+ ///
+ /// The URL of an image to show when the toggle button is in the checked state
+ ///
+ /// get_checkedImageUrl
+ /// set_checkedImageUrl
+ ///
+ /// The URL of an image to show when the toggle button is disabled and in the unchecked state
+ ///
+ /// get_disabledUncheckedImageUrl
+ /// set_disabledUncheckedImageUrl
+ ///
+ /// The URL of an image to show when the toggle button is disabled and in the checked state
+ ///
+ /// get_disabledCheckedImageUrl
+ /// set_disabledCheckedImageUrl
+ ///
+ /// The URL of an image to show when the toggle button is in the checked
+ /// state and the mouse is over the button
+ ///
+ /// get_checkedImageOverUrl
+ /// set_checkedImageOverUrl
+ ///
+ /// The URL of an image to show when the toggle button is in the unchecked
+ /// state and the mouse is over the button
+ ///
+ /// get_uncheckedImageOverUrl
+ /// set_uncheckedImageOverurl
+ ///
+ /// The alt text to show when the toggle button is in the unchecked state
+ ///
+ /// get_uncheckedImageAlternateText
+ /// set_uncheckedImageAlternateText
+ ///
+ /// The alt text to show when the toggle button is in the checked state
+ ///
+ /// get_checkedImageAlternateText
+ /// set_checkedImageAlternateText
+ ///
+ /// The alt text to show when the toggle button is in the checked state
+ /// and the mouse is over the button
+ ///
+ /// get_checkedImageOverAlternateText
+ /// set_checkedImageOverAlternateText
+ ///
+ /// The alt text to show when the toggle button is in the unchecked
+ /// state and the mouse is over the button
+ ///
+ /// get_uncheckedImageOverAlternateText
+ /// set_uncheckedImageOverAlternateText
+ ///
+ /// Generic animation played as when any UpdatePanel begins updating
+ ///
+ /// get_onUpdating
+ /// set_onUpdating
+ ///
+ /// Generic OnUpdating Animation's behavior
+ ///
+ /// get_onUpdatingBehavior
+ ///
+ /// Generic animation played after the UpdatePanel has finished updating
+ /// (but only if the UpdatePanel was changed)
+ ///
+ /// get_onUpdated
+ /// set_onUpdated
+ ///
+ /// Generic OnUpdated Animation's behavior
+ ///
+ /// get_onUpdatedBehavior
+ ///
+ /// An optional property that makes sure the OnUpdated event will fire
+ /// only after the onUpdating event is completed
+ ///
+ /// get_alwaysFinishOnUpdatingAnimation
+ /// set_alwaysFinishOnUpdatingAnimation
+ ///
+ /// ClientIDs of the trigger controls
+ ///
+ /// get_triggerControlsClientID
+ /// set_triggerControlsClientID
+ ///
+ /// Shows the ValidatorCallout popup
+ ///
+ ///
+ /// Hides the ValidatorCallout popup
+ ///
+ ///
+ /// Generic OnShow animation for the ValidatorCallout extender
+ ///
+ ///
+ /// The OnShow animation will be played each time the validation popup is displayed.
+ /// The popup will be positioned correctly, but hidden. The animation can be used to
+ /// display the popup along with any other visual effects.
+ ///
+ /// See Animation Reference for more details
+ ///
+ /// get_onShow
+ /// set_onShow
+ ///
+ /// Generic OnShow Animation's behavior
+ ///
+ /// get_onShowBehavior
+ ///
+ /// Generic OnHide animation for the ValidatorCallout extender
+ ///
+ ///
+ /// The OnHide animation will be played each time the validation popup is hidden
+ ///
+ /// get_onHide
+ /// set_onHide
+ ///
+ /// Generic OnHide Animation's behavior
+ ///
+ /// get_onHideBehavior
+ ///
+ /// The path to a custom warning icon image
+ ///
+ /// get_warningIconImageUrl
+ /// set_warningIconImageUrl
+ ///
+ /// The path to a custom close image
+ ///
+ /// get_closeImageUrl
+ /// set_closeImageUrl
+ ///
+ /// The width of the callout
+ ///
+ /// get_width
+ /// set_width
+ ///
+ /// Indicates where the ValidatorCallout popup should appear relatively to the control to validate
+ ///
+ ///
+ /// Possible values:
+ /// * BottomLeft
+ /// * BottomRight
+ /// * TopLeft
+ /// * TopRight
+ /// * Left
+ /// * Right
+ ///
+ /// get_popupPosition
+ /// set_popupPosition
+ ///
+ /// Name of the CSS class used to style the ValidatorCallout
+ ///
+ ///
+ /// See the ValidatorCallout Theming section for more information
+ ///
+ /// get_cssClass
+ /// set_cssClass
+ ///
+ /// A CSS class to apply to an invalid field
+ ///
+ /// get_highlightCssClass
+ /// set_highlightCssClass
+ ///
+ /// Determines whether the ValidatorCallout popup is opened
+ ///
+ ///
+ /// Boolean value, which is true when ValidatorCallout popup is open
+ ///
+ /// 0&&this._changeSelectedIndex(0,!1,!0);this._initializeLayout()},_getNextDiv:function(n,t){for(var i=null;t.value=7,(!i||i&&n.height&&n.height.length>0)&&(n.height="auto"),(!i||i&&n.overflow&&n.overflow.length>0)&&(n.overflow="auto")):(this._addResizeHandler(),n.height=u.offsetHeight+"px",n.overflow="hidden"),t=0;t=0;t--)n=this._panes[t],n&&(n.header&&(n.header._index=null,$removeHandler(n.header,"click",this._headerClickHandler),n.header=null),n.content&&(n.content._original=null,n.content=null),this._panes[t]=null,delete this._panes[t]);this._panes=null;this._headerClickHandler=null;Sys.Extended.UI.AccordionBehavior.callBaseMethod(this,"dispose")},_disposeResizeHandler:function(){this._resizeHandler&&($removeHandler(window,"resize",this._resizeHandler),this._resizeHandler=null)},_disposeAnimations:function(){for(var n,t=0;t0&&(t=Math.min(t,r)))),t},_getTotalSize:function(n){var t=$common.getSize(n),i=$common.getMarginBox(n);return t.width+=i.horizontal,t.height+=i.vertical,t},_getGutterSize:function(n){var i={width:0,height:0},t;try{t=$common.getPaddingBox(n);i.width+=t.horizontal;i.height+=t.vertical}catch(r){}try{t=$common.getBorderBox(n);i.width+=t.horizontal;i.height+=t.vertical}catch(r){}return t=$common.getMarginBox(n),i.width+=t.horizontal,i.height+=t.vertical,i},add_selectedIndexChanging:function(n){this.get_events().addHandler("selectedIndexChanging",n)},remove_selectedIndexChanging:function(n){this.get_events().removeHandler("selectedIndexChanging",n)},raiseSelectedIndexChanging:function(n){Sys.Extended.Deprecated("raiseSelectedIndexChanging(eventArgs)","raise_selectedIndexChanging(eventArgs)");this.raise_selectedIndexChanging(n)},raise_selectedIndexChanging:function(n){var t=this.get_events().getHandler("selectedIndexChanging");t&&t(this,n)},add_selectedIndexChanged:function(n){this.get_events().addHandler("selectedIndexChanged",n)},remove_selectedIndexChanged:function(n){this.get_events().removeHandler("selectedIndexChanged",n)},raiseSelectedIndexChanged:function(n){Sys.Extended.Deprecated("raiseSelectedIndexChanged(eventArgs)","raise_selectedIndexChanged(eventArgs)");this.raise_selectedIndexChanged(n)},raise_selectedIndexChanged:function(n){var t=this.get_events().getHandler("selectedIndexChanged");t&&t(this,n)},getPane:function(n){return(n===undefined||n===null)&&(n=this._selectedIndex),this._panes&&n>=0&&n=0?n.lastIndexOf("\\"):n.lastIndexOf("/"),t=n.substring(r),(t.indexOf("\\")===0||t.indexOf("/")===0)&&(t=t.substring(1)),i=t)}return encodeURIComponent(i)};this.getFileType=function(n){if(!n)throw"file must defined or not null";if(!n.value&&n.name)return n.name.substring(n.name.lastIndexOf(".")+1);if(n.value&&(n=n.value),typeof n!="string")throw"can't resolve file type.";return n.substring(n.lastIndexOf(".")+1)};this.sizeToString=function(n){if(!n||n<=0)return"0 Kb";var t=Math.floor(Math.log(n)/Math.log(1024));return(n/Math.pow(1024,Math.floor(t))).toFixed(2)+" "+["bytes","kb","MB","GB","TB","PB"][t]};this.checkHtml5BrowserSupport=function(){return window.File&&window.FileReader&&window.FileList&&window.Blob&&(new XMLHttpRequest).upload}};Sys.Extended.UI.AjaxFileUpload.Item=function(n,t,i){this._deleteButton=null;this._parentId=n;this._inputElementValue=t.value;this._id=t.id;this._slices=t.slices;this._sliceIndex=0;this._fileInfoContainer=null;this._fileStatusText=null;this._isUploaded=!1;this._isUploading=!1;this._fileSize=0;this._fileName="";this._fileType="";this._bytesUploaded=0;this._ui=this.initUI(i)};Sys.Extended.UI.AjaxFileUpload.Item.prototype={initUI:function(n){var l=this,t=this._inputElementValue,e=new Sys.Extended.UI.AjaxFileUpload.Utils,a=e.checkHtml5BrowserSupport(),i=this._id,r=$common.createElementFromTemplate({nodeName:"div",properties:{id:this._parentId+"_FileItemContainer_"+i},cssClasses:["ajax__fileupload_fileItemInfo"]}),u=$common.createElementFromTemplate({nodeName:"div",properties:{id:this._parentId+"_FileInfoContainer_"+i,style:{display:"inline-block"}}}),o=$common.createElementFromTemplate({nodeName:"span",properties:{id:this._parentId+"_FileItemInfo_"+i},cssClasses:["ajax__fileupload_fileItemInfo"]}),h=$common.createElementFromTemplate({nodeName:"span",properties:{id:this._parentId+"_FileItemStatus_"+i},cssClasses:["uploadstatus"]}),f=$common.createElementFromTemplate({nodeName:"div",properties:{id:this._parentId+"_FileItemDeleteButton_"+i},cssClasses:["removeButton"]}),s,c;return this._fileName=e.getFileName(t),s=decodeURIComponent(this._fileName),a?(this._fileSize=t.size,c=t.type?'('+t.type+")<\/span>":"",o.innerHTML=''+s+"<\/span> "+c+' - '+e.sizeToString(t.size)+"<\/span> ",this._fileType=t.type):(o.innerHTML=''+s+"<\/span>",this._fileType=e.getFileType(t)),u.appendChild(o),u.appendChild(h),$common.setText(f,Sys.Extended.UI.Resources.AjaxFileUpload_Remove),$addHandlers(f,{click:Function.createDelegate(this,function(){n(l)})}),Sys.Browser.agent==Sys.Browser.InternetExplorer&&Sys.Browser.version<=8?(r.appendChild(f),r.appendChild(u)):(r.appendChild(u),r.appendChild(f)),this._fileInfoContainer=u,this._deleteButton=f,this._fileStatusText=h,r},setStatus:function(n,t){$common.setText(this._fileStatusText," ("+t+")");this._fileInfoContainer.setAttribute("class",n+"State")},disabled:function(n){this._deleteButton.disabled=n?"disabled":""},hide:function(){this._deleteButton.style.visibility="hidden"},destroy:function(){$common.removeElement(this._inputElementValue);$common.removeElement(this._deleteButton);$common.removeElement(this._ui)},get_inputElementValue:function(){return this._inputElementValue},appendNodeTo:function(n){n.appendChild(this._ui)},removeNodeFrom:function(n){n.removeChild(this._ui)}};Sys.Extended.UI.AjaxFileUpload.Processor=function(n,t){var r=new Sys.Extended.UI.AjaxFileUpload.Utils,i=new XMLHttpRequest;this._iframe=null;this._iframeName=n.get_id()+"_uploadIframe";this._form=null;this.initialize=function(){this.attachEvents();this.createIFrame();this.createForm()};this.attachEvents=function(){this.onFileSelected$delegate=Function.createDelegate(this,this.onFileSelectedHandler);this.attachFileInputEvents(t.inputFile,!0);var r=this;i.onreadystatechange=function(){if(i.readyState==4&&i.status==200){var t=i.responseText;t&&(t=parseFloat(t).toFixed(2),n.setPercent(t));t<100&&setTimeout(function(){r.pollingServerProgress(!0)},500)}}};this.attachFileInputEvents=function(n,t){t?$addHandlers(n,{change:this.onFileSelected$delegate}):$common.removeHandlers(n,{change:this.onFileSelected$delegate})};this.onFileSelectedHandler=function(){var i={id:r.generateGuid(),value:t.inputFile,type:r.getFileType(t.inputFile.value)};n.fileTypeIsValid(i.type)?(n.addFileToQueue(i),this.createInputFileElement()):n.confirmFileIsInvalid(i)};this.createInputFileElement=function(){var i=t.inputFile,f,u;i.style.zIndex=-999;$common.setLocation(i,{x:-99999,y:-99999});this.attachFileInputEvents(i,!1);f=n.get_id()+"_file_"+r.generateGuid();u=$common.createElementFromTemplate({nodeName:"input",properties:{id:f,name:"act-file-data",type:"file",style:{zIndex:0,cursor:"pointer",position:"absolute"}}},i.parentNode);$common.setElementOpacity(u,0);this.attachFileInputEvents(u,!0);t.inputFile=u};this.startUpload=function(){var t=this._form,i=n.getNextFile(),r;if(!i){n._currentFileId=null;this.setThrobber(!1);n.done();return}for(n.setAsUploading(i),r=i.get_inputElementValue(),n._currentFileId=i._id,this.setThrobber(!0);t.firstChild;)t.removeChild(t.firstChild);r.name="act-file-data";t.appendChild(r);t.setAttribute("action",n._uploadUrl+"?contextKey="+n.get_id()+"&fileId="+n._currentFileId+"&fileName="+i._fileName+"&usePoll="+(n.get_serverPollingSupport()?"true":"false"));t.submit()};this.cancelUpload=function(){var t=new XMLHttpRequest,r=this;i&&i.abort();t.open("POST","?contextKey="+n.get_id()+"&cancel=1&guid="+n._currentFileId,!0);t.onreadystatechange=function(){if(r.setThrobber(!1),t.readyState==4)if(t.status==200)n.cancelUpload();else{r.raiseUploadError(t);throw"Failed to cancel upload.";}};t.send(null)};this.createIFrame=function(){var t=this._iframeName,n=document.createElement("IFRAME");n.width="0";n.height="0";n.style.display="none";n.src="about:blank";n.id=t;n.name=t;n.security="restricted";document.body.appendChild(n);n.contentWindow.name=t;$addHandlers(n,{load:Function.createDelegate(this,this.onIFrameLoadedHandler)});this._iframe=n};this.onIFrameLoadedHandler=function(t){if(n._currentFileId)try{var i=this._iframe,r=null;if(i.contentDocument?r=i.contentDocument:i.contentWindow?r=i.contentWindow.document:i.document&&(r=i.document),r==null)throw"Document not initialized";n.doneAndUploadNextFile(n.getCurrentFileItem())}catch(t){if(!n._canceled||!(t.message&&(t.message.indexOf("Access is denied")>-1||t.message.indexOf("Permission denied")>-1))){this.raiseUploadError(t);throw t;}}};this.setThrobber=function(i){if(n.get_serverPollingSupport()){n.setPercent(0);$common.setVisible(t.progressBar,i?!0:!1);$common.setVisible(t.progressBarContainer,i?!0:!1);this.pollingServerProgress(i);return}n.get_throbber()!=null&&(n.get_throbber().style.display=i?"":"none")};this.pollingServerProgress=function(t){t&&n._currentFileId&&(i.open("GET","?contextKey="+n.get_id()+"&poll=1&guid="+n._currentFileId,!0),i.send(null))};this.createForm=function(){var t,i="___postForm"+n.get_id();try{t=document.createElement('