private void LoadDebugTab(TabPage debugTab)
        {
            if (InvokeRequired)
            {
                var d = new LoadDebugTabDelegate(LoadDebugTab);
                Invoke(d, new object[] { debugTab });
            }
            else
            {
                DataTable variableValues = new DataTable();
                variableValues.Columns.Add("Name");
                variableValues.Columns.Add("Type");
                variableValues.Columns.Add("Value");
                variableValues.TableName = "VariableValuesDataTable" + DateTime.Now.ToString("MMddyyhhmmss");

                DataGridView variablesGridViewHelper = new DataGridView();
                variablesGridViewHelper.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
                variablesGridViewHelper.Dock = DockStyle.Fill;
                variablesGridViewHelper.ColumnHeadersHeight   = 30;
                variablesGridViewHelper.AutoSizeColumnsMode   = DataGridViewAutoSizeColumnsMode.Fill;
                variablesGridViewHelper.AllowUserToAddRows    = false;
                variablesGridViewHelper.AllowUserToDeleteRows = false;
                variablesGridViewHelper.ReadOnly = true;

                if (debugTab.Controls.Count != 0)
                {
                    debugTab.Controls.RemoveAt(0);
                }
                debugTab.Controls.Add(variablesGridViewHelper);

                List <ScriptVariable> engineVariables = ((frmScriptEngine)CurrentEngine).EngineInstance.VariableList;
                foreach (var variable in engineVariables)
                {
                    DataRow[] foundVariables = variableValues.Select("Name = '" + variable.VariableName + "'");
                    if (foundVariables.Length == 0)
                    {
                        string type = "null";
                        if (variable.VariableValue != null)
                        {
                            type = variable.VariableValue.GetType().FullName;
                        }

                        variableValues.Rows.Add(variable.VariableName, type, StringMethods.ConvertObjectToString(variable.VariableValue));
                    }
                }
                variablesGridViewHelper.DataSource = variableValues;
                uiPaneTabs.SelectedTab             = debugTab;
            }
        }
        public override void RunCommand(object sender)
        {
            var engine = (AutomationEngineInstance)sender;

            int closeAfter = int.Parse(v_AutoCloseAfter.ConvertUserVariableToString(engine));

            dynamic variableMessage = v_Message.ConvertUserVariableToString(engine);

            if (variableMessage == v_Message && variableMessage.StartsWith("{") && variableMessage.EndsWith("}"))
            {
                variableMessage = v_Message.ConvertUserVariableToObject(engine);
            }

            string type = "";

            if (variableMessage != null)
            {
                type = variableMessage.GetType().FullName;
            }

            if (variableMessage is string)
            {
                variableMessage = variableMessage.Replace("\\n", Environment.NewLine);
            }
            else
            {
                variableMessage = type + Environment.NewLine + StringMethods.ConvertObjectToString(variableMessage);
            }

            if (engine.ScriptEngineUI == null)
            {
                engine.ReportProgress("Complex Messagebox Supported With UI Only");
                MessageBox.Show(variableMessage, "Message Box Command", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            //automatically close messageboxes for server requests
            if (engine.IsServerExecution && closeAfter <= 0)
            {
                closeAfter = 10;
            }

            var result = ((frmScriptEngine)engine.ScriptEngineUI).Invoke(new Action(() =>
            {
                engine.ScriptEngineUI.ShowMessage(variableMessage, "MessageBox", DialogType.OkOnly, closeAfter);
            }
                                                                                    ));
        }
        public async override Tasks.Task RunCommand(object sender)
        {
            var engine = (IAutomationEngineInstance)sender;

            int closeAfter = (int)await v_AutoCloseAfter.EvaluateCode(engine);

            var variableMessage = await v_Message.EvaluateCode(engine);

            Type varMessageType = null;

            if (variableMessage != null)
            {
                varMessageType = variableMessage.GetType();
            }
            var message = StringMethods.ConvertObjectToString(variableMessage, varMessageType);

            if (engine.EngineContext.ScriptEngine == null)
            {
                engine.ReportProgress("Complex Messagebox Supported With UI Only");

                if (closeAfter > 0)
                {
                    var autoCloseForm = new Form()
                    {
                        Size = new Size(0, 0)
                    };
                    Tasks.Task.Delay(TimeSpan.FromSeconds(closeAfter))
                    .ContinueWith((t) => autoCloseForm.Close(), TaskScheduler.FromCurrentSynchronizationContext());

                    MessageBox.Show(autoCloseForm, message, "Message Box Command", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    MessageBox.Show(message, "Message Box Command", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }

                return;
            }

            var result = ((Form)engine.EngineContext.ScriptEngine).Invoke(new Action(() =>
            {
                engine.EngineContext.ScriptEngine.ShowMessage(message, "MessageBox", DialogType.OkOnly, closeAfter);
            }
                                                                                     ));
        }
Ejemplo n.º 4
0
        private void LoadDebugTab(TabPage debugTab)
        {
            if (InvokeRequired)
            {
                var d = new LoadDebugTabDelegate(LoadDebugTab);
                Invoke(d, new object[] { debugTab });
            }
            else
            {
                DataTable variableValues = new DataTable();
                variableValues.Columns.Add("Name");
                variableValues.Columns.Add("Type");
                variableValues.Columns.Add("Value");
                variableValues.TableName = "VariableValuesDataTable" + DateTime.Now.ToString("MMddyyhhmmss");

                DataGridView variableGridViewHelper = new DataGridView();
                variableGridViewHelper.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
                variableGridViewHelper.AutoSize                = true;
                variableGridViewHelper.Dock                    = DockStyle.Fill;
                variableGridViewHelper.ColumnHeadersHeight     = 30;
                variableGridViewHelper.AutoSizeColumnsMode     = DataGridViewAutoSizeColumnsMode.Fill;
                variableGridViewHelper.AllowUserToAddRows      = false;
                variableGridViewHelper.AllowUserToDeleteRows   = false;
                variableGridViewHelper.ReadOnly                = true;
                variableGridViewHelper.CellContentDoubleClick += DebugGridViewHelper_CellContentDoubleClick;
                variableGridViewHelper.BorderStyle             = BorderStyle.None;

                DataTable argumentValues = new DataTable();
                argumentValues.Columns.Add("Name");
                argumentValues.Columns.Add("Type");
                argumentValues.Columns.Add("Value");
                argumentValues.Columns.Add("Direction");
                argumentValues.TableName = "ArgumentValuesDataTable" + DateTime.Now.ToString("MMddyyhhmmss");

                DataGridView argumentGridViewHelper = new DataGridView();
                argumentGridViewHelper.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
                argumentGridViewHelper.AutoSize                = true;
                argumentGridViewHelper.Dock                    = DockStyle.Fill;
                argumentGridViewHelper.ColumnHeadersHeight     = 30;
                argumentGridViewHelper.AutoSizeColumnsMode     = DataGridViewAutoSizeColumnsMode.Fill;
                argumentGridViewHelper.AllowUserToAddRows      = false;
                argumentGridViewHelper.AllowUserToDeleteRows   = false;
                argumentGridViewHelper.ReadOnly                = true;
                argumentGridViewHelper.CellContentDoubleClick += DebugGridViewHelper_CellContentDoubleClick;
                argumentGridViewHelper.BorderStyle             = BorderStyle.None;

                if (debugTab.Controls[0].Controls.Count != 0)
                {
                    debugTab.Controls[0].Controls.Clear();
                }

                Label variableLabel = new Label();
                variableLabel.Text      = "Variables";
                variableLabel.ForeColor = Color.White;

                Label argumentLabel = new Label();
                argumentLabel.Text      = "Arguments";
                argumentLabel.ForeColor = Color.White;

                debugTab.Controls[0].Controls.Add(variableLabel);
                debugTab.Controls[0].Controls.Add(variableGridViewHelper);
                debugTab.Controls[0].Controls.Add(argumentLabel);
                debugTab.Controls[0].Controls.Add(argumentGridViewHelper);

                List <ScriptVariable> engineVariables = ((frmScriptEngine)CurrentEngine).EngineInstance.AutomationEngineContext.Variables;

                foreach (var variable in engineVariables)
                {
                    DataRow[] foundVariables = variableValues.Select("Name = '" + variable.VariableName + "'");
                    if (foundVariables.Length == 0)
                    {
                        string type = variable.VariableType.FullName;
                        if (variable.VariableValue != null && StringMethods.ConvertObjectToString(variable.VariableValue, variable.VariableType).Length > 40000)
                        {
                            variableValues.Rows.Add(variable.VariableName, type, StringMethods.ConvertObjectToString(variable.VariableValue, variable.VariableType).Substring(0, 40000));
                        }
                        else
                        {
                            variableValues.Rows.Add(variable.VariableName, type, StringMethods.ConvertObjectToString(variable.VariableValue, variable.VariableType));
                        }
                    }
                }

                List <ScriptArgument> engineArguments = ((frmScriptEngine)CurrentEngine).EngineInstance.AutomationEngineContext.Arguments;

                foreach (var argument in engineArguments)
                {
                    DataRow[] foundArguments = argumentValues.Select("Name = '" + argument.ArgumentName + "'");
                    if (foundArguments.Length == 0)
                    {
                        string type = argument.ArgumentType.FullName;
                        argumentValues.Rows.Add(argument.ArgumentName, type, StringMethods.ConvertObjectToString(argument.ArgumentValue, argument.ArgumentType),
                                                argument.Direction.ToString());
                    }
                }

                variableGridViewHelper.DataSource = variableValues;
                argumentGridViewHelper.DataSource = argumentValues;
                uiPaneTabs.SelectedTab            = debugTab;

                variableGridViewHelper.Sort(variableGridViewHelper.Columns["Name"], ListSortDirection.Ascending);
                argumentGridViewHelper.Sort(argumentGridViewHelper.Columns["Name"], ListSortDirection.Ascending);
            }
        }