/// <summary>
/// Adds the <see cref="IConfigurationItem"/> to the collection.
/// </summary>
/// <param name="item">The <see cref="IConfigurationItem"/> to add.</param>
public void Add(IConfigurationItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
IConfigurationItem oldItem = null;
if (Contains(item))
{
oldItem = this[item.Key];
Remove(oldItem);
(oldItem as IConfigurationItemAdvanced).Parent = null;
}
_Items.Add(item.Key, item);
(item as IConfigurationItemAdvanced).Parent = Parent;
MarkDirty();
if (oldItem == null)
{
RaiseCollectionChangedEvent(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
else
{
RaiseCollectionChangedEvent(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, item, oldItem));
}
}
protected virtual bool Load(IConfiguration Items)
{
//log.Debug("Load configuration: " + _URI);
if (_URI != "" && File.Exists(_URI))
{
_Configuration = new XmlDocument();
try
{
_Configuration.Load(_URI);
if (Items != null)
{
foreach (XmlNode node in _Configuration.DocumentElement.ChildNodes)
{
IConfigurationItem newItem = IConfigurationItemImpl.FromXml(node, _Source);
newItem.Name = string.Format("item-{0}", Items.Items.Count + 1);
Items.Items.Add(newItem);
}
}
return(true);
}
catch (Exception exc)
{
log.Debug(exc.ToString());
}
} //if (_URI != "" && File.Exists(_URI))
return(false);
} //protected virtual bool Load()
private void BulkImportForm_Load(object sender, EventArgs e)
{
IConfiguration conf = ConfigurationRepository.IConfiguration;
if (conf.GetConfigurationItem(UI_Constants.BulkImportFormSize) == null)
{
DefineConfigurationItems();
}
IConfigurationItem size = conf.GetConfigurationItem(UI_Constants.BulkImportFormSize);
this.Size = (size as IConfigurationItemObject <Size>).GetValue(this.Size);
IConfigurationItem location = conf.GetConfigurationItem(UI_Constants.BulkImportFormLocation);
this.Location = (location as IConfigurationItemObject <Point>).GetValue(this.Location);
//Make sure the form is shown on the visible screen
if (!Screen.GetWorkingArea(this).IntersectsWith(new Rectangle(this.Location, this.Size)))
{
this.Location = new Point(100, 100);
}
size = conf.GetConfigurationItem(UI_Constants.BulkImportFormSplitter1Location);
tvImport.Size = (size as IConfigurationItemObject <Size>).GetValue(tvImport.Size);
size = conf.GetConfigurationItem(UI_Constants.BulkImportFormSplitter2Location);
propDestination.Size = (size as IConfigurationItemObject <Size>).GetValue(propDestination.Size);
}
/// <summary>
/// Handled the <see cref="NotificationState"/> changed.
/// Updates the <see cref="IConfigurationItem"/>.
/// </summary>
/// <param name="notificationState">State of the notification.</param>
/// <param name="configItem">The configuration item.</param>
/// <param name="propertyName">Name of the property.</param>
private void NotificationStateChanged(NotificationState notificationState, IConfigurationItem configItem, string propertyName)
{
if (propertyName == nameof(NotificationState.IsNotUseGlobalSettingsForParentListActive))
{
return;
}
var connectorNotificationConfiguration = new ConnectorNotificationConfiguration();
connectorNotificationConfiguration.UseGlobalNotificationSettings = notificationState.ParentList.First(i => i.IsUseGlobalSettings).IsActive;
foreach (var item in notificationState.ParentList)
{
if (item.IsUseGlobalSettings)
{
continue;
}
connectorNotificationConfiguration.AssignFromObeservationStateActivity(item.ObservationState, item.IsActive);
}
var settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto, NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None
};
configItem.Value = JsonConvert.SerializeObject(connectorNotificationConfiguration, settings);
}
bool IConfiguration.Refresh(IConfigurationItem item)
{
if (item != null)
{
foreach (IConfigurationSource source in _ConfigurationSources)
{
source.SetConfigurationItem(item);
}
#region Set ConfigurationItem Value from Command line
foreach (ICommandlineItem cli in _CommandlineItems)
{
if (cli.Name == item.Name && cli.Found)
{
item.SetValue(cli.Value, eConfigurationSource.CmdLine);
break;
} //if (cli.Name == item.Name)
}
#endregion
} //if (item != null)
else
{
foreach (IConfigurationItem ci in _RootConfigurationItem.ConfigurationItems)
{
Interface.Refresh(ci);
}
}
return(false);
} //bool IConfiguration.Refresh(IConfigurationItem item)
private void LinkDataDefinitionsForm_Load(object sender, System.EventArgs e)
{
IConfiguration conf = ConfigurationRepository.IConfiguration;
if (conf.GetConfigurationItem(UI_Constants.DataDefinitionFormSize) == null)
{
DefineConfigurationItems();
}
IConfigurationItem size = conf.GetConfigurationItem(UI_Constants.DataDefinitionFormSize);
this.Size = (size as IConfigurationItemObject <Size>).GetValue(this.Size);
IConfigurationItem location = conf.GetConfigurationItem(UI_Constants.DataDefinitionFormLocation);
this.Location = (location as IConfigurationItemObject <Point>).GetValue(this.Location);
//Make sure the form is shown on the visible screen
if (!Screen.GetWorkingArea(this).IntersectsWith(new Rectangle(this.Location, this.Size)))
{
this.Location = new Point(100, 100);
}
size = conf.GetConfigurationItem(UI_Constants.DataDefinitionFormSplitterLocation);
lbxAvailable.Size = (size as IConfigurationItemObject <Size>).GetValue(lbxAvailable.Size);
}
private static IEmbeddedConfiguration NewEmbeddedConfiguration(IConfigurationItem support)
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.Add(support);
return(config);
}
} //protected XmlNode GetXmlNode(XmlDocument doc)
protected XmlNode AddSubNode(IConfigurationItem item, XmlNode node)
{
XmlNode result = node.OwnerDocument.CreateNode(XmlNodeType.Element, item.Name, "");
XmlAttribute definition = null;
if (result.Attributes[tag_definition_attribute] == null)
{
definition = node.OwnerDocument.CreateAttribute(tag_definition_attribute);
result.Attributes.Append(definition);
}
else
{
definition = result.Attributes[tag_definition_attribute];
}
definition.InnerText = item.ConfigurationItemValueType.ToString();
definition = null;
if (result.Attributes[tag_key_attribute] == null)
{
definition = node.OwnerDocument.CreateAttribute(tag_key_attribute);
result.Attributes.Append(definition);
}
else
{
definition = result.Attributes[tag_key_attribute];
}
definition.InnerText = item.StorageKey;
definition = null;
if (result.Attributes[tag_type_attribute] == null)
{
definition = node.OwnerDocument.CreateAttribute(tag_type_attribute);
result.Attributes.Append(definition);
}
else
{
definition = result.Attributes[tag_type_attribute];
}
definition.InnerText = item.Type;
node.AppendChild(result);
if (item.ConfigurationItems.Count > 0)
{
foreach (IConfigurationItem it in item.ConfigurationItems)
{
AddSubNode(it, result);
}
}
else
{
result.InnerText = item.Value;
}
return(result);
} //protected XmlNode AddSubNode(IConfigurationItem item, XmlNode node)
public void SerializeProjectDetectorConfiguration()
{
// Open a project
IProject project1 = TestFramework.ProjectManager.CreateProject(ProjectPath, ProjectInvestigator, DateTime.Now, ProjectDescription);
// Change detector configuration
IDetector mockConfigurableDetector = TestFramework.DetectorFactory.Detectors.Single(detector => detector.Name == "MockConfigurableDetector");
IConfigurationItem configurationItem = (mockConfigurableDetector as IConfigurable).Configuration.ElementAt(0);
Assert.That((int)configurationItem.Value, Is.EqualTo(123));
configurationItem.SetUserValue("456");
Assert.That((int)configurationItem.Value, Is.EqualTo(456));
// Save the project containing the detector configuration
TestFramework.ProjectManager.SaveProject(project1);
TestFramework.ProjectManager.CloseProject(project1);
// Change the detector configuration
configurationItem.SetUserValue("123");
// Check the change made
Assert.That((int)configurationItem.Value, Is.EqualTo(123));
// Open project
IProject project2 = TestFramework.ProjectManager.OpenProject(ProjectPath);
// Check the detector configuration
Assert.That((int)configurationItem.Value, Is.EqualTo(456));
TestFramework.ProjectManager.CloseProject(project2);
}
protected override void WndProc(ref Message m)
{
//log.Debug(string.Format("0x{0}", m.Msg.ToString("X4")));
base.WndProc(ref m);
if (m.Msg == WM_SHOWWINDOW)
{
if (!DesignMode && _Persistence != ePersistence.None && conf != null)
{
IConfigurationItem item = conf.GetConfigurationItem(Name);
if (item == null)
{
DefineConfiguration();
item = conf.GetConfigurationItem(Name);
}
List <string> items = new List <string>();
foreach (IConfigurationItem val in item.ConfigurationItems)
{
items.Add(val.Value);
}
Items.AddRange(items.ToArray());
SelectedIndex = conf.GetConfigurationValue((this as IConfigurationControl).ConfigurationName(), -1);
OnTextChanged(new EventArgs());
}
}
}
void IPgConnectionStash.PersistConnections(IConfigurationItem node, eConfigurationSource configurationSource)
{
foreach (IPgConnection dbCon in _DbSettings.Values)
{
if (dbCon.Persist)
{
log.Debug("Persist database connection: " + dbCon.ToString());
IConfigurationItem item = new IConfigurationItemImpl("item" + Convert.ToString(node.ConfigurationItems.Count + 1), "", configurationSource);
node.AddConfigurationItem(item);
item.AddConfigurationItem(new IConfigurationItemImpl("name", dbCon.Name, configurationSource));
item.AddConfigurationItem(new IConfigurationItemImpl("server", dbCon.Server, configurationSource));
item.AddConfigurationItem(new IConfigurationItemImpl("port", dbCon.Port, configurationSource));
item.AddConfigurationItem(new IConfigurationItemImpl("database", dbCon.Database, configurationSource));
item.AddConfigurationItem(new IConfigurationItemImpl("user", dbCon.User, configurationSource));
IConfigurationItem keyIt = new IConfigurationItemImpl("password", "", configurationSource);
keyIt.StorageKey = "system";
keyIt.Configuration = node.Configuration;
keyIt.SetValue(dbCon.Password);
item.AddConfigurationItem(keyIt);
}
}
}
public void Save()
{
IConfiguration conf = ConfigurationRepository.IConfiguration;
if (conf.GetConfigurationItem(UI_Constants.ForeColor1) == null)
{
DefineConfiguration();
}
for (int i = 1; i < ForeColors.Length; i++)
{
IConfigurationItem color = null;
color = conf.GetConfigurationItem(UI_Constants.ForeColor + i.ToString());
(color as IConfigurationItemObject <Color>).SetValue(ForeColors[i]);
color = conf.GetConfigurationItem(UI_Constants.BackColor + i.ToString());
(color as IConfigurationItemObject <Color>).SetValue(BackColors[i]);
}
if (OnUpdated != null)
{
OnUpdated(this, new EventArgs());
}
}
void IPgConnectionStash.RetreiveConnections(IConfigurationItem node)
{
foreach (IConfigurationItem item in node.ConfigurationItems)
{
IPgConnection dbCon = new PgConnection();
foreach (IConfigurationItem it in item.ConfigurationItems)
{
it.Configuration = node.Configuration;
switch (it.Name)
{
case "name": dbCon.Name = it.Value; break;
case "server": dbCon.Server = it.Value; break;
case "port": dbCon.Port = it.Value; break;
case "database": dbCon.Database = it.Value; break;
case "user": dbCon.User = it.Value; break;
case "password": dbCon.Password = it.GetValue(""); break;
}
}
dbCon.Persist = true;
if (!_DbSettings.Keys.Contains <string>(dbCon.Name))
{
log.Debug("Retrieve database connection: " + dbCon.ToString());
_DbSettings.Add(dbCon.Name, dbCon);
}
}
}
public static void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is IntegerConfigurationItem) && (control is System.Windows.Forms.NumericUpDown))
{
((IntegerConfigurationItem)item).Value = (int)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is LongConfigurationItem) && (control is System.Windows.Forms.NumericUpDown))
{
((LongConfigurationItem)item).Value = (long)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is FloatConfigurationItem) && (control is System.Windows.Forms.NumericUpDown))
{
((FloatConfigurationItem)item).Value = (float)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is DoubleConfigurationItem) && (control is System.Windows.Forms.NumericUpDown))
{
((DoubleConfigurationItem)item).Value = (double)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is BoolConfigurationItem) && (control is System.Windows.Forms.CheckBox))
{
((BoolConfigurationItem)item).Value = (bool)((System.Windows.Forms.CheckBox)control).Checked;
}
if ((item is StringOptionUniqueConfigurationItem) && (control is System.Windows.Forms.ComboBox))
{
((StringOptionUniqueConfigurationItem)item).Selection = (string)((System.Windows.Forms.ComboBox)control).SelectedItem;
}
}
public MethodsFromModelForm(IBaseNode selectedNode)
{
InitializeComponent();
lbxAvailable.DrawItem += lbxAvailable_DrawItem;
lbxSelected.DrawItem += lbxAvailable_DrawItem;
IDecisionTree tree = selectedNode.Tree;
AddMethodsToAvailable(tree.RootNode);
//Add Stock methods
IConfigurationItem stockMethods = ConfigurationRepository.IConfiguration.GetConfigurationItem(UI_Constants.StockMethods);
if (stockMethods != null)
{
foreach (IConfigurationItem it in stockMethods.ConfigurationItems)
{
if (!HasItem(it.GetValue("")))
{
lbxAvailable.Items.Add(new ListBoxItem(it.GetValue(""), 1));
}
}
}
toolTip.SetToolTip(btnOk, UI_Constants.CommitEnumToolTip);
toolTip.SetToolTip(btnClose, UI_Constants.RevertEnumToolTip);
toolTip.SetToolTip(btnAdd, UI_Constants.AddEnumToolTip);
toolTip.SetToolTip(btnRemove, UI_Constants.RemoveEnumToolTip);
toolTip.SetToolTip(btnNew, UI_Constants.NewEnumToolTip);
toolTip.SetToolTip(btnMoveUp, UI_Constants.MoveUpEnumToolTip);
toolTip.SetToolTip(btnMoveDown, UI_Constants.MoveDownEnumToolTip);
}
/// <summary>
/// Creates a new control and returns it.
/// </summary>
/// <param name="configItem">The configuration item.</param>
/// <param name="configItemAttribute">The configuration item attribute.</param>
/// <returns>
/// Returns the <see cref="FrameworkElement" /> for the <see cref="configItem" />.
/// </returns>
public override FrameworkElement GetControlInternal(IConfigurationItem configItem, ConfigurationItemAttribute configItemAttribute)
{
var stackPanel = new StackPanel();
stackPanel.Orientation = Orientation.Horizontal;
stackPanel.Margin = new Thickness(0, 0, 0, 0);
stackPanel.VerticalAlignment = VerticalAlignment.Center;
var checkBox = new CheckBox();
checkBox.DataContext = configItem;
var style = Application.Current.FindResource("MaterialDesignSwitchToggleButton") as Style;
checkBox.Style = style;
checkBox.Margin = new Thickness(2, 8, 0, 8);
stackPanel.Children.Add(checkBox);
var label = new Label();
label.Content = configItemAttribute.Caption;
label.Margin = new Thickness(8, 8, 0, 8);
label.Padding = new Thickness(0, 0, 0, 0);
label.VerticalAlignment = VerticalAlignment.Center;
stackPanel.Children.Add(label);
return(stackPanel);
}
public static void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemInteger) && (control is System.Windows.Forms.NumericUpDown))
{
((ConfigurationItemInteger)item).Value = (int)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is ConfigurationItemLong) && (control is System.Windows.Forms.NumericUpDown))
{
((ConfigurationItemLong)item).Value = (long)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is ConfigurationItemFloat) && (control is System.Windows.Forms.NumericUpDown))
{
((ConfigurationItemFloat)item).Value = (float)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is ConfigurationItemDouble) && (control is System.Windows.Forms.NumericUpDown))
{
((ConfigurationItemDouble)item).Value = (double)((System.Windows.Forms.NumericUpDown)control).Value;
}
if ((item is ConfigurationItemBool) && (control is System.Windows.Forms.CheckBox))
{
((ConfigurationItemBool)item).Value = (bool)((System.Windows.Forms.CheckBox)control).Checked;
}
if ((item is ConfigurationItemOptionUnique) && (control is System.Windows.Forms.ComboBox))
{
((ConfigurationItemOptionUnique)item).Selection = (string)((System.Windows.Forms.ComboBox)control).SelectedItem;
}
}
private bool CheckItemRecursive(IConfigurationItem configurationItem,
IConfigurationItem configurationItemToCheck)
{
if ((configurationItem is IItemsGroup) && (configurationItemToCheck is IItemsGroup))
{
if ((configurationItem.Name == configurationItemToCheck.Name) &&
((IItemsGroup)configurationItem).ConfigurationItemList.Count ==
((IItemsGroup)configurationItemToCheck).ConfigurationItemList.Count)
{
foreach (IConfigurationItem item in (configurationItem as IItemsGroup)
.ConfigurationItemList)
{
if (!CheckItemRecursive(item,
((IItemsGroup)configurationItemToCheck).ConfigurationItemList[
((IItemsGroup)configurationItem).ConfigurationItemList.IndexOf(item)]))
{
return(false);
}
}
}
else
{
return(false);
}
}
else
{
return(configurationItem.Name == configurationItemToCheck.Name);
}
return(true);
}
/// <summary>
/// Accept the changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonOKClick(object sender, EventArgs e)
{
foreach (Control control in tabControlConfiguration.Controls)
{
if (!(control is TabPage))
{
continue;
}
foreach (Control tableLayoutControl in control.Controls)
{
TableLayoutPanel tableLayoutPanel = tableLayoutControl as TableLayoutPanel;
if (tableLayoutPanel == null)
{
continue;
}
for (int rowIndex = 1; rowIndex < tableLayoutPanel.RowCount; rowIndex++)
{
TextBox userValue = tableLayoutPanel.GetControlFromPosition(2, rowIndex) as TextBox;
IConfigurationItem configurationItem = userValue.Tag as IConfigurationItem;
configurationItem.SetUserValue(userValue.Text);
}
}
}
}
private void btnOk_Click(object sender, EventArgs e)
{
IConfiguration conf = ConfigurationRepository.IConfiguration;
IConfigurationItem recentDomainTemplates = conf.GetConfigurationItem(UI_Constants.RecentDomainTemplates);
// truncate actual config file storage
recentDomainTemplates.ConfigurationItems.Clear();
// Fill the new config file storage
if (selectedDomainModelFile != "")
{
string itemName = string.Format("item-{0}", recentDomainTemplates.ConfigurationItems.Count + 1);
recentDomainTemplates.AddConfigurationItem(new IConfigurationItemImpl(itemName, selectedDomainModelFile, UI_Constants.ConfigurationSource));
ListViewItem item = GetListViewItem(selectedDomainModelFile);
if (item != null)
{
RecentFilesListView.Items.Remove(item);
}
}
int index = 0;
while (recentDomainTemplates.ConfigurationItems.Count < 10 && RecentFilesListView.Items.Count > index)
{
string domainTemplate = RecentFilesListView.Items[index++].Tag.ToString();
string itemName = string.Format("item-{0}", recentDomainTemplates.ConfigurationItems.Count + 1);
recentDomainTemplates.AddConfigurationItem(new IConfigurationItemImpl(itemName, domainTemplate, UI_Constants.ConfigurationSource));
}
conf.Save();
}
private void ExecuteSetConfigItemStatus(object param)
{
if (_disposed)
{
return;
}
if (_isChangingConfig)
{
return;
}
_isChangingConfig = true;
ComboBox box = (ComboBox)param;
IConfigurationItem item = (IConfigurationItem)box.DataContext;
ConfigurationStatus newStatus = (ConfigurationStatus)box.SelectedItem;
var itemSetResult = item.SetStatus(newStatus, "ConfigurationEditor");
if (!itemSetResult.Success)
{
RaiseUserError("Couldn't set item", String.Format("Could not set {0} to {2}, as it would cause the following error:\n\n{1}",
_serviceInfoManager.GetDescriptionOfServiceOrPluginFullName(item.ServiceOrPluginFullName),
itemSetResult.Describe(),
newStatus.ToString())
);
}
_isChangingConfig = false;
box.GetBindingExpression(ComboBox.SelectedItemProperty).UpdateTarget();
}
protected override void Dispose(bool disposing)
{
if (!DesignMode && _Persistence != ePersistence.None && conf != null)
{
IConfigurationItem list = conf.GetConfigurationItem(Name);
if (list == null)
{
DefineConfiguration();
list = conf.GetConfigurationItem(Name);
}
if (list != null)
{
list.Clear();
foreach (string elem in Items)
{
list.AddConfigurationItem(new IConfigurationItemImpl("item" + Convert.ToString(list.ConfigurationItems.Count + 1), elem, _ConfigurationSource));
}
}
if ((this as IConfigurationControl).ConfigurationName() != "")
{
ConfigurationRepository.IConfiguration.SetConfigurationValue((this as IConfigurationControl).ConfigurationName(), SelectedIndex);
}
conf.Save();
}
base.Dispose(disposing);
}
private static void Trace(IConfigurationItem item)
{
if (item == null)
{
return;
}
Console.WriteLine(item.ServiceName + ": " + item.Url);
}
public object Clone()
{
IConfigurationItem configurationItem = OnCloning();
configurationItem.Description = Description;
configurationItem.Name = Name;
return(configurationItem);
}
/// <summary>
/// Removes the specified <see cref="IConfigurationItem"/> from the collection.
/// </summary>
/// <param name="item">The <see cref="IConfigurationItem"/> to remove.</param>
/// <returns><b>True</b> if the <see cref="IConfigurationItem"/> was removed; otherwise <b>false</b>. This method returns <b>false</b> if the key was not found.</returns>
public bool Remove(IConfigurationItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
return(Remove(item.Key));
}
// EVENTS PROPAGATION
public void TextStyleChanged(Object sender, IConfigurationItem item)
{
LoggerWindowedConfiguration configuration = ((LoggerWindowedConfiguration)this.Configuration);
ConfigurationItemTextStyle configurationitem = ((ConfigurationItemTextStyle)configuration.findProperty(configuration.idTextStyle));
_window.PropagateFont(configurationitem.Value.Font);
_window.PropagateForeColor(configurationitem.Value.Foreground);
_window.PropagateBackColor(configurationitem.Value.Background);
}
public static void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
foreach (IUserInterfaceMapper mapper in _repository)
{
mapper.UpdateConfigurationItemFromControl(item, control);
}
//throw new ConfigurationException();
}
/// <summary>
/// Determines whether the collection contains a specific <see cref="IConfigurationItem"/>.
/// </summary>
/// <param name="item">The <see cref="IConfigurationItem"/> to locate.</param>
/// <returns><b>True</b> if the <see cref="IConfigurationItem"/> is found; otherwise, <b>false</b>.</returns>
public bool Contains(IConfigurationItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
return(_Items.ContainsKey(item.Key));
}
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if (control is System.Windows.Forms.Label)
{
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemTimeSpan) && (control is QIT.Common.Controls.TimeSpanShower))
{
((ConfigurationItemTimeSpan)item).Value = (TimeSpan)((QIT.Common.Controls.TimeSpanShower)control).Value;
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemString) && (control is System.Windows.Forms.TextBox))
{
((ConfigurationItemString)item).Value = (string)((System.Windows.Forms.TextBox)control).Text;
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
} // EditorPriority
public IConfigurationItemEditor CreateEditor(IConfigurationItem data)
{
var editor = new Editors.UiBroadcastListSettingsEditor()
{
Settings = data as UiBroadcastListSettings
};
return(editor);
} // CreateEditor
} // EditorPriority
public IConfigurationItemEditor CreateEditor(IConfigurationItem data)
{
var editor = new Editors.TvPlayersSettingsEditor()
{
Settings = data as TvPlayersSettings
};
return(editor);
} // CreateEditor
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemTextStyle) && (control is QIT.Common.Controls.TextStyleShower))
{
((ConfigurationItemTextStyle)item).Value = (QIT.Common.Abstraction.TextStyle)((QIT.Common.Controls.TextStyleShower)control).TextStyle;
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
/// <summary>
/// Creates a new control and returns it.
/// </summary>
/// <param name="configItem">The configuration item of the connector.</param>
/// <param name="configItemAttribute">The configuration item attribute.</param>
/// <returns>
/// Returns the <see cref="FrameworkElement" /> for the <see cref="configItem" />.
/// </returns>
public override FrameworkElement GetControlInternal(IConfigurationItem configItem, ConfigurationItemAttribute configItemAttribute)
{
var numericTextBox = base.GetControlInternal(configItem, configItemAttribute);
numericTextBox.PreviewTextInput += this.NumberValidationTextBox;
numericTextBox.Width = 150;
numericTextBox.HorizontalAlignment = HorizontalAlignment.Left;
return(numericTextBox);
}
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemDouble) && (control is System.Windows.Forms.NumericUpDown))
{
((ConfigurationItemDouble)item).Value = (double)((System.Windows.Forms.NumericUpDown)control).Value;
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
void IConfiguration.SetConfigurationValue(string path, bool newValue)
{
IConfigurationItem item = _RootConfigurationItem.GetConfigurationItem(path);
if (item != null)
{
item.SetValue(newValue);
}
}
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemBool) && (control is System.Windows.Forms.CheckBox))
{
((ConfigurationItemBool)item).Value = (bool)((System.Windows.Forms.CheckBox)control).Checked;
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
} // EditorPriority
public IConfigurationItemEditor CreateEditor(IConfigurationItem data)
{
var editor = new Editors.NetworkSettingsEditor()
{
Settings = data as NetworkSettings
};
return(editor);
} // CreateEditor
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemOptionUnique) && (control is System.Windows.Forms.ComboBox))
{
((ConfigurationItemOptionUnique)item).Selection = (string)((System.Windows.Forms.ComboBox)control).SelectedItem;
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
/// <summary>
/// Initializes a new instance of the <see cref="WordTableWorkItem"/> class.
/// </summary>
/// <param name="table">Table to wrap.</param>
/// <param name="workItemType">Work item to wrap.</param>
/// <param name="configuration">Configuration of all work items</param>
/// <param name="configurationItem">The configuration of this work item</param>
/// <exception cref="ConfigurationException">Thrown if the configuration contains invalid cell column or row for standard fields.</exception>
internal WordTableWorkItem(Table table, string workItemType, IConfiguration configuration, IConfigurationItem configurationItem)
{
if (table == null)
{
throw new ArgumentNullException("table");
}
if (workItemType == null)
{
throw new ArgumentNullException("workItemType");
}
if (configurationItem == null)
{
throw new ArgumentNullException("configurationItem");
}
Table = table;
TableStart = table.Range.Start;
WorkItemType = workItemType;
_configuration = configuration;
_configurationItem = configurationItem.Clone();
// Create fields
IList <IField> fields = new List <IField>();
foreach (var fieldItem in _configurationItem.FieldConfigurations)
{
if (fieldItem.IsMapped)
{
var cellRange = WordSyncHelper.GetCellRange(Table, fieldItem.RowIndex, fieldItem.ColIndex);
if (fieldItem.FieldValueType == FieldValueType.BasedOnVariable || fieldItem.FieldValueType == FieldValueType.BasedOnSystemVariable)
{
fields.Add(new StaticValueField(cellRange, fieldItem, true));
}
else
{
fields.Add(new WordTableField(cellRange, fieldItem, _configurationItem.GetConverter(fieldItem.ReferenceFieldName), true));
}
}
else
{
// Initialize unmapped fields with default values
var hiddenField = new HiddenField(fieldItem, _configurationItem.GetConverter(fieldItem.ReferenceFieldName));
if (fieldItem.DefaultValue != null)
{
hiddenField.Value = fieldItem.DefaultValue.DefaultValue;
}
fields.Add(hiddenField);
}
}
Fields = new WordTableFieldCollection(fields);
IsNew = Id <= 0;
}
public static System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
System.Windows.Forms.Control result=null;
foreach (IUserInterfaceMapper mapper in _repository)
{
result = mapper.mapConfigurationItemIntoControl(item);
if (result != null)
{
return result;
}
}
throw new ConfigurationException();
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemBool)
{
System.Windows.Forms.CheckBox typedControl = new System.Windows.Forms.CheckBox();
typedControl.Checked = ((ConfigurationItemBool)item).Value;
return typedControl;
}
else
{
return null;
}
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemString)
{
System.Windows.Forms.TextBox typedControl = new System.Windows.Forms.TextBox();
typedControl.Text = ((ConfigurationItemString)item).Value;
return typedControl;
}
else
{
return null;
}
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemTextStyle)
{
QIT.Common.Controls.TextStyleShower typedControl = new QIT.Common.Controls.TextStyleShower();
typedControl.TextStyle = ((ConfigurationItemTextStyle)item).Value;
return typedControl;
}
else
{
return null;
}
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemChar)
{
System.Windows.Forms.TextBox typedControl = new System.Windows.Forms.TextBox();
typedControl.MaxLength = 1;
typedControl.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
typedControl.Text = ((ConfigurationItemChar)item).Value.ToString();
return typedControl;
}
else
{
return null;
}
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemTimeSpan)
{
QIT.Common.Controls.TimeSpanShower typedControl = new QIT.Common.Controls.TimeSpanShower();
typedControl.MaxValue = ((ConfigurationItemTimeSpan)item).MaxValue;
typedControl.MinValue = ((ConfigurationItemTimeSpan)item).MinValue;
typedControl.Value = ((ConfigurationItemTimeSpan)item).Value;
return typedControl;
}
else
{
return null;
}
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemOptionUnique)
{
System.Windows.Forms.ComboBox typedControl = new System.Windows.Forms.ComboBox();
typedControl.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
foreach (string option in ((ConfigurationItemOptionUnique)item).Options)
{ typedControl.Items.Add(option); };
typedControl.SelectedItem = ((ConfigurationItemOptionUnique)item).Selection;
return typedControl;
}
else
{
return null;
}
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemDouble)
{
System.Windows.Forms.NumericUpDown typedControl = new System.Windows.Forms.NumericUpDown();
typedControl.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
// First assign the extremes, and then the value
typedControl.Maximum = (decimal)((ConfigurationItemDouble)item).MaxValue;
typedControl.Minimum = (decimal)((ConfigurationItemDouble)item).MinValue;
typedControl.Value = (decimal)((ConfigurationItemDouble)item).Value;
typedControl.DecimalPlaces = 6;
typedControl.Increment = (decimal)0.0001;
return typedControl;
}
else
{
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="vConfigurationItem"></param>
public ConfigurationForm(IConfigurationItem vConfigurationItem)
{
InitializeComponent();
mConfigurationItem = vConfigurationItem;
int vHeight, vWidth;
if (mConfigurationItem.HasControlPanel)
{
vHeight = Math.Max(vConfigurationItem.ControlPanel.Height, vConfigurationItem.ContentPanel.Height);
vWidth = vConfigurationItem.ControlPanel.Width + vConfigurationItem.ContentPanel.Width;
}
else
{
vHeight = vConfigurationItem.ContentPanel.Height;
vWidth = vConfigurationItem.ContentPanel.Width;
}
Size = new Size(vWidth, vHeight + 20);
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
if (item is ConfigurationItemQuantumState)
{
QIT.Physics.Controls.QuantumStateShower typedControl = new QIT.Physics.Controls.QuantumStateShower();
//IClassicBasisElement element0 = ClassicBasisFactory.UsualBasis.getElement(0);
//IClassicBasisElement element1 = ClassicBasisFactory.UsualBasis.getElement(1);
//IClassicStateDebugger debugger0 = ClassicBasisFactory.UsualBasis.getState(0).Debugger;
//IClassicStateDebugger debugger1 = ClassicBasisFactory.UsualBasis.getState(1).Debugger;
//typedControl.textBox0ID.Text = element0.GetID();
//typedControl.textBox1ID.Text = element1.GetID();
//typedControl.numericUpDown0Value.Value = (decimal)debugger0.getValue();
//typedControl.numericUpDown1Value.Value = (decimal)debugger1.getValue();
return typedControl;
}
else
{
return null;
}
}
public override void UpdateConfigurationItemFromControl(IConfigurationItem item, System.Windows.Forms.Control control)
{
if ((item is ConfigurationItemQuantumState) && (control is QIT.Physics.Controls.QuantumStateShower))
{
//((ConfigurationItemTimeSpan)item).Value = (TimeSpan)((QIT.Physics.Controls.QuantumStateShower)control).Value;
//IClassicBasisElement element0 = ClassicBasisFactory.UsualBasis.getElement(0);
//IClassicBasisElement element1 = ClassicBasisFactory.UsualBasis.getElement(1);
//IClassicStateDebugger debugger0 = ClassicBasisFactory.UsualBasis.getState(0).Debugger;
//IClassicStateDebugger debugger1 = ClassicBasisFactory.UsualBasis.getState(1).Debugger;
//element0.setID(textBox0ID.Text);
//element1.setID(textBox1ID.Text);
//debugger0.setValue((double)numericUpDown0Value.Value);
//debugger1.setValue((double)numericUpDown1Value.Value);
return;
}
//base.UpdateConfigurationItemFromControl(item, control);
}
public void Add(IConfigurationItem item)
{
item.Prepare(this);
SafeConfigurationItems().Put(item, item);
}
public ConfigurationItemViewModel(IConfigurationItem configurationItem)
{
this.ConfigItem = configurationItem.Key;
this.ConfigValue = (configurationItem.Value == null) ? string.Empty : configurationItem.Value.ToString();
this.IsWritable = (configurationItem is ReadWriteItem<bool> ||
configurationItem is ReadWriteItem<int> ||
configurationItem is ReadWriteItem<float> ||
configurationItem is ReadWriteItem<Enum> ||
configurationItem is ReadWriteItem<string>).ToString();
}
private void PropagateConfigurationChange(Object sender, IConfigurationItem item)
{
CheckAlgortihmConfiguration();
}
private static IEmbeddedConfiguration NewEmbeddedConfiguration(IConfigurationItem support)
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.Add(support);
return config;
}
public override System.Windows.Forms.Control mapConfigurationItemIntoControl(IConfigurationItem item)
{
return null;
}
public virtual void Add(IConfigurationItem configurationItem)
{
_config.Add(configurationItem);
}
public abstract bool Equals(IConfigurationItem configuration);
private void AssertPerformanceCounterInstanceLifetime(IConfigurationItem support, Action<IObjectContainer> action)
{
using (IObjectContainer db = Db4oEmbedded.OpenFile(NewEmbeddedConfiguration(support), TempFile()))
{
action(db);
Assert.IsTrue(PerformanceCounterCategory.InstanceExists(TempFile(), Db4oPerformanceCounters.CategoryName));
}
Assert.IsFalse(PerformanceCounterCategory.InstanceExists(TempFile(), Db4oPerformanceCounters.CategoryName));
}
