/// <summary>
/// Изменение словаря ограничений на основании строки ограничений
/// </summary>
protected void ChangeRestrictList()
{
var res = new SortedDictionary <int, List <int> >();
for (int i = 0; i < TechObjectManager.GetInstance().Objects.Count;
i++)
{
TechObject to = TechObjectManager.GetInstance().Objects[i];
for (int j = 0; j < to.ModesManager.Modes.Count; j++)
{
string restrictPair = "{ " + (i + 1).ToString() + ", " +
(j + 1).ToString() + " }";
if (restrictStr.Contains(restrictPair))
{
if (res.ContainsKey(i + 1))
{
res[i + 1].Add(j + 1);
}
else
{
List <int> restrictMode = new List <int>();
restrictMode.Add(j + 1);
res.Add(i + 1, restrictMode);
}
}
}
}
restrictList = res;
}
/// <summary>
/// Получить индексы параметров
/// </summary>
/// <param name="values">Список значений</param>
/// <returns></returns>
private List <int> GetParametersIndexes(ref List <string> values)
{
var indexes = new List <int>();
var equipment = Owner as Equipment;
if (equipment != null)
{
TechObject techObject = equipment.Owner;
if (techObject != null)
{
var copiedValues = new string[values.Count];
values.CopyTo(copiedValues);
foreach (var copiedValue in copiedValues)
{
Param param = techObject.GetParamsManager()
.GetParam(copiedValue);
if (param == null)
{
continue;
}
indexes.Add(param.GetParameterNumber - 1);
values.Remove(copiedValue);
}
}
}
return(indexes);
}
override public Editor.ITreeViewItem Insert()
{
TechObject newTechObject = null;
if (objects.Count > 0)
{
if (objects.Count == 1)
{
newTechObject = new TechObject("Танк", GetTechObjectN, 1,
2, "TANK", -1, "TankObj", "");
}
else
{
newTechObject = new TechObject(
objects[objects.Count - 1].EditText[0],
GetTechObjectN, objects[objects.Count - 1]
.TechNumber + 1,
objects[objects.Count - 1].TechType,
objects[objects.Count - 1].NameEplan,
objects[objects.Count - 1].CooperParamNumber,
objects[objects.Count - 1].NameBC,
objects[objects.Count - 1].AttachedObjects.Value);
}
}
else
{
newTechObject =
new TechObject("Мастер", GetTechObjectN, 1, 1, "MASTER",
-1, "MasterObj", "");
}
objects.Add(newTechObject);
return(newTechObject);
}
private ITreeViewItem InsertType(string selectedType,
TechObject techObj = null)
{
ITreeViewItem treeItem = GetTreeItem(selectedType);
ITreeViewItem innerItem;
bool needInsert = techObj == null;
if (needInsert)
{
innerItem = treeItem.Insert();
}
else
{
innerItem = treeItem.InsertCopy(techObj);
}
if (innerItem != null)
{
if (!treeObjects.Contains(treeItem))
{
treeObjects.Add(treeItem);
}
return(treeItem);
}
return(null);
}
override public Editor.ITreeViewItem InsertCopy(object obj)
{
if (obj is TechObject)
{
int newN = 1;
if (objects.Count > 0)
{
newN = objects[objects.Count - 1].TechNumber + 1;
}
//Старый и новый номер объекта - для замены в ограничениях
int oldObjN = GetTechObjectN(obj as TechObject);
int newObjN = objects.Count + 1;
TechObject newObject = (obj as TechObject).Clone(
GetTechObjectN, newN, oldObjN, newObjN);
objects.Add(newObject);
newObject.ChangeCrossRestriction();
newObject.Equipment.ModifyDevNames();
return(newObject);
}
return(null);
}
/// <summary>
/// Вставить подтип в дерево. Выполняется или вставка или
/// копирование и вставка.
/// </summary>
/// <param name="selectedSubType">Выбранный подтип на форме</param>
/// <param name="techObj">Объект, который надо вставить (скопировать)
/// </param>
/// <returns></returns>
private ITreeViewItem InsertSubType(string selectedSubType,
TechObject techObj = null)
{
ITreeViewItem baseTreeItem = GetTreeItem(selectedSubType);
ITreeViewItem currentObject;
bool needInsert = techObj == null;
if (needInsert)
{
currentObject = baseTreeItem.Insert();
}
else
{
currentObject = baseTreeItem.InsertCopy(techObj);
}
if (currentObject != null)
{
if (!objects.Contains(baseTreeItem))
{
objects.Add(baseTreeItem);
}
return(baseTreeItem);
}
else
{
return(null);
}
}
public TechObject Clone(GetN getN, int newNumber, int oldObjN,
int newObjN)
{
TechObject clone = (TechObject)MemberwiseClone();
clone.techNumber = new TechObjectN(clone, newNumber);
clone.techType = new Editor.ObjectProperty("Тип", TechType);
clone.nameBC = new Editor.ObjectProperty("Имя объекта Monitor",
NameBC);
clone.nameEplan = new NameInEplan(NameEplan, clone);
clone.s88Level = new ObjS88Level(S88Level, clone);
clone.attachedObjects = new AttachedToObjects(AttachedObjects.Value,
clone);
clone.getN = getN;
clone.baseTechObject = baseTechObject.Clone(clone);
clone.parameters = parameters.Clone();
clone.modes.ChngeOwner(clone);
clone.modes = modes.Clone(clone);
clone.modes.ModifyDevNames(TechNumber);
clone.modes.ModifyRestrictObj(oldObjN, newObjN);
clone.equipment = equipment.Clone(clone);
clone.equipment.ModifyDevNames();
clone.SetItems();
return(clone);
}
/// <summary>
/// Сохранить оборудование технологического объекта
/// </summary>
/// <param name="objName">Имя для сохранения</param>
/// <param name="equipment">Объект</param>
/// <returns></returns>
public string SaveEquipment(TechObject obj, string objName)
{
var res = "";
Equipment equipment = obj.Equipment;
foreach (var item in equipment.Items)
{
var property = item as BaseParameter;
var value = property.Value;
var luaName = property.LuaName;
var parameterType = GetParameterValueType(obj, property);
switch (parameterType)
{
case ParameterValueType.Device:
res += objName + $".{luaName} = " +
$"prg.control_modules.{value}\n";
break;
case ParameterValueType.ManyDevices:
res += SaveMoreThanOneDeviceInEquipment(objName,
luaName, value);
break;
case ParameterValueType.Parameter:
res += objName + $".{luaName} = " +
$"{objName}.PAR_FLOAT.{value}\n";
break;
}
}
return(res);
}
override public Editor.ITreeViewItem Replace(object child,
object copyObject)
{
TechObject techObject = child as TechObject;
if (copyObject is TechObject && techObject != null)
{
int newN = techObject.TechNumber;
//Старый и новый номер объекта - для замены в ограничениях
int oldObjN = GetTechObjectN(copyObject as TechObject);
int newObjN = GetTechObjectN(child as TechObject);
TechObject newObject = (copyObject as TechObject).Clone(
GetTechObjectN, newN, oldObjN, newObjN);
int index = objects.IndexOf(techObject);
objects.Remove(techObject);
objects.Insert(index, newObject);
index = objects.IndexOf(newObject);
newObject.ChangeCrossRestriction(techObject);
return(newObject);
}
return(null);
}
public AttachedToObjects(string attachedObjects,
TechObject techObject) : base("Привязанные агрегаты",
attachedObjects)
{
this.techObject = techObject;
SetValue(attachedObjects);
}
public TechObject Clone(GetN getLocalNum, int newNumber,
int oldGlobalNum, int newGlobalNum)
{
TechObject clone = (TechObject)MemberwiseClone();
clone.techNumber = new TechObjectN(clone, newNumber);
clone.techType = new ObjectProperty("Тип", TechType);
clone.nameBC = new ObjectProperty("Имя объекта Monitor", NameBC);
clone.nameEplan = new NameInEplan(NameEplan, clone);
clone.attachedObjects = new AttachedToObjects(AttachedObjects.Value,
clone);
clone.getLocalNum = getLocalNum;
if (baseTechObject != null)
{
clone.baseTechObject = baseTechObject.Clone(clone);
}
clone.paramsManager = paramsManager.Clone();
clone.modes = modes.Clone(clone);
clone.modes.ModifyDevNames(TechNumber);
clone.modes.ModifyRestrictObj(oldGlobalNum, newGlobalNum);
clone.equipment = equipment.Clone(clone);
clone.equipment.ModifyDevNames();
clone.SetItems();
return(clone);
}
public TechObjectN(TechObject techObject, int value)
: base("Номер", techObject.TechNumber.ToString())
{
this.techObject = techObject;
SetValue(value);
}
/// <summary>
/// Получить корректные номера технологических объектов из
/// входной строки
/// </summary>
/// <param name="inputString">Входная строка</param>
/// <returns></returns>
private List <int> GetValidTechObjNums(string inputString)
{
var numbers = new List <int>();
string[] numbersAsStringArray = inputString.Split(' ')
.ToArray();
foreach (var numAsString in numbersAsStringArray)
{
int number;
int.TryParse(numAsString, out number);
if (number == 0)
{
continue;
}
TechObject obj = TechObjectManager.GetInstance()
.GetTObject(number);
bool correctBaseObject = obj.BaseTechObject != null &&
obj.BaseTechObject.IsAttachable;
if (obj != null && correctBaseObject)
{
numbers.Add(number);
}
}
numbers = numbers.Distinct().ToList();
return(numbers);
}
/// <summary>
/// Удалить привязку агрегатов из аппарата.
/// </summary>
/// <param name="aggregatesNumbers">Список агрегатов</param>
private void RemoveDeletedAgregates(List <int> aggregatesNumbers)
{
if (aggregatesNumbers.Count == 0)
{
return;
}
foreach (var number in aggregatesNumbers)
{
TechObject removingAgregate = TechObjectManager
.GetInstance().GetTObject(number);
BaseTechObject removingBaseTechObject = removingAgregate
.BaseTechObject;
List <BaseParameter> properties = removingBaseTechObject
.AggregateParameters;
var deletingProperties = new List <BaseParameter>();
if (properties.Count != 0)
{
deletingProperties.AddRange(properties);
}
if (removingBaseTechObject.MainAggregateParameter != null)
{
deletingProperties.Add(removingBaseTechObject
.MainAggregateParameter);
}
TechObject thisTechObject = techObject;
List <Mode> modes = thisTechObject.ModesManager.Modes;
foreach (var mode in modes)
{
mode.BaseOperation.RemoveProperties(deletingProperties);
}
}
}
/// <summary>
/// Добавить опознанный объект при загрузке из LUA
/// </summary>
/// <param name="obj">Объект</param>
private void AddIdentifiedObjectWhenLoadFromLua(TechObject obj)
{
BaseTechObject baseTechObject = obj.BaseTechObject;
var type = (BaseTechObjectManager.ObjectType)baseTechObject
.S88Level;
string name = BaseTechObjectManager.GetInstance()
.GetS88Name(baseTechObject.S88Level);
switch (type)
{
case BaseTechObjectManager.ObjectType.ProcessCell:
AddProcessCellFromLua(obj);
break;
case BaseTechObjectManager.ObjectType.Unit:
AddS88ObjectFromLua(obj, name);
break;
case BaseTechObjectManager.ObjectType.Aggregate:
AddS88ObjectFromLua(obj, name);
break;
case BaseTechObjectManager.ObjectType.UserObject:
AddUserObject(obj);
break;
}
}
public override ITreeViewItem Insert()
{
if (Items.Length == 0)
{
var newObject = new TechObject(Name, GetTechObjectLocalNum,
1, 1, "MASTER", -1, "MasterObj", "", baseTechObject);
// Работа со списком в дереве и общим списком объектов.
objects.Add(newObject);
globalObjectsList.Add(newObject);
// Обозначение начального номера объекта для ограничений.
SetRestrictionOwner();
newObject.SetUpFromBaseTechObject();
newObject.AddParent(this);
return(newObject);
}
else
{
ObjectsAdder.Reset();
return(null);
}
}
/// <summary>
/// Копия объекта
/// </summary>
/// <param name="techObject">Копируемый объект</param>
/// <returns></returns>
public BaseTechObject Clone(TechObject techObject)
{
var cloned = Clone();
cloned.Owner = techObject;
return(cloned);
}
private string GenerateAttachedObjectsString()
{
string value = Value ?? string.Empty;
if (value == string.Empty)
{
return(value);
}
var objectNums = value.Split(' ').Select(int.Parse);
var objectNames = new List <string>();
foreach (var objNum in objectNums)
{
TechObject findedObject = TechObjectManager.GetInstance()
.GetTObject(objNum);
if (findedObject != null)
{
string name = $"\"{findedObject.Name} " +
$"{findedObject.TechNumber}\"";
objectNames.Add(name);
}
}
return(string.Join(", ", objectNames));
}
/// <summary>
/// Получить индексы параметров
/// </summary>
/// <param name="values">Список значений</param>
/// <returns></returns>
private List <int> GetParametersIndexes(List <string> values)
{
var indexes = new List <int>();
var equipment = Owner as Equipment;
if (equipment != null)
{
TechObject techObject = equipment.Owner;
if (techObject != null)
{
foreach (var value in values)
{
Param param = techObject.GetParamsManager()
.GetParam(value);
if (param == null)
{
continue;
}
indexes.Add(param.GetParameterNumber - 1);
}
}
}
return(indexes);
}
/// <summary>
/// Генерация одиночных шагов для объекта
/// </summary>
/// <param name="techObject">Объект</param>
/// <param name="objName">Имя объекта</param>
/// <param name="objNode">Дерево объекта (пишется либо сюда)</param>
/// <param name="objSingleStepsNode">Дерево для одиночных шагов
/// (либо сюда)</param>
private void GenerateSingleStepsTags(TechObject techObject,
string objName, TreeNode objNode, TreeNode objSingleStepsNode)
{
List <Mode> modes = techObject.ModesManager.Modes;
for (int modeNum = 1; modeNum <= modes.Count; modeNum++)
{
foreach (var state in modes[modeNum - 1].States)
{
int stepsCount = state.Steps.Count;
for (int stepNum = 1; stepNum <= stepsCount; stepNum++)
{
string stepTag = $"{objName}." +
$"{state.Type}_STEPS{modeNum}[ {stepNum} ]";
if (cdbxTagView)
{
objNode.Nodes.Add(stepTag, stepTag);
}
else
{
objSingleStepsNode.Nodes.Add(stepTag, stepTag);
}
}
}
}
}
/// <summary>
/// Генерация тэгов по операциям, шагам, доступности, состояниям
/// </summary>
/// <param name="item">Объект</param>
/// <param name="itemNumber">Глобальный номер</param>
private void GenerateModesOpersAvsStepsTags(TechObject item, string obj,
TreeNode objNode, TreeNode objModesNode, TreeNode objOperStateNode,
TreeNode objAvOperNode, TreeNode objStepsNode)
{
string mode = obj + ".MODES";
string step = mode + "_STEPS";
string oper = obj + ".OPERATIONS";
string av = obj + ".AVAILABILITY";
for (int i = 1; i <= item.ModesManager.Modes.Count; i++)
{
string number = "[ " + i.ToString() + " ]";
if (cdbxTagView == true)
{
objNode.Nodes.Add(mode + number, mode + number);
objNode.Nodes.Add(oper + number, oper + number);
objNode.Nodes.Add(av + number, av + number);
objNode.Nodes.Add(step + number, step + number);
}
else
{
objModesNode.Nodes.Add(mode + number, mode + number);
objOperStateNode.Nodes.Add(oper + number, oper + number);
objAvOperNode.Nodes.Add(av + number, av + number);
objStepsNode.Nodes.Add(step + number, step + number);
}
}
}
/// <summary>
/// Изменение словаря ограничений на основании строки ограничений
/// </summary>
protected void ChangeRestrictList()
{
var res = new SortedDictionary <int, List <int> >();
var techObjectsList = TechObjectManager.GetInstance()
.TechObjects;
for (int i = 0; i < techObjectsList.Count; i++)
{
TechObject to = techObjectsList[i];
for (int j = 0; j < to.ModesManager.Modes.Count; j++)
{
string restrictPair = $"{{ {i+1}, {j + 1} }}";
if (restrictStr.Contains(restrictPair))
{
if (res.ContainsKey(i + 1))
{
res[i + 1].Add(j + 1);
}
else
{
var restrictMode = new List <int>();
restrictMode.Add(j + 1);
res.Add(i + 1, restrictMode);
}
}
}
}
restrictList = res;
ChangeRestrictStr();
}
/// <summary>
/// Удаление перекрестных ограничений
/// </summary>
protected void ClearCrossRestriction(SortedDictionary <int,
List <int> > diffDict)
{
// Для ограничений на последующие операции
// не должны проставляться симметричные ограничения.
if ((luaName != "NextModeRestriction") && (diffDict.Count != 0))
{
SortedDictionary <int, List <int> > .KeyCollection keyColl =
diffDict.Keys;
foreach (int key in keyColl)
{
TechObject to = TechObjectManager.GetInstance()
.TechObjects[key - 1];
foreach (int val in diffDict[key])
{
Mode mode = to.GetMode(val - 1);
if (mode != null)
{
mode.DelRestriction(luaName, ownerObjNum,
ownerModeNum);
}
}
}
}
}
/// <summary>
/// Проверка действий в шаге
/// </summary>
/// <returns>Строка с ошибками</returns>
public string Check()
{
var errors = string.Empty;
List <int> devicesInAction = new List <int>();
foreach (Action a in actions)
{
if (a.GetType().Name == "Action" &&
(a.DisplayText[0].Contains("Включать") ||
a.DisplayText[0].Contains("Выключать")))
{
devicesInAction.AddRange(a.DeviceIndex);
}
}
List <int> FindEqual = devicesInAction.GroupBy(x => x)
.SelectMany(y => y.Skip(1)).Distinct().ToList();
foreach (int i in FindEqual)
{
State state = Owner;
Mode mode = state.Owner;
ModesManager modesManager = mode.Owner;
TechObject techObject = modesManager.Owner;
Device.IODevice device = Device.DeviceManager.GetInstance()
.GetDeviceByIndex(i);
string msg = $"Неправильно заданы устройства в шаге " +
$"\"{GetStepName()}\", операции \"{mode.Name}\"," +
$"технологического объекта " +
$"\"{techObject.DisplayText[0]}\"\n";
errors += msg;
}
return(errors);
}
/// <summary>
/// Инициализация базовой операции по имени
/// </summary>
/// <param name="baseOperName">Имя операции</param>
/// <param name="mode">Операция владелец</param>
public void Init(string baseOperName, Mode mode)
{
TechObject techObject = owner.Owner.Owner;
BaseTechObject baseTechObject = techObject.BaseTechObject;
string baseTechObjectName = baseTechObject?.Name ?? string.Empty;
ResetOperationSteps();
if (baseTechObjectName != string.Empty)
{
BaseOperation operation;
operation = techObject.BaseTechObject
.GetBaseOperationByName(baseOperName);
if (operation == null)
{
operation = techObject.BaseTechObject
.GetBaseOperationByLuaName(baseOperName);
}
if (operation != null)
{
Name = operation.Name;
LuaName = operation.LuaName;
Properties = operation.Properties
.Select(x => x.Clone())
.ToList();
foreach (var property in Properties)
{
property.Owner = this;
property.Parent = this;
}
states = operation.States;
foreach (var state in states)
{
foreach (var step in states[state.Key])
{
step.Owner = this;
}
}
owner = mode;
if (mode.Name == Mode.DefaultModeName)
{
mode.SetNewValue(operation.Name);
}
}
}
else
{
Name = string.Empty;
LuaName = string.Empty;
baseOperationProperties = new List <BaseParameter>();
states = new Dictionary <string, List <BaseStep> >();
}
techObject.AttachedObjects.Check();
SetItems();
}
public AttachedObjects(string attachedObjects, TechObject owner,
IAttachedObjectsStrategy strategy) :
base(strategy.Name, attachedObjects)
{
this.owner = owner;
this.strategy = strategy;
SetValue(attachedObjects);
}
/// <summary>
/// Формирование узлов для операций, шагов и параметров объектов.
/// </summary>
/// <param name="rootNode">корневой узел</param>
/// <param name="useNewNames">Использовать новые имена объектов
/// вместо OBJECT</param>
/// <param name="combineTags">Комбинировать тэги в один подтип</param>
public void GetObjectForXML(TreeNode rootNode, bool combineTags,
bool useNewNames)
{
cdbxNewNames = useNewNames;
cdbxTagView = combineTags;
GenerateSystemNode(rootNode);
for (int num = 1; num <= techObjectManager.TechObjects.Count; num++)
{
TechObject item = techObjectManager.TechObjects[num - 1];
var objNode = new TreeNode($"{item.NameBC}{item.TechNumber}");
var objModesNode = new TreeNode(item.NameBC +
item.TechNumber.ToString() + "_Операции");
var objOperStateNode = new TreeNode(item.NameBC +
item.TechNumber.ToString() + "_Состояния_Операций");
var objAvOperNode = new TreeNode(item.NameBC +
item.TechNumber.ToString() + "_Доступность");
var objStepsNode = new TreeNode(item.NameBC +
item.TechNumber.ToString() + "_Шаги");
var objSingleStepsNode = new TreeNode(item.NameBC +
item.TechNumber.ToString() + "_Одиночные_Шаги");
var objParamsNode = new TreeNode(item.NameBC +
item.TechNumber.ToString() + "_Параметры");
string objName = GenerateObjectName(item, num);
GenerateCMDTags(objName, objNode, objModesNode);
GenerateSTTags(item, objName, objNode, objModesNode);
GenerateModesOpersAvsStepsTags(item, objName, objNode,
objModesNode, objOperStateNode, objAvOperNode,
objStepsNode);
GenerateSingleStepsTags(item, objName, objNode,
objSingleStepsNode);
foreach (Params paramsGroup in item.GetParamsManager().Items)
{
string groupName = $"{objName}." +
$"{paramsGroup.NameForChannelBase}";
int count = paramsGroup.Items.Length;
GenerateParametersTags(count, objNode, objParamsNode,
groupName);
}
var singleNodes = new TreeNode[] { objModesNode,
objOperStateNode, objAvOperNode, objStepsNode,
objSingleStepsNode, objParamsNode };
GenerateRootNode(rootNode, objNode, singleNodes);
if (item.BaseTechObject != null && item.BaseTechObject.IsPID)
{
GeneratePIDNode(rootNode,
techObjectManager.GetTechObjectN(item));
}
}
}
/// <summary>
/// Экспорт описания проекта в файл.
/// </summary>
/// <param name="path">Место сохранения</param>
/// <param name="objectsNums">Список (номера) экспортируемых
/// объектов</param>
public void Export(string path, List <int> objectsNums)
{
string objectsDescription = "";
string objectsRestriction = "";
List <TechObject.TechObject> objects = techObjectManager.TechObjects;
foreach (var obj in objects)
{
int globalNum = techObjectManager.GetTechObjectN(obj);
bool needExporting = objectsNums.Contains(globalNum);
if (needExporting)
{
TechObject.TechObject exportingObject = obj.Clone(
techObjectManager.GetTechObjectN, obj.TechNumber,
globalNum, globalNum);
// Убираем привязку при экспорте.
exportingObject.AttachedObjects.SetValue("");
// Обходим нулевое значение т.к объект ни находится ни в
// каком списке объектов.
string description = exportingObject
.SaveAsLuaTable("\t\t", globalNum);
description = description
.Replace("[ 0 ]", $"[ {globalNum} ]");
string restriction = exportingObject
.SaveRestrictionAsLua("\t", globalNum);
restriction = restriction
.Replace("[ 0 ]", $"[ {globalNum} ]");
objectsDescription += description;
objectsRestriction += restriction;
}
else
{
objectsDescription += $"\t[ {globalNum} ] = {{0}},\n";
}
}
try
{
var fileWriter = new StreamWriter(path, false,
EasyEPlanner.EncodingDetector.DetectFileEncoding(path));
WriteObjectsDescription(fileWriter, objectsDescription);
fileWriter.WriteLine("\n");
WriteObjectsRestriction(fileWriter, objectsRestriction);
fileWriter.Flush();
fileWriter.Close();
}
catch
{
throw new Exception("Ошибка записи в файл при экспорте");
}
}
/// <summary>
/// Клонирование для вставки
/// </summary>
/// <param name="cloningObject">Клонируемый объект</param>
/// <param name="stubObject">Объект-заглушка</param>
/// <param name="newN">Номер внутренний объекта</param>
/// <param name="oldObjNum">Старый глобальный номер</param>
/// <param name="newObjNum">Новый глобальный номер</param>
/// <returns></returns>
private TechObject CloneForInsert(TechObject cloningObject,
TechObject stubObject, int newN, int oldObjNum, int newObjNum)
{
globalObjectsList.Add(stubObject);
var clonedObject = cloningObject.Clone(GetTechObjectLocalNum, newN,
oldObjNum, newObjNum);
globalObjectsList.Remove(stubObject);
return(clonedObject);
}
/// <summary>
/// Инициализация базовой операции по имени
/// </summary>
/// <param name="baseOperName">Имя операции</param>
/// <param name="mode">Операция владелец</param>
public void Init(string baseOperName, Mode mode)
{
TechObject techObject = owner.Owner.Owner;
string baseTechObjectName = techObject.BaseTechObject.Name;
ResetOperationSteps();
if (baseTechObjectName != "")
{
BaseOperation operation;
operation = techObject.BaseTechObject
.GetBaseOperationByName(baseOperName);
if (operation == null)
{
operation = techObject.BaseTechObject
.GetBaseOperationByLuaName(baseOperName);
}
if (operation != null)
{
Name = operation.Name;
LuaName = operation.LuaName;
Properties = operation.Properties
.Select(x => x.Clone())
.ToList();
foreach (var property in Properties)
{
property.Owner = this;
property.Parent = this;
}
baseSteps = operation.Steps;
foreach (var step in baseSteps)
{
step.Owner = this;
}
owner = mode;
if (mode.Name == Mode.DefaultModeName)
{
mode.SetNewValue(operation.Name);
}
}
}
else
{
Name = "";
LuaName = "";
baseOperationProperties = new List <BaseParameter>();
baseSteps = new List <BaseStep>();
}
techObject.AttachedObjects.Check();
SetItems();
}
