/// <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 + "'");
     }
 }
Ejemplo n.º 5
0
        /// <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");
            }
        }
Ejemplo n.º 7
0
        /// <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 + ")");
            }
        }