- new implementation (oberon; for obcn)

- ilo.st

  - new implementation (smalltalk; for gnu smalltalk)

- ilo-wayland.c

  - new implementation (c, for wayland)

- ilo-x.c

  - double buffering
  - optimizations to drawing process

- milo-x.c

  - double buffering
  - optimizations to drawing process
  - separate display buffers for each session

- ilo+graphica.cs

  - optimizations to drawing process
  - faster keyboard input

IMAGE

- dictionary data now in konilo.pali instead of being built by
  separate preprocessor

BLOCKS

// ilo+graphica.cs, (c) charles childers

using System.Drawing;
using System.Windows.Forms;
using System;
using System.IO;
using System.Text;
using System.Collections.Generic;
using System.Drawing.Imaging;
using System.Threading;
using System.Runtime.InteropServices;

namespace ilo
{
  class VM
  {

    Form window;
    PictureBox display;
    Bitmap framebuffer;

    public int sp, rp, ip;
    public int[] d, a, m;


    private char? keyBuffer = null;
    private readonly AutoResetEvent keyEvent = new AutoResetEvent(false);
    private readonly object keyLock = new object();

    private readonly object pixelLock = new object();
    private readonly object cursorLock = new object();
    private byte[] pixelBuffer = new byte[640 * 480];
    private int[] blitBuffer = new int[640 * 480];
    private bool hasDirty = false;
    private int dirtyMinX = 0, dirtyMinY = 0, dirtyMaxX = 0, dirtyMaxY = 0;
    private volatile bool cursorDirty = true;

    private void Form_KeyPress(object sender, KeyPressEventArgs e)
    {
      lock (keyLock)
      {
        keyBuffer = e.KeyChar == '\r' ? '\n' : e.KeyChar;
      }
      keyEvent.Set();
    }

    public int WaitKey()
    {
      keyEvent.WaitOne();
      lock (keyLock)
      {
        if (!keyBuffer.HasValue)
        {
          return 0;
        }
        char ch = keyBuffer.Value;
        keyBuffer = null;
        return ch;



      }
    }

    public VM()
    {
      sp = 0;
      rp = 0;
      ip = 0;
      d = new int[33];
      a = new int[257];
      m = new int[65536];
      load_rom();

      setup_window();
    }

    public void setup_window()
    {
      ManualResetEvent uiReady = new ManualResetEvent(false);
      var thread = new System.Threading.Thread(() =>
      {
        window = new Form();
        window.Text = "ilo VM Display";
        window.Width = 670;
        window.Height = 530;
        framebuffer = new Bitmap(640, 480);


        display = new PictureBox();
        display.Dock = DockStyle.Fill;
        display.Image = framebuffer;
        display.SizeMode = PictureBoxSizeMode.CenterImage;
        display.BackColor = Color.Black;
        display.Paint += Display_Paint;
        window.Controls.Add(display);
        window.KeyPreview = true;
        window.KeyPress += Form_KeyPress;
        window.FormClosed += (sender, e) => Environment.Exit(0);
        MarkFullDirty();
        SetupRenderTimer();
        uiReady.Set();
        Application.Run(window);
      });
      thread.IsBackground = true;
      thread.SetApartmentState(ApartmentState.STA);
      thread.Start();
      uiReady.WaitOne();
    }

    private void SetupRenderTimer()
    {
      var timer = new System.Windows.Forms.Timer();
      timer.Interval = 16;
      timer.Tick += (sender, args) => FlushFramebuffer();
      timer.Start();
    }

    private void EnsureBlitBuffer(int needed)
    {
      if (blitBuffer.Length < needed) blitBuffer = new int[needed];
    }

    private void MarkDirtyNoLock(int x, int y)
    {
      if (!hasDirty)
      {
        dirtyMinX = dirtyMaxX = x;
        dirtyMinY = dirtyMaxY = y;
        hasDirty = true;
        return;
      }
      if (x < dirtyMinX) dirtyMinX = x;
      if (x > dirtyMaxX) dirtyMaxX = x;
      if (y < dirtyMinY) dirtyMinY = y;
      if (y > dirtyMaxY) dirtyMaxY = y;
    }

    private void MarkFullDirtyNoLock()
    {
      hasDirty = true;
      dirtyMinX = 0;
      dirtyMinY = 0;
      dirtyMaxX = FW - 1;
      dirtyMaxY = FH - 1;
    }

    private void MarkFullDirty()
    {
      lock (pixelLock)
      {
        MarkFullDirtyNoLock();
      }
    }

    private void WriteDirtyRegionToBitmap(Rectangle rect)
    {
      int width = rect.Width;
      int height = rect.Height;
      int needed = width * height;
      EnsureBlitBuffer(needed);
      int idx = 0;
      for (int y = 0; y < height; y++)
      {
        int srcRow = (rect.Y + y) * FW + rect.X;
        for (int x = 0; x < width; x++)
        {
          blitBuffer[idx++] = pixelBuffer[srcRow + x] != 0 ? unchecked((int)0xFFFFFFFF) : unchecked((int)0xFF000000);
        }
      }

      BitmapData data = framebuffer.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
      for (int y = 0; y < height; y++)
      {
        IntPtr rowPtr = IntPtr.Add(data.Scan0, y * data.Stride);
        Marshal.Copy(blitBuffer, y * width, rowPtr, width);
      }
      framebuffer.UnlockBits(data);
    }

    private void FlushFramebuffer()
    {
      Rectangle rect;
      lock (pixelLock)
      {
        if (!hasDirty)
        {
          if (cursorDirty)
          {
            cursorDirty = false;
            display.Invalidate();
          }
          return;
        }
        rect = new Rectangle(dirtyMinX, dirtyMinY, dirtyMaxX - dirtyMinX + 1, dirtyMaxY - dirtyMinY + 1);
        WriteDirtyRegionToBitmap(rect);
        hasDirty = false;
        cursorDirty = false;
      }
      display.Invalidate();
    }

    public void put_pixel(int x, int y, int color)
    {
      if (x < 0 || x >= FW || y < 0 || y >= FH) return;
      byte value = (byte)(color != 0 ? 1 : 0);
      int index = (y * FW) + x;
      lock (pixelLock)
      {
        if (pixelBuffer[index] == value) return;

        pixelBuffer[index] = value;


        MarkDirtyNoLock(x, y);


      }
    }

    public int get_pixel(int x, int y)
    {


      if (x < 0 || x >= FW || y < 0 || y >= FH) return 0;

      int index = (y * FW) + x;






      lock (pixelLock)
      {
        return pixelBuffer[index] != 0 ? 1 : 0;

      }
    }

    private void Display_Paint(object sender, PaintEventArgs e)
    {
      int imageX = (display.Width - framebuffer.Width) / 2;
      int imageY = (display.Height - framebuffer.Height) / 2;

      using (Pen border = new Pen(Color.DarkBlue, 4))
      {
        e.Graphics.DrawRectangle(border, imageX - 2, imageY - 2, framebuffer.Width + 3, framebuffer.Height + 3);
      }

      using (Pen pen = new Pen(Color.Red, 2))
      {
        int localTx, localTy;
        lock (cursorLock)
        {
          localTx = tx;
          localTy = ty;
        }
        int cursorX = imageX + localTx;
        int cursorY = imageY + localTy;
        e.Graphics.DrawRectangle(pen, cursorX, cursorY, FONT_W, FONT_H);
      }
    }

    public void clear_screen()
    {
      lock (pixelLock)
      {
        Array.Clear(pixelBuffer, 0, pixelBuffer.Length);
        MarkFullDirtyNoLock();
      }
    }

    const int FONT_W = 8;  // Font width
    const int FONT_H = 16; // Font height
    const int FW = 640;    // Screen width
    const int FH = 480;    // Screen height
    int tx = 0;            // Cursor x position
    int ty = 0;            // Cursor y position

    byte Reverse(byte b)
    {
      b = (byte)((b & 0xF0) >> 4 | (b & 0x0F) << 4);
      b = (byte)((b & 0xCC) >> 2 | (b & 0x33) << 2);
      b = (byte)((b & 0xAA) >> 1 | (b & 0x55) << 1);
      return b;
    }

    // Special handling result: 0 = none, 1 = handled (no clamp needed), 2 = handled and needs clamp/scroll check
    int HandleSpecialCharacter(int c)
    {
      if (c == 8 || c == 127) // BACKSPACE/DELETE
      {
        int eraseX, eraseY;
        lock (cursorLock)
        {
          if (tx - FONT_W < 0)
          {
            cursorDirty = true;
            return 1;
          }
          tx -= FONT_W;
          eraseX = tx;

          eraseY = ty;
          cursorDirty = true;
        }
        DrawGlyphAt(eraseX, eraseY, ' ');
        return 1;
      }
      else if (c == 9) // TAB
      {
        int ts;
        lock (cursorLock) { ts = tx / FONT_W; }
        for (int i = ts; i < ((ts + 7) / 8) * 8; i++)
        {
          Dputc(' ');
        }
        return 1;
      }
      else if (c == 10 || c == 13) // CR or LF
      {
        lock (cursorLock)
        {
          ty += FONT_H;
          tx = 0;
          cursorDirty = true;
        }
        return 2;
      }
      return 0;
    }

    void DrawGlyphAt(int x, int y, int c)
    {
      int index = c * ((FONT_H * FONT_W) / 8);
      byte[] bitmap = new byte[FONT_H];
      Array.Copy(font, index, bitmap, 0, FONT_H);
      HandleRegularCharacter(bitmap, x, y);
    }

    void HandleRegularCharacter(byte[] bitmap, int originX, int originY)
    {
      for (int x = 0; x < FONT_H; x++)
      {
        for (int y = 0; y < FONT_W; y++)
        {
          int set = Reverse(bitmap[x]) & (1 << y);
          put_pixel(originX + y, originY + x, set != 0 ? -1 : 0);
        }
      }

    }

    void AdvanceCursorAndScroll()
    {
      bool needScroll = false;
      lock (cursorLock)
      {
        if (tx >= FW)
        {
          tx = 0;
          ty += FONT_H;
        }
        if (ty > (FH - FONT_H))
        {
          ty = FH - FONT_H;
          needScroll = true;
        }
        cursorDirty = true;
      }
      if (needScroll) Scroll();
    }

    public void Scroll()
    {
      lock (pixelLock)
      {




        int rowWidth = FW;
        int srcOffset = FONT_H * rowWidth;
        int copyBytes = (FH - FONT_H) * rowWidth;
        Buffer.BlockCopy(pixelBuffer, srcOffset, pixelBuffer, 0, copyBytes);
        Array.Clear(pixelBuffer, copyBytes, FONT_H * rowWidth);



        MarkFullDirtyNoLock();
      }
    }

    void Redraw()
    {
      cursorDirty = true;
    }

    void Dputc(int c)
    {
      int special = HandleSpecialCharacter(c);
      if (special != 0)
      {
        if (special == 2) AdvanceCursorAndScroll();
        return;
      }

      int index = c * ((FONT_H * FONT_W) / 8);
      byte[] bitmap = new byte[FONT_H];

      Array.Copy(font, index, bitmap, 0, FONT_H);
      int originX, originY;
      lock (cursorLock)
      {
        originX = tx;
        originY = ty;
      }
      HandleRegularCharacter(bitmap, originX, originY);
      lock (cursorLock)
      {
        tx = originX + FONT_W;
        ty = originY;
        cursorDirty = true;
      }
      AdvanceCursorAndScroll();
    }

    private int[] acc = new int[32];
    private int acc_i = 0;
    private int on = 0;

    {
      for (int x = 0; x < 32; x++) acc[x] = 0;
      ground = on = 0;
    }

    public void gt_up(int n)
    {
      lock (cursorLock)
      {
        ty -= FONT_H;
        if (ty < 0) ty = 0;
        cursorDirty = true;
      }
    }

    public void gt_down(int n)
    {
      lock (cursorLock)
      {
        ty += FONT_H;
        if (ty > 24 * FONT_H) ty = 24 * FONT_H;
        cursorDirty = true;
      }
    }

    public void gt_left(int n)
    {
      lock (cursorLock)
      {
        tx -= FONT_W;
        if (tx < 0) tx = 0;
        cursorDirty = true;
      }
    }

    public void gt_right(int n)
    {
      lock (cursorLock)
      {
        tx += FONT_W;
        if (tx > 79 * FONT_W) tx = 79 * FONT_W;
        cursorDirty = true;
      }
    }

    public void gt_move_cursor()
    {
      if (acc_i >= 1)
      {
        int a = (acc_pop() - 1) * FONT_W;
        int b = (acc_pop() - 1) * FONT_H;
        lock (cursorLock)
        {
          ty = b;
          if (ty < 0) ty = 0;
          if (ty > FONT_H * 24) ty = FONT_H * 24;
          tx = a;
          if (tx < 0) tx = 0;
          if (tx > FONT_W * 79) tx = FONT_W * 79;
          cursorDirty = true;
        }
        acc_reset();
        return;
      }
      lock (cursorLock)
      {
        tx = 0;
        ty = 0;
        cursorDirty = true;
      }
      acc_reset();
    }

    public void gt_reset()
    {
      acc_reset();
    }

    public void gt_next()
    {
      acc_i += 1;
      if (acc_i >= acc.Length) acc_i = acc.Length - 1;
      acc[acc_i] = 0;
    }

    public void gt_clear()
    {
      acc_reset();
      clear_screen();
      lock (cursorLock)
      {
        tx = ty = 0;

        cursorDirty = true;
      }
    }

    public void gt_set_attr()
    {
      acc_reset();
    }

    public void ioen() { ip = 65536; }
    public void iost() { sp++; d[sp] = sp - 1; sp++; d[sp] = rp; }

    public void iopp() { int color = d[sp]; sp--;
      int y = d[sp]; sp--;
      int x = d[sp]; sp--;
      put_pixel(x, y, color);

    }

    public void iogp() { int y = d[sp]; sp--; int x = d[sp]; d[sp] = get_pixel(x, y); }
    public void ioms() { Point pos = window.PointToClient(Cursor.Position);
      int x = pos.X;
      int y = pos.Y;
      bool leftDown = (Control.MouseButtons & MouseButtons.Left) != 0;