text:
/** @fileoverview The "dialogui" plugin. */

CKEDITOR.plugins.add( 'dialogui' );

(function()
{
	var initPrivateObject = function( elementDefinition )
	{
		this._ || ( this._ = {} );
		this._['default'] = this._.initValue = elementDefinition['default'] || '';
		this._.required = elementDefinition[ 'required' ] || false;
		var args = [ this._ ];
		for ( var i = 1 ; i < arguments.length ; i++ )
			args.push( arguments[i] );
		args.push( true );
		CKEDITOR.tools.extend.apply( CKEDITOR.tools, args );
		return this._;
	},
	textBuilder =
	{
		build : function( dialog, elementDefinition, output )
		{
			return new CKEDITOR.ui.dialog.textInput( dialog, elementDefinition, output );
		}
	},
	commonBuilder =
	{
		build : function( dialog, elementDefinition, output )
		{
			return new CKEDITOR.ui.dialog[elementDefinition.type]( dialog, elementDefinition, output );
		}
	},
	containerBuilder =
	{
		build : function( dialog, elementDefinition, output )
		{
			var children = elementDefinition.children,
				child,
				childHtmlList = [],
				childObjList = [];
			for ( var i = 0 ; ( i < children.length && ( child = children[i] ) ) ; i++ )
			{
				var childHtml = [];
				childHtmlList.push( childHtml );
				childObjList.push( CKEDITOR.dialog._.uiElementBuilders[ child.type ].build( dialog, child, childHtml ) );
			}
			return new CKEDITOR.ui.dialog[ elementDefinition.type ]( dialog, childObjList, childHtmlList, output, elementDefinition );
		}
	},
	commonPrototype =
	{
		isChanged : function()
		{
			return this.getValue() != this.getInitValue();
		},

		reset : function( noChangeEvent )
		{
			this.setValue( this.getInitValue(), noChangeEvent );
		},

		setInitValue : function()
		{
			this._.initValue = this.getValue();
		},

		resetInitValue : function()
		{
			this._.initValue = this._['default'];
		},

		getInitValue : function()
		{
			return this._.initValue;
		}
	},
	commonEventProcessors = CKEDITOR.tools.extend( {}, CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors,
		{
			onChange : function( dialog, func )
			{
				if ( !this._.domOnChangeRegistered )
				{
					dialog.on( 'load', function()
						{
							this.getInputElement().on( 'change', function()
							{
								// Make sure 'onchange' doesn't get fired after dialog closed. (#5719)
								if ( !dialog.parts.dialog.isVisible() )
									return;

								this.fire( 'change', { value : this.getValue() } );
							}, this );
						}, this );
					this._.domOnChangeRegistered = true;
				}

				this.on( 'change', func );
			}
		}, true ),
	eventRegex = /^on([A-Z]\w+)/,
	cleanInnerDefinition = function( def )
	{
		// An inner UI element should not have the parent's type, title or events.
		for ( var i in def )
		{
			if ( eventRegex.test( i ) || i == 'title' || i == 'type' )
				delete def[i];
		}
		return def;
	};

	CKEDITOR.tools.extend( CKEDITOR.ui.dialog,
		/** @lends CKEDITOR.ui.dialog */
		{
			/**
			 * Base class for all dialog elements with a textual label on the left.
			 * @constructor
			 * @example
			 * @extends CKEDITOR.ui.dialog.uiElement
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
label (Required) The label string.

			 *
labelLayout (Optional) Put 'horizontal' here if the
			 * 	label element is to be layed out horizontally. Otherwise a vertical
			 * 	layout will be used.

			 *
widths (Optional) This applies only for horizontal
			 * 	layouts - an 2-element array of lengths to specify the widths of the
			 * 	label and the content element.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 * @param {Function} contentHtml
			 * A function returning the HTML code string to be added inside the content
			 * cell.
			 */
			labeledElement : function( dialog, elementDefinition, htmlList, contentHtml )
			{
				if ( arguments.length < 4 )
					return;

				var _ = initPrivateObject.call( this, elementDefinition );
				_.labelId = CKEDITOR.tools.getNextId() + '_label';
				var children = this._.children = [];
				/** @ignore */
				var innerHTML = function()
				{
					var html = [],
						requiredClass = elementDefinition.required ? ' cke_required' : '' ;
					if ( elementDefinition.labelLayout != 'horizontal' )
						html.push( '',
								elementDefinition.label,
								'',
								'
',
								contentHtml.call( this, dialog, elementDefinition ),
								'
' );
					else
					{
						var hboxDefinition = {
							type : 'hbox',
							widths : elementDefinition.widths,
							padding : 0,
							children :
							[
								{
									type : 'html',
									html : '' +
										   CKEDITOR.tools.htmlEncode( elementDefinition.label ) +
										''
								},
								{
									type : 'html',
									html : '' +
										contentHtml.call( this, dialog, elementDefinition ) +
										''
								}
							]
						};
						CKEDITOR.dialog._.uiElementBuilders.hbox.build( dialog, hboxDefinition, html );
					}
					return html.join( '' );
				};
				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'div', null, { role : 'presentation' }, innerHTML );
			},

			/**
			 * A text input with a label. This UI element class represents both the
			 * single-line text inputs and password inputs in dialog boxes.
			 * @constructor
			 * @example
			 * @extends CKEDITOR.ui.dialog.labeledElement
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
default (Optional) The default value.

			 *
validate (Optional) The validation function.

			 *
maxLength (Optional) The maximum length of text box
			 * 	contents.

			 *
size (Optional) The size of the text box. This is
			 * 	usually overridden by the size defined by the skin, however.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			textInput : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3 )
					return;

				initPrivateObject.call( this, elementDefinition );
				var domId = this._.inputId = CKEDITOR.tools.getNextId() + '_textInput',
					attributes = { 'class' : 'cke_dialog_ui_input_' + elementDefinition.type, id : domId, type : 'text' },
					i;

				// Set the validator, if any.
				if ( elementDefinition.validate )
					this.validate = elementDefinition.validate;

				// Set the max length and size.
				if ( elementDefinition.maxLength )
					attributes.maxlength = elementDefinition.maxLength;
				if ( elementDefinition.size )
					attributes.size = elementDefinition.size;

				if ( elementDefinition.inputStyle )
					attributes.style = elementDefinition.inputStyle;

				// If user presses Enter in a text box, it implies clicking OK for the dialog.
				var me = this, keyPressedOnMe = false;
				dialog.on( 'load', function()
					{
						me.getInputElement().on( 'keydown', function( evt )
							{
								if ( evt.data.getKeystroke() == 13 )
									keyPressedOnMe = true;
							} );

						// Lower the priority this 'keyup' since 'ok' will close the dialog.(#3749)
						me.getInputElement().on( 'keyup', function( evt )
							{
								if ( evt.data.getKeystroke() == 13 && keyPressedOnMe )
								{
									dialog.getButton( 'ok' ) && setTimeout( function ()
									{
										dialog.getButton( 'ok' ).click();
									}, 0 );
									keyPressedOnMe = false;
								}
							}, null, null, 1000 );
					} );

				/** @ignore */
				var innerHTML = function()
				{
					// IE BUG: Text input fields in IE at 100% would exceed a  or inline
					// container's width, so need to wrap it inside a
.
					var html = [ '
<input ' );

					attributes[ 'aria-labelledby' ] = this._.labelId;
					this._.required && ( attributes[ 'aria-required' ] = this._.required );
					for ( var i in attributes )
						html.push( i + '="' + attributes[i] + '" ' );
					html.push( ' />
' );
					return html.join( '' );
				};
				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
			},

			/**
			 * A text area with a label on the top or left.
			 * @constructor
			 * @extends CKEDITOR.ui.dialog.labeledElement
			 * @example
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
rows (Optional) The number of rows displayed.
			 * 	Defaults to 5 if not defined.

			 *
cols (Optional) The number of cols displayed.
			 * 	Defaults to 20 if not defined. Usually overridden by skins.

			 *
default (Optional) The default value.

			 *
validate (Optional) The validation function.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			textarea : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3 )
					return;

				initPrivateObject.call( this, elementDefinition );
				var me = this,
					domId = this._.inputId = CKEDITOR.tools.getNextId() + '_textarea',
					attributes = {};

				if ( elementDefinition.validate )
					this.validate = elementDefinition.validate;

				// Generates the essential attributes for the textarea tag.
				attributes.rows = elementDefinition.rows || 5;
				attributes.cols = elementDefinition.cols || 20;

				if ( typeof elementDefinition.inputStyle != 'undefined' )
					attributes.style = elementDefinition.inputStyle;

				/** @ignore */
				var innerHTML = function()
				{
					attributes[ 'aria-labelledby' ] = this._.labelId;
					this._.required && ( attributes[ 'aria-required' ] = this._.required );
					var html = [ '
<textarea class="cke_dialog_ui_input_textarea" id="', domId, '" ' ];
					for ( var i in attributes )
						html.push( i + '="' + CKEDITOR.tools.htmlEncode( attributes[i] ) + '" ' );
					html.push( '>', CKEDITOR.tools.htmlEncode( me._['default'] ), '</textarea>
' );
					return html.join( '' );
				};
				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
			},

			/**
			 * A single checkbox with a label on the right.
			 * @constructor
			 * @extends CKEDITOR.ui.dialog.uiElement
			 * @example
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
checked (Optional) Whether the checkbox is checked
			 * 	on instantiation. Defaults to false.

			 *
validate (Optional) The validation function.

			 *
label (Optional) The checkbox label.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			checkbox : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3 )
					return;

				var _ = initPrivateObject.call( this, elementDefinition, { 'default' : !!elementDefinition[ 'default' ] } );

				if ( elementDefinition.validate )
					this.validate = elementDefinition.validate;

				/** @ignore */
				var innerHTML = function()
				{
					var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition,
							{
								id : elementDefinition.id ? elementDefinition.id + '_checkbox' : CKEDITOR.tools.getNextId() + '_checkbox'
							}, true ),
						html = [];

					var labelId = CKEDITOR.tools.getNextId() + '_label';
					var attributes = { 'class' : 'cke_dialog_ui_checkbox_input', type : 'checkbox', 'aria-labelledby' : labelId };
					cleanInnerDefinition( myDefinition );
					if ( elementDefinition[ 'default' ] )
						attributes.checked = 'checked';

					if ( typeof myDefinition.inputStyle != 'undefined' )
						myDefinition.style = myDefinition.inputStyle;

					_.checkbox = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'input', null, attributes );
					html.push( ' ',
							CKEDITOR.tools.htmlEncode( elementDefinition.label ),
							'' );
					return html.join( '' );
				};

				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'span', null, null, innerHTML );
			},

			/**
			 * A group of radio buttons.
			 * @constructor
			 * @example
			 * @extends CKEDITOR.ui.dialog.labeledElement
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
default (Required) The default value.

			 *
validate (Optional) The validation function.

			 *
items (Required) An array of options. Each option
			 * 	is a 1- or 2-item array of format [ 'Description', 'Value' ]. If 'Value'
			 * 	is missing, then the value would be assumed to be the same as the
			 * 	description.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			radio : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3)
					return;

				initPrivateObject.call( this, elementDefinition );
				if ( !this._['default'] )
					this._['default'] = this._.initValue = elementDefinition.items[0][1];
				if ( elementDefinition.validate )
					this.validate = elementDefinition.valdiate;
				var children = [], me = this;

				/** @ignore */
				var innerHTML = function()
				{
					var inputHtmlList = [], html = [],
						commonAttributes = { 'class' : 'cke_dialog_ui_radio_item', 'aria-labelledby' : this._.labelId },
						commonName = elementDefinition.id ? elementDefinition.id + '_radio' : CKEDITOR.tools.getNextId() + '_radio';
					for ( var i = 0 ; i < elementDefinition.items.length ; i++ )
					{
						var item = elementDefinition.items[i],
							title = item[2] !== undefined ? item[2] : item[0],
							value = item[1] !== undefined ? item[1] : item[0],
							inputId = CKEDITOR.tools.getNextId() + '_radio_input',
							labelId = inputId + '_label',
							inputDefinition = CKEDITOR.tools.extend( {}, elementDefinition,
									{
										id : inputId,
										title : null,
										type : null
									}, true ),
							labelDefinition = CKEDITOR.tools.extend( {}, inputDefinition,
									{
										title : title
									}, true ),
							inputAttributes =
							{
								type : 'radio',
								'class' : 'cke_dialog_ui_radio_input',
								name : commonName,
								value : value,
								'aria-labelledby' : labelId
							},
							inputHtml = [];
						if ( me._['default'] == value )
							inputAttributes.checked = 'checked';
						cleanInnerDefinition( inputDefinition );
						cleanInnerDefinition( labelDefinition );

						if ( typeof inputDefinition.inputStyle != 'undefined' )
							inputDefinition.style = inputDefinition.inputStyle;

						children.push( new CKEDITOR.ui.dialog.uiElement( dialog, inputDefinition, inputHtml, 'input', null, inputAttributes ) );
						inputHtml.push( ' ' );
						new CKEDITOR.ui.dialog.uiElement( dialog, labelDefinition, inputHtml, 'label', null, { id : labelId, 'for' : inputAttributes.id },
							   item[0] );
						inputHtmlList.push( inputHtml.join( '' ) );
					}
					new CKEDITOR.ui.dialog.hbox( dialog, children, inputHtmlList, html );
					return html.join( '' );
				};

				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
				this._.children = children;
			},

			/**
			 * A button with a label inside.
			 * @constructor
			 * @example
			 * @extends CKEDITOR.ui.dialog.uiElement
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
label (Required) The button label.

			 *
disabled (Optional) Set to true if you want the
			 * 	button to appear in disabled state.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			button : function( dialog, elementDefinition, htmlList )
			{
				if ( !arguments.length )
					return;

				if ( typeof elementDefinition == 'function' )
					elementDefinition = elementDefinition( dialog.getParentEditor() );

				initPrivateObject.call( this, elementDefinition, { disabled : elementDefinition.disabled || false } );

				// Add OnClick event to this input.
				CKEDITOR.event.implementOn( this );

				var me = this;

				// Register an event handler for processing button clicks.
				dialog.on( 'load', function( eventInfo )
					{
						var element = this.getElement();

						(function()
						{
							element.on( 'click', function( evt )
								{
									me.fire( 'click', { dialog : me.getDialog() } );
									evt.data.preventDefault();
								} );

							element.on( 'keydown', function( evt )
								{
									if ( evt.data.getKeystroke() in { 32:1 } )
									{
										me.click();
										evt.data.preventDefault();
									}
								} );
						})();

						element.unselectable();
					}, this );

				var outerDefinition = CKEDITOR.tools.extend( {}, elementDefinition );
				delete outerDefinition.style;

				var labelId = CKEDITOR.tools.getNextId() + '_label';
				CKEDITOR.ui.dialog.uiElement.call(
					this,
					dialog,
					outerDefinition,
					htmlList,
					'a',
					null,
					{
						style : elementDefinition.style,
						href : 'javascript:void(0)',
						title : elementDefinition.label,
						hidefocus : 'true',
						'class' : elementDefinition['class'],
						role : 'button',
						'aria-labelledby' : labelId
					},
					'' +
						CKEDITOR.tools.htmlEncode( elementDefinition.label ) +
					'' );
			},

			/**
			 * A select box.
			 * @extends CKEDITOR.ui.dialog.uiElement
			 * @example
			 * @constructor
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
default (Required) The default value.

			 *
validate (Optional) The validation function.

			 *
items (Required) An array of options. Each option
			 * 	is a 1- or 2-item array of format [ 'Description', 'Value' ]. If 'Value'
			 * 	is missing, then the value would be assumed to be the same as the
			 * 	description.

			 *
multiple (Optional) Set this to true if you'd like
			 * 	to have a multiple-choice select box.

			 *
size (Optional) The number of items to display in
			 * 	the select box.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			select : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3 )
					return;

				var _ = initPrivateObject.call( this, elementDefinition );

				if ( elementDefinition.validate )
					this.validate = elementDefinition.validate;

				_.inputId = CKEDITOR.tools.getNextId() + '_select';
				/** @ignore */
				var innerHTML = function()
				{
					var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition,
							{
								id : elementDefinition.id ? elementDefinition.id + '_select' : CKEDITOR.tools.getNextId() + '_select'
							}, true ),
						html = [],
						innerHTML = [],
						attributes = { 'id' : _.inputId, 'class' : 'cke_dialog_ui_input_select', 'aria-labelledby' : this._.labelId };

					// Add multiple and size attributes from element definition.
					if ( elementDefinition.size != undefined )
						attributes.size = elementDefinition.size;
					if ( elementDefinition.multiple != undefined )
						attributes.multiple = elementDefinition.multiple;

					cleanInnerDefinition( myDefinition );
					for ( var i = 0, item ; i < elementDefinition.items.length && ( item = elementDefinition.items[i] ) ; i++ )
					{
						innerHTML.push( '<option value="',
							CKEDITOR.tools.htmlEncode( item[1] !== undefined ? item[1] : item[0] ).replace( /"/g, '"' ), '" /> ',
							CKEDITOR.tools.htmlEncode( item[0] ) );
					}

					if ( typeof myDefinition.inputStyle != 'undefined' )
						myDefinition.style = myDefinition.inputStyle;

					_.select = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'select', null, attributes, innerHTML.join( '' ) );
					return html.join( '' );
				};

				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
			},

			/**
			 * A file upload input.
			 * @extends CKEDITOR.ui.dialog.labeledElement
			 * @example
			 * @constructor
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
validate (Optional) The validation function.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			file : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3 )
					return;

				if ( elementDefinition['default'] === undefined )
					elementDefinition['default'] = '';

				var _ = CKEDITOR.tools.extend( initPrivateObject.call( this, elementDefinition ), { definition : elementDefinition, buttons : [] } );

				if ( elementDefinition.validate )
					this.validate = elementDefinition.validate;

				/** @ignore */
				var innerHTML = function()
				{
					_.frameId = CKEDITOR.tools.getNextId() + '_fileInput';

					// Support for custom document.domain in IE.
					var isCustomDomain = CKEDITOR.env.isCustomDomain();

					var html = [
						'' +
						'' );

					return html.join( '' );
				};

				// IE BUG: Parent container does not resize to contain the iframe automatically.
				dialog.on( 'load', function()
					{
						var iframe = CKEDITOR.document.getById( _.frameId ),
							contentDiv = iframe.getParent();
						contentDiv.addClass( 'cke_dialog_ui_input_file' );
					} );

				CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
			},

			/**
			 * A button for submitting the file in a file upload input.
			 * @extends CKEDITOR.ui.dialog.button
			 * @example
			 * @constructor
			 * @param {CKEDITOR.dialog} dialog
			 * Parent dialog object.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
for (Required) The file input's page and element Id
			 * 	to associate to, in a 2-item array format: [ 'page_id', 'element_id' ].
			 *

			 *
validate (Optional) The validation function.

			 *

			 * @param {Array} htmlList
			 * List of HTML code to output to.
			 */
			fileButton : function( dialog, elementDefinition, htmlList )
			{
				if ( arguments.length < 3 )
					return;

				var _ = initPrivateObject.call( this, elementDefinition ),
					me = this;

				if ( elementDefinition.validate )
					this.validate = elementDefinition.validate;

				var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition );
				var onClick = myDefinition.onClick;
				myDefinition.className = ( myDefinition.className ? myDefinition.className + ' ' : '' ) + 'cke_dialog_ui_button';
				myDefinition.onClick = function( evt )
				{
					var target = elementDefinition[ 'for' ];		// [ pageId, elementId ]
					if ( !onClick || onClick.call( this, evt ) !== false )
					{
						dialog.getContentElement( target[0], target[1] ).submit();
						this.disable();
					}
				};

				dialog.on( 'load', function()
						{
							dialog.getContentElement( elementDefinition[ 'for' ][0], elementDefinition[ 'for' ][1] )._.buttons.push( me );
						} );

				CKEDITOR.ui.dialog.button.call( this, dialog, myDefinition, htmlList );
			},

			html : (function()
			{
				var myHtmlRe = /^\s*<[\w:]+\s+([^>]*)?>/,
					theirHtmlRe = /^(\s*<[\w:]+(?:\s+[^>]*)?)((?:.|\r|\n)+)$/,
					emptyTagRe = /\/$/;
				/**
				 * A dialog element made from raw HTML code.
				 * @extends CKEDITOR.ui.dialog.uiElement
				 * @name CKEDITOR.ui.dialog.html
				 * @param {CKEDITOR.dialog} dialog Parent dialog object.
				 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition Element definition.
				 * Accepted fields:
				 *

				 *
html (Required) HTML code of this element.

				 *

				 * @param {Array} htmlList List of HTML code to be added to the dialog's content area.
				 * @example
				 * @constructor
				 */
				return function( dialog, elementDefinition, htmlList )
				{
					if ( arguments.length < 3 )
						return;

					var myHtmlList = [],
						myHtml,
						theirHtml = elementDefinition.html,
						myMatch, theirMatch;

					// If the HTML input doesn't contain any tags at the beginning, add a  tag around it.
					if ( theirHtml.charAt( 0 ) != '<' )
						theirHtml = '' + theirHtml + '';

					// Look for focus function in definition.
					var focus = elementDefinition.focus;
					if ( focus )
					{
						var oldFocus = this.focus;
						this.focus = function()
						{
							oldFocus.call( this );
							typeof focus == 'function' && focus.call( this );
							this.fire( 'focus' );
						};
						if ( elementDefinition.isFocusable )
						{
							var oldIsFocusable = this.isFocusable;
							this.isFocusable = oldIsFocusable;
						}
						this.keyboardFocusable = true;
					}

					CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, myHtmlList, 'span', null, null, '' );

					// Append the attributes created by the uiElement call to the real HTML.
					myHtml = myHtmlList.join( '' );
					myMatch = myHtml.match( myHtmlRe );
					theirMatch = theirHtml.match( theirHtmlRe ) || [ '', '', '' ];

					if ( emptyTagRe.test( theirMatch[1] ) )
					{
						theirMatch[1] = theirMatch[1].slice( 0, -1 );
						theirMatch[2] = '/' + theirMatch[2];
					}

					htmlList.push( [ theirMatch[1], ' ', myMatch[1] || '', theirMatch[2] ].join( '' ) );
				};
			})(),

			/**
			 * Form fieldset for grouping dialog UI elements.
			 * @constructor
			 * @extends CKEDITOR.ui.dialog.uiElement
			 * @param {CKEDITOR.dialog} dialog Parent dialog object.
			 * @param {Array} childObjList
			 * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this
			 * container.
			 * @param {Array} childHtmlList
			 * Array of HTML code that correspond to the HTML output of all the
			 * objects in childObjList.
			 * @param {Array} htmlList
			 * Array of HTML code that this element will output to.
			 * @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
			 * The element definition. Accepted fields:
			 *

			 *
label (Optional) The legend of the this fieldset.

			 *
children (Required) An array of dialog field definitions which will be grouped inside this fieldset.

			 *

			 */
			fieldset : function( dialog, childObjList, childHtmlList, htmlList, elementDefinition )
			{
				var legendLabel = elementDefinition.label;
				/** @ignore */
				var innerHTML = function()
				{
					var html = [];
					legendLabel && html.push( '<legend>' + legendLabel + '</legend>' );
					for ( var i = 0; i < childHtmlList.length; i++ )
						html.push( childHtmlList[ i ] );
					return html.join( '' );
				};

				this._ = { children : childObjList };
				CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'fieldset', null, null, innerHTML );
			}

		}, true );

	CKEDITOR.ui.dialog.html.prototype = new CKEDITOR.ui.dialog.uiElement;

	CKEDITOR.ui.dialog.labeledElement.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
			/** @lends CKEDITOR.ui.dialog.labeledElement.prototype */
			{
				/**
				 * Sets the label text of the element.
				 * @param {String} label The new label text.
				 * @returns {CKEDITOR.ui.dialog.labeledElement} The current labeled element.
				 * @example
				 */
				setLabel : function( label )
				{
					var node = CKEDITOR.document.getById( this._.labelId );
					if ( node.getChildCount() < 1 )
						( new CKEDITOR.dom.text( label, CKEDITOR.document ) ).appendTo( node );
					else
						node.getChild( 0 ).$.nodeValue = label;
					return this;
				},

				/**
				 * Retrieves the current label text of the elment.
				 * @returns {String} The current label text.
				 * @example
				 */
				getLabel : function()
				{
					var node = CKEDITOR.document.getById( this._.labelId );
					if ( !node || node.getChildCount() < 1 )
						return '';
					else
						return node.getChild( 0 ).getText();
				},

				/**
				 * Defines the onChange event for UI element definitions.
				 * @field
				 * @type Object
				 * @example
				 */
				eventProcessors : commonEventProcessors
			}, true );

	CKEDITOR.ui.dialog.button.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
			/** @lends CKEDITOR.ui.dialog.button.prototype */
			{
				/**
				 * Simulates a click to the button.
				 * @example
				 * @returns {Object} Return value of the 'click' event.
				 */
				click : function()
				{
					if ( !this._.disabled )
						return this.fire( 'click', { dialog : this._.dialog } );
					this.getElement().$.blur();
					return false;
				},

				/**
				 * Enables the button.
				 * @example
				 */
				enable : function()
				{
					this._.disabled = false;
					var element = this.getElement();
					element && element.removeClass( 'cke_disabled' );
				},

				/**
				 * Disables the button.
				 * @example
				 */
				disable : function()
				{
					this._.disabled = true;
					this.getElement().addClass( 'cke_disabled' );
				},

				isVisible : function()
				{
					return this.getElement().getFirst().isVisible();
				},

				isEnabled : function()
				{
					return !this._.disabled;
				},

				/**
				 * Defines the onChange event and onClick for button element definitions.
				 * @field
				 * @type Object
				 * @example
				 */
				eventProcessors : CKEDITOR.tools.extend( {}, CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors,
					{
						/** @ignore */
						onClick : function( dialog, func )
						{
							this.on( 'click', func );
						}
					}, true ),

				/**
				 * Handler for the element's access key up event. Simulates a click to
				 * the button.
				 * @example
				 */
				accessKeyUp : function()
				{
					this.click();
				},

				/**
				 * Handler for the element's access key down event. Simulates a mouse
				 * down to the button.
				 * @example
				 */
				accessKeyDown : function()
				{
					this.focus();
				},

				keyboardFocusable : true
			}, true );

	CKEDITOR.ui.dialog.textInput.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement,
			/** @lends CKEDITOR.ui.dialog.textInput.prototype */
			{
				/**
				 * Gets the text input DOM element under this UI object.
				 * @example
				 * @returns {CKEDITOR.dom.element} The DOM element of the text input.
				 */
				getInputElement : function()
				{
					return CKEDITOR.document.getById( this._.inputId );
				},

				/**
				 * Puts focus into the text input.
				 * @example
				 */
				focus : function()
				{
					var me = this.selectParentTab();

					// GECKO BUG: setTimeout() is needed to workaround invisible selections.
					setTimeout( function()
						{
							var element = me.getInputElement();
							element && element.$.focus();
						}, 0 );
				},

				/**
				 * Selects all the text in the text input.
				 * @example
				 */
				select : function()
				{
					var me = this.selectParentTab();

					// GECKO BUG: setTimeout() is needed to workaround invisible selections.
					setTimeout( function()
						{
							var e = me.getInputElement();
							if ( e )
							{
								e.$.focus();
								e.$.select();
							}
						}, 0 );
				},

				/**
				 * Handler for the text input's access key up event. Makes a select()
				 * call to the text input.
				 * @example
				 */
				accessKeyUp : function()
				{
					this.select();
				},

				/**
				 * Sets the value of this text input object.
				 * @param {Object} value The new value.
				 * @returns {CKEDITOR.ui.dialog.textInput} The current UI element.
				 * @example
				 * uiElement.setValue( 'Blamo' );
				 */
				setValue : function( value )
				{
					!value && ( value = '' );
					return CKEDITOR.ui.dialog.uiElement.prototype.setValue.apply( this, arguments );
				},

				keyboardFocusable : true
			}, commonPrototype, true );

	CKEDITOR.ui.dialog.textarea.prototype = new CKEDITOR.ui.dialog.textInput();

	CKEDITOR.ui.dialog.select.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement,
			/** @lends CKEDITOR.ui.dialog.select.prototype */
			{
				/**
				 * Gets the DOM element of the select box.
				 * @returns {CKEDITOR.dom.element} The <select> element of this UI
				 * element.
				 * @example
				 */
				getInputElement : function()
				{
					return this._.select.getElement();
				},

				/**
				 * Adds an option to the select box.
				 * @param {String} label Option label.
				 * @param {String} value (Optional) Option value, if not defined it'll be
				 * assumed to be the same as the label.
				 * @param {Number} index (Optional) Position of the option to be inserted
				 * to. If not defined the new option will be inserted to the end of list.
				 * @example
				 * @returns {CKEDITOR.ui.dialog.select} The current select UI element.
				 */
				add : function( label, value, index )
				{
					var option = new CKEDITOR.dom.element( 'option', this.getDialog().getParentEditor().document ),
						selectElement = this.getInputElement().$;
					option.$.text = label;
					option.$.value = ( value === undefined || value === null ) ? label : value;
					if ( index === undefined || index === null )
					{
						if ( CKEDITOR.env.ie )
							selectElement.add( option.$ );
						else
							selectElement.add( option.$, null );
					}
					else
						selectElement.add( option.$, index );
					return this;
				},

				/**
				 * Removes an option from the selection list.
				 * @param {Number} index Index of the option to be removed.
				 * @example
				 * @returns {CKEDITOR.ui.dialog.select} The current select UI element.
				 */
				remove : function( index )
				{
					var selectElement = this.getInputElement().$;
					selectElement.remove( index );
					return this;
				},

				/**
				 * Clears all options out of the selection list.
				 * @returns {CKEDITOR.ui.dialog.select} The current select UI element.
				 */
				clear : function()
				{
					var selectElement = this.getInputElement().$;
					while ( selectElement.length > 0 )
						selectElement.remove( 0 );
					return this;
				},

				keyboardFocusable : true
			}, commonPrototype, true );

	CKEDITOR.ui.dialog.checkbox.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
			/** @lends CKEDITOR.ui.dialog.checkbox.prototype */
			{
				/**
				 * Gets the checkbox DOM element.
				 * @example
				 * @returns {CKEDITOR.dom.element} The DOM element of the checkbox.
				 */
				getInputElement : function()
				{
					return this._.checkbox.getElement();
				},

				/**
				 * Sets the state of the checkbox.
				 * @example
				 * @param {Boolean} true to tick the checkbox, false to untick it.
				 * @param {Boolean} noChangeEvent Internal commit, to supress 'change' event on this element.
				 */
				setValue : function( checked, noChangeEvent )
				{
					this.getInputElement().$.checked = checked;
					!noChangeEvent && this.fire( 'change', { value : checked } );
				},

				/**
				 * Gets the state of the checkbox.
				 * @example
				 * @returns {Boolean} true means the checkbox is ticked, false means it's not ticked.
				 */
				getValue : function()
				{
					return this.getInputElement().$.checked;
				},

				/**
				 * Handler for the access key up event. Toggles the checkbox.
				 * @example
				 */
				accessKeyUp : function()
				{
					this.setValue( !this.getValue() );
				},

				/**
				 * Defines the onChange event for UI element definitions.
				 * @field
				 * @type Object
				 * @example
				 */
				eventProcessors :
				{
					onChange : function( dialog, func )
					{
						if ( !CKEDITOR.env.ie )
							return commonEventProcessors.onChange.apply( this, arguments );
						else
						{
							dialog.on( 'load', function()
								{
									var element = this._.checkbox.getElement();
									element.on( 'propertychange', function( evt )
										{
											evt = evt.data.$;
											if ( evt.propertyName == 'checked' )
												this.fire( 'change', { value : element.$.checked } );
										}, this );
								}, this );
							this.on( 'change', func );
						}
						return null;
					}
				},

				keyboardFocusable : true
			}, commonPrototype, true );

	CKEDITOR.ui.dialog.radio.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
			/** @lends CKEDITOR.ui.dialog.radio.prototype */
			{
				/**
				 * Checks one of the radio buttons in this button group.
				 * @example
				 * @param {String} value The value of the button to be chcked.
				 * @param {Boolean} noChangeEvent Internal commit, to supress 'change' event on this element.
				 */
				setValue : function( value, noChangeEvent )
				{
					var children = this._.children,
						item;
					for ( var i = 0 ; ( i < children.length ) && ( item = children[i] ) ; i++ )
						item.getElement().$.checked = ( item.getValue() == value );
					!noChangeEvent && this.fire( 'change', { value : value } );
				},

				/**
				 * Gets the value of the currently checked radio button.
				 * @example
				 * @returns {String} The currently checked button's value.
				 */
				getValue : function()
				{
					var children = this._.children;
					for ( var i = 0 ; i < children.length ; i++ )
					{
						if ( children[i].getElement().$.checked )
							return children[i].getValue();
					}
					return null;
				},

				/**
				 * Handler for the access key up event. Focuses the currently
				 * selected radio button, or the first radio button if none is
				 * selected.
				 * @example
				 */
				accessKeyUp : function()
				{
					var children = this._.children, i;
					for ( i = 0 ; i < children.length ; i++ )
					{
						if ( children[i].getElement().$.checked )
						{
							children[i].getElement().focus();
							return;
						}
					}
					children[0].getElement().focus();
				},

				/**
				 * Defines the onChange event for UI element definitions.
				 * @field
				 * @type Object
				 * @example
				 */
				eventProcessors :
				{
					onChange : function( dialog, func )
					{
						if ( !CKEDITOR.env.ie )
							return commonEventProcessors.onChange.apply( this, arguments );
						else
						{
							dialog.on( 'load', function()
								{
									var children = this._.children, me = this;
									for ( var i = 0 ; i < children.length ; i++ )
									{
										var element = children[i].getElement();
										element.on( 'propertychange', function( evt )
											{
												evt = evt.data.$;
												if ( evt.propertyName == 'checked' && this.$.checked )
													me.fire( 'change', { value : this.getAttribute( 'value' ) } );
											} );
									}
								}, this );
							this.on( 'change', func );
						}
						return null;
					}
				},

				keyboardFocusable : true
			}, commonPrototype, true );

	CKEDITOR.ui.dialog.file.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement,
			commonPrototype,
			/** @lends CKEDITOR.ui.dialog.file.prototype */
			{
				/**
				 * Gets the <input> element of this file input.
				 * @returns {CKEDITOR.dom.element} The file input element.
				 * @example
				 */
				getInputElement : function()
				{
					var frameDocument = CKEDITOR.document.getById( this._.frameId ).getFrameDocument();
					return frameDocument.$.forms.length > 0 ?
						new CKEDITOR.dom.element( frameDocument.$.forms[0].elements[0] ) :
						this.getElement();
				},

				/**
				 * Uploads the file in the file input.
				 * @returns {CKEDITOR.ui.dialog.file} This object.
				 * @example
				 */
				submit : function()
				{
					this.getInputElement().getParent().$.submit();
					return this;
				},

				/**
				 * Get the action assigned to the form.
				 * @returns {String} The value of the action.
				 * @example
				 */
				getAction : function()
				{
					return this.getInputElement().getParent().$.action;
				},

				/**
				 * The events must be applied on the inner input element, and
				 * that must be done when the iframe & form has been loaded
				 */
				registerEvents : function( definition )
				{
					var regex = /^on([A-Z]\w+)/,
						match;

					var registerDomEvent = function( uiElement, dialog, eventName, func )
					{
						uiElement.on( 'formLoaded', function()
						{
							uiElement.getInputElement().on( eventName, func, uiElement );
						});
					};

					for ( var i in definition )
					{
						if ( !( match = i.match( regex ) ) )
							continue;

						if ( this.eventProcessors[i] )
							this.eventProcessors[i].call( this, this._.dialog, definition[i] );
						else
							registerDomEvent( this, this._.dialog, match[1].toLowerCase(), definition[i] );
					}

					return this;
				},

				/**
				 * Redraws the file input and resets the file path in the file input.
				 * The redraw logic is necessary because non-IE browsers tend to clear
				 * the <iframe> containing the file input after closing the dialog.
				 * @example
				 */
				reset : function()
				{
					var _ = this._,
						frameElement = CKEDITOR.document.getById( _.frameId ),
						frameDocument = frameElement.getFrameDocument(),
						elementDefinition = _.definition,
						buttons = _.buttons,
						callNumber = this.formLoadedNumber,
						unloadNumber = this.formUnloadNumber,
						langDir = _.dialog._.editor.lang.dir,
						langCode = _.dialog._.editor.langCode;

					// The callback function for the iframe, but we must call tools.addFunction only once
					// so we store the function number in this.formLoadedNumber
					if ( !callNumber )
					{
						callNumber = this.formLoadedNumber = CKEDITOR.tools.addFunction(
							function()
							{
								// Now we can apply the events to the input type=file
								this.fire( 'formLoaded' ) ;
							}, this ) ;

						// Remove listeners attached to the content of the iframe (the file input)
						unloadNumber = this.formUnloadNumber = CKEDITOR.tools.addFunction(
							function()
							{
								this.getInputElement().clearCustomData();
							}, this ) ;

						this.getDialog()._.editor.on( 'destroy', function()
								{
									CKEDITOR.tools.removeFunction( callNumber );
									CKEDITOR.tools.removeFunction( unloadNumber );
								} );
					}

					function generateFormField()
					{
						frameDocument.$.open();

						// Support for custom document.domain in IE.
						if ( CKEDITOR.env.isCustomDomain() )
							frameDocument.$.domain = document.domain;

						var size = '';
						if ( elementDefinition.size )
							size = elementDefinition.size - ( CKEDITOR.env.ie  ? 7 : 0 );	// "Browse" button is bigger in IE.

						frameDocument.$.write( [ '<title></title>',
								'<form enctype="multipart/form-data" method="POST" dir="' + langDir + '" lang="' + langCode + '" action="',
								CKEDITOR.tools.htmlEncode( elementDefinition.action ),
								'">',
								'<input type="file" name="',
								CKEDITOR.tools.htmlEncode( elementDefinition.id || 'cke_upload' ),
								'" size="',
								CKEDITOR.tools.htmlEncode( size > 0 ? size : "" ),
								'" />',
								'</form>',
								'',
								'' ].join( '' ) );

						frameDocument.$.close();

						for ( var i = 0 ; i < buttons.length ; i++ )
							buttons[i].enable();
					}

					// #3465: Wait for the browser to finish rendering the dialog first.
					if ( CKEDITOR.env.gecko )
						setTimeout( generateFormField, 500 );
					else
						generateFormField();
				},

				getValue : function()
				{
					return this.getInputElement().$.value || '';
				},

				/***
				 * The default value of input type="file" is an empty string, but during initialization
				 * of this UI element, the iframe still isn't ready so it can't be read from that object
				 * Setting it manually prevents later issues about the current value ("") being different
				 * of the initial value (undefined as it asked for .value of a div)
				 */
				setInitValue : function()
				{
					this._.initValue = '';
				},

				/**
				 * Defines the onChange event for UI element definitions.
				 * @field
				 * @type Object
				 * @example
				 */
				eventProcessors :
				{
					onChange : function( dialog, func )
					{
						// If this method is called several times (I'm not sure about how this can happen but the default
						// onChange processor includes this protection)
						// In order to reapply to the new element, the property is deleted at the beggining of the registerEvents method
						if ( !this._.domOnChangeRegistered )
						{
							// By listening for the formLoaded event, this handler will get reapplied when a new
							// form is created
							this.on( 'formLoaded', function()
							{
								this.getInputElement().on( 'change', function(){ this.fire( 'change', { value : this.getValue() } ); }, this );
							}, this );
							this._.domOnChangeRegistered = true;
						}

						this.on( 'change', func );
					}
				},

				keyboardFocusable : true
			}, true );

	CKEDITOR.ui.dialog.fileButton.prototype = new CKEDITOR.ui.dialog.button;

	CKEDITOR.ui.dialog.fieldset.prototype = CKEDITOR.tools.clone( CKEDITOR.ui.dialog.hbox.prototype );

	CKEDITOR.dialog.addUIElement( 'text', textBuilder );
	CKEDITOR.dialog.addUIElement( 'password', textBuilder );
	CKEDITOR.dialog.addUIElement( 'textarea', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'checkbox', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'radio', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'button', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'select', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'file', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'fileButton', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'html', commonBuilder );
	CKEDITOR.dialog.addUIElement( 'fieldset', containerBuilder );
})();

/**
 * Fired when the value of the uiElement is changed
 * @name CKEDITOR.ui.dialog.uiElement#change
 * @event
 */

/**
 * Fired when the inner frame created by the element is ready.
 * Each time the button is used or the dialog is loaded a new
 * form might be created.
 * @name CKEDITOR.ui.dialog.fileButton#formLoaded
 * @event
 */


text:
/*************************************************************************/
/*  link_button.cpp                                                      */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include "link_button.h"

void LinkButton::set_text(const String &p_text) {

	text = p_text;
	update();
	minimum_size_changed();
}

String LinkButton::get_text() const {
	return text;
}

void LinkButton::set_underline_mode(UnderlineMode p_underline_mode) {

	underline_mode = p_underline_mode;
	update();
}

LinkButton::UnderlineMode LinkButton::get_underline_mode() const {

	return underline_mode;
}

Size2 LinkButton::get_minimum_size() const {

	return get_font("font")->get_string_size(text);
}

void LinkButton::_notification(int p_what) {

	switch (p_what) {

		case NOTIFICATION_DRAW: {

			RID ci = get_canvas_item();
			Size2 size = get_size();
			Color color;
			bool do_underline = false;

			switch (get_draw_mode()) {

				case DRAW_NORMAL: {

					color = get_color("font_color");
					do_underline = underline_mode == UNDERLINE_MODE_ALWAYS;
				} break;
				case DRAW_PRESSED: {

					if (has_color("font_color_pressed"))
						color = get_color("font_color_pressed");
					else
						color = get_color("font_color");

					do_underline = underline_mode != UNDERLINE_MODE_NEVER;

				} break;
				case DRAW_HOVER: {

					color = get_color("font_color_hover");
					do_underline = underline_mode != UNDERLINE_MODE_NEVER;

				} break;
				case DRAW_HOVER_PRESSED: break; // Not used in this class
				case DRAW_DISABLED: {

					color = get_color("font_color_disabled");
					do_underline = underline_mode == UNDERLINE_MODE_ALWAYS;

				} break;
			}

			if (has_focus()) {

				Ref<StyleBox> style = get_stylebox("focus");
				style->draw(ci, Rect2(Point2(), size));
			}

			Ref<Font> font = get_font("font");

			draw_string(font, Vector2(0, font->get_ascent()), text, color);

			if (do_underline) {
				int underline_spacing = get_constant("underline_spacing");
				int width = font->get_string_size(text).width;
				int y = font->get_ascent() + underline_spacing;

				draw_line(Vector2(0, y), Vector2(width, y), color);
			}

		} break;
	}
}

void LinkButton::_bind_methods() {

	ClassDB::bind_method(D_METHOD("set_text", "text"), &LinkButton::set_text);
	ClassDB::bind_method(D_METHOD("get_text"), &LinkButton::get_text);

	ClassDB::bind_method(D_METHOD("set_underline_mode", "underline_mode"), &LinkButton::set_underline_mode);
	ClassDB::bind_method(D_METHOD("get_underline_mode"), &LinkButton::get_underline_mode);

	BIND_ENUM_CONSTANT(UNDERLINE_MODE_ALWAYS);
	BIND_ENUM_CONSTANT(UNDERLINE_MODE_ON_HOVER);
	BIND_ENUM_CONSTANT(UNDERLINE_MODE_NEVER);

	ADD_PROPERTYNZ(PropertyInfo(Variant::STRING, "text"), "set_text", "get_text");
	ADD_PROPERTYNZ(PropertyInfo(Variant::INT, "underline", PROPERTY_HINT_ENUM, "Always,On Hover,Never"), "set_underline_mode", "get_underline_mode");
}

LinkButton::LinkButton() {
	underline_mode = UNDERLINE_MODE_ALWAYS;
	set_enabled_focus_mode(FOCUS_NONE);
	set_default_cursor_shape(CURSOR_POINTING_HAND);
}

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using MovieCatalog.DAL;
using MovieCatalog.BLL;
using System.Data;

using System.Data.Entity;
using System.Data.Entity.Core;
using System.Data.Entity.Core.Objects;

using System.Data.SqlClient;
using System.IO;

using Excel = Microsoft.Office.Interop.Excel;
using ExcelAutoFormat = Microsoft.Office.Interop.Excel.XlRangeAutoFormat;

namespace MovieCatalog
{
    public partial class CheckMovies : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                try
                {
                    MovieCatalogBL context = new MovieCatalogBL();
                    var query = context.GetMoviesExpiry();
                    ListView2.DataSource = query;
                    ListView2.DataBind();
                }
                catch (Exception)
                {
                    lblMessage2.Text = "An error occurred while retrieving movies. Please try again.";
                    lblMessage2.Attributes.Add("style", "color:red; font: bold 14px/16px Sans-Serif,Arial");
                }

            }

        }

        // Days to Expiration - fill the column fields
        protected void ListView2_ItemDataBound(object sender, ListViewItemEventArgs e)
        {
            if (e.Item.ItemType == ListViewItemType.DataItem)
            {
                // Display the Expiry Date in italics.
              Label expDateLabel = (Label)e.Item.FindControl("lblExpireDate");
              Label daysToExpiryLabel = (Label)e.Item.FindControl("lblDaysToExpiry");

              // Convert to Date lblExpireDate Text
              DateTime expDate = Convert.ToDateTime(expDateLabel.Text);
              // calculate the days to expiration
              int daysToExpiry = (Int32)((expDate - DateTime.Now).Days);
              daysToExpiryLabel.Text = daysToExpiry.ToString();

              daysToExpiryLabel.Font.Bold = true;
              daysToExpiryLabel.ForeColor = System.Drawing.Color.Red;

            }
        }

       protected void AddExpiryDays()
        {
            foreach (ListViewItem item in ListView1.Items)
            {
                Label labelDaysToExpiry = (Label)item.FindControl("lblDaysToExpiry");
                Label labelExpiryDate = (Label)item.FindControl("lblExpireDate");
                DateTime expiryDate = Convert.ToDateTime(labelExpiryDate.Text);
                int daysToExpiry = (Int32)((expiryDate - DateTime.Now).Days);
                labelDaysToExpiry.Text = " " + daysToExpiry;
            }
        }

       protected void btnExportToExcel_Click(object sender, EventArgs e)
       {
          try
          {
           MovieCatalogBL context = new MovieCatalogBL();
           List<Movie> movieList = context.GetMoviesExpiry().ToList();

               if (movieList.Count > 0)
           {
               string path = Server.MapPath("~/exportedfiles/");

               if (!Directory.Exists(path))   // CHECK IF THE FOLDER EXISTS. IF NOT, CREATE A NEW FOLDER.
               {
                   Directory.CreateDirectory(path);
               }

               // "File.Delete" method does not throw an exception when a file doesn't exist.
               File.Delete(path + "MoviesToExpire.xls"); // DELETE THE FILE BEFORE CREATING A NEW ONE.

               // ADD A WORKBOOK USING THE EXCEL APPLICATION.
               Excel.Application xlAppToExport = new Excel.Application();
               xlAppToExport.Workbooks.Add("");

               // ADD A WORKSHEET.
               Excel.Worksheet xlWorkSheetToExport = default(Excel.Worksheet);
               xlWorkSheetToExport = (Excel.Worksheet)xlAppToExport.Sheets["Sheet1"];

               // ROW ID FROM WHERE THE DATA STARTS SHOWING.
               int iRowCnt = 4;

               // SHOW THE HEADER.
               xlWorkSheetToExport.Cells[1, 1] = "Movies To Expire in next 30 days.";

               Excel.Range range = xlWorkSheetToExport.Cells[1, 1] as Excel.Range;
               range.EntireRow.Font.Name = "Arial";
               range.EntireRow.Font.Bold = true;
               range.EntireRow.Font.Size = 20;

               // Depends how long the title is
               xlWorkSheetToExport.Range["A1:F1"].MergeCells = true;       // MERGE CELLS OF THE HEADER.

               // SHOW COLUMNS ON THE TOP.
               xlWorkSheetToExport.Cells[iRowCnt - 1, 1] = "Title";
               xlWorkSheetToExport.Cells[iRowCnt - 1, 2] = "Country";
               xlWorkSheetToExport.Cells[iRowCnt - 1, 3] = "Genre";
               xlWorkSheetToExport.Cells[iRowCnt - 1, 4] = "Year Of Production";
               xlWorkSheetToExport.Cells[iRowCnt - 1, 5] = "Expiry Date";

               foreach (var item in movieList)
               {
                   xlWorkSheetToExport.Cells[iRowCnt, 1] = item.OriginalName;
                   xlWorkSheetToExport.Cells[iRowCnt, 2] = item.Country;
                   xlWorkSheetToExport.Cells[iRowCnt, 3] = item.Genre;
                   xlWorkSheetToExport.Cells[iRowCnt, 4] = item.Year;
                   xlWorkSheetToExport.Cells[iRowCnt, 5] = item.ExpireDate;

                   iRowCnt = iRowCnt + 1;
               }

               // FINALLY, FORMAT THE EXCEL SHEET USING EXCEL'S AUTOFORMAT FUNCTION.
               Excel.Range range1 = xlAppToExport.ActiveCell.Worksheet.Cells[4, 1] as Excel.Range;
               range1.AutoFormat(ExcelAutoFormat.xlRangeAutoFormatList3);

               // SAVE THE FILE IN A FOLDER. (XLS or XLSX format)
               xlWorkSheetToExport.SaveAs(path + "MoviesToExpire.xls");

               // CLEAR.
               xlAppToExport.Workbooks.Close();
               xlAppToExport.Quit();
               xlAppToExport = null;
               xlWorkSheetToExport = null;

               lblMessage2.Text = "Data Exported.";
               lblMessage2.Attributes.Add("style", "color:green; font: bold 14px/16px Sans-Serif,Arial");
             }

           }
          catch (IOException)
          {
              lblMessage2.Text = "There was an error while exporting data. Check if file is in use by another application (MS Excel).";
              lblMessage2.Attributes.Add("style", "color:red; font: bold 14px/16px Sans-Serif,Arial");
          }
           catch (Exception ex)
           {
               lblMessage2.Text = "There was an error while exporting data. Try again." + "
" + ex.ToString(); ;
               lblMessage2.Attributes.Add("style", "color:red; font: bold 14px/16px Sans-Serif,Arial");
           }
       }

       // VIEW THE EXPORTED EXCEL DATA.
       protected void ViewData(object sender, System.EventArgs e)
       {
           string path = Server.MapPath("~/exportedfiles/");

           try
           {
               // CHECK IF THE FOLDER EXISTS.
               if (Directory.Exists(path))
               {
                   // CHECK IF THE FILE EXISTS.
                   if (File.Exists(path + "MoviesToExpire.xls"))
                   {
                       string strScript = "";
                       if (!Page.ClientScript.IsStartupScriptRegistered("clientScript"))
                       {
                         ClientScript.RegisterStartupScript(this.GetType() , "clientScript", strScript);
                       }

                   }
                   else
                   {
                       lblMessage2.Text = "File with exported data does not exist.";
                       lblMessage2.Attributes.Add("style", "color:red; font: bold 14px/16px Sans-Serif,Arial");
                   }
               }
               else
               {
                   lblMessage2.Text = "Directory with exported data does not exist.";
                   lblMessage2.Attributes.Add("style", "color:red; font: bold 14px/16px Sans-Serif,Arial");
               }
           }
           catch (Exception ex)
           {
               lblMessage2.Text = "There was an error while opening file. Try again." + "
" + ex.ToString();
               lblMessage2.Attributes.Add("style", "color:red; font: bold 14px/16px Sans-Serif,Arial");
           }
       }

    }
}


text:
class DLLEXPORT_RBM RigidBodyFrame {
public:
  RigidBodyFrame(const std::string& _name, const std::shared_ptr<RigidBody>& _body, const Eigen::Matrix4d& _transform_to_body)
   : name(_name), body(_body), transform_to_body(_transform_to_body), frame_index(0) {}
  RigidBodyFrame(const std::string& _name, const std::shared_ptr<RigidBody>& _body, const Eigen::Vector3d& xyz=Eigen::Vector3d::Zero(), const Eigen::Vector3d& rpy=Eigen::Vector3d::Zero())
          : name(_name), body(_body), frame_index(0) {
    transform_to_body << rpy2rotmat(rpy), xyz, 0,0,0,1;
  }
  RigidBodyFrame() : name(""), body(nullptr), transform_to_body(Eigen::Matrix4d::Identity()), frame_index(0) {}

  std::string name;
  std::shared_ptr<RigidBody> body;
  Eigen::Matrix4d transform_to_body;  // todo: change this to Isometry3d
  int frame_index;  // this will be negative, but will also be gone soon!

public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

#endif // _RIGIDBODYFRAME_H_


text:
#pragma once
#include <map>
#include <set>
#include <tuple>
#include <regex>
#include <string>
#include <thread>
#include "net/acceptor.hpp"
#include "net/syslogstream.hpp"
#include "http/headers.hpp"

namespace http {

using namespace std::literals;

class controller
{
public:

    using callback = std::function<std::string(std::string_view,std::string_view)>;

    void text(const std::string& content)
    {
        m_content_type = "text/plain"s;
        m_callback = [&](std::string_view,std::string_view){return content;};
    }

    void html(const std::string& content)
    {
        m_content_type = "text/html"s;
        m_callback = [&](std::string_view,std::string_view){return content;};
    }

    void css(const std::string& content)
    {
        m_content_type = "text/css"s;
        m_callback = [&](std::string_view,std::string_view){return content;};
    }

    void script(const std::string& content)
    {
        m_content_type = "application/javascript"s;
        m_callback = [&](std::string_view,std::string_view){return content;};
    }

    void json(const std::string& content)
    {
        m_content_type = "application/json"s;
        m_callback = [&](std::string_view,std::string_view){return content;};
    }

    void xml(const std::string& content)
    {
        m_content_type = "application/xml"s;
        m_callback = [&](std::string_view,std::string_view){return content;};
    }

    void response(std::string_view content_type, callback cb)
    {
        m_content_type = content_type;
        m_callback = cb;
    }

    std::tuple<std::string,std::string> render(std::string_view request = "", std::string_view body = "") const
    {
        return {m_callback(request,body),m_content_type};
    }

    void content_type(std::string_view type)
    {
        m_content_type = type;
    }

    const std::string& content_type() const
    {
        return m_content_type;
    }

private:

    std::string m_content_type = "*/*"s;

    callback m_callback = [](std::string_view, std::string_view){return "Not Found"s;};
};

class server
{
public:

    controller& get(const std::string& path)
    {
        m_methods.insert("GET"s);
        return m_router[path]["GET"s];
    }

    controller& head(const std::string& path)
    {
        m_methods.insert("HEAD"s);
        return m_router[path]["HEAD"s];
    }

    controller& post(const std::string& path)
    {
        m_methods.insert("POST"s);
        return m_router[path]["POST"s];
    }

    controller& put(const std::string& path)
    {
        m_methods.insert("PUT"s);
        return m_router[path]["PUT"s];
    }

    controller& patch(const std::string& path)
    {
        m_methods.insert("PATCH"s);
        return m_router[path]["PATCH"s];
    }

    controller& destroy(const std::string& path)
    {
        m_methods.insert("DELETE"s);
        return m_router[path]["DELETE"s];
    }

    void listen(std::string_view service_or_port = "http")
    {
        slog << info << "Starting up at "s << service_or_port << flush;
        auto endpoint = net::acceptor{"0.0.0.0", service_or_port};
        endpoint.timeout(0s); // no timeout
        slog << notice << "Started up at " << endpoint.host() << ":" << endpoint.service_or_port() << flush;
        while(true)
        {
            slog << notice << "Accepting connections" << flush;
            auto client = endpoint.accept();
            std::thread{[client = std::move(client), this]() mutable {handle(client);}}.detach();
        }
    }

    void public_paths(std::string_view regex)
    {
        m_public_paths = regex;
    }

    void credentials(std::initializer_list<std::string> tokens)
    {
        m_credentials.insert(tokens);
    }

private:

    auto date() const
    {
        return ext::to_rfc1123(std::chrono::system_clock::now());
    }

    const auto& host() const
    {
        static auto s_host = syslog::gethostname();
        return s_host;
    }

    auto methods() const
    {
        auto tmp = ""s;
        for(const auto&  m : m_methods)
        {
            if(not tmp.empty()) tmp += ", "s;
            tmp += m;
        }
        return tmp;
    }

    const auto& content_type() const
    {
        return m_content_type;
    }

    void handle(auto& client)
    {
        auto& [stream,endpoint,port] = client;
        slog << notice << "Accepted connection from " << endpoint << ":" << port << flush;

        try
        {
            while(stream)
            {
                auto method = ""s, uri = ""s, version = ""s;
                stream >> method >> uri >> version >> crlf;

                if(not stream.good()) break;

                slog << info << "HTTP request \"" << method << ' ' << uri << ' ' << version << "\"" << flush;

                auto headers = http::headers{};
                stream >> headers >> crlf;

                auto authorization = ""s;
                if(headers.contains("authorization"))
                    authorization = headers["authorization"];

                auto content_length = 0ull;
                if(headers.contains("content-length"))
                    content_length = std::stoll(headers["content-length"]);

                auto body = std::string(content_length,' ');
                for(auto& c : body)
                    c = stream.get();

                slog << debug << "HTTP request body \"" << body << "\"" << flush;

                if(version != "HTTP/1.1")
                {
                    stream << "HTTP/1.1 505 HTTP Version Not Supported" << crlf
                           << "Date: "         << date()                << crlf
                           << "Server: "       << host()                << crlf
                           << "Content-Type: " << content_type()        << crlf
                           << "Content-Length: 0"                       << crlf
                           << crlf << flush;
                }
                else if(not m_methods.contains(method))
                {
                    stream << "HTTP/1.1 400 Bad Request"                    << crlf
                           << "Date: "         << date()                    << crlf
                           << "Server: "       << host()                    << crlf
                           << "Content-Type: " << content_type()            << crlf
                           << "Content-Length: 0"                           << crlf
                           << "Access-Control-Allow-Methods: " << methods() << crlf
                           << crlf << flush;
                }
                else if(uri == "/favicon.ico")
                {
                    stream << "HTTP/1.1 404 Not Found"           << crlf
                           << "Date: "         << date()         << crlf
                           << "Server: "       << host()         << crlf
                           << "Content-Type: " << content_type() << crlf
                           << "Content-Length: 0"                << crlf
                           << crlf << flush;
                }
                else if(not std::regex_match(uri,std::regex(m_public_paths)) and not m_credentials.contains(authorization))
                {
                    stream << "HTTP/1.1 401 Unauthorized status"                     << crlf
                           << "Date: "         << date()                             << crlf
                           << "Server: "       << host()                             << crlf
                           << "Content-Type: " << content_type()                     << crlf
                           << "Content-Length: 0"                                    << crlf
                           << "WWW-Authenticate: Basic realm=\"User Visible Realm\"" << crlf
                           << crlf << flush;
                }
                else
                {
                    auto content = ""s,  type = ""s;

                    for(auto& [path,controller] : m_router)
                        if(std::regex_match(uri,std::regex(path)))
                            std::tie(content,type) = controller[method].render(uri,body);

                    if(not type.empty())
                        stream << "HTTP/1.1 200 OK"                                           << crlf
                               << "Date: " << date()                                          << crlf
                               << "Server: " << host()                                        << crlf
                               << "Content-Type: " << type                                    << crlf
                               << "Content-Length: " << content.length()                      << crlf
                               << "Access-Control-Allow-Methods: " << methods()               << crlf
                               << "Cache-Control: private"                                    << crlf
                               << "Access-Control-Allow-Headers: Authorization"               << crlf
//                             << "Access-Control-Allow-Origin: http://localhost:8080"        << crlf // FIXME
//                             << "Access-Control-Allow-Credentials: true"                    << crlf
                               << crlf
                               << (method != "HEAD"s ? content : ""s) << flush;
                    else
                        stream << "HTTP/1.0 404 Not Found"                                    << crlf
                               << "Date: " << date()                                          << crlf
                               << "Server: " << host()                                        << crlf
                               << "Content-Type: " << content_type()                          << crlf
                               << "Content-Length: 0"                                         << crlf
                               << crlf << flush;
                }
            }
            slog << info << "connection closed" << flush;
        }
        catch(const std::exception& e)
        {
            stream << "HTTP/1.0 500 Internal Server Error" << crlf
                   << "Date: " << date()                   << crlf
                   << "Server: " << host()                 << crlf
                   << "Content-Type: " << content_type()   << crlf
                   << "Content-Length: 0"                  << crlf
                   << crlf << flush;

            slog << net::error << e.what() << net::flush;
        }
    }

    using router = std::map<std::string,std::map<std::string,controller>, std::less<>>;

    router m_router = {};

    std::string m_content_type = "*/*"s;

    std::set<std::string> m_methods = {"HEAD"s, "OPTIONS"s};

    std::string m_public_paths = ".*";

    std::set<std::string> m_credentials = {};
};

} // namespace http


text:
<?php

/***************************************************************************
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version. Although none of the code may be
 *   sold. If you have been sold this script, get a refund.
 ***************************************************************************/

$query = "SELECT cat_id FROM " . $DBPrefix . "categories WHERE parent_id = -1";
$db->direct_query($query);
$parent_cat_id = $db->result('cat_id');

$query = "SELECT cat_id FROM " . $DBPrefix . "categories WHERE parent_id = :parent_cat_id ORDER BY cat_name";
$params = array();
$params[] = array(':parent_cat_id', $parent_cat_id, 'int');
$db->query($query, $params);

$categories = $db->fetchAll();

// move current language to end of array
unset($LANGUAGES[$language]);
$LANGUAGES[$language] = $language;

foreach ($LANGUAGES as $k => $v)
{
	include MAIN_PATH . 'language/' . $k . '/messages.inc.php';
	include MAIN_PATH . 'language/' . $k . '/categories.inc.php';
	$cat_strings = [];
	//build array of category names
	foreach ($categories as $category)
	{
		$cat_strings[$category['cat_id']] = $category_names[$category['cat_id']];
	}
	// sort the array
	asort($cat_strings);

	// build select dropdown
	$output = "\t" . '<option value="0">' . $MSG['277'] . '</option>' . "\n";
	$output.= "\t" . '<option value="0">----------------------</option>' . "\n";
	foreach ($cat_strings as $cat_id => $category_name)
	{
		$output .= "\t" . '<option value="' . $cat_id . '">' . $category_name . '</option>' . "\n";
	}
	$handle = fopen (MAIN_PATH . 'language/' . $k . '/categories_select_box.inc.php', 'w');
	fputs($handle, $output);
	fclose($handle);
}

$template->assign_block_vars('alerts', array('TYPE' => 'success', 'MESSAGE' => $MSG['086']));
?>


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

    <title>File Transfer Demo</title>

File Sharing over WebSockets using the WS3V Protocol

File Transfer Demo

Select an Image File and Click Upload to send it to the server over WebSockets.

If the file transfer is successful, the server will flip the image and return it to the client over WebSockets.

<input type="file" id="file" name="file" />

waiting for image...

    <link rel="stylesheet" href="../../WS3V/debug-assets/css/styles.css">

WS3V is an open WebSocket protocol providing modern web standard solutions for RESTful APIs.

WS3V by Mike Olsen is licensed under a Creative Commons Attribution 3.0 Unported License.


text:
function funcMain()
{
    var JokersWild = document.getElementById("gotoJokersWild");
    JokersWild.addEventListener("click", function(){VPnavigator.pushPage('JokersWild.html', {animation: 'slide'});}, false);
    var Ack = document.getElementById("gotoAck");
    Ack.addEventListener("click", function(){VPnavigator.pushPage('Ack.html', {animation: 'slide'});}, false);
}


text:
namespace TheXDS.MCART.Tests.Types.Extensions;
using NUnit.Framework;
using System;
using System.Text;
using TheXDS.MCART.Types.Extensions;

public class StringBuilderExtensionsTests
{
    [Test]
    public void AppendLineIfNotNull_Test()
    {
        StringBuilder sb = new();
        sb.AppendLineIfNotNull(null);
        Assert.True(sb.ToString().IsEmpty());
        sb.AppendLineIfNotNull("test");
        Assert.AreEqual($"test{Environment.NewLine}", sb.ToString());
        sb.AppendLineIfNotNull(null);
        Assert.AreEqual($"test{Environment.NewLine}", sb.ToString());
    }

    [Test]
    public void AppendAndWrap_Test()
    {
        StringBuilder sb = new();
        string s = new('x', 120);
        sb.AppendAndWrap(s, 80);
        string[]? sa = sb.ToString().Split(Environment.NewLine);
        Assert.AreEqual(80, sa[0].Length);
        Assert.AreEqual(40, sa[1].Length);
    }
}


text:
/* eslint-env mocha */
import assert from 'assert';
import { createRenderer } from 'react-addons-test-utils';
import { sandbox } from 'sinon';
import React from 'react';
import PropTypes from 'prop-types';
import isRequiredIf from '../../isRequiredIf';

const { bool } = PropTypes;

describe('React component bool proptype tests', () => {
  let fixtures = {};

  beforeEach(() => {
    fixtures.renderer = createRenderer();
    fixtures.Component = props =>
Hello {props.value}
; // eslint-disable-line
    fixtures.sandbox = sandbox.create();
    fixtures.warn = fixtures.sandbox.stub(console, 'error').throws();
  });

  afterEach(() => {
    fixtures.sandbox.restore();
    fixtures = {};
  });

  it(
    '...prop is not required and present, so it ' +
    'validates against React bool propType',
    () => {
      const {
        renderer,
        Component,
      } = fixtures;

      Component.propTypes = {
        value: isRequiredIf(bool, false),
      };

      assert.doesNotThrow(
        () => {
          renderer.render(<Component value />);
        },
        undefined,
      );
    },
  );

  it(
    '...prop is not required and missing, so it ' +
    'validates against React bool propType',
    () => {
      const {
        renderer,
        Component,
      } = fixtures;

      Component.propTypes = {
        value: isRequiredIf(bool, false),
      };

      assert.doesNotThrow(
        () => {
          renderer.render(<Component />);
        },
        undefined,
      );
    },
  );

  it(
    '...prop is required and warns because it is missing',
    () => {
      const {
        renderer,
        Component,
      } = fixtures;

      Component.propTypes = {
        value: isRequiredIf(bool, true),
      };

      assert.throws(
        () => {
          renderer.render(<Component />);
        },
        Error,
        'Throws because required prop is missing.',
      );
    },
  );

  it(
    '...prop is required and present so it validates against the bool',
    () => {
      const {
        renderer,
        Component,
      } = fixtures;

      Component.propTypes = {
        value: isRequiredIf(bool, true),
      };

      assert.doesNotThrow(
        () => {
          renderer.render(<Component value />);
        },
        undefined,
      );
    },
  );
});


text:
namespace _6.Remove_Villain
{
    using System;
    using System.Data.SqlClient;

    public class StartUp
    {
        public static void Main()
        {
            Console.Write("Please enter Villain Id: ");
            var villainId = int.Parse(Console.ReadLine());

            SqlConnection connection =
                new SqlConnection("Server=(localdb)\\MSSQLLocalDB;Database=MinionsDB;Integrated security=true");
            connection.Open();
            using (connection)
            {
                string queryToCheckId = "SELECT Name FROM Villains WHERE VillainId = @VillainId";
                SqlCommand commandToCheckId = new SqlCommand(queryToCheckId, connection);
                commandToCheckId.Parameters.AddWithValue("@VillainId", villainId);
                string nameOfVillain = (string)commandToCheckId.ExecuteScalar();

                if (nameOfVillain == null)
                {
                    Console.WriteLine("No such villain was found.");
                    Environment.Exit(0);
                }

                string queryToDeleteMinions = @"DELETE FROM MinionsVillains
                                               WHERE VillainId = @VillainId;
                                               SELECT @@ROWCOUNT;";
                SqlCommand commandToDeleteMinions = new SqlCommand(queryToDeleteMinions, connection);
                commandToDeleteMinions.Parameters.AddWithValue("@VillainId", villainId);
                int numberOfMinions = (int) commandToDeleteMinions.ExecuteScalar();

                string queryToDeleteVillain = "DELETE FROM Villains WHERE VillainId = @VillainId";
                SqlCommand commandToDeleteVillain = new SqlCommand(queryToDeleteVillain, connection);
                commandToDeleteVillain.Parameters.AddWithValue("@VillainId", villainId);
                commandToDeleteVillain.ExecuteNonQuery();

                Console.WriteLine($"{nameOfVillain} was deleted.");
                Console.WriteLine($"{numberOfMinions} minions released.");
            }
        }
    }
}


text:
// flowlint ambiguous-object-type:error

'use strict';

const RelayModernEnvironment = require('../RelayModernEnvironment');
const RelayModernStore = require('../RelayModernStore');
const RelayNetwork = require('../../network/RelayNetwork');
const RelayRecordSource = require('../RelayRecordSource');

const {
  createOperationDescriptor,
} = require('../RelayModernOperationDescriptor');
const {createReaderSelector} = require('../RelayModernSelector');
const {ROOT_ID} = require('../RelayStoreUtils');
const {graphql, getRequest} = require('relay-runtime');

describe('query cache expiration time', () => {
  let environment;
  let operationDescriptor;
  let ParentQuery;
  let source;
  let store;
  let fetchTime;
  const QUERY_CACHE_EXPIRATION_TIME = 1000;
  const GC_RELEASE_BUFFER_SIZE = 1;

  beforeEach(() => {
    fetchTime = Date.now();
    jest.spyOn(global.Date, 'now').mockImplementation(() => fetchTime);

    jest.resetModules();
    ParentQuery = getRequest(graphql`
      query RelayModernEnvironmentQueryCacheExpirationTimeTestQuery {
        me {
          id
          name
        }
      }
    `);

    source = RelayRecordSource.create();
    store = new RelayModernStore(source, {
      queryCacheExpirationTime: QUERY_CACHE_EXPIRATION_TIME,
      gcReleaseBufferSize: GC_RELEASE_BUFFER_SIZE,
    });
    environment = new RelayModernEnvironment({
      network: RelayNetwork.create(jest.fn()),
      store,
    });
    operationDescriptor = createOperationDescriptor(ParentQuery, {
      size: 32,
    });
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  describe('interactions with the release buffer', () => {
    it('retains disposed query in release buffer if less time than the query cache expiration time has passed when query is released', () => {
      environment.commitPayload(operationDescriptor, {
        me: {
          id: '4',
          name: 'Zuck',
        },
      });
      const {dispose} = environment.retain(operationDescriptor);
      const snapshot = environment.lookup(
        createReaderSelector(
          ParentQuery.fragment,
          ROOT_ID,
          {},
          operationDescriptor.request,
        ),
      );
      // data is still in the store
      expect(snapshot.data).toEqual({
        me: {
          id: '4',
          name: 'Zuck',
        },
      });

      fetchTime += QUERY_CACHE_EXPIRATION_TIME - 1;
      dispose();
      jest.runAllTimers();
      const snapshot2 = environment.lookup(
        createReaderSelector(
          ParentQuery.fragment,
          ROOT_ID,
          {},
          operationDescriptor.request,
        ),
      );

      // data is still in the store
      expect(snapshot2.data).toEqual({
        me: {
          id: '4',
          name: 'Zuck',
        },
      });
    });

    it('immediately releases stale disposed items', () => {
      environment.commitPayload(operationDescriptor, {
        me: {
          id: '4',
          name: 'Zuck',
        },
      });
      const {dispose} = environment.retain(operationDescriptor);
      const snapshot = environment.lookup(
        createReaderSelector(
          ParentQuery.fragment,
          ROOT_ID,
          {},
          operationDescriptor.request,
        ),
      );
      // data is still in the store
      expect(snapshot.data).toEqual({
        me: {
          id: '4',
          name: 'Zuck',
        },
      });
      fetchTime += QUERY_CACHE_EXPIRATION_TIME;
      dispose();
      jest.runAllTimers();
      const snapshot2 = environment.lookup(
        createReaderSelector(
          ParentQuery.fragment,
          ROOT_ID,
          {},
          operationDescriptor.request,
        ),
      );
      // data is not in the store
      expect(snapshot2.data).toBe(undefined);
    });
  });

  describe('with check()', () => {
    it('returns available for retained data until query cache expiration time has passed', () => {
      environment.commitPayload(operationDescriptor, {
        me: {
          id: '4',
          name: 'Zuck',
        },
      });
      const {dispose} = environment.retain(operationDescriptor);
      const originalFetchTime = fetchTime;

      expect(environment.check(operationDescriptor)).toEqual({
        status: 'available',
        fetchTime: originalFetchTime,
      });

      dispose();
      fetchTime += QUERY_CACHE_EXPIRATION_TIME - 1;
      expect(environment.check(operationDescriptor)).toEqual({
        status: 'available',
        fetchTime: originalFetchTime,
      });

      fetchTime += 1;
      expect(environment.check(operationDescriptor)).toEqual({
        status: 'stale',
      });
    });
  });
});


text:
require 'tilt'
require 'govspeak'

module Tilt
  class GovspeakTemplate < Template
    def prepare
      @engine = Govspeak::Document.new(data)
      @output = nil
    end

    def evaluate(scope, locals, &block)
      @output ||= @engine.to_html
    end
  end

  register GovspeakTemplate, :markdown, :mkd, :md
end


text:
TEST(rocfft_UnitTest, 1D_hermitian)
{
    // Run two 1D C2R transforms, on:
    // * random input
    // * identical random input, but modified to be Hermitian-symmetric
    // We should tolerate the input being having non-zero imaginary part in the DC mode
    // and the Nyquist frequency (of the length is even).

    rocfft_params p;
    p.length         = {8};
    p.precision      = fft_precision_double;
    p.transform_type = fft_transform_type_real_inverse;
    p.placement      = fft_placement_notinplace;
    p.validate();

    if(verbose)
    {
        std::cout << p.str("\n\t") << std::endl;
    }

    ASSERT_TRUE(p.valid(verbose));

    std::vector<std::complex<double>> h_input(p.isize[0]);

    std::random_device                     rd;
    std::mt19937                           gen(rd());
    std::uniform_real_distribution<double> dis(0.0, 1.0);
    for(auto& val : h_input)
    {
        val = std::complex<double>(dis(gen), dis(gen));
    }

    if(verbose)
    {
        std::cout << "non-Hermitian input:";
        for(const auto& val : h_input)
        {
            std::cout << " " << val;
        }
        std::cout << std::endl;
    }

    gpubuf ibuf;
    ASSERT_TRUE(ibuf.alloc(p.ibuffer_sizes()[0]) == hipSuccess);
    ASSERT_TRUE(hipMemcpy(ibuf.data(), h_input.data(), ibuf.size(), hipMemcpyHostToDevice)
                == hipSuccess);

    gpubuf obuf;
    ASSERT_TRUE(obuf.alloc(p.obuffer_sizes()[0]) == hipSuccess);

    ASSERT_TRUE(p.create_plan() == fft_status_success);

    std::vector<void*> pibuf = {ibuf.data()};
    std::vector<void*> pobuf = {obuf.data()};
    ASSERT_TRUE(p.execute(pibuf.data(), pobuf.data()) == fft_status_success);

    std::vector<double> h_output(p.osize[0]);
    ASSERT_TRUE(hipMemcpy(h_output.data(), obuf.data(), obuf.size(), hipMemcpyDeviceToHost)
                == hipSuccess);

    ASSERT_TRUE(hipDeviceSynchronize() == hipSuccess);

    if(verbose)
    {
        std::cout << "output:";
        for(const auto& val : h_output)
        {
            std::cout << " " << val;
        }
        std::cout << std::endl;
    }

    std::vector<std::complex<double>> h_input1 = h_input;

    // Impose Hermitian symmetry on the input:
    h_input1[0].imag(0.0);
    if(p.length[0] % 2 == 0)
    {
        h_input1.back().imag(0.0);
    }
    if(verbose)
    {
        std::cout << "Hermitian input:";
        for(const auto& val : h_input1)
        {
            std::cout << " " << val;
        }
        std::cout << std::endl;
    }

    double maxdiff = 0.0;
    for(unsigned int i = 0; i < h_input.size(); ++i)
    {
        auto val = std::abs(h_input[i] - h_input1[i]);
        if(val > maxdiff)
            maxdiff = val;
    }
    ASSERT_TRUE(maxdiff > 0.0);

    ASSERT_TRUE(hipMemcpy(ibuf.data(), h_input1.data(), ibuf.size(), hipMemcpyHostToDevice)
                == hipSuccess);
    ASSERT_TRUE(p.execute(pibuf.data(), pobuf.data()) == fft_status_success);
    std::vector<double> h_output1(p.osize[0]);
    ASSERT_TRUE(hipMemcpy(h_output1.data(), obuf.data(), obuf.size(), hipMemcpyDeviceToHost)
                == hipSuccess);

    if(verbose)
    {
        std::cout << "output:";
        for(const auto& val : h_output1)
        {
            std::cout << " " << val;
        }
        std::cout << std::endl;
    }

    double maxerr = 0;
    for(unsigned int i = 0; i < h_output.size(); ++i)
    {
        auto val = std::abs(h_output[i] - h_output1[i]);
        if(val > maxerr)
            maxerr = val;
    }

    if(verbose)
        std::cout << maxerr << std::endl;

    EXPECT_TRUE(maxerr == 0.0);
}

template <typename T>
std::string str(T begin, T end)
{
    std::stringstream ss;
    bool              first = true;
    for(; begin != end; begin++)
    {
        if(!first)
            ss << ", ";
        ss << *begin;
        first = false;
    }
    return ss.str();
}

// Test that the GPU Hermitian symmetrizer code produces the correct results.
TEST(rocfft_UnitTest, rtc_gpu_symmetrizer)
{
    std::vector<std::vector<size_t>> lengths = {{4, 4, 3},
                                                {5},
                                                {8},
                                                {5, 5},
                                                {5, 8},
                                                {8, 5},
                                                {8, 8},
                                                {5, 5, 5},
                                                {8, 5, 5},
                                                {5, 8, 5},
                                                {5, 5, 8},
                                                {5, 8, 8},
                                                {8, 5, 8},
                                                {8, 8, 5},
                                                {8, 8, 8}};

    for(const auto& length : lengths)
    {
        // Symmetrize complex data and ensure that the checker sees that it's symmetric.

        // Use the params class to set up strides and lengths:
        rocfft_params p;
        p.length         = length;
        p.precision      = fft_precision_double;
        p.transform_type = fft_transform_type_real_inverse;
        p.placement      = fft_placement_notinplace;
        p.validate();
        if(verbose)
        {
            std::cout << "\t" << p.str("\n\t") << std::endl;
        }
        ASSERT_TRUE(p.valid(verbose));

        // Data buffers:
        gpubuf buf;
        ASSERT_TRUE(buf.alloc(sizeof(std::complex<double>) * p.isize[0]) == hipSuccess);
        std::vector<std::complex<double>> hbuf(p.isize[0]);

        // Initialize a Hermitian-symmetric array; it should be symmetric.
        init_hermitiancomplex_cm(p.length_cm(), p.ilength_cm(), p.istride_cm(), buf.data());
        ASSERT_TRUE(hipMemcpy(hbuf.data(), buf.data(), buf.size(), hipMemcpyDeviceToHost)
                    == hipSuccess);
        if(verbose > 1)
        {
            printbuffer_cm(hbuf, p.ilength_cm(), p.istride_cm(), p.nbatch, p.idist);
        }
        EXPECT_TRUE(
            check_symmetry_cm(hbuf, p.length_cm(), p.istride_cm(), p.nbatch, p.idist, verbose > 0))
            << "length: " << str(length.begin(), length.end());

        // This should not be symmetric:
        std::mt19937_64 rng;
        std::seed_seq   ss{uint32_t(10)};
        rng.seed(ss);
        std::uniform_real_distribution<double> unif(0, 1);
        for(auto& v : hbuf)
        {
            v = std::complex<double>(unif(rng), unif(rng));
        }
        if(verbose > 2)
        {
            printbuffer_cm(hbuf, p.ilength_cm(), p.istride_cm(), p.nbatch, p.idist);
        }
        EXPECT_TRUE(
            !check_symmetry_cm(hbuf, p.length_cm(), p.istride_cm(), p.nbatch, p.idist, false))
            << "length: " << str(length.begin(), length.end());
    }

    for(const auto& length : lengths)
    {
        // Generate Hermitian-symmetric data and ensure that applying the symmetrizer has no effect.

        rocfft_params p;
        p.length         = length;
        p.precision      = fft_precision_double;
        p.transform_type = fft_transform_type_real_forward;
        p.placement      = fft_placement_notinplace;
        p.validate();
        if(verbose)
        {
            std::cout << "\t" << p.str("\n\t") << std::endl;
        }
        ASSERT_TRUE(p.valid(verbose));
        ASSERT_TRUE(p.create_plan() == fft_status_success);

        gpubuf ibuf, obuf;
        ASSERT_TRUE(ibuf.alloc(p.ibuffer_sizes()[0]) == hipSuccess);
        ASSERT_TRUE(obuf.alloc(p.obuffer_sizes()[0]) == hipSuccess);

        initreal_cm(p.length_cm(), p.istride_cm(), ibuf.data());

        std::vector<void*> pibuf = {ibuf.data()};
        std::vector<void*> pobuf = {obuf.data()};

        ASSERT_TRUE(p.execute(pibuf.data(), pobuf.data()) == fft_status_success);

        std::vector<std::complex<double>> h_output(p.osize[0]);
        std::fill(h_output.begin(), h_output.end(), 0.0);
        ASSERT_TRUE(
            hipMemcpy(h_output.data(), obuf.data(), p.obuffer_sizes()[0], hipMemcpyDeviceToHost)
            == hipSuccess);

        impose_hermitian_symmetry_cm(p.length_cm(), p.olength_cm(), p.ostride_cm(), obuf.data());
        std::vector<std::complex<double>> h_output_resym(p.osize[0]);
        std::fill(h_output_resym.begin(), h_output_resym.end(), 0.0);
        ASSERT_TRUE(
            hipMemcpy(
                h_output_resym.data(), obuf.data(), p.obuffer_sizes()[0], hipMemcpyDeviceToHost)
            == hipSuccess);

        double maxdiff = 0;
        for(unsigned int i = 0; i < h_output.size(); ++i)
        {
            auto rdiff = std::abs(h_output[i].real() - h_output_resym[i].real());
            auto idiff = std::abs(h_output[i].imag() - h_output_resym[i].imag());
            maxdiff    = std::max({maxdiff, rdiff, idiff});
        }

        if(verbose)
        {
            std::cout << "maxdiff: " << maxdiff << std::endl;
        }

        if(verbose > 2)
        {
            std::cout << "before symmetrization:\n";
            printbuffer_cm(h_output, p.olength_cm(), p.ostride_cm(), p.nbatch, p.odist);
            std::cout << "after symmetrization:\n";
            printbuffer_cm(h_output_resym, p.olength_cm(), p.ostride_cm(), p.nbatch, p.odist);
        }

        EXPECT_TRUE(maxdiff < 1e-13) << maxdiff << "\n" << p.str() << "\n";
    }
}