/// <summary>
        /// Gets the prevalue editor settings.
        /// </summary>
        /// <param name="dataTypeDefinitionId">The data type definition id.</param>
        /// <returns>The PreValue Editor Settings.</returns>
        public PreValueEditorSettings GetPrevalueEditorSettings(int dataTypeDefinitionId)
        {
            var prevalues = PreValues.GetPreValues(dataTypeDefinitionId);
            var settings = new PreValueEditorSettings();

            if (prevalues.Count > 0)
            {
                var prevalue = (PreValue)prevalues[0];

                if (!string.IsNullOrEmpty(prevalue.Value))
                {
                    var serializer = new JavaScriptSerializer();

                    try
                    {
                        settings = serializer.Deserialize<PreValueEditorSettings>(prevalue.Value);
                    }
                    catch (Exception ex)
                    {
                        // Cannot understand stored prevalues
                        Helper.Log.Error<DataType>("Error when parsing stored prevalues", ex);
                    }
                }
            }

            return settings;
        }
Exemplo n.º 2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DataEditor"/> class.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <param name="settings">The settings.</param>
        /// <param name="dataTypeDefinitionId">The data type definition id.</param>
        /// <param name="instanceId">The instance id.</param>
        public DataEditor(IData data, PreValueEditorSettings settings, int dataTypeDefinitionId, string instanceId)
        {
            this.settings = settings;
            this.data = data;

            this.dataTypeDefinitionId = dataTypeDefinitionId;
            this.instanceId = instanceId;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DataEditor"/> class.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <param name="settings">The settings.</param>
        /// <param name="dataTypeDefinitionId">The data type definition id.</param>
        /// <param name="instanceId">The instance id.</param>
        public DataEditor(IData data, PreValueEditorSettings settings, int dataTypeDefinitionId, string instanceId)
        {
            // Set up dependencies
            this.prevalueEditorSettingsHandler = new PrevalueEditorSettingsHandler();
            this.settings = settings;
            this.data = data;

            this.dataTypeDefinitionId = dataTypeDefinitionId;
            this.instanceId = instanceId;
        }
Exemplo n.º 4
0
        /// <summary>
        /// Saves this instance.
        /// </summary>
        public override void Save()
        {
            lock (Locker)
            {
                var prevalues = new List<object>();

                // Set settings
                if (this.settings == null)
                {
                    this.settings = this.prevalueEditorSettingsHandler.GetPrevalueEditorSettings(this.DataType.DataTypeDefinitionId);
                }

                this.Settings.ShowLabel = this.showLabel != null && this.showLabel.Checked;
                this.Settings.ShowGridHeader = this.showHeader != null && this.showHeader.Checked;
                this.Settings.ShowGridFooter = this.showFooter != null && this.showFooter.Checked;
                this.Settings.ReadOnly = this.readOnly != null && this.readOnly.Checked;
                this.Settings.TableHeight = this.tableHeight != null ? int.Parse(this.tableHeight.Text) : 300;
                prevalues.Add(this.Settings);

                // Add existing prevalues;
                foreach (var t in this.preValues)
                {
                    var parsedprevalue = ParsePrevalue(t);

                    if (parsedprevalue != null)
                    {
                        prevalues.Add(parsedprevalue);
                    }
                }

                // Add last (new) prevalue
                var newprevalue = ParsePrevalue(this.newPreValue);

                if (newprevalue != null)
                {
                    prevalues.Add(newprevalue);
                }

                if (prevalues.Count > 0)
                {
                    // Delete former values
                    PreValues.DeleteByDataTypeDefinition(this.DataType.DataTypeDefinitionId);

                    // Add new values
                    this.AddPrevalues(prevalues);

                    // Must not refresh on initial load. [LK]
                    if (prevalues.Count > 1)
                    {
                        // Reload IFrame to show changes
                        this.Page.Response.Redirect(this.Page.Request.Url.ToString());
                    }
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Creates child controls for this control
        /// </summary>
        protected override void CreateChildControls()
        {
            base.CreateChildControls();

            // Get configuration
            this._newPreValue = new PreValueRow();
            this._preValues = new List<PreValueRow>();
            this._settings = DtgHelpers.GetSettings(this.m_DataType.DataTypeDefinitionId);
            this.GetConfig();

            // Instantiate default controls
            this._accordionContainer = new Panel { ID = "dtg_accordion_" + this.m_DataType.DataTypeDefinitionId, CssClass = "dtg_accordion" };
            this._showLabel = new CheckBox() { ID = "showLabel", Checked = this._settings.ShowLabel };
            this._showHeader = new CheckBox() { ID = "showHeader", Checked = this._settings.ShowGridHeader };
            this._showFooter = new CheckBox() { ID = "showFooter", Checked = this._settings.ShowGridFooter };
            this._readOnly = new CheckBox() { ID = "readOnly", Checked = this._settings.ReadOnly };
            this._tableHeight = new TextBox() { ID = "TableHeight", Text = this._settings.TableHeight.ToString() };
            this._tableHeightValidator = new RegularExpressionValidator()
                {
                    ID = "NumberOfRowsValidator",
                    CssClass = "validator",
                    ValidationExpression = @"^[1-9]*[0-9]*$",
                    ControlToValidate = this._tableHeight.ClientID,
                    Display = ValidatorDisplay.Dynamic,
                    ErrorMessage = Helper.Dictionary.GetDictionaryItem("MustBeANumber", "Must be a number")
                };

            // Write controls for adding new entry
            var addNewProperty = new Panel() { ID = "newProperty", CssClass = "addNewProperty" };

            var addNewPropertyHeader = new Panel() { CssClass = "propertyHeader" };

            var addNewPropertyTitle = new HtmlGenericControl("h3") { InnerText = Helper.Dictionary.GetDictionaryItem("AddNewDataType", "Add new datatype") };
            addNewPropertyTitle.Attributes["class"] = "propertyTitle";

            var icnNewError = new HtmlGenericControl("span") { InnerText = Helper.Dictionary.GetDictionaryItem("Error", "Error") };
            icnNewError.Attributes["class"] = "ErrorProperty";

            addNewPropertyHeader.Controls.Add(addNewPropertyTitle);
            addNewPropertyHeader.Controls.Add(icnNewError);

            var addNewPropertyControls = new Panel() { ID = "addNewPropertyControls", CssClass = "propertyControls" };
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<ul>" });

            // NAME
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

            // Instantiate controls
            var txtNewName = new TextBox() { ID = "newName", CssClass = "newName" };
            var lblNewName = new Label()
            {
                AssociatedControlID = txtNewName.ClientID,
                Text = Helper.Dictionary.GetDictionaryItem("Name", "Name")
                    + "<br/><small class='description'>"
                    + Helper.Dictionary.GetDictionaryItem(
                    "NameDescription",
                    "The column display name") + "</small>",
                CssClass = "label"
            };
            var valNewName = new RequiredFieldValidator()
                {
                    ID = "newNameValidator",
                    CssClass = "validator",
                    Enabled = false,
                    ControlToValidate = txtNewName.ClientID,
                    Display = ValidatorDisplay.Dynamic,
                    ErrorMessage = Helper.Dictionary.GetDictionaryItem("YouMustSpecifyAName", "You must specify a name")
                };

            // Add controls to control
            addNewPropertyControls.Controls.Add(lblNewName);
            addNewPropertyControls.Controls.Add(txtNewName);
            addNewPropertyControls.Controls.Add(valNewName);
            ((PreValueRow)this._newPreValue).Controls.Add(txtNewName);
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

            // ALIAS
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

            // Instantiate controls
            var txtNewAlias = new TextBox() { ID = "newAlias", CssClass = "newAlias" };
            var lblNewAlias = new Label()
            {
                AssociatedControlID = txtNewAlias.ClientID,
                Text = Helper.Dictionary.GetDictionaryItem("Alias", "Alias")
                    + "<br/><small class='description'>"
                    + Helper.Dictionary.GetDictionaryItem(
                    "AliasDescription",
                    "The column alias") + "</small>",
                CssClass = "label"
            };
            var valNewAlias = new RequiredFieldValidator()
                {
                    ID = "newAliasValidator",
                    CssClass = "validator",
                    Enabled = false,
                    ControlToValidate = txtNewAlias.ClientID,
                    Display = ValidatorDisplay.Dynamic,
                    ErrorMessage =
                        Helper.Dictionary.GetDictionaryItem("YouMustSpecifyAnAlias", "You must specify an alias")
                };

            var valNewAliasExists = new CustomValidator()
                {
                    ID = "newAliasExistsValidator",
                    CssClass = "validator exists",
                    Enabled = false,
                    ControlToValidate = txtNewAlias.ClientID,
                    Display = ValidatorDisplay.Dynamic,
                    ClientValidationFunction = "ValidateNewAliasExists",
                    ErrorMessage = Helper.Dictionary.GetDictionaryItem("AliasAlreadyExists", "Alias already exists!")
                };
            valNewAliasExists.ServerValidate += valNewAliasExists_ServerValidate;

            // Add controls to control
            addNewPropertyControls.Controls.Add(lblNewAlias);
            addNewPropertyControls.Controls.Add(txtNewAlias);
            addNewPropertyControls.Controls.Add(valNewAlias);
            addNewPropertyControls.Controls.Add(valNewAliasExists);
            ((PreValueRow)this._newPreValue).Controls.Add(txtNewAlias);
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

            // DATATYPE
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

            // Instantiate controls
            var ddlNewType = DtgHelpers.GetDataTypeDropDown();
            ddlNewType.ID = "newType";
            var lblNewType = new Label()
            {
                AssociatedControlID = ddlNewType.ClientID,
                Text = Helper.Dictionary.GetDictionaryItem("DataType", "Datatype")
                    + "<br/><small class='description'>"
                    + Helper.Dictionary.GetDictionaryItem(
                    "DatatypeDescription",
                    "The column data editor") + "</small>",
                CssClass = "label"
            };

            // Add controls to control
            addNewPropertyControls.Controls.Add(lblNewType);
            addNewPropertyControls.Controls.Add(ddlNewType);
            ((PreValueRow)this._newPreValue).Controls.Add(ddlNewType);
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

            // MANDATORY
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

            // Instantiate controls
            var chkNewMandatory = new CheckBox() { ID = "newMandatory", CssClass = "newMandatory" };
            var lblNewMandatory = new Label()
                                      {
                                          AssociatedControlID = chkNewMandatory.ClientID,
                                          Text =
                                              Helper.Dictionary.GetDictionaryItem("Mandatory", "Mandatory")
                                              + "<br/><small class='description'>"
                                              + Helper.Dictionary.GetDictionaryItem(
                                                  "MandatoryDescription",
                                                  "Whether this column is mandatory") + "</small>",
                                          CssClass = "label"
                                      };

            // Add controls to control
            addNewPropertyControls.Controls.Add(lblNewMandatory);
            addNewPropertyControls.Controls.Add(chkNewMandatory);
            ((PreValueRow)this._newPreValue).Controls.Add(chkNewMandatory);
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

            // VISIBLE
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

            // Instantiate controls
            var chkNewVisible = new CheckBox() { ID = "newVisible", CssClass = "newVisible", Checked = true };
            var lblNewVisible = new Label()
            {
                AssociatedControlID = chkNewVisible.ClientID,
                Text = Helper.Dictionary.GetDictionaryItem("Visible", "Visible")
                    + "<br/><small class='description'>"
                    + Helper.Dictionary.GetDictionaryItem(
                    "VisibleDescription",
                    "Whether this column is visible in the grid. <br/>(it can still be edited)") + "</small>",
                CssClass = "label"
            };

            // Add controls to control
            addNewPropertyControls.Controls.Add(lblNewVisible);
            addNewPropertyControls.Controls.Add(chkNewVisible);
            ((PreValueRow)this._newPreValue).Controls.Add(chkNewVisible);
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

            // VALIDATION
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

            // Instantiate controls
            var txtNewValidation = new TextBox()
                {
                    ID = "newValidation",
                    TextMode = TextBoxMode.MultiLine,
                    Rows = 2,
                    Columns = 20,
                    CssClass = "newValidation"
                };
            var lblNewValidation = new Label()
            {
                AssociatedControlID = txtNewValidation.ClientID,
                Text = Helper.Dictionary.GetDictionaryItem("Validation", "Validation")
                    + "<br/><small class='description'>"
                    + Helper.Dictionary.GetDictionaryItem(
                    "ValidationDescription",
                    "The regular expression used for validation. Leave empty to disable") + "</small>",
                CssClass = "label"
            };
            var lnkNewValidation = new HyperLink
                {
                    ID = "newValidationLink",
                    CssClass = "validationLink",
                    NavigateUrl = "#",
                    Text =
                        Helper.Dictionary.GetDictionaryItem(
                            "SearchForARegularExpression", "Search for a regular expression")
                };
            var valNewValidation = new CustomValidator()
                {
                    ID = "newValidationValidator",
                    CssClass = "validator",
                    ControlToValidate = txtNewValidation.ClientID,
                    Display = ValidatorDisplay.Dynamic,
                    ClientValidationFunction = "ValidateRegex",
                    ErrorMessage =
                        Helper.Dictionary.GetDictionaryItem(
                            "ValidationStringIsNotValid", "Validation string is not valid")
                };
            valNewValidation.ServerValidate += this.valNewValidation_ServerValidate;

            // Add controls to control
            addNewPropertyControls.Controls.Add(lblNewValidation);
            addNewPropertyControls.Controls.Add(txtNewValidation);
            addNewPropertyControls.Controls.Add(valNewValidation);
            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "<br/>" });
            addNewPropertyControls.Controls.Add(lnkNewValidation);
            ((PreValueRow)this._newPreValue).Controls.Add(txtNewValidation);

            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

            // PREVALUE SORT ORDER

            // Instantiate controls
            var hdnNewSortOrder = new HiddenField() { Value = (this._preValues.Count + 1).ToString() };
            addNewPropertyControls.Controls.Add(hdnNewSortOrder);
            ((PreValueRow)this._newPreValue).Controls.Add(hdnNewSortOrder);

            addNewPropertyControls.Controls.Add(new LiteralControl() { Text = "</ul>" });

            addNewProperty.Controls.Add(addNewPropertyHeader);
            addNewProperty.Controls.Add(addNewPropertyControls);

            this._accordionContainer.Controls.Add(addNewProperty);

            // Write stored entries
            foreach (var s in this._preValues)
            {
                var editProperty = new Panel() { ID = "editProperty_" + s.Id.ToString(), CssClass = "editProperty" };

                var editDataType = ddlNewType.Items.FindByValue(s.DataTypeId.ToString());

                var editPropertyHeader = new Panel() { CssClass = "propertyHeader" };
                var editPropertyTitle = new HtmlGenericControl("h3")
                                            {
                                                InnerText =
                                                    string.Format(
                                                        "{0} ({1}), {2}: {3}",
                                                        s.Name.StartsWith("#")
                                                            ? uQuery.GetDictionaryItem(
                                                                s.Name.Substring(
                                                                    1, s.Name.Length - 1),
                                                                s.Name.Substring(
                                                                    1, s.Name.Length - 1))
                                                            : s.Name,
                                                        s.Alias,
                                                        uQuery.GetDictionaryItem("Type", "Type"),
                                                        editDataType != null
                                                            ? editDataType.Text
                                                            : "ERROR: This datatype is not supported")
                                            };

                editPropertyTitle.Attributes["class"] = "propertyTitle";

                var lnkDelete = new LinkButton
                    {
                        CssClass = "DeleteProperty ui-button ui-widget ui-state-default ui-corner-all ui-button-icon-only",
                        Text =
                            "<span class='ui-button-icon-primary ui-icon ui-icon-close'>&nbsp;</span><span class='ui-button-text'>Delete</span>",
                        OnClientClick =
                            "return confirm('"
                            +
                            uQuery.GetDictionaryItem(
                                "AreYouSureYouWantToDeleteThisColumn", "Are you sure you want to delete this column")
                            + "?');",
                        CommandArgument = s.Id.ToString(),
                        CommandName = "Delete"
                    };
                lnkDelete.Command += new CommandEventHandler(this.lnkDelete_Command);

                var icnEditError = new HtmlGenericControl("span")
                    { InnerText = Helper.Dictionary.GetDictionaryItem("Error", "Error") };
                icnEditError.Attributes["class"] = "ErrorProperty";

                editPropertyHeader.Controls.Add(editPropertyTitle);
                editPropertyHeader.Controls.Add(lnkDelete);
                editPropertyHeader.Controls.Add(icnEditError);

                var editPropertyControls = new Panel() { CssClass = "propertyControls" };

                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<ul>" });

                // NAME
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

                // Instantiate controls
                var txtEditName = new TextBox() { ID = "editName_" + this._preValues.IndexOf(s), CssClass = "editName", Text = s.Name };
                var lblEditName = new Label()
                {
                    AssociatedControlID = txtEditName.ClientID,
                    Text = Helper.Dictionary.GetDictionaryItem("Name", "Name")
                        + "<br/><small class='description'>"
                        + Helper.Dictionary.GetDictionaryItem(
                        "NameDescription",
                        "The column display name") + "</small>",
                    CssClass = "label"
                };
                var valEditName = new RequiredFieldValidator()
                    {
                        ID = "editNameValidator_" + this._preValues.IndexOf(s),
                        CssClass = "validator",
                        ControlToValidate = txtEditName.ClientID,
                        Display = ValidatorDisplay.Dynamic,
                        ErrorMessage = "You must specify a name"
                    };

                // Add controls to control
                editPropertyControls.Controls.Add(lblEditName);
                editPropertyControls.Controls.Add(txtEditName);
                editPropertyControls.Controls.Add(valEditName);
                s.Controls.Add(txtEditName);
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

                // ALIAS
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

                // Instantiate controls
                var txtEditAlias = new TextBox() { ID = "editAlias_" + this._preValues.IndexOf(s), CssClass = "editAlias", Text = s.Alias };
                var lblEditAlias = new Label()
                {
                    AssociatedControlID = txtEditAlias.ClientID,
                    Text = Helper.Dictionary.GetDictionaryItem("Alias", "Alias")
                        + "<br/><small class='description'>"
                        + Helper.Dictionary.GetDictionaryItem(
                        "AliasDescription",
                        "The column alias") + "</small>",
                    CssClass = "label"
                };
                var valEditAlias = new RequiredFieldValidator()
                    {
                        ID = "editAliasValidator_" + this._preValues.IndexOf(s),
                        CssClass = "validator",
                        ControlToValidate = txtEditAlias.ClientID,
                        Display = ValidatorDisplay.Dynamic,
                        ErrorMessage = "You must specify an alias"
                    };
                var valEditAliasExists = new CustomValidator()
                    {
                        ID = "editAliasExistsValidator_" + this._preValues.IndexOf(s),
                        CssClass = "validator exists",
                        ControlToValidate = txtEditAlias.ClientID,
                        Display = ValidatorDisplay.Dynamic,
                        ClientValidationFunction = "ValidateAliasExists",
                        ErrorMessage = "Alias already exists!"
                    };
                valEditAliasExists.ServerValidate += valEditAliasExists_ServerValidate;

                // Add controls to control
                editPropertyControls.Controls.Add(lblEditAlias);
                editPropertyControls.Controls.Add(txtEditAlias);
                editPropertyControls.Controls.Add(valEditAlias);
                editPropertyControls.Controls.Add(valEditAliasExists);
                s.Controls.Add(txtEditAlias);
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

                // DATATYPE
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

                // Instantiate controls
                var ddlEditType = DtgHelpers.GetDataTypeDropDown();
                ddlEditType.ID = "editDataType_" + this._preValues.IndexOf(s);
                var lblEditType = new Label()
                {
                    AssociatedControlID = ddlEditType.ClientID,
                    Text = Helper.Dictionary.GetDictionaryItem("DataType", "Datatype")
                        + "<br/><small class='description'>"
                        + Helper.Dictionary.GetDictionaryItem(
                        "DatatypeDescription",
                        "The column data editor") + "</small>",
                    CssClass = "label"
                };

                // Add controls to control
                editPropertyControls.Controls.Add(lblEditType);
                ddlEditType.SelectedValue = s.DataTypeId.ToString();
                editPropertyControls.Controls.Add(ddlEditType);
                s.Controls.Add(ddlEditType);
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

                // MANDATORY
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

                // Instantiate controls
                var chkEditMandatory = new CheckBox() { ID = "editMandatory_" + this._preValues.IndexOf(s), CssClass = "editMandatory", Checked = s.Mandatory};
                var lblEditMandatory = new Label()
                {
                    AssociatedControlID = chkEditMandatory.ClientID,
                    Text = Helper.Dictionary.GetDictionaryItem("Mandatory", "Mandatory")
                        + "<br/><small class='description'>"
                        + Helper.Dictionary.GetDictionaryItem(
                        "MandatoryDescription",
                        "Whether this column is mandatory") + "</small>",
                    CssClass = "label"
                };

                // Add controls to control
                editPropertyControls.Controls.Add(lblEditMandatory);
                editPropertyControls.Controls.Add(chkEditMandatory);
                s.Controls.Add(chkEditMandatory);
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

                // VISIBLE
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

                // Instantiate controls
                var chkEditVisible = new CheckBox() { ID = "editVisible_" + this._preValues.IndexOf(s), CssClass = "editVisible", Checked = s.Visible };
                var lblEditVisible = new Label()
                {
                    AssociatedControlID = chkEditVisible.ClientID,
                    Text = Helper.Dictionary.GetDictionaryItem("Visible", "Visible")
                        + "<br/><small class='description'>"
                        + Helper.Dictionary.GetDictionaryItem(
                        "VisibleDescription",
                        "Whether this column is visible in the grid. <br/>(it can still be edited)") + "</small>",
                    CssClass = "label"
                };

                // Add controls to control
                editPropertyControls.Controls.Add(lblEditVisible);
                editPropertyControls.Controls.Add(chkEditVisible);
                s.Controls.Add(chkEditVisible);
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

                // VALIDATION
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<li>" });

                // Instantiate control
                var txtEditValidation = new TextBox()
                    {
                        ID = "editValidation_" + this._preValues.IndexOf(s),
                        TextMode = TextBoxMode.MultiLine,
                        Rows = 2,
                        Columns = 20,
                        CssClass = "editValidation",
                        Text = s.ValidationExpression
                    };
                var lblEditValidation = new Label()
                {
                    AssociatedControlID = txtEditValidation.ClientID,
                    Text = Helper.Dictionary.GetDictionaryItem("Validation", "Validation")
                        + "<br/><small class='description'>"
                        + Helper.Dictionary.GetDictionaryItem(
                        "ValidationDescription",
                        "The regular expression used for validation. Leave empty to disable") + "</small>",
                    CssClass = "label"
                };
                var lnkEditValidation = new HyperLink
                    {
                        CssClass = "validationLink",
                        NavigateUrl = "#",
                        Text =
                            Helper.Dictionary.GetDictionaryItem(
                                "SearchForARegularExpression", "Search for a regular expression")
                    };
                var valEditValidation = new CustomValidator()
                    {
                        ID = "editValidationValidator_" + this._preValues.IndexOf(s),
                        CssClass = "validator",
                        ControlToValidate = txtEditValidation.ClientID,
                        Display = ValidatorDisplay.Dynamic,
                        ClientValidationFunction = "ValidateRegex",
                        ErrorMessage =
                            Helper.Dictionary.GetDictionaryItem(
                                "ValidationStringIsNotValid", "Validation string is not valid")
                    };
                valEditValidation.ServerValidate += valEditValidation_ServerValidate;

                // Add controls to control
                editPropertyControls.Controls.Add(lblEditValidation);
                editPropertyControls.Controls.Add(txtEditValidation);
                editPropertyControls.Controls.Add(valEditValidation);
                editPropertyControls.Controls.Add(new LiteralControl() { Text = "<br/>" });
                editPropertyControls.Controls.Add(lnkEditValidation);
                s.Controls.Add(txtEditValidation);

                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</li>" });

                // SORT ORDER

                // Instantiate controls
                var hdnEditSortOrderWrapper = new Panel() { CssClass = "sortOrder" };
                var hdnEditSortOrder = new HiddenField() { Value = s.SortOrder.ToString() };
                hdnEditSortOrderWrapper.Controls.Add(hdnEditSortOrder);
                editPropertyControls.Controls.Add(hdnEditSortOrderWrapper);
                s.Controls.Add(hdnEditSortOrder);

                editPropertyControls.Controls.Add(new LiteralControl() { Text = "</ul>" });

                editProperty.Controls.Add(editPropertyHeader);
                editProperty.Controls.Add(editPropertyControls);

                this._accordionContainer.Controls.Add(editProperty);
            }

            this.Controls.Add(this._showLabel);
            this.Controls.Add(this._showHeader);
            this.Controls.Add(this._showFooter);
            this.Controls.Add(this._readOnly);
            this.Controls.Add(this._tableHeight);
            this.Controls.Add(this._tableHeightValidator);
            this.Controls.Add(this._accordionContainer);
        }