void ReleaseDesignerOutlets()
{
if (DefinitionDescription != null)
{
DefinitionDescription.Dispose();
DefinitionDescription = null;
}
if (DefinitionTitle != null)
{
DefinitionTitle.Dispose();
DefinitionTitle = null;
}
}
/// <summary>
/// The add include to collection.
/// </summary>
/// <param name="fileName">
/// The file name.
/// </param>
/// <param name="itemName">
/// The item name.
/// </param>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
private void AddIncludeToCollection(string fileName, string itemName, string expression, DefinitionDescription parent)
{
// check if I already have the definition in the collection
lock (this.processCollection)
{
DefinitionDescription basicProgramDescription = null;
if (this.processCollection.ContainsKey(fileName, itemName, typeof(BasicProgramDescription)))
{
basicProgramDescription = this.processCollection[fileName, itemName, typeof(BasicProgramDescription)];
}
if (basicProgramDescription == null)
{
basicProgramDescription = new BasicProgramDescription(fileName, itemName);
BasicProgramDescription.IsInclude = true;
this.processCollection.Add(basicProgramDescription);
}
this.AddBasicProgramToCollection(
basicProgramDescription,
new ProcessLoadState { Expression = expression, HookPoint = "INCLUDE", ParentDefinitionDescription = parent });
}
}
/// <summary>
/// The add expression to collection.
/// </summary>
/// <param name="source">
/// The source.
/// </param>
/// <param name="hookType">
/// The hook type.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <param name="processDescription">
/// The process description.
/// </param>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="sysid">
/// The sysid.
/// </param>
private void AddExpressionToCollection(
SourceDefinition source,
SourceDefinition hookType,
string description,
DefinitionDescription processDescription,
string expression,
string sysid = "")
{
JobManager.RunInDispatcherThread(
DebugWindowManager.DebugConsoleWindow.Dispatcher,
DispatcherPriority.Normal,
delegate
{
try
{
switch (source)
{
case SourceDefinition.Field:
this.AddItemToCollection(
processDescription.DictionaryExpressions,
new SBExpression(processDescription.FileName, expression, hookType, sysid)
{
Description =
description
});
break;
case SourceDefinition.Screen:
/*
if (hookType == SourceDefinition.Process)
{
//AddItemToCollection(processDescription.ProcessCollection, );
this.AddProcessToCollection(
description,
processDescription,
new SBExpression(processDescription.FileName, expression, hookType, sysid, expression)
{
Description
=
description
});
}
else
{
*/
this.AddItemToCollection(
processDescription.ScreenExpressions,
new SBExpression(processDescription.FileName, expression, hookType, sysid)
{
Description =
description
});
/*
}
*/
break;
case SourceDefinition.Menu:
this.AddProcessToCollection(
description,
processDescription,
new SBExpression(processDescription.FileName, expression, hookType, sysid, expression)
{
Description
=
description
});
break;
case SourceDefinition.Paragraph:
this.AddItemToCollection(
processDescription.Expressions,
new SBExpression(processDescription.FileName, expression, hookType, sysid)
{
Description =
description
});
break;
case SourceDefinition.Unknown:
this.AddItemToCollection(
processDescription.Expressions,
new SBExpression(processDescription.FileName, expression, hookType, sysid)
{
Description =
description
});
break;
}
}
catch (Exception exception)
{
CustomLogger.LogException(exception, "Problem adding expression to the collection.");
}
});
}
/// <summary>
/// The add basic program to collection.
/// </summary>
/// <param name="basicProgramDescription">
/// The basic program description.
/// </param>
/// <param name="processLoadState">
/// The process load state.
/// </param>
private void AddBasicProgramToCollection(DefinitionDescription basicProgramDescription, ProcessLoadState processLoadState = null)
{
if (DebugWindowManager.DebugConsoleWindow == null)
{
return;
}
if (basicProgramDescription == null)
{
CustomLogger.LogError(() => "A null basic program description was passed to AddBasicProgramToCollection.");
return;
}
JobManager.RunInDispatcherThread(
DebugWindowManager.DebugConsoleWindow.Dispatcher,
DispatcherPriority.Normal,
delegate
{
try
{
if (processLoadState == null)
{
CustomLogger.LogError(() => "A nullprocessLoadState was passed to AddBasicProgramToCollection.");
return;
}
if (processLoadState.ParentDefinitionDescription == null)
{
this.Definition = basicProgramDescription;
this.ProcessStack.Clear();
this.ProcessStack.Push(this.Definition);
}
else
{
this.AddItemToCollection(
processLoadState.ParentDefinitionDescription.ProcessCollection,
new ProcessCall
{
Description = processLoadState.HookPoint,
ProcessDescription = basicProgramDescription
});
}
}
catch (Exception ex)
{
CustomLogger.LogException(
ex,
"There was a problem adding " + basicProgramDescription.Name + " to the collection.");
}
});
}
/// <summary>
/// The load screen.
/// </summary>
/// <param name="screenName">
/// The screen name.
/// </param>
/// <param name="fileName">
/// The file name.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="hookPoint">
/// The hook point.
/// </param>
internal void LoadScreen(string screenName, string fileName, DefinitionDescription parent = null, string hookPoint = "")
{
JobManager.RunInUIThread(
DispatcherPriority.Input,
delegate
{
if (string.IsNullOrEmpty(screenName) || string.IsNullOrEmpty(fileName))
{
return;
}
this.SetIsLoading(1);
SBFile.ReadDictionaryItem(
fileName,
screenName,
new ScreenDefinitionLoadState
{
FileName = fileName,
ParentDefinitionDescription = parent,
HookPoint = hookPoint
},
this.ReadProcessCompleted);
});
}
/// <summary>
/// Loads the definition from expression.
/// </summary>
/// <param name="source">
/// Where the expression is being called from.
/// </param>
/// <param name="hookType">
/// If this is a process hook point or expression hook point.
/// </param>
/// <param name="expression">
/// The original expression that the definition name was derrived from.
/// </param>
/// <param name="parent">
/// Parent <see cref="DefinitionDescription"/>, if this is null then it will be the root of the tree.
/// </param>
/// <param name="hookPoint">
/// The name of the definition slot where the definition was found.
/// </param>
/// <param name="sysid">
/// The system id to use otherwise the current system id will be used.
/// </param>
internal void LoadProcessFromExpression(
SourceDefinition source,
SourceDefinition hookType,
string expression,
DefinitionDescription parent = null,
string hookPoint = "",
string sysid = "")
{
if (string.IsNullOrEmpty(expression))
{
// there is no expression so no need to try load it.
return;
}
if (expression.StartsWith("P.CALL.PROCESS"))
{
// this is specific to American Auto Shield. The have a process used to call other processes so we can just remove it.
expression = expression.Substring(15);
}
// Check to see if it is a constant, if so just add it to the collection.
if (SBExpression.IsConstantValueExpression(expression))
{
this.AddExpressionToCollection(source, hookType, hookPoint, parent, expression);
return;
}
var colonPos = expression.IndexOf(":", StringComparison.Ordinal);
if (colonPos != 1)
{
// SB expression that have an identified, i.e. B: D: all have a single character then a ':'
colonPos = 0;
}
// a field definition has no process hooks they are all expressions, etc. int help.
if (source != SourceDefinition.Paragraph
&& (colonPos > 0 || source == SourceDefinition.Field || source == SourceDefinition.Expression))
{
this.AddExpressionToCollection(source, hookType, hookPoint, parent, expression);
return;
}
string callType;
var pName = GetProcessName(expression, out callType);
if (!string.IsNullOrEmpty(pName))
{
switch (callType)
{
case "C":
this.LoadProcess(pName, source, hookType, parent, expression, hookPoint, sysid);
break;
case "B":
this.LoadBasicProgramFromExpression(pName, parent, hookPoint);
break;
case "M":
break;
case "D":
this.AddExpressionToCollection(source, hookType, hookPoint, parent, expression);
break;
case "V":
this.AddExpressionToCollection(source, hookType, hookPoint, parent, expression);
break;
default:
this.LoadProcess(pName, source, hookType, parent, expression, hookPoint, sysid);
break;
}
}
}
/// <summary>
/// Loads the definition from xxPROCESS.
/// </summary>
/// <param name="pName">
/// Name of the definition.
/// </param>
/// <param name="slotType"></param>
/// <param name="parent">
/// Parent <see cref="DefinitionDescription"/>, if this is null then it will be the root of the tree.
/// </param>
/// <param name="expression">
/// The original expression that the definition name was derrived from.
/// </param>
/// <param name="hookPoint">
/// The name of the definition slot where the definition was found.
/// </param>
/// <param name="sysid">
/// The system id to use otherwise the current system id will be used.
/// </param>
/// <param name="source"></param>
internal void LoadProcess(
string pName,
SourceDefinition source,
SourceDefinition slotType,
DefinitionDescription parent = null,
string expression = "",
string hookPoint = "",
string sysid = "")
{
if (SBExpression.IsStandardSBExpression(expression))
{
// standard SB expression elements and therefore no need to try read the process, just add the element
this.AddExpressionToCollection(parent, hookPoint, expression);
return;
}
if (string.IsNullOrEmpty(expression))
{
expression = pName;
}
JobManager.RunInUIThread(
DispatcherPriority.Input,
delegate
{
var processFile = sysid;
if (string.IsNullOrEmpty(processFile))
{
processFile = SBPlusClient.Current.SystemId;
}
// read definition record from current xxProcess
processFile += "PROCESS";
// check if I already have the definition in the collection
lock (this.processCollection)
{
if (this.processCollection.ContainsKey(processFile, pName))
{
this.SetIsLoading(1);
this.AddProcessToCollection(pName, parent, this.processCollection[pName]);
this.SetIsLoading(-1);
return;
}
}
this.SetIsLoading(1);
SBFile.Read(
processFile,
pName,
this.ReadProcessCompleted,
new ProcessLoadState { HookPoint = hookPoint, ParentDefinitionDescription = parent, Expression = expression, Source = source, SlotType = slotType, SysId = sysid });
});
}
/// <summary>
/// The load basic program from expression.
/// </summary>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="hookPoint">
/// The hook point.
/// </param>
internal void LoadBasicProgramFromExpression(string expression, DefinitionDescription parent = null, string hookPoint = "")
{
string callType;
var programName = ProcessAnalysisViewModel.GetProcessName(expression, out callType);
if (programName.IndexOf("(") > 0)
{
programName = programName.Substring(0, expression.IndexOf("(") - 1);
}
if (string.IsNullOrEmpty(programName))
{
return;
}
this.LoadBasicProgram(programName, parent, expression, hookPoint);
}
/// <summary>
/// The add expression to collection.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="hookPoint">
/// The hook point.
/// </param>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="sysId">
/// The sys id.
/// </param>
internal void AddExpressionToCollection(DefinitionDescription parent, string hookPoint, string expression, string sysId = "")
{
// standard SB expression elements and therefore no need to try read the process, just add the element
// var processDescription = new DefinitionDescription(string.Empty, expression, string.Empty) { Description = hookPoint };
var sbExpression = new SBExpression(parent.FileName, expression, SourceDefinition.Expression, sysId);
// this.AddProcessToCollection(hookPoint, parent, processDescription);
this.AddProcessToCollection(hookPoint, parent, sbExpression);
}
/// <summary>
/// The load basic program.
/// </summary>
/// <param name="programName">
/// The program name.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="hookPoint">
/// The hook point.
/// </param>
private void LoadBasicProgram(
string programName,
DefinitionDescription parent = null,
string expression = "",
string hookPoint = "")
{
JobManager.RunInUIThread(
DispatcherPriority.Input,
delegate
{
// check if I already have the definition in the collection
lock (this.processCollection)
{
if (this.processCollection.ContainsKey(string.Empty, programName, typeof(BasicProgramDescription)))
{
// Debug.WriteLine("[ProcessAnalysisViewModel.LoadBasicProgram(320)] Loaded " + programName + " from cache");
this.AddBasicProgramToCollection(
this.processCollection[programName] as BasicProgramDescription,
new ProcessLoadState
{
Expression = expression,
HookPoint = hookPoint,
ParentDefinitionDescription = parent
});
return;
}
// not in cache so add it.
// Debug.WriteLine("[ProcessAnalysisViewModel.LoadBasicProgram(328)] Added " + programName + " to cache.");
var basicProgramDescription = new BasicProgramDescription(string.Empty, programName);
this.processCollection.Add(basicProgramDescription);
}
this.SetIsLoading(1);
SBFile.Read(
"VOC",
programName,
this.ReadBasicProgramVocPointerCompleted,
new ProcessLoadState { HookPoint = hookPoint, ParentDefinitionDescription = parent, Expression = expression });
});
}
/// <summary>
/// This method will parse out the definition and figure out the type of definition.
/// </summary>
/// <param name="processFileName">
/// The name of the file that contains the process.
/// </param>
/// <param name="pName">
/// The name of the definition.
/// </param>
/// <param name="defn">
/// The definition description.
/// </param>
/// <param name="processLoadState">
/// The information about the definition definition passed from the calling routine.
/// </param>
/// <returns>
/// The <see cref="DefinitionDescription"/>.
/// </returns>
private DefinitionDescription CreateProcessDescription(
string processFileName,
string pName,
SBString defn,
ProcessLoadState processLoadState)
{
DefinitionDescription processDescription;
if (defn == null)
{
if (processLoadState.Source == SourceDefinition.Button)
{
/*
processDescription = new ButtonDefinitionDescription()
{
Description = processLoadState.HookPoint,
pName,
Source
};
*/
processDescription = new ButtonDefinitionDescription(
processFileName,
pName,
SourceDefinition.Process,
processLoadState.Expression);
}
else
{
processDescription = new DefinitionDescription(
processFileName,
pName,
SourceDefinition.Process,
processLoadState.Expression)
{
IsError = true
};
}
return processDescription;
}
switch (defn.Extract(1).Value)
{
case "I":
processDescription = new InputDefinitionDescription(processFileName, pName, processLoadState.Expression, defn);
break;
case "O":
processDescription = new OutputDefinitionDescription(processFileName, pName, processLoadState.Expression, defn);
break;
case "P":
processDescription = this.CreateParagraphDescription(processFileName, pName, processLoadState.Expression, defn);
break;
case "SCREEN":
processDescription = new ScreenDefintion(processFileName, pName, string.Empty, defn);
break;
case "F":
processDescription = new FileUpdateDefinitionDescription(processFileName, pName, string.Empty, defn);
break;
case "M":
processDescription = new MenuDefinitionDescription(processFileName, pName, string.Empty, defn);
break;
case "S":
processDescription = new SelectionProcessDescription(processFileName, pName, SourceDefinition.Process, processLoadState.SysId, defn);
break;
default:
processDescription = new DefinitionDescription(
processFileName,
pName,
SourceDefinition.Process,
processLoadState.Expression);
break;
}
return processDescription;
}
/// <summary>
/// The add process to collection.
/// </summary>
/// <param name="description">
/// The description.
/// </param>
/// <param name="parentDefinitionDescription">
/// The parent definition description.
/// </param>
/// <param name="processDescription">
/// The process description.
/// </param>
/// <param name="source">Where is the process being called from.</param>
private void AddProcessToCollection(
string description,
DefinitionDescription parentDefinitionDescription,
DefinitionDescription processDescription,
SourceDefinition source = SourceDefinition.Unknown)
{
JobManager.RunInDispatcherThread(
DebugWindowManager.DebugConsoleWindow.Dispatcher,
DispatcherPriority.Normal,
delegate
{
if (parentDefinitionDescription == null)
{
this.Definition = processDescription;
this.ResetAnalysis();
this.ProcessStack.Push(this.Definition);
}
else
{
switch (source)
{
case SourceDefinition.Screen:
if (processDescription is SBExpression)
{
this.AddItemToCollection(parentDefinitionDescription.ScreenExpressions, processDescription as SBExpression);
}
else
{
this.AddItemToCollection(
parentDefinitionDescription.ProcessCollection,
new ProcessCall { Description = description, ProcessDescription = processDescription });
}
break;
case SourceDefinition.Button:
//this.AddItemToCollection(description, processDescription, parentDefinitionDescription.ProcessCollection);
this.AddItemToCollection(
parentDefinitionDescription.ProcessCollection,
new ProcessCall { Description = description, ProcessDescription = processDescription });
break;
default:
this.AddItemToCollection(
parentDefinitionDescription.ProcessCollection,
new ProcessCall { Description = description, ProcessDescription = processDescription });
break;
}
}
});
}
/// <summary>
/// The push process.
/// </summary>
/// <param name="stack">
/// The stack.
/// </param>
/// <param name="definition">
/// The definition.
/// </param>
private static void PushProcess(ProcessStack stack, DefinitionDescription definition)
{
// check if there is a definition on the stack, if there is add it to the list of children, not just push it.
if (stack.Count == 0)
{
stack.Push(definition);
}
else
{
var lowestParent = FindLowestProcess(stack.Peek());
if (lowestParent != null)
{
lowestParent.ChildProcesses.Push(definition);
}
}
}
/// <summary>
/// The find lowest process parent.
/// </summary>
/// <param name="definition">
/// The definition.
/// </param>
/// <returns>
/// The <see cref="DefinitionDescription"/>.
/// </returns>
private static DefinitionDescription FindLowestProcessParent(DefinitionDescription definition)
{
// The zero is to prevent an infinite loop - it should never happen.
if (definition.ChildProcesses.Count == 0)
{
return definition;
}
if (definition.ChildProcesses.Count == 1)
{
// I need to look if the child has a definition in it's children.
var childProcessDescription = definition.ChildProcesses.Peek();
if (childProcessDescription.ChildProcesses.Count == 0)
{
return definition;
}
}
return FindLowestProcessParent(definition.ChildProcesses.Peek());
}
/// <summary>
/// The find lowest process.
/// </summary>
/// <param name="definition">
/// The definition.
/// </param>
/// <returns>
/// The <see cref="DefinitionDescription"/>.
/// </returns>
private static DefinitionDescription FindLowestProcess(DefinitionDescription definition)
{
if (definition.ChildProcesses.Count == 0)
{
return definition;
}
return FindLowestProcess(definition.ChildProcesses.Peek());
}
/// <summary>
/// The do update process stack.
/// </summary>
/// <param name="add">
/// The add.
/// </param>
/// <param name="processName">
/// The process name.
/// </param>
/// <param name="actionTime">
/// The action time.
/// </param>
/// <param name="serverActionTime">
/// The server action time.
/// </param>
private static void DoUpdateProcessStack(bool add, string processName, DateTime actionTime, int serverActionTime)
{
try
{
Debug.WriteLine("[DebugViewModel.DoUpdateProcessStack(837)] " + add + ", " + processName);
lock (Instance.ProcessStack)
{
if (add)
{
var historyProcess = new DefinitionDescription(string.Empty, processName)
{
StartTime = actionTime,
ServerStartMilliseconds =
serverActionTime
};
try
{
PushProcess(
Instance.ProcessStack,
new DefinitionDescription(string.Empty, processName)
{
HistoryProcessDescription = historyProcess,
StartTime = actionTime,
ServerStartMilliseconds = serverActionTime
});
}
catch (Exception exception)
{
SBPlusClient.LogError("Exception caught adding " + processName + " to ProcessStack.", exception);
}
lock (Instance.ProcessHistoryStack)
{
try
{
if (Instance.CurrentProcess == null)
{
Instance.ProcessHistoryStack.Push(historyProcess);
}
else
{
Instance.CurrentProcess.ChildProcesses.Push(historyProcess);
}
Instance.CurrentProcess = historyProcess;
}
catch (Exception exception)
{
SBPlusClient.LogError("Exception caught adding " + processName + " to ProcessHistoryStack.", exception);
}
}
}
else
{
try
{
if (Instance.ProcessStack.Count == 0)
{
return;
}
PopProcess(Instance.ProcessStack, actionTime, serverActionTime);
}
catch (Exception exception)
{
CustomLogger.LogException(exception, "Exception caught adding " + processName + " to ProcessHistoryStack.");
}
}
}
}
catch (Exception exception)
{
SBPlusClient.LogError("Exception caught.", exception);
}
}
