EMCC: Emscripten version wip

- added keyboard handling
- added text editing

Author: chrisws

src/platform/emcc/canvas.cpp

@@ -357,11 +357,11 @@ void maDrawImageRegion(MAHandle maHandle, const MARect *srcRect, const MAPoint2d
 }
 
 void maDrawRGB(const MAPoint2d *dstPoint, const void *src,  const MARect *srcRect, int opacity, int stride) {
-  logEntered();
+  appLog("maDrawRGB not yet implemented");
 }
 
 void maGetImageData(MAHandle maHandle, void *dst, const MARect *srcRect, int stride) {
-  logEntered();
+  appLog("maGetImageData not yet implemented");
 }
 
 //

src/platform/emcc/keymap.h

@@ -0,0 +1,42 @@
+// This file is part of SmallBASIC
+//
+// Copyright(C) 2001-2022 Chris Warren-Smith.
+//
+// This program is distributed under the terms of the GPL v2.0 or later
+// Download the GNU Public License (GPL) from www.gnu.org
+//
+
+#pragma once
+
+const int KEYMAP[][2] = {
+  {DOM_VK_RETURN, SB_KEY_ENTER},
+  {DOM_VK_ESCAPE, SB_KEY_ESCAPE},
+  {DOM_VK_ENTER, SB_KEY_ENTER},
+  {DOM_VK_TAB, SB_KEY_TAB},
+  {DOM_VK_BACK_SPACE, SB_KEY_BACKSPACE},
+  {DOM_VK_DELETE, SB_KEY_DELETE},
+  {DOM_VK_UP, SB_KEY_UP},
+  {DOM_VK_DOWN, SB_KEY_DN},
+  {DOM_VK_LEFT, SB_KEY_LEFT},
+  {DOM_VK_RIGHT, SB_KEY_RIGHT},
+  {DOM_VK_PAGE_UP, SB_KEY_PGUP},
+  {DOM_VK_PAGE_DOWN, SB_KEY_PGDN},
+  {DOM_VK_HOME, SB_KEY_HOME},
+  {DOM_VK_END, SB_KEY_END},
+  {DOM_VK_INSERT, SB_KEY_INSERT},
+  {DOM_VK_F1, SB_KEY_F(1)},
+  {DOM_VK_F2, SB_KEY_F(2)},
+  {DOM_VK_F3, SB_KEY_F(3)},
+  {DOM_VK_F4, SB_KEY_F(4)},
+  {DOM_VK_F5, SB_KEY_F(5)},
+  {DOM_VK_F6, SB_KEY_F(6)},
+  {DOM_VK_F7, SB_KEY_F(7)},
+  {DOM_VK_F8, SB_KEY_F(8)},
+  {DOM_VK_F9, SB_KEY_F(9)},
+  {DOM_VK_F10, SB_KEY_F(10)},
+  {DOM_VK_F11, SB_KEY_F(11)},
+  {DOM_VK_F12, SB_KEY_F(12)}
+};
+
+const int KEYMAP_LEN = sizeof(KEYMAP) / sizeof(KEYMAP[0]);
+

src/platform/emcc/runtime.cpp

@@ -9,13 +9,15 @@
 #include "config.h"
 
 #include <emscripten.h>
+#include <emscripten/key_codes.h>
 #include "include/osd.h"
 #include "common/smbas.h"
 #include "lib/maapi.h"
 #include "ui/utils.h"
 #include "ui/theme.h"
 #include "platform/emcc/runtime.h"
 #include "platform/emcc/main_bas.h"
+#include "platform/emcc/keymap.h"
 
 #define MAIN_BAS "__main_bas__"
 #define WAIT_INTERVAL 10
@@ -32,7 +34,7 @@ MAEvent *getMotionEvent(int type, const EmscriptenMouseEvent *event) {
   return result;
 }
 
-MAEvent *getKeyPressedEvent(int keycode, int nativeKey) {
+MAEvent *getKeyPressedEvent(int keycode, int nativeKey = 0) {
   MAEvent *result = new MAEvent();
   result->type = EVENT_TYPE_KEY_PRESSED;
   result->key = keycode;
@@ -98,10 +100,6 @@ void Runtime::browseFile(const char *url) {
     }, url);
 }
 
-char *Runtime::getClipboardText() {
-  return nullptr;
-}
-
 char *Runtime::loadResource(const char *fileName) {
   logEntered();
   char *buffer = System::loadResource(fileName);
@@ -114,12 +112,38 @@ char *Runtime::loadResource(const char *fileName) {
 }
 
 void Runtime::handleKeyboard(int eventType, const EmscriptenKeyboardEvent *e) {
-  trace("eventType: %d [%s %s %s] [%d %d %d] %s%s%s%s ",
-        eventType,
-        e->key, e->code, e->charValue,
-        e->charCode,      e->keyCode,      e->which,
-        e->ctrlKey ? " CTRL" : "", e->shiftKey ? " SHIFT" : "", e->altKey ? " ALT" : "", e->metaKey ? " META" : "");
-
+  int keyCode = e->keyCode;
+  switch (e->keyCode) {
+  case DOM_VK_SHIFT:
+  case DOM_VK_CONTROL:
+  case DOM_VK_ALT:
+  case DOM_VK_CAPS_LOCK:
+    // ignore press without modifier key
+    break;
+  default:
+    for (int i = 0; i < KEYMAP_LEN; i++) {
+      if (keyCode == KEYMAP[i][0]) {
+        keyCode = KEYMAP[i][1];
+        break;
+      }
+    }
+    if (e->ctrlKey && e->altKey) {
+      pushEvent(getKeyPressedEvent(SB_KEY_CTRL_ALT(keyCode)));
+    } else if (e->ctrlKey && e->shiftKey) {
+      pushEvent(getKeyPressedEvent(SB_KEY_SHIFT_CTRL(keyCode)));
+    } else if (e->altKey && e->shiftKey) {
+      pushEvent(getKeyPressedEvent(SB_KEY_ALT_SHIFT(keyCode)));
+    } else if (e->ctrlKey) {
+      pushEvent(getKeyPressedEvent(SB_KEY_CTRL(keyCode)));
+    } else if (e->altKey) {
+      pushEvent(getKeyPressedEvent(SB_KEY_ALT(keyCode)));
+    } else if (e->shiftKey) {
+      pushEvent(getKeyPressedEvent(SB_KEY_SHIFT(keyCode)));
+    } else {
+      pushEvent(getKeyPressedEvent(keyCode));
+    }
+    break;
+  }
 }
 
 void Runtime::handleMouse(int eventType, const EmscriptenMouseEvent *e) {
@@ -221,9 +245,6 @@ void Runtime::runShell() {
   _state = kDoneState;
 }
 
-void Runtime::setClipboardText(const char *text) {
-}
-
 void Runtime::showCursor(CursorType cursorType) {
   static CursorType _cursorType;
   if (_cursorType != cursorType) {
@@ -234,6 +255,207 @@ void Runtime::showCursor(CursorType cursorType) {
   }
 }
 
+void System::editSource(strlib::String loadPath, bool restoreOnExit) {
+  logEntered();
+
+  strlib::String fileName;
+  int i = loadPath.lastIndexOf('/', 0);
+  if (i != -1) {
+    fileName = loadPath.substring(i + 1);
+  } else {
+    fileName = loadPath;
+  }
+
+  strlib::String dirtyFile;
+  dirtyFile.append(" * ");
+  dirtyFile.append(fileName);
+  strlib::String cleanFile;
+  cleanFile.append(" - ");
+  cleanFile.append(fileName);
+
+  int w = _output->getWidth();
+  int h = _output->getHeight();
+  int charWidth = _output->getCharWidth();
+  int charHeight = _output->getCharHeight();
+  int prevScreenId = _output->selectScreen(SOURCE_SCREEN);
+  TextEditInput *editWidget;
+  if (_editor != nullptr) {
+    editWidget = _editor;
+    editWidget->_width = w;
+    editWidget->_height = h;
+  } else {
+    editWidget = new TextEditInput(_programSrc, charWidth, charHeight, 0, 0, w, h);
+  }
+  auto *helpWidget = new TextEditHelpWidget(editWidget, charWidth, charHeight, false);
+  auto *widget = editWidget;
+  _modifiedTime = getModifiedTime();
+  editWidget->updateUI(nullptr, nullptr);
+  editWidget->setLineNumbers();
+  editWidget->setFocus(true);
+
+  _output->clearScreen();
+  _output->addInput(editWidget);
+  _output->addInput(helpWidget);
+
+  if (gsb_last_line && isBreak()) {
+    String msg = "Break at line: ";
+    msg.append(gsb_last_line);
+    alert("Error", msg);
+  } else if (gsb_last_error && !isBack()) {
+    // program stopped with an error
+    editWidget->setCursorRow(gsb_last_line + editWidget->getSelectionRow() - 1);
+    alert("Error", gsb_last_errmsg);
+  }
+
+  bool showStatus = !editWidget->getScroll();
+  _srcRendered = false;
+  _output->setStatus(showStatus ? cleanFile : "");
+  _output->redraw();
+  _state = kEditState;
+
+  while (_state == kEditState) {
+    MAEvent event = getNextEvent();
+    switch (event.type) {
+    case EVENT_TYPE_POINTER_PRESSED:
+      if (!showStatus && widget == editWidget && event.point.x < editWidget->getMarginWidth()) {
+        _output->setStatus(editWidget->isDirty() ? dirtyFile : cleanFile);
+        _output->redraw();
+        showStatus = true;
+      }
+      break;
+    case EVENT_TYPE_POINTER_RELEASED:
+      if (showStatus && event.point.x < editWidget->getMarginWidth() && editWidget->getScroll()) {
+        _output->setStatus("");
+        _output->redraw();
+        showStatus = false;
+      }
+      break;
+    case EVENT_TYPE_OPTIONS_BOX_BUTTON_CLICKED:
+      if (editWidget->isDirty() && !editWidget->getScroll()) {
+        _output->setStatus(dirtyFile);
+        _output->redraw();
+      }
+      break;
+    case EVENT_TYPE_KEY_PRESSED:
+      if (_userScreenId == -1) {
+        int sw = _output->getScreenWidth();
+        bool redraw = true;
+        bool dirty = editWidget->isDirty();
+        char *text;
+
+        switch (event.key) {
+        case SB_KEY_F(2):
+        case SB_KEY_F(3):
+        case SB_KEY_F(4):
+        case SB_KEY_F(5):
+        case SB_KEY_F(6):
+        case SB_KEY_F(7):
+        case SB_KEY_F(8):
+        case SB_KEY_F(10):
+        case SB_KEY_F(11):
+        case SB_KEY_F(12):
+        case SB_KEY_MENU:
+        case SB_KEY_ESCAPE:
+        case SB_KEY_BREAK:
+          // unhandled keys
+          redraw = false;
+        break;
+        case SB_KEY_F(1):
+          widget = helpWidget;
+          helpWidget->createKeywordIndex();
+          helpWidget->showPopup(-4, -2);
+          helpWidget->setFocus(true);
+          showStatus = false;
+          break;
+        case SB_KEY_F(9):
+          _state = kRunState;
+          if (editWidget->isDirty()) {
+            saveFile(editWidget, loadPath);
+          }
+          break;
+        case SB_KEY_CTRL('s'):
+          saveFile(editWidget, loadPath);
+          break;
+        case SB_KEY_CTRL('c'):
+        case SB_KEY_CTRL('x'):
+          text = widget->copy(event.key == (int)SB_KEY_CTRL('x'));
+        if (text) {
+          setClipboardText(text);
+          free(text);
+        }
+        break;
+        case SB_KEY_CTRL('v'):
+          text = getClipboardText();
+          widget->paste(text);
+          free(text);
+          break;
+        case SB_KEY_CTRL('o'):
+          _output->selectScreen(USER_SCREEN1);
+          showCompletion(true);
+          _output->redraw();
+          _state = kActiveState;
+          waitForBack();
+          _output->selectScreen(SOURCE_SCREEN);
+          _state = kEditState;
+          break;
+        default:
+          redraw = widget->edit(event.key, sw, charWidth);
+          break;
+        }
+        if (editWidget->isDirty() != dirty && !editWidget->getScroll()) {
+          _output->setStatus(editWidget->isDirty() ? dirtyFile : cleanFile);
+        }
+        if (redraw) {
+          _output->redraw();
+        }
+      }
+    }
+
+    if (isBack() && widget == helpWidget) {
+      widget = editWidget;
+      helpWidget->hide();
+      editWidget->setFocus(true);
+      _state = kEditState;
+      _output->redraw();
+    }
+
+    if (widget->isDirty()) {
+      int choice = -1;
+      if (isClosing()) {
+        choice = 0;
+      } else if (isBack()) {
+        const char *message = "The current file has not been saved.\n"
+                              "Would you like to save it now?";
+        choice = ask("Save changes?", message, isBack());
+      }
+      if (choice == 0) {
+        widget->save(loadPath);
+      } else if (choice == 2) {
+        // cancel
+        _state = kEditState;
+      }
+    }
+  }
+
+  if (_state == kRunState) {
+    // allow the editor to be restored on return
+    if (!_output->removeInput(editWidget)) {
+      trace("Failed to remove editor input");
+    }
+    _editor = editWidget;
+    _editor->setFocus(false);
+  } else {
+    _editor = nullptr;
+  }
+
+  // deletes editWidget unless it has been removed
+  _output->removeInputs();
+  if (!isClosing() && restoreOnExit) {
+    _output->selectScreen(prevScreenId);
+  }
+  logLeaving();
+}
+
 //
 // ma event handling
 //
@@ -262,12 +484,18 @@ void maWait(int timeout) {
 //
 // System platform methods
 //
-void System::editSource(strlib::String loadPath, bool restoreOnExit) {
-  // empty
-}
-
 bool System::getPen3() {
-  return false;
+  bool result = false;
+  if (_touchX != -1 && _touchY != -1) {
+    result = true;
+  } else {
+    // get mouse
+    processEvents(0);
+    if (_touchX != -1 && _touchY != -1) {
+      result = true;
+    }
+  }
+  return result;
 }
 
 void System::completeKeyword(int index) {

src/platform/emcc/runtime.h

@@ -19,7 +19,7 @@ struct Runtime : public System {
   void alert(const char *title, const char *message);
   int  ask(const char *title, const char *prompt, bool cancel=true);
   void browseFile(const char *url);
-  char *getClipboardText();
+  char *getClipboardText() { return nullptr; }
   int  getFontSize() { return _output->getFontSize(); }
   void enableCursor(bool enabled) {}
   int  handle(int event);
@@ -37,7 +37,7 @@ struct Runtime : public System {
   bool run(const char *bas) { return execute(bas); }
   void runShell();
   void resize(int w, int h);
-  void setClipboardText(const char *text);
+  void setClipboardText(const char *text) {}
   void setFontSize(int size);
   void setLoadBreak(const char *url) {}
   void setLoadPath(const char *url) {}