";
+
+ if (!this._inner_command) {
+ if (this._ready_image) {
+ this._inner_command = this._create_inner_command(this._edge_type, this.width, this.height, this.url, this._img_width, this._img_height, this.edgex, this.edgey);
+ }
+ else {
+ if (this.url) {
+ var imgsize = nexacro._getImageSize(this.url, this._on_notify_imgsize, this);
+ this._img_sizereq = true;
+ if (imgsize) {
+ this._img_sizereq = false;
+ this._ready_image = true;
+ this._img_width = imgsize.width;
+ this._img_height = imgsize.height;
+ this._inner_command = this._create_inner_command(this._edge_type, this.width, this.height, this.url, this._img_width, this._img_height, this.edgex, this.edgey);
+ }
+ }
+ }
+ }
+
+ if (this._inner_command) {
+ str += this._inner_command;
+ }
+
+ str += "
";
+ return str;
+ }
+ return "";
+ };
+ __pEdgeImageElement.attachHandle = function (win) {
+ if (this.name && !this.handle) {
+ var handle = win._doc.getElementById(this.name);
+ if (handle) {
+ this.handle = handle;
+ }
+ }
+ };
+ __pEdgeImageElement.attach_handle_fromparent = function (_parent) {
+ if (_parent && !this.handle) {
+ var handle = _parent.firstChild;
+ if (handle) {
+ this.handle = handle;
+ }
+ }
+ };
+
+ __pEdgeImageElement.destroy = function () {
+ var handle = this.handle;
+ if (handle) {
+ var dest_handle = (this.owner_elem ? this.owner_elem.handle : null);
+ nexacro.__removeDOMNode(dest_handle, handle);
+
+ this.owner_elem = null;
+ this.handle = null;
+ }
+ this.parent = null;
+ this.parent_elem = null;
+ };
+
+ __pEdgeImageElement.setElementSize = function (width, height) {
+ if (this.width != width || this.height != height) {
+ this.width = width;
+ this.height = height;
+
+ if (this._ready_image) {
+ this._inner_command = this._create_inner_command(this._edge_type, width, height, this.url, this._img_width, this._img_height, this.edgex, this.edgey);
+ }
+
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMStyle_Size(handle.style, width, height);
+ handle.innerHTML = this._inner_command;
+ }
+ }
+ };
+
+ __pEdgeImageElement.setElementInfo = function (edgeImage, edge_info) {
+ edgeImage = (edgeImage || edge_info);
+ if (this.edgeImage != edgeImage) {
+ this.edgeImage = edgeImage;
+ this._edge_info = edge_info;
+
+ var url = edgeImage._sysurl;
+ var edgex = edgeImage.edge_x;
+ var edgey = edgeImage.edge_y;
+
+ var url_change = false;
+ var layout_change = false;
+ var edge_type = 0;
+
+ if (edgex < 0) {
+ edgex = 0;
+ }
+ if (edgey < 0) {
+ edgey = 0;
+ }
+
+ if (edgex > 0 && edgey > 0) {
+ edge_type = 3;
+ }
+ else if (edgey > 0) {
+ edge_type = 2;
+ }
+ else if (edgex > 0) {
+ edge_type = 1;
+ }
+
+ if (this._edge_type != edge_type || this.edgex != edgex || this.edgey != edgey) {
+ this._edge_type = edge_type;
+ this.edgex = edgex;
+ this.edgey = edgey;
+ layout_change = true;
+ }
+
+ if (this.url != url) {
+ this.url = url;
+ url_change = true;
+
+ var imgsize = nexacro._getImageSize(this.url, this._on_notify_imgsize, this);
+ if (imgsize) {
+ this._img_sizereq = false;
+ this._ready_image = true;
+ if (this._img_width != imgsize.width || this._img_height != imgsize.height) {
+ this._img_width = imgsize.width;
+ this._img_height = imgsize.height;
+ layout_change = true;
+ }
+ }
+ else {
+ this._img_sizereq = true;
+ this._ready_image = false;
+ this._img_width = 0;
+ this._img_height = 0;
+ }
+ }
+ else {
+ this._ready_image = true;
+ }
+
+ if (layout_change || url_change) {
+ this._inner_command = "";
+ if (this._ready_image) {
+ this._inner_command = this._create_inner_command(edge_type, this.width, this.height, url, this._img_width, this._img_height, edgex, edgey);
+ }
+
+ var handle = this.handle;
+ if (handle) {
+ if (layout_change) {
+ handle.innerHTML = this._inner_command;
+ }
+ else {
+ this._updateURL(handle, url);
+ }
+ }
+ }
+ }
+ };
+
+ if (nexacro._BrowserVersion <= 7) {
+ nexacro._makeImageClipInfo = function (top, right, bottom, left) {
+ return "rect(" + top + " " + right + " " + bottom + " " + left + ")";
+ };
+ }
+ else {
+ nexacro._makeImageClipInfo = function (top, right, bottom, left) {
+ return "rect(" + top + "px," + right + "px," + bottom + "px," + left + "px)";
+ };
+ }
+
+ __pEdgeImageElement._createLeftRight_command = function (img_width, height, img_offset_y, edgex, edgey, url) {
+ var _top = (-img_offset_y);
+ var _height = height + img_offset_y + img_offset_y;
+ var _clip_top = edgey + img_offset_y;
+ var _clip_bottom = height - edgey + img_offset_y;
+
+ var str = "";
+ str += "") : ">";
+
+ if (this._use_decoration) {
+ str += nexacro.__getHTMLAttr_DecorateText(this.text);
+ }
+ else {
+ str += nexacro.__getHTMLAttr_Text(this.text, this.wordWrap || this._wordwrap_info);
+ }
+
+ str += "
";
+ return str;
+ }
+ }
+ return "";
+ };
+ _pTextBoxElement.attachHandle = function (win) {
+ if (this.name && !this._created) {
+ var handle = win._doc.getElementById(this.name);
+ if (handle) {
+ this.handle = handle;
+ this._box_node = handle;
+ handle._linked_element = this;
+ }
+ this._created = true;
+ }
+ };
+ }
+
+ _pTextBoxElement.destroy = function () {
+ this._destroyElementHandle();
+ this.owner_elem = null;
+ this._box_node = null;
+ this.parent = null;
+ this.parent_elem = null;
+ this._created = false;
+ };
+
+
+
+ _pTextBoxElement.setElementPadding = function () {
+ };
+
+
+ _pTextBoxElement.setElementTextAlign = function (textalign) {
+ if (this.textAlign != textalign) {
+ this.textAlign = textalign;
+ var box_node = this._box_node;
+
+ if (box_node) {
+ nexacro.__setDOMStyle_textAlign(box_node.style, textalign, this.rtl);
+ }
+ }
+ };
+
+ _pTextBoxElement.setElementVerticalAlign = function (verticalalign) {
+ if (this.verticalAlign != verticalalign) {
+ this.verticalAlign = verticalalign;
+ var box_node = this._box_node;
+ if (box_node) {
+ nexacro.__setDOMStyle_verticalAlign(box_node.style, verticalalign);
+ }
+ }
+ };
+
+ _pTextBoxElement.setElementText = function (text) {
+ if (this.text != text || this._use_decoration == true) {
+ this.text = text;
+ this._use_decoration = false;
+ if (this._created) {
+ if (text) {
+ if (this.handle) {
+ nexacro.__setDOMNode_Text(this._box_node, text, this.wordWrap || this._wordwrap_info);
+ }
+ else {
+ this._createElementHandle(this.owner_elem);
+ }
+ }
+ else {
+ if (this.handle) {
+ this._destroyElementHandle();
+ }
+ }
+ }
+ }
+ };
+
+ _pTextBoxElement.setElementDecorateText = function (text) {
+ if (this.text != text || this._use_decoration == false) {
+ this.text = text;
+ this._use_decoration = true;
+ if (this._created) {
+ if (text) {
+ if (this.handle) {
+ nexacro.__setDOMNode_DecorateText(this._box_node, text);
+ }
+ else {
+ this._createElementHandle(this.owner_elem);
+ }
+ }
+ else {
+ if (this.handle) {
+ this._destroyElementHandle();
+ }
+ }
+ }
+ }
+ };
+
+ _pTextBoxElement.setElementWordWrap = function (wordwrap) {
+ if (this.wordWrap != wordwrap) {
+ var oldwordwrap = this.wordWrap || this._wordwrap_info;
+ this.wordWrap = wordwrap;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNodeStyle_WordWrap(handle.style, wordwrap);
+ if (this._created && this.text && this._use_decoration == false && oldwordwrap != wordwrap) {
+ nexacro.__setDOMNode_Text(this._box_node, this.text, wordwrap);
+ }
+ }
+ }
+ };
+
+ _pTextBoxElement.setElementCSSMapInfo = function (wordwrap) {
+ if (this._wordwrap_info != wordwrap) {
+ var oldwordwrap = this.wordWrap || this._wordwrap_info;
+ this._wordwrap_info = wordwrap;
+ var handle = this.handle;
+ if (handle) {
+ if (!this.wordWrap && this.text && this._use_decoration == false && oldwordwrap != wordwrap) {
+ nexacro.__setDOMNode_Text(this._box_node, this.text, wordwrap);
+ }
+ }
+ }
+ };
+
+
+
+ nexacro.IconElement = function (parent_elem, id) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ this.id = id;
+ this.name = this.parent_elem.name + ":" + (id || "icon");
+ };
+ var _pIconElement = nexacro._createPrototype(nexacro.Element, nexacro.IconElement);
+ nexacro.IconElement.prototype = _pIconElement;
+
+
+ _pIconElement._type_name = "IconElement";
+ _pIconElement.typeselector = "nexacontentsbox";
+
+ _pIconElement.padding = null;
+ _pIconElement.textAlign = null;
+ _pIconElement.verticalAlign = null;
+ _pIconElement.icon = "";
+ _pIconElement._created = false;
+
+ _pIconElement._createElementHandle = function (owner_elem, _doc) {
+ if (this.icon && (this.icon.value != "none")) {
+ _doc = _doc || owner_elem._getRootWindowHandle();
+
+ var handle = _doc.createElement("div");
+ this.handle = handle;
+
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ var handle_style = handle.style;
+
+ this._refreshCommonStyleProps(handle_style);
+
+ var textAlign = this.textAlign;
+ if (textAlign) {
+ nexacro.__setDOMStyle_BKImageTextAlign(handle_style, textAlign);
+ }
+
+ if (this.verticalAlign) {
+ nexacro.__setDOMStyle_BKImageVerticalAlign(handle_style, this.verticalAlign);
+ }
+
+ nexacro.__setDOMStyle_BKImageUrl(handle_style, this.icon._sysurl);
+
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+ }
+ };
+
+
+
+ _pIconElement.create = function (win) {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+ this._createElementHandle(owner_elem, win._doc);
+ this._created = true;
+ }
+ };
+
+ _pIconElement.createCommand = function () {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+ if (this.icon && (this.icon.value != "none")) {
+ var handle_style = this._getCommonStyleStr();
+ var str;
+
+ handle_style += nexacro.__getHTMLStyle_BKImageUrl(this.icon._sysurl);
+
+ var classname = this._getElementClassName();
+ str = "") : ">";
+ }
+ else if (_type == 3) {
+ str = "
") : ">";
+ str += "") : ">";
+
+ if (this.iconPos == "left" || this.iconPos == "top") {
+ str += "![](" + this.icon._sysurl + ")
";
+ str += "";
+ }
+ else {
+ str += "
";
+ str += "
";
+ }
+
+ str += "
";
+ }
+ return str;
+ }
+ }
+ return "";
+ };
+ _pIconTextElement.attachHandle = function (win) {
+ if (this.name && !this._created) {
+ var handle = win._doc.getElementById(this.name);
+ if (handle) {
+ this.handle = handle;
+ handle._linked_element = this;
+
+ var _type = this._contents_type, box_node;
+ if (_type == 1) {
+ box_node = handle.firstChild.firstChild.firstChild;
+ this._box_node = box_node;
+ }
+ else if (this._contents_type == 3) {
+ box_node = handle.firstChild.firstChild.firstChild;
+ this._box_node = box_node;
+ if (this.iconPos == "left" || this.iconPos == "top") {
+ this._icon_node = box_node.firstChild;
+ this._text_node = box_node.lastChild;
+ }
+ else {
+ this._text_node = box_node.firstChild;
+ this._icon_node = box_node.lastChild;
+ }
+ }
+ }
+ this._created = true;
+ }
+ };
+ }
+ else {
+ _pIconTextElement.createCommand = function () {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+
+ var _type = this._contents_type;
+ if (_type) {
+ var handle_style = this._getCommonStyleStr();
+ var box_style = "";
+ var text_style = "";
+ var value_str = "";
+
+
+ if (_type == 1 || _type == 3) {
+ if (this.textAlign) {
+ box_style += nexacro.__getHTMLStyle_textAlign(this.textAlign, this.rtl);
+ }
+ if (this.verticalAlign) {
+ box_style += nexacro.__getHTMLStyle_verticalAlign(this.verticalAlign);
+ }
+ }
+ else if (_type == 2) {
+ var textAlign = this.textAlign;
+ if (textAlign || this.verticalAlign) {
+ box_style += nexacro.__getHTMLStyle_BKImageAlign(textAlign, this.verticalAlign);
+ }
+ }
+
+ if (_type == 1) {
+ if (this._use_decoration) {
+ value_str = nexacro.__getHTMLAttr_DecorateText(this.text);
+ }
+ else {
+ value_str = nexacro.__getHTMLAttr_Text(this.text, this.wordWrap || this._wordwrap_info);
+ }
+ }
+ else if (_type == 2) {
+ box_style += nexacro.__getHTMLStyle_BKImageUrl(this.icon._sysurl);
+ }
+ else if (_type == 3) {
+ if (this.textwidth) {
+ text_style += nexacro.__getHTMLStyle_TextWidth(parseInt(this.textwidth));
+ }
+ if (this.textPadding) {
+ text_style += nexacro.__getHTMLStyle_PaddingObject(this.textPadding, this.rtl);
+ }
+
+ if (this.iconPos == "left" || this.iconPos == "right") {
+ text_style += nexacro.__getHTMLStyle_Display("inline-block");
+ }
+
+ if (this._use_decoration) {
+ value_str = nexacro.__getHTMLAttr_DecorateText(this.text);
+ }
+ else {
+ value_str = nexacro.__getHTMLAttr_Text(this.text, this.wordWrap || this._wordwrap_info);
+ }
+ }
+
+ var aria_hidden = "";
+ if (nexacro._enableaccessibility && nexacro._accessibilitytype == 4) {
+ aria_hidden = " aria-hidden = 'true' ";
+ }
+
+ var classname = this._getElementClassName(), str = "";
+ if (_type == 1) {
+ str = "
") : ">";
+ str += value_str + "
";
+ }
+ else if (_type == 2) {
+ str = "
") : ">";
+ str += "
";
+ }
+ else if (_type == 3) {
+ str = "
") : ">";
+
+ if (this.iconPos == "left" || this.iconPos == "top") {
+ str += "
";
+ str += "
") : ">";
+ str += value_str + "
";
+ }
+ else {
+ str += "
") : ">";
+ str += value_str + "
";
+ str += "
";
+ }
+
+ str += "
";
+ }
+ return str;
+ }
+ }
+ return "";
+ };
+ _pIconTextElement.attachHandle = function (win) {
+ if (this.name && !this._created) {
+ var handle = win._doc.getElementById(this.name);
+ if (handle) {
+ this.handle = handle;
+ handle._linked_element = this;
+
+ this._box_node = handle;
+ if (this._contents_type == 3) {
+ var box_node = handle;
+ if (this.iconPos == "left" || this.iconPos == "top") {
+ this._icon_node = box_node.firstChild;
+ this._text_node = box_node.lastChild;
+ }
+ else {
+ this._text_node = box_node.firstChild;
+ this._icon_node = box_node.lastChild;
+ }
+ }
+ }
+ this._created = true;
+ }
+ };
+ }
+
+ _pIconTextElement.destroy = function () {
+ this._destroyElementHandle();
+
+ this.owner_elem = null;
+ this._box_node = null;
+ this._text_node = null;
+ this._icon_node = null;
+
+ this.parent = null;
+ this.parent_elem = null;
+ this._created = false;
+ };
+
+
+ _pIconTextElement.setElementPadding = function (padding) {
+ if (this.padding != padding) {
+ this.padding = padding;
+ var handle = this.handle;
+
+ if (handle) {
+ nexacro.__setDOMStyle_PaddingObject(handle.style, padding, this.rtl);
+ }
+ }
+ };
+
+ _pIconTextElement.setElementTextAlign = function (textalign) {
+ if (this.textAlign != textalign) {
+ this.textAlign = textalign;
+
+ var box_node = this._box_node;
+
+ if (box_node) {
+ var _type = this._contents_type;
+ if (_type == 1 || _type == 3) {
+ nexacro.__setDOMStyle_textAlign(box_node.style, textalign, this.rtl);
+ }
+ else {
+ if (textalign) {
+ nexacro.__setDOMStyle_BKImageTextAlign(box_node.style, textalign);
+ }
+ else {
+ nexacro.__clearDOMStyle_BKImageTextAlign(box_node.style);
+ }
+ }
+ }
+ }
+ };
+ _pIconTextElement.setElementVerticalAlign = function (verticalalign) {
+ if (this.verticalAlign != verticalalign) {
+ this.verticalAlign = verticalalign;
+
+ var box_node = this._box_node;
+ if (box_node) {
+ var _type = this._contents_type;
+ if (_type != 2) {
+ nexacro.__setDOMStyle_verticalAlign(box_node.style, verticalalign);
+ }
+ else {
+ if (verticalalign) {
+ nexacro.__setDOMStyle_BKImageVerticalAlign(box_node.style, verticalalign);
+ }
+ else {
+ nexacro.__clearDOMStyle_BKImageVerticalAlign(box_node.style);
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementTextPadding = function (textPadding) {
+ if (this.textPadding != textPadding) {
+ this.textPadding = textPadding;
+ var text_node = this._text_node;
+
+ if (text_node) {
+ nexacro.__setDOMStyle_PaddingObject(text_node.style, textPadding, this.rtl);
+ }
+ }
+ };
+
+ _pIconTextElement.setElementTextWidth = function (textwidth) {
+ if (this.textwidth != textwidth) {
+ this.textwidth = textwidth;
+
+ var text_node = this._text_node;
+ if (text_node) {
+ var _type = this._contents_type;
+ if (_type == 3) {
+ var _textwidth = parseInt(textwidth);
+ if (_textwidth > 0) {
+ nexacro.__setDOMStyle_TextWidth(text_node.style, _textwidth);
+ }
+ else {
+ nexacro.__clearDOMStyle_TextWidth(text_node.style);
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementText = function (text) {
+ if (this.text !== text || this._use_decoration == true) {
+ this.text = text;
+ this._use_decoration = false;
+
+ var _type = 0;
+ var icon_url = this.icon ? (this.icon.value == "none" ? undefined : this.icon._sysurl) : undefined;
+ if (icon_url && text) {
+ _type = 3;
+ }
+ else if (icon_url) {
+ _type = 2;
+ }
+ else if (text) {
+ _type = 1;
+ }
+
+ if (this._contents_type != _type) {
+ this._contents_type = _type;
+ if (this._created) {
+ this._destroyElementHandle();
+ this._createElementHandle(this.owner_elem);
+ }
+ }
+ else {
+ if (this._created) {
+ if (_type == 1) {
+ var box_node = this._box_node;
+ if (box_node) {
+ nexacro.__setDOMNode_Text(box_node, text, this.wordWrap || this._wordwrap_info);
+ }
+ }
+ else if (_type == 3) {
+ var text_node = this._text_node;
+ if (text_node) {
+ nexacro.__setDOMNode_Text(text_node, text, this.wordWrap || this._wordwrap_info);
+ }
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementDecorateText = function (text) {
+ if (this.text != text || this._use_decoration == false) {
+ this.text = text;
+ this._use_decoration = true;
+
+ var _type = 0;
+ var icon_url = this.icon ? (this.icon.value == "none" ? undefined : this.icon._sysurl) : undefined;
+ if (icon_url && text) {
+ _type = 3;
+ }
+ else if (icon_url) {
+ _type = 2;
+ }
+ else if (text) {
+ _type = 1;
+ }
+
+ if (this._contents_type != _type) {
+ this._contents_type = _type;
+ if (this._created) {
+ this._destroyElementHandle();
+ this._createElementHandle(this.owner_elem);
+ }
+ }
+ else {
+ if (this._created) {
+ if (_type == 1) {
+ var box_node = this._box_node;
+ nexacro.__setDOMNode_DecorateText(box_node, text);
+ }
+ else if (_type == 3) {
+ var text_node = this._text_node;
+ nexacro.__setDOMNode_DecorateText(text_node, text);
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementWordWrap = function (wordwrap) {
+ if (this.wordWrap != wordwrap) {
+ var oldwordwrap = this.wordWrap || this._wordwrap_info;
+ this.wordWrap = wordwrap;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNodeStyle_WordWrap(handle.style, wordwrap);
+ if (this._created && this.text && this._use_decoration == false && oldwordwrap != wordwrap) {
+ var _type = this._contents_type;
+ if (_type == 1) {
+ var box_node = this._box_node;
+ if (box_node) {
+ nexacro.__setDOMNode_Text(box_node, this.text, wordwrap);
+ }
+ }
+ else if (_type == 3) {
+ var text_node = this._text_node;
+ if (text_node) {
+ nexacro.__setDOMNode_Text(text_node, this.text, wordwrap);
+ }
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementCSSMapInfo = function (wordwrap) {
+ if (this._wordwrap_info != wordwrap) {
+ var oldwordwrap = this.wordWrap || this._wordwrap_info;
+ this._wordwrap_info = wordwrap;
+ var handle = this.handle;
+ if (handle) {
+ if (!this.wordWrap && this.text && this._use_decoration == false && oldwordwrap != wordwrap) {
+ var _type = this._contents_type;
+ if (_type == 1) {
+ var box_node = this._box_node;
+ if (box_node) {
+ nexacro.__setDOMNode_Text(box_node, this.text, wordwrap);
+ }
+ }
+ else if (_type == 3) {
+ var text_node = this._text_node;
+ if (text_node) {
+ nexacro.__setDOMNode_Text(text_node, this.text, wordwrap);
+ }
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementIcon = function (icon) {
+ if (this.icon != icon) {
+ this.icon = icon;
+
+ var icon_url = icon ? (icon.value == "none" ? undefined : icon._sysurl) : undefined;
+
+ var _type = 0;
+ if (icon_url && this.text) {
+ _type = 3;
+ }
+ else if (icon_url) {
+ _type = 2;
+ }
+ else if (this.text) {
+ _type = 1;
+ }
+
+ if (this._contents_type != _type) {
+ this._contents_type = _type;
+ if (this._created) {
+ this._createElementHandle(this.owner_elem);
+ }
+ }
+ else {
+ if (this._created) {
+ if (_type == 2) {
+ var box_node = this._box_node;
+ nexacro.__setDOMStyle_BKImageUrl(box_node.style, icon_url);
+ }
+ else if (_type == 3) {
+ var icon_node = this._icon_node;
+ nexacro.__setDOMNode_ImageUrl(icon_node, icon_url);
+ }
+ }
+ }
+ }
+ };
+
+ _pIconTextElement.setElementIconPos = function (icon_pos) {
+ var pos = ["left", "right", "top", "bottom"];
+ if (pos.indexOf(icon_pos) < 0) {
+ icon_pos = "left";
+ }
+
+ if (this.iconPos != icon_pos) {
+ var oldpos = this.iconPos;
+ this.iconPos = icon_pos;
+
+ if (this._created && this._contents_type == 3) {
+ var text_node = this._text_node;
+ var icon_node = this._icon_node;
+ var box_node = this._box_node;
+
+ if (oldpos) {
+ if (icon_pos == "left" || icon_pos == "right") {
+ if (oldpos == "top" || oldpos == "bottom") {
+ nexacro.__setDOMStyle_Display(text_node.style, "inline-block");
+ }
+ }
+ else {
+ if (oldpos == "left" || oldpos == "right") {
+ nexacro.__setDOMStyle_Display(text_node.style, "block");
+ }
+ }
+
+ if (icon_pos == "left" || icon_pos == "top") {
+ if (oldpos == "right" || oldpos == "bottom") {
+ nexacro.__appendDOMNode(box_node, text_node);
+ }
+ }
+ else {
+ if (oldpos == "left" || oldpos == "top") {
+ nexacro.__appendDOMNode(box_node, icon_node);
+ }
+ }
+ }
+ else {
+ switch (icon_pos) {
+ case "left":
+ nexacro.__setDOMStyle_Display(text_node.style, "inline-block");
+ nexacro.__appendDOMNode(box_node, text_node);
+ break;
+ case "right":
+ nexacro.__setDOMStyle_Display(text_node.style, "inline-block");
+ break;
+ case "top":
+ nexacro.__appendDOMNode(box_node, text_node);
+ break;
+ }
+ }
+ }
+ }
+ };
+
+ nexacro.ImageElement = function (parent_elem, id) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ this.id = id;
+ this.name = this.parent_elem.name + ":" + (id || "image");
+ };
+ var _pImageElement = nexacro._createPrototype(nexacro.Element, nexacro.ImageElement);
+ nexacro.ImageElement.prototype = _pImageElement;
+
+ _pImageElement._type_name = "ImageElement";
+ _pImageElement.typeselector = "nexaimagebox";
+
+ _pImageElement.image = null;
+
+ _pImageElement.padding = null;
+ _pImageElement._created = false;
+
+
+ _pImageElement._createElementHandle = function (owner_elem, _doc) {
+ if (this.image) {
+ _doc = _doc || owner_elem._getRootWindowHandle();
+ var handle = _doc.createElement("img");
+ if (handle) {
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ this.handle = handle;
+ nexacro.__setDOMNode_Alt(handle, this.parent_elem.accessibilitylabel ? this.parent_elem.accessibilitylabel : this.parent_elem.linkedcontrol.id);
+ var handle_style = handle.style;
+
+ this._refreshCommonStyleProps(handle_style);
+
+ nexacro.__setDOMNode_ImageUrl(handle, this.image._sysurl);
+ nexacro.__setDOMStyle_Pos(handle.style, this.left, this.top);
+
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+ }
+ }
+ };
+
+
+ _pImageElement.create = function (win) {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && owner_elem.handle && !this.handle) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+ this._createElementHandle(owner_elem, win._doc);
+ this._created = true;
+ }
+ };
+
+ _pImageElement.createCommand = function () {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+
+ if (this.image) {
+ var handle_style = this._getCommonStyleStr();
+ var str = "
![]()
") : "/>";
+ return str;
+ }
+ }
+ return "";
+ };
+ _pImageElement.attachHandle = function (win) {
+ if (this.name && !this._created) {
+ var handle = win._doc.getElementById(this.name);
+ if (handle) {
+ this.handle = handle;
+ handle._linked_element = this;
+ }
+ this._created = true;
+ }
+ };
+
+ _pImageElement.destroy = function () {
+ this._destroyElementHandle();
+ this.owner_elem = null;
+ this.parent = null;
+ this.parent_elem = null;
+ this._created = false;
+ };
+
+
+
+ _pImageElement.setElementPadding = function (padding) {
+ if (this.padding != padding) {
+ this.padding = padding;
+ var handle = this.handle;
+
+ if (handle) {
+ nexacro.__setDOMStyle_PaddingObject(handle.style, padding, this.rtl);
+ }
+ }
+ };
+
+
+ _pImageElement.setElementImage = function (image) {
+ if (this.image != image) {
+ this.image = image;
+
+ if (image) {
+ if (this.handle) {
+ nexacro.__setDOMNode_ImageUrl(this.handle, image._sysurl);
+ }
+ else if (this.owner_elem) {
+ this._createElementHandle(this.owner_elem);
+ }
+ }
+ else {
+ if (this.handle) {
+ this._destroyElementHandle();
+ }
+ }
+ }
+ _pImageElement.getImageCount = nexacro._emptyFn;
+ _pImageElement.setImageIndex = nexacro._emptyFn;
+ };
+
+
+ nexacro.InputElement = function (parent_elem, id) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ this.id = id;
+ this.name = this.parent_elem.name + ":" + (id || "input");
+
+ this._composer = new nexacro._CompositionState();
+ this._imelocale = new nexacro._ImeLocale();
+ };
+
+ var _pInputElement = nexacro._createPrototype(nexacro.Element, nexacro.InputElement);
+ nexacro.InputElement.prototype = _pInputElement;
+
+ _pInputElement._type_name = "InputElement";
+ _pInputElement.typeselector = "nexainput";
+
+ _pInputElement.textAlign = null;
+ _pInputElement.padding = null;
+ _pInputElement.caretcolor = null;
+ _pInputElement.selectcolor = null;
+ _pInputElement.selectbackground = null;
+ _pInputElement.compositecolor = null;
+
+ _pInputElement.enable = true;
+ _pInputElement.useime = "global";
+ _pInputElement.imemode = "auto";
+ _pInputElement.readonly = false;
+ _pInputElement.maxlength = 0;
+ _pInputElement.autoskip = false;
+ _pInputElement.autoselect = false;
+ _pInputElement.value = null;
+ _pInputElement.defaultvalue = "";
+ _pInputElement.displaynulltext = "";
+ _pInputElement.displayinvalidtext = undefined;
+ _pInputElement.tabindentsize = 4;
+ _pInputElement.usesoftkeyboard = true;
+ _pInputElement.inputtype = "text";
+
+ _pInputElement._keypad_type = "text";
+
+ _pInputElement._is_focused = false;
+ _pInputElement._is_sys_focused = false;
+
+ _pInputElement._is_input_touchstart = false;
+ _pInputElement._is_input_element = true;
+ _pInputElement._is_invalid_value = false;
+
+ _pInputElement._accept_focus_process = true;
+ _pInputElement._accept_blur_process = true;
+
+ _pInputElement._accept_keypadrestore_process = false;
+
+ _pInputElement._zerolength_value = undefined;
+ _pInputElement._input_text = "";
+ _pInputElement._disabled_color = null;
+ _pInputElement._imedisable = false;
+
+ _pInputElement._checkmax_editing_only = true;
+ _pInputElement._last_selection_range = null;
+
+ _pInputElement._BeforeinputState = {
+ };
+ _pInputElement._BeforeinputState.PASS = 0;
+ _pInputElement._BeforeinputState.CANCEL = 1;
+ _pInputElement._BeforeinputState.CONVERT_UPPER = 2;
+ _pInputElement._BeforeinputState.CONVERT_LOWER = 3;
+ _pInputElement._BeforeinputState.REPLACE = 4;
+ _pInputElement._BeforeinputState.MAXLENGTH = 5;
+
+ _pInputElement._beforeinput_result_data = null;
+ _pInputElement._beforeinput_result_pos = null;
+ _pInputElement._beforeinput_result_insert_data = null;
+
+ _pInputElement._use_propertychange_evt = false;
+ _pInputElement._delay_pos = null;
+
+ _pInputElement._forced_fire_event_list = [];
+ _pInputElement._paste_caret_pos = null;
+
+ _pInputElement._status_csspseudoclass = {
+ AUTOFILL : 0
+ };
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion <= 8) {
+ _pInputElement.MOUSE_LBUTTON = 1;
+ _pInputElement.MOUSE_MBUTTON = 4;
+ _pInputElement.MOUSE_RBUTTON = 2;
+ }
+ else {
+ _pInputElement.MOUSE_LBUTTON = 0;
+ _pInputElement.MOUSE_MBUTTON = 1;
+ _pInputElement.MOUSE_RBUTTON = 2;
+ }
+
+
+ _pInputElement._use_html_maxlength = false;
+ _pInputElement._skip_sys_keyinput = false;
+ _pInputElement._skip_check_imelocale = false;
+ _pInputElement._force_focus = false;
+
+ if (nexacro._Browser == "Chrome" && nexacro._BrowserVersion >= 60) {
+ _pInputElement._use_event_beforeinput = true;
+ }
+ else {
+ _pInputElement._use_event_beforeinput = false;
+ }
+
+ if (window.AnimationEvent) {
+ _pInputElement._use_event_animation = true;
+ }
+ else {
+ _pInputElement._use_event_animation = false;
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 10) {
+ _pInputElement._evtorder_compositionend_is_last = true;
+ }
+ else {
+ _pInputElement._evtorder_compositionend_is_last = false;
+ }
+
+ if ((nexacro._Browser == "IE" && (nexacro._BrowserType == "Edge" || nexacro._BrowserVersion == 9)) || nexacro._OS == "iOS") {
+ _pInputElement._evtfire_oninput_after_compositionend = false;
+ }
+ else {
+ _pInputElement._evtfire_oninput_after_compositionend = true;
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion == 9) {
+ _pInputElement._evtfire_oninput_only_when_cut = true;
+ }
+ else {
+ _pInputElement._evtfire_oninput_only_when_cut = false;
+ }
+
+ if ((nexacro._OS == "iOS" && nexacro._Browser == "MobileSafari") || (nexacro._OS == "Mac OS" && nexacro._Browser == "Safari")) {
+ _pInputElement._apple_default_browser = true;
+ }
+ else {
+ _pInputElement._apple_default_browser = false;
+ }
+
+ if (nexacro._OS == "Android" && nexacro._Browser == "Chrome" && nexacro._BrowserVersion <= 34) {
+ _pInputElement._evtfire_oninput_only_when_backspacekey = true;
+ }
+ else {
+ _pInputElement._evtfire_oninput_only_when_backspacekey = false;
+ }
+ if (nexacro._Browser == "IE") {
+ if (nexacro._BrowserVersion > 9 || nexacro._BrowserType == "Edge") {
+ _pInputElement._use_scroll_referesh = true;
+ }
+ else {
+ _pInputElement._use_scroll_referesh = false;
+ }
+ }
+ else if (nexacro._OS == "iOS") {
+ _pInputElement._use_scroll_referesh = true;
+ }
+ else {
+ _pInputElement._use_scroll_referesh = false;
+ }
+
+ if (nexacro._OS == "iOS" && (nexacro._SystemType == "iphone" || nexacro._SystemType == "ipad")) {
+ _pInputElement._NUMERIC_KEYPAD_TYPE = "number";
+ }
+ else if (nexacro._OS == "iOS" || nexacro._OS == "Android" || nexacro._OS == "Windows Phone") {
+ _pInputElement._NUMERIC_KEYPAD_TYPE = "tel";
+ }
+ else {
+ _pInputElement._NUMERIC_KEYPAD_TYPE = "text";
+ }
+
+ if (nexacro._OS == "Android") {
+ _pInputElement._INDICATOR_WIDTH = 32;
+ }
+ else {
+ _pInputElement._INDICATOR_WIDTH = 0;
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion == 8) {
+ _pInputElement._check_imetype_composing_status = true;
+ }
+ else {
+ _pInputElement._check_imetype_composing_status = false;
+ }
+
+ if (nexacro._Browser != "IE" || (nexacro._Browser == "IE" && nexacro._BrowserVersion > 8)) {
+ _pInputElement._use_node_selection_range = true;
+ }
+ else {
+ _pInputElement._use_node_selection_range = false;
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 9) {
+ _pInputElement._createElementHandle = function (owner_elem, _doc) {
+ owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ var handle_style = this._getCommonStyleStr();
+
+ if (!this.enable) {
+ handle_style += nexacro.__getHTMLStyle_Enable(this.enable, this._disabled_color);
+ }
+
+ if (this.textAlign) {
+ handle_style += nexacro.__getHTMLStyle_textAlign(this.textAlign, this.rtl);
+ }
+
+ if (this.padding) {
+ handle_style += nexacro.__getHTMLStyle_PaddingObject(this.padding, this.rtl);
+ }
+
+ if (this.imemode) {
+ handle_style += nexacro.__getHTMLStyle_ImeMode(this.imemode);
+ }
+
+ handle_style += this._getElementDefaultLineHeight();
+
+ var handle_attr = nexacro.__getHTMLAttr_Enable(this.enable) +
+ nexacro.__getHTMLAttr_ReadOnly(this.readonly);
+ if (this.maxlength > 0 && this._use_html_maxlength) {
+ handle_attr += nexacro.__getHTMLAttr_MaxLength(this.maxlength);
+ }
+
+ var str = "
0 && this._use_html_maxlength) {
+ nexacro.__setDOMNode_MaxLength(handle, this.maxlength);
+ }
+
+ if (nexacro._enableaccessibility) {
+ nexacro.__setDOMAccessibility_LabelBy(handle, owner_elem.name);
+
+ if (nexacro._accessibilitytype == 4 || nexacro._accessibilitytype == 5) {
+ nexacro.__setDOMAccessibility_Role(handle, owner_elem.name);
+ }
+ }
+
+ nexacro.__setDOMNode_Autocomplete(handle, "off");
+
+ if (this.handle) {
+ nexacro.__appendDOMNode(owner_elem.dest_handle, this.handle);
+ }
+ };
+ }
+
+ _pInputElement.create = function (win) {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && owner_elem.handle && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+ this._createElementHandle(owner_elem, win._doc);
+ this._bindSysEvent();
+ this._created = true;
+ }
+ };
+
+ _pInputElement._destroyInputHandle = function () {
+ if (this.handle) {
+ var dest_handle = (this.owner_elem ? this.owner_elem.dest_handle : null);
+ this.handle._linked_element = null;
+
+ nexacro.__removeDOMNode(dest_handle, this.handle);
+
+ this.handle = null;
+ }
+ };
+
+ _pInputElement.destroy = function () {
+ if (this._restore_scrollpos_timer > 0) {
+ clearTimeout(this._restore_scrollpos_timer);
+ this._restore_scrollpos_timer = 0;
+ }
+
+
+ this._unbindSysEvent();
+
+ this._destroyInputHandle();
+
+ return nexacro.Element.prototype.destroy.call(this);
+ };
+
+ _pInputElement.createCommand = function () {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+
+ var handle_style = this._getCommonStyleStr();
+
+ if (!this.enable) {
+ handle_style += nexacro.__getHTMLStyle_Enable(this.enable, this._disabled_color);
+ }
+
+ if (this.textAlign) {
+ handle_style += nexacro.__getHTMLStyle_textAlign(this.textAlign, this.rtl);
+ }
+
+ if (this.padding) {
+ handle_style += nexacro.__getHTMLStyle_PaddingObject(this.padding, this.rtl);
+ }
+
+ if (this.imemode) {
+ if (this._imedisable) {
+ handle_style += nexacro.__getHTMLStyle_ImeMode("disabled");
+ }
+ else {
+ handle_style += nexacro.__getHTMLStyle_ImeMode(this.imemode);
+ }
+ }
+
+ handle_style += this._getElementDefaultLineHeight();
+
+ var handle_attr = nexacro.__getHTMLAttr_Enable(this.enable) +
+ nexacro.__getHTMLAttr_ReadOnly(this.readonly);
+ if (this.maxlength > 0 && this._use_html_maxlength) {
+ handle_attr += nexacro.__getHTMLAttr_MaxLength(this.maxlength);
+ }
+
+ var str = "
= 0 || this.top >= 0) {
+ str += nexacro.__getHTMLStyle_Pos(this.left, this.top, bPositionRtl);
+ }
+ if (this.width >= 0 && this.height >= 0) {
+ str += nexacro.__getHTMLStyle_Size(this.inputtype == "date" ? this.width + this._INDICATOR_WIDTH : this.width, this.height);
+ }
+
+ if (this.color) {
+ str += nexacro.__getHTMLStyle_ColorObject(this.color);
+ }
+ if (this.font) {
+ str += nexacro.__getHTMLStyle_FontObject(this.font);
+ }
+ if (this.wordSpacing) {
+ str += nexacro.__getHTMLStyle_WordSpacingObject(this.wordSpacing);
+ }
+ if (this.letterSpacing) {
+ str += nexacro.__getHTMLStyle_LetterSpacingObject(this.letterSpacing);
+ }
+ if (this.textDecoration) {
+ str += nexacro.__getHTMLStyle_TextDecorationObject(this.textDecoration);
+ }
+ if (this.rtl != undefined) {
+ str += nexacro.__getHTMLStyle_Direction(this.rtl);
+ }
+ if (this.wordWrap) {
+ str += nexacro.__getHTMLStyle_WordWrap(this.wordWrap);
+ }
+ return str;
+ };
+
+ _pInputElement._refreshCommonStyleProps = function (handle_style) {
+ var bPositionRtl = this._isParentRtl();
+
+ if (!this.visible) {
+ nexacro.__setDOMStyle_Visible(handle_style, false);
+ }
+
+ if (this.display == "none") {
+ nexacro.__setDOMStyle_Display(handle_style, "none");
+ }
+
+ {
+
+ if (this._use_translate_move) {
+ nexacro.__setDOMStyle_Pos(handle_style, 0, 0, bPositionRtl);
+ nexacro.__setDOMStyle_Translate(handle_style, this.left, this.top, this.rtl);
+ }
+ else {
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top, bPositionRtl);
+ }
+ }
+
+ var linked_control = this.linkedcontrol;
+ if (!(linked_control && linked_control._is_frame && (linked_control._is_main && !nexacro._allow_default_pinchzoom))) {
+ if (this.width && this.height) {
+ nexacro.__setDOMStyle_Size(handle_style, this.inputtype == "date" ? this.width + this._INDICATOR_WIDTH : this.width, this.height);
+ }
+ }
+
+ if (this.color) {
+ nexacro.__setDOMStyle_ColorObject(handle_style, this.color);
+ }
+ if (this.font) {
+ nexacro.__setDOMStyle_FontObject(handle_style, this.font);
+ }
+ if (this.wordSpacing) {
+ nexacro.__setDOMStyle_WordSpacingObject(handle_style, this.wordSpacing);
+ }
+ if (this.letterSpacing) {
+ nexacro.__setDOMStyle_LetterSpacingObject(handle_style, this.letterSpacing);
+ }
+ if (this.textDecoration) {
+ nexacro.__setDOMStyle_TextDecorationObject(handle_style, this.textDecoration);
+ }
+
+ if (this.rtl !== undefined) {
+ nexacro.__setDOMStyle_Direction(handle_style, this.rtl);
+ }
+ if (this.wordWrap) {
+ nexacro.__setDOMStyle_WordWrap(handle_style, this.wordWrap);
+ }
+ };
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 10) {
+ _pInputElement.setElementSize = function (width, height) {
+ if (this.width != width || this.height != height) {
+ this.width = width;
+ this.height = height;
+
+ if (width < 0) {
+ width = 0;
+ }
+ if (height < 0) {
+ height = 0;
+ }
+
+ var handle = this.handle;
+ if (handle) {
+ if (width && height) {
+ nexacro.__setDOMStyle_Size(handle.style, width - 1, height);
+
+ setTimeout(function () {
+ nexacro.__setDOMStyle_Size(handle.style, width, height);
+ }, 0);
+ }
+ else {
+ nexacro.__clearDOMStyle_Size(handle.style);
+ }
+
+ this._setElementDefaultLineHeight();
+ }
+ }
+ };
+ }
+ else if (nexacro._OS == "Android") {
+ _pInputElement.setElementSize = function (width, height) {
+ if (this.width != width || this.height != height) {
+ this.width = width;
+ this.height = height;
+
+ if (width < 0) {
+ width = 0;
+ }
+ if (height < 0) {
+ height = 0;
+ }
+
+ if (this.inputtype == "date") {
+ width += this._INDICATOR_WIDTH;
+ }
+
+ var handle = this.handle;
+ if (handle) {
+ if (width && height) {
+ nexacro.__setDOMStyle_Size(handle.style, width, height);
+ }
+ else {
+ nexacro.__clearDOMStyle_Size(handle.style);
+ }
+
+ this._setElementDefaultLineHeight();
+ }
+ }
+ };
+ }
+ else {
+ _pInputElement.setElementSize = function (width, height) {
+ if (this.width != width || this.height != height) {
+ this.width = width;
+ this.height = height;
+
+ if (width < 0) {
+ width = 0;
+ }
+ if (height < 0) {
+ height = 0;
+ }
+
+ var handle = this.handle;
+ if (handle) {
+ if (width && height) {
+ nexacro.__setDOMStyle_Size(handle.style, width, height);
+ }
+ else {
+ nexacro.__clearDOMStyle_Size(handle.style);
+ }
+
+ this._setElementDefaultLineHeight();
+ }
+ }
+ };
+ }
+
+ _pInputElement.setElementTextAlign = function (textalign) {
+ if (this.textAlign != textalign) {
+ this.textAlign = textalign;
+ var handle = this.handle;
+
+ if (handle) {
+ nexacro.__setDOMStyle_textAlign(handle.style, textalign, this.rtl);
+ }
+ }
+ };
+
+ _pInputElement.setElementPadding = function (padding) {
+ if (this.padding != padding) {
+ this.padding = padding;
+ var handle = this.handle;
+
+ if (handle) {
+ nexacro.__setDOMStyle_PaddingObject(handle.style, padding, this.rtl);
+ }
+ }
+ };
+
+ _pInputElement.setElementCaretColor = function (color) {
+ if (this.caretcolor != color) {
+ this.caretcolor = color;
+ var input_handle = this.handle;
+ if (input_handle) {
+ }
+ }
+ };
+
+ _pInputElement.setElementSelectColor = function (color) {
+ this.selectcolor = color;
+ };
+
+ _pInputElement.setElementSelectBackgroundColor = function (color) {
+ this.selectbackground = color;
+ };
+
+ _pInputElement.setElementCompositeColor = function (color) {
+ this.compositecolor = color;
+ };
+
+ _pInputElement.setElementTabindentSize = function (indent) {
+ this.tabindentsize = indent;
+ };
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion <= 8) {
+ _pInputElement._setElementDefaultLineHeight = function () {
+ if (this.handle) {
+ nexacro.__setDOMStyle_LineHeightObject(this.handle.style, nexacro.CSSValueObject(this.height + "px"));
+ }
+ };
+
+ _pInputElement._getElementDefaultLineHeight = function () {
+ return nexacro.__getHTMLStyle_lineHeight(this.height + "px");
+ };
+ }
+ else {
+ _pInputElement._setElementDefaultLineHeight = function () {
+ if (this.handle) {
+ nexacro.__setDOMStyle_LineHeightObject(this.handle.style, nexacro.CSSValueObject("100%"));
+ }
+ };
+
+ _pInputElement._getElementDefaultLineHeight = function () {
+ return nexacro.__getHTMLStyle_lineHeight("100%");
+ };
+ }
+
+ _pInputElement.setElementEnable = function (enable, color) {
+ if (this.enable != enable) {
+ this.enable = enable;
+
+ if (!enable) {
+ this._disabled_color = color;
+ }
+ else {
+ this._disabled_color = null;
+ }
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ nexacro.__setDOMNode_Enable(input_handle, enable);
+ nexacro.__setDOMStyle_ColorObject(input_handle.style, this._disabled_color);
+ }
+ }
+ };
+
+ _pInputElement.setElementReadonly = function (readonly) {
+ if (this.readonly != readonly) {
+ this.readonly = readonly;
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ nexacro.__setDOMNode_ReadOnly(input_handle, readonly);
+ }
+ }
+ };
+
+ _pInputElement.setElementAutoSkip = function (v) {
+ if (this.autoskip != v) {
+ this.autoskip = v;
+ }
+ };
+
+ _pInputElement.setElementAutoSelect = function (v) {
+ if (this.autoselect != v) {
+ this.autoselect = v;
+ }
+ };
+
+ _pInputElement.setElementMaxLength = function (length) {
+ if (this.maxlength != length) {
+ this.maxlength = length;
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (this._use_html_maxlength) {
+ nexacro.__setDOMNode_MaxLength(input_handle, (length > 0) ? length : 65535);
+ }
+
+ var text = this.getElementText();
+ if (this._is_focused || !this._checkmax_editing_only) {
+ if (this.maxlength > 0 && text.length > this.maxlength) {
+ text = text.substring(0, this.maxlength);
+ this._updateInputValue(text);
+ }
+ }
+ }
+ }
+ };
+
+ _pInputElement.setElementUseSoftKeyboard = function (usesoftkeyboard) {
+ if (this.usesoftkeyboard != usesoftkeyboard) {
+ this.usesoftkeyboard = usesoftkeyboard;
+ }
+ };
+
+ _pInputElement.setElementUseIme = function (useime) {
+ if (this.useime != useime) {
+ this.useime = useime;
+ }
+ };
+
+ _pInputElement.setElementImeMode = function (imemode) {
+ if (this.imemode != imemode) {
+ this.imemode = imemode;
+ var input_handle = this.handle;
+ if (input_handle) {
+ nexacro.__setDOMNode_ImeMode(input_handle, imemode);
+ }
+ }
+ };
+
+ _pInputElement.setElementDisplayNullText = function (nulltext) {
+ var input_handle = this.handle;
+
+ if (this.displaynulltext == nulltext) {
+ return;
+ }
+
+ this.displaynulltext = nulltext;
+
+ if (input_handle) {
+ if (nexacro._isNull(this.value) && !this._is_focused) {
+ this._updateInputValue(this.displaynulltext);
+ }
+ }
+ };
+
+ _pInputElement.setElementDisplayInvalidText = function (v) {
+ if (this.displayinvalidtext == v) {
+ return;
+ }
+
+ this.displayinvalidtext = v;
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (this._is_invalid_value) {
+ this._updateInputValue(this.displayinvalidtext);
+ }
+ }
+ };
+
+ _pInputElement.setElementDefaultValue = function (value) {
+ if (value != this.defaultvalue) {
+ this.defaultvalue = value;
+ }
+ };
+
+ _pInputElement.setElementValue = function (value, bInvalidValue) {
+ var text = (nexacro._isNull(value) ? this.defaultvalue : (value + ""));
+ var inputtype = this.inputtype;
+ this._is_invalid_value = (bInvalidValue === true) ? true : false;
+
+ if (!bInvalidValue && (this.value == value) && (this._getInputValue() == text)) {
+ return;
+ }
+
+ this.value = value;
+ this._input_text = text;
+
+ var input_handle = this.handle;
+ var comp = this.parent_elem.linkedcontrol;
+ if (input_handle) {
+ if (bInvalidValue) {
+ if (!nexacro._isNull(this.displayinvalidtext) && !this._is_focused) {
+ inputtype = "text";
+ this._updateInputValue(this.displayinvalidtext);
+ }
+ else {
+ this._updateInputValue(text);
+ }
+ }
+ else {
+ this._setElementLastSelectionRange();
+
+ if (this.value || this.value === "") {
+ if (!comp._is_killfocusing && (this._is_focused || !this._checkmax_editing_only)) {
+ if (this.maxlength > 0 && text.length > this.maxlength) {
+ text = text.substring(0, this.maxlength);
+ }
+ }
+
+ this._updateInputValue(text);
+ }
+ else if (!this._is_focused && this.displaynulltext != "") {
+ inputtype = "text";
+ this._updateInputValue(this.displaynulltext);
+ }
+ else {
+ this._updateInputValue(text);
+ }
+ }
+
+ nexacro.__setDOMNode_Type(input_handle, inputtype);
+ }
+ };
+
+ _pInputElement.replaceElementText = function (value, begin, end, bselect) {
+ var input_value = this._getInputValue();
+ if (begin < 0) {
+ return;
+ }
+
+ if (end < 0) {
+ end = input_value.length;
+ }
+ if (begin > end) {
+ end = begin;
+ }
+
+ value = (value ? value : "");
+ var caretpos = begin + value.length;
+
+ var text = input_value.substring(0, begin) + value + input_value.substring(end);
+
+ if (bselect) {
+ this._updateInputValue(text, !this._processing_oninput, begin, caretpos);
+ }
+ else {
+ this._updateInputValue(text, !this._processing_oninput, caretpos);
+ }
+ };
+
+ _pInputElement.updateElementText = function (value, caretpos) {
+ value = (value ? value : "");
+ this._updateInputValue(value, !this._processing_oninput, caretpos);
+ };
+
+ _pInputElement._updateElementValue = function (value) {
+ if (this.value == value) {
+ return;
+ }
+
+ if (!value) {
+ value = this._zerolength_value;
+ }
+
+ this.value = value;
+ };
+
+ _pInputElement._setElementUseMaxLength = function (v) {
+ if ((nexacro._Browser != "IE" && nexacro._Browser != "Gecko" && nexacro._BrowserExtra != "SamsungBrowser")) {
+ this._use_html_maxlength = v;
+ }
+ else {
+ this._use_html_maxlength = false;
+ }
+ };
+
+ _pInputElement.on_updateEvtOrder_process = function () {
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 10) {
+ this._evtorder_compositionend_is_last = true;
+ }
+ else {
+ this._evtorder_compositionend_is_last = false;
+ }
+ };
+
+ if (nexacro._Browser == "IE") {
+ if (nexacro._BrowserVersion <= 8) {
+ _pInputElement._updateInputValue = function (value, fireevent, selectionStart, selectionEnd) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (this._composer && this._composer.isComposing()) {
+ input_handle.blur();
+ input_handle.focus();
+ }
+
+ var processing_flag = this._processing_oninput;
+ if (!fireevent) {
+ this._processing_oninput = true;
+ }
+
+ if (selectionStart != null && selectionStart > -1) {
+ if (selectionEnd == -1) {
+ selectionEnd = value.length;
+ }
+ if (selectionEnd == null || selectionEnd < selectionStart) {
+ selectionEnd = selectionStart;
+ }
+ }
+
+ this._selectstartpos_onprepertychange_afterupdate = selectionStart;
+ this._selectendpos_onprepertychange_afterupdate = selectionEnd;
+
+ this._input_text = value;
+ nexacro.__setDOMNode_Value(input_handle, value);
+
+ if (this instanceof nexacro.TextAreaElement && !this._is_sys_focused) {
+ this._need_reset_update_value = true;
+ }
+
+ this._selectstartpos_onprepertychange_afterupdate = undefined;
+ this._selectendpos_onprepertychange_afterupdate = undefined;
+ if (!fireevent) {
+ this._processing_oninput = processing_flag;
+ }
+ }
+ };
+ }
+ else {
+ _pInputElement._updateInputValue = function (value, fireevent, selectionStart, selectionEnd) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (this._composer && this._composer.isComposing()) {
+ this._accept_blur_process = false;
+ this._accept_focus_process = false;
+
+ input_handle.blur();
+ input_handle.focus();
+ }
+
+ this._input_text = value;
+ nexacro.__setDOMNode_Value(input_handle, value);
+
+ if (selectionStart != null && selectionStart > -1) {
+ if (selectionEnd == -1) {
+ selectionEnd = value.length;
+ }
+ if (selectionEnd == null || selectionEnd < selectionStart) {
+ selectionEnd = selectionStart;
+ }
+
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, selectionStart, selectionEnd);
+ }
+ this._setElementLastSelectionRange([selectionStart, selectionEnd]);
+ }
+
+ if (fireevent) {
+ this._fireHTMLEvent(input_handle, "input", "oninput");
+ }
+ }
+ };
+ }
+ }
+ else {
+ _pInputElement._updateInputValue = function (value, fireevent, selectionStart, selectionEnd) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (nexacro._Browser == "Chrome") {
+ if (this._composer && this._composer.isComposing()) {
+ this._composer.setStatus(nexacro._CompositionState.END, selectionEnd);
+ }
+ }
+
+ this._input_text = value;
+ nexacro.__setDOMNode_Value(input_handle, value);
+
+ if (selectionStart != null && selectionStart > -1) {
+ if (selectionEnd == -1) {
+ selectionEnd = value.length;
+ }
+ if (selectionEnd == null || selectionEnd < selectionStart) {
+ selectionEnd = selectionStart;
+ }
+
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, selectionStart, selectionEnd);
+ }
+ this._setElementLastSelectionRange([selectionStart, selectionEnd]);
+ }
+ if (fireevent) {
+ nexacro.__fireHTMLEvent(input_handle, "input", "oninput");
+ }
+ }
+ };
+ }
+
+ _pInputElement.setElementInputType = function (type, bImedisable) {
+ if (type == "number" || type == "tel") {
+ type = this._NUMERIC_KEYPAD_TYPE;
+ }
+ else if (type == "date") {
+ type = "date";
+ }
+
+ else if (type != "password") {
+ type = "text";
+ }
+
+ var input_handle = this.handle;
+ var new_handle;
+
+ if (this._imedisable != bImedisable) {
+ this._imedisable = bImedisable ? bImedisable : false;
+ if (input_handle) {
+ nexacro.__setDOMNode_ImeMode(input_handle, this._imedisable ? "disabled" : this.imemode);
+ }
+ }
+
+ if (this.inputtype != type) {
+ this._keypad_type = type;
+
+ var inputtype = (type == "number" ? "text" : type);
+ if (nexacro._OS == "Android" && (type == "number" || type == "tel")) {
+ inputtype = "tel";
+ }
+ if (this.inputtype != inputtype) {
+ this.inputtype = inputtype;
+
+ if (input_handle) {
+ new_handle = nexacro.__changeInputDOMNodeType(input_handle, inputtype);
+ if (new_handle != input_handle) {
+ this._unbindSysEvent();
+
+ new_handle._linked_element = this;
+ input_handle = this.handle = new_handle;
+
+ this._bindSysEvent();
+
+ if (this._is_focused) {
+ nexacro.__setInputDOMNodeFocus(input_handle);
+ }
+ }
+ }
+ }
+ }
+ };
+
+ if (nexacro._OS == "iOS" && nexacro._SystemType == "iphone") {
+ _pInputElement._change_to_keypad_type = function () {
+ if (this.readonly || this._is_sys_focused || this.inputtype == this._keypad_type) {
+ return;
+ }
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ var text = this._inputtext_on_inputtype = this.getElementText();
+ this._caretpos_on_inputtype = this.getElementCaretPos();
+
+ var keypad_type = this._keypad_type;
+ if (keypad_type == "number" && text) {
+ if (nexacro.isNumeric(text) == false) {
+ keypad_type = "text";
+ }
+ }
+ nexacro.__changeInputDOMNodeType(input_handle, keypad_type);
+ this._accept_keypadrestore_process = true;
+ }
+ };
+
+ _pInputElement._change_type_on_sys_focus = function (type) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ var text = this._inputtext_on_inputtype;
+ var pos = this._caretpos_on_inputtype;
+
+ nexacro.__changeInputDOMNodeType(input_handle, type);
+
+ this._updateInputValue(text ? text : "");
+ this.setElementSetSelect(pos.begin, pos.end);
+
+ this._inputtext_on_inputtype = "";
+ this._caretpos_on_inputtype = null;
+
+ this._restore_scrollpos_onclick = true;
+
+ var cur_doc = this._getRootWindowHandle();
+ var cur_win = cur_doc.defaultView || cur_doc.parentWindow;
+
+ nexacro._observeSysEvent(cur_win, "scroll", "onscroll", this._on_sys_scroll);
+ var pThis = this;
+ this._restore_scrollpos_timer = setTimeout(function () {
+ clearTimeout(pThis._restore_scrollpos_timer);
+ pThis._restore_scrollpos_timer = 0;
+
+ nexacro._stopSysObserving(cur_win, "scroll", "onscroll", pThis._on_sys_scroll);
+ pThis._restore_scrollpos_onclick = false;
+ }, 500);
+ }
+ };
+
+ _pInputElement._scrollintoview_on_sys_click = function () {
+ if (this._restore_scrollpos_onclick) {
+ if (this._restore_scrollpos_timer > 0) {
+ clearTimeout(this._restore_scrollpos_timer);
+ this._restore_scrollpos_timer = 0;
+ }
+
+ var cur_doc = this._getRootWindowHandle();
+ var cur_win = cur_doc.defaultView || cur_doc.parentWindow;
+
+ if (this._scoll_pos) {
+ cur_win.scrollTo(this._scoll_pos[0], this._scoll_pos[1]);
+ }
+ nexacro._stopSysObserving(cur_win, "scroll", "onscroll", this._on_sys_scroll);
+ this._restore_scrollpos_onclick = false;
+ }
+ };
+
+ _pInputElement._restore_keypad_type = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (this._keypad_type == "number" && this._accept_keypadrestore_process) {
+ nexacro.__changeInputDOMNodeType(input_handle, "text");
+ this._accept_keypadrestore_process = false;
+ }
+ }
+ };
+ }
+ else {
+ _pInputElement._change_to_keypad_type = nexacro._emptyFn;
+ _pInputElement._change_type_on_sys_focus = nexacro._emptyFn;
+ _pInputElement._scrollintoview_on_sys_click = nexacro._emptyFn;
+ _pInputElement._restore_keypad_type = nexacro._emptyFn;
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion > 8) {
+ _pInputElement._fireHTMLEvent = function (handle, name, onname) {
+ if (!handle) {
+ return;
+ }
+
+ var doc = handle.ownerDocument || handle.document;
+
+ var evt = nexacro.__createHTMLEvent(doc, name);
+ if (evt) {
+ this._forced_fire_event_list.push(evt.timeStamp);
+ nexacro.__despatchEvent(handle, evt);
+ }
+ };
+ }
+ else {
+ _pInputElement._fireHTMLEvent = function (handle, name, onname) {
+ nexacro.__fireHTMLEvent(handle, name, onname);
+ };
+ }
+
+ _pInputElement._applyElementFocus = function () {
+ nexacro.__setInputDOMNodeFocus(this.handle);
+ };
+
+ _pInputElement._applyMaxlength = function () {
+ var input_handle = this.handle;
+
+ if (this._checkmax_editing_only) {
+ var newValue = this.value;
+ if (!nexacro._isNull(newValue)) {
+ if (this.maxlength > 0 && newValue.length > this.maxlength) {
+ newValue = newValue.substring(0, this.maxlength);
+ }
+ }
+ else {
+ newValue = this.defaultvalue;
+ }
+
+ var domValue = this._getInputValue();
+ if (domValue !== newValue) {
+ this._updateInputValue(newValue);
+ if (nexacro._isNull(this.value)) {
+ nexacro.__setDOMNode_Type(input_handle, this.inputtype);
+ nexacro.__setDOMStyle_ColorObject(input_handle.style, "");
+ }
+ }
+ }
+ };
+
+ _pInputElement.setElementFocus = function (trigger_type, self_flag) {
+ var _doc;
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused) {
+ this._is_focused = true;
+
+ this._applyMaxlength();
+ }
+
+ if (!this._is_sys_focused) {
+ if (trigger_type == "lbutton" || trigger_type == "lbuttondown" || trigger_type == "rbuttondown" ||
+ trigger_type == "touch" || trigger_type == "tap" || trigger_type == "longpress") {
+ if (!(nexacro._OS == "iOS" && nexacro._enableaccessibility)) {
+ this._change_to_keypad_type();
+ }
+ }
+
+ if (nexacro._BrowserType == "Edge") {
+ if (self_flag !== true || trigger_type != "lbuttondown") {
+ nexacro.__setInputDOMNodeFocus(input_handle);
+ if (!this.autoselect && trigger_type != undefined && trigger_type != "lbutton") {
+ _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, 0, 0);
+ }
+ }
+ }
+ }
+ else {
+ if (nexacro._Browser == "Chrome") {
+ if (!trigger_type) {
+ _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, 0, 0);
+ }
+ }
+ }
+
+ if (!(nexacro._OS == "iOS" && this.inputtype == "date")) {
+ nexacro.__setInputDOMNodeFocus(input_handle, trigger_type);
+ }
+
+ this._restore_keypad_type();
+ }
+ }
+ else if (nexacro._Browser == "IE" && nexacro._BrowserType != "Edge" && trigger_type == "focus") {
+ if (this.inputtype != "date") {
+ nexacro.__setInputDOMNodeFocus(input_handle);
+ }
+ }
+ nexacro.__setLastFocusedElement(this);
+ }
+ };
+
+ _pInputElement.setElementBlur = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ var _doc = this._getRootWindowHandle();
+ var pThis;
+
+ if (_doc && (nexacro._Browser != "IE" || (nexacro._Browser == "IE" && nexacro._BrowserVersion >= 11))) {
+ if (nexacro._BrowserType != "Edge") {
+ if (this.inputtype != "date") {
+ if (nexacro._Browser != "MobileSafari") {
+ if (!(nexacro._enableaccessibility && nexacro._accessibilitytype == 5)) {
+ var end_pos = 0;
+ var caret_pos = nexacro.__getDOMNodeCaretPos(_doc, input_handle);
+ {
+
+ end_pos = caret_pos ? caret_pos.end : 0;
+ }
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, end_pos, end_pos, true);
+ }
+ }
+ nexacro._removeInputDOMNodeCaret(input_handle);
+ }
+ }
+ }
+
+ if (this._checkmax_editing_only && this.maxlength > 0) {
+ var text = (nexacro._isNull(this.value) ? this.defaultvalue : (this.value + ""));
+ var value = this._getInputValue();
+ if (text != value) {
+ this._updateInputValue(value);
+ }
+ }
+
+ if (this._is_focused) {
+ this._is_focused = false;
+
+ if (nexacro._BrowserType != "Edge" && nexacro._Browser != "Gecko") {
+ if (this._is_sys_focused) {
+ nexacro.__setDOMNode_Blur(input_handle);
+ }
+ }
+ }
+
+
+ if (this.value == null && this.displaynulltext != "") {
+ if (nexacro._OS == "iOS" && nexacro._SystemType == "iphone") {
+ pThis = this;
+ setTimeout(function () {
+ nexacro.__setDOMNode_Type(input_handle, "text");
+ pThis._updateInputValue(pThis.displaynulltext, false);
+ }, 0);
+ }
+ else {
+ nexacro.__setDOMNode_Type(input_handle, "text");
+ this._updateInputValue(this.displaynulltext, false);
+ }
+ }
+ else {
+ if (this._is_invalid_value && !nexacro._isNull(this.displayinvalidtext)) {
+ if (nexacro._OS == "iOS" && nexacro._SystemType == "iphone") {
+ pThis = this;
+ setTimeout(function () {
+ nexacro.__setDOMNode_Type(input_handle, "text");
+ pThis._updateInputValue(pThis.displayinvalidtext, false);
+ }, 0);
+ }
+ else {
+ nexacro.__setDOMNode_Type(input_handle, "text");
+ this._updateInputValue(this.displayinvalidtext, false);
+ }
+ }
+ }
+ }
+ };
+
+ _pInputElement.setElementSetSelect = function (start, end) {
+ if (this.inputtype == "date") {
+ return;
+ }
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ var _doc = this._getRootWindowHandle();
+ var val = this.getElementText();
+ var len = val.length;
+
+ end = (typeof end == 'number') ? (end == -1 ? len : end) : start;
+
+ if (!this._is_focused) {
+ this._setElementLastSelectionRange([start, end]);
+ return;
+ }
+
+ var range = end - start;
+ if (_doc) {
+ if (range == len) {
+ if (nexacro._isTouchInteraction && nexacro._OS == "iOS") {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, start, end);
+ }
+ else {
+ nexacro.__setDOMNode_Select(_doc, input_handle);
+ }
+ }
+ else {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, start, end);
+ }
+ }
+ }
+ };
+
+ _pInputElement._setElementLastSelectionRange = function (range) {
+ if (range) {
+ this._last_selection_range = range;
+ }
+ else {
+ this._last_selection_range = null;
+ }
+ };
+
+ _pInputElement.getElementCaretPos = function () {
+ var input_handle = this.handle;
+ if (input_handle && this.inputtype != "date" && this._is_focused) {
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ return nexacro.__getDOMNodeCaretPos(_doc, input_handle);
+ }
+ }
+ return -1;
+ };
+
+ _pInputElement.getElementSelectionRange = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused && this._last_selection_range) {
+ return this._last_selection_range;
+ }
+
+ var _doc = this._getRootWindowHandle();
+ if (_doc && (this._use_node_selection_range || this._is_focused)) {
+ var sel = nexacro.__getDOMNodeSelectionRange(_doc, input_handle);
+ return sel.splice(0, 2);
+ }
+ }
+ return [0, 0];
+ };
+
+ _pInputElement.getElementText = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ return this._getInputValue();
+ }
+ return this._input_text;
+ };
+
+ _pInputElement._getInputValue = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (this._is_focused) {
+ return nexacro.__getDOMNodeValue(input_handle);
+ }
+ else {
+ if (this.displaynulltext) {
+ if (this.getInputStatusPseudoClass("AUTOFILL")) {
+ return nexacro.__getDOMNodeValue(input_handle);
+ }
+ else {
+ return this._input_text;
+ }
+ }
+ else {
+ if (this._is_invalid_value) {
+ return this._input_text;
+ }
+ else {
+ return nexacro.__getDOMNodeValue(input_handle);
+ }
+ }
+ }
+ }
+ return "";
+ };
+
+ _pInputElement.getElementValue = function () {
+ return this.value;
+ };
+
+ _pInputElement.getCompositionStatus = function () {
+ return (this._composer ? this._composer.status : nexacro._CompositionState.NONE);
+ };
+
+ _pInputElement.isComposing = function () {
+ return (this._composer ? this._composer.isComposing() : false);
+ };
+
+ _pInputElement.setCompositionComplete_process = function (end_pos, is_composing) {
+ var pos = this.getElementCaretPos();
+
+ var value = this._getInputValue();
+ var _is_composing = this._composer.isComposing();
+ if (_is_composing) {
+ this._composer.setStatus(nexacro._CompositionState.END, pos.end);
+ this._updateInputValue(value, !this._processing_oninput);
+ }
+ };
+
+ _pInputElement.setCompositionComplete = function (end_pos, is_composing) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ this.setCompositionComplete_process.call(this, end_pos, is_composing);
+
+ var pos = this.getElementCaretPos();
+ this._composer.setStatus(nexacro._CompositionState.NONE, pos.end);
+ }
+ };
+
+ _pInputElement.setCompositionCancel_process = function (end_pos, is_composing) {
+ var _is_composing = this._composer.isComposing();
+ if (_is_composing) {
+ var value = this._getInputValue();
+ var offset = this._composer.getOffset();
+ this._composer.setStatus(nexacro._CompositionState.END, offset.begin);
+ this._updateInputValue(value.substring(0, offset.begin), !this._processing_oninput);
+ }
+ };
+
+ _pInputElement.setCompositionCancel = function (end_pos, is_composing) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ this.setCompositionCancel_process.call(this, end_pos, is_composing);
+
+ var pos = this.getElementCaretPos();
+ this._composer.setStatus(nexacro._CompositionState.NONE, pos.end);
+ }
+ };
+
+ _pInputElement.setInputProcess = function (v) {
+ this._processing_oninput = v;
+ };
+
+ _pInputElement.getInputProcess = function () {
+ return this._processing_oninput;
+ };
+
+ _pInputElement.setInputStatusPseudoClass = function (pseudoclass, state) {
+ this._status_csspseudoclass[pseudoclass] = state;
+ };
+
+ _pInputElement.getInputStatusPseudoClass = function (pseudoclass) {
+ return this._status_csspseudoclass[pseudoclass];
+ };
+
+ _pInputElement.setElementAccessibilityRole = nexacro._emptyFn;
+ _pInputElement._setElementInputRole = nexacro._emptyFn;
+ _pInputElement._wantAccessibilityAdditionalLabel = nexacro._emptyFn;
+
+ _pInputElement._checkMaxLength = function (value, caretpos, fix_composition) {
+ var maxlength = this.maxlength;
+ if (maxlength <= 0 && caretpos <= 0) {
+ return;
+ }
+
+ var vlength = value.length;
+ var _is_composing = this._composer.isComposing();
+ if (maxlength < vlength) {
+ if (this._use_html_maxlength && _is_composing) {
+ return;
+ }
+
+ var _has_candidate_window;
+ if (_is_composing && !fix_composition) {
+ _has_candidate_window = this._composer.isHasCandiateWindow(value.charAt(caretpos - 1));
+ }
+
+ if (fix_composition || !_is_composing || !_has_candidate_window) {
+ return {
+ "ismax" : true,
+ "pos" : (caretpos - (vlength - maxlength))
+ };
+ }
+ else {
+ var offset = this._composer.getOffset();
+ if (maxlength == (vlength - (offset.end - offset.begin))) {
+ return {
+ "ismax" : true,
+ "pos" : (caretpos - (vlength - maxlength))
+ };
+ }
+ }
+ }
+ else {
+ return {
+ "ismax" : (!_is_composing && maxlength == vlength),
+ "pos" : caretpos
+ };
+ }
+
+ return;
+ };
+
+ _pInputElement._go_next_focus = function () {
+ var input_handle = this.handle;
+ var comp = this.parent_elem.linkedcontrol;
+ if (input_handle && comp) {
+ var form = comp._getForm();
+ var newfocus_comp = form._searchNextTabFocus(form._last_focused);
+
+ if (newfocus_comp && newfocus_comp[0]) {
+ if (newfocus_comp[0] instanceof nexacro.Form && newfocus_comp[0]._last_focused) {
+ var win = form._getWindow();
+ win._removeFromCurrentFocusPath(newfocus_comp[0]._last_focused);
+ }
+
+ newfocus_comp[0]._setFocus(true, 0, true);
+
+ if (!newfocus_comp[0].autoselect && newfocus_comp[0]._is_editable_control) {
+ newfocus_comp[0]._setDefaultCaret();
+ }
+ }
+ }
+ };
+
+ _pInputElement._bindSysEvent = function () {
+ var input = this.handle;
+ if (input) {
+ nexacro._observeSysEvent(input, "keydown", "onkeydown", this._on_sys_keydown);
+ nexacro._observeSysEvent(input, "keyup", "onkeyup", this._on_sys_keyup);
+ nexacro._observeSysEvent(input, "keypress", "onkeypress", this._on_sys_keypress);
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion <= 8 && input.onpropertychange !== "undefined") {
+ nexacro._observeSysEvent(input, "propertychange", "onpropertychange", this._on_sys_propertychange);
+ this._use_propertychange_evt = true;
+ }
+ else {
+ if (this._use_event_beforeinput) {
+ nexacro._observeSysEvent(input, "beforeinput", "onbeforeinput", this._on_sys_beforeinput_forward);
+ }
+
+ nexacro._observeSysEvent(input, "input", "oninput", this._on_sys_keyinput_forward);
+ nexacro._observeSysEvent(input, "compositionstart", "oncompositionstart", this._on_sys_compositionstart);
+ nexacro._observeSysEvent(input, "compositionupdate", "oncompositionupdate", this._on_sys_compositionupdate);
+ nexacro._observeSysEvent(input, "compositionend", "oncompositionend", this._on_sys_compositionend);
+ }
+
+ nexacro._observeSysEvent(input, "cut", "oncut", this._on_sys_cut);
+ nexacro._observeSysEvent(input, "paste", "onpaste", this._on_sys_paste);
+
+ nexacro._observeSysEvent(input, "mousedown", "onmousedown", this._on_sys_mousedown);
+ nexacro._observeSysEvent(input, "mouseup", "onmouseup", this._on_sys_mouseup);
+
+ nexacro._observeSysEvent(input, "focus", "onfocus", this._on_sys_focus);
+ nexacro._observeSysEvent(input, "blur", "onblur", this._on_sys_blur);
+
+ nexacro._observeSysEvent(input, "select", "onselect", this._on_sys_select);
+ nexacro._observeSysEvent(input, "click", "onclick", this._on_sys_click);
+
+ if (nexacro._SupportTouch) {
+ nexacro._observeSysEvent(input, "touchstart", "ontouchstart", this._on_sys_touchstart);
+ nexacro._observeSysEvent(input, "touchend", "ontouchend", this._on_sys_touchend);
+ }
+
+ if (this._use_event_animation) {
+ nexacro._observeSysEvent(input, "animationstart", "onanimationstart", this._on_sys_animationstart);
+ }
+ }
+ };
+
+ _pInputElement._unbindSysEvent = function () {
+ var input = this.handle;
+ if (input) {
+ nexacro._stopSysObserving(input, "keydown", "onkeydown", this._on_sys_keydown);
+ nexacro._stopSysObserving(input, "keyup", "onkeyup", this._on_sys_keyup);
+ nexacro._stopSysObserving(input, "keypress", "onkeypress", this._on_sys_keypress);
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion <= 8 && input.onpropertychange !== "undefined") {
+ nexacro._stopSysObserving(input, "propertychange", "onpropertychange", this._on_sys_propertychange);
+ }
+ else {
+ if (this._use_event_beforeinput) {
+ nexacro._stopSysObserving(input, "beforeinput", "onbeforeinput", this._on_sys_beforeinput_forward);
+ }
+
+ nexacro._stopSysObserving(input, "input", "oninput", this._on_sys_keyinput_forward);
+ nexacro._stopSysObserving(input, "compositionstart", "oncompositionstart", this._on_sys_compositionstart);
+ nexacro._stopSysObserving(input, "compositionupdate", "oncompositionupdate", this._on_sys_compositionupdate);
+ nexacro._stopSysObserving(input, "compositionend", "oncompositionend", this._on_sys_compositionend);
+ }
+
+ nexacro._stopSysObserving(input, "cut", "oncut", this._on_sys_cut);
+ nexacro._stopSysObserving(input, "paste", "onpaste", this._on_sys_paste);
+
+ nexacro._stopSysObserving(input, "mousedown", "onmousedown", this._on_sys_mousedown);
+ nexacro._stopSysObserving(input, "mouseup", "onmouseup", this._on_sys_mouseup);
+
+ nexacro._stopSysObserving(input, "focus", "onfocus", this._on_sys_focus);
+ nexacro._stopSysObserving(input, "blur", "onblur", this._on_sys_blur);
+
+ nexacro._stopSysObserving(input, "select", "onselect", this._on_sys_select);
+ nexacro._stopSysObserving(input, "click", "onclick", this._on_sys_click);
+
+ if (nexacro._SupportTouch) {
+ nexacro._stopSysObserving(input, "touchstart", "ontouchstart", this._on_sys_touchstart);
+ nexacro._stopSysObserving(input, "touchend", "ontouchend", this._on_sys_touchend);
+ }
+
+ if (this._use_event_animation) {
+ nexacro._stopSysObserving(input, "animationstart", "onanimationstart", this._on_sys_animationstart);
+ }
+ }
+ };
+
+ _pInputElement.on_sys_keydown_before_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var keycode = nexacro._getSysEventKey(evt);
+
+ var comp = pThis.parent_elem.linkedcontrol;
+ var _win = comp._getWindow();
+ var capture_comp;
+ if (comp) {
+ capture_comp = _win._getCaptureComp(false, true, comp);
+ }
+
+ if (capture_comp && capture_comp != comp) {
+ nexacro._stopSysEvent(evt);
+ return false;
+ }
+
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setDelayStatus(undefined);
+
+ if (keycode == nexacro.KeyCode_ImeInput && nexacro._OS != "Android") {
+ if (!pThis._composer.isComposing()) {
+ pThis._composer.setDelayStatus(nexacro._CompositionState.START, pos.begin);
+ }
+ else {
+ pThis._composer.setDelayStatus(nexacro._CompositionState.COMPOSING, pos.end);
+ }
+ }
+ else {
+ var is_composing = pThis._composer.isComposing();
+ if (is_composing) {
+ pThis._composer.setDelayStatus(nexacro._CompositionState.END, pos.end);
+ }
+ else {
+ pThis._composer.setStatus(nexacro._CompositionState.NONE, pos.begin);
+ }
+ }
+
+ return true;
+ };
+
+ _pInputElement.on_sys_keydown_specialkey_process = function (evt) {
+ if (nexacro._Browser == "IE") {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var keycode = nexacro._getSysEventKey(evt);
+
+ if (nexacro._BrowserVersion == 8) {
+ if (keycode == nexacro.Event.KEY_TAB) {
+ pThis.setCompositionComplete();
+ }
+ }
+ else if (nexacro._BrowserVersion == 9) {
+ if (input_handle.value.length > 0 && (keycode == nexacro.Event.KEY_BACKSPACE || keycode == nexacro.Event.KEY_DEL || keycode == nexacro.Event.KEY_ESC)) {
+ setTimeout(function () {
+ nexacro.__fireHTMLEvent(input_handle, "input", "oninput");
+ }, 0);
+ }
+ }
+ else if (nexacro._BrowserVersion > 9) {
+ if (keycode == nexacro.Event.KEY_ESC) {
+ setTimeout(function () {
+ nexacro.__fireHTMLEvent(input_handle, "input", "oninput");
+ }, 0);
+ }
+ }
+ }
+ return true;
+ };
+
+ _pInputElement.on_sys_keydown_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement._on_sys_keydown = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (!pThis.readonly) {
+ if (!pThis.on_sys_keydown_before_process.call(pThis, evt)) {
+ return;
+ }
+ if (!pThis.on_sys_keydown_specialkey_process.call(pThis, evt)) {
+ return;
+ }
+ pThis.on_sys_keydown_process.call(pThis, evt);
+ }
+ }
+ };
+
+ _pInputElement.on_sys_keyup_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_keyup_specialkey_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_keyup_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ pThis._composer.setDelayStatus(undefined);
+
+ var value = pThis._getInputValue();
+
+ if (nexacro._OS == "Android" && nexacro._Browser == "Chrome" && nexacro._BrowserVersion > "34") {
+ if (pThis._beforeinput_result_pos && !pThis._composer.isComposing()) {
+ var selectionStart = pThis._beforeinput_result_pos.begin;
+ var selectionEnd = pThis._beforeinput_result_pos.end;
+ if (selectionStart != null && selectionStart > -1) {
+ if (selectionEnd == -1) {
+ selectionEnd = value.length;
+ }
+ if (selectionEnd == null || selectionEnd < selectionStart) {
+ selectionEnd = selectionStart;
+ }
+
+ var _doc = pThis._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, selectionStart, selectionEnd);
+ }
+ }
+ }
+ }
+
+
+ return true;
+ };
+
+ _pInputElement._on_sys_keyup = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (!pThis.readonly) {
+ if (!pThis.on_sys_keyup_before_process.call(pThis, evt)) {
+ return;
+ }
+ if (!pThis.on_sys_keyup_specialkey_process.call(pThis, evt)) {
+ return;
+ }
+
+ pThis.on_sys_keyup_process.call(pThis, evt);
+ }
+
+ if (pThis._use_event_beforeinput) {
+ while (pThis._beforeinput_result && pThis._beforeinput_result.length > 0) {
+ pThis._beforeinput_result.pop();
+ }
+
+ pThis._beforeinput_result_insert_data = null;
+ pThis._beforeinput_result_data = null;
+ pThis._beforeinput_result_pos = null;
+ }
+ }
+ };
+
+ _pInputElement.on_sys_keypress_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_keypress_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var charcode = evt.charCode || evt.keyCode;
+
+ var value = pThis._getInputValue();
+ var _range = pThis.getElementSelectionRange();
+
+ var comp = pThis.parent_elem.linkedcontrol;
+ var _win = comp._getRootWindow();
+
+ if (_win && _win._keydown_element) {
+ if (_win._keydown_element !== pThis) {
+ return false;
+ }
+ }
+
+ if (!evt.ctrlKey && !evt.altKey && charcode) {
+ var inputChar = String.fromCharCode(charcode);
+ if (inputChar.length > 0) {
+ if (pThis.autoskip && pThis.maxlength > 0 && value.length >= pThis.maxlength && _range[0] == _range[1]) {
+ if (charcode != nexacro.Event.KEY_RETURN) {
+ pThis._go_next_focus();
+ }
+ }
+ }
+ }
+
+ if (!pThis._use_html_maxlength) {
+ if (pThis.maxlength > 0 && value.length >= pThis.maxlength && _range[0] == _range[1]) {
+ nexacro._stopSysEvent(evt);
+ return false;
+ }
+ }
+ };
+
+ _pInputElement._on_sys_keypress = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+
+ if (nexacro._OS == "iOS") {
+ pThis._updateImeLocale(evt);
+
+ return false;
+ }
+
+ if (!pThis.on_sys_keypress_before_process.call(pThis, evt)) {
+ return;
+ }
+
+ return pThis.on_sys_keypress_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement._is_accept_touch = function (win) {
+ if (nexacro._OS === 'iOS' && win) {
+ var lastfocus_elem = win._last_focused_elem;
+ if (lastfocus_elem && lastfocus_elem.isInputElement()) {
+ if (this !== lastfocus_elem && lastfocus_elem.isComposing()) {
+ return false;
+ }
+ }
+ }
+ return true;
+ };
+ _pInputElement.on_complete_composition_value_process = function () {
+ return true;
+ };
+
+ _pInputElement.on_complete_composition_value = function () {
+ return this.on_complete_composition_value_process.call(this);
+ };
+
+ _pInputElement.on_apply_imeSet = function (evt) {
+ var i, len;
+ var input_handle = evt ? (evt.target || evt.srcElement) : null;
+ var pThis = input_handle ? input_handle._linked_element : this;
+
+ var _locale = pThis._imelocale.getLocale();
+ if (_locale && nexacro._cache_inputelement_set[_locale]) {
+ for (var prop in nexacro._cache_inputelement_set[_locale]) {
+ pThis[prop] = nexacro._cache_inputelement_set[_locale][prop];
+ }
+
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ if (!nexacro._cache_inputelement_set[_locale][nexacro._inputelement_user_override_func[i]]) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ }
+ else {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+
+ var comp = pThis.parent_elem.linkedcontrol;
+ if (comp.on_apply_imeSet) {
+ comp.on_apply_imeSet();
+ }
+
+ pThis.on_apply_ime_environment(evt);
+ };
+
+ _pInputElement.on_apply_ime_environment_process = function (evt) {
+ var input_handle = evt ? (evt.target || evt.srcElement) : this.handle;
+ this._setElementUseMaxLength(true);
+ nexacro.__setDOMNode_MaxLength(input_handle, this.maxlength);
+ this.on_updateEvtOrder_process();
+ };
+
+ _pInputElement.on_apply_ime_environment = function (evt) {
+ this.on_apply_ime_environment_process.call(this, evt);
+ };
+
+ _pInputElement.on_apply_force_imeSet = function (evt) {
+ return true;
+ };
+
+ _pInputElement._updateLocale = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var comp = pThis.parent_elem.linkedcontrol;
+ if (comp instanceof nexacro.MaskEdit) {
+ pThis._skip_check_imelocale = true;
+ pThis._imelocale.setLocale("");
+ pThis.on_apply_imeSet(evt);
+ return;
+ }
+
+ var pos = pThis.getElementCaretPos();
+ var value = pThis._getInputValue();
+
+ pThis._imelocale.updateLocale((evt.data || evt.key) || value.substr(pos.end - 1, 1));
+ if (pThis._imelocale.IsChangeLocale()) {
+ pThis.on_apply_imeSet(evt);
+ }
+
+ pThis.on_apply_force_imeSet.call(pThis, evt);
+ };
+
+ _pInputElement._updateImeLocale = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+
+ if (pThis._skip_check_imelocale) {
+ return true;
+ }
+
+ var comp = pThis.parent_elem.linkedcontrol;
+ var e_data;
+ var composing_status = pThis._composer.status;
+
+ var value = pThis._getInputValue();
+ var pos = pThis.getElementCaretPos();
+
+ var prev_status = pThis._composer._prev_status;
+
+ if (this._use_event_beforeinput) {
+ var beforeinput_data = evt.data;
+
+ if (composing_status != nexacro._CompositionState.END) {
+ if (beforeinput_data === null) {
+ return true;
+ }
+
+ if (!pThis.isComposing()) {
+ }
+ else {
+ if (comp instanceof nexacro.MaskEdit) {
+ pThis._skip_check_imelocale = true;
+ return true;
+ }
+
+ if ((prev_status == nexacro._CompositionState.NONE && composing_status == nexacro._CompositionState.START) || (prev_status == nexacro._CompositionState.END && composing_status == nexacro._CompositionState.START)) {
+ pThis._updateLocale(evt);
+ }
+ }
+ }
+ }
+ else {
+ if (this._apple_default_browser) {
+ if (pThis.isComposing() && (comp instanceof nexacro.MaskEdit)) {
+ input_handle.blur();
+ input_handle.focus();
+ pThis._updateInputValue(comp.text, false, pos.begin);
+ return false;
+ }
+
+ e_data = evt.data || evt.key;
+ if (e_data) {
+ if (evt.key || (pThis.isComposing() && (prev_status == nexacro._CompositionState.START && composing_status == nexacro._CompositionState.COMPOSING))) {
+ var keycode = evt.charCode || evt.keyCode;
+ if (evt.key && (keycode >= 33 && keycode <= 126)) {
+ return true;
+ }
+
+ pThis._updateLocale(evt);
+ }
+ }
+
+ return true;
+ }
+
+ if (pos != -1 && composing_status != nexacro._CompositionState.END) {
+ if (!pThis.isComposing()) {
+ }
+ else {
+ if (prev_status == nexacro._CompositionState.NONE && nexacro._CompositionState.START ||
+ prev_status == nexacro._CompositionState.END && nexacro._CompositionState.START ||
+ prev_status == nexacro._CompositionState.START && nexacro._CompositionState.COMPOSING || (pThis._check_imetype_composing_status && prev_status == nexacro._CompositionState.COMPOSING && composing_status == nexacro._CompositionState.COMPOSING)) {
+ if (value) {
+ pThis._updateLocale(evt);
+ }
+ }
+ }
+ }
+ }
+ return true;
+ };
+
+ _pInputElement.on_sys_beforeinput_forward_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_beforeinput_forward_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+
+ var pThis = input_handle._linked_element;
+ var comp = pThis.parent_elem.linkedcontrol;
+
+ var beforeinput_data = evt.data;
+ var beforeinput_type = evt.inputType;
+
+ var input_value = pThis._getInputValue();
+ var input_pos = pThis.getElementCaretPos();
+ var composing_status = pThis.getCompositionStatus();
+ var beginOffset = input_pos.begin;
+ var endOffset = input_pos.end;
+
+ var _win = comp._getWindow();
+ var capture_comp;
+ if (comp) {
+ capture_comp = _win._getCaptureComp(false, true, comp);
+ }
+
+ if (capture_comp && capture_comp != comp) {
+ pThis._beforeinput_result = [pThis._BeforeinputState.CANCEL];
+ pThis._beforeinput_result_data = input_value;
+ pThis._beforeinput_result_pos = {
+ begin : beginOffset,
+ end : endOffset
+ };
+ return false;
+ }
+
+
+ if (beforeinput_data == null && beforeinput_type == "insertLineBreak") {
+ beforeinput_data = "↵";
+ }
+ else if (beforeinput_type == "insertCompositionText") {
+ pThis._composing_start = beginOffset;
+ pThis._composing_end = endOffset;
+ }
+
+ pThis._beforeinput_result = comp._on_beforekeyinput(pThis, beforeinput_data, composing_status, beginOffset, endOffset, beforeinput_type);
+
+ if (pThis._beforeinput_result) {
+ pThis._beforeinput_result.forEach(function (state) {
+ var caret_after_convert, data;
+ switch (state) {
+ case pThis._BeforeinputState.PASS:
+ break;
+ case pThis._BeforeinputState.CANCEL:
+ pThis._beforeinput_result_data = input_value;
+ pThis._beforeinput_result_pos = {
+ begin : beginOffset,
+ end : endOffset
+ };
+
+ break;
+ case pThis._BeforeinputState.CONVERT_UPPER:
+ if (beforeinput_type == "insertFromPaste") {
+ pThis._beforeinput_result_insert_data = pThis._beforeinput_result_insert_data ? pThis._beforeinput_result_insert_data.toUpperCase() : "";
+ data = pThis._beforeinput_result_data;
+ pThis._beforeinput_result_data = data.substring(0, pThis._beforeinput_result_pos.begin - pThis._beforeinput_result_insert_data.length);
+ pThis._beforeinput_result_data += pThis._beforeinput_result_insert_data;
+ pThis._beforeinput_result_data += data.substring(pThis._beforeinput_result_pos.begin);
+ }
+ else if (beforeinput_type != "insertLineBreak") {
+ caret_after_convert = beginOffset + beforeinput_data.length;
+
+ pThis._beforeinput_result_data = input_value.substring(0, beginOffset) + beforeinput_data.toUpperCase() + input_value.substring(endOffset, input_value.length);
+ pThis._beforeinput_result_pos = {
+ begin : caret_after_convert,
+ end : caret_after_convert
+ };
+ }
+ break;
+ case pThis._BeforeinputState.CONVERT_LOWER:
+ if (beforeinput_type == "insertFromPaste") {
+ pThis._beforeinput_result_insert_data = pThis._beforeinput_result_insert_data ? pThis._beforeinput_result_insert_data.toLowerCase() : "";
+ data = pThis._beforeinput_result_data;
+ pThis._beforeinput_result_data = data.substring(0, pThis._beforeinput_result_pos.begin - pThis._beforeinput_result_insert_data.length);
+ pThis._beforeinput_result_data += pThis._beforeinput_result_insert_data;
+ pThis._beforeinput_result_data += data.substring(pThis._beforeinput_result_pos.begin);
+ }
+ else if (beforeinput_type != "insertLineBreak") {
+ caret_after_convert = beginOffset + beforeinput_data.length;
+ pThis._beforeinput_result_data = input_value.substring(0, beginOffset) + beforeinput_data.toLowerCase() + input_value.substring(endOffset);
+ pThis._beforeinput_result_pos = {
+ begin : caret_after_convert,
+ end : caret_after_convert
+ };
+ }
+
+ break;
+ case pThis._BeforeinputState.MAXLENGTH:
+ break;
+ case pThis._BeforeinputState.REPLACE:
+ break;
+ default:
+ break;
+ }
+ }, pThis);
+ }
+ };
+
+ _pInputElement._on_sys_beforeinput_forward = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+
+ if (!pThis._updateImeLocale(evt)) {
+ return false;
+ }
+
+ if (!pThis.on_sys_beforeinput_forward_before_process.call(pThis, evt)) {
+ return false;
+ }
+
+ pThis.on_sys_beforeinput_forward_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement.on_sys_propertychange_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_propertychange_process = function (evt) {
+ var ret;
+ var input_handle = evt.srcElement;
+ var pThis = input_handle._linked_element;
+
+ if (pThis) {
+ var pos;
+ var select_start = pThis._selectstartpos_onprepertychange_afterupdate;
+ var select_end = pThis._selectendpos_onprepertychange_afterupdate;
+ if (select_start != null && select_start > -1) {
+ var _doc = pThis._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, select_start, select_end);
+ }
+
+ pThis._selectstartpos_onprepertychange_afterupdate = undefined;
+ pThis._selectendpos_onprepertychange_afterupdate = undefined;
+ }
+
+ if (!pThis._processing_oninput) {
+ var cur_status;
+ var delay_status = pThis._composer._delay_status;
+ if (delay_status != null) {
+ if (delay_status == nexacro._CompositionState.END) {
+ pos = pThis._delay_pos = pThis.getElementCaretPos();
+ pThis.setCompositionComplete();
+ pThis.setElementSetSelect(pos.begin, pos.end);
+ }
+ else {
+ pos = pThis.getElementCaretPos();
+ var delay_status_pos = pThis._composer._delay_status_pos;
+
+ if (delay_status == nexacro._CompositionState.START) {
+ if (delay_status_pos < 0) {
+ delay_status_pos = pos.begin;
+ }
+ pThis._composer.setStatus(delay_status, delay_status_pos);
+ pThis._composer.setStatus(nexacro._CompositionState.COMPOSING, pos.end);
+ }
+ else if (delay_status == nexacro._CompositionState.COMPOSING) {
+ pThis._composer.setStatus(delay_status, pos.end);
+ }
+ else {
+ if (delay_status_pos < 0) {
+ delay_status_pos = pos.begin;
+ }
+ pThis._composer.setStatus(delay_status, delay_status_pos);
+ }
+ }
+ }
+
+ if (pThis._delay_pos) {
+ pThis.setElementSetSelect(pThis._delay_pos.begin, pThis._delay_pos.end);
+ pThis._delay_pos = null;
+ }
+
+ pThis._composer.setDelayStatus(undefined);
+
+ var value = pThis._getInputValue();
+
+ var prev_status = pThis._composer._prev_status;
+ cur_status = pThis._composer.status;
+
+ if (prev_status == cur_status && pThis.value == value) {
+ return;
+ }
+
+ pThis._processing_oninput = true;
+ ret = pThis._on_sys_keyinput.call(this, evt);
+ pThis._processing_oninput = false;
+ }
+ }
+ return ret;
+ };
+
+
+
+ _pInputElement._on_sys_propertychange = function (evt) {
+ if (evt.propertyName == "value") {
+ var input_handle = evt.srcElement;
+ var pThis = input_handle._linked_element;
+ if (input_handle) {
+ if (!pThis.on_sys_propertychange_before_process.call(pThis, evt)) {
+ return;
+ }
+
+ return pThis.on_sys_propertychange_process.call(pThis, evt);
+ }
+ }
+ };
+
+ _pInputElement.on_sys_keyinput_forward_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_keyinput_forward_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+
+ var ret;
+ var pThis = input_handle._linked_element;
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserType != "Edge") {
+ var timestamp = evt.timeStamp;
+ var len = pThis._forced_fire_event_list.length;
+ var idx = (len > 0) ? pThis._forced_fire_event_list.indexOf(timestamp) : -1;
+ if (idx >= 0) {
+ pThis._forced_fire_event_list.splice(idx, 1);
+ }
+ else {
+ if (!nexacro._checkActiveElement(pThis)) {
+ return;
+ }
+ }
+ }
+
+ if (pThis && !pThis._processing_oninput) {
+ var value = pThis._getInputValue();
+
+ var prev_status = pThis._composer._prev_status;
+ var cur_status = pThis._composer.status;
+ if (prev_status == cur_status) {
+ if (!pThis.value && pThis.defaultvalue == value) {
+ return;
+ }
+ }
+
+ pThis._processing_oninput = true;
+ ret = pThis._on_sys_keyinput.call(this, evt);
+ pThis._processing_oninput = false;
+ }
+
+ return ret;
+ };
+
+ _pInputElement._on_sys_keyinput_forward = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+
+ if (!pThis.on_sys_keyinput_forward_before_process(evt)) {
+ return false;
+ }
+
+ return pThis.on_sys_keyinput_forward_process(evt);
+ }
+ };
+
+ if (_pInputElement._use_event_beforeinput) {
+ _pInputElement.on_sys_keyinput_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_keyinput_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ if (pThis._skip_sys_keyinput) {
+ pThis._skip_sys_keyinput = false;
+ return;
+ }
+
+ var comp = pThis.parent_elem.linkedcontrol;
+ var ismax = false;
+ var value;
+ var pos;
+ if (pThis._beforeinput_result) {
+ var bcancle = false;
+ pThis._beforeinput_result.forEach(function (state) {
+ switch (state) {
+ case nexacro.InputElement.prototype._BeforeinputState.PASS:
+ break;
+ case nexacro.InputElement.prototype._BeforeinputState.CANCEL:
+ pThis._updateInputValue(pThis._beforeinput_result_data, false, pThis._beforeinput_result_pos.end, pThis._beforeinput_result_pos.end);
+ bcancle = true;
+ break;
+ case nexacro.InputElement.prototype._BeforeinputState.CONVERT_UPPER:
+ case nexacro.InputElement.prototype._BeforeinputState.CONVERT_LOWER:
+ case nexacro.InputElement.prototype._BeforeinputState.REPLACE:
+ if (pThis._beforeinput_result_data != null) {
+ pThis._updateInputValue(pThis._beforeinput_result_data, false, pThis._beforeinput_result_pos.begin, pThis._beforeinput_result_pos.end);
+ }
+ break;
+ case nexacro.InputElement.prototype._BeforeinputState.MAXLENGTH:
+ ismax = true;
+
+ break;
+ }
+ }, pThis);
+
+ if (bcancle) {
+ return;
+ }
+ }
+
+ value = pThis._getInputValue();
+ pos = pThis.getElementCaretPos();
+
+ if (pThis._composer.isComposing()) {
+ pThis._composer.setStatus(nexacro._CompositionState.COMPOSING, pos.end);
+ }
+
+ var old_value = pThis.value;
+ pThis._updateElementValue(value);
+
+ if (comp._on_keyinput) {
+ comp._on_keyinput(pThis);
+ }
+
+ if (pThis.getInputStatusPseudoClass("AUTOFILL")) {
+ nexacro.__changeInputDOMNodeType(input_handle, pThis.inputtype);
+ }
+
+ if (pThis.autoskip && ismax) {
+ if (pThis.value && value.length >= pThis.maxlength) {
+ pThis._go_next_focus();
+ }
+ }
+
+ var prev_status = pThis._composer._prev_status;
+ var cur_status = pThis._composer.status;
+
+ if (prev_status == cur_status && pThis.value == old_value) {
+ if (comp._on_input_autoskip) {
+ comp._on_input_autoskip();
+ }
+ }
+
+ pThis._composer._prev_status = cur_status;
+ };
+
+ _pInputElement._on_sys_keyinput = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (!pThis.on_sys_keyinput_before_process.call(pThis, evt)) {
+ return;
+ }
+
+ return pThis.on_sys_keyinput_process.call(pThis, evt);
+ }
+ };
+ }
+ else {
+ _pInputElement.on_sys_keyinput_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_keyinput_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var comp = pThis.parent_elem.linkedcontrol;
+
+ var composing_status = pThis._composer.status;
+ var beginOffset, endOffset;
+
+ var value = pThis._getInputValue();
+ var pos = pThis.getElementCaretPos();
+
+ if (composing_status == nexacro._CompositionState.NONE) {
+ beginOffset = pThis._paste_caret_pos ? pThis._paste_caret_pos.begin : pThis._composer.startOffset;
+ endOffset = pThis._paste_caret_pos ? pThis._paste_caret_pos.end : pos.end;
+
+ if (beginOffset > endOffset) {
+ beginOffset = endOffset;
+ }
+ }
+ else {
+ var offsetCompose = pThis._composer.getOffset();
+ beginOffset = offsetCompose.begin;
+ endOffset = offsetCompose.end;
+
+ if (beginOffset == endOffset && (composing_status == 3 || composing_status == 1)) {
+ if (pThis._last_selection_range) {
+ beginOffset = pThis._last_selection_range[0];
+ }
+ else {
+ beginOffset -= 1;
+ }
+ }
+
+ if (pThis._composer.isComposing()) {
+ endOffset = pos.end;
+ }
+ }
+
+ var bBackspace = pThis._checkBackspaceKeyInKeyInput(pThis.value, value, beginOffset, endOffset);
+ var bSelect = pThis._checkSelectionInKeyInput(pThis.value, value, beginOffset, endOffset);
+
+ if (bBackspace) {
+ nexacro.__fireHTMLEvent(input_handle, "keydown", "onkeydown");
+ }
+
+ if (bSelect !== false) {
+ beginOffset = bSelect;
+ }
+
+ if (comp._on_beforekeyinput) {
+ comp._on_beforekeyinput(pThis, value, composing_status, beginOffset, endOffset);
+ if (pThis._event_stop) {
+ nexacro._stopSysEvent(evt);
+ pThis._event_stop = false;
+ return false;
+ }
+ }
+
+ var new_value = pThis._getInputValue();
+
+ pos = pThis.getElementCaretPos();
+
+ if (nexacro._OS == "Android" && nexacro._Browser == "Chrome" && nexacro._BrowserVersion > "34") {
+ if (comp instanceof nexacro.MaskEdit) {
+ pThis._beforeinput_result_pos = {
+ begin : pos.begin,
+ end : pos.end
+ };
+ }
+ }
+
+ var ismax = false;
+ if (pThis.maxlength > 0) {
+ var caretpos = pThis._paste_caret_pos ? pThis._paste_caret_pos.end - (value.length - new_value.length) : pos.end;
+
+ value = new_value;
+
+ var check = pThis._checkMaxLength(value, caretpos);
+ if (check) {
+ ismax = check.ismax;
+ var newpos = check.pos;
+
+ if (ismax) {
+ if (caretpos != newpos) {
+ value = value.substring(0, newpos) + value.substring(caretpos);
+ pThis._updateInputValue(value);
+ pThis.setElementSetSelect(newpos, newpos);
+
+ value = pThis._getInputValue();
+ pos = pThis.getElementCaretPos();
+ }
+
+ pThis.setCompositionComplete(newpos, false);
+ }
+ }
+ }
+ else {
+ value = new_value;
+ }
+
+ if (pThis._composer.isComposing()) {
+ pThis._composer.setStatus(nexacro._CompositionState.COMPOSING, pos.end);
+ }
+
+ var old_value = pThis.value;
+ pThis._updateElementValue(value);
+
+ var prev_status = pThis._composer._prev_status;
+ var cur_status = pThis._composer.status;
+
+ if (prev_status == cur_status && pThis.value == old_value) {
+ if (comp._on_input_autoskip) {
+ comp._on_input_autoskip();
+ }
+ }
+
+ pThis._composer._prev_status = cur_status;
+
+ if (pThis.value == old_value) {
+ if (ismax && pThis.autoskip) {
+ if (nexacro._Browser == "Safari") {
+ setTimeout(function () {
+ pThis._go_next_focus();
+ }, 0);
+ }
+ else {
+ pThis._go_next_focus();
+ }
+ }
+
+ return false;
+ }
+
+ if (comp._on_keyinput) {
+ comp._on_keyinput(pThis);
+ }
+
+ if (pThis._event_stop) {
+ nexacro._stopSysEvent(evt);
+ pThis._event_stop = false;
+ return false;
+ }
+
+ if (ismax && pThis.autoskip) {
+ if (pThis.value && value.length > pThis.value.length) {
+ ismax = false;
+ }
+
+ if (ismax) {
+ if (nexacro._Browser == "Safari") {
+ setTimeout(function () {
+ pThis._go_next_focus();
+ }, 0);
+ }
+ else {
+ pThis._go_next_focus();
+ }
+ }
+ }
+ return true;
+ };
+ _pInputElement._on_sys_keyinput = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ {
+
+ if (!pThis._updateImeLocale(evt)) {
+ return false;
+ }
+ }
+
+ if (!pThis.on_sys_keyinput_before_process.call(pThis, evt)) {
+ return false;
+ }
+ if (!pThis.on_sys_keyinput_process.call(pThis, evt)) {
+ return false;
+ }
+ }
+ };
+ }
+
+ _pInputElement.on_sys_cut_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement._on_sys_cut = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+
+ if (!pThis.on_sys_cut_before_process.call(pThis, evt)) {
+ return false;
+ }
+
+ if (pThis._evtfire_oninput_only_when_cut) {
+ setTimeout(function () {
+ var value = pThis._getInputValue();
+ pThis._updateInputValue(value, true);
+ }, 0);
+ }
+ };
+
+ _pInputElement.on_sys_paste_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement._on_sys_paste = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+
+ if (!pThis.on_sys_paste_before_process.call(pThis, evt)) {
+ return false;
+ }
+
+ var data;
+ if (evt.clipboardData && evt.clipboardData.getData) {
+ data = evt.clipboardData.getData('text/plain');
+ }
+ else if (window.clipboardData && window.clipboardData.getData) {
+ data = window.clipboardData.getData('text');
+ }
+
+ if (input_handle && !input_handle._linked_element._use_event_beforeinput && data) {
+ data = data.replace(/\r\n|\n/g, "");
+
+ var value = pThis._getInputValue();
+
+ var pos = pThis.getElementCaretPos();
+ var begin = pos.begin;
+ var end = pos.end;
+
+ var newvalue = value.substring(0, begin) + data + value.substring(end);
+ var newpos = begin + data.length;
+ pos.end = newpos;
+ nexacro._stopSysEvent(evt);
+ setTimeout(function () {
+ pThis._paste_caret_pos = pos;
+ pThis._updateInputValue(newvalue, true, newpos);
+ pThis._paste_caret_pos = null;
+ }, 0);
+
+ nexacro._stopSysEvent(evt);
+ return false;
+ }
+ };
+
+ _pInputElement.on_sys_compositionstart_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setStatus(nexacro._CompositionState.START, pos.begin);
+
+ return true;
+ };
+
+ _pInputElement._on_sys_compositionstart = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ pThis.on_sys_compositionstart_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement.on_sys_compositionupdate_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setStatus(nexacro._CompositionState.COMPOSING, pos.end);
+
+ return true;
+ };
+
+ _pInputElement._on_sys_compositionupdate = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ pThis.on_sys_compositionupdate_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement.on_sys_compositionend_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setStatus(nexacro._CompositionState.END, pos.end);
+
+ return true;
+ };
+
+ _pInputElement._on_sys_compositionend = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ pThis.on_sys_compositionend_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement._on_sys_mousedown = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle && evt.button == nexacro.InputElement.prototype.MOUSE_LBUTTON) {
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ var sel = pThis.getElementSelectionRange();
+
+ if (evt.ctrlKey && (sel[0] == sel[1])) {
+ pThis.setElementSetSelect(0, -1);
+ pThis.__prevent_sys_lbuttonup = true;
+ }
+ else {
+ pThis._setElementLastSelectionRange();
+ pThis.__prevent_sys_lbuttonup = false;
+ }
+
+ if (nexacro._BrowserType == "Edge") {
+ if (!pThis._is_sys_focused && pThis.autoselect) {
+ evt.preventDefault();
+ }
+ }
+
+ if (nexacro._OS == "iOS") {
+ if (pThis.inputtype == "date") {
+ evt.preventDefault();
+ }
+ }
+ }
+ }
+ };
+
+ _pInputElement._on_sys_mouseup = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle && evt.button == nexacro.InputElement.prototype.MOUSE_LBUTTON) {
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ if (pThis.__prevent_sys_lbuttonup) {
+ pThis.__prevent_sys_lbuttonup = false;
+ if (evt.preventDefault) {
+ evt.preventDefault();
+ }
+ else {
+ evt.returnValue = false;
+ }
+ return false;
+ }
+
+ if (pThis.getElementCaretPos && pThis._composer) {
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setStatus(nexacro._CompositionState.NONE, pos.end);
+ }
+ }
+ }
+ };
+
+ _pInputElement._on_sys_scroll = function (evt) {
+ var target = (evt.target || evt.srcElement);
+ if (target) {
+ if (target.nodeName == "input" || target.nodeName == "textarea") {
+ }
+ else if (target.nodeName == "#document") {
+ var cur_win = target.defaultView || target.parentWindow;
+
+ var scrollLeft = ('pageXOffset' in cur_win) ? cur_win.pageXOffset : target.documentElement.scrollLeft;
+ var scrollTop = ('pageXOffset' in cur_win) ? cur_win.pageYOffset : target.documentElement.scrollTop;
+
+ var focused = target.activeElement;
+ if (focused && focused != target.body) {
+ var pThis = focused._linked_element;
+ if (!pThis) {
+ return;
+ }
+
+ if (pThis._restore_scrollpos_onclick) {
+ if (pThis._restore_scrollpos_timer > 0) {
+ clearTimeout(pThis._restore_scrollpos_timer);
+ pThis._restore_scrollpos_timer = 0;
+ }
+
+ pThis._scoll_pos = [scrollLeft, scrollTop];
+ nexacro._stopSysObserving(cur_win, "scroll", "onscroll", pThis._on_sys_scroll);
+ }
+ }
+ }
+ }
+ };
+
+ _pInputElement.on_sys_focus_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_focus_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+
+ if (pThis._accept_focus_process === false) {
+ pThis._accept_focus_process = true;
+ return;
+ }
+
+ if ((nexacro._Browser == "IE" && nexacro._BrowserVersion == 8 || nexacro._BrowserType == "Edge") && pThis._force_focus) {
+ pThis._force_focus = false;
+ return;
+ }
+
+ var _parent = pThis.parent;
+ if (_parent) {
+ if (pThis._need_reset_update_value) {
+ pThis.on_reset_update_value(true);
+ }
+
+ var comp = _parent.linkedcontrol;
+ if (comp) {
+ var _win = comp._getWindow();
+ if (_win && _win._is_active_window) {
+ var cur_focus_paths = _win.getCurrentFocusPaths();
+ var focuspath_index = -1;
+
+ var rootComp = comp._getRootComponent(comp);
+ if (cur_focus_paths) {
+ focuspath_index = nexacro._indexOf(cur_focus_paths, rootComp);
+ }
+
+ if (focuspath_index == -1) {
+ var old_focused_comp = cur_focus_paths ? cur_focus_paths[cur_focus_paths.length - 1] : null;
+ if (old_focused_comp) {
+ if (pThis._use_event_beforeinput) {
+ pThis._skip_sys_keyinput = true;
+ }
+
+ if (nexacro._Browser == "Chrome" || nexacro._Browser == "Opera" || nexacro._OS == "iOS") {
+ pThis.setElementValue(comp.value, pThis._is_invalid_value);
+ }
+ old_focused_comp._apply_setfocus();
+ return;
+ }
+ }
+ }
+ }
+ }
+ pThis._is_sys_focused = true;
+
+ var _doc = pThis._getRootWindowHandle();
+ if (pThis.autoselect && pThis.inputtype != "date") {
+ pThis.__prevent_sys_lbuttonup = true;
+ if (nexacro._OS == "iOS") {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, 0, pThis._getInputValue().length);
+ }
+ else {
+ nexacro.__setDOMNode_Select(_doc, input_handle);
+ }
+ }
+ else if (pThis._last_selection_range && !(nexacro._enableaccessibility && nexacro._accessibilitytype == 5)) {
+ var sel = pThis._last_selection_range;
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, sel[0], sel[1]);
+ }
+
+ if (pThis.value == null) {
+ pThis._zerolength_value = undefined;
+ }
+ else {
+ pThis._zerolength_value = "";
+ }
+
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setStatus(nexacro._CompositionState.NONE, pos.begin);
+
+ return true;
+ };
+
+ _pInputElement._on_sys_focus = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (!pThis) {
+ return;
+ }
+
+ if (!pThis.on_sys_focus_before_process(evt)) {
+ return;
+ }
+ if (!pThis.on_sys_focus_process(evt)) {
+ return;
+ }
+ }
+ };
+
+ _pInputElement.on_sys_blur_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_blur_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+
+ if (pThis._accept_blur_process === false) {
+ pThis._accept_blur_process = true;
+ return;
+ }
+
+ pThis._is_sys_focused = false;
+ pThis._restore_scrollpos_onclick = false;
+ pThis._skip_sys_keyinput = false;
+
+ if (pThis._restore_scrollpos_timer > 0) {
+ clearTimeout(pThis._restore_scrollpos_timer);
+ pThis._restore_scrollpos_timer = 0;
+ }
+
+ var cur_doc = pThis._getRootWindowHandle();
+ if (cur_doc) {
+ var cur_win = cur_doc.defaultView || cur_doc.parentWindow;
+ nexacro._stopSysObserving(cur_win, "scroll", "onscroll", pThis._on_sys_scroll);
+ nexacro._adjustBodyScrollPos(cur_doc);
+ }
+
+ if ((nexacro._Browser == "IE" && nexacro._BrowserVersion == 8 || nexacro._BrowserType == "Edge") && pThis._force_focus) {
+ input_handle.focus();
+ }
+
+ return true;
+ };
+
+ _pInputElement._on_sys_blur = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (!pThis) {
+ return;
+ }
+
+ if (!pThis.on_sys_blur_before_process(evt)) {
+ return;
+ }
+ if (!pThis.on_sys_blur_process(evt)) {
+ return;
+ }
+ }
+ };
+
+ _pInputElement.on_sys_select_before_process = function (evt) {
+ return true;
+ };
+
+ _pInputElement.on_sys_select_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ if (pThis._is_focused) {
+ var sel = pThis.getElementSelectionRange();
+ if (sel && sel[0] != sel[1]) {
+ pThis._setElementLastSelectionRange(sel);
+ }
+ }
+ return true;
+ };
+
+ _pInputElement._on_sys_select = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ if (!pThis.on_sys_select_before_process(evt)) {
+ return;
+ }
+ if (!pThis.on_sys_select_process(evt)) {
+ return;
+ }
+ }
+ }
+ };
+
+ _pInputElement._on_sys_click = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ if (nexacro._OS == "Android" && pThis.inputtype == "date") {
+ if (pThis.parent.linkedcontrol._prevent_clickevent) {
+ evt.preventDefault();
+ }
+ }
+ pThis._scrollintoview_on_sys_click();
+ }
+ }
+ };
+
+ _pInputElement.on_sys_touchstart_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ if (pThis.inputtype == "date" && pThis.readonly) {
+ nexacro._stopSysEvent(evt);
+ return false;
+ }
+ }
+
+ var touches = evt.touches;
+ if (touches && touches.length > 1) {
+ nexacro._stopSysEvent(evt);
+ }
+
+ return true;
+ };
+
+ _pInputElement._on_sys_touchstart = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ pThis.on_sys_touchstart_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement.on_sys_touchend_process = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ var pos = pThis.getElementCaretPos();
+ pThis._composer.setStatus(nexacro._CompositionState.NONE, pos.end);
+ }
+ return true;
+ };
+
+ _pInputElement._on_sys_touchend = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ pThis.on_sys_touchend_process.call(pThis, evt);
+ }
+ };
+
+ _pInputElement._on_sys_touchmove = nexacro._emptyFn;
+
+ _pInputElement._on_sys_animationstart = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ var animation_name = evt.animationName;
+
+ switch (animation_name) {
+ case "nexainput_autofill":
+ {
+
+ pThis.setInputStatusPseudoClass("AUTOFILL", 1);
+
+ if (pThis.inputtype == "password") {
+ nexacro.__changeInputDOMNodeType(input_handle, "password");
+ }
+ break;
+ }
+ case "nexainput_notautofill":
+ {
+
+ pThis.setInputStatusPseudoClass("AUTOFILL", 0);
+
+ if (pThis.value == null && pThis.displaynulltext != "") {
+ nexacro.__changeInputDOMNodeType(input_handle, "text");
+ }
+ break;
+ }
+ }
+ }
+ };
+
+ if (_pInputElement._evtfire_oninput_only_when_backspacekey) {
+ _pInputElement._checkBackspaceKeyInKeyInput = function (old_value, value, begin, end) {
+ var ret = false;
+
+ var old_pos = this._composer.getOffset();
+
+ if (old_value) {
+ if (old_value.length > value.length) {
+ if (end < old_pos.end) {
+ var idx = old_value.substring(0, end).indexOf(value.substring(0, end));
+
+ if (idx == 0) {
+ ret = true;
+ }
+ }
+ }
+ }
+ return ret;
+ };
+
+ _pInputElement._checkSelectionInKeyInput = function (old_value, value, begin, end) {
+ var ret = false;
+
+ if (end - begin != 1) {
+ if (old_value && old_value.length == begin) {
+ if (begin != end) {
+ ret = true;
+ for (var i = 0; i < old_value.length; i++) {
+ if (old_value.charAt(i) != value.charAt(i)) {
+ ret = i;
+ break;
+ }
+
+ if (i == end) {
+ ret = i;
+ break;
+ }
+ }
+ }
+ }
+ }
+ return ret;
+ };
+ }
+ else {
+ _pInputElement._checkBackspaceKeyInKeyInput = function () {
+ return false;
+ };
+ _pInputElement._checkSelectionInKeyInput = function () {
+ return false;
+ };
+ }
+
+
+ _pInputElement = null;
+
+ nexacro.TextAreaElement = function (parent_elem, id) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ this.id = id;
+ this.name = this.parent_elem.name + ":" + (id || "input");
+
+ this._need_reset_update_value = false;
+
+ this._composer = new nexacro._CompositionState();
+ this._imelocale = new nexacro._ImeLocale();
+ };
+
+ var _pTextAreaElement = new nexacro._createPrototype(nexacro.InputElement, nexacro.TextAreaElement);
+ nexacro.TextAreaElement.prototype = _pTextAreaElement;
+
+ _pTextAreaElement._type_name = "TextAreaElement";
+ _pTextAreaElement.typeselector = "nexatextarea";
+
+ _pTextAreaElement.usemultiline = true;
+ _pTextAreaElement._use_html_maxlength = false;
+
+ if (nexacro._BrowserType == "Edge") {
+ _pTextAreaElement._BROWSER_SCROLLBAR_SIZE = 0;
+ }
+ else if (nexacro._Browser == "IE" && nexacro._BrowserVersion == 11) {
+ _pTextAreaElement._BROWSER_SCROLLBAR_SIZE = 0;
+ }
+ else if (nexacro._BrowserType == "WebKit" || nexacro._BrowserType == "Opera") {
+ _pTextAreaElement._BROWSER_SCROLLBAR_SIZE = 0;
+ }
+ else if (nexacro._Browser == "Gecko" || (nexacro._Browser == "IE" && nexacro._BrowserVersion < 9)) {
+ _pTextAreaElement._BROWSER_SCROLLBAR_SIZE = 17;
+ }
+ else {
+ _pTextAreaElement._BROWSER_SCROLLBAR_SIZE = undefined;
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion <= 10) {
+ _pTextAreaElement._use_proto = false;
+ }
+ else {
+ _pTextAreaElement._use_proto = true;
+ }
+
+ _pTextAreaElement._createElementHandle = function (owner_elem, _doc) {
+ var handle = this.handle = _doc.createElement("textarea");
+ var handle_style = handle.style;
+
+ handle.id = this.name;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+ nexacro.__setTextAreaDOMStyle_AbsoluteTransparent(handle.style);
+ handle._linked_element = this;
+
+ this._refreshCommonStyleProps(handle_style);
+
+ var wordWrap = this.wordWrap || this._wordwrap_info;
+
+
+ if (wordWrap) {
+ nexacro.__setTextAreaDOMNode_WordWrap(handle, wordWrap);
+ }
+
+ if (this.textAlign) {
+ nexacro.__setDOMStyle_textAlign(handle_style, this.textAlign, this.rtl);
+ }
+
+ if (this.padding) {
+ nexacro.__setDOMStyle_PaddingObject(handle_style, this.padding, this.rtl);
+ }
+
+ if (!this.enable) {
+ nexacro.__setDOMNode_Enable(handle, false);
+ }
+
+ if (this.readonly) {
+ nexacro.__setDOMNode_ReadOnly(handle, true);
+ }
+
+ if (this.value) {
+ if (this._is_invalid_value && !nexacro._isNull(this.displayinvalidtext)) {
+ nexacro.__setDOMNode_Value(handle, this.displayinvalidtext);
+ }
+ else {
+ nexacro.__setDOMNode_Value(handle, this.value);
+ }
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion == 8) {
+ this._need_reset_update_value = true;
+ }
+ }
+ else if (this.displaynulltext) {
+ nexacro.__setDOMNode_Value(handle, this.displaynulltext);
+ }
+
+ if (this.imemode) {
+ nexacro.__setDOMNode_ImeMode(handle, this.imemode);
+ }
+
+ if (this.maxlength > 0 && this._use_html_maxlength) {
+ nexacro.__setDOMNode_MaxLength(handle, this.maxlength);
+ }
+
+ if (nexacro._enableaccessibility) {
+ nexacro.__setDOMAccessibility_LabelBy(handle, this.parent_elem.name);
+
+ if (nexacro._accessibilitytype == 4 || nexacro._accessibilitytype == 5) {
+ nexacro.__setDOMAccessibility_Role(handle, this.parent_elem.name);
+ }
+ }
+
+ if (this.handle) {
+ nexacro.__appendDOMNode(owner_elem.dest_handle, this.handle);
+ }
+ };
+
+ _pTextAreaElement._destroyInputHandle = function () {
+ if (this.handle) {
+ var dest_handle = (this.owner_elem ? this.owner_elem.dest_handle : null);
+ this.handle._linked_element = null;
+
+ nexacro.__removeDOMNode(dest_handle, this.handle);
+
+ this.handle = null;
+ }
+ };
+
+ _pTextAreaElement.createCommand = function () {
+ var owner_elem = this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this._created) {
+ this.owner_elem = owner_elem;
+ this.rtl = this._isParentRtl();
+
+ var handle_style = this._getCommonStyleStr();
+ handle_style += nexacro.__getTextAreaHTMLStyle_AbsoluteTransparent();
+
+
+ if (!this.enable) {
+ handle_style += nexacro.__getHTMLStyle_Enable(this.enable, this._disabled_color);
+ }
+ if (this.padding) {
+ handle_style += nexacro.__getHTMLStyle_PaddingObject(this.padding, this.rtl);
+ }
+ if (this.textAlign) {
+ handle_style += nexacro.__getHTMLStyle_textAlign(this.textAlign, this.rtl);
+ }
+ if (this.imemode) {
+ if (this._imedisable) {
+ handle_style += nexacro.__getHTMLStyle_ImeMode("disabled");
+ }
+ else {
+ handle_style += nexacro.__getHTMLStyle_ImeMode(this.imemode);
+ }
+ }
+
+ var attr_str = nexacro.__getHTMLAttr_Enable(this.enable) +
+ nexacro.__getHTMLAttr_Wrap(this.wordWrap || this._wordwrap_info) +
+ nexacro.__getHTMLAttr_ReadOnly(this.readonly);
+ if (this.maxlength > 0 && this._use_html_maxlength) {
+ attr_str += nexacro.__getHTMLAttr_MaxLength(this.maxlength);
+ }
+
+ var str = "
";
+
+ return str;
+ }
+
+ return "";
+ };
+
+ if ((nexacro._Browser == "IE" && nexacro._BrowserVersion < 10) || nexacro._BrowserType == "IE10" || nexacro._OS == "iOS") {
+ _pTextAreaElement.setElementSize = function (width, height) {
+ if (this.width != width || this.height != height) {
+ var parent_elem = this.parent_elem;
+ var padding = parent_elem.padding ? parent_elem.padding : parent_elem._padding_info;
+ if (padding) {
+ width -= padding.left + padding.right;
+ height -= padding.top + padding.bottom;
+ }
+ this.width = width + this._getOverflowScrollSize();
+ this.height = height + this._getOverflowScrollSize();
+
+ if (width < 0) {
+ width = 0;
+ }
+ if (height < 0) {
+ height = 0;
+ }
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ var pos_before = this.getElementCaretPos();
+
+ nexacro.__setDOMStyle_Size(input_handle.style, this.width, this.height);
+
+ var pos_after = this.getElementCaretPos();
+ if ((pos_before != -1 && pos_after != -1) && (pos_before.begin != pos_after.begin || pos_before.end != pos_after.end)) {
+ this.setElementSetSelect(0, 0);
+ this.setElementSetSelect(pos_before.begin, pos_before.end);
+ }
+ }
+ }
+ };
+ }
+ else {
+ _pTextAreaElement.setElementSize = function (width, height) {
+ var scrollsize = this._getOverflowScrollSize();
+ width += scrollsize;
+ height += scrollsize;
+ if (this.width != width || this.height != height) {
+ this.width = width;
+ this.height = height;
+
+ if (width < 0) {
+ width = 0;
+ }
+ if (height < 0) {
+ height = 0;
+ }
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ var pos_before = this.getElementCaretPos();
+
+ nexacro.__setDOMStyle_Size(input_handle.style, this.width, this.height);
+
+ var pos_after = this.getElementCaretPos();
+ if ((pos_before != -1 && pos_after != -1) && (pos_before.begin != pos_after.begin || pos_before.end != pos_after.end)) {
+ this.setElementSetSelect(0, 0);
+ this.setElementSetSelect(pos_before.begin, pos_before.end);
+ }
+ }
+ }
+ };
+ }
+
+ _pTextAreaElement._applyMaxlength = function () {
+ var input_handle = this.handle;
+ if (this._checkmax_editing_only) {
+ var newValue = this.value;
+ if (!nexacro._isNull(newValue)) {
+ if (this.maxlength > 0 && newValue.length > this.maxlength) {
+ newValue = newValue.substring(0, this.maxlength);
+ }
+ }
+ else {
+ newValue = this.defaultvalue;
+ }
+
+ var domValue = this._getInputValue();
+ if (domValue !== newValue) {
+ this._updateInputValue(newValue);
+ if (nexacro._isNull(this.value)) {
+ nexacro.__setDOMNode_Type(input_handle, this.inputtype);
+ nexacro.__setDOMStyle_ColorObject(input_handle.style, "");
+ }
+ }
+ }
+ };
+
+ _pTextAreaElement.setElementFocus = function (trigger_type, self_flag) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ var _doc;
+ if (!this._is_focused) {
+ this._is_focused = true;
+ this._applyMaxlength();
+ }
+
+ if (!this._is_sys_focused) {
+ if (trigger_type == "lbutton" || trigger_type == "lbuttondown" || trigger_type == "rbuttondown" ||
+ trigger_type == "touch" || trigger_type == "tap" || trigger_type == "longpress") {
+ if (!(nexacro._OS == "iOS" && nexacro._enableaccessibility)) {
+ this._change_to_keypad_type();
+ }
+ }
+
+ if (nexacro._BrowserType == "Edge") {
+ if (self_flag !== true || trigger_type != "lbuttondown") {
+ nexacro.__setInputDOMNodeFocus(input_handle);
+
+ if (!this.autoselect && trigger_type != undefined && trigger_type != "lbutton") {
+ _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, 0, 0);
+ }
+ }
+ }
+ }
+ else if (nexacro._Browser == "IE" && nexacro._BrowserVersion == 8) {
+ if (self_flag !== true || trigger_type != "lbuttondown") {
+ if (!this.autoselect) {
+ _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, 0, 0);
+
+ setTimeout(function () {
+ nexacro.__setInputDOMNodeFocus(input_handle);
+ }, 0);
+ }
+ }
+ else {
+ nexacro.__setInputDOMNodeFocus(input_handle);
+ }
+ }
+ }
+ else {
+ if (nexacro._Browser == "Chrome" || nexacro._Browser == "Gecko") {
+ if (self_flag !== true || trigger_type == undefined) {
+ _doc = this._getRootWindowHandle();
+ if (_doc) {
+ nexacro.__setDOMNode_SetSelect(_doc, input_handle, 0, 0);
+ }
+ }
+ }
+
+ if (!(nexacro._OS == "iOS" && this.inputtype == "date")) {
+ nexacro.__setInputDOMNodeFocus(input_handle, trigger_type);
+ }
+ }
+ }
+ nexacro.__setLastFocusedElement(this);
+ }
+ };
+
+ _pTextAreaElement.setElementEnable = function (enable, color) {
+ if (this.enable != enable) {
+ this.enable = enable;
+
+ if (!enable) {
+ this._disabled_color = color;
+ }
+ else {
+ this._disabled_color = null;
+ }
+
+ var input_handle = this.handle;
+ if (input_handle) {
+ nexacro.__setTextAreaDOMNode_Enable(input_handle, enable);
+ nexacro.__setDOMStyle_ColorObject(input_handle.style, this.color);
+ }
+ }
+ };
+
+ _pTextAreaElement.setElementCSSMapInfo = function (wordwrap) {
+ if (this._wordwrap_info != wordwrap) {
+ var oldwordwrap = this.wordWrap || this._wordwrap_info;
+ this._wordwrap_info = wordwrap;
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this.wordWrap && oldwordwrap != wordwrap) {
+ nexacro.__setTextAreaDOMNode_Wrap(input_handle, wordwrap);
+ }
+ }
+ }
+ };
+
+ _pTextAreaElement.setElementWordWrap = function (wordWrap) {
+ if (this.wordWrap != wordWrap) {
+ this.wordWrap = wordWrap;
+ var input_handle = this.handle;
+
+ if (input_handle) {
+ nexacro.__setTextAreaDOMNode_WordWrap(input_handle, wordWrap);
+
+ if (!this._is_focused && this.value == null && this.displaynulltext) {
+ this._updateInputValue(this.displaynulltext);
+ }
+ else {
+ if (this._is_invalid_value && !nexacro._isNull(this.displayinvalidtext)) {
+ this._updateInputValue(this.displayinvalidtext);
+ }
+ else {
+ this._updateInputValue(this.getElementText());
+ }
+ }
+ }
+ }
+ };
+
+ _pTextAreaElement.setElementValue = function (value) {
+ if (value) {
+ value = value.replace(/\r\n/g, "\n");
+ }
+ this._setElementValue(value);
+ };
+
+ _pTextAreaElement._setElementValue = function (value) {
+ var comp = this.parent.linkedcontrol;
+ var html_position_style = nexacro._getHTMLPositionStyle();
+ if (html_position_style) {
+ nexacro._setHTMLPositionStyle("absolute");
+ }
+ nexacro.InputElement.prototype.setElementValue.call(this, value);
+ if (html_position_style) {
+ nexacro._OnceCallbackTimer.callonce(comp, function () {
+ nexacro._setHTMLPositionStyle(html_position_style);
+ });
+ }
+ };
+
+ _pTextAreaElement.updateElementText = function (value, caretpos) {
+ if (value) {
+ value = value.replace(/\r\n/g, "\n");
+ }
+
+ nexacro.InputElement.prototype.updateElementText.call(this, value, caretpos);
+ };
+
+ _pTextAreaElement._updateElementValue = function (value) {
+ if (value) {
+ value = value.replace(/\r\n/g, "\n");
+ }
+
+ nexacro.InputElement.prototype._updateElementValue.call(this, value);
+ };
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 9) {
+ _pTextAreaElement._getInputValue = function () {
+ var value = nexacro.InputElement.prototype._getInputValue.call(this);
+ if (value) {
+ return value.replace(/\r\n/g, "\n");
+ }
+ return value;
+ };
+ }
+ else {
+ _pTextAreaElement._getInputValue = function () {
+ return nexacro.InputElement.prototype._getInputValue.call(this);
+ };
+ }
+
+ _pTextAreaElement.on_reset_update_value = function (resetpos) {
+ return true;
+ };
+
+ _pTextAreaElement.setElementInputType = function (type, bImedisable) {
+ var input_handle = this.handle;
+
+ if (this._imedisable != bImedisable) {
+ this._imedisable = bImedisable ? bImedisable : false;
+ if (input_handle) {
+ nexacro.__setDOMNode_ImeMode(input_handle, this._imedisable ? "disabled" : this.imemode);
+ }
+ }
+ };
+
+ _pTextAreaElement.setElementSetSelect = function (start, end) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ var value = this._getInputValue();
+ end = (typeof end == 'number') ? (end == -1 ? value.length : end) : start;
+
+ this._setElementLastSelectionRange([start, end]);
+
+ if (this._is_focused) {
+ nexacro.__setTextAreaDOMNodeSetSelect(this._getRootWindowHandle(), input_handle, start, end);
+ }
+ }
+ };
+
+ _pTextAreaElement.getElementCaretPos = function () {
+ var input_handle = this.handle;
+ if (input_handle && this._is_focused) {
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ return nexacro.__getTextAreaDOMNodeCaretPos(_doc, input_handle);
+ }
+ }
+ return -1;
+ };
+
+ _pTextAreaElement.getElementSelectionRange = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused && this._last_selection_range) {
+ return this._last_selection_range;
+ }
+
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ var sel = nexacro.__getTextAreaDOMNodeSelectionRange(_doc, input_handle);
+ return sel.slice(0, 2);
+ }
+ }
+ return [0, 0];
+ };
+
+ _pTextAreaElement.getElementCaretLine = function () {
+ var input_handle = this.handle;
+ if (input_handle && this._is_focused) {
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ return nexacro.__getTextAreaDOMNodeCaretLine(_doc, input_handle, this.wordWrap, this.font);
+ }
+ }
+ return 0;
+ };
+
+ _pTextAreaElement.getElementTextLineCount = function (withwrap) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ var wordWrap = withwrap ? this.wordWrap : "none";
+ return nexacro.__getTextAreaDOMNodeTextLineCount(_doc, input_handle, input_handle.value, wordWrap, this.font);
+ }
+ }
+ return 0;
+ };
+
+ _pTextAreaElement.isFirstCaretLine = function () {
+ var input_handle = this.handle;
+ if (input_handle && this._is_focused) {
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ var sel = nexacro.__getTextAreaDOMNodeSelectionRange(_doc, input_handle);
+
+ var start = sel[0], end = sel[1], direction = sel[2];
+ var text = this._getInputValue();
+
+ if (direction == "none" || direction == "backward") {
+ text = text.slice(0, start);
+ }
+ else {
+ text = text.slice(0, end);
+ }
+
+ if (text == "") {
+ return true;
+ }
+
+ if (/[\r\n]/g.test(text)) {
+ return false;
+ }
+
+ var lines = nexacro.__getTextAreaDOMNodeTextLineCount(_doc, input_handle, text, this.wordWrap, this.font);
+ if (lines <= 1) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+
+ _pTextAreaElement.isLastCaretLine = function () {
+ var input_handle = this.handle;
+ if (input_handle && this._is_focused) {
+ var _doc = this._getRootWindowHandle();
+ if (_doc) {
+ var sel = nexacro.__getTextAreaDOMNodeSelectionRange(_doc, input_handle);
+
+ var end, direction = sel[2];
+ var text = this._getInputValue();
+
+ var remain_text;
+ if (direction == "backward") {
+ end = sel[0];
+ }
+ else {
+ end = sel[1];
+ }
+
+ remain_text = text.slice(end);
+ if (remain_text == "") {
+ return true;
+ }
+
+ if (/[\r\n]/g.test(remain_text)) {
+ return false;
+ }
+
+ var newline = text.lastIndexOf('\n');
+ if (newline < 0) {
+ newline = text.lastIndexOf('\r');
+ }
+ if (newline >= 0) {
+ newline += 1;
+ }
+ else {
+ newline = 0;
+ }
+
+ var full_text = text.slice(newline);
+ var full_lines = nexacro.__getTextAreaDOMNodeTextLineCount(_doc, input_handle, full_text, this.wordWrap, this.font);
+
+ var prev_text = text.slice(newline, end);
+ var prev_lines = nexacro.__getTextAreaDOMNodeTextLineCount(_doc, input_handle, prev_text, this.wordWrap, this.font);
+
+ if (full_lines == prev_lines) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+
+ _pTextAreaElement.setElementScrollPos = function (hpos, vpos) {
+ if (hpos < 0) {
+ hpos = 0;
+ }
+ if (vpos < 0) {
+ vpos = 0;
+ }
+
+ this.setElementHScrollPos(hpos);
+ this.setElementVScrollPos(vpos);
+ };
+
+ _pTextAreaElement.getElementHScrollPos = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused && this.value == null && this.displaynulltext) {
+ return 0;
+ }
+ if (this.rtl) {
+ return (input_handle.scrollWidth - input_handle.clientWidth - input_handle.scrollLeft);
+ }
+ else {
+ return input_handle.scrollLeft;
+ }
+ }
+ return 0;
+ };
+
+ _pTextAreaElement.setElementHScrollPos = function (v) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused && this.value == null && this.displaynulltext) {
+ return;
+ }
+ if (this.rtl) {
+ input_handle.scrollLeft = (input_handle.scrollWidth - input_handle.clientWidth - v);
+ }
+ else {
+ input_handle.scrollLeft = v;
+ }
+ }
+ };
+
+ _pTextAreaElement.getElementVScrollPos = function () {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused && this.value == null && this.displaynulltext) {
+ return 0;
+ }
+
+ return input_handle.scrollTop;
+ }
+ return 0;
+ };
+
+ _pTextAreaElement.setElementVScrollPos = function (v) {
+ var input_handle = this.handle;
+ if (input_handle) {
+ if (!this._is_focused && this.value == null && this.displaynulltext) {
+ return;
+ }
+ input_handle.scrollTop = v;
+ }
+ };
+
+ _pTextAreaElement.getElementScrollWidth = function () {
+ var input_handle = this.handle;
+ var ret = 0;
+ if (input_handle) {
+ var scrollmax = input_handle.scrollWidth - input_handle.clientWidth;
+ ret = this.parent_elem.client_width + scrollmax;
+ }
+ return ret;
+ };
+
+ _pTextAreaElement.getElementScrollHeight = function () {
+ var input_handle = this.handle;
+ var ret = 0;
+ if (input_handle) {
+ var scrollmax = input_handle.scrollHeight - input_handle.clientHeight;
+ ret = this.parent_elem.client_height + scrollmax;
+ }
+ return ret;
+ };
+
+ _pTextAreaElement._getOverflowScrollSize = function () {
+ if (this._BROWSER_SCROLLBAR_SIZE === undefined) {
+ nexacro.TextAreaElement.prototype._BROWSER_SCROLLBAR_SIZE = nexacro.__getOverflowScrollSize();
+ }
+
+ var ret = this._BROWSER_SCROLLBAR_SIZE;
+ if (nexacro._Browser == "Gecko") {
+ var ratio = window.devicePixelRatio;
+ ret = ret / (ratio ? ratio : 1);
+ }
+
+ return ret;
+ };
+
+ _pTextAreaElement._bindSysEvent = function () {
+ var input = this.handle;
+ if (input) {
+ nexacro.InputElement.prototype._bindSysEvent.call(this);
+ nexacro._observeSysEvent(input, "scroll", "onscroll", this._on_sys_scroll);
+ }
+ };
+
+ _pTextAreaElement._unbindSysEvent = function () {
+ var input = this.handle;
+ if (input) {
+ nexacro.InputElement.prototype._unbindSysEvent.call(this);
+ nexacro._stopSysObserving(input, "scroll", "onscroll", this._on_sys_scroll);
+ }
+ };
+
+ _pTextAreaElement._on_sys_scroll = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ if (input_handle) {
+ var pThis = input_handle._linked_element;
+ if (pThis) {
+ var parent_elem = pThis.parent_elem;
+ var comp = parent_elem.linkedcontrol;
+ var _win = comp._getWindow();
+
+ var evtid = "";
+ var scrolltype = parent_elem._scrolltype;
+
+ var pos = pThis.getElementCaretPos();
+
+ var bWheel = false;
+ var bResetPos = false;
+ var bScroll = false;
+ if (_win && (_win._cur_ldown_elem || _win._cur_mdown_elem)) {
+ if (_win._cur_mdown_elem) {
+ bWheel = true;
+ }
+ bResetPos = true;
+ }
+ else if (nexacro._isTouchInteraction) {
+ if (_win && _win._cur_touch_elem || (pos && pos != -1 && pos.begin != pos.end)) {
+ bResetPos = true;
+ }
+ }
+
+ if (bResetPos) {
+ var hscroll_pos = parent_elem.scroll_left;
+ var vscroll_pos = parent_elem.scroll_top;
+
+ if (hscroll_pos != input_handle.scrollLeft) {
+ if (scrolltype != "none" && scrolltype != "vertical" && !comp._is_tracking) {
+ if (pThis.rtl) {
+ var rtlhscroll_pos = (input_handle.scrollWidth - input_handle.clientWidth - input_handle.scrollLeft);
+ if (hscroll_pos != rtlhscroll_pos) {
+ bScroll = true;
+ }
+ }
+ else {
+ hscroll_pos = input_handle.scrollLeft;
+ bScroll = true;
+ }
+ }
+ if (bWheel) {
+ evtid = "mousewheel_h";
+ }
+ }
+
+ if (vscroll_pos != input_handle.scrollTop) {
+ if (scrolltype != "none" && scrolltype != "horizontal" && !comp._is_tracking) {
+ vscroll_pos = input_handle.scrollTop;
+ bScroll = true;
+ }
+ if (bWheel) {
+ evtid = "mousewheel_v";
+ }
+ }
+
+ if (bScroll) {
+ comp._scrollTo(hscroll_pos, vscroll_pos, true, false, undefined, evtid);
+ }
+ }
+ }
+ }
+ };
+
+ _pTextAreaElement._on_sys_paste = function (evt) {
+ var input_handle = (evt.target || evt.srcElement);
+ var pThis = input_handle._linked_element;
+
+ if (!pThis.on_sys_paste_before_process.call(pThis, evt)) {
+ return false;
+ }
+
+ var data;
+ if (evt.clipboardData && evt.clipboardData.getData) {
+ data = evt.clipboardData.getData('text/plain');
+ }
+ else if (window.clipboardData && window.clipboardData.getData) {
+ data = window.clipboardData.getData('text');
+ }
+
+ if (input_handle && !input_handle._linked_element._use_event_beforeinput && data) {
+ var value = pThis._getInputValue();
+
+ var pos = pThis.getElementCaretPos();
+ var begin = pos.begin;
+ var end = pos.end;
+
+ data = data.replace(/"/g, "\"");
+
+ if (data.indexOf("\r\n") != -1 || data.indexOf("\n\r") != -1) {
+ data = data.replace(/\r\n|\n\r/g, "\n");
+ }
+
+ if (data.indexOf("\r") != -1) {
+ data = data.replace(/\r/g, "");
+ }
+
+ var newvalue = value.substring(0, begin) + data + value.substring(end);
+ var newpos = begin + data.length;
+ pos.end = newpos;
+ nexacro._stopSysEvent(evt);
+
+
+
+ pThis._paste_caret_pos = pos;
+ pThis._updateInputValue(newvalue, true, newpos);
+ pThis._paste_caret_pos = null;
+
+ pos = pThis.getElementCaretPos();
+
+
+ setTimeout(function () {
+ pThis.setElementSetSelect(pos.begin, pos.end);
+ }, 0);
+
+ return false;
+ }
+ };
+
+ _pTextAreaElement.on_apply_imeSet = function (evt) {
+ var i, len;
+ var input_handle = evt ? (evt.target || evt.srcElement) : this.handle;
+ var pThis = input_handle ? input_handle._linked_element : this;
+
+ var _locale = pThis._imelocale.getLocale();
+ if (_locale && nexacro._cache_inputelement_set[_locale] && nexacro._cache_textareaelement_set[_locale]) {
+ if (this._use_proto) {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis.__proto__[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+
+ for (var prop in nexacro._cache_inputelement_set[_locale]) {
+ pThis.__proto__[prop] = nexacro._cache_inputelement_set[_locale][prop];
+ }
+ }
+ else {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+
+ for (var prop in nexacro._cache_inputelement_set[_locale]) {
+ pThis[prop] = nexacro._cache_inputelement_set[_locale][prop];
+ }
+ }
+
+ for (var prop in nexacro._cache_textareaelement_set[_locale]) {
+ pThis[prop] = nexacro._cache_textareaelement_set[_locale][prop];
+ }
+
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ if (!nexacro._cache_inputelement_set[_locale][nexacro._inputelement_user_override_func[i]] &&
+ !nexacro._cache_textareaelement_set[_locale][nexacro._inputelement_user_override_func[i]] &&
+ pThis[nexacro._inputelement_user_override_func[i]] !== nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]]) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.TextAreaElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ }
+ else if (_locale && nexacro._cache_inputelement_set[_locale]) {
+ if (this._use_proto) {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis.__proto__[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+
+ for (var prop in nexacro._cache_inputelement_set[_locale]) {
+ pThis.__proto__[prop] = nexacro._cache_inputelement_set[_locale][prop];
+ }
+ }
+ else {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+
+ for (var prop in nexacro._cache_inputelement_set[_locale]) {
+ pThis[prop] = nexacro._cache_inputelement_set[_locale][prop];
+ }
+ }
+
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ if (!nexacro._cache_inputelement_set[_locale][nexacro._inputelement_user_override_func[i]] &&
+ pThis[nexacro._inputelement_user_override_func[i]] !== nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]]) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.TextAreaElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ }
+ else if (_locale && nexacro._cache_textareaelement_set[_locale]) {
+ if (this._use_proto) {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis.__proto__[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ else {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+
+ for (var prop in nexacro._cache_textareaelement_set[_locale]) {
+ pThis[prop] = nexacro._cache_textareaelement_set[_locale][prop];
+ }
+
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ if (!nexacro._cache_textareaelement_set[_locale][nexacro._inputelement_user_override_func[i]] &&
+ pThis[nexacro._inputelement_user_override_func[i]] !== nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]]) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.TextAreaElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ }
+ else {
+ if (this._use_proto) {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis.__proto__[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ else {
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+
+ for (i = 0, len = nexacro._inputelement_user_override_func.length; i < len; i++) {
+ if (pThis[nexacro._inputelement_user_override_func[i]] !== nexacro.InputElement.prototype[nexacro._inputelement_user_override_func[i]]) {
+ pThis[nexacro._inputelement_user_override_func[i]] = nexacro.TextAreaElement.prototype[nexacro._inputelement_user_override_func[i]];
+ }
+ }
+ }
+
+ var comp = pThis.parent_elem.linkedcontrol;
+ if (comp.on_apply_imeSet) {
+ comp.on_apply_imeSet();
+ }
+
+ pThis.on_apply_ime_environment(evt);
+ };
+
+
+
+ _pTextAreaElement = null;
+
+ nexacro.ControlElement = function (parent_elem) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ };
+
+ var _pControlElement = nexacro._createPrototype(nexacro.Element, nexacro.ControlElement);
+ nexacro.ControlElement.prototype = _pControlElement;
+ _pControlElement._type_name = "ControlElement";
+
+ _pControlElement.enable = true;
+ _pControlElement.tabindex = -1;
+ _pControlElement.zindex = -1;
+
+ _pControlElement.color = null;
+ _pControlElement.font = null;
+ _pControlElement.textDecoration = null;
+
+ _pControlElement.borderRadius = null;
+ _pControlElement.border = null;
+ _pControlElement.background = null;
+ _pControlElement.edge = null;
+
+ _pControlElement.padding = null;
+
+ _pControlElement.cursor = null;
+ _pControlElement.opacity = null;
+ _pControlElement.boxShadow = null;
+
+ _pControlElement.position_step = undefined;
+ _pControlElement.linkedcontrol = null;
+
+ _pControlElement.inner_width = 0;
+ _pControlElement.inner_height = 0;
+ _pControlElement.client_left = 0;
+ _pControlElement.client_top = 0;
+ _pControlElement.client_width = 0;
+ _pControlElement.client_height = 0;
+
+ _pControlElement._client_left = 0;
+ _pControlElement._client_top = 0;
+
+ _pControlElement._classname = "";
+
+ _pControlElement._is_popup = false;
+ _pControlElement.zoom = 100;
+
+ _pControlElement._edge_elem = null;
+ _pControlElement._apply_client_padding = true;
+ _pControlElement._border_info = null;
+ _pControlElement._padding_info = null;
+ _pControlElement._edge_info = null;
+
+ _pControlElement.accessibilityrole = "";
+ _pControlElement.accessibilityenable = true;
+ _pControlElement.accessibilitylabel = "";
+ _pControlElement.accessibilitydesclevel = "";
+ _pControlElement.accessibilitydescription = "";
+ _pControlElement.accessibilityaction = "";
+ _pControlElement.accessibility_value = undefined;
+ _pControlElement.accessibility_stat_disabled = undefined;
+ _pControlElement.accessibility_stat_hidden = undefined;
+ _pControlElement.accessibility_stat_checked = undefined;
+ _pControlElement.accessibility_stat_pressed = undefined;
+ _pControlElement.accessibility_stat_selected = undefined;
+ _pControlElement.accessibility_stat_expanded = undefined;
+ _pControlElement.accessibility_stat_autocomplete = undefined;
+ _pControlElement.accessibility_flag_haspopup = undefined;
+ _pControlElement.accessibility_flag_focusable = undefined;
+ _pControlElement.accessibility_flag_readonly = undefined;
+ _pControlElement.accessibility_flag_password = undefined;
+ _pControlElement.accessibility_flag_multiselectable = undefined;
+ _pControlElement.accessibility_flag_selectable = undefined;
+ _pControlElement.accessibility_flag_defaultbutton = undefined;
+ _pControlElement.accessibility_prop_itemcount = undefined;
+ _pControlElement.accessibility_prop_itemindex = undefined;
+ _pControlElement.accessibility_prop_valuemax = undefined;
+ _pControlElement.accessibility_prop_valuemin = undefined;
+
+ _pControlElement.create = nexacro._emptyFn;
+ _pControlElement.destroy = nexacro._emptyFn;
+ _pControlElement.clearContents = nexacro._emptyFn;
+
+ _pControlElement.setElementStepCount = nexacro._emptyFn;
+ _pControlElement.setElementStepIndex = nexacro._emptyFn;
+
+ _pControlElement.borderLeftNone = false;
+ _pControlElement.borderTopNone = false;
+ _pControlElement.borderRightNone = false;
+ _pControlElement.borderBottomNone = false;
+
+ _pControlElement.create = function (win) {
+ var _doc, owner_elem, handle;
+ var handle_style;
+ if (!this._is_popup) {
+ owner_elem = (this._is_nc_element) ? this.parent_elem : this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && owner_elem.handle) {
+ if (!this.handle) {
+ this.owner_elem = owner_elem;
+ _doc = win._doc || owner_elem._getRootWindowHandle();
+
+ handle = _doc.createElement("div");
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ var bPositionRtl = this._isParentRtl();
+ this.handle = this.dest_handle = handle;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+
+ if (!this._is_simple_control) {
+ var inner_node = _doc.createElement("div");
+ this.dest_handle = inner_node;
+ nexacro.__setDOMNode_ClassName(inner_node, this._getElementNexaClassName("nexasimplecontainer"));
+ nexacro.__setDOMNode_Id(inner_node, "", "nexacontainer");
+
+ nexacro.__appendDOMNode(handle, inner_node);
+
+ var innernodestyle = inner_node.style;
+ nexacro.__setDOMStyle_Pos(innernodestyle, this.client_left, this.client_top, bPositionRtl);
+ if (this.client_width && this.client_height) {
+ nexacro.__setDOMStyle_Size(innernodestyle, this.client_width, this.client_height);
+ }
+ }
+ handle_style = handle.style;
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top, bPositionRtl);
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+
+
+ this._refreshControl(handle, handle_style, _doc);
+
+ if (this._isMultiInnerProc()) {
+ nexacro.__appendDOMNode((this._is_nc_element) ? owner_elem.handle : owner_elem._getDestHandle(this.top), handle);
+ }
+ else {
+ nexacro.__appendDOMNode((this._is_nc_element) ? owner_elem.handle : owner_elem.dest_handle, handle);
+ }
+ }
+ }
+ }
+ else {
+ _doc = this._doc = win._doc;
+ owner_elem = win;
+
+ handle = _doc.createElement("div");
+ var linkedcontrol = this.linkedcontrol;
+
+ handle._linked_element = this;
+ handle.id = this.name;
+
+ this.handle = this.dest_handle = handle;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+
+ handle_style = handle.style;
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top);
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+
+ if (linkedcontrol._findOwnerElementHandle) {
+ var owner_elem_info = linkedcontrol._findOwnerElementHandle();
+ if (owner_elem_info.is_append) {
+ if (owner_elem_info.ref_handle) {
+ nexacro.__appendDOMNode(owner_elem_info.ref_handle, handle);
+ }
+ else {
+ nexacro.__appendDOMNode(owner_elem_info.owner_handle, handle);
+ }
+ this.owner_elem = owner_elem_info.owner_handle._linked_element;
+ }
+ else {
+ nexacro.__insertDOMNode(owner_elem_info.owner_handle, handle, owner_elem_info.ref_handle);
+ this.owner_elem = owner_elem.dest_handle._linked_element;
+ }
+ }
+ else {
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+ this.owner_elem = owner_elem;
+ }
+
+ this._refreshControl(handle, handle_style, _doc);
+
+ this._frame_node = nexacro._createFrameNode(handle, this.left, this.top, _doc, this.width, this.height);
+ if (this._frame_node) {
+ this._frame_node._linked_element = this;
+ nexacro._observeSysEvent(this._frame_node, "load", "onload", this._iframe_eventhandler_onload);
+ }
+ }
+ };
+
+ _pControlElement._iframe_eventhandler_onload = function (evt) {
+ if (window.event) {
+ evt = window.event;
+ }
+ var node = evt.target;
+ if (!node) {
+ return;
+ }
+
+ try {
+ var _doc = node.contentDocument || node.contentWindow.document;
+ if (this._linked_element) {
+ nexacro._observeSysEvent(_doc, "contextmenu", "oncontextmenu", this._linked_element._iframe_eventhandler_oncontextmenu);
+ }
+ }
+ catch (e) {
+ }
+ };
+
+ _pControlElement._iframe_eventhandler_oncontextmenu = function (evt) {
+ return nexacro._stopSysEvent(evt);
+ };
+
+ _pControlElement._getControlStatusStr = function () {
+ var str = "";
+ if (this.status) {
+ str += nexacro.__getHTMLAttr_Status(this.status);
+ }
+
+ if (this.userstatus) {
+ str += nexacro.__getHTMLAttr_UserStatus(this.userstatus);
+ }
+ return str;
+ };
+
+ _pControlElement.createCommandStart = function () {
+ if (!this._is_popup) {
+ var owner_elem = (this._is_nc_element) ? this.parent_elem : this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && !this.handle) {
+ this.owner_elem = owner_elem;
+ var str = "
") : ">";
+
+ var edge_elem = this._edge_elem;
+ if (edge_elem) {
+ str += edge_elem.createCommand();
+ }
+
+ if (this._client_elem && !this._is_popup) {
+ str += this._client_elem.createCommandStart();
+ }
+ else if (!this._is_simple_control) {
+ style_str = "";
+ if (this.client_left || this.client_top) {
+ style_str += nexacro.__getHTMLStyle_Pos(this.client_left, this.client_top, this._isParentRtl());
+ }
+ if (this.client_width && this.client_height) {
+ style_str += nexacro.__getHTMLStyle_Size(this.client_width, this.client_height);
+ }
+ str += "
") : " >";
+ }
+
+ return str;
+ }
+ }
+ return "";
+ };
+
+ _pControlElement._on_createCommandEnd = function () {
+ return "";
+ };
+
+ _pControlElement.createCommandEnd = function () {
+ if (!this._is_popup) {
+ var str = "";
+ if (this._client_elem && !this._is_popup) {
+ str = this._client_elem.createCommandEnd();
+ }
+ else if (!this._is_simple_control) {
+ str += "
";
+ }
+
+ str += this._on_createCommandEnd();
+ str += "
";
+ return str;
+ }
+ return "";
+ };
+
+ _pControlElement._on_attachHandle = nexacro._emptyFn;
+ _pControlElement.attachHandle = function (win) {
+ if (this.name && !this.handle) {
+ var handle = win._doc.getElementById(this.name);
+ if (handle) {
+ handle._linked_element = this;
+
+ if (this._is_simple_control) {
+ this.handle = this.dest_handle = handle;
+ }
+ else if (this._client_elem) {
+ this.handle = this.dest_handle = handle;
+ this._client_elem.attachHandle(win);
+ }
+ else {
+ this.handle = handle;
+ this.dest_handle = handle.lastChild;
+ }
+
+ var edge_elem = this._edge_elem;
+ if (edge_elem) {
+ edge_elem.attach_handle_fromparent(handle);
+ }
+
+ this._setAccessibility_notify();
+
+ this._on_attachHandle(win);
+ }
+ }
+ };
+
+ _pControlElement._on_destroy = nexacro._emptyFn;
+
+ _pControlElement.destroy = function () {
+ var handle = this.handle;
+ if (handle) {
+ this._removeElementHandle();
+ this.dest_handle = null;
+
+ if (this._is_popup) {
+ nexacro._destroyFrameNode(handle, this._frame_node);
+ this._frame_node = null;
+ }
+ if (this._edge_elem) {
+ this._edge_elem.destroy();
+ this._edge_elem = null;
+ }
+
+ if (this._client_elem) {
+ this._client_elem.destroy();
+ this._client_elem = null;
+ }
+
+ this._on_destroy();
+ }
+ this.owner_elem = null;
+ this.handle = null;
+ this.parent = null;
+ this.parent_elem = null;
+ this.linkedcontrol = null;
+ };
+
+ _pControlElement.initElementInfo = function () {
+ var control = this.linkedcontrol;
+
+ this.client_width = 0;
+ this.client_height = 0;
+
+ this._is_simple_control = control._is_simple_control;
+ this._is_popup = control._is_popup_control;
+
+ this._use_translate_move = (control._use_translate_move === false) ? control._use_translate_move : nexacro._use_translate_scroll;
+ this._use_container_move = control._use_container_move;
+
+ this._apply_client_padding = control._apply_client_padding;
+ };
+
+ _pControlElement.setLinkedControl = function (control) {
+ if (!this.linkedcontrol && control) {
+ this.parent = control;
+ this.linkedcontrol = control;
+ this.id = control.id;
+ this.name = control._unique_id;
+ }
+ };
+
+ _pControlElement.setElementPositionStep = function (position_step) {
+ if (this.position_step != position_step || position_step == -1) {
+ this.position_step = position_step;
+
+ var handle = this.handle;
+ if (handle && this.parent_elem) {
+ var old_owner_elem = this.owner_elem;
+ var owner_elem = this.parent_elem.getContainerElement(position_step);
+ if (old_owner_elem && old_owner_elem.dest_handle && owner_elem && owner_elem.dest_handle) {
+ nexacro.__unlinkDOMNode(old_owner_elem.dest_handle, this.handle);
+ nexacro.__appendDOMNode(owner_elem.dest_handle, this.handle);
+ this.owner_elem = owner_elem;
+ }
+ }
+ }
+ };
+
+ _pControlElement._on_clearContents = nexacro._emptyFn;
+ _pControlElement.clearContents = function () {
+ if (this.handle && this._client_elem) {
+ this._client_elem.clearContents();
+ this._on_clearContents();
+ }
+ };
+
+ _pControlElement.appendChildElement = function (child_elem) {
+ if (this.handle) {
+ if (child_elem.parent_elem != this) {
+ child_elem.parent_elem = this;
+ }
+
+ if (!child_elem.handle) {
+ child_elem.create(this._getWindow());
+ }
+ else {
+ child_elem._appendToContainer(this.getContainerElement(child_elem.position_step));
+ }
+ }
+ };
+
+ _pControlElement.insertChildElement = function (child_elem, before_elem) {
+ if (this.handle) {
+ if (child_elem.parent_elem != this) {
+ child_elem.parent_elem = this;
+ }
+
+ if (!child_elem.handle) {
+ child_elem.create(this._getWindow());
+ }
+ else {
+ child_elem._insertToContainer(this.getContainerElement(child_elem.position_step), before_elem);
+ }
+ }
+ };
+
+ _pControlElement.removeChildElement = function (child_elem) {
+ if (child_elem.parent_elem == this) {
+ child_elem._removeFromContainer();
+ }
+ };
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 9) {
+ _pControlElement._getComputedStyle = function (prop, noflush) {
+ var handle = this.handle;
+ if (handle && prop) {
+ return handle.currentStyle[prop];
+ }
+ };
+
+ _pControlElement._getComputedStyleBackgroundColor = function (noflush) {
+ var handle = this.handle;
+ if (handle) {
+ return handle.currentStyle["backgroundColor"];
+ }
+ };
+ }
+ else {
+ _pControlElement._getComputedStyle = function (prop, noflush) {
+ var handle = this.handle;
+ if (handle && prop) {
+ var style = window.getComputedStyle(handle, null);
+ return style.getPropertyValue(prop);
+ }
+ };
+
+ _pControlElement._getComputedStyleBackgroundColor = function (noflush) {
+ var handle = this.handle;
+ if (handle) {
+ var style = window.getComputedStyle(handle, null);
+ return style.getPropertyValue("background-color");
+ }
+ };
+ }
+
+ _pControlElement._flushCommand = nexacro._emptyFn;
+ _pControlElement._getComputedStyleSubValue = nexacro._emptyFn;
+
+
+
+
+ _pControlElement._sendToBackElement = function (elem) {
+ if (elem && elem.owner_elem == this && elem.handle) {
+ nexacro.__sendDOMNodeToBack(elem.handle);
+ }
+ };
+ _pControlElement._bringToFrontElement = function (elem) {
+ if (elem && elem.owner_elem == this && elem.handle) {
+ nexacro.__bringDOMNodeToFront(elem.handle);
+ }
+ };
+ _pControlElement._moveToNextElement = function (elem, base_elem) {
+ if (elem && base_elem && elem.owner_elem == this && base_elem.owner_elem == this && elem.handle && base_elem.handle) {
+ nexacro.__moveDOMNodeToNext(elem.handle, base_elem.handle);
+ }
+ };
+ _pControlElement._moveToPrevElement = function (elem, base_elem) {
+ if (elem && base_elem && elem.owner_elem == this && base_elem.owner_elem == this && elem.handle && base_elem.handle) {
+ nexacro.__moveDOMNodeToPrev(elem.handle, base_elem.handle);
+ }
+ };
+
+ _pControlElement.sendToBackElement = function (elem) {
+ var client_elem = this.getContainerElement(elem.position_step);
+ client_elem._sendToBackElement(elem);
+ };
+
+ _pControlElement.bringToFrontElement = function (elem) {
+ var client_elem = this.getContainerElement(elem.position_step);
+ client_elem._bringToFrontElement(elem);
+ };
+
+ _pControlElement.moveToNextElement = function (elem, base_elem) {
+ var client_elem = this.getContainerElement(elem.position_step);
+ client_elem._moveToNextElement(elem, base_elem);
+ };
+
+ _pControlElement.moveToPrevElement = function (elem, base_elem) {
+ var client_elem = this.getContainerElement(elem.position_step);
+ client_elem._moveToPrevElement(elem, base_elem);
+ };
+
+
+
+ _pControlElement.saveToImageFile = nexacro._emptyFn;
+ _pControlElement.saveToImageObject = nexacro._emptyFn;
+
+
+ _pControlElement._setElementHScrollPos = function (hpos) {
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNode_HScrollPos(handle, hpos);
+ }
+ };
+
+ _pControlElement._setElementVScrollPos = function (vpos) {
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNode_VScrollPos(handle, vpos);
+ }
+ };
+ _pControlElement._setElementScrollPos = function (hpos, vpos) {
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNode_Offset(handle, hpos, vpos);
+ }
+ };
+
+ _pControlElement.setElementTranslateStart = function () {
+ if (this._client_elem) {
+ this._client_elem._setElementTranslateStart();
+ }
+ };
+ _pControlElement.setElementTranslateEnd = function () {
+ if (this._client_elem) {
+ this._client_elem._setElementTranslateEnd();
+ }
+ };
+
+ _pControlElement.setElementHScrollPos = function (hpos) {
+ if (hpos < 0) {
+ hpos = 0;
+ }
+ if (hpos > this.hscroll_limit) {
+ hpos = this.hscroll_limit;
+ }
+
+ if (this.scroll_left != hpos || this._reset_scrollpos) {
+ this.scroll_left = hpos;
+ if (this._use_container_move) {
+ this._client_elem._setElementHScrollPos(hpos);
+ }
+
+ if (this.linkedcontrol) {
+ this.linkedcontrol._setHscrollPos(hpos);
+ }
+ }
+ };
+
+ _pControlElement.setElementVScrollPos = function (vpos) {
+ if (vpos < 0) {
+ vpos = 0;
+ }
+ if (vpos > this.vscroll_limit) {
+ vpos = this.vscroll_limit;
+ }
+ if (this.scroll_top != vpos || this._reset_scrollpos) {
+ this.scroll_top = vpos;
+ if (this._use_container_move) {
+ this._client_elem._setElementVScrollPos(vpos);
+ }
+
+ if (this.linkedcontrol) {
+ this.linkedcontrol._setVscrollPos(vpos);
+ }
+ }
+ };
+
+ _pControlElement.setElementScrollPos = function (hpos, vpos) {
+ if (hpos < 0) {
+ hpos = 0;
+ }
+ if (vpos < 0) {
+ vpos = 0;
+ }
+ if (hpos > this.hscroll_limit) {
+ hpos = this.hscroll_limit;
+ }
+ if (vpos > this.vscroll_limit) {
+ vpos = this.vscroll_limit;
+ }
+
+ if (this.scroll_left != hpos || this.scroll_top != vpos) {
+ this.scroll_left = hpos;
+ this.scroll_top = vpos;
+ if (this._use_container_move) {
+ this._client_elem._setElementScrollPos(hpos, vpos);
+ }
+
+ if (this.linkedcontrol) {
+ this.linkedcontrol._setHscrollPos(hpos);
+ this.linkedcontrol._setVscrollPos(vpos);
+ }
+ }
+ };
+
+ _pControlElement.getElementScrollLeft = function () {
+ return 0;
+ };
+ _pControlElement.getElementScrollTop = function () {
+ return 0;
+ };
+
+ _pControlElement.getElementScrollWidth = function () {
+ return this.inner_width;
+ };
+ _pControlElement.getElementScrollHeight = function () {
+ return this.inner_height;
+ };
+
+ _pControlElement.beginTransitionEffect = nexacro._emptyFn;
+ _pControlElement.applyTransitionEffect = nexacro._emptyFn;
+ _pControlElement.cancelTransitionEffect = nexacro._emptyFn;
+
+ _pControlElement._getElementClassName = function () {
+ var classname = this.typeselector;
+ if (this.rtl) {
+ classname += " nexartl";
+ }
+
+ if (this.idselector) {
+ classname += " " + this.idselector;
+ }
+ if (this.classselector) {
+ classname += " " + this.classselector;
+ }
+
+ if (this._use_translate_move) {
+ classname += " nexatransform";
+ }
+ return classname;
+ };
+
+ _pControlElement.setElementTypeCSSSelector = function (typename) {
+ if (this.typeselector != typename) {
+ this.typeselector = typename;
+ var handle = this.handle;
+ if (handle) {
+ var classname = this._getElementClassName();
+ if (this._classname != classname) {
+ this._classname = classname;
+ nexacro.__setDOMNode_ClassName(handle, classname);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementClassCSSSelector = function (classname) {
+ if (this.classselector != classname) {
+ this.classselector = classname;
+
+ var handle = this.handle;
+ if (handle) {
+ classname = this._getElementClassName();
+ if (this._classname != classname) {
+ this._classname = classname;
+ nexacro.__setDOMNode_ClassName(handle, classname);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementIDCSSSelector = function (id) {
+ if (this.idselector != id) {
+ this.idselector = id;
+
+ var handle = this.handle;
+ if (handle) {
+ var classname = this._getElementClassName();
+ if (this._classname != classname) {
+ this._classname = classname;
+ nexacro.__setDOMNode_ClassName(handle, classname);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementCSSMapInfo = function (border, padding, edge) {
+ var change_border = false, change_padding = false;
+ if (this._border_info != border) {
+ this._border_info = border;
+ change_border = (this.border == null);
+ }
+
+ if (this._padding_info != padding) {
+ this._padding_info = padding;
+ change_padding = (this.padding == null);
+ }
+
+ if (this._edge_info != edge) {
+ this._edge_info = edge;
+ }
+
+ var handle = this.handle;
+ var change_inner = (change_border && this._updateInnerSize());
+
+ var create_edge = false;
+ var edge_elem = this._edge_elem;
+ if (edge_elem) {
+ if ((this.edge && this.edge.value != "none") || (this._edge_info && this._edge_info.value != "none")) {
+ if (change_inner) {
+ edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ if (this.edge == null) {
+ edge_elem.setElementInfo(null, edge);
+ }
+ }
+ else {
+ edge_elem.destroy();
+ this._edge_elem = null;
+ }
+ }
+ else {
+ if (this.edge) {
+ if (this.edge.value != "none") {
+ create_edge = true;
+ }
+ }
+ else if (this._edge_info) {
+ if (this._edge_info.value != "none") {
+ create_edge = true;
+ }
+ }
+
+ if (create_edge) {
+ edge_elem = this._edge_elem = new nexacro._EdgeImageElement(this);
+ edge_elem.setElementSize(this.inner_width, this.inner_height);
+ edge_elem.setElementInfo(this.edge, edge);
+
+ if (handle) {
+ edge_elem.create();
+ }
+ }
+ }
+
+ if (change_inner || change_padding) {
+ this._updateClientRect();
+ }
+ };
+
+
+
+ _pControlElement.setElementZIndex = function (zindex) {
+ if (this.zindex != zindex) {
+ this.zindex = zindex;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMStyle_Zindex(handle.style, zindex);
+ }
+ }
+ };
+
+ _pControlElement.setElementToolTip = function (tooltiptext, tooltiptype) {
+ if (this.tooltiptext != tooltiptext || this.tooltiptype != tooltiptype) {
+ this.tooltiptext = tooltiptext;
+ this.tooltiptype = tooltiptype;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNode_ToolTip(handle, tooltiptext, tooltiptype);
+ }
+ }
+ };
+
+ _pControlElement.setElementFocus = function (selffocus) {
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMNode_Focus(handle, selffocus);
+ nexacro.__setLastFocusedElement(this);
+ }
+ };
+
+ _pControlElement.setElementSize = function (width, height) {
+ if (width < 0) {
+ width = 0;
+ }
+ if (height < 0) {
+ height = 0;
+ }
+
+ if (this.handle) {
+ nexacro.__setDOMStyle_Size(this.handle.style, width, height);
+ if (width == 0 || height == 0) {
+ var border = nexacro.BorderObject("0px none");
+ nexacro.__setDOMStyle_BorderObject(this.handle.style, border, this.rtl);
+ }
+ else if (this.width == 0 || this.height == 0) {
+ nexacro.__setDOMStyle_BorderObject(this.handle.style, this.border, this.rtl);
+ if (this.borderLeftNone || this.borderTopNone || this.borderRightNone || this.borderBottomNone) {
+ nexacro.__setDOMStyle_BorderNone(this.handle.style, this.borderLeftNone, this.borderTopNone, this.borderRightNone, this.borderBottomNone, this.border, this.rtl);
+ }
+ }
+ }
+
+ this.width = width;
+ this.height = height;
+
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+
+ if (this._frame_node) {
+ nexacro.__setDOMStyle_Size(this._frame_node.style, width, height);
+ }
+ };
+
+ _pControlElement.setElementBorderRadius = function (borderRadius) {
+ if (this.borderRadius != borderRadius) {
+ this.borderRadius = borderRadius;
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderRadiusObject(this.handle.style, borderRadius, this.rtl);
+ }
+ }
+ };
+
+ _pControlElement.setElementBorder = function (border) {
+ if (this.border != border) {
+ this.border = border;
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderObject(this.handle.style, border, this.rtl);
+ }
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementBorderLeftNone = function (borderleft) {
+ if (this.borderLeftNone != borderleft) {
+ this.borderLeftNone = borderleft;
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderLeftNone(this.handle.style, borderleft);
+ }
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementBorderTopNone = function (bordertop) {
+ if (this.borderTopNone != bordertop) {
+ this.borderTopNone = bordertop;
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderTopNone(this.handle.style, bordertop);
+ }
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementBorderRightNone = function (borderright) {
+ if (this.borderRightNone != borderright) {
+ this.borderRightNone = borderright;
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderRightNone(this.handle.style, borderright);
+ }
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementBorderBottomNone = function (borderbottom) {
+ if (this.borderBottomNone != borderbottom) {
+ this.borderBottomNone = borderbottom;
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderBottomNone(this.handle.style, borderbottom);
+ }
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementBorderNone = function (borderleft, bordertop, borderright, borderbottom) {
+ if (borderleft != this.borderLeftNone || bordertop != this.borderTopNone || borderright != this.borderRightNone || borderbottom != this.borderBottomNone) {
+ this.borderLeftNone = borderleft;
+ this.borderTopNone = bordertop;
+ this.borderRightNone = borderright;
+ this.borderBottomNone = borderbottom;
+
+ if (this.handle) {
+ nexacro.__setDOMStyle_BorderNone(this.handle.style, borderleft, bordertop, borderright, borderbottom, this.border, this.rtl);
+ }
+
+ if (this._updateInnerSize()) {
+ this._updateClientRect();
+
+ if (this._edge_elem) {
+ this._edge_elem.setElementSize(this.inner_width, this.inner_height);
+ }
+ }
+ }
+ };
+
+ _pControlElement.setElementBackground = function (background) {
+ if (this.background != background) {
+ this.background = background;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMStyle_BackgroundObject(handle.style, background, this.rtl);
+ }
+ }
+ };
+
+ _pControlElement.setElementEdge = function (edge) {
+ if (this.edge != edge) {
+ this.edge = edge;
+
+ var create_edge = false;
+ var edge_elem = this._edge_elem;
+ if (edge_elem) {
+ if (edge) {
+ if (edge.value == "none") {
+ edge_elem.destroy();
+ this._edge_elem = null;
+ }
+ else {
+ edge_elem.setElementInfo(edge, this._edge_info);
+ }
+ }
+ else if (this._edge_info) {
+ if (this._edge_info.value == "none") {
+ edge_elem.destroy();
+ this._edge_elem = null;
+ }
+ else {
+ edge_elem.setElementInfo(null, this._edge_info);
+ }
+ }
+ else {
+ edge_elem.destroy();
+ this._edge_elem = null;
+ }
+ }
+ else {
+ if (edge) {
+ if (edge.value != "none") {
+ create_edge = true;
+ }
+ }
+ else if (this._edge_info) {
+ if (this._edge_info.value != "none") {
+ create_edge = true;
+ }
+ }
+
+ if (create_edge) {
+ edge_elem = this._edge_elem = new nexacro._EdgeImageElement(this);
+ edge_elem.setElementSize(this.inner_width, this.inner_height);
+ edge_elem.setElementInfo(edge, this._edge_info);
+
+ if (this.handle) {
+ edge_elem.create();
+ }
+ }
+ }
+ }
+ };
+
+
+ _pControlElement.setElementPadding = function (padding) {
+ if (this.padding != padding) {
+ this.padding = padding;
+
+ if (this._apply_client_padding) {
+ this._updateClientRect();
+ }
+ }
+ };
+
+ _pControlElement.setElementCursor = function (cursor) {
+ if (this.cursor != cursor) {
+ this.cursor = cursor;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMStyle_CursorObject(handle.style, cursor);
+ }
+ }
+ };
+
+ _pControlElement.setElementOpacity = function (opacity) {
+ if (this.opacity != opacity) {
+ this.opacity = opacity;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMStyle_OpacityObject(handle.style, opacity);
+ }
+ }
+ };
+
+ _pControlElement.setElementBoxShadow = function (boxshadow) {
+ if (this.boxShadow != boxshadow) {
+ this.boxShadow = boxshadow;
+ var handle = this.handle;
+
+ if (handle) {
+ nexacro.__setDOMStyle_ShadowObject(handle.style, boxshadow, this.rtl);
+ }
+ }
+ };
+
+ _pControlElement.setElementZoom = function (zoomfactor) {
+ var handle = this.handle;
+ if (handle) {
+ if (zoomfactor < 0) {
+ zoomfactor = 0;
+ }
+ this.zoom = zoomfactor;
+ nexacro.__setDOMStyle_TransformScale(handle.style, zoomfactor / 100);
+ this._updateClientRect();
+ }
+ };
+
+ _pControlElement.setElementDisplay = function (display) {
+ if (this.display != display) {
+ this.display = display;
+ var handle = this.handle;
+ if (handle) {
+ nexacro.__setDOMStyle_Display(handle.style, display);
+ }
+ }
+ };
+
+ _pControlElement.setElementSimpleControl = function (simplecontrol) {
+ if (this._is_simple_control != simplecontrol) {
+ if (this.handle) {
+ if (!this._is_simple_control) {
+ nexacro.__removeDOMNode(this.handle, this.dest_handle);
+ this.dest_handle = this.handle;
+ }
+ else {
+ var owner_elem = this.owner_elem;
+ var _doc = owner_elem._getRootWindowHandle();
+ var inner_node = _doc.createElement("div");
+ this.dest_handle = inner_node;
+ nexacro.__setDOMNode_ClassName(inner_node, this._getElementNexaClassName("nexasimplecontainer"));
+ nexacro.__setDOMNode_Id(inner_node, "", "nexacontainer");
+ nexacro.__appendDOMNode(this.handle, inner_node);
+
+ var innernodestyle = inner_node.style;
+ nexacro.__setDOMStyle_Pos(innernodestyle, this.client_left, this.client_top);
+ if (this.client_width && this.client_height) {
+ nexacro.__setDOMStyle_Size(innernodestyle, this.client_width, this.client_height);
+ }
+ }
+ }
+
+ this._is_simple_control = simplecontrol;
+ }
+ };
+
+ _pControlElement.setElementHittestType = nexacro._emptyFn;
+ _pControlElement.getClientLeft = function () {
+ if (this._apply_client_padding && !this._is_simple_control) {
+ return 0;
+ }
+ return this.client_left;
+ };
+
+ _pControlElement.getClientTop = function () {
+ if (this._apply_client_padding && !this._is_simple_control) {
+ return 0;
+ }
+ return this.client_top;
+ };
+
+
+ _pControlElement.getClientWidth = function () {
+ return this.client_width;
+ };
+
+ _pControlElement.getClientHeight = function () {
+ return this.client_height;
+ };
+
+ _pControlElement._updateInnerSize = function () {
+ var inner_width = this.width;
+ var inner_height = this.height;
+
+ var border = this.border || this._border_info;
+
+ if (border) {
+ var borderleft = border.left ? border.left._width : 0;
+ var borderright = border.right ? border.right._width : 0;
+ var bordertop = border.top ? border.top._width : 0;
+ var borderbottom = border.bottom ? border.bottom._width : 0;
+
+ if (this.borderLeftNone) {
+ borderleft = 0;
+ }
+ if (this.borderRightNone) {
+ borderright = 0;
+ }
+ if (this.borderTopNone) {
+ bordertop = 0;
+ }
+ if (this.borderBottomNone) {
+ borderbottom = 0;
+ }
+
+ inner_width -= (borderleft + borderright);
+ inner_height -= (bordertop + borderbottom);
+
+ if (inner_width < 0) {
+ inner_width = 0;
+ }
+ if (inner_height < 0) {
+ inner_height = 0;
+ }
+ }
+
+ if (this.inner_width != inner_width || this.inner_height != inner_height) {
+ this.inner_width = inner_width;
+ this.inner_height = inner_height;
+ return true;
+ }
+ return false;
+ };
+
+ _pControlElement._on_updateClientRect = function () {
+ var ret = 0;
+ if (this._apply_client_padding) {
+ var client_left = 0;
+ var client_top = 0;
+ var client_width = this.inner_width;
+ var client_height = this.inner_height;
+
+ var padding = (this.padding || this._padding_info);
+ if (padding) {
+ client_left = padding.left;
+ client_top = padding.top;
+ client_width -= padding.left + padding.right;
+ client_height -= padding.top + padding.bottom;
+ }
+
+ if (this.client_left != client_left || this.client_top != client_top) {
+ this.client_left = client_left;
+ this.client_top = client_top;
+ ret = 1;
+ }
+ if (this.client_width != client_width || this.client_height != client_height) {
+ this.client_width = client_width;
+ this.client_height = client_height;
+ ret += 2;
+ }
+ }
+ else {
+ if (this.client_width != this.inner_width || this.client_height != this.inner_height) {
+ this.client_width = this.inner_width;
+ this.client_height = this.inner_height;
+ ret += 2;
+ }
+ }
+
+ return ret;
+ };
+
+ _pControlElement._updateClientRect = function () {
+ var ret = this._on_updateClientRect();
+ if (ret & 1) {
+ this._on_change_clientPos(this.client_left, this.client_top);
+ }
+ if (ret & 2) {
+ this._on_change_clientSize(this.client_width, this.client_height);
+ }
+ };
+
+ _pControlElement._on_change_clientPos = function (left, top) {
+ var notify = false;
+
+ var client_elem = this._client_elem;
+ if (client_elem) {
+ client_elem.setElementPosition(left, top);
+ }
+ else if (this._apply_client_padding) {
+ if (this.handle && this.handle != this.dest_handle) {
+ var dest_handle = this.dest_handle;
+ nexacro.__setDOMStyle_Pos(dest_handle.style, left, top);
+ }
+ else {
+ notify = true;
+ }
+ }
+
+ var control = this.linkedcontrol;
+ if (control && notify) {
+ control.on_change_containerPos(left, top);
+ }
+ };
+
+ _pControlElement._on_change_clientSize = function (width, height) {
+ var client_elem = this._client_elem;
+ if (client_elem) {
+ client_elem.setElementSize(width, height);
+ }
+ else if (this._apply_client_padding || !this._is_simple_control) {
+ if (this.handle && this.handle != this.dest_handle) {
+ var dest_handle = this.dest_handle;
+ nexacro.__setDOMStyle_Size(dest_handle.style, width, height);
+ }
+ }
+
+
+ var control = this.linkedcontrol;
+ if (control) {
+ control.on_change_containerRect(width, height);
+ }
+ };
+
+
+ _pControlElement._refreshControl = function (handle, handle_style) {
+ if (this.tabindex >= -1) {
+ nexacro.__setDOMNode_TabIndex(handle, this.tabindex);
+ }
+ if (!nexacro._isNull(this.tooltiptext)) {
+ nexacro.__setDOMNode_ToolTip(handle, this.tooltiptext, this.tooltiptype);
+ }
+
+ if (this.zindex >= 0) {
+ nexacro.__setDOMStyle_Zindex(handle_style, this.zindex);
+ }
+
+ this._refreshCommonStyleProps(handle_style);
+
+ if (this.borderRadius) {
+ nexacro.__setDOMStyle_BorderRadiusObject(handle_style, this.borderRadius, this.rtl);
+ }
+
+ if (this.width == 0 || this.height == 0) {
+ var border = nexacro.BorderObject("0px none");
+ nexacro.__setDOMStyle_BorderObject(handle_style, border);
+ }
+ else {
+ nexacro.__setDOMStyle_BorderObject(handle_style, this.border, this.rtl);
+ if (this.borderLeftNone || this.borderTopNone || this.borderRightNone || this.borderBottomNone) {
+ nexacro.__setDOMStyle_BorderNone(this.handle.style, this.borderLeftNone, this.borderTopNone, this.borderRightNone, this.borderBottomNone, this.border, this.rtl);
+ }
+ }
+
+ if (this.background) {
+ nexacro.__setDOMStyle_BackgroundObject(handle_style, this.background, this.rtl);
+ }
+
+
+
+ if (this.cursor) {
+ nexacro.__setDOMStyle_CursorObject(handle_style, this.cursor);
+ }
+ if (this.opacity) {
+ nexacro.__setDOMStyle_OpacityObject(handle_style, this.opacity);
+ }
+ if (this.boxShadow) {
+ nexacro.__setDOMStyle_ShadowObject(handle_style, this.boxShadow, this.rtl);
+ }
+
+ if (this.status) {
+ nexacro.__setDOMNode_Status(handle, this.status);
+ }
+
+ if (this.userstatus) {
+ nexacro.__setDOMNode_UserStatus(handle, this.userstatus);
+ }
+
+ if (nexacro._enableaccessibility) {
+ this._refreshAccessibilityInfo(handle, handle_style);
+ }
+
+ if (this._edge_elem) {
+ this._edge_elem.create();
+ }
+ };
+
+ _pControlElement._getControlStyleStr = function () {
+ var str = this._getCommonStyleStr();
+
+ if (this.borderRadius) {
+ str += nexacro.__getHTMLStyle_BorderRadiusObject(this.borderRadius, this.rtl);
+ }
+
+ if (this.width == 0 || this.height == 0) {
+ str += "border: 0px none;";
+ }
+ else if (this.border) {
+ str += nexacro.__getHTMLStyle_BorderObject(this.border, this.rtl);
+ }
+
+ if (this.borderLeftNone) {
+ str += nexacro.__getHTMLStyle_BorderLeftNone();
+ }
+ if (this.borderTopNone) {
+ str += nexacro.__getHTMLStyle_BorderTopNone();
+ }
+ if (this.borderRightNone) {
+ str += nexacro.__getHTMLStyle_BorderRightNone();
+ }
+ if (this.borderBottomNone) {
+ str += nexacro.__getHTMLStyle_BorderBottomNone();
+ }
+
+ if (this.background) {
+ str += nexacro.__getHTMLStyle_BackgroundObject(this.background, this.rtl);
+ }
+
+
+ if (this.cursor) {
+ str += nexacro.__getHTMLStyle_CursorObject(this.cursor);
+ }
+
+ if (this.opacity) {
+ str += nexacro.__getHTMLStyle_OpacityObject(this.opacity);
+ }
+
+ if (this.boxShadow) {
+ str += nexacro.__getHTMLStyle_ShadowObject(this.boxShadow, this.rtl);
+ }
+
+ return str;
+ };
+
+ _pControlElement._isMultiInnerProc = function () {
+ var parent_elem = this.parent_elem;
+ if (parent_elem && parent_elem._use_container_move && parent_elem._use_multiinner) {
+ if (this.owner_elem && (this.owner_elem instanceof nexacro._MultiInnerContainerElement)) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ _pControlElement.setElementPosition = function (left, top, bForce) {
+ if (this._isMultiInnerProc()) {
+ var owner_elem = this.owner_elem;
+ if (this.left != left || this.top != top || bForce) {
+ var adjust_top = top;
+
+ if (!this._is_nc_element && owner_elem && (this.top != top || bForce)) {
+ adjust_top = owner_elem._changeInnerElement(top, this.handle);
+ }
+
+ nexacro.Element.prototype.setElementPosition.call(this, left, adjust_top, bForce);
+ this.top = top;
+ }
+ }
+ else {
+ nexacro.Element.prototype.setElementPosition.call(this, left, top, bForce);
+ }
+ };
+
+
+ _pControlElement._refreshAccessibilityInfo = nexacro._emptyFn;
+ _pControlElement._getAccessibilityInfoStr = function () {
+ return "";
+ };
+ _pControlElement._setAccessibility_notify = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityRole = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityLabel = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityEnable = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityDescription = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityDescLevel = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityAction = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityValue = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatDisabled = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatHidden = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatChecked = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatPressed = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatSelected = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatExpanded = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatAutoComplete = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagHasPopup = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagFocusable = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagReadOnly = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagPassword = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagMultiSelectable = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagSelectable = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagDefaultButton = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityFlagMultiLine = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityInfoCount = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityInfoIndex = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityInfoValueMax = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityInfoValueMin = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityInfoValueCur = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityInfoLevel = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityHotKey = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityActiveDescendant = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatFocus = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatKillFocus = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityStatLive = nexacro._emptyFn;
+
+ _pControlElement.notifyAccessibility = nexacro._emptyFn;
+ _pControlElement._makeAccessibilityLabelbyReadtype = nexacro._emptyFn;
+ _pControlElement.setElementAccessibilityParentLabel = nexacro._emptyFn;
+
+
+
+ nexacro.ScrollableControlElement = function (parent_elem, use_multiinner) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ this._use_multiinner = use_multiinner;
+
+ if (use_multiinner) {
+ this._client_elem = new nexacro._MultiInnerContainerElement(this);
+ }
+ else {
+ this._client_elem = new nexacro._ContainerElement(this);
+ }
+ };
+
+ var _pScrollableControlElement = nexacro._createPrototype(nexacro.ControlElement, nexacro.ScrollableControlElement);
+ nexacro.ScrollableControlElement.prototype = _pScrollableControlElement;
+ _pScrollableControlElement._type_name = "ScrollableControlElement";
+
+ _pScrollableControlElement.create = function (win) {
+ var owner_elem, _doc, handle, handle_style;
+ if (!this._is_popup) {
+ owner_elem = (this._is_nc_element) ? this.parent_elem : this.parent_elem.getContainerElement(this.position_step);
+ if (owner_elem && owner_elem.handle) {
+ if (!this.handle) {
+ this.owner_elem = owner_elem;
+ _doc = win._doc || owner_elem._getRootWindowHandle();
+
+ handle = _doc.createElement("div");
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ this.handle = this.dest_handle = handle;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+
+ handle_style = handle.style;
+ var bPositionRtl = this._isParentRtl();
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top, bPositionRtl);
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+
+ this._refreshControl(handle, handle_style, _doc);
+
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+ }
+ }
+ }
+ else {
+ _doc = win._doc;
+ owner_elem = win;
+
+ handle = _doc.createElement("div");
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ this.handle = this.dest_handle = handle;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+
+ handle_style = handle.style;
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top);
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+
+ this._refreshControl(handle, handle_style, _doc);
+
+ this.handle = this.dest_handle = handle;
+ if (this.linkedcontrol._findOwnerElementHandle) {
+ var owner_elem_info = this.linkedcontrol._findOwnerElementHandle();
+ if (owner_elem_info.is_append) {
+ nexacro.__appendDOMNode(owner_elem_info.owner_handle, handle);
+ }
+ else {
+ owner_elem_info.owner_handle.insertBefore(handle, owner_elem_info.ref_handle);
+ }
+ this.owner_elem = owner_elem_info.owner_handle._linked_element;
+ }
+ else {
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+ this.owner_elem = owner_elem;
+ }
+
+ this._frame_node = nexacro._createFrameNode(handle, this.left, this.top, _doc, this.width, this.height);
+ }
+
+ if (this.handle) {
+ if (!this._client_elem.handle) {
+ this._client_elem.create(win);
+ }
+
+ var step_count = this._step_count;
+ if (step_count > 0) {
+ this._step_containers = [];
+ for (var i = 0; i < step_count; i++) {
+ var step_client = new nexacro._ContainerElement(this._client_elem, this._use_translate_scroll);
+ step_client.setElementPosition(i * this.client_width, 0);
+ step_client.setElementSize(this.client_width, this.container_maxheight);
+ step_client.create(win);
+ this._step_containers.push(step_client);
+ }
+ }
+ }
+ };
+
+ _pScrollableControlElement._on_destroy = function () {
+ var handle = this.handle;
+ if (handle) {
+ var step_containers = this._step_containers;
+ if (step_containers) {
+ var step_count = step_containers.length;
+ for (var i = 0; i < step_count; i++) {
+ var step_client = step_containers[i];
+ step_client.destroy();
+ }
+ this._step_containers = null;
+ }
+ }
+ };
+
+ _pScrollableControlElement._on_clearContents = function () {
+ if (this.handle) {
+ var step_containers = this._step_containers;
+ if (step_containers) {
+ var step_count = step_containers.length;
+ for (var i = 0; i < step_count; i++) {
+ var step_client = step_containers[i];
+ step_client.destroy();
+ }
+ this._step_containers = null;
+ }
+ }
+ };
+
+ _pScrollableControlElement._setInnerElementScrollMaxTops = function (tops) {
+ if (!this._use_multiinner) {
+ return;
+ }
+
+ if (this._client_elem) {
+ this._client_elem._setScrollMaxTops(tops);
+ }
+ };
+
+ _pScrollableControlElement.initElementInfo = function () {
+ nexacro.ControlElement.prototype.initElementInfo.call(this);
+
+ this._zclient_width = 0;
+ this._zclient_height = 0;
+
+ var control = this.linkedcontrol;
+ if (control._is_scrollable) {
+ this._hscroll_control = null;
+ this._vscroll_control = null;
+
+ this._step_containers = null;
+
+ this.zoom = 100;
+
+ this.scroll_left = 0;
+ this.scroll_top = 0;
+ this.container_maxwidth = 0;
+ this.container_maxheight = 0;
+
+ this.hscroll_limit = 0;
+ this.vscroll_limit = 0;
+
+ this._hscroll_size = 0;
+ this._vscroll_size = 0;
+ this._hscrollbartype = "";
+ this._vscrollbartype = "";
+ this._scrolltype = "";
+
+ this._scrollview_width_top = 0;
+ this._step_count = 0;
+ this._step_index = -1;
+
+ if (control._use_translate_scroll_force) {
+ this._use_translate_scroll = control._use_translate_scroll;
+ }
+ else {
+ this._use_translate_scroll = (control._use_translate_scroll === false) ? control._use_translate_scroll : nexacro._use_translate_scroll;
+ }
+ this._use_container_move = control._use_container_move;
+ this._use_native_scroll = control._use_native_scroll;
+
+
+ this.setElementScrollbarSize(control._getHScrollBarSize(), control._getVScrollBarSize(), control._getHScrollBarType(), control._getVScrollBarType(), control.scrolltype);
+ }
+ else if (control._is_expandable) {
+ this._expandbarwidth = 0;
+ this._expandbarheight = 0;
+ this._expandbartype = false;
+ this._expanddirtype = "horz";
+ this._expandvisible;
+ this._expandarrange;
+
+ this._use_translate_scroll = false;
+ this._use_container_move = false;
+ this._use_native_scroll = false;
+
+ this._on_updateClientRect = this._on_updateClientRectExpand;
+ this._on_change_clientPos = this._on_change_clientPosExpand;
+ this._on_change_clientSize = this._on_change_clientSizeExpand;
+ }
+
+ var client_elemt = this._client_elem;
+ if (client_elemt) {
+ client_elemt._use_translate_scroll = this._use_translate_scroll;
+ client_elemt._use_container_move = this._use_container_move;
+ client_elemt._use_native_scroll = this._use_native_scroll;
+ }
+ };
+
+ _pScrollableControlElement.setElementStepCount = function (count) {
+ if (this._step_count != count) {
+ var step_count = this._step_count;
+ var step_containers = this._step_containers;
+ var i, step_client;
+ if (step_containers && this._step_count) {
+ for (i = 0; i < step_count; i++) {
+ step_client = step_containers[i];
+ step_client.destroy();
+ }
+ this._step_containers = null;
+ }
+
+ this._step_count = count;
+
+ this._updateClientRect();
+ if (this.handle && count > 0) {
+ this._step_containers = [];
+
+ for (i = 0; i < count; i++) {
+ step_client = new nexacro._ContainerElement(this._client_elem, this._use_translate_scroll);
+ step_client.setElementPosition(i * this.client_width, 0);
+ step_client.setElementSize(this.client_width, this.client_height);
+ step_client.create();
+ this._step_containers.push(step_client);
+ }
+ }
+ }
+ };
+
+ _pScrollableControlElement.setElementStepIndex = function (index) {
+ if (this._step_index != index) {
+ if (this._step_count > 0) {
+ if (index > -1 && this._step_count > index) {
+ this._step_index = index;
+ }
+ }
+ else {
+ this._step_index = index;
+ }
+ }
+ };
+
+ _pScrollableControlElement.setElementZoom = function (zoomfactor) {
+ var handle = this.handle;
+ if (handle) {
+ if (zoomfactor < 0) {
+ zoomfactor = 0;
+ }
+ this.zoom = zoomfactor;
+ var client = this.getContainerElement(this._step_index);
+ if (client) {
+ client.setElementZoom(zoomfactor);
+ }
+ this._updateClientRect();
+ }
+ };
+
+ _pScrollableControlElement.setElementScrollMaxSize = function (width, height) {
+ if (this.container_maxwidth != width || this.container_maxheight != height) {
+ this.container_maxwidth = width;
+ this.container_maxheight = height;
+
+ if (this._step_count) {
+ var client_elem = this.getContainerElement(this._step_index);
+ if (client_elem) {
+ client_elem.setElementScrollMaxSize(this.client_width, height);
+ }
+ }
+ if (this._client_elem) {
+ this._client_elem.setElementScrollMaxSize(width, height);
+ }
+
+ this._updateClientRect();
+ }
+ };
+
+ _pScrollableControlElement.setElementScrollbarSize = function (hscroll_size, vscroll_size, hscrollbartype, vscrollbartype, scrolltype) {
+ var ret = false;
+ if (this._vscroll_size != vscroll_size || this._hscroll_size != hscroll_size) {
+ this._vscroll_size = vscroll_size | 0;
+ this._hscroll_size = hscroll_size | 0;
+
+ ret = true;
+ }
+
+ if (this._hscrollbartype != hscrollbartype || this._vscrollbartype != vscrollbartype) {
+ this._hscrollbartype = hscrollbartype;
+ this._vscrollbartype = vscrollbartype;
+
+ ret = true;
+ }
+
+ if (this._scrolltype != scrolltype) {
+ this._scrolltype = scrolltype;
+ var container = this._client_elem;
+ if (container) {
+ container._setElementScrolltype(this._getElementScrollType(scrolltype));
+ }
+ ret = true;
+ }
+ if (ret) {
+ this._updateClientRect();
+ }
+ return ret;
+ };
+
+ _pScrollableControlElement.setElementExpandbarSize = function (expandbarsize, expandbartype, expanddirtype, expandvisible, expandarrange) {
+ var ret = false;
+
+ if (this._expandbarwidth != expandbarsize[0]) {
+ this._expandbarwidth = +expandbarsize[0];
+ ret = true;
+ }
+ if (this._expandbarheight != expandbarsize[1]) {
+ this._expandbarheight = +expandbarsize[1];
+ ret = true;
+ }
+ if (this._expandbartype != expandbartype) {
+ this._expandbartype = expandbartype;
+ ret = true;
+ }
+ if (this._expanddirtype != expanddirtype) {
+ this._expanddirtype = expanddirtype;
+ ret = true;
+ }
+ if (this._expandvisible != expandvisible) {
+ this._expandvisible = expandvisible;
+ ret = true;
+ }
+ if (this._expandarrange != expandarrange) {
+ this._expandarrange = expandarrange;
+ ret = true;
+ }
+
+ if (ret) {
+ this._updateClientRect();
+ }
+
+ return ret;
+ };
+
+ _pScrollableControlElement.getContainerElement = function (position_step) {
+ var step_count = this._step_count;
+ var step_index = this._step_index;
+ var step_containers = this._step_containers;
+ if (step_count > 0 && step_containers && step_count > position_step) {
+ if (position_step < 0 || position_step == null) {
+ position_step = (step_index > -1 ? step_index : 0);
+ }
+
+ return step_containers[position_step];
+ }
+ else {
+ return this._client_elem;
+ }
+ };
+
+ _pScrollableControlElement.getElementScrollLeft = function () {
+ var container = this.getContainerElement(this.position_step);
+ if (!container) {
+ return 0;
+ }
+
+ return container.getElementScrollLeft();
+ };
+
+ _pScrollableControlElement.getElementScrollTop = function () {
+ var container = this._client_elem;
+ if (!container) {
+ return 0;
+ }
+
+ return container.getElementScrollTop();
+ };
+
+ _pScrollableControlElement.getElementScrollWidth = function () {
+ var container = this.getContainerElement(this.position_step);
+ if (!container) {
+ return 0;
+ }
+
+ return container.getElementScrollWidth();
+ };
+
+ _pScrollableControlElement.getElementScrollHeight = function () {
+ var container = this._client_elem;
+ if (!container) {
+ return 0;
+ }
+
+ return container.getElementScrollHeight();
+ };
+
+ _pScrollableControlElement.setElementVScrollPos = function (vpos) {
+ if (vpos < 0) {
+ vpos = 0;
+ }
+ if (vpos > this.vscroll_limit) {
+ vpos = this.vscroll_limit;
+ }
+ if (this.scroll_top != vpos || this._reset_scrollpos) {
+ this.scroll_top = vpos;
+ if (this._step_count > 0) {
+ this.getContainerElement(this._step_index)._setElementVScrollPos(vpos);
+ }
+ if (this._use_container_move) {
+ this._client_elem._setElementVScrollPos(vpos);
+ }
+ if (this.linkedcontrol) {
+ this.linkedcontrol._setVscrollPos(vpos);
+ }
+ }
+ };
+
+
+ _pScrollableControlElement._updateClientRect = function () {
+ var ret = this._on_updateClientRect();
+ if (ret & 1) {
+ this._on_change_clientPos(this.client_left, this.client_top);
+ }
+ if (ret & 2) {
+ this._on_change_clientSize(this._zclient_width, this._zclient_height);
+ }
+ };
+
+ _pScrollableControlElement._on_change_clientPos = function (left, top) {
+ var step_count = this._step_count;
+ var step_index = this._step_index;
+ var step_containers = this._step_containers;
+ var zclient_width = this._zclient_width;
+ var i;
+ var step_client_elem;
+ if (this._apply_client_padding) {
+ if (this._client_elem) {
+ if (step_count > 0 && step_containers) {
+ for (i = 0; i < step_count; i++) {
+ step_client_elem = step_containers[i];
+ step_client_elem.setElementPosition(zclient_width * i, 0);
+ if (i == step_index) {
+ step_client_elem.setElementSize(zclient_width, this.container_maxheight);
+ }
+ }
+ }
+ else {
+ this._client_elem.setElementPosition(left, top);
+ }
+ }
+ else if (this.handle && this.handle != this.dest_handle) {
+ var dest_handle = this.dest_handle;
+ nexacro.__setDOMStyle_Pos(dest_handle.style, left, top);
+ }
+ }
+ else if (this._client_elem) {
+ this._client_elem.setElementPosition(left, top);
+ if (step_count > 0 && step_containers) {
+ for (i = 0; i < step_count; i++) {
+ step_client_elem = step_containers[i];
+ step_client_elem.setElementPosition(zclient_width * i, 0);
+ }
+
+ step_index = this._step_index;
+ var step_scroll_left = zclient_width * step_index;
+ if (this.scroll_left != step_scroll_left) {
+ this.scroll_left = step_scroll_left;
+ this._client_elem._setElementHScrollPos(step_scroll_left);
+ }
+ }
+ }
+
+ var control = this.linkedcontrol;
+ if (control) {
+ control.on_change_containerPos(left, top);
+ }
+ };
+
+ _pScrollableControlElement._on_change_clientPosExpand = function (left, top) {
+ var client_elem = this._client_elem;
+ if (client_elem) {
+ client_elem.setElementPosition(left, top);
+ }
+ else {
+ var handle = this.handle;
+ var dest_handle = this.dest_handle;
+ if (handle && handle != dest_handle & this._apply_client_padding) {
+ nexacro.__setDOMStyle_Pos(dest_handle.style, left, top);
+ }
+ }
+
+ var control = this.linkedcontrol;
+ if (control) {
+ control.on_change_containerPos(left, top);
+ }
+ };
+
+ _pScrollableControlElement._on_change_clientSize = function (width, height) {
+ var handle = this.handle;
+ var dest_handle = this.dest_handle;
+
+ var client_elem = this._client_elem;
+
+ var zclient_width = this._zclient_width;
+
+ var max_width = Math.max(width, this.container_maxwidth);
+ var max_height = Math.max(height, this.container_maxheight);
+
+ var step_count = this._step_count;
+ var step_containers = this._step_containers;
+ var step_client_elem;
+ var i;
+ if (this._apply_client_padding) {
+ if (client_elem) {
+ client_elem.setElementSize(width, height);
+
+ if (step_count > 0 && step_containers) {
+ for (i = 0; i < step_count; i++) {
+ step_client_elem = step_containers[i];
+ if (step_client_elem) {
+ step_client_elem.setElementSize(zclient_width, max_height);
+ dest_handle = step_client_elem.dest_handle;
+ if (dest_handle) {
+ nexacro.__setDOMStyle_Size(dest_handle.style, width, max_height);
+ }
+ }
+ }
+ }
+ }
+ else if (handle && handle != dest_handle) {
+ nexacro.__setDOMStyle_Size(dest_handle.style, width, height);
+ }
+ }
+ else {
+ if (client_elem) {
+ if (step_count > 0 && step_containers) {
+ for (i = 0; i < step_count; i++) {
+ step_client_elem = step_containers[i];
+ if (step_client_elem) {
+ step_client_elem.setElementSize(zclient_width, max_height);
+ }
+ }
+ }
+ else {
+ client_elem.setElementSize(width, height);
+ }
+ }
+ }
+
+ if (client_elem && client_elem._use_translate_scroll) {
+ if (this._use_multiinner) {
+ client_elem.setElementScrollMaxSize(max_width, max_height);
+ }
+ else {
+ if (client_elem.dest_handle) {
+ nexacro.__setDOMStyle_Size(client_elem.dest_handle.style, max_width, max_height);
+ }
+ }
+ }
+
+ var control = this.linkedcontrol;
+ if (control) {
+ control.on_change_containerRect(width, height);
+ }
+ };
+
+ _pScrollableControlElement._on_change_clientSizeExpand = function (width, height) {
+ var client_elem = this._client_elem;
+ if (client_elem) {
+ client_elem.setElementSize(width, height);
+ }
+ else {
+ var handle = this.handle;
+ var dest_handle = this.dest_handle;
+ if (handle && handle != dest_handle & this._apply_client_padding) {
+ nexacro.__setDOMStyle_Size(dest_handle.style, width, height);
+ }
+ }
+
+ var control = this.linkedcontrol;
+ if (control) {
+ control.on_change_containerRect(width, height);
+ }
+ };
+
+ _pScrollableControlElement._on_updateClientRect = function () {
+ var client_left = 0;
+ var client_top = 0;
+ var client_width = this.inner_width;
+ var client_height = this.inner_height;
+
+ var cur_client_width = this.client_width;
+
+ if (this._apply_client_padding) {
+ var padding = this.padding ? this.padding : this._padding_info;
+ if (padding) {
+ client_left = padding.left;
+ client_top = padding.top;
+ client_width -= padding.left + padding.right;
+ client_height -= padding.top + padding.bottom;
+ }
+ }
+
+ var client_elem = this._client_elem;
+ if (!client_elem) {
+ return 0;
+ }
+
+ var zoomfactor = this.zoom / 100;
+ var zclient_width = this._zclient_width = client_width / zoomfactor;
+ var zclient_height = this._zclient_height = client_height / zoomfactor;
+
+ var container_maxwidth = this.container_maxwidth;
+ var container_maxheight = this.container_maxheight;
+
+ var scroll_left = this.scroll_left;
+ var scroll_top = this.scroll_top;
+
+ var step_count = this._step_count;
+ var step_containers = this._step_containers;
+ if (step_count > 0 && step_containers) {
+ container_maxwidth = step_count * zclient_width;
+ }
+
+ var reset_vlimit = false;
+ var reset_hlimit = false;
+
+
+ var hscroll_limit = 0;
+ var vscroll_limit = 0;
+
+ var hscrollbartype = this._hscrollbartype;
+ var vscrollbartype = this._vscrollbartype;
+ var scrolltype = this._scrolltype;
+
+ if (step_count > 0 && step_containers) {
+ hscrollbartype = "none";
+ }
+
+ if (container_maxwidth > zclient_width) {
+ if ((scrolltype != "none" && scrolltype != "vertical") && hscrollbartype != "none" && hscrollbartype != "autoindicator") {
+ client_height -= this._hscroll_size;
+ zclient_height = client_height / zoomfactor;
+ }
+
+ hscroll_limit = container_maxwidth - zclient_width;
+ }
+ else {
+ if (hscrollbartype == "fixed") {
+ client_height -= this._hscroll_size;
+ zclient_height = client_height / zoomfactor;
+ }
+ }
+
+ if (container_maxheight > zclient_height) {
+ vscroll_limit = container_maxheight - zclient_height;
+
+ if ((scrolltype != "none" && scrolltype != "horizontal") && vscrollbartype != "none" && vscrollbartype != "autoindicator") {
+ client_width -= this._vscroll_size;
+ zclient_width = client_width / zoomfactor;
+ }
+
+ if (container_maxwidth > zclient_width) {
+ if ((scrolltype != "none" && scrolltype != "vertical") && hscrollbartype != "none" && hscrollbartype != "autoindicator" && hscroll_limit == 0) {
+ client_height -= this._hscroll_size;
+ zclient_height = client_height / zoomfactor;
+ vscroll_limit += this._hscroll_size;
+ }
+ hscroll_limit = container_maxwidth - zclient_width;
+ }
+ else if (container_maxwidth > cur_client_width) {
+ hscroll_limit = container_maxwidth - cur_client_width;
+ }
+ }
+ else {
+ if (vscrollbartype == "fixed") {
+ client_width -= this._vscroll_size;
+ zclient_width = client_width / zoomfactor;
+
+ if (container_maxwidth > zclient_width) {
+ hscroll_limit = container_maxwidth - zclient_width;
+ }
+ else if (container_maxwidth > cur_client_width) {
+ hscroll_limit = container_maxwidth - cur_client_width;
+ }
+ }
+ }
+
+ if (step_count > 0 && step_containers) {
+ container_maxwidth = step_count * zclient_width;
+
+ if (container_maxwidth > zclient_width) {
+ hscroll_limit = container_maxwidth - zclient_width;
+ }
+ }
+
+ if (this.hscroll_limit != hscroll_limit) {
+ reset_hlimit = true;
+ this.hscroll_limit = hscroll_limit;
+
+ if (scroll_left > hscroll_limit && hscroll_limit >= 0) {
+ this.setElementHScrollPos(hscroll_limit);
+ }
+ }
+
+ if (this.vscroll_limit != vscroll_limit) {
+ reset_vlimit = true;
+ this.vscroll_limit = vscroll_limit;
+
+ if (scroll_top > vscroll_limit && vscroll_limit >= 0) {
+ this.setElementVScrollPos(vscroll_limit);
+ }
+ }
+
+ this._zclient_width = zclient_width;
+ this._zclient_height = zclient_height;
+
+ var ret = 0;
+ if (this.client_left != client_left || this.client_top != client_top) {
+ this.client_left = client_left;
+ this.client_top = client_top;
+ ret = 1;
+ }
+ else if (step_count > 0) {
+ ret = 1;
+ }
+
+ var cw = this.client_width != client_width;
+ var ch = this.client_height != client_height;
+
+ if (cw || ch) {
+ this.client_width = client_width;
+ this.client_height = client_height;
+ ret += 2;
+ }
+ else if (this.client_width != zclient_width || this.client_height != zclient_height) {
+ ret += 2;
+ }
+ else if (reset_hlimit || reset_vlimit) {
+ ret += 2;
+ }
+ return ret;
+ };
+
+ _pScrollableControlElement._on_updateClientRectExpand = function () {
+ var ret = 0;
+
+ var client_left = 0;
+ var client_top = 0;
+ var client_width = this.inner_width;
+ var client_height = this.inner_height;
+
+ if (!this._client_elem) {
+ return ret;
+ }
+
+ if (this._apply_client_padding) {
+ var padding = this.padding ? this.padding : this._padding_info;
+ if (padding) {
+ client_left = padding.left;
+ client_top = padding.top;
+ client_width -= padding.left + padding.right;
+ client_height -= padding.top + padding.bottom;
+ }
+ }
+
+ if (this._expandbartype && this._expanddirtype == "vert") {
+ client_height -= this._expandbarheight;
+ }
+
+ if (this._expandbartype && this._expanddirtype == "horz") {
+ client_width -= this._expandbarwidth;
+ }
+
+ if (this.client_left != client_left || this.client_top != client_top) {
+ this.client_left = client_left;
+ this.client_top = client_top;
+ ret = 1;
+ }
+
+ if (this.client_width != client_width || this.client_height != client_height) {
+ this.client_width = this._zclient_width = client_width;
+ this.client_height = this._zclient_height = client_height;
+ ret += 2;
+ }
+
+ return ret;
+ };
+
+ _pScrollableControlElement._getElementScrollType = function (scrolltype) {
+ var ret = 0x11;
+ if (scrolltype == "both") {
+ ret = 0x00;
+ }
+ else if (scrolltype == "horizontal") {
+ ret = 0x01;
+ }
+ else if (scrolltype == "vertical") {
+ ret = 0x10;
+ }
+ return ret;
+ };
+
+ nexacro.FrameControlElement = function (parent_elem) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+
+ this._border_elems = new nexacro.Collection();
+ this._frame_node = null;
+ };
+ var _pFrameControlElement = nexacro._createPrototype(nexacro.ControlElement, nexacro.FrameControlElement);
+ nexacro.FrameControlElement.prototype = _pFrameControlElement;
+ _pFrameControlElement._type_name = "FrameControlElement";
+
+ _pFrameControlElement._title_control = null;
+ _pFrameControlElement._status_control = null;
+ _pFrameControlElement._title_height = 0;
+ _pFrameControlElement._status_height = 0;
+ _pFrameControlElement._title_top = 0;
+ _pFrameControlElement._title_width = 0;
+ _pFrameControlElement._status_top = 0;
+ _pFrameControlElement._status_width = 0;
+ _pFrameControlElement._max_child_zindex = 0;
+ _pFrameControlElement._is_window_element = false;
+ _pFrameControlElement._resizable = false;
+
+ _pFrameControlElement._doc = null;
+
+ _pFrameControlElement.create = function (win) {
+ var _doc, handle, handle_style, inner_node, innernodestyle;
+ if (!this.handle) {
+ if (this.parent_elem == null) {
+ _doc = this._doc = win._doc;
+ this.owner_elem = win;
+ this._is_window_element = true;
+ this.left = 0;
+ this.top = 0;
+ if (nexacro._allow_default_pinchzoom) {
+ this.width = nexacro._getWindowHandleClientWidth(win.handle);
+ this.height = nexacro._getWindowHandleClientHeight(win.handle);
+ }
+ else {
+ this.width = win.clientWidth;
+ this.height = win.clientHeight;
+ }
+
+ handle = win.dest_handle;
+
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ this.handle = this.dest_handle = handle;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+
+ if (!this._is_simple_control) {
+ inner_node = _doc.createElement("div");
+ this.dest_handle = inner_node;
+ nexacro.__setDOMNode_ClassName(inner_node, this._getElementNexaClassName("nexasimplecontainer"));
+ nexacro.__setDOMNode_Id(inner_node, "", "nexacontainer");
+ nexacro.__appendDOMNode(handle, inner_node);
+
+ innernodestyle = inner_node.style;
+ nexacro.__setDOMStyle_Pos(innernodestyle, this.client_left, this.client_top);
+ nexacro.__setDOMStyle_Size(innernodestyle, this.client_width, this.client_height);
+ }
+
+ handle_style = handle.style;
+
+
+ if (!nexacro._allow_default_pinchzoom && nexacro._isDesktop()) {
+ nexacro.__setDOMStyle_Fixed(handle_style);
+ }
+
+ this._refreshControl(handle, handle_style, _doc);
+
+
+ nexacro.__setDOMStyle_BorderNone(handle_style, true, true, true, true, this.border, this.rtl);
+ }
+ else {
+ var owner_elem = (this._is_nc_element) ? this.parent_elem : this.parent_elem.getContainerElement();
+ if (owner_elem && owner_elem.handle && !this.handle) {
+ this.owner_elem = owner_elem;
+ _doc = owner_elem._getRootWindowHandle();
+ handle = _doc.createElement("div");
+
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ this.handle = this.dest_handle = handle;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementClassName());
+
+ handle_style = handle.style;
+ if (owner_elem instanceof nexacro.ModalOverlayElement) {
+ if (!nexacro._allow_default_pinchzoom && nexacro._isDesktop()) {
+ nexacro.__setDOMStyle_Fixed(handle_style);
+ }
+ }
+
+
+ if (!this._is_simple_control) {
+ inner_node = _doc.createElement("div");
+ this.dest_handle = inner_node;
+ nexacro.__setDOMNode_ClassName(inner_node, this._getElementNexaClassName("nexasimplecontainer"));
+ nexacro.__setDOMNode_Id(inner_node, "", "nexacontainer");
+ nexacro.__appendDOMNode(handle, inner_node);
+
+ innernodestyle = inner_node.style;
+ nexacro.__setDOMStyle_Pos(innernodestyle, this.client_left, this.client_top);
+ if (this.client_width && this.client_height) {
+ nexacro.__setDOMStyle_Size(innernodestyle, this.client_width, this.client_height);
+ }
+ }
+
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top);
+ if (this.width && this.height) {
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+ }
+
+ this._refreshControl(handle, handle_style, _doc);
+
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+
+
+ this._frame_node = nexacro._createFrameNode(handle, this.left, this.top, _doc, this.width, this.height);
+ }
+ }
+
+ if (this._resizable) {
+ this._createBorderElements();
+ this._updateBorderElementsPosition();
+ }
+ }
+ else {
+ if (this.parent_elem == null) {
+ var _win = win;
+ if (this.handle != _win.dest_handle) {
+ var old_handle = this.handle;
+
+ _doc = this._doc = _win._doc;
+ handle = _win.dest_handle;
+
+ this.owner_elem = _win;
+ this._is_window_element = true;
+ this.left = 0;
+ this.top = 0;
+ this.width = _win.clientWidth;
+ this.height = _win.clientHeight;
+
+ handle.id = this.name;
+ handle._linked_element = this;
+
+ this.handle = this.dest_handle = handle;
+
+ handle_style = handle.style;
+
+ if (this.border) {
+ this.border = null;
+ }
+
+ this._title_height = 0;
+ this._status_height = 0;
+
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top);
+ if (this.width && this.height) {
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+ }
+
+ this._refreshControl(handle, handle_style, _doc);
+
+ if (old_handle.hasChildNodes()) {
+ var childs = old_handle.childNodes;
+ for (var i = 0; i < childs.length; i++) {
+ var child = childs[i];
+ nexacro.__appendDOMNode(handle, child);
+ }
+ }
+ }
+ }
+ }
+ };
+
+ _pFrameControlElement._on_destroy = function () {
+ this._destroyBorderElements();
+
+ this._title_control = null;
+ this._status_control = null;
+ };
+
+
+
+ _pFrameControlElement.setElementCSSMapInfo = function (border, padding, edge) {
+ if (this.linkedcontrol && this.linkedcontrol._is_window) {
+ border = null;
+ }
+
+ nexacro.ControlElement.prototype.setElementCSSMapInfo.call(this, border, null, edge);
+ };
+
+ _pFrameControlElement._getRootWindowHandle = function () {
+ if (this._is_window_element) {
+ return this._doc;
+ }
+ else if (this.owner_elem) {
+ return this.owner_elem._getRootWindowHandle();
+ }
+ else if (this.parent && this.parent._getRootWindowHandle) {
+ return this.parent._getRootWindowHandle();
+ }
+ return null;
+ };
+
+ _pFrameControlElement.setElementBorder = function (border) {
+ if (this.linkedcontrol && this.linkedcontrol._is_window) {
+ return;
+ }
+
+ nexacro.ControlElement.prototype.setElementBorder.call(this, border);
+ };
+
+ _pFrameControlElement._updateClientRect = function () {
+ var ret = this._on_updateClientRect();
+ if (ret & 1) {
+ this._on_change_clientPos(this.client_left, this.client_top);
+ }
+ if (ret & 2) {
+ this._on_change_clientSize(this.client_width, this.client_height);
+ }
+
+ if (ret) {
+ this._updateBorderElementsPosition();
+ }
+ };
+
+ _pFrameControlElement._on_updateClientRect = function () {
+ var client_left = 0;
+ var client_top = 0;
+ var client_width = this.inner_width;
+ var client_height = this.inner_height;
+
+ if (this._apply_client_padding) {
+ var padding = (this.padding || this._padding_info);
+ if (padding) {
+ client_left = padding.left;
+ client_top = padding.top;
+ client_width -= padding.left + padding.right;
+ client_height -= padding.top + padding.bottom;
+ }
+ }
+
+ var title_control = this._title_control;
+ if (title_control) {
+ if (!this._is_verticalmin && (this.client_left != client_left || this._title_top != client_top || this._title_width != client_width)) {
+ this._title_top = client_top;
+ this._title_width = client_width;
+ title_control.move(client_left, client_top, client_width, this._title_height);
+ }
+ else if (this._is_verticalmin && (this.client_top != client_top || this._title_top != client_top || this._title_height != client_height)) {
+ this._title_top = client_top;
+ this._title_width = client_width;
+ title_control.move(client_left, client_top, client_width, client_height);
+ }
+ client_top += this._title_height;
+ client_height -= this._title_height;
+ if (client_height < 0) {
+ client_height = 0;
+ }
+ }
+ else {
+ this._title_top = client_top;
+ }
+
+ var status_control = this._status_control;
+ if (status_control) {
+ if (this._status_height > 0) {
+ client_height -= this._status_height;
+ if (client_height < 0) {
+ client_height = 0;
+ }
+ }
+ var status_top = client_top + client_height;
+ if (this.client_left != client_left || this._status_top != status_top || this._status_width != client_width) {
+ this._status_top = status_top;
+ this._status_width = client_width;
+ status_control.move(client_left, status_top, client_width, this._status_height);
+ }
+ }
+ else {
+ this._status_top = client_top + client_height;
+ }
+
+ var ret = 0;
+ if (this.client_left != client_left || this.client_top != client_top) {
+ this.client_left = client_left;
+ this.client_top = client_top;
+ ret = 1;
+ }
+ if (this.client_width != client_width || this.client_height != client_height) {
+ this.client_width = client_width;
+ this.client_height = client_height;
+ ret += 2;
+ }
+ return ret;
+ };
+
+
+
+
+
+ _pFrameControlElement.appendChildElement = function (child_elem) {
+ if (this.handle) {
+ if (!this._client_elem) {
+ return;
+ }
+
+ if (child_elem.parent_elem == this._client_elem) {
+ child_elem._is_nc_element = true;
+ }
+ else {
+ if (child_elem.handle) {
+ var old_doc = child_elem._getRootWindowHandle();
+ var new_doc = this._getRootWindowHandle();
+ if (old_doc != new_doc) {
+ child_elem.parent_elem = this._client_elem;
+ child_elem._removeFromContainer();
+ }
+ else {
+ child_elem.parent_elem = this._client_elem;
+ }
+ }
+ else {
+ child_elem.parent_elem = this._client_elem;
+ }
+ }
+
+ child_elem._is_nc_element = true;
+
+ child_elem.setElementPosition(0, 0);
+ child_elem.setElementSize(this.client_width, this.client_height);
+
+ if (!child_elem.handle) {
+ child_elem.create();
+ }
+ else {
+ child_elem._appendToContainer(this._client_elem);
+ }
+ }
+ };
+
+ _pFrameControlElement.removeChildElement = function (child_elem) {
+ if (child_elem.parent_elem == this) {
+ child_elem._removeFromContainer();
+ }
+ };
+
+
+ _pFrameControlElement.sendToBackElement = function (elem) {
+ if (elem && elem.owner_elem &&
+ elem.owner_elem.owner_elem == this.owner_elem && elem.handle) {
+ nexacro.__sendDOMNodeToBack(elem.handle);
+ if (elem._border_elems) {
+ for (var i = 0; i < elem._border_elems.length; i++) {
+ nexacro.__sendDOMNodeToBack(elem._border_elems[i].handle);
+ }
+ }
+ }
+ };
+
+ _pFrameControlElement.bringToFrontElement = function (elem) {
+ if (this.handle) {
+ this._max_child_zindex++;
+
+ var new_zindex = (this._max_child_zindex * 10);
+
+ elem.setElementZIndex(new_zindex);
+ if (elem._border_elems) {
+ for (var i = 0; i < elem._border_elems.length; i++) {
+ elem._border_elems[i].setElementZIndex(new_zindex + (i + 1));
+ }
+ }
+ }
+ };
+
+ _pFrameControlElement.moveToNextElement = function (elem, base_elem) {
+ var client_elem = this.getContainerElement(elem.position_step);
+ client_elem.moveToNextElement(elem, base_elem);
+ };
+
+ _pFrameControlElement.moveToPrevElement = function (elem, base_elem) {
+ var client_elem = this.getContainerElement(elem.position_step);
+ client_elem.moveToPrevElement(elem, base_elem);
+ };
+
+ _pFrameControlElement.setTitleBarControl = function (title_control, title_height) {
+ this._title_control = title_control;
+ if (title_control) {
+ this._title_height = parseInt(title_height) | 0;
+ this._title_width = 0;
+ }
+ else {
+ this._title_height = 0;
+ this._title_width = 0;
+ }
+
+ this._updateClientRect();
+ };
+
+ _pFrameControlElement.setStatusBarControl = function (status_control, status_height) {
+ this._status_control = status_control;
+ if (status_control) {
+ this._status_height = parseInt(status_height) | 0;
+ this._status_width = 0;
+ }
+ else {
+ this._status_height = 0;
+ this._status_width = 0;
+ }
+
+ this._updateClientRect();
+ };
+
+
+ _pFrameControlElement._createBorderElements = function () {
+ if (this.parent == null || this.parent_elem == null) {
+ return;
+ }
+
+ if (this._border_elems.length > 0) {
+ return;
+ }
+
+ var i, border_elem;
+ var name_table = Array("lt", "t", "rt", "l", "r", "lb", "b", "rb");
+ for (i = 0; i < 8; i++) {
+ border_elem = new nexacro._FrameResizeBorderElement(this.parent_elem);
+
+ border_elem.parent = this;
+
+ this._border_elems.add_item(name_table[i], border_elem);
+ }
+
+ this._setResizable(this._resizable);
+
+ var win = this.linkedcontrol._getWindow();
+
+ for (i = 0; i < 8; i++) {
+ border_elem = this._border_elems[i];
+ border_elem.linkedcontrol = this.linkedcontrol;
+ border_elem.create(win);
+ }
+ };
+
+ _pFrameControlElement._destroyBorderElements = function () {
+ var cnt = this._border_elems.length;
+ for (var i = 0; i < cnt; i++) {
+ this._border_elems[i].destroy();
+ this._border_elems[i] = null;
+ }
+
+ this._border_elems.clear();
+ this._border_elems = null;
+ };
+
+ _pFrameControlElement.setElementPosition = function (x, y) {
+ nexacro.ControlElement.prototype.setElementPosition.call(this, x, y);
+ this._updateBorderElementsPosition();
+ };
+
+
+ _pFrameControlElement._updateBorderElementsPosition = function () {
+ if (this._border_elems.length == 0) {
+ return;
+ }
+
+ var border = this.border || this._border_info;
+ var lw = 0, tw = 0, rw = 0, bw = 0;
+ if (border) {
+ if (border._single == 1) {
+ lw = tw = rw = bw = border._getBorderWidth();
+ }
+ else {
+ lw = border.left._width;
+ tw = border.top._width;
+ rw = border.right._width;
+ bw = border.bottom._width;
+ }
+ }
+
+ var inner_width = this.inner_width;
+ var inner_height = this.inner_height;
+
+ if (lw < 5) {
+ var lx = 5 - lw;
+ lw += lx;
+ inner_width -= lx;
+ }
+ if (tw < 5) {
+ var tx = 5 - tw;
+ tw += tx;
+ inner_height -= tx;
+ }
+ if (rw < 5) {
+ var rx = 5 - rw;
+ rw += rx;
+ inner_width -= rx;
+ }
+ if (bw < 5) {
+ var bx = 5 - bw;
+ bw += bx;
+ inner_height -= bx;
+ }
+
+ var left = this.left;
+ var top = this.top;
+
+ var x = left;
+ var y = top;
+ var i;
+ for (i = 0; i < 8; i++) {
+ this._border_elems[i].setElementPosition(x, y);
+ switch (i) {
+ case 0:
+ x += lw;
+ break;
+ case 1:
+ x += inner_width;
+ break;
+ case 2:
+ x = left;
+ y += tw;
+ break;
+ case 3:
+ x += (lw + inner_width);
+ break;
+ case 4:
+ x = left;
+ y += inner_height;
+ break;
+ case 5:
+ x += lw;
+ break;
+ case 6:
+ x += inner_width;
+ break;
+ case 7:
+ break;
+ }
+ }
+ var w, h;
+ for (i = 0; i < 8; i++) {
+ if (i == 0 || i == 3 || i == 5) {
+ w = lw;
+ }
+ if (i == 1 || i == 6) {
+ w = inner_width;
+ }
+ if (i == 2 || i == 4 || i == 7) {
+ w = rw;
+ }
+ if (i < 3) {
+ h = tw;
+ }
+ else if (i < 5) {
+ h = inner_height;
+ }
+ else {
+ h = bw;
+ }
+ this._border_elems[i].setElementSize(w, h);
+ }
+ };
+
+ _pFrameControlElement._setResizable = function (resizable) {
+ this._resizable = resizable;
+ if (this.handle) {
+ if (this._border_elems.length == 0) {
+ if (resizable) {
+ this._createBorderElements();
+ this._updateBorderElementsPosition();
+ }
+ else {
+ return;
+ }
+ }
+
+ var cursor_table = Array("nw", "n", "ne", "w", "e", "sw", "s", "se");
+ for (var i = 0; i < 8; i++) {
+ var border_elem = this._border_elems[i];
+ border_elem._is_track = resizable;
+
+ var cursor;
+ if (resizable) {
+ cursor = nexacro.CursorObject(cursor_table[i] + "-resize");
+ }
+ else {
+ cursor = nexacro.CursorObject("arrow");
+ }
+ border_elem.setElementCursor(cursor);
+ }
+ }
+
+ var statuscontrol = this._status_control;
+ if (statuscontrol) {
+ statuscontrol.set_resizable(resizable);
+ }
+ };
+
+ nexacro._FrameResizeBorderElement = function (parent_elem) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ };
+
+ var __pFrameResizeBorderElement = nexacro._createPrototype(nexacro.ControlElement, nexacro._FrameResizeBorderElement);
+ nexacro._FrameResizeBorderElement.prototype = __pFrameResizeBorderElement;
+
+ __pFrameResizeBorderElement._type_name = "FrameResizeBorderElement";
+ __pFrameResizeBorderElement._is_simple_control = true;
+
+ __pFrameResizeBorderElement._on_starttrack = function () {
+ this.linkedcontrol._on_border_starttrack(this.cursor);
+ };
+ __pFrameResizeBorderElement._on_endtrack = function (x, y, dragdata) {
+ this.linkedcontrol._on_border_endtrack(x, y, dragdata);
+ };
+ __pFrameResizeBorderElement._on_movetrack = function (x, y, dragdata) {
+ this.linkedcontrol._on_border_movetrack(x, y, dragdata);
+ };
+
+ __pFrameResizeBorderElement._updateClientRect = nexacro._emptyFn;
+
+ nexacro.ModalOverlayElement = function (parent_elem) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ };
+
+ var _pModalOverlayElement = nexacro._createPrototype(nexacro.ControlElement, nexacro.ModalOverlayElement);
+ nexacro.ModalOverlayElement.prototype = _pModalOverlayElement;
+ _pModalOverlayElement._type_name = "ModalOverlayElement";
+ _pModalOverlayElement._background_handle = null;
+
+
+ _pModalOverlayElement.create = function (win) {
+ if (this.parent_elem && !this.handle) {
+ var _doc = this._doc = this.parent_elem._getRootWindowHandle();
+ var handle = _doc.createElement("div");
+ handle._linked_element = this;
+
+
+ this.handle = this.dest_handle = handle;
+
+ var handle_style = handle.style;
+
+ nexacro.__setDOMNode_ClassName(handle, this._getElementNexaClassName("nexamodaloverlay"));
+ nexacro.__setDOMNode_Id(handle, "", "nexacontainer");
+ nexacro.__setDOMStyle_Pos(handle_style, 0, 0);
+ nexacro.__setDOMStyle_Size(handle_style, win.clientWidth, win.clientHeight);
+
+ var owner_elem = win.frame.getElement();
+ var waitcomp_elem = win.frame._getWaitComponentElement();
+ var ref_dest_handle = null;
+ if (waitcomp_elem) {
+ ref_dest_handle = waitcomp_elem.handle;
+ }
+ if (ref_dest_handle) {
+ owner_elem.dest_handle.insertBefore(handle, ref_dest_handle);
+ }
+ else {
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+ }
+
+
+ this._refreshControl(handle, handle.style, _doc);
+ this._createBackgroundElement(_doc, handle, win.clientWidth, win.clientHeight);
+ if (nexacro._isDesktop() && nexacro._Browser == "Chrome") {
+ var _window = this._getWindow();
+ if (_window) {
+ this.setElementZoom(_window._wheelZoom);
+ }
+ }
+ if (nexacro._enableaccessibility && nexacro._accessibilitytype == 5) {
+ nexacro.__removeHTMLAttr_Proeprty(handle, "tabindex");
+ }
+
+ this._frame_node = nexacro._createFrameNode(handle, this.left, this.top, _doc, win.clientWidth, win.clientHeight);
+ if (this._frame_node) {
+ this._frame_node._linked_element = this;
+ nexacro._observeSysEvent(this._frame_node, "load", "onload", this._iframe_eventhandler_onload);
+ }
+ }
+ };
+
+ _pModalOverlayElement._iframe_eventhandler_onload = function (evt) {
+ if (window.event) {
+ evt = window.event;
+ }
+
+ var node = evt.srcElement || evt.target;
+ if (!node) {
+ return;
+ }
+
+ try {
+ var _doc = node.contentDocument || node.contentWindow.document;
+ if (this._linked_element) {
+ nexacro._observeSysEvent(_doc, "mousemove", "onmousemove", this._linked_element._iframe_eventhandler_onmousemove);
+ nexacro._observeSysEvent(_doc, "contextmenu", "oncontextmenu", this._linked_element._iframe_eventhandler_oncontextmenu);
+ nexacro._observeSysEvent(_doc, "mouseup", "onmouseup", this._linked_element._iframe_eventhandler_onmouseup);
+ }
+ }
+ catch (e) {
+ }
+ };
+
+ _pModalOverlayElement._iframe_eventhandler_onmouseup = function (evt) {
+ return nexacro._syshandler_onmouseup(window.nexacro_HTMLSysEvent, null, evt);
+ };
+
+ _pModalOverlayElement._iframe_eventhandler_onmousemove = function (evt) {
+ return nexacro._syshandler_onmousemove(window.nexacro_HTMLSysEvent, null, evt);
+ };
+
+ _pModalOverlayElement._iframe_eventhandler_oncontextmenu = function (evt) {
+ return nexacro._stopSysEvent(evt);
+ };
+
+ _pModalOverlayElement.destroy = function () {
+ if (!this.handle) {
+ return;
+ }
+
+ var _win = this.linkedcontrol._getWindow();
+ var owner_elem = _win.frame.getElement();
+ this._destroyBackgroundElement(this.handle);
+ nexacro.__removeDOMNode(owner_elem.dest_handle, this.handle);
+ this.handle = null;
+
+ if (this._frame_node) {
+ this._frame_node._linked_element = null;
+ }
+
+ nexacro._destroyFrameNode(this.handle, this._frame_node);
+ this._frame_node = null;
+ };
+
+ _pModalOverlayElement.setElementSize = function (width, height, update) {
+ nexacro.Element.prototype.setElementSize.call(this, width, height, update);
+ if (this._frame_node) {
+ nexacro.__setDOMStyle_Size(this._frame_node.style, width, height);
+ }
+ };
+
+ if (nexacro._Browser == "IE" && nexacro._BrowserVersion < 9) {
+ _pModalOverlayElement._createBackgroundElement = function (_doc, overlay_handle, width, height) {
+ var background = this.background;
+ var background_handle = _doc.createElement("div");
+ var bRtl = this._isRtl();
+
+ nexacro.__setDOMStyle_Size(background_handle.style, width, height);
+
+ if (background) {
+ nexacro.__setDOMStyle_BackgroundObject(overlay_handle.style, null, bRtl);
+ nexacro.__setDOMStyle_BackgroundObject(background_handle.style, background, bRtl);
+ }
+ nexacro.__setDOMStyle_Filter(background_handle.style, 50);
+ nexacro.__appendDOMNode(overlay_handle, background_handle);
+ this._background_handle = background_handle;
+ };
+
+ _pModalOverlayElement._destroyBackgroundElement = function (handle) {
+ var background_handle = this._background_handle;
+ if (background_handle) {
+ nexacro.__removeDOMNode(handle, background_handle);
+ }
+ this._background_handle = null;
+ };
+ }
+ else {
+ _pModalOverlayElement._createBackgroundElement = nexacro._emptyFn;
+ _pModalOverlayElement._destroyBackgroundElement = nexacro._emptyFn;
+ }
+
+ _pModalOverlayElement._getRootWindowHandle = function () {
+ return this._doc;
+ };
+
+ nexacro._OverlayElement = function (parent_elem) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+
+ this.background = nexacro.BackgroundObject("grey");
+ this.opacity = nexacro.OpacityObject(0.1);
+ };
+
+ var _pOverlayElement = nexacro._createPrototype(nexacro.ModalOverlayElement, nexacro._OverlayElement);
+ nexacro._OverlayElement.prototype = _pOverlayElement;
+ _pOverlayElement._type_name = "OverlayElement";
+ _pOverlayElement._background_handle = null;
+
+ _pOverlayElement.create = function (win) {
+ if (this.parent_elem && !this.handle) {
+ var _doc = this._doc = this.parent_elem._getRootWindowHandle();
+ var handle = _doc.createElement("div");
+ handle._linked_element = this;
+
+ this.handle = this.dest_handle = handle;
+
+ var handle_style = handle.style;
+ nexacro.__setDOMNode_ClassName(handle, this._getElementNexaClassName("nexamodaloverlay"));
+ nexacro.__setDOMNode_Id(handle, "", "nexacontainer");
+ nexacro.__setDOMStyle_Pos(handle_style, 0, 0);
+
+ var owner_elem = this.parent.getElement();
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+
+ this._refreshControl(handle, handle.style, _doc);
+ this._createBackgroundElement(_doc, handle);
+
+ if (nexacro._enableaccessibility && nexacro._accessibilitytype == 5) {
+ nexacro.__removeHTMLAttr_Proeprty(handle, "tabindex");
+ }
+
+ this._frame_node = nexacro._createFrameNode(handle, this.left, this.top, _doc);
+ if (this._frame_node) {
+ this._frame_node._linked_element = this;
+ nexacro._observeSysEvent(this._frame_node, "load", "onload", this._iframe_eventhandler_onload);
+ }
+ }
+ };
+
+ _pOverlayElement = null;
+
+ nexacro._ContainerElement = function (parent_elem, use_translate_scroll, type, use_onscroll_inner) {
+ this.parent = parent_elem;
+ this.parent_elem = parent_elem;
+ this._use_translate_scroll = (use_translate_scroll === false) ? use_translate_scroll : nexacro._use_translate_scroll;
+ this.type = (type) ? type : "";
+ this._use_onscroll_inner = use_onscroll_inner;
+ };
+
+ var __pContainerElement = nexacro._createPrototype(nexacro.Element, nexacro._ContainerElement);
+ nexacro._ContainerElement.prototype = __pContainerElement;
+ __pContainerElement._type_name = "ContainerElement";
+
+ __pContainerElement._scroll_left = 0;
+ __pContainerElement._scroll_top = 0;
+ __pContainerElement._scroll_maxwidth = 0;
+ __pContainerElement._scroll_maxheight = 0;
+ __pContainerElement._cached_scrollLeft = 0;
+ __pContainerElement._cached_scrollTop = 0;
+ __pContainerElement._is_nc_element = true;
+ __pContainerElement._use_translate_scroll = nexacro._use_translate_scroll;
+ __pContainerElement._use_container_move = true;
+ __pContainerElement.type = "";
+
+ var _bind_container_scroll_handler_after = nexacro._emptyFn;
+
+ var _bind_container_scroll_handler = function (elem) {
+ return function (evt) {
+ if (!evt && window.event) {
+ evt = window.event;
+ }
+
+ var target = evt.srcElement || evt.target;
+ if (!target) {
+ return;
+ }
+
+ evt._node_activate_scroll = undefined;
+
+ if (elem._use_translate_scroll) {
+ target.scrollLeft = 0;
+ target.scrollTop = 0;
+ }
+ else {
+ if ((elem._scroll_top != target.scrollTop || elem._scroll_left != target.scrollLeft) && elem._use_onscroll_inner != true) {
+ evt._node_activate_scroll = true;
+ elem._callback_func_onscroll(evt);
+ }
+ else {
+ elem._scroll_left = target.scrollLeft;
+ elem._scroll_top = target.scrollTop;
+ elem._scroll_maxwidth = target.scrollWidth;
+ elem._scroll_maxheight = target.scrollHeight;
+ elem._callback_func_onscroll(evt);
+ }
+
+ _bind_container_scroll_handler_after(elem, target.scrollLeft, target.scrollTop);
+ }
+ };
+ };
+
+ if (nexacro._Browser == "IE") {
+ __pContainerElement._callback_func_onscroll = function (evt) {
+ if ((!evt || evt.type != "scroll") && window.event) {
+ evt = window.event;
+ }
+ if (evt.type != "scroll") {
+ return;
+ }
+
+ var target = evt.srcElement;
+ if (!target) {
+ return;
+ }
+
+ var container = target._linked_element;
+ if (container) {
+ var parent_elem = container.parent;
+ var retn = false;
+
+ if (parent_elem._recover_vpos != undefined) {
+ target.scrollTop = parent_elem._recover_vpos;
+ parent_elem._recover_vpos = undefined;
+ retn = true;
+ }
+ if (parent_elem._recover_hpos != undefined) {
+ target.scrollLeft = parent_elem._recover_hpos;
+ parent_elem._recover_hpos = undefined;
+ retn = true;
+ }
+
+ if (retn) {
+ return;
+ }
+
+ var elem_scroll_top = container._scroll_top | 0;
+ var elem_scroll_left = container._scroll_left | 0;
+
+ container._cached_scrollLeft = target.scrollLeft;
+ container._cached_scrollTop = target.scrollTop;
+
+ var hscroll_pos = container._cached_scrollLeft;
+ var vscroll_pos = container._cached_scrollTop;
+
+ var linkedcontrol = container._findScrollbarControl(container, false);
+
+ var bhscroll = false;
+ var bvscroll = false;
+ if (linkedcontrol) {
+ if (elem_scroll_left != container._cached_scrollLeft) {
+ if (linkedcontrol.scrollbartype != "none" && linkedcontrol.scrollbartype != "vertical") {
+ bhscroll = true;
+ }
+ }
+
+ if (elem_scroll_top != container._cached_scrollTop) {
+ if (linkedcontrol.scrollbartype != "none" && linkedcontrol.scrollbartype != "horizontal") {
+ bvscroll = true;
+ }
+ }
+
+ if (bhscroll || bvscroll) {
+ linkedcontrol._scrollTo(bhscroll ? hscroll_pos : null, bvscroll ? vscroll_pos : null);
+ }
+ }
+ }
+ };
+ }
+ else {
+ __pContainerElement._callback_func_onscroll = function (evt) {
+ };
+ }
+
+ __pContainerElement.create = function (win) {
+ var owner_elem = this.parent_elem;
+ if (owner_elem && owner_elem.handle && !this.handle) {
+ this.owner_elem = owner_elem;
+ this.name = owner_elem.name + ":container" + this.type;
+ var _doc = win ? win._doc : owner_elem._getRootWindowHandle();
+
+ var handle = _doc.createElement("div");
+ handle._linked_element = this;
+
+ this.handle = handle;
+
+ if (this._use_native_scroll) {
+ nexacro.__setDOMNode_ClassName(handle, this._getElementNexaClassName("nexacontainer", "nexanativescroll"));
+ nexacro.__setDOMNode_Id(handle, "", "nexacontainer");
+ }
+ else {
+ nexacro.__setDOMNode_ClassName(handle, this._getElementNexaClassName("nexacontainer"));
+ nexacro.__setDOMNode_Id(handle, "", "nexacontainer");
+ }
+
+ this.createInnerContainer(_doc);
+
+ var handle_style = handle.style;
+ nexacro.__setDOMStyle_Pos(handle_style, this.left, this.top, this._isParentRtl());
+ nexacro.__setDOMStyle_Size(handle_style, this.width, this.height);
+
+ if (this.parent._step_count > 0) {
+ nexacro.__setDOMStyle_ScrollLimitX(handle.style, 0);
+ }
+ else {
+ nexacro.__setDOMStyle_ScrollLimitX(handle.style, this._scroll_type & 0x10);
+ }
+
+ nexacro.__setDOMStyle_ScrollLimitY(handle.style, this._scroll_type & 0x01);
+
+ nexacro.__appendDOMNode(owner_elem.dest_handle, handle);
+
+ this._syshandler_onscroll_forward = _bind_container_scroll_handler(this);
+ nexacro._observeSysEvent(handle, "scroll", "onscroll", this._syshandler_onscroll_forward);
+ }
+ };
+
+ __pContainerElement.createCommandStart = function () {
+ var owner_elem = this.parent_elem;
+ if (owner_elem && !this.handle) {
+ this.owner_elem = owner_elem;
+ this.name = owner_elem.name + ":container" + this.type;
+ var str = "
";
+ }
+
+ return str;
+ }
+ return "";
+ };
+
+ __pContainerElement.createCommandEnd = function () {
+ var str = "";
+ if (this._use_translate_scroll || this._use_onscroll_inner) {
+ str += "