/// <summary>
/// The create paragraph description.
/// </summary>
/// <param name="processFileName">
/// The process file name.
/// </param>
/// <param name="pName">
/// The p name.
/// </param>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="defn">
/// The defn.
/// </param>
/// <returns>
/// The <see cref="ParagraphDescription"/>.
/// </returns>
private ParagraphDescription CreateParagraphDescription(string processFileName, string pName, string expression, SBString defn)
{
var processDescription = new ParagraphDescription(processFileName, pName, expression, defn);
// Now parse out the paragraph to find definition and basic program calls
var paragraphExpression = defn.Extract(3).Value;
var elements = paragraphExpression.Split(GenericConstants.CHAR_ARRAY_SEMI_COLON);
// C0;AP4;P4;C1;=;I2;EP.BRANCH,INT.CALL;J5;P4;C2;=;I1;BBASIC.PROGRAM
foreach (var element in elements)
{
if (string.IsNullOrEmpty(element.Trim()))
{
continue;
}
switch (element.Substring(0, 1))
{
case "E":
this.LoadProcessFromExpression(
SourceDefinition.Paragraph,
SourceDefinition.Process,
element.Substring(1),
processDescription,
"Execute");
break;
case "B":
this.LoadBasicProgramFromExpression(element.Substring(1), processDescription, "Call");
break;
}
}
return processDescription;
}
/// <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 parse definition.
/// </summary>
/// <param name="definition">
/// The definition.
/// </param>
private void ParseDefinition(SBString definition)
{
/*
Type 2
1: vertical box
2: horiz boxtype.
3: user painted
4: as 3 + select no
5: horiz box with linked sub-menus (for GUI)
*
* Option Description 6.M C
* Name 7.M D
* Type (M/P/T/>/H/C/X) 8.M D
*
* Process before menu display 13.1
* Process after display 13.2
* Process after select option 13.3
* Process after execution of option 13.4
* Process after escaping this menu 13.5
* Process before returning to SYSMENU or LOGIN 13.6
* Process to determine box cords 13.7
* Subroutine to call at start 13.8
*/
switch (definition.Extract(MenuType).Value)
{
case "1":
this.ProcessMenuOptions(definition);
break;
case "2":
this.ProcessMenuOptions(definition);
break;
case "3":
break;
case "4":
break;
case "5":
break;
}
}
/// <summary>
/// The process menu options.
/// </summary>
/// <param name="definition">
/// The definition.
/// </param>
private void ProcessMenuOptions(SBString definition)
{
try
{
var noOptions = definition.Extract(MenuOptionType).Dcount();
for (int optNo = 1; optNo <= noOptions; optNo++)
{
var desc = definition.Extract(Options, optNo).Value;
var type = definition.Extract(MenuOptionType, optNo).Value;
var process = definition.Extract(ProcessName, optNo).Value;
if (type.Equals("P") && !string.IsNullOrEmpty(process))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Menu,
SourceDefinition.Process,
process,
this,
desc);
}
}
}
catch (Exception exception)
{
this.IsError = true;
CustomLogger.LogException(exception, "There was a problem process the menu '" + this.Name + "'");
}
}
/// <summary>
/// The update definition stack.
/// </summary>
/// <param name="add">
/// The add.
/// </param>
/// <param name="processName">
/// The definition name.
/// </param>
/// <param name="paramaters">
/// The proc name.
/// </param>
public static void UpdateProcessStack(bool add, string processName, SBString paramaters)
{
var actionTime = DateTime.Now;
try
{
int serverActionTime = 0;
if (paramaters.Extract(1, 1).Dcount() > 1)
{
int.TryParse(paramaters.Extract(1, 1, 1).Value, out serverActionTime);
CustomLogger.LogDebug(() => string.Format("Add {0} {1} at {2}.", add, processName, serverActionTime));
}
else
{
CustomLogger.LogDebug(() => string.Format("Add {0} {1}.", add, processName));
}
if (DebugWindowManager.DebugConsoleWindow == null)
{
// no debug windows.
return;
}
if (Thread.CurrentThread.ManagedThreadId != DebugWindowManager.DebugConsoleWindow.Dispatcher.Thread.ManagedThreadId)
{
JobManager.RunInDispatcherThread(
DebugWindowManager.DebugConsoleWindow.Dispatcher,
DispatcherPriority.Normal,
() => DoUpdateProcessStack(add, processName, actionTime, serverActionTime));
}
else
{
DoUpdateProcessStack(add, processName, actionTime, serverActionTime);
}
}
catch (Exception exception)
{
SBPlusClient.LogError("Exception caught.", exception);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ScreenProcessDescription"/> class.
/// </summary>
/// <param name="fileName">
/// The name of the file that contains the screen.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="definition">
/// The definition.
/// </param>
public ScreenProcessDescription(string fileName, string name, string expression, SBString definition)
: this(fileName, name, expression)
{
if (!string.IsNullOrWhiteSpace(definition.Extract(5, 1).Value))
{
this.Dictionary = definition.Extract(5, 1).Value;
this.ProcessCollection.Add(
new ProcessCall { Description = "Dictionary", ProcessDescription = new DictionaryDescription(this.Dictionary) });
}
if (!string.IsNullOrWhiteSpace(definition.Extract(6).Value))
{
this.ScreenName = definition.Extract(6).Value;
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadScreen(this.ScreenName, this.Dictionary, this, "Screen");
// Now check if there are linked screens. To do this see if the last character is numeric. If it is go back until you find the first non-numeric. Now
// we have a starting point, loop adding 1 untill there is no hit.
int startIndex = this.ScreenName.Length - 1;
while (SBXA.Shared.Utilities.IsNumber(this.ScreenName.Substring(startIndex)))
{
startIndex++;
}
startIndex--; // because it would have been incremented one beyond.
if (!string.IsNullOrEmpty(this.ScreenName.Substring(startIndex))
&& Utilities.IsNumber(this.ScreenName.Substring(startIndex)))
{
var nextScreen = Convert.ToInt16(this.ScreenName.Substring(startIndex)) + 1;
var prefix = this.ScreenName.Substring(0, startIndex);
DebugViewModel.Instance.ProcessAnalysisViewModel.SetIsLoading(1);
// I have a starting point, now read the definition.
SBFile.ReadDictionaryItem(
this.Dictionary,
prefix + nextScreen,
new object[] { nextScreen, prefix, this.Dictionary },
this.ReadLinkedScreenCompleted);
}
}
// load the list of processes
if (!string.IsNullOrWhiteSpace(definition.Extract(8, 1).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(8, 1).Value,
this,
"Before");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(8, 2).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(8, 2).Value,
this,
"After");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(8, 7).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(8, 7).Value,
this,
"Before Display");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(8, 8).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(8, 8).Value,
this,
"Before Action Bar Option");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(8, 4).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(8, 4).Value,
this,
"After Action Bar Option");
}
}
/// <summary>
/// The parse screen definition.
/// </summary>
/// <param name="definition">
/// The definition.
/// </param>
private void ParseScreenDefinition(SBString definition)
{
const int ButtonDesc = 11;
const int Buttons = 12;
const int Fields = 15;
const int ProcessesBefore = 25;
const int ProcessesAfter = 26;
const int IntHelp = 27;
const int FieldPos = 31;
const int ConversionCode = 34;
const int DefaultDerived = 35;
const int Validation = 36;
// So far I have not found where or what this is, in the BRANCH S1 screen it looks like a hangove from rev control. const int InputConversion = 39;
const int StyleName = 51;
try
{
// fields
var noFields = definition.Dcount(Fields);
for (int fno = 1; fno <= noFields; fno++)
{
var processBefore = (definition.Dcount() >= ProcessesBefore && definition.Extract(ProcessesBefore).Dcount() >= fno)
? definition.Extract(ProcessesBefore, fno).Value
: string.Empty;
var processAfter = (definition.Dcount() >= ProcessesAfter && definition.Extract(ProcessesAfter).Dcount() >= fno)
? definition.Extract(ProcessesAfter, fno).Value
: string.Empty;
var intuitiveHelp = (definition.Dcount() >= IntHelp && definition.Extract(IntHelp).Dcount() >= fno)
? definition.Extract(IntHelp, fno).Value
: string.Empty;
var conversionCode = (definition.Dcount() >= ConversionCode && definition.Extract(ConversionCode).Dcount() >= fno)
? definition.Extract(ConversionCode, fno).Value
: string.Empty;
var fieldDefault = string.Empty;
if (definition.Dcount() >= FieldPos && definition.Extract(FieldPos).Dcount() >= fno)
{
fieldDefault = (!string.IsNullOrEmpty(definition.Extract(FieldPos, fno).Value)
&& definition.Extract(FieldPos, fno).Value.Substring(0, 1).Equals("0"))
? string.Empty
: definition.Extract(DefaultDerived, fno).Value;
}
var derived = string.Empty;
if (definition.Dcount() >= FieldPos && definition.Extract(FieldPos).Dcount() >= fno)
{
derived = (!string.IsNullOrEmpty(definition.Extract(FieldPos, fno).Value)
&& definition.Extract(FieldPos, fno).Value.Substring(0, 1).Equals("0"))
? string.Empty
: definition.Extract(DefaultDerived, fno).Value;
}
var validation = (definition.Dcount() >= Validation && definition.Extract(Validation).Dcount() >= fno)
? definition.Extract(Validation, fno).Value
: string.Empty;
var styleName = (definition.Dcount() >= StyleName && definition.Extract(StyleName).Dcount() >= fno)
? definition.Extract(StyleName, fno).Value
: string.Empty;
this.FieldDescriptions.Add(
new ScreenFieldDefinition(this.FileName, definition.Extract(Fields, fno).Value)
{
ProcessBefore = processBefore,
ProcessAfter = processAfter,
IntuitiveHelp = intuitiveHelp,
ConversionCode = conversionCode,
FieldDefault = fieldDefault,
Derived = derived,
Validation = validation,
StyleName = styleName
});
}
// Buttons
var noButtons = definition.Dcount(Buttons);
for (int bNo = 1; bNo <= noButtons; bNo++)
{
if (!definition.Extract(Buttons, bNo).IsNullOrEmpty())
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Button,
SourceDefinition.Process,
definition.Extract(Buttons, bNo).Value,
this,
"Button " + definition.Extract(ButtonDesc, bNo).Value);
}
}
// load the list of processes
if (!string.IsNullOrWhiteSpace(definition.Extract(7, 1).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(7, 1).Value,
this,
"Before Screen Display");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(7, 2).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(7, 2).Value,
this,
"After Screen Display");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(7, 3).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(7, 3).Value,
this,
"After Read Record");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(7, 4).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(7, 4).Value,
this,
"After Accept");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(7, 5).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(7, 5).Value,
this,
"After Update");
}
if (!string.IsNullOrWhiteSpace(definition.Extract(7, 6).Value))
{
DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression(
SourceDefinition.Screen,
SourceDefinition.Process,
definition.Extract(7, 6).Value,
this,
"If Escape");
}
// Buttons
}
catch (Exception exception)
{
CustomLogger.LogException(exception, "Exception parsing screen definition");
// MessageBox.Show("Exception parsing screen definition (" + exception.Message + ")");
}
}