1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Windows.Forms;
using O2.Kernel.ExtensionMethods;
using O2.DotNetWrappers.Windows;
using System.IO;

namespace O2.DotNetWrappers.ExtensionMethods
{
    public static class Processes_ExtensionMethods
    {

        public static Process getProcessWithWindowTitle(this string processName, string windowTitle)
        {
            foreach (var process in Processes.getProcessesCalled(processName))
                if (process.MainWindowTitle == windowTitle)
                    return process;
            return null;
        }

        // TODO: Double check if the name still matches the behaviour (and if there are no duplicate methods)

        public static Process exeConsoleOut(this TextBox textBox, string processToStart)
        {
            return textBox.exeConsoleOut(processToStart, "");
        }

        public static Process exeConsoleOut(this TextBox textBox, string processToStart, string arguments)
        {
            return textBox.startProcessAndShowConsoleOut(processToStart, arguments);
        }

        public static Process startProcessAndShowConsoleOut(this TextBox textBox, string processToStart)
        {
            return textBox.startProcessAndShowConsoleOut(processToStart, "");
        }

        public static Process startProcessAndShowConsoleOut(this TextBox textBox, string processToStart, string arguments)
        {
            textBox.set_Text("");
            return startConsoleApp(processToStart, arguments, (text) => textBox.append_Line(text));
        }

        public static Process exeConsoleOutWithConsoleIn(this TextBox textBox, string processToStart)
        {
            return textBox.exeConsoleOutWithConsoleIn(processToStart, "");
        }

        public static Process exeConsoleOutWithConsoleIn(this TextBox textBox, string processToStart, string arguments)
        {
            return textBox.startProcessMapConsoleOutAndReturnConsoleIn(processToStart, arguments);
        }

        public static Process startProcessMapConsoleOutAndReturnConsoleIn(this TextBox textBox, string processToStart, string arguments)
        {
            return startConsoleAppAndRedirectInput(
                        processToStart, arguments,
                        (text) => textBox.append_Line(text),
                        (text) => textBox.append_Line(text));
        }

        public static Process write(this Process process, string textToSendToStandardInput)
        {
            if (process.StandardInput != null)
                process.StandardInput.WriteLine(textToSendToStandardInput.line());
            return process;
        }

        public static Process stop(this Process process)
        {
            if (process != null)
                if (process.HasExited.isFalse())
                    process.Kill();
            return process;
        }

        // add to main Processes.cs file
        public static Process startConsoleApp(string processToStart, string arguments, Action<string> consoleOut)
        {
            var pProcess = new Process
            {
                StartInfo =
                {
                    Arguments = arguments,
                    FileName = processToStart,
                    UseShellExecute = false,
                    //RedirectStandardInput  = true,
                    //RedirectStandardOutput = true,
                    //RedirectStandardError = true,
                    //CreateNoWindow = false
                }
            };
            pProcess.EnableRaisingEvents = true;
            pProcess.Exited += (sender, e) => "Process exited".error();

            pProcess.ErrorDataReceived +=
                (sender, e) =>
                {
                    if (e.Data.valid())
                        consoleOut(e.Data);
                };


            pProcess.OutputDataReceived +=
                    (sender, e) =>
                    {
                        if (e.Data.valid())
                            consoleOut(e.Data);
                    };

            pProcess.Start();
            //pProcess.BeginErrorReadLine();
            //pProcess.BeginOutputReadLine();
            //            pProcess.be();
            return pProcess;

            /*return Processes.startProcessAsConsoleApplication(
                processToStart,
                arguments,
                (sender, e) => {
                                    if(e.Data.valid())
                                        consoleOut(e.Data);
                               });	    						   */
        }

        public static Process startConsoleAppAndRedirectInput(string processToStart, string arguments, Action<string> consoleOut, Action<string> consoleError)
        {
            var memoryStream = new MemoryStream();
            var streamWriter = new StreamWriter(memoryStream);

            var process = Processes.startProcessAndRedirectIO(
                                        processToStart, arguments, ref streamWriter,
                                        (sender, e) =>
                                        {
                                            if (e.Data.valid())
                                                consoleOut(e.Data);
                                        },
                                        (sender, e) =>
                                        {
                                            if (e.Data.valid())
                                                consoleError(e.Data);
                                        });
            //return streamWriter; // not using this since the use the extension method procecess.write(...)
            return process;
        }

        public static List<Process> stop(this List<Process> processesToStop)
        {
            foreach (var process in processesToStop)
                if (process.HasExited == false)
                    process.Kill();
            return processesToStop;
        }	
    }
}