Internal function to generate the internal widget markup
@param {aria.templates.MarkupWriter} out
@protected
336898
function (out) {
            // --------------------------------------------------- destructuring

            var cfg = this._cfg;

            var waiAria = cfg.waiAria;
            var waiTitleTag = cfg.waiTitleTag;

            // ------------------------------------------------------ processing

            if (waiAria) {
                out.write('</a>');
                if (waiTitleTag) {
                    out.write('</' + waiTitleTag + '>');
                }
            }

            this._frame.writeMarkupEnd(out);
        }
1254844
function (out) {
                if (this.domType) {
                    // if domType is empty, we do not output anything for the section
                    // (used in the tooltip)
                    var attributeList = this.attributes ? ariaUtilsHtml.buildAttributeList(this.attributes) : '';
                    var h = ['<', this.domType, attributeList, ' id="', this._domId, '" ',
                            ariaUtilsDelegate.getMarkup(this.delegateId), '>'];
                    out.write(h.join(''));// opening the section
                }
            }
800220
function (out) {
            out.writeln("$prototype: {");
            out.increaseIndent();
            out.write(out.getBlockContent("prototype"));
            out.decreaseIndent();
            out.writeln("}");
            out.decreaseIndent();
            out.writeln("});");
            out.leaveBlock();
        }
225455
function (out) {
            var cfg = this._cfg, orientation = this._orientation, cfgH, cfgW, cfgHclass, cfgWclass;
            var size = this._calculateSize(cfg), size1 = size.size1, size2 = size.size2, splitterBarPos;
            var panelBorder = orientation ? this._panelBorderH : this._panelBorderV;
            if (size1 === 0) {
                splitterBarPos = 0;
                size2 += panelBorder;
            } else {
                if (size2 === 0) {
                    size1 += panelBorder;
                }
                splitterBarPos = size1 + panelBorder;
            }

            this.setProperty("size1", size1);
            this.setProperty("size2", size2);
            var borderClass = "";
            var sclass = cfg.sclass;
            var height = cfg.height - this._containerBorderH, width = cfg.width - this._containerBorderV;

            if (cfg.border) {
                borderClass = "xSplitter_" + sclass + "_sBdr";
            }
            this._handleBarClass = "xSplitter_" + sclass + (orientation ? "_sHandleH" : "_sHandleV");

            if (orientation) {
                cfgH = height, cfgW = width, cfgWclass = width - this._panelBorderV, cfgHclass = size1;
            } else {
                cfgH = height, cfgHclass = height - this._panelBorderH, cfgW = width, cfgWclass = size1;
            }

            out.write(['<span class="xSplitter_', sclass, '_sContainer ', borderClass, '" style="height:', cfgH,
                    'px;width:', cfgW, 'px;"><span class="xSplitter_', sclass,
                    '_sConstrained"  ><span class="xSplitter_', sclass, '_sMacro" style="height: ', cfgHclass,
                    'px; width:', cfgWclass, 'px;">'].join(""));
            out.beginSection({
                id : "_splitterContent1_" + this._domId,
                macro : cfg.macro1
            });
            out.endSection();
            out.write('</span> ');

            var sDimension, sPosition, sEndPosition, splitterBarSize;
            if (orientation) {
                cfgHclass = size2, cfgWclass = width - this._panelBorderV, sDimension = "width", splitterBarSize = width
                        - this._separatorBorderV, sPosition = "top", sEndPosition = "bottom";
            } else {
                cfgHclass = height - this._panelBorderH, cfgWclass = size2, sDimension = "height", splitterBarSize = height
                        - this._separatorBorderH, sPosition = "left", sEndPosition = "right";
            }

            out.write(['<span class="', this._handleBarClass, '" style="' + sDimension + ':', splitterBarSize,
                    'px;' + sPosition + ':', splitterBarPos, 'px; "> </span><span id="splitBarProxy_', this._domId,
                    '" class="', this._handleBarClass, ' " style="' + sPosition + ':', splitterBarPos,
                    'px; ' + sDimension + ':' + splitterBarSize + 'px;"></span><span class="xSplitter_', sclass,
                    '_sMacro" style="height: ', cfgHclass, 'px;width:', cfgWclass, 'px;' + sEndPosition + ':0px">'].join(""));

            out.beginSection({
                id : "_splitterContent2_" + this._domId,
                macro : cfg.macro2
            });
            out.endSection();
            out.write(['</span> </span> </span>'].join(""));

        }
754655
function(markup) {

	var container = y.createElement('div');
	container.innerHTML = markup;

	return new NWTNodeInstance(container.childNodes[0]);
}
1085061
function (out) {
                var cssPrefix = this._cssPrefix;
                out.write('</span></span>');
                this._writeExtraMarkupEnd(out);
                var hasBorder = this._hasBorder(this._cfg.stateObject.skipRightBorder, this._cfg.iconsRight);
                out.write(['<span ', hasBorder ? '' : 'style="display:none;"', ' class="xFixedHeightFrame_bme ',
                        cssPrefix, 'e ', cssPrefix, 'bkgA"></span>'].join(''));
                out.write('</span>');
            }
392198
function (out) {
            var cfg = this._cfg;
            var tabString = (cfg.tabIndex != null ? ' tabindex="' + this._calculateTabIndex() + '" ' : ' ');
            out.write(['<a', Aria.testMode ? ' id="' + this._domId + '_link"' : '',
                    ' class="sortIndicatorLink" href="#"' + tabString + this._getWaiAriaMarkup() + '>' + ariaUtilsString.escapeHTML(cfg.label)].join(""));
            this._icon.writeMarkup(out);
            out.write('</a>');
        }
59338
function (out) {
            var skinObj = this._skinObj, cfg = this._cfg;
            out.write(['<span style="float:left;text-align:', cfg.labelAlign,
                    skinObj.labelMargins ? ';margin:' + skinObj.labelMargins : '',
                    skinObj.labelFontSize ? ';font-size:' + skinObj.labelFontSize + 'px' : '',
                    cfg.labelWidth > -1 ? ';width:' + cfg.labelWidth + 'px' : '', '">',
                    ariaUtilsString.escapeHTML(cfg.label), '</span>'].join(""));
        }
558429
function (out) {
            var cfg = this._cfg, cssPrefix = this._cssPrefix; // , state = cfg.stateObject;
            var frameContainerClass = (cfg.block !== true) ? ' ' : 'class="xBlock"';
            var sizeInfo = {
                style : '',
                /*
                 * TODO: the CSS class cssClass should not define any padding, margin or border for the frame to be
                 * correctly displayed
                 */
                className : 'xFrameContent ' + cssPrefix + 'c ' + cfg.cssClass
            };
            this._appendInnerSizeInfo(sizeInfo);
            var displayInline = "";

            if (this._inlineBlock) {
                displayInline = "vertical-align: middle;display: inline";
                displayInline += (ariaCoreBrowser.isIE7) ? ";zoom:1" : "-block;";
            }

            out.write(['<table cellspacing="0" cellpadding="0" style="position: relative;' + displayInline + '"',
                    frameContainerClass, '><tbody isFrame="1">', '<tr>', '<td class="', cssPrefix, 'tlc ', cssPrefix,
                    'bkgA"></td>', '<td class="', cssPrefix, 'ts ', cssPrefix,
                    'bkgB">' + this.__addFrameIcon(cfg, cssPrefix, 'top') + '</td>', '<td class="', cssPrefix, 'trc ',
                    cssPrefix, 'bkgA"></td>', '</tr>', '<tr>', '<td class="', cssPrefix, 'ls ', cssPrefix,
                    'bkgC"></td>', '<td class="', cssPrefix, 'm">', '<span ',
                    Aria.testMode && this._baseId ? ' id="' + this._baseId + '"' : '',
                    (sizeInfo.style ? 'style="' + sizeInfo.style + '"' : ''), ' class="', sizeInfo.className, '">'].join(''));
        }
888461
function generate() {
    var parsed = ensureConfig();
    if (!parsed.name)
        mu.log.error('cannot generate template using name of undefined.\n').write().exit();
    // Generate the template.
    mu.render(parsed.name, parsed.output, parsed.options);
}
446180
function (out) {
            if (this._cfgOk) {
                var cfg = this._cfg;
                var sectionCfg = {
                    id : this._sectionId,
                    type : cfg.type,
                    attributes : cfg.attributes
                };

                out.beginSection(sectionCfg);
                this._writePlaceholderContent(out);
                out.endSection();
            }
        }
308973
function( editor, output )
		{
			var env = CKEDITOR.env;

			var id = 'cke_' + this.id;
			var clickFn = CKEDITOR.tools.addFunction( function( $element )
				{
					var _ = this._;

					if ( _.state == CKEDITOR.TRISTATE_DISABLED )
						return;

					this.createPanel( editor );

					if ( _.on )
					{
						_.panel.hide();
						return;
					}

					this.commit();
					var value = this.getValue();
					if ( value )
						_.list.mark( value );
					else
						_.list.unmarkAll();

					_.panel.showBlock( this.id, new CKEDITOR.dom.element( $element ), 4 );
				},
				this );

			var instance = {
				id : id,
				combo : this,
				focus : function()
				{
					var element = CKEDITOR.document.getById( id ).getChild( 1 );
					element.focus();
				},
				clickFn : clickFn
			};

			function updateState()
			{
				var state = this.modes[ editor.mode ] ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED;
				this.setState( editor.readOnly && !this.readOnly ? CKEDITOR.TRISTATE_DISABLED : state );
				this.setValue( '' );
			}

			editor.on( 'mode', updateState, this );
			// If this combo is sensitive to readOnly state, update it accordingly.
			!this.readOnly && editor.on( 'readOnly', updateState, this);

			var keyDownFn = CKEDITOR.tools.addFunction( function( ev, element )
				{
					ev = new CKEDITOR.dom.event( ev );

					var keystroke = ev.getKeystroke();
					switch ( keystroke )
					{
						case 13 :	// ENTER
						case 32 :	// SPACE
						case 40 :	// ARROW-DOWN
							// Show panel
							CKEDITOR.tools.callFunction( clickFn, element );
							break;
						default :
							// Delegate the default behavior to toolbar button key handling.
							instance.onkey( instance,  keystroke );
					}

					// Avoid subsequent focus grab on editor document.
					ev.preventDefault();
				});

			var focusFn = CKEDITOR.tools.addFunction( function() { instance.onfocus && instance.onfocus(); } );

			// For clean up
			instance.keyDownFn = keyDownFn;

			output.push(
				'<span class="cke_rcombo" role="presentation">',
				'<span id=', id );

			if ( this.className )
				output.push( ' class="', this.className, ' cke_off"');

			output.push(
				' role="presentation">',
					'<span id="' + id+ '_label" class=cke_label>', this.label, '</span>',
					'<a hidefocus=true title="', this.title, '" tabindex="-1"',
						env.gecko && env.version >= 10900 && !env.hc ? '' : ' href="javascript:void(\'' + this.label + '\')"',
						' role="button" aria-labelledby="', id , '_label" aria-describedby="', id, '_text" aria-haspopup="true"' );

			// Some browsers don't cancel key events in the keydown but in the
			// keypress.
			// TODO: Check if really needed for Gecko+Mac.
			if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
			{
				output.push(
					' onkeypress="return false;"' );
			}

			// With Firefox, we need to force it to redraw, otherwise it
			// will remain in the focus state.
			if ( CKEDITOR.env.gecko )
			{
				output.push(
					' onblur="this.style.cssText = this.style.cssText;"' );
			}

			output.push(
					' onkeydown="CKEDITOR.tools.callFunction( ', keyDownFn, ', event, this );"' +
					' onfocus="return CKEDITOR.tools.callFunction(', focusFn, ', event);" ' +
					( CKEDITOR.env.ie ? 'onclick="return false;" onmouseup' : 'onclick' ) +		// #188
						'="CKEDITOR.tools.callFunction(', clickFn, ', this); return false;">' +
						'<span>' +
							'<span id="' + id + '_text" class="cke_text cke_inline_label">' + this.label + '</span>' +
						'</span>' +
						'<span class=cke_openbutton><span class=cke_icon>' + ( CKEDITOR.env.hc ? '&#9660;' : CKEDITOR.env.air ?  '&nbsp;' : '' ) + '</span></span>' +	// BLACK DOWN-POINTING TRIANGLE
					'</a>' +
				'</span>' +
				'</span>' );

			if ( this.onRender )
				this.onRender();

			return instance;
		}
1090248
function(markup) {
		markup = markup || "";
		return gui.Guide.suspend(function() {
			var doc = document.implementation.createHTMLDocument("");
			if (markup.toLowerCase().contains("<!doctype")) {
				try {
					doc.documentElement.innerHTML = markup;
				} catch (ie9exception) {
					doc = new ActiveXObject("htmlfile");
					doc.open();
					doc.write(markup);
					doc.close();
				}
			} else {
				doc.body.innerHTML = markup;
			}
			return doc;
		});
	}
1243416
void mapOut(String out, Object comp, String comp_out) {
        if (comp == ca.getComponent()) {
            throw new ComponentException("cannot connect 'Out' with itself for " + out);
        }
        ComponentAccess ac_dest = lookup(comp);
        FieldAccess destAccess = (FieldAccess) ac_dest.output(comp_out);
        FieldAccess srcAccess = (FieldAccess) ca.output(out);
        checkFA(destAccess, comp, comp_out);
        checkFA(srcAccess, ca.getComponent(), out);

        FieldContent data = srcAccess.getData();
        data.tagLeaf();
        data.tagOut();

        destAccess.setData(data);
        dataSet.add(data);

        if (log.isLoggable(Level.CONFIG)) {
            log.log(Level.CONFIG, String.format("@Out(%s) -> @Out(%s)", srcAccess, destAccess));
        }
//        ens.fireMapOut(srcAccess, destAccess);
    }
600582
function (out) {
            this._frame.writeMarkupEnd(out);
            var oSelf = this;
            ariaUtilsArray.forEach(this._iconsRight, function (value) {
                oSelf._writeIcon(value, out);
            });
        }
212561
function (out) {
            var cfg = this._cfg;
            var state = cfg.stateObject;
            var sizeInfo = {
                style : cfg.block ? 'display:block;' : '',
                className : "xSimpleFrame " + this._cssPrefix + "frame " + cfg.cssClass
            };

            var verticalAlignApplied = this._verticalAlignApplied;
            if (verticalAlignApplied) {
                sizeInfo.style += "line-height: " + this.innerHeight + "px;";
            }

            this._appendInnerSizeInfo(sizeInfo);
            if (!this._hasBorder(state.skipLeftBorder, cfg.iconsLeft)) {
                sizeInfo.style = sizeInfo.style
                        + 'border-left:0px;border-top-left-radius:0px;border-bottom-left-radius:0px;';
            }
            if (!this._hasBorder(state.skipRightBorder, cfg.iconsRight)) {
                sizeInfo.style = sizeInfo.style
                        + 'border-right:0px;border-top-right-radius:0px;border-bottom-right-radius:0px;';
            }

            out.write('<span ' + (sizeInfo.style ? 'style="' + sizeInfo.style + '"' : '') + 'class="'
                    + sizeInfo.className + '">');
            if (verticalAlignApplied) {
                var innerHeight = state.innerHeight;
                if (ariaUtilsType.isNumber(innerHeight)) {
                    innerHeight += "px";
                }

                // Vertical align is added in this block, as this property has no effect without the heights information
                out.write([
                    '<span style="display: inline-block;height:',
                    innerHeight,
                    ';line-height:',
                    innerHeight,
                    ';vertical-align:',
                    state.verticalAlign,
                    '">'
                ].join(""));
            }
        }
456851
function (out) {
            if (!this._cfgOk) {
                // configuration was incorrect, do not generate any markup in this case
                this.initWidget = Aria.empty;
                return out.write(this.INVALID_CONFIGURATION);
            }

            // Only interested in gestures when there's a particular configuration
            var delegateMarkup = "", cfg = this._cfg;
            if (cfg.tapToMove || (cfg.tapToToggle && this._isSwitch)) {
                this._delegateId = aria.utils.Delegate.add({
                    fn : this.delegate,
                    scope : this
                });
                delegateMarkup = aria.utils.Delegate.getMarkup(this._delegateId);
            }

            cfg.attributes = cfg.attributes || {};
            cfg.attributes.classList = cfg.attributes.classList || [];
            cfg.attributes.classList.push("touchLibSlider");

            out.write([
                    // Div containing the widget
                    '<div ', ariaUtilsHtml.buildAttributeList(cfg.attributes), '" style="width:', this._cfg.width,
                    'px;" ', delegateMarkup, '>',
                    // Rail, thumbs move over here
                    '<span class="touchContainer" style="width:', this._cfg.width, 'px;" id="', this._parentDomId,
                    '">',
                    // slider thumb
                    '<span id="', this._domId, '" class="sliderButton" style="left:0px;"></span>'].join(""));
            if (this._isSwitch) {
                out.write([
                        // For ON state Markup
                        '<div style="left:0px;width:', this._cfg.width, 'px;" class="touchLibSwitchOn" id="',
                        this._onSwitchId, '">', this._onLabel, '</div>',
                        // For OFF state Markup
                        '<div style="left:0px;width:0px;" class="touchLibSwitchOff" id="', this._offSwitchId, '">',
                        this._offLabel, '</div>'].join(""));
            } else {
                out.write(['<span class="sliderHighLight" id="', this._highlightDomId, '"></span>'].join(""));
            }
            out.write('</span></div>');
        }