# data file for the Fltk User Interface Designer (fluid)
version 1.0109 
do_not_include_H_from_C 
header_name {.hpp} 
code_name {.cpp}
decl {\#include "gui.hpp"} {selected
} 

decl {\#include "script.hpp"} {} 

decl {\#include "debuglib.hpp"} {} 

decl {\#include "debugger.hpp"} {} 

decl {\#include <vector>} {} 

decl {\#include <FL/Fl_Text_Buffer.H>} {} 

class Ep128EmuGUI_DebugWindow {open
} {
  decl {friend class Ep128EmuGUIMonitor;} {public
  }
  decl {friend class Ep128EmuGUI_LuaScript;} {public
  }
  decl {Ep128EmuGUI& gui;} {}
  decl {char windowTitle[64];} {}
  decl {int savedWindowPositionX;} {}
  decl {int savedWindowPositionY;} {}
  decl {Fl_Widget *focusWidget;} {}
  decl {Fl_Widget *prvTab;} {}
  decl {uint32_t memoryDumpStartAddress;} {}
  decl {uint32_t memoryDumpViewAddress;} {}
  decl {uint8_t memoryDumpAddressMode;} {}
  decl {int32_t ixViewOffset;} {}
  decl {int32_t iyViewOffset;} {}
  decl {uint32_t disassemblyStartAddress;} {}
  decl {uint32_t disassemblyViewAddress;} {}
  decl {uint32_t disassemblyNextAddress;} {}
  decl {Fl_Text_Buffer *bpEditBuffer;} {}
  decl {Fl_Text_Buffer *scriptEditBuffer;} {}
  decl {std::string breakPointLists[6];} {}
  decl {std::string tmpBuffer;} {}
  decl {Ep128EmuGUI_LuaScript luaScript;} {}
  decl {Ep128EmuGUI_DebugWindow(Ep128EmuGUI& gui_);} {public
  }
  decl {~Ep128EmuGUI_DebugWindow();} {public
  }
  decl {void show();} {public
  }
  decl {bool shown() const;} {public
  }
  decl {void hide();} {public
  }
  decl {void activate();} {public
  }
  decl {bool active() const;} {public
  }
  decl {void deactivate(double tt = 0.1);} {public
  }
  decl {bool breakPoint(int type, uint16_t addr, uint8_t value);} {public
  }
  decl {void updateWindow();} {public
  }
  decl {void dumpMemory(std::string& buf, uint32_t startAddr, uint32_t endAddr, uint32_t cursorAddr, bool showCursor, uint8_t addressMode);} {}
  decl {char * dumpMemoryAtRegister(char *bufp, const char *regName, uint16_t addr, int byteCnt, uint32_t cursorAddr = 0xFFFFFFFFU);} {}
  decl {void updateMemoryDumpDisplay();} {}
  decl {void updateIOPortDisplay();} {}
  decl {void updateDisassemblyDisplay();} {}
  decl {uint32_t disassemblySearchBack(int insnCnt);} {}
  decl {void applyBreakPointList();} {}
  decl {static void breakPointCallback(void *userData, int type, uint16_t addr, uint8_t value);} {public
  }
  decl {static void hideWindowCallback(void *userData);} {}
  Function {createDebugWindow()} {open private return_type void
  } {
    Fl_Window window {
      callback {{
  if (breakPointEditor->changed()) {
    breakPointEditor->clear_changed();
    breakPointEditor->do_callback();
  }
  focusWidget = (Fl_Widget *) 0;
  gui.vm.setSingleStepMode(0);
  this->hide();
}} open
      xywh {146 98 960 720} type Double color 48 resizable size_range {920 700 1080 810} visible
    } {
      Fl_Tabs debugTabs {
        callback {{
  if (prvTab == monitorTab)
    updateWindow();
  prvTab = o->value();
}} open
        xywh {10 10 940 665}
      } {
        Fl_Group mainTab {
          label {Page 1} open
          xywh {10 35 940 640} box THIN_UP_BOX
        } {
          Fl_Group {} {open
            xywh {20 45 515 245} box THIN_UP_BOX align 21
          } {
            Fl_Output cpuRegisterDisplay {
              label {CPU registers}
              xywh {30 70 495 80} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
            }
            Fl_Output stackMemoryDumpDisplay {
              label Stack
              xywh {30 175 360 105} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
            }
            Fl_Output memoryPagingDisplay {
              label {Memory paging}
              xywh {400 175 125 105} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
            }
          }
          Fl_Group {} {open
            xywh {545 45 395 152} box THIN_UP_BOX align 21
          } {
            Fl_Output ioPortDisplay {
              label {I/O registers}
              xywh {555 70 375 117} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
            }
          }
          Fl_Group {} {open
            xywh {20 300 515 365} box THIN_UP_BOX align 21
          } {
            Fl_Input searchStringValuator {
              label Search
              callback {{
  if (o->value()) {
    try {
      std::vector<std::string>  args;
      {
        std::string tmp("H ");
        tmp += o->value();
        Ep128Emu::tokenizeString(args, tmp.c_str());
      }
      if (memoryDumpAddressMode > 1) {
        // cannot search I/O ports, force CPU address mode
        memoryDumpAddressMode = 1;
        memoryDumpAddressModeValuator->value(1);
      }
      int32_t addr = monitor_->searchPattern(
          args, 1, args.size() - 1,
          memoryDumpViewAddress + 1U, memoryDumpViewAddress,
          bool(memoryDumpAddressMode));
      if (addr >= 0) {
        memoryDumpViewAddress = uint32_t(addr);
        updateMemoryDumpDisplay();
      }
      else
        throw Ep128Emu::Exception("Search string not found");
    }
    catch (std::exception& e) {
      gui.errorMessage(e.what());
    }
  }
}}
              tooltip {The search string can be specified with the syntax used by the H and SR monitor commands} xywh {30 325 375 25} align 5 when 10 textfont 4
              code0 {o->cursor_color(Fl_Color(3));}
            }
            Fl_Button {} {
              label {Find next}
              callback {{
  searchStringValuator->do_callback();
}}
              xywh {415 325 110 25} color 50 selection_color 51
            }
            Fl_Output memoryDumpDisplay {
              label {Memory dump}
              xywh {30 375 375 105} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
              class Ep128EmuGUI_ScrollableOutput
            }
            Fl_Choice memoryDumpAddressModeValuator {
              callback {{
  memoryDumpAddressMode = uint8_t(o->value());
  updateMemoryDumpDisplay();
}} open
              tooltip {Select if 16 bit CPU, 22 bit physical, or I/O addresses are to be used} xywh {415 375 110 25} down_box BORDER_BOX
              code0 {o->add("Physical address|CPU address|IO address");}
              code1 {o->value(1);}
            } {}
            Fl_Input memoryDumpStartAddressValuator {
              label {Start address}
              callback {{
  if (Ep128Emu::parseHexNumber(memoryDumpStartAddress, o->value())) {
    if (memoryDumpStartAddress != memoryDumpViewAddress) {
      memoryDumpViewAddress = memoryDumpStartAddress;
      updateMemoryDumpDisplay();
    }
  }
}}
              xywh {415 420 110 25} align 5 textfont 4
              code0 {o->cursor_color(Fl_Color(3));}
              code1 {o->value("0000");}
            }
            Fl_Button memoryDumpPrvPageButton {
              label {@<}
              callback {{
  memoryDumpViewAddress = (memoryDumpViewAddress + 0x3FFFE0U) & 0x3FFFFFU;
  updateMemoryDumpDisplay();
}}
              tooltip {View previous page} xywh {415 455 35 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {@|<}
              callback {{
  if (memoryDumpStartAddress != memoryDumpViewAddress) {
    memoryDumpViewAddress = memoryDumpStartAddress;
    updateMemoryDumpDisplay();
  }
}}
              tooltip {Return to start address} xywh {455 455 30 25} color 50 selection_color 51
            }
            Fl_Button memoryDumpNxtPageButton {
              label {@>}
              callback {{
  memoryDumpViewAddress = (memoryDumpViewAddress + 0x000020U) & 0x3FFFFFU;
  updateMemoryDumpDisplay();
}}
              tooltip {View next page} xywh {490 455 35 25} color 50 selection_color 51
            }
            Fl_Output memoryDisplay_BC_DE_HL {
              xywh {30 490 495 51} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
            }
            Fl_Output memoryDisplay_IX {
              xywh {30 547 375 51} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
              class Ep128EmuGUI_ScrollableOutput
            }
            Fl_Button ixPrvPageButton {
              label {@<}
              callback {{
  ixViewOffset = ((ixViewOffset + 0x0170) & 0xF0) - 0x80;
  updateMemoryDumpDisplay();
}}
              tooltip {View previous page} xywh {415 560 35 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {@|<}
              callback {{
  if (ixViewOffset != 0) {
    ixViewOffset = 0;
    updateMemoryDumpDisplay();
  }
}}
              tooltip {Reset IX view offset to zero} xywh {455 560 30 25} color 50 selection_color 51
            }
            Fl_Button ixNxtPageButton {
              label {@>}
              callback {{
  ixViewOffset = ((ixViewOffset + 0x0190) & 0xF0) - 0x80;
  updateMemoryDumpDisplay();
}}
              tooltip {View next page} xywh {490 560 35 25} color 50 selection_color 51
            }
            Fl_Output memoryDisplay_IY {
              xywh {30 604 375 51} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
              class Ep128EmuGUI_ScrollableOutput
            }
            Fl_Button iyPrvPageButton {
              label {@<}
              callback {{
  iyViewOffset = ((iyViewOffset + 0x0170) & 0xF0) - 0x80;
  updateMemoryDumpDisplay();
}}
              tooltip {View previous page} xywh {415 617 35 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {@|<}
              callback {{
  if (iyViewOffset != 0) {
    iyViewOffset = 0;
    updateMemoryDumpDisplay();
  }
}}
              tooltip {Reset IY view offset to zero} xywh {455 617 30 25} color 50 selection_color 51
            }
            Fl_Button iyNxtPageButton {
              label {@>}
              callback {{
  iyViewOffset = ((iyViewOffset + 0x0190) & 0xF0) - 0x80;
  updateMemoryDumpDisplay();
}}
              tooltip {View next page} xywh {490 617 35 25} color 50 selection_color 51
            }
          }
          Fl_Group {} {open
            xywh {545 207 395 458} box THIN_UP_BOX align 21
          } {
            Fl_Output disassemblyDisplay {
              label Disassembler
              xywh {555 232 375 378} type Multiline align 5 textfont 5 textcolor 2
              code0 {o->cursor_color(FL_BACKGROUND2_COLOR);}
              class Ep128EmuGUI_ScrollableOutput
            }
            Fl_Input disassemblyStartAddressValuator {
              label {Start address}
              callback {{
  if (Ep128Emu::parseHexNumber(disassemblyStartAddress, o->value()))
    disassemblyViewAddress = disassemblyStartAddress;
  updateDisassemblyDisplay();
}}
              xywh {560 630 115 25} align 5 textfont 4
              code0 {o->cursor_color(Fl_Color(3));}
              code1 {o->value("0000");}
            }
            Fl_Button disassemblyPrvPageButton {
              label {@<}
              callback {{
  disassemblyViewAddress = disassemblySearchBack(20);
  updateDisassemblyDisplay();
}}
              tooltip {View previous page} xywh {685 630 55 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {@|<}
              callback {{
  if (disassemblyViewAddress != disassemblyStartAddress) {
    disassemblyViewAddress = disassemblyStartAddress;
    updateDisassemblyDisplay();
  }
}}
              tooltip {Return to start address} xywh {745 630 55 25} color 50 selection_color 51
            }
            Fl_Button disassemblyNxtPageButton {
              label {@>}
              callback {{
  disassemblyViewAddress = disassemblyNextAddress;
  updateDisassemblyDisplay();
}}
              tooltip {View next page} xywh {805 630 55 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label PC
              callback {{
  disassemblyViewAddress = gui.vm.getProgramCounter();
  updateDisassemblyDisplay();
}}
              tooltip {View code at the program counter} xywh {870 630 55 25} color 50 selection_color 51
            }
          }
        }
        Fl_Group monitorTab {
          label {Page 2} open
          xywh {10 35 940 640} box THIN_UP_BOX hide
        } {
          Fl_Group {} {open
            xywh {20 45 530 365} box THIN_UP_BOX align 21
          } {
            Fl_Text_Editor monitor_ {
              tooltip {Type ? for a list of available monitor commands, or ? CMD for help on command CMD} xywh {30 55 510 345} when 0 textfont 5 textcolor 2
              code0 {o->setDebugger(*this);}
              code1 {o->cursor_style(Fl_Text_Display::BLOCK_CURSOR);}
              code2 {o->cursor_color(Fl_Color(3));}
              class Ep128EmuGUIMonitor
            }
          }
          Fl_Group {} {open
            xywh {560 45 380 365} box THIN_UP_BOX align 21
          } {
            Fl_Text_Editor breakPointEditor {
              callback {{
  applyBreakPointList();
}}
              tooltip {Enter watchpoint definitions, separated by spaces or newlines. Allowed formats include NN (I/O), NNNN (memory, CPU address), and NN:NNNN (memory, physical address as segment:offset); each N is a hexadecimal digit. Address ranges (separated by a - character) can also be specified. Use the following suffixes to check for read, write, or execute access only, set priority, or ignore watchpoints depending on the program counter: r, w, x, p0, p1, p2, p3, i.} xywh {570 55 360 255} box DOWN_BOX align 5 textfont 4
              code0 {o->cursor_color(Fl_Color(3));}
              code1 {o->buffer(bpEditBuffer);}
              code2 {o->scrollbar_align(FL_ALIGN_RIGHT);}
            }
            Fl_Value_Slider bpPriorityThresholdValuator {
              label {Priority threshold}
              callback {{
  gui.config.debug.bpPriorityThreshold = int(o->value() + 0.5);
  gui.config.debugSettingsChanged = true;
  try {
    gui.config.applySettings();
  }
  catch (std::exception& e) {
    gui.errorMessage(e.what());
  }
}}
              xywh {575 331 145 23} type Horizontal color 47 selection_color 52 align 5 maximum 4 step 1
            }
            Fl_Button {} {
              label {Load from file}
              callback {{
  std::FILE *f = (std::FILE *) 0;
  try {
    std::string tmp;
    if (gui.browseFile(tmp, gui.debuggerDirectory,
                       "All files\\t*", Fl_Native_File_Chooser::BROWSE_FILE,
                       "Load watchpoint definitions from file")) {
      f = Ep128Emu::fileOpen(tmp.c_str(), "rb");
      if (!f)
        throw Ep128Emu::Exception("cannot open file");
      tmp = "";
      bool  crFlag = false;
      while (true) {
        int   c = std::fgetc(f);
        if (crFlag) {
          crFlag = false;
          if (c == '\\n')
            continue;
        }
        if (c == EOF)
          break;
        if (char(c) == '\\0')
          continue;
        if (c == '\\r') {
          tmp += '\\n';
          crFlag = true;
        }
        else
          tmp += char(c);
      }
      std::fclose(f);
      f = (std::FILE *) 0;
      bpEditBuffer->text(tmp.c_str());
      Ep128Emu::BreakPointList  bpList(tmp);
      gui.vm.clearBreakPoints();
      gui.vm.setBreakPoints(bpList);
    }
  }
  catch (std::exception& e) {
    if (f)
      std::fclose(f);
    gui.errorMessage(e.what());
  }
}}
              xywh {780 330 145 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {Save to file}
              callback {{
  std::FILE   *f = (std::FILE *) 0;
  const char  *buf = (char *) 0;
  try {
    std::string tmp;
    if (gui.browseFile(tmp, gui.debuggerDirectory,
                       "All files\\t*",
                       Fl_Native_File_Chooser::BROWSE_SAVE_FILE,
                       "Save watchpoint definitions to file")) {
      f = Ep128Emu::fileOpen(tmp.c_str(), "w");
      if (!f)
        throw Ep128Emu::Exception("cannot open file");
      buf = bpEditBuffer->text();
      if (!buf)
        throw std::bad_alloc();
      const char  *bufp = buf;
      char        c = '\\0';
      while ((*bufp) != '\\0') {
        c = *(bufp++);
        if (std::fputc(c, f) == EOF)
          throw Ep128Emu::Exception("error writing file - is the disk full ?");
      }
      if (c != '\\n') {
        if (std::fputc('\\n', f) == EOF)
          throw Ep128Emu::Exception("error writing file - is the disk full ?");
      }
      std::free(const_cast<char *>(buf));
      std::fclose(f);
    }
  }
  catch (std::exception& e) {
    if (buf)
      std::free(const_cast<char *>(buf));
    if (f)
      std::fclose(f);
    gui.errorMessage(e.what());
  }
}}
              xywh {780 370 145 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label Apply
              callback {{
  applyBreakPointList();
}}
              tooltip {Reset watchpoints from text format definition} xywh {575 370 145 25} color 50 selection_color 51
            }
          }
          Fl_Group {} {open
            xywh {20 420 920 245} box THIN_UP_BOX align 21
          } {
            Fl_Text_Editor luaScriptEditor {
              tooltip {Lua script editor (for documentation, see the README file)} xywh {30 430 740 225} box DOWN_BOX align 5 textfont 4
              code0 {o->cursor_color(Fl_Color(3));}
              code1 {o->buffer(scriptEditBuffer);}
              code2 {o->scrollbar_align(FL_ALIGN_RIGHT);}
            }
            Fl_Button {} {
              label {Load from file}
              callback {{
  std::FILE *f = (std::FILE *) 0;
  try {
    std::string tmp;
    if (gui.browseFile(tmp, gui.debuggerDirectory,
                       "Lua scripts\\t*.lua",
                       Fl_Native_File_Chooser::BROWSE_FILE,
                       "Load Lua script from file")) {
      f = Ep128Emu::fileOpen(tmp.c_str(), "rb");
      if (!f)
        throw Ep128Emu::Exception("cannot open file");
      tmp = "";
      bool  crFlag = false;
      while (true) {
        int   c = std::fgetc(f);
        if (crFlag) {
          crFlag = false;
          if (c == '\\n')
            continue;
        }
        if (c == EOF)
          break;
        if (char(c) == '\\0')
          continue;
        if (c == '\\r') {
          tmp += '\\n';
          crFlag = true;
        }
        else
          tmp += char(c);
      }
      std::fclose(f);
      f = (std::FILE *) 0;
      scriptEditBuffer->text(tmp.c_str());
    }
  }
  catch (std::exception& e) {
    if (f)
      std::fclose(f);
    gui.errorMessage(e.what());
  }
}}
              xywh {780 435 145 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {Save to file}
              callback {{
  std::FILE   *f = (std::FILE *) 0;
  const char  *buf = (char *) 0;
  try {
    std::string tmp;
    if (gui.browseFile(tmp, gui.debuggerDirectory,
                       "Lua scripts\\t*.lua",
                       Fl_Native_File_Chooser::BROWSE_SAVE_FILE,
                       "Save Lua script to file")) {
      f = Ep128Emu::fileOpen(tmp.c_str(), "w");
      if (!f)
        throw Ep128Emu::Exception("cannot open file");
      buf = scriptEditBuffer->text();
      if (!buf)
        throw std::bad_alloc();
      const char  *bufp = buf;
      char        c = '\\0';
      while ((*bufp) != '\\0') {
        c = *(bufp++);
        if (std::fputc(c, f) == EOF)
          throw Ep128Emu::Exception("error writing file - is the disk full ?");
      }
      if (c != '\\n') {
        if (std::fputc('\\n', f) == EOF)
          throw Ep128Emu::Exception("error writing file - is the disk full ?");
      }
      std::free(const_cast<char *>(buf));
      std::fclose(f);
    }
  }
  catch (std::exception& e) {
    if (buf)
      std::free(const_cast<char *>(buf));
    if (f)
      std::fclose(f);
    gui.errorMessage(e.what());
  }
}}
              xywh {780 470 145 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label {Insert callback}
              callback {{
  try {
    scriptEditBuffer->insert(luaScriptEditor->insert_position(),
                             "\\nfunction breakPointCallback(t, a, v)\\n"
                             "  return true\\n"
                             "end\\n");
  }
  catch (std::exception& e) {
    gui.errorMessage(e.what());
  }
}}
              tooltip {Insert breakpoint callback function template} xywh {780 530 145 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label Run
              callback {{
  const char  *buf = (char *) 0;
  try {
    buf = scriptEditBuffer->text();
    if (!buf)
      throw std::bad_alloc();
    luaScript.loadScript(buf);
    std::free(const_cast<char *>(buf));
    buf = (char *) 0;
    updateWindow();
  }
  catch (std::exception& e) {
    if (buf)
      std::free(const_cast<char *>(buf));
    gui.errorMessage(e.what());
  }
}}
              tooltip {Run or restart the Lua script, and enable the breakpoint callback if it is defined} xywh {780 590 145 25} color 50 selection_color 51
            }
            Fl_Button {} {
              label Stop
              callback {{
  luaScript.closeScript();
}}
              tooltip {Disable the Lua breakpoint callback} xywh {780 625 145 25} color 50 selection_color 51
            }
          }
        }
      }
      Fl_Button stepIntoButton {
        label {Step into}
        callback {{
  focusWidget = stepButton;
  gui.vm.setSingleStepMode(4);
  this->deactivate();
}}
        xywh {330 685 80 25} selection_color 50
      }
      Fl_Button returnButton {
        label Return
        callback {{
  focusWidget = stepButton;
  gui.vm.setSingleStepMode(2);
  uint16_t  tmp = gui.vm.getStackPointer();
  uint32_t  tmp2 = gui.vm.readMemory(tmp, true);
  tmp = (tmp + 1) & 0xFFFF;
  tmp2 = tmp2 | (uint32_t(gui.vm.readMemory(tmp, true)) << 8);
  gui.vm.setSingleStepModeNextAddress(int32_t(tmp2));
  this->deactivate();
}}
        xywh {420 685 80 25} selection_color 50
      }
      Fl_Button stepToButton {
        label {Step to:}
        callback {{
  uint32_t  tmp = 0U;
  if (Ep128Emu::parseHexNumber(tmp, stepToAddressValuator->value())) {
    focusWidget = stepButton;
    gui.vm.setSingleStepMode(2);
    gui.vm.setSingleStepModeNextAddress(int32_t(tmp & 0xFFFFU));
    this->deactivate();
  }
}}
        xywh {510 685 80 25} selection_color 50
      }
      Fl_Input stepToAddressValuator {
        callback {{
  uint32_t  tmp = 0U;
  if (!Ep128Emu::parseHexNumber(tmp, o->value()))
    tmp = 0U;
  tmp = tmp & 0xFFFFU;
  char    tmp2[16];
  std::sprintf(&(tmp2[0]), "%04X", (unsigned int) tmp);
  o->value(&(tmp2[0]));
}}
        xywh {595 685 70 25} textfont 4
        code0 {o->cursor_color(Fl_Color(3));}
        code1 {o->value("0000");}
      }
      Fl_Button stepOverButton {
        label {Step over}
        callback {{
  focusWidget = stepButton;
  gui.vm.setSingleStepMode(2);
  this->deactivate();
}}
        xywh {685 685 80 25} selection_color 50
      }
      Fl_Button stepButton {
        label Step
        callback {{
  focusWidget = stepButton;
  gui.vm.setSingleStepMode(1);
  this->deactivate();
}}
        xywh {775 685 80 25} selection_color 50
      }
      Fl_Button continueButton {
        label Continue
        callback {{
  focusWidget = continueButton;
  gui.vm.setSingleStepMode(0);
  this->deactivate();
}}
        xywh {865 685 80 25} selection_color 50
      }
    }
  }
} 
