/// <summary>
/// Applies the settings of this attribute to the given configuration entry.
/// </summary>
/// <param name="Entry"></param>
public void ApplyToConfigurationEntry(ConfigurationEntry Entry) {
Entry.Text = Text;
Entry.SubText = SubText;
Entry.SortKey = SortKey;
Entry.GroupKey = GroupKey;
Entry.ReadOnly = ReadOnly;
Entry.Minimum = Minimum;
Entry.Maximum = Maximum;
Entry.ControlType = ControlType;
if (!String.IsNullOrEmpty(Validator)) {
String[] validators = Validator.Split(',');
foreach (String v in validators) {
String validator = v.Trim();
if (String.IsNullOrEmpty(validator))
continue;
if (AvailableValidators.ContainsKey(validator))
Entry.ValidateValue += new ConfigurationEntry.ValidateEvent(AvailableValidators[validator]);
else
throw new ArgumentException(String.Format("Unknown validator: {0}", validator), "Validator");
}
}
}
/// <summary>
/// Add a new <see cref="ConfigurationEntry"/> to the set.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public ConfigurationEntry Add(ConfigurationEntry key) {
Data.Add(key);
return key;
}
void config_ValidateValue(ConfigurationEntry Sender, ref object Value, out bool Valid) {
Valid = true;
if (ValidateValue == null)
return;
try {
Valid = (bool)DirectInvoker.InvokeDirect(ValidateValue, SelectedRecord, new object[] { Value });
} catch {
Valid = false;
}
}
/// <summary>
/// Generic validator for directories. Checks if a directory exists.
/// </summary>
/// <param name="Sender">The configuration entry for which the given <paramref name="Value"/> should be validated.</param>
/// <param name="Value">The value to validate.</param>
/// <param name="Valid">True if the value is valid or has been converted into a valid value, otherwise false.</param>
public static void ValidateDirectoryExists(ConfigurationEntry Sender, ref object Value, out bool Valid) {
Valid = false;
if (Value == null)
return;
String val = Value.ToString();
// Accept empty strings
if (String.IsNullOrEmpty(val)) {
Valid = true;
return;
}
Valid = Directory.Exists(val);
}
/// <summary>
/// Generic validator for Double values. Includes constraint checking by respecting <see cref="Minimum"/> and <see cref="Maximum"/> values.
/// </summary>
/// <param name="Sender">The configuration entry for which the given <paramref name="Value"/> should be validated.</param>
/// <param name="Value">The value to validate.</param>
/// <param name="Valid">True if the value is valid or has been converted into a valid value, otherwise false.</param>
public static void ValidateDoubleValue(ConfigurationEntry Sender, ref object Value, out bool Valid) {
Valid = false;
// Value conversion
Double temp_value = 0.0;
if (Value is Double) {
Valid = true;
temp_value = (Double)Value;
} else if (Value != null && Double.TryParse(Value.ToString(), out temp_value)) {
Valid = true;
}
// Constraint checking
Double min = ToDouble(Sender.Minimum, Double.MinValue);
Double max = ToDouble(Sender.Maximum, Double.MaxValue);
if (Valid)
Valid = temp_value >= min && temp_value <= max;
// Transformation
if (Valid)
Value = temp_value;
}
FileSystemBrowser AddFileSystemBrowserToRow(ConfigurationEntry Entry, Int32 Row, Boolean IsDirectoryBrowser) {
FileSystemBrowser control = new FileSystemBrowser();
ApplyBasicControlSettings(control, Entry, 1, Row);
// Layout
control.Anchor = AnchorStyles.Left | AnchorStyles.Right;
// Content
control.IsDirectoryBrowser = IsDirectoryBrowser;
control.Value = Entry.ValueAsString;
control.ValueChanged += new EventHandler(control_ValueChanged);
return control;
}
bool SetEditor(ConfigurationEntry Sender, IWin32Window Owner) {
HasManyEditForm.SelectRecords(Owner, "Play around", this, "Set");
// Nothing else to save, the has-many-set has been saved by the edit form.
return false;
}
string entry_FormatValue(ConfigurationEntry Sender, object Value) {
String value_as_string = (Value == null ? "" : Value.ToString());
if (BoundObject == null)
return value_as_string;
String method_name = Sender.Name + "FormatValue";
Type t = GetDirectType(BoundObject);
MethodInfo method = t.GetMethod(method_name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (method == null)
return value_as_string;
return (string)method.Invoke(BoundObject, new object[] { Sender, Value });
}
void ApplyBasicControlSettings(Control Control, ConfigurationEntry Entry, Int32 Column, Int32 Row) {
if (Entry != null) {
Control.Tag = Entry;
Control.Enabled = !Entry.ReadOnly;
Control.Leave += new EventHandler(control_Leave);
}
Table.Controls.Add(Control);
Table.SetCellPosition(Control, new TableLayoutPanelCellPosition(Column, Row));
}
bool entry_Editor(ConfigurationEntry Sender, IWin32Window Owner) {
if (BoundObject == null)
return false;
String method_name = Sender.Name + "Editor";
Type t = GetDirectType(BoundObject);
MethodInfo method = t.GetMethod(method_name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (method == null)
return false;
return (bool)DirectInvoker.InvokeDirect(method, BoundObject, new object[] { Sender, Owner });
}
void entry_QueryPossibleValues(ConfigurationEntry Sender, out object[] PossibleValues) {
PossibleValues = null;
if (BoundObject == null)
return;
String property_name = Sender.Name + "PossibleValues";
Type t = GetDirectType(BoundObject);
PropertyInfo prop = t.GetProperty(property_name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (prop == null)
return;
PossibleValues = (object[])prop.GetValue(BoundObject, null);
}
protected ConfigurationEntry AddByPropertyWithAttribute(Object BoundObject, PropertyInfo Property) {
Object[] attrs = Property.GetCustomAttributes(typeof(ConfigurationAttribute), true);
if (attrs.Length <= 0)
return null;
ConfigurationAttribute attr = (ConfigurationAttribute)attrs[0];
ConfigurationEntry entry = new ConfigurationEntry();
entry.Name = Property.Name;
attr.ApplyToConfigurationEntry(entry);
if (BoundObject == null)
entry.Value = null;
else
entry.Value = Property.GetValue(BoundObject, null);
entry.PropertyChanged += new PropertyChangedEventHandler(entry_PropertyChanged);
entry.QueryPossibleValues += new ConfigurationEntry.QueryPossibleValuesEvent(entry_QueryPossibleValues);
entry.Editor += new ConfigurationEntry.EditorHandler(entry_Editor);
entry.FormatValue += new ConfigurationEntry.FormatValueHandler(entry_FormatValue);
if (entry.SortKey == 0)
entry.SortKey = Data.Count;
Add(entry);
return entry;
}
/// <summary>
/// Remove a <see cref="ConfigurationEntry"/> from the set.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool Remove(ConfigurationEntry key) {
return Data.Remove(key);
}
/// <summary>
/// Check if a <see cref="ConfigurationEntry"/> has already been added to the set.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool Contains(ConfigurationEntry key) {
return Data.Contains(key);
}
Button AddButtonToRow(ConfigurationEntry Entry, Int32 Row) {
Button btn = new Button();
ApplyBasicControlSettings(btn, Entry, 1, Row);
// Layout
btn.BackColor = SystemColors.ButtonFace;
// Content
btn.Text = "Ändern";
btn.Click += new EventHandler(btn_Click);
return btn;
}
TextBox AddTextBoxToRow(ConfigurationEntry Entry, Int32 Row) {
TextBox control = new TextBox();
ApplyBasicControlSettings(control, Entry, 1, Row);
// Layout
control.Anchor = AnchorStyles.Right | AnchorStyles.Left;
// Content
control.Text = Entry.ValueAsString;
control.TextChanged += new EventHandler(control_ValueChanged);
return control;
}
LabelSlider AddLabelSliderToRow(ConfigurationEntry Entry, Int32 Row) {
LabelSlider sld = new LabelSlider();
ApplyBasicControlSettings(sld, Entry, 1, Row);
// Layout
sld.Anchor = AnchorStyles.Right | AnchorStyles.Left;
// Content
sld.FormatValue += new LabelSlider.FormatValueEvent(sld_FormatValue);
sld.Minimum = ConfigurationEntry.ToInt32(Entry.Minimum, 0);
sld.Maximum = ConfigurationEntry.ToInt32(Entry.Maximum, 10);
sld.SmallChange = 1;
sld.LargeChange = Convert.ToInt32(Math.Round((Convert.ToDouble(sld.Maximum - sld.Minimum)) / 10.0));
sld.Value = ConfigurationEntry.ToInt32(Entry.Value, sld.Minimum);
sld.ValueChanged += new EventHandler(control_ValueChanged);
return sld;
}
TextBox AddMultilineBoxToRow(ConfigurationEntry Entry, Int32 Row) {
TextBox control = AddTextBoxToRow(Entry, Row);
control.Multiline = true;
control.Height = control.Height * 3;
control.ScrollBars = ScrollBars.Vertical;
control.WordWrap = true;
return control;
}
Boolean ValidateValueOfControl(Control Control, ConfigurationEntry Entry, ref Object Value) {
Boolean result = Entry.IsValueValid(ref Value);
if (result) {
Control.BackColor = SystemColors.Window;
if (AutoSave) {
Saving = true;
Entry.Value = Value;
Saving = false;
}
} else {
Control.BackColor = Color.Red;
}
return result;
}
ComboBox AddComboBoxToRow(ConfigurationEntry Entry, Int32 Row) {
ComboBox cbx = new ComboBox();
ApplyBasicControlSettings(cbx, Entry, 1, Row);
// Layout
cbx.Anchor = AnchorStyles.Right | AnchorStyles.Left;
// Content
cbx.DropDownStyle = ComboBoxStyle.DropDownList;
object[] values = Entry.GetPossibleValues();
if (values != null && values.Length > 0)
cbx.Items.AddRange(values);
if (Entry.Value != null)
cbx.SelectedIndex = cbx.Items.IndexOf(Entry.Value);
cbx.SelectedIndexChanged += new EventHandler(control_ValueChanged);
return cbx;
}
/// <summary>
///
/// </summary>
/// <param name="Text">Label text naming a property in a very short manner.</param>
/// <param name="SortKey">Using this the order of all configurable properties is determined.</param>
/// <param name="GroupKey">Configurable properties are grouped using this.</param>
/// <param name="ControlType">Defines the GUI control that should be used when editing a property.</param>
public ConfigurationAttribute(String Text, Int32 SortKey, Object GroupKey, ConfigurationEntry.ControlTypes ControlType) {
this.Text = Text;
this.SortKey = SortKey;
this.GroupKey = GroupKey;
this.ControlType = ControlType;
}
LinkLabel AddLinkLabelToRow(ConfigurationEntry Entry, Int32 Row) {
LinkLabel control = new LinkLabel();
ApplyBasicControlSettings(control, Entry, 1, Row);
// Layout
control.AutoSize = true;
control.Anchor = AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Bottom | AnchorStyles.Left;
control.TextAlign = ContentAlignment.TopLeft;
control.Margin = new Padding(
control.Margin.Left,
control.Margin.Top + (int)control.Font.Size,
control.Margin.Right,
control.Margin.Bottom);
control.AutoEllipsis = true;
// Content
var default_text = "<Bitte auswählen>";
control.Text = Entry.GetValueAsString(Entry.Value, default_text);
if (String.IsNullOrEmpty(control.Text)) // Empty strings hide the label and the user will not
control.Text = default_text; // be able to click on it anymore -- catch that here.
control.LinkClicked += new LinkLabelLinkClickedEventHandler(linklabel_LinkClicked);
return control;
}
/// <summary>
/// Generic validator for Int32 values. Includes constraint checking by respecting <see cref="Minimum"/> and <see cref="Maximum"/> values.
/// </summary>
/// <param name="Sender">The configuration entry for which the given <paramref name="Value"/> should be validated.</param>
/// <param name="Value">The value to validate.</param>
/// <param name="Valid">True if the value is valid or has been converted into a valid value, otherwise false.</param>
public static void ValidateInt32Value(ConfigurationEntry Sender, ref object Value, out bool Valid) {
Valid = false;
// Value conversion
Int32 temp_value = 0;
if (Value is Int32) {
Valid = true;
temp_value = (Int32)Value;
} else if (Value != null && Int32.TryParse(Value.ToString(), out temp_value)) {
Valid = true;
}
// Constraint checking
Int32 min = ToInt32(Sender.Minimum, Int32.MinValue);
Int32 max = ToInt32(Sender.Maximum, Int32.MaxValue);
if (Valid)
Valid = temp_value >= min && temp_value <= max;
// Transformation
if (Valid)
Value = temp_value;
}
CheckBox AddCheckBoxToRow(ConfigurationEntry Entry, Int32 Row) {
CheckBox cb = new CheckBox();
ApplyBasicControlSettings(cb, Entry, 1, Row);
// Layout
cb.Anchor = AnchorStyles.Right | AnchorStyles.Left;
// Content
cb.Text = Entry.Text;
cb.Checked = (Entry.Value == null ? false : Entry.Value is Boolean ? (Boolean)Entry.Value : Boolean.Parse(Entry.Value.ToString()));
cb.CheckedChanged += new EventHandler(control_ValueChanged);
return cb;
}
/// <summary>
/// Generic validator for Boolean values.
/// </summary>
/// <param name="Sender">The configuration entry for which the given <paramref name="Value"/> should be validated.</param>
/// <param name="Value">The value to validate.</param>
/// <param name="Valid">True if the value is valid or has been converted into a valid value, otherwise false.</param>
public static void ValidateBooleanValue(ConfigurationEntry Sender, ref object Value, out bool Valid) {
Valid = false;
if (Value == null || (Value is String && (String)Value == "")) {
Value = false;
Valid = true;
return;
}
Boolean bool_value;
if (Boolean.TryParse(Value.ToString(), out bool_value)) {
Value = bool_value;
Valid = true;
return;
}
}
Label AddLabelToRow(ConfigurationEntry Entry, Int32 Row) {
Label lbl = new Label();
ApplyBasicControlSettings(lbl, Entry, 1, Row);
// Layout
lbl.AutoSize = true;
lbl.Anchor = AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Bottom | AnchorStyles.Left;
lbl.TextAlign = ContentAlignment.TopLeft;
lbl.Margin = new Padding(
lbl.Margin.Left,
lbl.Margin.Top + (int)lbl.Font.Size,
lbl.Margin.Right,
lbl.Margin.Bottom);
lbl.AutoEllipsis = true;
// Content
lbl.Text = Entry.ValueAsString;
return lbl;
}
/// <summary>
/// Creates a new <see cref="Common.Configuration.ConfigurationEntry"/> according to the collection and
/// assigns it to the matrix.
/// </summary>
protected virtual void CreateAndAssignConfiguration() {
var config = new ConfigurationEntry();
config.Value = Collection.CollectionDictionaryWithValues;
config.PropertyChanged += new PropertyChangedEventHandler(config_PropertyChanged);
config.ValidateValue += new ConfigurationEntry.ValidateEvent(config_ValidateValue);
config.FormatValue += new ConfigurationEntry.FormatValueHandler(config_FormatValue);
Matrix.ConfigEntry = config;
}
Label AddSubTextLabelToRow(ConfigurationEntry Entry, Int32 Row) {
Label lbl = new Label();
ApplyBasicControlSettings(lbl, Entry, 1, Row);
// Layout
lbl.AutoSize = true;
lbl.Anchor = AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Bottom | AnchorStyles.Left;
lbl.TextAlign = ContentAlignment.TopLeft;
lbl.ForeColor = SystemColors.GrayText;
lbl.Margin = new Padding(lbl.Margin.Left, 0, lbl.Margin.Right,
9);
// Content
lbl.Text = Entry.SubText;
return lbl;
}
string config_FormatValue(ConfigurationEntry Sender, object Value) {
if (Value is IEditableDbRecord) {
// Column and row headers ...
return (Value as IEditableDbRecord).Name;
} else {
string result;
try {
result = (string)DirectInvoker.InvokeDirect(FormatValue, SelectedRecord, new object[] { Value });
} catch {
result = (Value == null ? "" : Value.ToString());
}
return result;
}
}
/// <summary>
/// Add a new <see cref="ConfigurationEntry"/> to the set.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
public ConfigurationEntry Add(ConfigurationEntry key, object value) {
key.Value = value;
Data.Add(key);
return key;
}
