void Initialize(bool bInit)
{
if (_view != null)
{
_view.ShowLine = true;
_view.LinePen = _doc.AxisPen;
_view.MajorPen = _doc.MajorPen;
_view.MinorPen = _doc.MinorPen;
_view.MajorTickLength = _doc.MajorTickLength;
_view.MinorTickLength = _doc.MinorTickLength;
SelectableListNodeList list = new SelectableListNodeList();
list.Clear();
if (_doc.CachedAxisInformation != null)
{
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstDownSide, null, _doc.FirstDownMajorTicks));
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstUpSide, null, _doc.FirstUpMajorTicks));
}
_view.MajorPenTicks = list;
list.Clear();
if (_doc.CachedAxisInformation != null)
{
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstDownSide, null, _doc.FirstDownMinorTicks));
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstUpSide, null, _doc.FirstUpMinorTicks));
}
_view.MinorPenTicks = list;
}
}
void Initialize(bool bInit)
{
if (_view != null)
{
_view.ShowLine = true;
_view.LinePen = _doc.AxisPen;
_view.MajorPen = _doc.MajorPen;
_view.MinorPen = _doc.MinorPen;
_view.MajorTickLength = _doc.MajorTickLength;
_view.MinorTickLength = _doc.MinorTickLength;
SelectableListNodeList list = new SelectableListNodeList();
list.Clear();
if (_doc.CachedAxisInformation != null)
{
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstDownSide, null, _doc.FirstDownMajorTicks));
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstUpSide, null, _doc.FirstUpMajorTicks));
}
_view.MajorPenTicks = list;
list.Clear();
if (_doc.CachedAxisInformation != null)
{
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstDownSide, null, _doc.FirstDownMinorTicks));
list.Add(new SelectableListNode(_doc.CachedAxisInformation.NameOfFirstUpSide, null, _doc.FirstUpMinorTicks));
}
_view.MinorPenTicks = list;
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
_xColumn = _doc.RowHeaderColumn;
_yColumn = _doc.ColumnHeaderColumn;
// Initialize value columns
_valueColumns.Clear();
for (int i = 0; i < _doc.ColumnCount; ++i)
{
var col = _doc.GetDataColumnProxy(i);
_valueColumns.Add(new SelectableListNode(col.Document != null ? col.Document.FullName : "Unresolved column", col, false));
}
CalcMaxPossiblePlotRangeTo();
// Initialize tables
string[] tables = Current.Project.DataTableCollection.GetSortedTableNames();
string dataTableName = _doc.DataTable == null ? string.Empty : _doc.DataTable.Name;
_availableTables.Clear();
foreach (var tableName in tables)
{
_availableTables.Add(new SelectableListNode(tableName, Current.Project.DataTableCollection[tableName], dataTableName == tableName));
}
// Initialize columns
FillAvailableColumnList();
_rowsController = new Common.AscendingIntegerCollectionController();
_rowsController.InitializeDocument(_doc.ParticipatingDataRows.Clone());
}
if (null != _view)
{
EhSelectedColumnKindChanged(); // ask view which column kind is now selected
UpdateButtonEnablingInView(); // do that in every case, even if nothing has changed
_view.InitializeAvailableTables(_availableTables);
_view.InitializeAvailableColumns(_availableColumns);
_view.GroupNumber = _doc.GroupNumber;
_view.UseAllAvailableDataColumns = _doc.UseAllAvailableDataColumnsOfGroup;
_view.UseAllAvailableDataRows = _doc.UseAllAvailableDataRows;
_view.Initialize_XColumn(_xColumn == null ? string.Empty : _xColumn.FullName);
_view.Initialize_YColumn(_yColumn == null ? string.Empty : _yColumn.FullName);
_view.Initialize_VColumns(_valueColumns);
CalcMaxPossiblePlotRangeTo();
if (_rowsController.ViewObject == null)
{
Current.Gui.FindAndAttachControlTo(_rowsController);
}
_view.Initialize_DataRowsControl(_rowsController.ViewObject);
}
}
/// <summary>Invalidates all data concerning common substring search and replacement.</summary>
private void InvalidateAllCommonSubstringData()
{
_userModifiedCommonSubstring = null;
_listOfSelectedTableNames.Clear();
_commonSubstringsList.Clear();
_substringReplacementCandidatesList.Clear();
foreach (MyXTableListNode node in _tableList)
{
node.PreviewTableName = null;
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
if (null == _propertyTypes)
{
_propertyTypes = new SelectableListNodeList();
}
else
{
_propertyTypes.Clear();
}
_propertyTypes.Add(new SelectableListNode("String", typeof(string), (_doc.PropertyValue is string) || (null == _doc.PropertyValue)));
_propertyTypes.Add(new SelectableListNode("Double", typeof(double), _doc.PropertyValue is double));
_propertyTypes.Add(new SelectableListNode("Integer", typeof(int), _doc.PropertyValue is int));
_propertyTypes.Add(new SelectableListNode("DateTime", typeof(DateTime), _doc.PropertyValue is DateTime));
}
if (null != _view)
{
_view.PropertyName = _doc.PropertyName;
_view.PropertyTypes = _propertyTypes;
ShowPropertyValue();
}
}
private void InitChoicesCyclingVariableAndChoicesAverageColumns()
{
var srcData = _doc.DataTable.DataColumns;
var columnsToProcess = _doc.GetDataColumns(ExpandCyclingVariableColumnDataAndOptions.ColumnsParticipatingIdentifier);
DataColumn columnWithCyclingVariable = _doc.GetDataColumnOrNull(ExpandCyclingVariableColumnDataAndOptions.ColumnWithCyclingVariableIdentifier);
IList <DataColumn> columnsToAverageOverRepeatPeriod = _doc.GetDataColumns(ExpandCyclingVariableColumnDataAndOptions.ColumnsToAverageIdentifier);
_choicesCyclingVar.Clear();
foreach (var col in srcData.Columns)
{
_choicesCyclingVar.Add(new SelectableListNode(srcData.GetColumnName(col), col, object.ReferenceEquals(columnWithCyclingVariable, col)));
}
_choicesColsToAverage.Clear();
foreach (var col in srcData.Columns)
{
_choicesColsToAverage.Add(new SelectableListNode
(srcData.GetColumnName(col), col, columnsToAverageOverRepeatPeriod.Contains(col)));
}
if (null != _view)
{
_view.InitializeCyclingVariableColumn(_choicesCyclingVar);
_view.InitializeColumnsToAverage(_choicesColsToAverage);
}
}
private void FillAvailableColumnList()
{
_availableColumns.Clear();
var node = _availableTables.FirstSelectedNode;
DataTable tg = node == null ? null : node.Tag as DataTable;
if (null != tg)
{
if (_areDataColumnsShown)
{
for (int i = 0; i < tg.DataColumnCount; ++i)
{
_availableColumns.Add(new SelectableListNode(tg.DataColumns.GetColumnName(i), tg.DataColumns[i], false));
}
}
else
{
for (int i = 0; i < tg.PropertyColumnCount; ++i)
{
_availableColumns.Add(new SelectableListNode(tg.PropertyColumns.GetColumnName(i), tg.PropertyColumns[i], false));
}
}
}
if (null != _view)
{
_view.InitializeAvailableColumns(_availableColumns);
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
_doc.NewTable = _doc.OriginalTable;
// Initialize tables
string[] tables = Current.Project.DataTableCollection.GetSortedTableNames();
_availableTables.Clear();
DataTable tg = _doc.OriginalTable;
foreach (var tableName in tables)
{
_availableTables.Add(new SelectableListNode(tableName, Current.Project.DataTableCollection[tableName], tg != null && tg.Name == tableName));
}
TriggerUpdateOfMatchingTables();
}
if (null != _view)
{
_view.AvailableTables_Initialize(_availableTables);
_view.MatchingTables_Initialize(_matchingTables);
_view.Diagnostics_Initialize(0, 0, 0);
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
FillAvailableUnitsDictionary();
GetAvailableUnitsForQuantity(_quantity, _availableUnits);
_includedUnits.Clear();
foreach (var unit in _doc.FixedUnits)
{
if (unit is UnitWithLimitedPrefixes lpUnit)
{
_prefixesForUnit[lpUnit.Unit] = new List <SIPrefix>(lpUnit.Prefixes);
_includedUnits.Add(new SelectableListNode(lpUnit.Unit.Name, lpUnit.Unit, false));
}
else
{
_prefixesForUnit[unit] = new List <SIPrefix>(new[] { SIPrefix.None });
_includedUnits.Add(new SelectableListNode(unit.Name, unit, false));
}
}
UpdateAllPrefixedUnits(_allChoosenPrefixedUnits);
AddToIncludedUnits = Current.Gui.NewRelayCommand(EhAddToIncludedUnits);
RemoveFromIncludedUnits = Current.Gui.NewRelayCommand(EhRemoveFromIncludedUnits);
SelectedPrefixesChangedCommand = Current.Gui.NewRelayCommand(EhSelectedPrefixesChangedCommand);
}
}
private void InitXYColumns()
{
var srcData = _doc.DataTable.DataColumns;
var columnsToProcess = _doc.GetDataColumns(ConvertXYVToMatrixDataAndOptions.ColumnV);
DataColumn columnX = _doc.GetDataColumnOrNull(ConvertXYVToMatrixDataAndOptions.ColumnX);
DataColumn columnY = _doc.GetDataColumnOrNull(ConvertXYVToMatrixDataAndOptions.ColumnY);
_choicesXColumn.Clear();
foreach (var col in srcData.Columns)
{
_choicesXColumn.Add(new SelectableListNode(srcData.GetColumnName(col), col, object.ReferenceEquals(columnX, col)));
}
_choicesYColumn.Clear();
foreach (var col in srcData.Columns)
{
_choicesYColumn.Add(new SelectableListNode(srcData.GetColumnName(col), col, object.ReferenceEquals(columnY, col)));
}
if (null != _view)
{
_view.InitializeXColumn(_choicesXColumn);
_view.InitializeYColumn(_choicesYColumn);
}
}
public void ShowFilesInPath(string path)
{
string[] files;
_fileList.Clear();
try
{
if (Directory.Exists(path))
{
files = Directory.GetFiles(path);
}
else
{
return;
}
}
catch (Exception)
{
return;
}
watcher.Path = path;
watcher.EnableRaisingEvents = true;
foreach (string file in files)
{
_fileList.Add(new FileListItem(file));
}
}
private void InitParticipatingColumns()
{
// Initialize value columns
_valueColumns.Clear();
var columnProxies = _doc.GetDataColumnProxies(DecomposeByColumnContentDataAndOptions.ColumnsParticipatingIdentifier);
foreach (var colProxy in columnProxies)
{
_valueColumns.Add(new SelectableListNode(colProxy.Document != null ? colProxy.Document.FullName : "Unresolved column", colProxy.Clone(), false)); // clone of colProxy is important for apply later on
}
if (null != _view)
{
_view.InitializeParticipatingColumns(_valueColumns);
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
_binningTypes.Clear();
var binningTypes = Altaxo.Main.Services.ReflectionService.GetNonAbstractSubclassesOf(typeof(IBinning));
foreach (var type in binningTypes)
{
_binningTypes.Add(new SelectableListNode(type.ToString(), type, type == _doc.CreationOptions.Binning.GetType()));
}
if (null != _binningController)
{
_binningController.Dispose();
_binningController = null;
}
_binningController = (IMVCANController)Current.Gui.GetControllerAndControl(new object[] { _doc.CreationOptions.Binning }, typeof(IMVCANController), UseDocument.Directly);
}
if (null != _view)
{
_view.Errors = _doc.Errors;
_view.Warnings = _doc.Warnings;
_view.NumberOfValuesOriginal = _doc.NumberOfValuesOriginal;
_view.NumberOfValuesFiltered = _doc.NumberOfValuesFiltered;
_view.NumberOfNaNValues = _doc.NumberOfNaNValues;
_view.NumberOfInfiniteValues = _doc.NumberOfInfiniteValues;
_view.MinimumValue = _doc.MinimumValue;
_view.MaximumValue = _doc.MaximumValue;
_view.IgnoreNaNValues = _doc.CreationOptions.IgnoreNaN;
_view.IgnoreInfiniteValues = _doc.CreationOptions.IgnoreInfinity;
_view.IgnoreValuesBelowLowerBoundary = _doc.CreationOptions.LowerBoundaryToIgnore.HasValue;
_view.IsLowerBoundaryInclusive = _doc.CreationOptions.IsLowerBoundaryInclusive;
if (_doc.CreationOptions.LowerBoundaryToIgnore.HasValue)
{
_view.LowerBoundary = _doc.CreationOptions.LowerBoundaryToIgnore.Value;
}
_view.IgnoreValuesAboveUpperBoundary = _doc.CreationOptions.UpperBoundaryToIgnore.HasValue;
_view.IsUpperBoundaryInclusive = _doc.CreationOptions.IsUpperBoundaryInclusive;
if (_doc.CreationOptions.UpperBoundaryToIgnore.HasValue)
{
_view.UpperBoundary = _doc.CreationOptions.UpperBoundaryToIgnore.Value;
}
_view.BinningType = _binningTypes;
_view.UseAutomaticBinning = !_doc.CreationOptions.IsUserDefinedBinningType;
_view.BinningView = _binningController.ViewObject;
}
}
public static void Sort(SelectableListNodeList list, IComparer <SelectableListNode> comparer)
{
var sset = new SortedSet <SelectableListNode>(list, comparer);
list.Clear();
foreach (var item in sset)
{
list.Add(item);
}
}
private void UpdateAllPrefixedUnits(SelectableListNodeList result)
{
result.Clear();
foreach (var entry in _prefixesForUnit)
{
foreach (var prefix in entry.Value)
{
result.Add(new SelectableListNode(prefix.ShortCut + entry.Key.ShortCut, null, false));
}
}
}
private void GetAvailableUnitQuantities(SelectableListNodeList result)
{
result.Clear();
var list = new HashSet <string>(_listOfUnits.Values.Select(x => x.Quantity));
var quantities = list.ToArray();
Array.Sort(quantities);
foreach (var quantity in quantities)
{
result.Add(new SelectableListNode(quantity, quantity, false));
}
}
private void GetAvailableUnitsForQuantity(string quantity, SelectableListNodeList result)
{
result.Clear();
var unitTypes = _listOfUnits.Where(x => x.Value.Quantity == quantity).Select(x => x.Key);
foreach (var ty in unitTypes)
{
var propInfo = ty.GetProperty("Instance");
var propMethod = propInfo.GetGetMethod();
if (null != propMethod)
{
var instance = (IUnit)propMethod.Invoke(null, null);
result.Add(new SelectableListNode(instance.Name, instance, false));
}
}
}
protected virtual void Controller_CurrentItems_Initialize()
{
if (null == _currentItems)
{
_currentItems = new SelectableListNodeList();
}
else
{
_currentItems.Clear();
}
foreach (var currentItem in _doc)
{
_currentItems.Add(new SelectableListNode(ToDisplayName(currentItem), currentItem, false));
}
}
private void InitChoicesCyclingVariableAndChoicesAverageColumns()
{
var srcData = _doc.DataTable.DataColumns;
var columnsToProcess = _doc.GetDataColumns(DecomposeByColumnContentDataAndOptions.ColumnsParticipatingIdentifier);
DataColumn columnWithCyclingVariable = _doc.GetDataColumnOrNull(DecomposeByColumnContentDataAndOptions.ColumnWithCyclingVariableIdentifier);
_choicesCyclingVar.Clear();
foreach (var col in srcData.Columns)
{
_choicesCyclingVar.Add(new SelectableListNode(srcData.GetColumnName(col), col, object.ReferenceEquals(columnWithCyclingVariable, col)));
}
if (null != _view)
{
_view.InitializeCyclingVariableColumn(_choicesCyclingVar);
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
// look for coordinate system types
if (null == _cosSubTypes)
{
_cosSubTypes = ReflectionService.GetNonAbstractSubclassesOf(typeof(G3DCoordinateSystem));
}
if (null == _choiceList)
{
_choiceList = new SelectableListNodeList();
}
_choiceList.Clear();
foreach (Type t in _cosSubTypes)
{
_choiceList.Add(new SelectableListNode(Current.Gui.GetUserFriendlyClassName(t), t, t == _doc.GetType()));
}
}
if (_view != null)
{
// look for a controller-control
_view.TypeLabel = "Type:";
_view.InitializeTypeNames(_choiceList);
// To avoid looping when a dedicated controller is unavailable, we first instantiate the controller alone and compare the types
_instanceController = (IMVCAController)Current.Gui.GetController(new object[] { _doc }, typeof(IMVCAController), UseDocument.Directly);
if (_instanceController != null && (_instanceController.GetType() != GetType()))
{
Current.Gui.FindAndAttachControlTo(_instanceController);
if (_instanceController.ViewObject != null)
{
_view.SetInstanceControl(_instanceController.ViewObject);
}
}
else
{
_instanceController = null;
_view.SetInstanceControl(null);
}
}
}
private void InitializeLineConnectionChoices()
{
if (null == _lineConnectChoices)
{
_lineConnectChoices = new SelectableListNodeList();
}
else
{
_lineConnectChoices.Clear();
}
var types = Altaxo.Main.Services.ReflectionService.GetNonAbstractSubclassesOf(typeof(ILineConnectionStyle));
foreach (var t in types)
{
_lineConnectChoices.Add(new SelectableListNode(t.Name, t, t == _doc.Connection.GetType()));
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
_graphsInProject.Clear();
foreach (GraphDocument graph in Current.Project.GraphDocumentCollection)
{
_graphsInProject.Add(new SelectableListNode(graph.Name, graph, false));
}
}
if (null != _view)
{
_view.GraphsInProject = _graphsInProject;
RenderPreview(_doc);
}
}
public void EhView_PredefinedStyleSelected()
{
var sel = _predefinedStyleSetsAvailable.FirstSelectedNode;
if (null == sel)
{
return;
}
var template = G3DPlotStyleCollectionTemplates.GetTemplate((int)sel.Tag, _doc.GetPropertyContext());
_currentItems.Clear(() => _doc.Clear());
for (int i = 0; i < template.Count; i++)
{
var listNode = new SelectableListNode(Current.Gui.GetUserFriendlyClassName(template[i].GetType()), template[i], false);
_currentItems.Add <IG3DPlotStyle>(listNode, (docNode) => _doc.Add(docNode));
}
OnCollectionChangeCommit();
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (_view != null)
{
_view.MajorTicks = GUIConversion.ToString(_doc.MajorTickSpan);
_view.MinorTicks = _doc.MinorTicks;
_view.ZeroLever = _doc.ZeroLever;
_view.MinGrace = _doc.OrgGrace;
_view.MaxGrace = _doc.EndGrace;
_snapTicksToOrg.Clear();
_snapTicksToEnd.Clear();
foreach (BoundaryTickSnapping s in Enum.GetValues(typeof(BoundaryTickSnapping)))
{
_snapTicksToOrg.Add(new SelectableListNode(Current.Gui.GetUserFriendlyName(s), s, s == _doc.SnapOrgToTick));
_snapTicksToEnd.Add(new SelectableListNode(Current.Gui.GetUserFriendlyName(s), s, s == _doc.SnapEndToTick));
}
_view.SnapTicksToOrg = _snapTicksToOrg;
_view.SnapTicksToEnd = _snapTicksToEnd;
_view.TargetNumberMajorTicks = _doc.TargetNumberOfMajorTicks;
_view.TargetNumberMinorTicks = _doc.TargetNumberOfMinorTicks;
_view.TransfoOffset = GUIConversion.ToString(_doc.TransformationOffset);
_view.DivideBy = GUIConversion.ToString(_doc.TransformationDivider);
_view.TransfoOperationIsMultiply = _doc.TransformationOperationIsMultiply;
_view.SuppressMajorTickValues = GUIConversion.ToString(_doc.SuppressedMajorTicks.ByValues);
_view.SuppressMinorTickValues = GUIConversion.ToString(_doc.SuppressedMinorTicks.ByValues);
_view.SuppressMajorTicksByNumber = GUIConversion.ToString(_doc.SuppressedMajorTicks.ByNumbers);
_view.SuppressMinorTicksByNumber = GUIConversion.ToString(_doc.SuppressedMinorTicks.ByNumbers);
_view.AddMajorTickValues = GUIConversion.ToString(_doc.AdditionalMajorTicks.Values);
_view.AddMinorTickValues = GUIConversion.ToString(_doc.AdditionalMinorTicks.Values);
}
}
private void FillAvailableColumnList()
{
_availableColumns.Clear();
DataTable tg = _doc.DataTable;
if (null != tg)
{
for (int i = 0; i < tg.DataColumnCount; ++i)
{
if (tg.DataColumns.GetColumnGroup(i) == _doc.GroupNumber)
{
_availableColumns.Add(new SelectableListNode(tg.DataColumns.GetColumnName(i), tg.DataColumns[i], false));
}
}
}
if (null != _view)
{
_view.InitializeAvailableColumns(_availableColumns);
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
ExpandCyclingVariableColumnDataAndOptions.EnsureCoherence(_doc, false);
InitChoicesCyclingVariableAndChoicesAverageColumns();
InitParticipatingColumns();
// Initialize tables
string[] tables = Current.Project.DataTableCollection.GetSortedTableNames();
string dataTableName = _doc.DataTable == null ? string.Empty : _doc.DataTable.Name;
_availableTables.Clear();
foreach (var tableName in tables)
{
_availableTables.Add(new SelectableListNode(tableName, Current.Project.DataTableCollection[tableName], dataTableName == tableName));
}
// Initialize columns
FillAvailableColumnList();
}
if (null != _view)
{
_view.InitializeCyclingVariableColumn(_choicesCyclingVar);
_view.InitializeColumnsToAverage(_choicesColsToAverage);
_view.InitializeAvailableTables(_availableTables);
_view.InitializeAvailableColumns(_availableColumns);
_view.GroupNumber = _doc.GroupNumber;
_view.InitializeParticipatingColumns(_valueColumns);
}
}
private void GetAvailablePrefixes(IUnit unit, SelectableListNodeList result)
{
result.Clear();
HashSet <SIPrefix> previouslySelectedPrefixes = null;
if (_prefixesForUnit.TryGetValue(unit, out var list))
{
previouslySelectedPrefixes = new HashSet <SIPrefix>(list);
}
foreach (var prefix in unit.Prefixes)
{
bool isSelected = null != previouslySelectedPrefixes?previouslySelectedPrefixes.Contains(prefix) : string.IsNullOrEmpty(prefix.Name);
string name = prefix.Name;
if (string.IsNullOrEmpty(prefix.Name))
{
name = "<< without prefix >>";
}
result.Add(new SelectableListNode(name, prefix, isSelected));
}
}
protected override void Initialize(bool initData)
{
base.Initialize(initData);
if (initData)
{
// ------- Set the environment name --------------
EnvironmentName = _doc.Name;
// ------- Set available quantities --------------
_quantities.Clear();
if (string.IsNullOrEmpty(_doc.Quantity)) // if doc has not quantitie still, then all quantities will be shown
{
foreach (var quantity in UnitsExtensions.GetAllDefinedQuantities())
{
var node = new SelectableListNode(quantity, quantity, quantity == _doc.Quantity);
_quantities.Add(node);
if (node.IsSelected)
{
_selectedQuantity = node;
}
}
}
else // else if doc already has a quantity, then we do not allow to change this quantity
{
var node = new SelectableListNode(_doc.Quantity, _doc.Quantity, true);
_quantities.Add(node);
_selectedQuantity = node;
}
// -------- Set up the unit environment controller -------
_unitController = new UnitEnvironmentController(quantity: _doc.Quantity);
_unitController.InitializeDocument(_doc.Environment ?? new QuantityWithUnitGuiEnvironment());
Current.Gui.FindAndAttachControlTo(_unitController);
}
}