MindBlow: Brainfuck IDE for ShiftOS

For 50,000 Codepoints you can write and run Brainfuck programs in
a dedicated IDE. Check out the site on "shiftnet/mindblow".

The IDE seems to be working perfectly. The site has some theming
issues.

1 files changed, 183 insertions, 0 deletions

diff --git a/ShiftOS.WinForms/Applications/MindBlow.cs b/ShiftOS.WinForms/Applications/MindBlow.cs
new file mode 100644
index 0000000..22f5011
--- /dev/null
+++ b/ShiftOS.WinForms/Applications/MindBlow.cs
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using ShiftOS.Engine;
+using System.IO;
+using System.Threading;
+
+namespace ShiftOS.WinForms.Applications
+{
+    [WinOpen("mindblow")]
+    [Launcher("MindBlow", false, null, "Utilities")]
+    [RequiresUpgrade("mindblow")]
+    public partial class MindBlow : UserControl, IShiftOSWindow, IBFListener
+    {
+        private class TextBoxStream : Stream
+        {
+            private TextBox box;
+            private KeysConverter kc;
+            public TextBoxStream(TextBox mybox)
+            {
+                kc = new KeysConverter();
+                box = mybox;
+            }
+            public override bool CanRead => true;
+
+            public override bool CanSeek => false;
+
+            public override bool CanWrite => true;
+
+            public override long Length => box.Text.Length;
+
+            public override long Position { get => Length; set => throw new NotImplementedException(); }
+
+            public override void Flush()
+            {
+            }
+
+            public override int Read(byte[] buffer, int offset, int count)
+            {
+                object lck = new object();
+                int ptr = offset;
+                KeyPressEventHandler handler = (o, a) =>
+                {
+                    lock (lck)
+                    {
+                        buffer[ptr] = (byte)a.KeyChar;
+                        ptr++;
+                    }
+                };
+                Desktop.InvokeOnWorkerThread(() => box.KeyPress += handler);
+                while (true)
+                {
+                    lock (lck)
+                        if (ptr >= offset + count)
+                            break;
+                }
+                Desktop.InvokeOnWorkerThread(() => box.KeyPress -= handler);
+                return count;
+            }
+
+            public override long Seek(long offset, SeekOrigin origin)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override void SetLength(long value)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override void Write(byte[] buffer, int offset, int count)
+            {
+                string output = "";
+                foreach (byte b in buffer.Skip(offset).Take(count))
+                    output += Convert.ToChar(b);
+                Desktop.InvokeOnWorkerThread(() => box.Text += output);
+            }
+        }
+        private static string[] DefaultMem;
+        private BFInterpreter Interpreter;
+
+        private void DoLayout()
+        {
+            memlist.Left = 0;
+            memlist.Width = monitor.Width;
+            memlist.Height = monitor.Height - memlist.Top;
+            program.Top = 0;
+            program.Left = 0;
+            programinput.Width = program.Width;
+            programinput.Height = program.Height - load.Height;
+            load.Top = save.Top = run.Top = programinput.Height;
+            load.Width = save.Width = run.Width = save.Left = program.Width / 3;
+            run.Left = save.Left * 2;
+        }
+
+        public MindBlow()
+        {
+            InitializeComponent();
+            DefaultMem = new string[30000];
+            for (ushort i = 0; i < 30000; i++)
+                DefaultMem[i] = "0";
+            memlist.Items.AddRange(DefaultMem);
+            Interpreter = new BFInterpreter(new TextBoxStream(consoleout), this);
+        }
+
+        public void IPtrMoved(int newval)
+        {
+            Desktop.InvokeOnWorkerThread(() => instptr.Text = "Instruction: " + newval.ToString());
+        }
+
+        public void MemChanged(ushort pos, byte newval)
+        {
+            Desktop.InvokeOnWorkerThread(() => memlist.Items[pos] = newval.ToString());
+        }
+
+        public void MemReset()
+        {
+            Desktop.InvokeOnWorkerThread(() =>
+            {
+                memlist.Items.Clear();
+                memlist.Items.AddRange(DefaultMem);
+            });
+        }
+
+        public void OnLoad()
+        {
+            DoLayout();
+        }
+
+        public void OnSkinLoad()
+        {
+        }
+
+        public bool OnUnload()
+        {
+            return true;
+        }
+
+        public void OnUpgrade()
+        {
+        }
+
+        public void PointerMoved(ushort newval)
+        {
+            Desktop.InvokeOnWorkerThread(() => memptr.Text = "Memory: " + newval.ToString());
+        }
+
+        private void MindBlow_Resize(object sender, EventArgs e)
+        {
+            DoLayout();
+        }
+
+        private void run_Click(object sender, EventArgs e)
+        {
+            new Thread(() =>
+            {
+                Interpreter.Reset();
+                Interpreter.Execute(programinput.Text);
+            }).Start();
+        }
+
+        private void tabs_Selected(object sender, TabControlEventArgs e)
+        {
+            DoLayout();
+        }
+
+        private void load_Click(object sender, EventArgs e)
+        {
+            AppearanceManager.SetupDialog(new FileDialog(new string[] { ".bf" }, FileOpenerStyle.Open, new Action<string>((file) => programinput.Text = Objects.ShiftFS.Utils.ReadAllText(file))));
+        }
+
+        private void save_Click(object sender, EventArgs e)
+        {
+            AppearanceManager.SetupDialog(new FileDialog(new string[] { ".bf" }, FileOpenerStyle.Save, new Action<string>((file) => Objects.ShiftFS.Utils.WriteAllText(file, programinput.Text))));
+        }
+    }
+}