Restructuring Fluid source files.

14 files changed, 7493 insertions, 0 deletions

diff --git a/fluid/app/Fd_Snap_Action.cxx b/fluid/app/Fd_Snap_Action.cxx
new file mode 100644
index 000000000..c093af1ff
--- /dev/null
+++ b/fluid/app/Fd_Snap_Action.cxx
@@ -0,0 +1,1816 @@
+//
+// Snap action code file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#include "app/Fd_Snap_Action.h"
+
+#include "io/file.h"
+#include "nodes/Fl_Group_Type.h"
+#include "panels/settings_panel.h"
+
+#include <FL/fl_draw.H>
+#include <FL/Fl_Menu_Bar.H>
+#include <FL/fl_string_functions.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+
+// TODO: warning if the user wants to change builtin layouts
+// TODO: move panel to global settings panel (move load & save to main pulldown, or to toolbox?)
+// INFO: how about a small tool box for quick preset selection and disabling of individual snaps?
+
+void select_layout_suite_cb(Fl_Widget *, void *user_data);
+
+int Fd_Snap_Action::eex = 0;
+int Fd_Snap_Action::eey = 0;
+
+static Fd_Layout_Preset fltk_app = {
+  15, 15, 15, 15, 0, 0, // window:    l, r, t, b, gx, gy
+  10, 10, 10, 10, 0, 0, // group:     l, r, t, b, gx, gy
+  25, 25,               // tabs:      t, b
+  20, 10, 4,            // widget_x:  min, inc, gap
+  20,  4, 8,            // widget_y:  min, inc, gap
+  0, 14, -1, 14          // labelfont/size, textfont/size
+};
+static Fd_Layout_Preset fltk_dlg = {
+  10, 10, 10, 10, 0, 0, // window:    l, r, t, b, gx, gy
+  10, 10, 10, 10, 0, 0, // group:     l, r, t, b, gx, gy
+  20, 20,               // tabs:      t, b
+  20, 10, 5,            // widget_x:  min, inc, gap
+  20,  5, 5,            // widget_y:  min, inc, gap
+  0, 11, -1, 11          // labelfont/size, textfont/size
+};
+static Fd_Layout_Preset fltk_tool = {
+  10, 10, 10, 10, 0, 0, // window:    l, r, t, b, gx, gy
+  10, 10, 10, 10, 0, 0, // group:     l, r, t, b, gx, gy
+  18, 18,               // tabs:      t, b
+  16,  8, 2,            // widget_x:  min, inc, gap
+  16,  4, 2,            // widget_y:  min, inc, gap
+  0, 10, -1, 10          // labelfont/size, textfont/size
+};
+
+static Fd_Layout_Preset grid_app = {
+  12, 12, 12, 12, 12, 12, // window:    l, r, t, b, gx, gy
+  12, 12, 12, 12, 12, 12, // group:     l, r, t, b, gx, gy
+  24, 24,                 // tabs:      t, b
+  12, 6, 6,               // widget_x:  min, inc, gap
+  12, 6, 6,               // widget_y:  min, inc, gap
+  0, 14, -1, 14            // labelfont/size, textfont/size
+};
+
+static Fd_Layout_Preset grid_dlg = {
+  10, 10, 10, 10, 10, 10, // window:    l, r, t, b, gx, gy
+  10, 10, 10, 10, 10, 10, // group:     l, r, t, b, gx, gy
+  20, 20,                 // tabs:      t, b
+  10, 5, 5,               // widget_x:  min, inc, gap
+  10, 5, 5,               // widget_y:  min, inc, gap
+  0, 12, -1, 12            // labelfont/size, textfont/size
+};
+
+static Fd_Layout_Preset grid_tool = {
+  8, 8, 8, 8, 8, 8, // window:    l, r, t, b, gx, gy
+  8, 8, 8, 8, 8, 8, // group:     l, r, t, b, gx, gy
+  16, 16,           // tabs:      t, b
+  8, 4, 4,          // widget_x:  min, inc, gap
+  8, 4, 4,          // widget_y:  min, inc, gap
+  0, 10, -1, 10      // labelfont/size, textfont/size
+};
+
+static Fd_Layout_Suite static_suite_list[] = {
+  { (char*)"FLTK", (char*)"@fd_beaker FLTK", { &fltk_app, &fltk_dlg, &fltk_tool }, FD_STORE_INTERNAL },
+  { (char*)"Grid", (char*)"@fd_beaker Grid", { &grid_app, &grid_dlg, &grid_tool }, FD_STORE_INTERNAL }
+};
+
+Fl_Menu_Item main_layout_submenu_[] = {
+  { static_suite_list[0].menu_label, 0, select_layout_suite_cb, (void*)0, FL_MENU_RADIO|FL_MENU_VALUE },
+  { static_suite_list[1].menu_label, 0, select_layout_suite_cb, (void*)1, FL_MENU_RADIO },
+  { NULL }
+};
+
+static Fl_Menu_Item static_choice_menu[] = {
+  { static_suite_list[0].menu_label },
+  { static_suite_list[1].menu_label },
+  { NULL }
+};
+
+Fd_Layout_Preset *layout = &fltk_app;
+Fd_Layout_List g_layout_list;
+
+// ---- Callbacks ------------------------------------------------------ MARK: -
+
+void layout_suite_marker(Fl_Widget *, void *) {
+  // intentionally left empty
+}
+
+void select_layout_suite_cb(Fl_Widget *, void *user_data) {
+  int index = (int)(fl_intptr_t)user_data;
+  assert(index >= 0);
+  assert(index < g_layout_list.list_size_);
+  g_layout_list.current_suite(index);
+  g_layout_list.update_dialogs();
+}
+
+void select_layout_preset_cb(Fl_Widget *, void *user_data) {
+  int index = (int)(fl_intptr_t)user_data;
+  assert(index >= 0);
+  assert(index < 3);
+  g_layout_list.current_preset(index);
+  g_layout_list.update_dialogs();
+}
+
+void edit_layout_preset_cb(Fl_Button *w, long user_data) {
+  int index = (int)w->argument();
+  assert(index >= 0);
+  assert(index < 3);
+  if (user_data == (long)(fl_intptr_t)LOAD) {
+    w->value(g_layout_list.current_preset() == index);
+  } else {
+    g_layout_list.current_preset(index);
+    g_layout_list.update_dialogs();
+  }
+}
+
+// ---- Fd_Layout_Suite ------------------------------------------------ MARK: -
+
+/**
+ Write presets to a Preferences database.
+ */
+void Fd_Layout_Preset::write(Fl_Preferences &prefs) {
+  assert(this);
+  Fl_Preferences p_win(prefs, "Window");
+  p_win.set("left_margin", left_window_margin);
+  p_win.set("right_margin", right_window_margin);
+  p_win.set("top_margin", top_window_margin);
+  p_win.set("bottom_margin", bottom_window_margin);
+  p_win.set("grid_x", window_grid_x);
+  p_win.set("grid_y", window_grid_y);
+
+  Fl_Preferences p_grp(prefs, "Group");
+  p_grp.set("left_margin", left_group_margin);
+  p_grp.set("right_margin", right_group_margin);
+  p_grp.set("top_margin", top_group_margin);
+  p_grp.set("bottom_margin", bottom_group_margin);
+  p_grp.set("grid_x", group_grid_x);
+  p_grp.set("grid_y", group_grid_y);
+
+  Fl_Preferences p_tbs(prefs, "Tabs");
+  p_tbs.set("top_margin", top_tabs_margin);
+  p_tbs.set("bottom_margin", bottom_tabs_margin);
+
+  Fl_Preferences p_wgt(prefs, "Widget");
+  p_wgt.set("min_w", widget_min_w);
+  p_wgt.set("inc_w", widget_inc_w);
+  p_wgt.set("gap_x", widget_gap_x);
+  p_wgt.set("min_h", widget_min_h);
+  p_wgt.set("inc_h", widget_inc_h);
+  p_wgt.set("gap_y", widget_gap_y);
+
+  Fl_Preferences p_lyt(prefs, "Layout");
+  p_lyt.set("labelfont", labelfont);
+  p_lyt.set("labelsize", labelsize);
+  p_lyt.set("textfont", textfont);
+  p_lyt.set("textsize", textsize);
+}
+
+/**
+ Read presets from a Preferences database.
+ */
+void Fd_Layout_Preset::read(Fl_Preferences &prefs) {
+  assert(this);
+  Fl_Preferences p_win(prefs, "Window");
+  p_win.get("left_margin", left_window_margin, 15);
+  p_win.get("right_margin", right_window_margin, 15);
+  p_win.get("top_margin", top_window_margin, 15);
+  p_win.get("bottom_margin", bottom_window_margin, 15);
+  p_win.get("grid_x", window_grid_x, 0);
+  p_win.get("grid_y", window_grid_y, 0);
+
+  Fl_Preferences p_grp(prefs, "Group");
+  p_grp.get("left_margin", left_group_margin, 10);
+  p_grp.get("right_margin", right_group_margin, 10);
+  p_grp.get("top_margin", top_group_margin, 10);
+  p_grp.get("bottom_margin", bottom_group_margin, 10);
+  p_grp.get("grid_x", group_grid_x, 0);
+  p_grp.get("grid_y", group_grid_y, 0);
+
+  Fl_Preferences p_tbs(prefs, "Tabs");
+  p_tbs.get("top_margin", top_tabs_margin, 25);
+  p_tbs.get("bottom_margin", bottom_tabs_margin, 25);
+
+  Fl_Preferences p_wgt(prefs, "Widget");
+  p_wgt.get("min_w", widget_min_w, 20);
+  p_wgt.get("inc_w", widget_inc_w, 10);
+  p_wgt.get("gap_x", widget_gap_x, 4);
+  p_wgt.get("min_h", widget_min_h, 20);
+  p_wgt.get("inc_h", widget_inc_h, 4);
+  p_wgt.get("gap_y", widget_gap_y, 8);
+
+  Fl_Preferences p_lyt(prefs, "Layout");
+  p_lyt.get("labelfont", labelfont, 0);
+  p_lyt.get("labelsize", labelsize, 14);
+  p_lyt.get("textfont", textfont, 0);
+  p_lyt.get("textsize", textsize, 14);
+}
+
+/**
+ Write presets to an .fl project file.
+ */
+void Fd_Layout_Preset::write(Fd_Project_Writer *out) {
+  out->write_string("    preset { 1\n"); // preset format version
+  out->write_string("      %d %d %d %d %d %d\n",
+                    left_window_margin, right_window_margin,
+                    top_window_margin, bottom_window_margin,
+                    window_grid_x, window_grid_y);
+  out->write_string("      %d %d %d %d %d %d\n",
+                    left_group_margin, right_group_margin,
+                    top_group_margin, bottom_group_margin,
+                    group_grid_x, group_grid_y);
+  out->write_string("      %d %d\n", top_tabs_margin, bottom_tabs_margin);
+  out->write_string("      %d %d %d %d %d %d\n",
+                    widget_min_w, widget_inc_w, widget_gap_x,
+                    widget_min_h, widget_inc_h, widget_gap_y);
+  out->write_string("      %d %d %d %d\n",
+                    labelfont, labelsize, textfont, textsize);
+  out->write_string("    }\n"); // preset format version
+}
+
+/**
+ Read presets from an .fl project file.
+ */
+void Fd_Layout_Preset::read(Fd_Project_Reader *in) {
+  const char *key;
+  key = in->read_word(1);
+  if (key && !strcmp(key, "{")) {
+    for (;;) {
+      key = in->read_word();
+      if (!key) return;
+      if (key[0] == '}') break;
+      int ver = atoi(key);
+      if (ver == 0) {
+        continue;
+      } else if (ver == 1) {
+        left_window_margin = in->read_int();
+        right_window_margin = in->read_int();
+        top_window_margin = in->read_int();
+        bottom_window_margin = in->read_int();
+        window_grid_x = in->read_int();
+        window_grid_y = in->read_int();
+
+        left_group_margin = in->read_int();
+        right_group_margin = in->read_int();
+        top_group_margin = in->read_int();
+        bottom_group_margin = in->read_int();
+        group_grid_x = in->read_int();
+        group_grid_y = in->read_int();
+
+        top_tabs_margin = in->read_int();
+        bottom_tabs_margin = in->read_int();
+
+        widget_min_w = in->read_int();
+        widget_inc_w = in->read_int();
+        widget_gap_x = in->read_int();
+        widget_min_h = in->read_int();
+        widget_inc_h = in->read_int();
+        widget_gap_y = in->read_int();
+
+        labelfont = in->read_int();
+        labelsize = in->read_int();
+        textfont = in->read_int();
+        textsize = in->read_int();
+      } else { // skip unknown chunks
+        for (;;) {
+          key = in->read_word(1);
+          if (key && (key[0] == '}'))
+            return;
+        }
+      }
+    }
+  } else {
+    // format error
+  }
+}
+
+/**
+ Return the preferred text size, but make sure it's not 0.
+ */
+int Fd_Layout_Preset::textsize_not_null() {
+  // try the user selected text size
+  if (textsize > 0) return textsize;
+  // if the user did not set one, try the label size
+  if (labelsize > 0) return labelsize;
+  // if that doesn;t work, fall back to the default value
+  return 14;
+}
+
+
+// ---- Fd_Layout_Suite ------------------------------------------------ MARK: -
+
+/**
+ Write a presets suite to a Preferences database.
+ */
+void Fd_Layout_Suite::write(Fl_Preferences &prefs) {
+  assert(this);
+  assert(name_);
+  prefs.set("name", name_);
+  for (int i = 0; i < 3; ++i) {
+    Fl_Preferences prefs_preset(prefs, Fl_Preferences::Name(i));
+    assert(layout[i]);
+    layout[i]->write(prefs_preset);
+  }
+}
+
+/**
+ Read a presets suite from a Preferences database.
+ */
+void Fd_Layout_Suite::read(Fl_Preferences &prefs) {
+  assert(this);
+  for (int i = 0; i < 3; ++i) {
+    Fl_Preferences prefs_preset(prefs, Fl_Preferences::Name(i));
+    assert(layout[i]);
+    layout[i]->read(prefs_preset);
+  }
+}
+
+/**
+ Write a presets suite to an .fl project file.
+ */
+void Fd_Layout_Suite::write(Fd_Project_Writer *out) {
+  out->write_string("  suite {\n");
+  out->write_string("    name "); out->write_word(name_); out->write_string("\n");
+  for (int i = 0; i < 3; ++i) {
+    layout[i]->write(out);
+  }
+  out->write_string("  }\n");
+}
+
+/**
+ Read a presets suite from an .fl project file.
+ */
+void Fd_Layout_Suite::read(Fd_Project_Reader *in) {
+  const char *key;
+  key = in->read_word(1);
+  if (key && !strcmp(key, "{")) {
+    int ix = 0;
+    for (;;) {
+      key = in->read_word();
+      if (!key) return;
+      if (!strcmp(key, "name")) {
+        name(in->read_word());
+      } else if (!strcmp(key, "preset")) {
+        if (ix >= 3) return; // file format error
+        layout[ix++]->read(in);
+      } else if (!strcmp(key, "}")) {
+        break;
+      } else {
+        in->read_word(); // unknown key, ignore, hopefully a key-value pair
+      }
+    }
+  } else {
+    // file format error
+  }
+}
+
+/**
+ \brief Update the menu_label to show a symbol representing the storage location.
+ Also updates the FLUID user interface.
+ */
+void Fd_Layout_Suite::update_label() {
+  std::string sym;
+  switch (storage_) {
+    case FD_STORE_INTERNAL: sym.assign("@fd_beaker  "); break;
+    case FD_STORE_USER: sym.assign("@fd_user  "); break;
+    case FD_STORE_PROJECT: sym.assign("@fd_project  "); break;
+    case FD_STORE_FILE: sym.assign("@fd_file  "); break;
+  }
+  sym.append(name_);
+  if (menu_label)
+    ::free(menu_label);
+  menu_label = fl_strdup(sym.c_str());
+  g_layout_list.update_menu_labels();
+}
+
+/**
+ \brief Update the Suite name and the Suite menu_label.
+ Also updates the FLUID user interface.
+ */
+void Fd_Layout_Suite::name(const char *n) {
+  if (name_)
+    ::free(name_);
+  if (n)
+    name_ = fl_strdup(n);
+  else
+    name_ = NULL;
+  update_label();
+}
+
+/**
+ Initialize the class for first use.
+ */
+void Fd_Layout_Suite::init() {
+  name_ = NULL;
+  menu_label = NULL;
+  layout[0] = layout[1] = layout[2] = NULL;
+  storage_ = FD_STORE_INTERNAL;
+}
+
+/**
+ Free all allocated resources.
+ */
+Fd_Layout_Suite::~Fd_Layout_Suite() {
+  if (storage_ == FD_STORE_INTERNAL) return;
+  if (name_) ::free(name_);
+  for (int i = 0; i < 3; ++i) {
+    delete layout[i];
+  }
+}
+
+// ---- Fd_Layout_List ------------------------------------------------- MARK: -
+
+/**
+ Draw a little FLUID beaker symbol.
+ */
+static void fd_beaker(Fl_Color c) {
+  fl_color(221);
+  fl_begin_polygon();
+  fl_vertex(-0.6,  0.2);
+  fl_vertex(-0.9,  0.8);
+  fl_vertex(-0.8,  0.9);
+  fl_vertex( 0.8,  0.9);
+  fl_vertex( 0.9,  0.8);
+  fl_vertex( 0.6,  0.2);
+  fl_end_polygon();
+  fl_color(c);
+  fl_begin_line();
+  fl_vertex(-0.3, -0.9);
+  fl_vertex(-0.2, -0.8);
+  fl_vertex(-0.2, -0.2);
+  fl_vertex(-0.9,  0.8);
+  fl_vertex(-0.8,  0.9);
+  fl_vertex( 0.8,  0.9);
+  fl_vertex( 0.9,  0.8);
+  fl_vertex( 0.2, -0.2);
+  fl_vertex( 0.2, -0.8);
+  fl_vertex( 0.3, -0.9);
+  fl_end_line();
+}
+
+/**
+ Draw a user silhouette symbol
+ */
+static void fd_user(Fl_Color c) {
+  fl_color(245);
+  fl_begin_complex_polygon();
+  fl_arc( 0.1,  0.9, 0.8,  0.0,  80.0);
+  fl_arc( 0.0, -0.5, 0.4, -65.0, 245.0);
+  fl_arc(-0.1,  0.9, 0.8, 100.0, 180.0);
+  fl_end_complex_polygon();
+  fl_color(c);
+  fl_begin_line();
+  fl_arc( 0.1,  0.9, 0.8,  0.0,  80.0);
+  fl_arc( 0.0, -0.5, 0.4, -65.0, 245.0);
+  fl_arc(-0.1,  0.9, 0.8, 100.0, 180.0);
+  fl_end_line();
+}
+
+/**
+ Draw a document symbol.
+ */
+static void fd_project(Fl_Color c) {
+  Fl_Color fc = FL_LIGHT2;
+  fl_color(fc);
+  fl_begin_complex_polygon();
+  fl_vertex(-0.7, -1.0);
+  fl_vertex(0.1, -1.0);
+  fl_vertex(0.1, -0.4);
+  fl_vertex(0.7, -0.4);
+  fl_vertex(0.7, 1.0);
+  fl_vertex(-0.7, 1.0);
+  fl_end_complex_polygon();
+
+  fl_color(fl_lighter(fc));
+  fl_begin_polygon();
+  fl_vertex(0.1, -1.0);
+  fl_vertex(0.1, -0.4);
+  fl_vertex(0.7, -0.4);
+  fl_end_polygon();
+
+  fl_color(fl_darker(c));
+  fl_begin_loop();
+  fl_vertex(-0.7, -1.0);
+  fl_vertex(0.1, -1.0);
+  fl_vertex(0.1, -0.4);
+  fl_vertex(0.7, -0.4);
+  fl_vertex(0.7, 1.0);
+  fl_vertex(-0.7, 1.0);
+  fl_end_loop();
+
+  fl_begin_line();
+  fl_vertex(0.1, -1.0);
+  fl_vertex(0.7, -0.4);
+  fl_end_line();
+}
+
+/**
+ Draw a 3 1/2" floppy symbol.
+ */
+void fd_file(Fl_Color c) {
+  Fl_Color fl = FL_LIGHT2;
+  Fl_Color fc = FL_DARK3;
+  fl_color(fc);
+  fl_begin_polygon(); // case
+  fl_vertex(-0.9, -1.0);
+  fl_vertex(0.9, -1.0);
+  fl_vertex(1.0, -0.9);
+  fl_vertex(1.0, 0.9);
+  fl_vertex(0.9, 1.0);
+  fl_vertex(-0.9, 1.0);
+  fl_vertex(-1.0, 0.9);
+  fl_vertex(-1.0, -0.9);
+  fl_end_polygon();
+
+  fl_color(fl_lighter(fl));
+  fl_begin_polygon();
+  fl_vertex(-0.7, -1.0); // slider
+  fl_vertex(0.7, -1.0);
+  fl_vertex(0.7, -0.4);
+  fl_vertex(-0.7, -0.4);
+  fl_end_polygon();
+
+  fl_begin_polygon(); // label
+  fl_vertex(-0.7, 0.0);
+  fl_vertex(0.7, 0.0);
+  fl_vertex(0.7, 1.0);
+  fl_vertex(-0.7, 1.0);
+  fl_end_polygon();
+
+  fl_color(fc);
+  fl_begin_polygon();
+  fl_vertex(-0.5, -0.9); // slot
+  fl_vertex(-0.3, -0.9);
+  fl_vertex(-0.3, -0.5);
+  fl_vertex(-0.5, -0.5);
+  fl_end_polygon();
+
+  fl_color(fl_darker(c));
+  fl_begin_loop();
+  fl_vertex(-0.9, -1.0);
+  fl_vertex(0.9, -1.0);
+  fl_vertex(1.0, -0.9);
+  fl_vertex(1.0, 0.9);
+  fl_vertex(0.9, 1.0);
+  fl_vertex(-0.9, 1.0);
+  fl_vertex(-1.0, 0.9);
+  fl_vertex(-1.0, -0.9);
+  fl_end_loop();
+}
+
+/**
+ Instantiate the class that holds a list of all layouts and manages the UI.
+ */
+Fd_Layout_List::Fd_Layout_List()
+: main_menu_(main_layout_submenu_),
+  choice_menu_(static_choice_menu),
+  list_(static_suite_list),
+  list_size_(2),
+  list_capacity_(2),
+  list_is_static_(true),
+  current_suite_(0),
+  current_preset_(0)
+{
+  fl_add_symbol("fd_beaker", fd_beaker, 1);
+  fl_add_symbol("fd_user", fd_user, 1);
+  fl_add_symbol("fd_project", fd_project, 1);
+  fl_add_symbol("fd_file", fd_file, 1);
+}
+
+/**
+ Release allocated resources.
+ */
+Fd_Layout_List::~Fd_Layout_List() {
+  assert(this);
+  if (!list_is_static_) {
+    ::free(main_menu_);
+    ::free(choice_menu_);
+    for (int i = 0; i < list_size_; i++) {
+      Fd_Layout_Suite &suite = list_[i];
+      if (suite.storage_ != FD_STORE_INTERNAL)
+        suite.~Fd_Layout_Suite();
+    }
+    ::free(list_);
+  }
+}
+
+/**
+ Update the Setting dialog and menus to reflect the current Layout selection state.
+ */
+void Fd_Layout_List::update_dialogs() {
+  static Fl_Menu_Item *preset_menu = NULL;
+  if (!preset_menu) {
+    preset_menu = (Fl_Menu_Item*)main_menubar->find_item(select_layout_preset_cb);
+    assert(preset_menu);
+  }
+  assert(this);
+  assert(current_suite_ >= 0 );
+  assert(current_suite_ < list_size_);
+  assert(current_preset_ >= 0 );
+  assert(current_preset_ < 3);
+  layout = list_[current_suite_].layout[current_preset_];
+  assert(layout);
+  if (w_settings_layout_tab) {
+    w_settings_layout_tab->do_callback(w_settings_layout_tab, LOAD);
+    layout_choice->redraw();
+  }
+  preset_menu[current_preset_].setonly(preset_menu);
+  main_menu_[current_suite_].setonly(main_menu_);
+}
+
+/**
+ Refresh the label pointers for both pulldown menus.
+ */
+void Fd_Layout_List::update_menu_labels() {
+  for (int i=0; i<list_size_; i++) {
+    main_menu_[i].label(list_[i].menu_label);
+    choice_menu_[i].label(list_[i].menu_label);
+  }
+}
+
+/**
+ Load all user layouts from the FLUID user preferences.
+ */
+int Fd_Layout_List::load(const std::string &filename) {
+  remove_all(FD_STORE_FILE);
+  Fl_Preferences prefs(filename.c_str(), "layout.fluid.fltk.org", NULL, Fl_Preferences::C_LOCALE);
+  read(prefs, FD_STORE_FILE);
+  return 0;
+}
+
+/**
+ Save all user layouts to the FLUID user preferences.
+ */
+int Fd_Layout_List::save(const std::string &filename) {
+  assert(this);
+  Fl_Preferences prefs(filename.c_str(), "layout.fluid.fltk.org", NULL, (Fl_Preferences::Root)(Fl_Preferences::C_LOCALE|Fl_Preferences::CLEAR));
+  prefs.clear();
+  write(prefs, FD_STORE_FILE);
+  return 0;
+}
+
+/**
+ Write Suite and Layout selection and selected layout data to Preferences database.
+ */
+void Fd_Layout_List::write(Fl_Preferences &prefs, Fd_Tool_Store storage) {
+  Fl_Preferences prefs_list(prefs, "Layouts");
+  prefs_list.clear();
+  prefs_list.set("current_suite", list_[current_suite()].name_);
+  prefs_list.set("current_preset", current_preset());
+  int n = 0;
+  for (int i = 0; i < list_size_; ++i) {
+    Fd_Layout_Suite &suite = list_[i];
+    if (suite.storage_ == storage) {
+      Fl_Preferences prefs_suite(prefs_list, Fl_Preferences::Name(n++));
+      suite.write(prefs_suite);
+    }
+  }
+}
+
+/**
+ Read Suite and Layout selection and selected layout data to Preferences database.
+ */
+void Fd_Layout_List::read(Fl_Preferences &prefs, Fd_Tool_Store storage) {
+  Fl_Preferences prefs_list(prefs, "Layouts");
+  std::string cs;
+  int cp = 0;
+  preferences_get(prefs_list, "current_suite", cs, "");
+  prefs_list.get("current_preset", cp, 0);
+  for (int i = 0; i < prefs_list.groups(); ++i) {
+    Fl_Preferences prefs_suite(prefs_list, Fl_Preferences::Name(i));
+    char *new_name = NULL;
+    prefs_suite.get("name", new_name, NULL);
+    if (new_name) {
+      int n = add(new_name);
+      list_[n].read(prefs_suite);
+      list_[n].storage(storage);
+      ::free(new_name);
+    }
+  }
+  current_suite(cs);
+  current_preset(cp);
+  update_dialogs();
+}
+
+/**
+ Write Suite and Layout selection and project layout data to an .fl project file.
+ */
+void Fd_Layout_List::write(Fd_Project_Writer *out) {
+  // Don't write the Snap field if no custom layout was used
+  if ((current_suite()==0) && (current_preset()==0)) {
+    int nSuite = 0;
+    for (int i=0; i<list_size_; i++) {
+      if (list_[i].storage_ == FD_STORE_PROJECT) nSuite++;
+    }
+    if (nSuite == 0) return;
+  }
+  out->write_string("\nsnap {\n  ver 1\n");
+  out->write_string("  current_suite "); out->write_word(list_[current_suite()].name_); out->write_string("\n");
+  out->write_string("  current_preset %d\n", current_preset());
+  for (int i=0; i<list_size_; i++) {
+    Fd_Layout_Suite &suite = list_[i];
+    if (suite.storage_ == FD_STORE_PROJECT)
+      suite.write(out);
+  }
+  out->write_string("}");
+}
+
+/**
+ Read Suite and Layout selection and project layout data from an .fl project file.
+ */
+void Fd_Layout_List::read(Fd_Project_Reader *in) {
+  const char *key;
+  key = in->read_word(1);
+  if (key && !strcmp(key, "{")) {
+    std::string cs;
+    int cp = 0;
+    for (;;) {
+      key = in->read_word();
+      if (!key) return;
+      if (!strcmp(key, "ver")) {
+        in->read_int();
+      } else if (!strcmp(key, "current_suite")) {
+        cs = in->read_word();
+      } else if (!strcmp(key, "current_preset")) {
+        cp = in->read_int();
+      } else if (!strcmp(key, "suite")) {
+        int n = add(in->filename_name());
+        list_[n].read(in);
+        list_[n].storage(FD_STORE_PROJECT);
+      } else if (!strcmp(key, "}")) {
+        break;
+      } else {
+        in->read_word(); // unknown key, ignore, hopefully a key-value pair
+      }
+    }
+    current_suite(cs);
+    current_preset(cp);
+    update_dialogs();
+  } else {
+    // old style "snap" is followed by an integer. Ignore.
+  }
+}
+
+/**
+ Set the current Suite.
+ \param[in] ix index into list of suites
+ */
+void Fd_Layout_List::current_suite(int ix) {
+  assert(ix >= 0);
+  assert(ix < list_size_);
+  current_suite_ = ix;
+  layout = list_[current_suite_].layout[current_preset_];
+}
+
+/**
+ Set the current Suite.
+ \param[in] arg_name name of the selected suite
+ \return if no name is given or the name is not found, keep the current suite selected
+ */
+void Fd_Layout_List::current_suite(std::string arg_name) {
+  if (arg_name.empty()) return;
+  for (int i = 0; i < list_size_; ++i) {
+    Fd_Layout_Suite &suite = list_[i];
+    if (suite.name_ && (strcmp(suite.name_, arg_name.c_str()) == 0)) {
+      current_suite(i);
+      break;
+    }
+  }
+}
+
+/**
+ Select a Preset within the current Suite.
+ \param[in] ix 0 = application, 1 = dialog, 2 = toolbox
+ */
+void Fd_Layout_List::current_preset(int ix) {
+  assert(ix >= 0);
+  assert(ix < 3);
+  current_preset_ = ix;
+  layout = list_[current_suite_].layout[current_preset_];
+}
+
+/**
+ Allocate enough space for n entries in the list.
+ */
+void Fd_Layout_List::capacity(int n) {
+  static Fl_Menu_Item *suite_menu = NULL;
+  if (!suite_menu)
+    suite_menu = (Fl_Menu_Item*)main_menubar->find_item(layout_suite_marker);
+
+  int old_n = list_size_;
+  int i;
+
+  Fd_Layout_Suite *new_list = (Fd_Layout_Suite*)::calloc(n, sizeof(Fd_Layout_Suite));
+  for (i = 0; i < old_n; i++)
+    new_list[i] = list_[i];
+  if (!list_is_static_) ::free(list_);
+  list_ = new_list;
+
+  Fl_Menu_Item *new_main_menu = (Fl_Menu_Item*)::calloc(n+1, sizeof(Fl_Menu_Item));
+  for (i = 0; i < old_n; i++)
+    new_main_menu[i] = main_menu_[i];
+  if (!list_is_static_) ::free(main_menu_);
+  main_menu_ = new_main_menu;
+  suite_menu->user_data(main_menu_);
+
+  Fl_Menu_Item *new_choice_menu = (Fl_Menu_Item*)::calloc(n+1, sizeof(Fl_Menu_Item));
+  for (i = 0; i < old_n; i++)
+    new_choice_menu[i] = choice_menu_[i];
+  if (!list_is_static_) ::free(choice_menu_);
+  choice_menu_ = new_choice_menu;
+  if (layout_choice) layout_choice->menu(choice_menu_);
+
+  list_capacity_ = n;
+  list_is_static_ = false;
+}
+
+/**
+ \brief Clone the currently selected suite and append it to the list.
+ Selects the new layout and updates the UI.
+ */
+int Fd_Layout_List::add(const char *name) {
+  if (list_size_ == list_capacity_) {
+    capacity(list_capacity_ * 2);
+  }
+  int n = list_size_;
+  Fd_Layout_Suite &old_suite = list_[current_suite_];
+  Fd_Layout_Suite &new_suite = list_[n];
+  new_suite.init();
+  new_suite.name(name);
+  for (int i=0; i<3; ++i) {
+    new_suite.layout[i] = new Fd_Layout_Preset;
+    ::memcpy(new_suite.layout[i], old_suite.layout[i], sizeof(Fd_Layout_Preset));
+  }
+  Fd_Tool_Store new_storage = old_suite.storage_;
+  if (new_storage == FD_STORE_INTERNAL)
+    new_storage = FD_STORE_USER;
+  new_suite.storage(new_storage);
+  main_menu_[n].label(new_suite.menu_label);
+  main_menu_[n].callback(main_menu_[0].callback());
+  main_menu_[n].argument(n);
+  main_menu_[n].flags = main_menu_[0].flags;
+  choice_menu_[n].label(new_suite.menu_label);
+  list_size_++;
+  current_suite(n);
+  return n;
+}
+
+/**
+ Rename the current Suite.
+ */
+void Fd_Layout_List::rename(const char *name) {
+  int n = current_suite();
+  list_[n].name(name);
+  main_menu_[n].label(list_[n].menu_label);
+  choice_menu_[n].label(list_[n].menu_label);
+}
+
+/**
+ Remove the given suite.
+ \param[in] ix index into list of suites
+ */
+void Fd_Layout_List::remove(int ix) {
+  int tail = list_size_-ix-1;
+  if (tail) {
+    for (int i = ix; i < list_size_-1; i++)
+      list_[i] = list_[i+1];
+  }
+  ::memmove(main_menu_+ix, main_menu_+ix+1, (tail+1) * sizeof(Fl_Menu_Item));
+  ::memmove(choice_menu_+ix, choice_menu_+ix+1, (tail+1) * sizeof(Fl_Menu_Item));
+  list_size_--;
+  if (current_suite() >= list_size_)
+    current_suite(list_size_ - 1);
+}
+
+/**
+ Remove all Suites that use the given storage attribute.
+ \param[in] storage storage attribute, see FD_STORE_INTERNAL, etc.
+ */
+void Fd_Layout_List::remove_all(Fd_Tool_Store storage) {
+  for (int i=list_size_-1; i>=0; --i) {
+    if (list_[i].storage_ == storage)
+      remove(i);
+  }
+}
+
+// ---- Helper --------------------------------------------------------- MARK: -
+
+static void draw_h_arrow(int, int, int);
+static void draw_v_arrow(int x, int y1, int y2);
+static void draw_left_brace(const Fl_Widget *w);
+static void draw_right_brace(const Fl_Widget *w);
+static void draw_top_brace(const Fl_Widget *w);
+static void draw_bottom_brace(const Fl_Widget *w);
+static void draw_grid(int x, int y, int dx, int dy);
+void draw_width(int x, int y, int r, Fl_Align a);
+void draw_height(int x, int y, int b, Fl_Align a);
+
+static int nearest(int x, int left, int grid, int right=0x7fff) {
+  int grid_x = ((x-left+grid/2)/grid)*grid+left;
+  if (grid_x < left+grid/2) return left; // left+grid/2;
+  if (grid_x > right-grid/2) return right; // right-grid/2;
+  return grid_x;
+}
+
+static bool in_window(Fd_Snap_Data &d) {
+  return (d.wgt && d.wgt->parent == d.win);
+}
+
+static bool in_group(Fd_Snap_Data &d) {
+  return (d.wgt && d.wgt->parent && d.wgt->parent->is_a(ID_Group) && d.wgt->parent != d.win);
+}
+
+static bool in_tabs(Fd_Snap_Data &d) {
+  return (d.wgt && d.wgt->parent && d.wgt->parent->is_a(ID_Tabs));
+}
+
+static Fl_Group *parent(Fd_Snap_Data &d) {
+  return (d.wgt->o->parent());
+}
+
+// ---- Fd_Snap_Action ------------------------------------------------- MARK: -
+
+/** \class Fd_Snap_Action
+
+ When a user drags one or more widgets, snap actions can be defined that provide
+ hints if a preferred widget position or size is nearby. The user's motion is
+ then directed towards the nearest preferred position, and the widget selection
+ snaps into place.
+
+ FLUID provides a list of various snap actions. Every snap action uses the data
+ from the motion event and combines it with the sizes and positions of all other
+ widgets in the layout.
+
+ Common snap actions include gaps and margins, but also alignments and
+ simple grid positions.
+ */
+
+/**
+ \brief Check if a snap action has reached a preferred x position.
+ \param[inout] d current event data
+ \param[in] x_ref position of moving point
+ \param[in] x_snap position of target point
+ \return 1 if the points are not within range and won;t be considered
+ \return 0 if the point is as close as another in a previous action
+ \return -1 if this point is closer than any previous check, and this is the
+    new distance to beat.
+ */
+int Fd_Snap_Action::check_x_(Fd_Snap_Data &d, int x_ref, int x_snap) {
+  int dd = x_ref + d.dx - x_snap;
+  int d2 = abs(dd);
+  if (d2 > d.x_dist) return 1;
+  dx = d.dx_out = d.dx - dd;
+  ex = d.ex_out = x_snap;
+  if (d2 == d.x_dist) return 0;
+  d.x_dist = d2;
+  return -1;
+}
+
+/**
+ \brief Check if a snap action has reached a preferred y position.
+ \see Fd_Snap_Action::check_x_(Fd_Snap_Data &d, int x_ref, int x_snap)
+ */
+int Fd_Snap_Action::check_y_(Fd_Snap_Data &d, int y_ref, int y_snap) {
+  int dd = y_ref + d.dy - y_snap;
+  int d2 = abs(dd);
+  if (d2 > d.y_dist) return 1;
+  dy = d.dy_out = d.dy - dd;
+  ey = d.ey_out = y_snap;
+  if (d2 == d.y_dist) return 0;
+  d.y_dist = d2;
+  return -1;
+}
+
+/**
+ \brief Check if a snap action has reached a preferred x and y position.
+ \see Fd_Snap_Action::check_x_(Fd_Snap_Data &d, int x_ref, int x_snap)
+ */
+void Fd_Snap_Action::check_x_y_(Fd_Snap_Data &d, int x_ref, int x_snap, int y_ref, int y_snap) {
+  int ddx = x_ref + d.dx - x_snap;
+  int d2x = abs(ddx);
+  int ddy = y_ref + d.dy - y_snap;
+  int d2y = abs(ddy);
+  if ((d2x <= d.x_dist) && (d2y <= d.y_dist)) {
+    dx = d.dx_out = d.dx - ddx;
+    ex = d.ex_out = x_snap;
+    d.x_dist = d2x;
+    dy = d.dy_out = d.dy - ddy;
+    ey = d.ey_out = y_snap;
+    d.y_dist = d2y;
+  }
+}
+
+/**
+ \brief Check if a snap action was applied to the current event.
+ This method is used to determine if a visual indicator for this snap action
+ should be drawn.
+ \param[inout] d current event data
+ */
+bool Fd_Snap_Action::matches(Fd_Snap_Data &d) {
+  switch (type) {
+    case 1: return (d.drag & mask) && (eex == ex) && (d.dx == dx);
+    case 2: return (d.drag & mask) && (eey == ey) && (d.dy == dy);
+    case 3: return (d.drag & mask) && (eex == ex) && (d.dx == dx) && (eey == ey) && (d.dy == dy);
+  }
+  return false;
+}
+
+/**
+ \brief Run through all possible snap actions and store the winning coordinates in eex and eey.
+ \param[inout] d current event data
+ */
+void Fd_Snap_Action::check_all(Fd_Snap_Data &data) {
+  for (int i=0; list[i]; i++) {
+    if (list[i]->mask & data.drag)
+      list[i]->check(data);
+  }
+  eex = data.ex_out;
+  eey = data.ey_out;
+}
+
+/**
+ \brief Draw a visual indicator for all snap actions that were applied during the last check.
+ Only one snap coordinate can win. FLUID chooses the one that is closest to
+ the current user event. If two or more snap actions suggest the same
+ coordinate, all of them will be drawn.
+ \param[inout] d current event data
+ */
+void Fd_Snap_Action::draw_all(Fd_Snap_Data &data) {
+  for (int i=0; list[i]; i++) {
+    if (list[i]->matches(data))
+      list[i]->draw(data);
+  }
+}
+
+/** Return a sensible step size for resizing a widget. */
+void Fd_Snap_Action::get_resize_stepsize(int &x_step, int &y_step) {
+  if ((layout->widget_inc_w > 1) && (layout->widget_inc_h > 1)) {
+    x_step = layout->widget_inc_w;
+    y_step = layout->widget_inc_h;
+  } else if ((layout->group_grid_x > 1) && (layout->group_grid_y > 1)) {
+    x_step = layout->group_grid_x;
+    y_step = layout->group_grid_y;
+  } else {
+    x_step = layout->window_grid_x;
+    y_step = layout->window_grid_y;
+  }
+}
+
+/** Return a sensible step size for moving a widget. */
+void Fd_Snap_Action::get_move_stepsize(int &x_step, int &y_step) {
+  if ((layout->group_grid_x > 1) && (layout->group_grid_y > 1)) {
+    x_step = layout->group_grid_x;
+    y_step = layout->group_grid_y;
+  } else if ((layout->window_grid_x > 1) && (layout->window_grid_y > 1)) {
+    x_step = layout->window_grid_x;
+    y_step = layout->window_grid_y;
+  } else {
+    x_step = layout->widget_gap_x;
+    y_step = layout->widget_gap_y;
+  }
+}
+
+/** Fix the given size to the same or next bigger snap position. */
+void Fd_Snap_Action::better_size(int &w, int &h) {
+  int x_min = 1, y_min = 1, x_inc = 1, y_inc = 1;
+  get_resize_stepsize(x_inc, y_inc);
+  if (x_inc < 1) x_inc = 1;
+  if (y_inc < 1) y_inc = 1;
+  if ((layout->widget_min_w > 1) && (layout->widget_min_h > 1)) {
+    x_min = layout->widget_min_w;
+    y_min = layout->widget_min_h;
+  } else if ((layout->group_grid_x > 1) && (layout->group_grid_y > 1)) {
+    x_min = layout->group_grid_x;
+    y_min = layout->group_grid_y;
+  } else {
+    x_min = x_inc;
+    y_min = y_inc;
+  }
+  int ww = fd_max(w - x_min, 0); w = (w - ww + x_inc - 1) / x_inc; w = w * x_inc; w = w + ww;
+  int hh = fd_max(h - y_min, 0); h = (h - hh + y_inc - 1) / y_inc; h = h * y_inc; h = h + hh;
+}
+
+
+// ---- snapping prototypes -------------------------------------------- MARK: -
+
+/**
+ Base class for all actions that drag the left side or the entire widget.
+ */
+class Fd_Snap_Left : public Fd_Snap_Action {
+public:
+  Fd_Snap_Left() { type = 1; mask = FD_LEFT|FD_DRAG; }
+};
+
+/**
+ Base class for all actions that drag the right side or the entire widget.
+ */
+class Fd_Snap_Right : public Fd_Snap_Action {
+public:
+  Fd_Snap_Right() { type = 1; mask = FD_RIGHT|FD_DRAG; }
+};
+
+/**
+ Base class for all actions that drag the top side or the entire widget.
+ */
+class Fd_Snap_Top : public Fd_Snap_Action {
+public:
+  Fd_Snap_Top() { type = 2; mask = FD_TOP|FD_DRAG; }
+};
+
+/**
+ Base class for all actions that drag the bottom side or the entire widget.
+ */
+class Fd_Snap_Bottom : public Fd_Snap_Action {
+public:
+  Fd_Snap_Bottom() { type = 2; mask = FD_BOTTOM|FD_DRAG; }
+};
+
+// ---- window snapping ------------------------------------------------ MARK: -
+
+/**
+ Check if the widget hits the left window edge.
+ */
+class Fd_Snap_Left_Window_Edge : public Fd_Snap_Left {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE { clr(); check_x_(d, d.bx, 0); }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE { draw_left_brace(d.win->o); };
+};
+Fd_Snap_Left_Window_Edge snap_left_window_edge;
+
+/**
+ Check if the widget hits the right window edge.
+ */
+class Fd_Snap_Right_Window_Edge : public Fd_Snap_Right {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE { clr(); check_x_(d, d.br, d.win->o->w()); }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE { draw_right_brace(d.win->o); };
+};
+Fd_Snap_Right_Window_Edge snap_right_window_edge;
+
+/**
+ Check if the widget hits the top window edge.
+ */
+class Fd_Snap_Top_Window_Edge : public Fd_Snap_Top {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE { clr(); check_y_(d, d.by, 0); }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE { draw_top_brace(d.win->o); };
+};
+Fd_Snap_Top_Window_Edge snap_top_window_edge;
+
+/**
+ Check if the widget hits the bottom window edge.
+ */
+class Fd_Snap_Bottom_Window_Edge : public Fd_Snap_Bottom {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE { clr(); check_y_(d, d.bt, d.win->o->h()); }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE { draw_bottom_brace(d.win->o); };
+};
+Fd_Snap_Bottom_Window_Edge snap_bottom_window_edge;
+
+/**
+ Check if the widget hits the left window edge plus a user defined margin.
+ */
+class Fd_Snap_Left_Window_Margin : public Fd_Snap_Left {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_window(d)) check_x_(d, d.bx, layout->left_window_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_h_arrow(d.bx, (d.by+d.bt)/2, 0);
+  };
+};
+Fd_Snap_Left_Window_Margin snap_left_window_margin;
+
+class Fd_Snap_Right_Window_Margin : public Fd_Snap_Right {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_window(d)) check_x_(d, d.br, d.win->o->w()-layout->right_window_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_h_arrow(d.br, (d.by+d.bt)/2, d.win->o->w()-1);
+  };
+};
+Fd_Snap_Right_Window_Margin snap_right_window_margin;
+
+class Fd_Snap_Top_Window_Margin : public Fd_Snap_Top {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_window(d)) check_y_(d, d.by, layout->top_window_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_v_arrow((d.bx+d.br)/2, d.by, 0);
+  };
+};
+Fd_Snap_Top_Window_Margin snap_top_window_margin;
+
+class Fd_Snap_Bottom_Window_Margin : public Fd_Snap_Bottom {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_window(d)) check_y_(d, d.bt, d.win->o->h()-layout->bottom_window_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_v_arrow((d.bx+d.br)/2, d.bt, d.win->o->h()-1);
+  };
+};
+Fd_Snap_Bottom_Window_Margin snap_bottom_window_margin;
+
+// ---- group snapping ------------------------------------------------- MARK: -
+
+/**
+ Check if the widget hits the left group edge.
+ */
+class Fd_Snap_Left_Group_Edge : public Fd_Snap_Left {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d)) check_x_(d, d.bx, parent(d)->x());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_left_brace(parent(d));
+  };
+};
+Fd_Snap_Left_Group_Edge snap_left_group_edge;
+
+class Fd_Snap_Right_Group_Edge : public Fd_Snap_Right {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d)) check_x_(d, d.br, parent(d)->x() + parent(d)->w());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_right_brace(parent(d));
+  };
+};
+Fd_Snap_Right_Group_Edge snap_right_group_edge;
+
+class Fd_Snap_Top_Group_Edge : public Fd_Snap_Top {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d)) check_y_(d, d.by, parent(d)->y());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_top_brace(parent(d));
+  };
+};
+Fd_Snap_Top_Group_Edge snap_top_group_edge;
+
+class Fd_Snap_Bottom_Group_Edge : public Fd_Snap_Bottom {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d)) check_y_(d, d.bt, parent(d)->y() + parent(d)->h());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_bottom_brace(parent(d));
+  };
+};
+Fd_Snap_Bottom_Group_Edge snap_bottom_group_edge;
+
+
+/**
+ Check if the widget hits the left group edge plus a user defined margin.
+ */
+class Fd_Snap_Left_Group_Margin : public Fd_Snap_Left {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d)) check_x_(d, d.bx, parent(d)->x() + layout->left_group_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_left_brace(parent(d));
+    draw_h_arrow(d.bx, (d.by+d.bt)/2, parent(d)->x());
+  };
+};
+Fd_Snap_Left_Group_Margin snap_left_group_margin;
+
+class Fd_Snap_Right_Group_Margin : public Fd_Snap_Right {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d)) check_x_(d, d.br, parent(d)->x()+parent(d)->w()-layout->right_group_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_right_brace(parent(d));
+    draw_h_arrow(d.br, (d.by+d.bt)/2, parent(d)->x()+parent(d)->w()-1);
+  };
+};
+Fd_Snap_Right_Group_Margin snap_right_group_margin;
+
+class Fd_Snap_Top_Group_Margin : public Fd_Snap_Top {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d) && !in_tabs(d)) check_y_(d, d.by, parent(d)->y()+layout->top_group_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_top_brace(parent(d));
+    draw_v_arrow((d.bx+d.br)/2, d.by, parent(d)->y());
+  };
+};
+Fd_Snap_Top_Group_Margin snap_top_group_margin;
+
+class Fd_Snap_Bottom_Group_Margin : public Fd_Snap_Bottom {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_group(d) && !in_tabs(d)) check_y_(d, d.bt, parent(d)->y()+parent(d)->h()-layout->bottom_group_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_bottom_brace(parent(d));
+    draw_v_arrow((d.bx+d.br)/2, d.bt, parent(d)->y()+parent(d)->h()-1);
+  };
+};
+Fd_Snap_Bottom_Group_Margin snap_bottom_group_margin;
+
+// ----- tabs snapping ------------------------------------------------- MARK: -
+
+/**
+ Check if the widget top hits the Fl_Tabs group top edge plus a user defined margin.
+ */
+class Fd_Snap_Top_Tabs_Margin : public Fd_Snap_Top_Group_Margin {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_tabs(d)) check_y_(d, d.by, parent(d)->y()+layout->top_tabs_margin);
+  }
+};
+Fd_Snap_Top_Tabs_Margin snap_top_tabs_margin;
+
+class Fd_Snap_Bottom_Tabs_Margin : public Fd_Snap_Bottom_Group_Margin {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_tabs(d)) check_y_(d, d.bt, parent(d)->y()+parent(d)->h()-layout->bottom_tabs_margin);
+  }
+};
+Fd_Snap_Bottom_Tabs_Margin snap_bottom_tabs_margin;
+
+// ----- grid snapping ------------------------------------------------- MARK: -
+
+/**
+ Base class for grid based snapping.
+ */
+class Fd_Snap_Grid : public Fd_Snap_Action {
+protected:
+  int nearest_x, nearest_y;
+public:
+  Fd_Snap_Grid() { type = 3; mask = FD_LEFT|FD_TOP|FD_DRAG; }
+  void check_grid(Fd_Snap_Data &d, int left, int grid_x, int right, int top, int grid_y, int bottom) {
+    if ((grid_x <= 1) || (grid_y <= 1)) return;
+    int suggested_x = d.bx + d.dx;
+    nearest_x = nearest(suggested_x, left, grid_x, right);
+    int suggested_y = d.by + d.dy;
+    nearest_y = nearest(suggested_y, top, grid_y, bottom);
+    if (d.drag == FD_LEFT)
+      check_x_(d, d.bx, nearest_x);
+    else if (d.drag == FD_TOP)
+      check_y_(d, d.by, nearest_y);
+    else
+      check_x_y_(d, d.bx, nearest_x, d.by, nearest_y);
+  }
+  bool matches(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (d.drag == FD_LEFT) return (eex == ex);
+    if (d.drag == FD_TOP) return (eey == ey) && (d.dx == dx);
+    return (d.drag & mask) && (eex == ex) && (d.dx == dx) && (eey == ey) && (d.dy == dy);
+  }
+};
+
+/**
+ Check if the widget hits window grid coordinates.
+ */
+class Fd_Snap_Window_Grid : public Fd_Snap_Grid {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (in_window(d)) check_grid(d, layout->left_window_margin, layout->window_grid_x, d.win->o->w()-layout->right_window_margin,
+                                 layout->top_window_margin, layout->window_grid_y, d.win->o->h()-layout->bottom_window_margin);
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_grid(nearest_x, nearest_y, layout->window_grid_x, layout->window_grid_y);
+  };
+};
+Fd_Snap_Window_Grid snap_window_grid;
+
+/**
+ Check if the widget hits group grid coordinates.
+ */
+class Fd_Snap_Group_Grid : public Fd_Snap_Grid {
+public:
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (in_group(d)) {
+      clr();
+      Fl_Widget *g = parent(d);
+      check_grid(d, g->x()+layout->left_group_margin, layout->group_grid_x, g->x()+g->w()-layout->right_group_margin,
+                 g->y()+layout->top_group_margin, layout->group_grid_y, g->y()+g->h()-layout->bottom_group_margin);
+    }
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_grid(nearest_x, nearest_y, layout->group_grid_x, layout->group_grid_y);
+  };
+};
+Fd_Snap_Group_Grid snap_group_grid;
+
+// ----- sibling snapping ---------------------------------------------- MARK: -
+
+/**
+ Base class the check distance to other widgets in the same group.
+ */
+class Fd_Snap_Sibling : public Fd_Snap_Action {
+protected:
+  Fl_Widget *best_match;
+public:
+  Fd_Snap_Sibling() : best_match(NULL) { }
+  virtual int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) = 0;
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    best_match = NULL;
+    if (!d.wgt) return;
+    if (!d.wgt->parent->is_a(ID_Group)) return;
+    int dsib_min = 1024;
+    Fl_Group_Type *gt = (Fl_Group_Type*)d.wgt->parent;
+    Fl_Group *g = (Fl_Group*)gt->o;
+    Fl_Widget *w = d.wgt->o;
+    for (int i=0; i<g->children(); i++) {
+      Fl_Widget *c = g->child(i);
+      if (c == w) continue;
+      int sret = sibling_check(d, c);
+      if (sret < 1) {
+        int dsib;
+        if (type==1)
+          dsib = abs( ((d.by+d.bt)/2+d.dy) - (c->y()+c->h()/2) );
+        else
+          dsib = abs( ((d.bx+d.br)/2+d.dx) - (c->x()+c->w()/2) );
+        if (sret == -1 || (dsib < dsib_min)) {
+          dsib_min = dsib;
+          best_match = c;
+        }
+      }
+    }
+  }
+};
+
+/**
+ Check if widgets have the same x coordinate, so they can be vertically aligned.
+ */
+class Fd_Snap_Siblings_Left_Same : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Left_Same() { type = 1; mask = FD_LEFT|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return check_x_(d, d.bx, s->x());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_left_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Left_Same snap_siblings_left_same;
+
+/**
+ Check if widgets touch left to right, or have a user selected gap left to right.
+ */
+class Fd_Snap_Siblings_Left : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Left() { type = 1; mask = FD_LEFT|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return fd_min(check_x_(d, d.bx, s->x()+s->w()),
+                  check_x_(d, d.bx, s->x()+s->w()+layout->widget_gap_x) );
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_right_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Left snap_siblings_left;
+
+class Fd_Snap_Siblings_Right_Same : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Right_Same() { type = 1; mask = FD_RIGHT|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return check_x_(d, d.br, s->x()+s->w());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_right_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Right_Same snap_siblings_right_same;
+
+class Fd_Snap_Siblings_Right : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Right() { type = 1; mask = FD_RIGHT|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return fd_min(check_x_(d, d.br, s->x()),
+                  check_x_(d, d.br, s->x()-layout->widget_gap_x));
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_left_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Right snap_siblings_right;
+
+class Fd_Snap_Siblings_Top_Same : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Top_Same() { type = 2; mask = FD_TOP|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return check_y_(d, d.by, s->y());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_top_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Top_Same snap_siblings_top_same;
+
+class Fd_Snap_Siblings_Top : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Top() { type = 2; mask = FD_TOP|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return fd_min(check_y_(d, d.by, s->y()+s->h()),
+                  check_y_(d, d.by, s->y()+s->h()+layout->widget_gap_y));
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_bottom_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Top snap_siblings_top;
+
+class Fd_Snap_Siblings_Bottom_Same : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Bottom_Same() { type = 2; mask = FD_BOTTOM|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return check_y_(d, d.bt, s->y()+s->h());
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_bottom_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Bottom_Same snap_siblings_bottom_same;
+
+class Fd_Snap_Siblings_Bottom : public Fd_Snap_Sibling {
+public:
+  Fd_Snap_Siblings_Bottom() { type = 2; mask = FD_BOTTOM|FD_DRAG; }
+  int sibling_check(Fd_Snap_Data &d, Fl_Widget *s) FL_OVERRIDE {
+    return fd_min(check_y_(d, d.bt, s->y()),
+                  check_y_(d, d.bt, s->y()-layout->widget_gap_y));
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    if (best_match) draw_top_brace(best_match);
+  };
+};
+Fd_Snap_Siblings_Bottom snap_siblings_bottom;
+
+
+// ------ widget snapping ---------------------------------------------- MARK: -
+
+/**
+ Snap horizontal resizing to min_w or min_w and a multiple of inc_w.
+ */
+class Fd_Snap_Widget_Ideal_Width : public Fd_Snap_Action {
+public:
+  Fd_Snap_Widget_Ideal_Width() { type = 1; mask = FD_LEFT|FD_RIGHT; }
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (!d.wgt) return;
+    int iw = 15, ih = 15;
+    d.wgt->ideal_size(iw, ih);
+    if (d.drag == FD_RIGHT) {
+      check_x_(d, d.br, d.bx+iw);
+      iw = layout->widget_min_w;
+      if (iw > 0) iw = nearest(d.br-d.bx+d.dx, layout->widget_min_w, layout->widget_inc_w);
+      check_x_(d, d.br, d.bx+iw);
+    } else {
+      check_x_(d, d.bx, d.br-iw);
+      iw = layout->widget_min_w;
+      if (iw > 0) iw = nearest(d.br-d.bx-d.dx, layout->widget_min_w, layout->widget_inc_w);
+      check_x_(d, d.bx, d.br-iw);
+    }
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_width(d.bx, d.bt+7, d.br, 0);
+  };
+};
+Fd_Snap_Widget_Ideal_Width snap_widget_ideal_width;
+
+class Fd_Snap_Widget_Ideal_Height : public Fd_Snap_Action {
+public:
+  Fd_Snap_Widget_Ideal_Height() { type = 2; mask = FD_TOP|FD_BOTTOM; }
+  void check(Fd_Snap_Data &d) FL_OVERRIDE {
+    clr();
+    if (!d.wgt) return;
+    int iw, ih;
+    d.wgt->ideal_size(iw, ih);
+    if (d.drag == FD_BOTTOM) {
+      check_y_(d, d.bt, d.by+ih);
+      ih = layout->widget_min_h;
+      if (ih > 0) ih = nearest(d.bt-d.by+d.dy, layout->widget_min_h, layout->widget_inc_h);
+      check_y_(d, d.bt, d.by+ih);
+    } else {
+      check_y_(d, d.by, d.bt-ih);
+      ih = layout->widget_min_h;
+      if (ih > 0) ih = nearest(d.bt-d.by-d.dy, layout->widget_min_h, layout->widget_inc_h);
+      check_y_(d, d.by, d.bt-ih);
+    }
+  }
+  void draw(Fd_Snap_Data &d) FL_OVERRIDE {
+    draw_height(d.br+7, d.by, d.bt, 0);
+  };
+};
+Fd_Snap_Widget_Ideal_Height snap_widget_ideal_height;
+
+// ---- snap actions list ---------------------------------------------- MARK: -
+
+/**
+ /brief The list of all snap actions available to FLUID.
+ New snap actions can be appended to the list. If multiple snap actions
+ with different coordinates, but the same snap distance are found, the last
+ action in the list wins. All snap actions with the same distance and same
+ winning coordinates are drawn in the overlay plane.
+ */
+Fd_Snap_Action *Fd_Snap_Action::list[] = {
+  &snap_left_window_edge,
+  &snap_right_window_edge,
+  &snap_top_window_edge,
+  &snap_bottom_window_edge,
+
+  &snap_left_window_margin,
+  &snap_right_window_margin,
+  &snap_top_window_margin,
+  &snap_bottom_window_margin,
+
+  &snap_window_grid,
+  &snap_group_grid,
+
+  &snap_left_group_edge,
+  &snap_right_group_edge,
+  &snap_top_group_edge,
+  &snap_bottom_group_edge,
+
+  &snap_left_group_margin,
+  &snap_right_group_margin,
+  &snap_top_group_margin,
+  &snap_bottom_group_margin,
+
+  &snap_top_tabs_margin,
+  &snap_bottom_tabs_margin,
+
+  &snap_siblings_left_same, &snap_siblings_left,
+  &snap_siblings_right_same, &snap_siblings_right,
+  &snap_siblings_top_same, &snap_siblings_top,
+  &snap_siblings_bottom_same, &snap_siblings_bottom,
+
+  &snap_widget_ideal_width,
+  &snap_widget_ideal_height,
+
+  NULL
+};
+
+// ---- draw alignment marks ------------------------------------------- MARK: -
+
+static void draw_v_arrow(int x, int y1, int y2) {
+  int dy = (y1>y2) ? -1 : 1 ;
+  fl_yxline(x, y1, y2);
+  fl_xyline(x-4, y2, x+4);
+  fl_line(x-2, y2-dy*5, x, y2-dy);
+  fl_line(x+2, y2-dy*5, x, y2-dy);
+}
+
+static void draw_h_arrow(int x1, int y, int x2) {
+  int dx = (x1>x2) ? -1 : 1 ;
+  fl_xyline(x1, y, x2);
+  fl_yxline(x2, y-4, y+4);
+  fl_line(x2-dx*5, y-2, x2-dx, y);
+  fl_line(x2-dx*5, y+2, x2-dx, y);
+}
+
+static void draw_top_brace(const Fl_Widget *w) {
+  int x = w->as_window() ? 0 : w->x();
+  int y = w->as_window() ? 0 : w->y();
+  fl_yxline(x, y-2, y+6);
+  fl_yxline(x+w->w()-1, y-2, y+6);
+  fl_xyline(x-2, y, x+w->w()+1);
+}
+
+static void draw_left_brace(const Fl_Widget *w)  {
+  int x = w->as_window() ? 0 : w->x();
+  int y = w->as_window() ? 0 : w->y();
+  fl_xyline(x-2, y, x+6);
+  fl_xyline(x-2, y+w->h()-1, x+6);
+  fl_yxline(x, y-2, y+w->h()+1);
+}
+
+static void draw_right_brace(const Fl_Widget *w) {
+  int x = w->as_window() ? w->w() - 1 : w->x() + w->w() - 1;
+  int y = w->as_window() ? 0 : w->y();
+  fl_xyline(x-6, y, x+2);
+  fl_xyline(x-6, y+w->h()-1, x+2);
+  fl_yxline(x, y-2, y+w->h()+1);
+}
+
+static void draw_bottom_brace(const Fl_Widget *w) {
+  int x = w->as_window() ? 0 : w->x();
+  int y = w->as_window() ? w->h() - 1 : w->y() + w->h() - 1;
+  fl_yxline(x, y-6, y+2);
+  fl_yxline(x+w->w()-1, y-6, y+2);
+  fl_xyline(x-2, y, x+w->w()+1);
+}
+
+void draw_height(int x, int y, int b, Fl_Align a) {
+  char buf[16];
+  int h = b - y;
+  sprintf(buf, "%d", h);
+  fl_font(FL_HELVETICA, 9);
+  int lw = (int)fl_width(buf);
+  int lx;
+
+  b --;
+  if (h < 30) {
+    // Move height to the side...
+    if (a == FL_ALIGN_LEFT) lx = x - lw - 2;
+    else lx = x + 2;
+    fl_yxline(x, y, b);
+  } else {
+    // Put height inside the arrows...
+    if (a == FL_ALIGN_LEFT) lx = x - lw + 2;
+    else lx = x - lw / 2;
+    fl_yxline(x, y, y + (h - 11) / 2);
+    fl_yxline(x, y + (h + 11) / 2, b);
+  }
+
+  // Draw the height...
+  fl_draw(buf, lx, y + (h + 7) / 2);
+
+  // Draw the arrowheads...
+  fl_line(x-2, y+5, x, y+1, x+2, y+5);
+  fl_line(x-2, b-5, x, b-1, x+2, b-5);
+
+  // Draw the end lines...
+  fl_xyline(x - 4, y, x + 4);
+  fl_xyline(x - 4, b, x + 4);
+}
+
+void draw_width(int x, int y, int r, Fl_Align a) {
+  char buf[16];
+  int w = r-x;
+  sprintf(buf, "%d", w);
+  fl_font(FL_HELVETICA, 9);
+  int lw = (int)fl_width(buf);
+  int ly = y + 4;
+
+  r--;
+
+  if (lw > (w - 20)) {
+    // Move width above/below the arrows...
+    if (a == FL_ALIGN_TOP) ly -= 10;
+    else ly += 10;
+
+    fl_xyline(x, y, r);
+  } else {
+    // Put width inside the arrows...
+    fl_xyline(x, y, x + (w - lw - 2) / 2);
+    fl_xyline(x + (w + lw + 2) / 2, y, r);
+  }
+
+  // Draw the width...
+  fl_draw(buf, x + (w - lw) / 2, ly-2);
+
+  // Draw the arrowheads...
+  fl_line(x+5, y-2, x+1, y, x+5, y+2);
+  fl_line(r-5, y-2, r-1, y, r-5, y+2);
+
+  // Draw the end lines...
+  fl_yxline(x, y - 4, y + 4);
+  fl_yxline(r, y - 4, y + 4);
+}
+
+static void draw_grid(int x, int y, int dx, int dy) {
+  int dx2 = 1, dy2 = 1;
+  const int n = 2;
+  for (int i=-n; i<=n; i++) {
+    for (int j=-n; j<=n; j++) {
+      if (abs(i)+abs(j) < 4) {
+        int xx = x + i*dx , yy = y + j*dy;
+        fl_xyline(xx-dx2, yy, xx+dx2);
+        fl_yxline(xx, yy-dy2, yy+dy2);
+      }
+    }
+  }
+}
diff --git a/fluid/app/Fd_Snap_Action.h b/fluid/app/Fd_Snap_Action.h
new file mode 100644
index 000000000..50b520319
--- /dev/null
+++ b/fluid/app/Fd_Snap_Action.h
@@ -0,0 +1,193 @@
+//
+// Snap action header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#ifndef _FLUID_FD_SNAP_ACTION_H
+#define _FLUID_FD_SNAP_ACTION_H
+
+#include "app/fluid.h"
+#include "nodes/Fl_Window_Type.h"
+
+#include <string>
+
+struct Fl_Menu_Item;
+
+extern Fl_Menu_Item main_layout_submenu_[];
+
+/**
+ \brief Collection of layout settings.
+
+ Presets contain default fonts and font sizes for labels and text. They
+ can be used to guide widget positions using margins, grids, and gap sizes.
+ There are three Presets available in one Suite, marked "application",
+ "dialog", and "toolbox".
+ */
+class Fd_Layout_Preset {
+public:
+  int left_window_margin;   ///< gap between the window border and the widget
+  int right_window_margin;
+  int top_window_margin;
+  int bottom_window_margin;
+  int window_grid_x;        ///< a regular grid across the window with its origin in the top left window corner
+  int window_grid_y;
+
+  int left_group_margin;    ///< gap between the border of a widget and its parent group
+  int right_group_margin;
+  int top_group_margin;
+  int bottom_group_margin;
+  int group_grid_x;         ///< a regular grid across the group with its origin in the top left group corner
+  int group_grid_y;
+
+  int top_tabs_margin;      ///< preferred top edge tab size inside Fl_Tabs
+  int bottom_tabs_margin;   ///< preferred bottom edge tab size inside Fl_Tabs
+
+  int widget_min_w;         ///< minimum widget width
+  int widget_inc_w;         ///< widget width increments starting from widget_min_w
+  int widget_gap_x;         ///< preferred horizontal gap between widgets
+  int widget_min_h;
+  int widget_inc_h;
+  int widget_gap_y;
+
+  int labelfont;            ///< preferred font for labels
+  int labelsize;            ///< preferred size for labels
+  int textfont;             ///< preferred font for text elements
+  int textsize;             ///< preferred size for text elements
+
+  void write(Fl_Preferences &prefs);
+  void read(Fl_Preferences &prefs);
+  void write(Fd_Project_Writer*);
+  void read(Fd_Project_Reader*);
+
+  int textsize_not_null();
+};
+
+extern Fd_Layout_Preset *layout;
+
+/**
+ \brief A collection of layout presets.
+
+ A suite of layout presets is designed to cover various use cases when
+ designing UI layouts for applications.
+ There are three Presets available in one Suite, marked "application",
+ "dialog", and "toolbox".
+ */
+class Fd_Layout_Suite {
+public:
+  char *name_;                  ///< name of the suite
+  char *menu_label;             ///< label text used in pulldown menu
+  Fd_Layout_Preset *layout[3];  ///< presets for application, dialog, and toolbox windows
+  Fd_Tool_Store storage_;       ///< storage location (see FD_STORE_INTERNAL, etc.)
+  void write(Fl_Preferences &prefs);
+  void read(Fl_Preferences &prefs);
+  void write(Fd_Project_Writer*);
+  void read(Fd_Project_Reader*);
+  void update_label();
+  void storage(Fd_Tool_Store s) { storage_ = s; update_label(); }
+  void name(const char *n);
+  void init();
+  ~Fd_Layout_Suite();
+public:
+
+};
+
+/**
+ \brief Manage all layout suites that are available to the user.
+
+ FLUID has two built-in suites. More suites can be cloned or added and stored
+ as a user preference, as part of an .fl project file, or in a separate file
+ for import/export and sharing.
+ */
+class Fd_Layout_List {
+public:
+  Fl_Menu_Item *main_menu_;
+  Fl_Menu_Item *choice_menu_;
+  Fd_Layout_Suite *list_;
+  int list_size_;
+  int list_capacity_;
+  bool list_is_static_;
+  int current_suite_;
+  int current_preset_;
+  std::string filename_;
+public:
+  Fd_Layout_List();
+  ~Fd_Layout_List();
+  void update_dialogs();
+  void update_menu_labels();
+  int current_suite() const { return current_suite_; }
+  void current_suite(int ix);
+  void current_suite(std::string);
+  int current_preset() const { return current_preset_; }
+  void current_preset(int ix);
+  Fd_Layout_Suite &operator[](int ix) { return list_[ix]; }
+  int add(const char *name);
+  void rename(const char *name);
+  void capacity(int);
+
+  int load(const std::string &filename);
+  int save(const std::string &filename);
+  void write(Fl_Preferences &prefs, Fd_Tool_Store storage);
+  void read(Fl_Preferences &prefs, Fd_Tool_Store storage);
+  void write(Fd_Project_Writer*);
+  void read(Fd_Project_Reader*);
+  int add(Fd_Layout_Suite*);
+  void remove(int index);
+  void remove_all(Fd_Tool_Store storage);
+  Fd_Layout_Preset *at(int);
+  int size();
+};
+
+extern Fd_Layout_List g_layout_list;
+
+/**
+ \brief Structure holding all the data to perform interactive alignment operations.
+ */
+typedef struct Fd_Snap_Data {
+  int dx, dy;           ///< distance of the mouse from its initial PUSH event
+  int bx, by, br, bt;   ///< bounding box of the original push event or current bounding box when drawing
+  int drag;             ///< drag event mask
+  int x_dist, y_dist;   ///< current closest snapping distance in x and y
+  int dx_out, dy_out;   ///< current closest snapping point as a delta
+  Fl_Widget_Type *wgt;  ///< first selected widget
+  Fl_Window_Type *win;  ///< window that handles the drag action
+  int ex_out, ey_out;   ///< chosen snap position
+} Fd_Snap_Data;
+
+/**
+ \brief Find points of interest when moving the bounding box of all selected widgets.
+ */
+class Fd_Snap_Action {
+protected:
+  int check_x_(Fd_Snap_Data &d, int x_ref, int x_snap);
+  int check_y_(Fd_Snap_Data &d, int y_ref, int y_snap);
+  void check_x_y_(Fd_Snap_Data &d, int x_ref, int x_snap, int y_ref, int y_snap);
+  void clr() { ex = dx = 0x7fff;  }
+public:
+  int ex, ey, dx, dy, type, mask;
+  Fd_Snap_Action() : ex(0x7fff), ey(0x7fff), dx(128), dy(128), type(0), mask(0) { }
+  virtual ~Fd_Snap_Action() { }
+  virtual void check(Fd_Snap_Data &d) = 0;
+  virtual void draw(Fd_Snap_Data &d) { }
+  virtual bool matches(Fd_Snap_Data &d);
+public:
+  static int eex, eey;
+  static Fd_Snap_Action *list[];
+  static void check_all(Fd_Snap_Data &d);
+  static void draw_all(Fd_Snap_Data &d);
+  static void get_resize_stepsize(int &x_step, int &y_step);
+  static void get_move_stepsize(int &x_step, int &y_step);
+  static void better_size(int &w, int &h);
+};
+
+#endif // _FLUID_FD_SNAP_ACTION_H
diff --git a/fluid/app/Fluid_Image.cxx b/fluid/app/Fluid_Image.cxx
new file mode 100644
index 000000000..d25f17023
--- /dev/null
+++ b/fluid/app/Fluid_Image.cxx
@@ -0,0 +1,412 @@
+//
+// Pixmap (and other images) label support for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2022 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#include "app/Fluid_Image.h"
+
+#include "app/fluid.h"
+#include "io/file.h"
+#include "io/code.h"
+#include "nodes/Fl_Group_Type.h"
+#include "nodes/Fl_Window_Type.h"
+#include "tools/fluid_filename.h"
+
+#include <FL/Fl.H>
+#include <FL/Fl_Widget.H>
+#include <FL/Fl_Window.H>
+#include <FL/fl_string_functions.h>
+#include <FL/fl_utf8.h>     // fl_fopen()
+#include <FL/Fl_File_Chooser.H>
+#include <FL/Fl_SVG_Image.H>
+#include <FL/Fl_Anim_GIF_Image.H>
+#include "../src/flstring.h"
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+void Fluid_Image::image(Fl_Widget *o) {
+  if (o->window() != o) o->image(img);
+}
+
+void Fluid_Image::deimage(Fl_Widget *o) {
+  if (o->window() != o) o->deimage(img);
+}
+
+/** Write the contents of the name() file as binary source code.
+ \param fmt short name of file contents for error message
+ \return 0 if the file could not be opened or read */
+size_t Fluid_Image::write_static_binary(Fd_Code_Writer& f, const char* fmt) {
+  size_t nData = 0;
+  enter_project_dir();
+  FILE *in = fl_fopen(name(), "rb");
+  leave_project_dir();
+  if (!in) {
+    write_file_error(f, fmt);
+    return 0;
+  } else {
+    fseek(in, 0, SEEK_END);
+    nData = ftell(in);
+    fseek(in, 0, SEEK_SET);
+    if (nData) {
+      char *data = (char*)calloc(nData, 1);
+      if (fread(data, nData, 1, in)==0) { /* ignore */ }
+      f.write_cdata(data, (int)nData);
+      free(data);
+    }
+    fclose(in);
+  }
+  return nData;
+}
+
+/** Write the contents of the name() file as textual source code.
+ \param fmt short name of file contents for error message
+ \return 0 if the file could not be opened or read */
+size_t Fluid_Image::write_static_text(Fd_Code_Writer& f, const char* fmt) {
+  size_t nData = 0;
+  enter_project_dir();
+  FILE *in = fl_fopen(name(), "rb");
+  leave_project_dir();
+  if (!in) {
+    write_file_error(f, fmt);
+    return 0;
+  } else {
+    fseek(in, 0, SEEK_END);
+    nData = ftell(in);
+    fseek(in, 0, SEEK_SET);
+    if (nData) {
+      char *data = (char*)calloc(nData+1, 1);
+      if (fread(data, nData, 1, in)==0) { /* ignore */ }
+      f.write_cstring(data, (int)nData);
+      free(data);
+    }
+    fclose(in);
+  }
+  return nData;
+}
+
+void Fluid_Image::write_static_rgb(Fd_Code_Writer& f, const char* idata_name) {
+  // Write image data...
+  f.write_c("\n");
+  f.write_c_once("#include <FL/Fl_Image.H>\n");
+  f.write_c("static const unsigned char %s[] =\n", idata_name);
+  const int extra_data = img->ld() ? (img->ld()-img->w()*img->d()) : 0;
+  f.write_cdata(img->data()[0], (img->w() * img->d() + extra_data) * img->h());
+  f.write_c(";\n");
+  write_initializer(f, "Fl_RGB_Image", "%s, %d, %d, %d, %d", idata_name, img->w(), img->h(), img->d(), img->ld());
+}
+
+/**
+ Write the static image data into the soutrce file.
+
+ If \p compressed is set, write the original image format, which requires
+ linking the matching image reader at runtime, or if we want to store the raw
+ uncompressed pixels, which makes images fast, needs no reader, but takes a
+ lot of memory (current default for PNG)
+
+ \param compressed write data in the original compressed file format
+ */
+void Fluid_Image::write_static(Fd_Code_Writer& f, int compressed) {
+  if (!img) return;
+  const char *idata_name = f.unique_id(this, "idata", fl_filename_name(name()), 0);
+  function_name_ = f.unique_id(this, "image", fl_filename_name(name()), 0);
+
+  if (is_animated_gif_) {
+    // Write animated gif image data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_Anim_GIF_Image.H>\n");
+    f.write_c("static const unsigned char %s[] =\n", idata_name);
+    size_t nData = write_static_binary(f, "AnimGIF");
+    f.write_c(";\n");
+    write_initializer(f, "Fl_Anim_GIF_Image", "\"%s\", %s, %d", fl_filename_name(name()), idata_name, nData);
+  } else if (compressed && fl_ascii_strcasecmp(fl_filename_ext(name()), ".gif")==0) {
+    // Write gif image data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_GIF_Image.H>\n");
+    f.write_c("static const unsigned char %s[] =\n", idata_name);
+    size_t nData = write_static_binary(f, "GIF");
+    f.write_c(";\n");
+    write_initializer(f, "Fl_GIF_Image", "\"%s\", %s, %d", fl_filename_name(name()), idata_name, nData);
+  } else if (compressed && fl_ascii_strcasecmp(fl_filename_ext(name()), ".bmp")==0) {
+    // Write bmp image data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_BMP_Image.H>\n");
+    f.write_c("static const unsigned char %s[] =\n", idata_name);
+    size_t nData = write_static_binary(f, "BMP");
+    f.write_c(";\n");
+    write_initializer(f, "Fl_BMP_Image", "\"%s\", %s, %d", fl_filename_name(name()), idata_name, nData);
+  } else if (img->count() > 1) {
+    // Write Pixmap data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_Pixmap.H>\n");
+    f.write_c("static const char *%s[] = {\n", idata_name);
+    f.write_cstring(img->data()[0], (int)strlen(img->data()[0]));
+
+    int i;
+    int ncolors, chars_per_color;
+    sscanf(img->data()[0], "%*d%*d%d%d", &ncolors, &chars_per_color);
+
+    if (ncolors < 0) {
+      f.write_c(",\n");
+      f.write_cstring(img->data()[1], ncolors * -4);
+      i = 2;
+    } else {
+      for (i = 1; i <= ncolors; i ++) {
+        f.write_c(",\n");
+        f.write_cstring(img->data()[i], (int)strlen(img->data()[i]));
+      }
+    }
+    for (; i < img->count(); i ++) {
+      f.write_c(",\n");
+      f.write_cstring(img->data()[i], img->w() * chars_per_color);
+    }
+    f.write_c("\n};\n");
+    write_initializer(f, "Fl_Pixmap", "%s", idata_name);
+  } else if (img->d() == 0) {
+    // Write Bitmap data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_Bitmap.H>\n");
+    f.write_c("static const unsigned char %s[] =\n", idata_name);
+    f.write_cdata(img->data()[0], ((img->w() + 7) / 8) * img->h());
+    f.write_c(";\n");
+    write_initializer(f, "Fl_Bitmap", "%s, %d, %d, %d", idata_name, ((img->w() + 7) / 8) * img->h(), img->w(), img->h());
+  } else if (compressed && fl_ascii_strcasecmp(fl_filename_ext(name()), ".jpg")==0) {
+    // Write jpeg image data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_JPEG_Image.H>\n");
+    f.write_c("static const unsigned char %s[] =\n", idata_name);
+    size_t nData = write_static_binary(f, "JPEG");
+    f.write_c(";\n");
+    write_initializer(f, "Fl_JPEG_Image", "\"%s\", %s, %d", fl_filename_name(name()), idata_name, nData);
+  } else if (compressed && fl_ascii_strcasecmp(fl_filename_ext(name()), ".png")==0) {
+    // Write png image data...
+    f.write_c("\n");
+    f.write_c_once("#include <FL/Fl_PNG_Image.H>\n");
+    f.write_c("static const unsigned char %s[] =\n", idata_name);
+    size_t nData = write_static_binary(f, "PNG");
+    f.write_c(";\n");
+    write_initializer(f, "Fl_PNG_Image", "\"%s\", %s, %d", fl_filename_name(name()), idata_name, nData);
+  }
+#ifdef FLTK_USE_SVG
+  else if (fl_ascii_strcasecmp(fl_filename_ext(name()), ".svg")==0 || fl_ascii_strcasecmp(fl_filename_ext(name()), ".svgz")==0) {
+    bool gzipped = (strcmp(fl_filename_ext(name()), ".svgz") == 0);
+    // Write svg image data...
+    if (compressed) {
+      f.write_c("\n");
+      f.write_c_once("#include <FL/Fl_SVG_Image.H>\n");
+      if (gzipped) {
+        f.write_c("static const unsigned char %s[] =\n", idata_name);
+        size_t nData = write_static_binary(f, "SVGZ");
+        f.write_c(";\n");
+        write_initializer(f, "Fl_SVG_Image", "\"%s\", %s, %ld", fl_filename_name(name()), idata_name, nData);
+      } else {
+        f.write_c("static const char %s[] =\n", idata_name);
+        write_static_text(f, "SVG");
+        f.write_c(";\n");
+        write_initializer(f, "Fl_SVG_Image", "\"%s\", %s", fl_filename_name(name()), idata_name);
+      }
+    } else {
+      // if FLUID runs from the command line, make sure that the image is not
+      // only loaded but also rasterized, so we can write the RGB image data
+      Fl_RGB_Image* rgb_image = NULL;
+      Fl_SVG_Image* svg_image = NULL;
+      if (img->d()>0)
+        rgb_image = (Fl_RGB_Image*)img->image();
+      if (rgb_image)
+        svg_image = rgb_image->as_svg_image();
+      if (svg_image) {
+        svg_image->resize(svg_image->w(), svg_image->h());
+        write_static_rgb(f, idata_name);
+      } else {
+        write_file_error(f, "RGB_from_SVG");
+      }
+    }
+  }
+#endif // FLTK_USE_SVG
+  else {
+    write_static_rgb(f, idata_name);
+  }
+}
+
+void Fluid_Image::write_file_error(Fd_Code_Writer& f, const char *fmt) {
+  f.write_c("#warning Cannot read %s file \"%s\": %s\n", fmt, name(), strerror(errno));
+  enter_project_dir();
+  f.write_c("// Searching in path \"%s\"\n", fl_getcwd(0, FL_PATH_MAX));
+  leave_project_dir();
+}
+
+void Fluid_Image::write_initializer(Fd_Code_Writer& f, const char *type_name, const char *format, ...) {
+  /* Outputs code that returns (and initializes if needed) an Fl_Image as follows:
+   static Fl_Image *'function_name_'() {
+     static Fl_Image *image = NULL;
+     if (!image)
+       image = new 'type_name'('product of format and remaining args');
+     return image;
+   } */
+  va_list ap;
+  va_start(ap, format);
+  f.write_c("static Fl_Image *%s() {\n", function_name_);
+  if (is_animated_gif_)
+    f.write_c("%sFl_GIF_Image::animate = true;\n", f.indent(1));
+  f.write_c("%sstatic Fl_Image *image = NULL;\n", f.indent(1));
+  f.write_c("%sif (!image)\n", f.indent(1));
+  f.write_c("%simage = new %s(", f.indent(2), type_name);
+  f.vwrite_c(format, ap);
+  f.write_c(");\n");
+  f.write_c("%sreturn image;\n", f.indent(1));
+  f.write_c("}\n");
+  va_end(ap);
+}
+
+void Fluid_Image::write_code(Fd_Code_Writer& f, int bind, const char *var, int inactive) {
+  /* Outputs code that attaches an image to an Fl_Widget or Fl_Menu_Item.
+   This code calls a function output before by Fluid_Image::write_initializer() */
+  if (img) {
+    f.write_c("%s%s->%s%s( %s() );\n", f.indent(), var, bind ? "bind_" : "", inactive ? "deimage" : "image", function_name_);
+    if (is_animated_gif_)
+      f.write_c("%s((Fl_Anim_GIF_Image*)(%s()))->canvas(%s, Fl_Anim_GIF_Image::DONT_RESIZE_CANVAS);\n", f.indent(), function_name_, var);
+  }
+}
+
+void Fluid_Image::write_inline(Fd_Code_Writer& f, int inactive) {
+  if (img)
+    f.write_c("%s()", function_name_);
+}
+
+
+////////////////////////////////////////////////////////////////
+
+static Fluid_Image** images = 0; // sorted list
+static int numimages = 0;
+static int tablesize = 0;
+
+Fluid_Image* Fluid_Image::find(const char *iname) {
+  if (!iname || !*iname) return 0;
+
+  // first search to see if it exists already:
+  int a = 0;
+  int b = numimages;
+  while (a < b) {
+    int c = (a+b)/2;
+    int i = strcmp(iname,images[c]->name_);
+    if (i < 0) b = c;
+    else if (i > 0) a = c+1;
+    else return images[c];
+  }
+
+  // no, so now see if the file exists:
+
+  enter_project_dir();
+  FILE *f = fl_fopen(iname,"rb");
+  if (!f) {
+    if (batch_mode)
+      fprintf(stderr, "Can't open image file:\n%s\n%s",iname,strerror(errno));
+    else
+      fl_message("Can't open image file:\n%s\n%s",iname,strerror(errno));
+    leave_project_dir();
+    return 0;
+  }
+  fclose(f);
+
+  Fluid_Image *ret = new Fluid_Image(iname);
+
+  if (!ret->img || !ret->img->w() || !ret->img->h()) {
+    delete ret;
+    ret = 0;
+    if (batch_mode)
+      fprintf(stderr, "Can't read image file:\n%s\nunrecognized image format",iname);
+    else
+      fl_message("Can't read image file:\n%s\nunrecognized image format",iname);
+  }
+  leave_project_dir();
+  if (!ret) return 0;
+
+  // make a new entry in the table:
+  numimages++;
+  if (numimages > tablesize) {
+    tablesize = tablesize ? 2*tablesize : 16;
+    if (images) images = (Fluid_Image**)realloc(images, tablesize*sizeof(Fluid_Image*));
+    else images = (Fluid_Image**)malloc(tablesize*sizeof(Fluid_Image*));
+  }
+  for (b = numimages-1; b > a; b--) images[b] = images[b-1];
+  images[a] = ret;
+
+  return ret;
+}
+
+Fluid_Image::Fluid_Image(const char *iname)
+  : is_animated_gif_(false)
+{
+  name_ = fl_strdup(iname);
+  written = 0;
+  refcount = 0;
+  img = Fl_Shared_Image::get(iname);
+  if (img && iname) {
+    const char *ext = fl_filename_ext(iname);
+    if (fl_ascii_strcasecmp(ext, ".gif")==0) {
+      int fc = Fl_Anim_GIF_Image::frame_count(iname);
+      if (fc > 0) is_animated_gif_ = true;
+    }
+  }
+  function_name_ = NULL;
+}
+
+void Fluid_Image::increment() {
+  ++refcount;
+}
+
+void Fluid_Image::decrement() {
+  --refcount;
+  if (refcount > 0) return;
+  delete this;
+}
+
+Fluid_Image::~Fluid_Image() {
+  int a;
+  if (images) {
+    for (a = 0; a<numimages; a++) {
+      if (images[a] == this) {
+        numimages--;
+        for (; a < numimages; a++) {
+          images[a] = images[a+1];
+        }
+        break;
+      }
+    }
+  }
+  if (img) img->release();
+  free((void*)name_);
+}
+
+////////////////////////////////////////////////////////////////
+
+const char *ui_find_image_name;
+Fluid_Image *ui_find_image(const char *oldname) {
+  enter_project_dir();
+  fl_file_chooser_ok_label("Use Image");
+  const char *name = fl_file_chooser("Image?",
+            "Image Files (*.{bm,bmp,gif,jpg,pbm,pgm,png,ppm,xbm,xpm,svg"
+#ifdef HAVE_LIBZ
+                        ",svgz"
+#endif
+                                     "})",
+            oldname,1);
+  fl_file_chooser_ok_label(NULL);
+  ui_find_image_name = name;
+  Fluid_Image *ret = (name && *name) ? Fluid_Image::find(name) : 0;
+  leave_project_dir();
+  return ret;
+}
diff --git a/fluid/app/Fluid_Image.h b/fluid/app/Fluid_Image.h
new file mode 100644
index 000000000..e3b5faaac
--- /dev/null
+++ b/fluid/app/Fluid_Image.h
@@ -0,0 +1,60 @@
+//
+// Image header file for the Fast Light Tool Kit (FLTK).
+//
+// This class stores the image labels for widgets in fluid.  This is
+// not a class in FLTK itself, and will produce different types of
+// code depending on what the image type is.
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#ifndef FLUID_IMAGE_H
+#define FLUID_IMAGE_H
+
+#include "io/code.h"
+
+#include <FL/Fl_Shared_Image.H>
+
+class Fluid_Image {
+  bool is_animated_gif_;
+  const char *name_;
+  int refcount;
+  Fl_Shared_Image *img;
+  const char *function_name_;
+protected:
+  Fluid_Image(const char *name); // no public constructor
+  ~Fluid_Image(); // no public destructor
+  size_t write_static_binary(Fd_Code_Writer& f, const char* fmt);
+  size_t write_static_text(Fd_Code_Writer& f, const char* fmt);
+  void write_static_rgb(Fd_Code_Writer& f, const char* idata_name);
+public:
+  int written;
+  static Fluid_Image* find(const char *);
+  void decrement(); // reference counting & automatic free
+  void increment();
+  void image(Fl_Widget *); // set the image of this widget
+  void deimage(Fl_Widget *); // set the deimage of this widget
+  void write_static(Fd_Code_Writer& f, int compressed);
+  void write_initializer(Fd_Code_Writer& f, const char *type_name, const char *format, ...);
+  void write_code(Fd_Code_Writer& f, int bind, const char *var, int inactive = 0);
+  void write_inline(Fd_Code_Writer& f, int inactive = 0);
+  void write_file_error(Fd_Code_Writer& f, const char *fmt);
+  const char *name() const {return name_;}
+};
+
+// pop up file chooser and return a legal image selected by user,
+// or zero for any errors:
+Fluid_Image *ui_find_image(const char *);
+extern const char *ui_find_image_name;
+
+#endif
diff --git a/fluid/app/align_widget.cxx b/fluid/app/align_widget.cxx
new file mode 100644
index 000000000..a9badf9e4
--- /dev/null
+++ b/fluid/app/align_widget.cxx
@@ -0,0 +1,414 @@
+//
+// Alignment code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#include "app/align_widget.h"
+
+#include "app/fluid.h"
+#include "app/undo.h"
+#include "nodes/Fl_Group_Type.h"
+
+#include <FL/Fl.H>
+#include <FL/Fl_Window.H>
+
+/**
+ the first behavior always uses the first selected widget as a reference
+ the second behavior uses the largest widget (most extreme positions) as
+ a reference.
+ */
+#define BREAK_ON_FIRST break
+//#define BREAK_ON_FIRST
+
+void align_widget_cb(Fl_Widget*, long how)
+{
+  const int max = 32768, min = -32768;
+  int left, right, top, bot, wdt, hgt, n;
+  Fl_Type *o;
+  int changed = 0;
+  switch ( how )
+  {
+  //---- align
+  case 10: // align left
+    left = max;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->x()<left)
+          left = w->x();
+        BREAK_ON_FIRST;
+      }
+    if (left!=max)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(left, w->y(), w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  case 11: // align h.center
+    left = max; right = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->x()<left)
+          left = w->x();
+        if (w->x()+w->w()>right)
+          right = w->x()+w->w();
+        BREAK_ON_FIRST;
+      }
+    if (left!=max)
+    {
+      int center2 = left+right;
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize((center2-w->w())/2, w->y(), w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    }
+    break;
+  case 12: // align right
+    right = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->x()+w->w()>right)
+          right = w->x()+w->w();
+        BREAK_ON_FIRST;
+      }
+    if (right!=min)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(right-w->w(), w->y(), w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  case 13: // align top
+    top = max;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->y()<top)
+          top = w->y();
+        BREAK_ON_FIRST;
+      }
+    if (top!=max)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(w->x(), top, w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  case 14: // align v.center
+    top = max; bot = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->y()<top)
+          top = w->y();
+        if (w->y()+w->h()>bot)
+          bot = w->y()+w->h();
+        BREAK_ON_FIRST;
+      }
+    if (top!=max)
+    {
+      int center2 = top+bot;
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(w->x(), (center2-w->h())/2, w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    }
+    break;
+  case 15: // align bottom
+    bot = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->y()+w->h()>bot)
+          bot = w->y()+w->h();
+        BREAK_ON_FIRST;
+      }
+    if (bot!=min)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize( w->x(), bot-w->h(), w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  //---- space evenly
+  case 20: // space evenly across
+    left = max; right = min; wdt = 0; n = 0;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->x()<left)
+          left = w->x();
+        if (w->x()+w->w()>right)
+          right = w->x()+w->w();
+        wdt += w->w();
+        n++;
+      }
+    wdt = (right-left)-wdt;
+    n--;
+    if (n>0)
+    {
+      wdt = wdt/n*n; // make sure that all gaps are the same, possibly moving the rightmost widget
+      int cnt = 0, wsum = 0;
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(left+wsum+wdt*cnt/n, w->y(), w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+          cnt++;
+          wsum += w->w();
+        }
+    }
+    break;
+  case 21: // space evenly down
+    top = max; bot = min; hgt = 0, n = 0;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->y()<top)
+          top = w->y();
+        if (w->y()+w->h()>bot)
+          bot = w->y()+w->h();
+        hgt += w->h();
+        n++;
+      }
+    hgt = (bot-top)-hgt;
+    n--;
+    if (n>0)
+    {
+      hgt = hgt/n*n; // make sure that all gaps are the same, possibly moving the rightmost widget
+      int cnt = 0, hsum = 0;
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(w->x(), top+hsum+hgt*cnt/n, w->w(), w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+          cnt++;
+          hsum += w->h();
+        }
+    }
+    break;
+  //---- make same size
+  case 30: // same width
+    wdt = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->w()>wdt)
+          wdt = w->w();
+        BREAK_ON_FIRST;
+      }
+    if (wdt!=min)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize(w->x(), w->y(), wdt, w->h());
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  case 31: // same height
+    hgt = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->h()>hgt)
+          hgt = w->h();
+        BREAK_ON_FIRST;
+      }
+    if (hgt!=min)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize( w->x(), w->y(), w->w(), hgt);
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  case 32: // same size
+    hgt = min; wdt = min;
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget())
+      {
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        if (w->w()>wdt)
+          wdt = w->w();
+        if (w->h()>hgt)
+          hgt = w->h();
+        BREAK_ON_FIRST;
+      }
+    if (hgt!=min)
+      for (Fl_Type *o = Fl_Type::first; o; o = o->next)
+        if (o->selected && o->is_widget())
+        {
+          if (!changed) {
+            changed = 1;
+            undo_checkpoint();
+          }
+          Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+          Fl_Type::allow_layout++;
+          w->resize( w->x(), w->y(), wdt, hgt);
+          Fl_Type::allow_layout--;
+          w->redraw();
+          if (w->window()) w->window()->redraw();
+        }
+    break;
+  //---- center in group
+  case 40: // center hor
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget() && o->parent)
+      {
+        if (!changed) {
+          changed = 1;
+          undo_checkpoint();
+        }
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        Fl_Widget *p = ((Fl_Widget_Type *)o->parent)->o;
+        int center2;
+
+        if (w->window() == p) center2 = p->w();
+        else center2 = 2*p->x()+p->w();
+
+        Fl_Type::allow_layout++;
+        w->resize((center2-w->w())/2, w->y(), w->w(), w->h());
+        Fl_Type::allow_layout--;
+        w->redraw();
+        if (w->window()) w->window()->redraw();
+      }
+    break;
+  case 41: // center vert
+    for (o = Fl_Type::first; o; o = o->next)
+      if (o->selected && o->is_widget() && o->parent)
+      {
+        if (!changed) {
+          changed = 1;
+          undo_checkpoint();
+        }
+        Fl_Widget *w = ((Fl_Widget_Type *)o)->o;
+        Fl_Widget *p = ((Fl_Widget_Type *)o->parent)->o;
+        int center2;
+
+        if (w->window() == p) center2 = p->h();
+        else center2 = 2*p->y()+p->h();
+
+        Fl_Type::allow_layout++;
+        w->resize(w->x(), (center2-w->h())/2, w->w(), w->h());
+        Fl_Type::allow_layout--;
+        set_modflag(1);
+        w->redraw();
+        if (w->window()) w->window()->redraw();
+      }
+    break;
+  }
+  if (changed)
+    set_modflag(1);
+}
diff --git a/fluid/app/align_widget.h b/fluid/app/align_widget.h
new file mode 100644
index 000000000..f04372215
--- /dev/null
+++ b/fluid/app/align_widget.h
@@ -0,0 +1,24 @@
+//
+// FLUID main entry for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2021 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#ifndef _FLUID_ALIGN_WIDGET_H
+#define _FLUID_ALIGN_WIDGET_H
+
+class Fl_Widget;
+
+void align_widget_cb(Fl_Widget *, long);
+
+#endif // _FLUID_ALIGN_WIDGET_H
diff --git a/fluid/app/fluid.cxx b/fluid/app/fluid.cxx
new file mode 100644
index 000000000..e9d473fb2
--- /dev/null
+++ b/fluid/app/fluid.cxx
@@ -0,0 +1,2339 @@
+//
+// FLUID main entry for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2025 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#include "app/fluid.h"
+
+#include "app/mergeback.h"
+#include "app/undo.h"
+#include "io/file.h"
+#include "io/code.h"
+#include "nodes/Fl_Type.h"
+#include "nodes/Fl_Function_Type.h"
+#include "nodes/Fl_Group_Type.h"
+#include "nodes/Fl_Window_Type.h"
+#include "nodes/factory.h"
+#include "panels/settings_panel.h"
+#include "panels/function_panel.h"
+#include "panels/codeview_panel.h"
+#include "panels/template_panel.h"
+#include "panels/about_panel.h"
+#include "rsrcs/pixmaps.h"
+#include "app/shell_command.h"
+#include "tools/autodoc.h"
+#include "widgets/widget_browser.h"
+
+#include <FL/Fl.H>
+#ifdef __APPLE__
+#include <FL/platform.H> // for fl_open_callback
+#endif
+#include <FL/Fl_Help_Dialog.H>
+#include <FL/Fl_Menu_Bar.H>
+#include <FL/Fl_PNG_Image.H>
+#include <FL/Fl_Native_File_Chooser.H>
+#include <FL/Fl_Printer.H>
+#include <FL/fl_string_functions.h>
+#include <locale.h>     // setlocale()..
+#include "../src/flstring.h"
+
+extern "C"
+{
+#if defined(HAVE_LIBPNG) && defined(HAVE_LIBZ)
+#  include <zlib.h>
+#  ifdef HAVE_PNG_H
+#    include <png.h>
+#  else
+#    include <libpng/png.h>
+#  endif // HAVE_PNG_H
+#endif // HAVE_LIBPNG && HAVE_LIBZ
+}
+
+/// \defgroup globals Fluid Global Variables, Functions and Callbacks
+/// \{
+
+//
+// Globals..
+//
+
+/// FLUID-wide help dialog.
+static Fl_Help_Dialog *help_dialog = NULL;
+
+/// Main app window menu bar.
+Fl_Menu_Bar *main_menubar = NULL;
+
+/// Main app window.
+Fl_Window *main_window;
+
+/// Fluid application preferences, always accessible, will be flushed when app closes.
+Fl_Preferences fluid_prefs(Fl_Preferences::USER_L, "fltk.org", "fluid");
+
+/// Show guides in the design window when positioning widgets, saved in app preferences.
+int show_guides = 1;
+
+/// Show areas of restricted use in overlay plane.
+/// Restricted areas are widget that overlap each other, widgets that are outside
+/// of their parent's bounds (except children of Scroll groups), and areas
+/// within an Fl_Tile that are not covered by children.
+int show_restricted = 1;
+
+/// Show a ghosted outline for groups that have very little contrast.
+/// This makes groups with NO_BOX or FLAT_BOX better editable.
+int show_ghosted_outline = 1;
+
+/// Show widget comments in the browser, saved in app preferences.
+int show_comments = 1;
+
+/// Use external editor for editing Fl_Code_Type, saved in app preferences.
+int G_use_external_editor = 0;
+
+/// Debugging help for external Fl_Code_Type editor.
+int G_debug = 0;
+
+/// Run this command to load an Fl_Code_Type into an external editor, save in app preferences.
+char G_external_editor_command[512];
+
+
+// File history info...
+
+/// Stores the absolute filename of the last 10 design files, saved in app preferences.
+char absolute_history[10][FL_PATH_MAX];
+
+/// This list of filenames is computed from \c absolute_history and displayed in the main menu.
+char relative_history[10][FL_PATH_MAX];
+
+/// Menuitem to save a .fl design file, will be deactivated if the design is unchanged.
+Fl_Menu_Item *save_item = NULL;
+
+/// First Menuitem that shows the .fl design file history.
+Fl_Menu_Item *history_item = NULL;
+
+/// Menuitem to show or hide the widget bin, label will change if bin is visible.
+Fl_Menu_Item *widgetbin_item = NULL;
+
+/// Menuitem to show or hide the code view, label will change if view is visible.
+Fl_Menu_Item *codeview_item = NULL;
+
+/// Menuitem to show or hide the editing overlay, label will change if overlay visibility changes.
+Fl_Menu_Item *overlay_item = NULL;
+
+/// Menuitem to show or hide the editing guides, label will change if overlay visibility changes.
+Fl_Menu_Item *guides_item = NULL;
+
+/// Menuitem to show or hide the restricted area overlys, label will change if overlay visibility changes.
+Fl_Menu_Item *restricted_item = NULL;
+
+////////////////////////////////////////////////////////////////
+
+/// Filename of the current .fl project file
+static const char *filename = NULL;
+
+/// Set if the current design has been modified compared to the associated .fl design file.
+int modflag = 0;
+
+/// Set if the code files are older than the current design.
+int modflag_c = 0;
+
+/// Application work directory, stored here when temporarily changing to the source code directory.
+/// \see goto_source_dir()
+static std::string app_work_dir;
+
+/// Used as a counter to set the .fl project dir as the current directory.
+/// \see enter_project_dir(), leave_project_dir()
+static char in_project_dir = 0;
+
+/// Set, if Fluid was started with the command line argument -u
+int update_file = 0;            // fluid -u
+
+/// Set, if Fluid was started with the command line argument -c
+int compile_file = 0;           // fluid -c
+
+/// Set, if Fluid was started with the command line argument -cs
+int compile_strings = 0;        // fluid -cs
+
+/// Set, if Fluid was started with the command line argument -v
+int show_version = 0;        // fluid -v
+
+/// Set, if Fluid runs in batch mode, and no user interface is activated.
+int batch_mode = 0;             // if set (-c, -u) don't open display
+
+/// command line arguments that overrides the generate code file extension or name
+std::string g_code_filename_arg;
+
+/// command line arguments that overrides the generate header file extension or name
+std::string g_header_filename_arg;
+
+/// current directory path at application launch
+std::string g_launch_path;
+
+/// if set, generate images for automatic documentation in this directory
+std::string g_autodoc_path;
+
+/// path to store temporary files during app run
+/// \see tmpdir_create_called
+std::string tmpdir_path;
+
+/// true if the temporary file path was already created
+/// \see tmpdir_path
+bool tmpdir_create_called = false;
+
+
+/// Offset in pixels when adding widgets from an .fl file.
+int pasteoffset = 0;
+
+/// Paste offset incrementing at every paste command.
+static int ipasteoffset = 0;
+
+// ---- project settings
+
+/// The current project, possibly a new, empty roject
+Fluid_Project g_project;
+
+/**
+ Initialize a new project.
+ */
+Fluid_Project::Fluid_Project() :
+  i18n_type(FD_I18N_NONE),
+  include_H_from_C(1),
+  use_FL_COMMAND(0),
+  utf8_in_src(0),
+  avoid_early_includes(0),
+  header_file_set(0),
+  code_file_set(0),
+  write_mergeback_data(0),
+  header_file_name(".h"),
+  code_file_name(".cxx")
+{ }
+
+/**
+ Clear all project resources.
+ Not implemented.
+ */
+Fluid_Project::~Fluid_Project() {
+}
+
+/**
+ Reset all project setting to create a new empty project.
+ */
+void Fluid_Project::reset() {
+  ::delete_all();
+  i18n_type = FD_I18N_NONE;
+
+  i18n_gnu_include = "<libintl.h>";
+  i18n_gnu_conditional = "";
+  i18n_gnu_function = "gettext";
+  i18n_gnu_static_function = "gettext_noop";
+
+  i18n_pos_include = "<nl_types.h>";
+  i18n_pos_conditional = "";
+  i18n_pos_file = "";
+  i18n_pos_set = "1";
+
+  include_H_from_C = 1;
+  use_FL_COMMAND = 0;
+  utf8_in_src = 0;
+  avoid_early_includes = 0;
+  header_file_set = 0;
+  code_file_set = 0;
+  header_file_name = ".h";
+  code_file_name = ".cxx";
+  write_mergeback_data = 0;
+}
+
+/**
+ Tell the project and i18n tab of the settings dialog to refresh themselves.
+ */
+void Fluid_Project::update_settings_dialog() {
+  if (settings_window) {
+    w_settings_project_tab->do_callback(w_settings_project_tab, LOAD);
+    w_settings_i18n_tab->do_callback(w_settings_i18n_tab, LOAD);
+  }
+}
+
+/**
+ Make sure that a path name ends with a forward slash.
+ \param[in] str directory or path name
+ \return a new string, ending with a '/'
+ */
+static std::string end_with_slash(const std::string &str) {
+  char last = str[str.size()-1];
+  if (last !='/' && last != '\\')
+    return str + "/";
+  else
+    return str;
+}
+
+/**
+ Generate a path to a directory for temporary data storage.
+ The path is stored in g_tmpdir.
+ */
+static void create_tmpdir() {
+  if (tmpdir_create_called)
+    return;
+  tmpdir_create_called = true;
+
+  char buf[128];
+#if _WIN32
+  // The usual temp file locations on Windows are
+  //    %system%\Windows\Temp
+  //    %userprofiles%\AppData\Local
+  // usually resolving into
+  //    C:/Windows/Temp/
+  //    C:\Users\<username>\AppData\Local\Temp
+  fl_snprintf(buf, sizeof(buf)-1, "fluid-%d/", (long)GetCurrentProcessId());
+  std::string name = buf;
+  wchar_t tempdirW[FL_PATH_MAX+1];
+  char tempdir[FL_PATH_MAX+1];
+  unsigned len = GetTempPathW(FL_PATH_MAX, tempdirW);
+  if (len == 0) {
+    strcpy(tempdir, "c:/windows/temp/");
+  } else {
+    unsigned wn = fl_utf8fromwc(tempdir, FL_PATH_MAX, tempdirW, len);
+    tempdir[wn] = 0;
+  }
+  std::string path = tempdir;
+  end_with_slash(path);
+  path += name;
+  fl_make_path(path.c_str());
+  if (fl_access(path.c_str(), 6) == 0) tmpdir_path = path;
+#else
+  fl_snprintf(buf, sizeof(buf)-1, "fluid-%d/", getpid());
+  std::string name = buf;
+  std::string path = fl_getenv("TMPDIR");
+  if (!path.empty()) {
+    end_with_slash(path);
+    path += name;
+    fl_make_path(path.c_str());
+    if (fl_access(path.c_str(), 6) == 0) tmpdir_path = path;
+  }
+  if (tmpdir_path.empty()) {
+    path = std::string("/tmp/") + name;
+    fl_make_path(path.c_str());
+    if (fl_access(path.c_str(), 6) == 0) tmpdir_path = path;
+  }
+#endif
+  if (tmpdir_path.empty()) {
+    char pbuf[FL_PATH_MAX+1];
+    fluid_prefs.get_userdata_path(pbuf, FL_PATH_MAX);
+    path = std::string(pbuf);
+    end_with_slash(path);
+    path += name;
+    fl_make_path(path.c_str());
+    if (fl_access(path.c_str(), 6) == 0) tmpdir_path = path;
+  }
+  if (tmpdir_path.empty()) {
+    if (batch_mode) {
+      fprintf(stderr, "ERROR: Can't create directory for temporary data storage.\n");
+    } else {
+      fl_alert("Can't create directory for temporary data storage.");
+    }
+  }
+}
+
+/**
+ Delete the temporary directory that was created in set_tmpdir.
+ */
+static void delete_tmpdir() {
+  // was a temporary directory created
+  if (!tmpdir_create_called)
+    return;
+  if (tmpdir_path.empty())
+    return;
+
+  // first delete all files that may still be left in the temp directory
+  struct dirent **de;
+  int n_de = fl_filename_list(tmpdir_path.c_str(), &de);
+  if (n_de >= 0) {
+    for (int i=0; i<n_de; i++) {
+      std::string path = tmpdir_path + de[i]->d_name;
+      fl_unlink(path.c_str());
+    }
+    fl_filename_free_list(&de, n_de);
+  }
+
+  // then delete the directory itself
+  if (fl_rmdir(tmpdir_path.c_str()) < 0) {
+    if (batch_mode) {
+      fprintf(stderr, "WARNING: Can't delete tmpdir '%s': %s", tmpdir_path.c_str(), strerror(errno));
+    } else {
+      fl_alert("WARNING: Can't delete tmpdir '%s': %s", tmpdir_path.c_str(), strerror(errno));
+    }
+  }
+}
+
+/**
+ Return the path to a temporary directory for this instance of FLUID.
+ Fluid will do its best to clear and delete this directory when exiting.
+ \return the path to the temporary directory, ending in a '/', or and empty
+      string if no directory could be created.
+ */
+const std::string &get_tmpdir() {
+  if (!tmpdir_create_called)
+    create_tmpdir();
+  return tmpdir_path;
+}
+
+/**
+ Give the user the opportunity to save a project before clearing it.
+
+ If the project has unsaved changes, this function pops up a dialog, that
+ allows the user to save the project, continue without saving the project,
+ or to cancel the operation.
+
+ If the user chooses to save, and no filename was set, a file dialog allows
+ the user to pick a name and location, or to cancel the operation.
+
+ \return false if the user aborted the operation and the calling function
+ should abort as well
+ */
+bool confirm_project_clear() {
+  if (modflag == 0) return true;
+  switch (fl_choice("This project has unsaved changes. Do you want to save\n"
+                    "the project file before proceeding?",
+                    "Cancel", "Save", "Don't Save"))
+  {
+    case 0 : /* Cancel */
+      return false;
+    case 1 : /* Save */
+      save_cb(NULL, NULL);
+      if (modflag) return false;  // user canceled the "Save As" dialog
+  }
+  return true;
+}
+
+// ----
+
+extern Fl_Window *the_panel;
+
+/**
+ Ensure that text widgets in the widget panel propagates apply current changes.
+ By temporarily clearing the text focus, all text widgets with changed text
+ will unfocus and call their respective callbacks, propagating those changes to
+ their data set.
+ */
+void flush_text_widgets() {
+  if (Fl::focus() && (Fl::focus()->top_window() == the_panel)) {
+    Fl_Widget *old_focus = Fl::focus();
+    Fl::focus(NULL); // trigger callback of the widget that is losing focus
+    Fl::focus(old_focus);
+  }
+}
+
+// ----
+
+/**
+ Change the current working directory to the .fl project directory.
+
+ Every call to enter_project_dir() must have a corresponding leave_project_dir()
+ call. Enter and leave calls can be nested.
+
+ The first call to enter_project_dir() remembers the original directory, usually
+ the launch directory of the application. Nested calls will increment a nesting
+ counter. When the nesting counter is back to 0, leave_project_dir() will return
+ to the original directory.
+
+ The global variable 'filename' must be set to the current project file with
+ absolute or relative path information.
+
+ \see leave_project_dir(), pwd, in_project_dir
+ */
+void enter_project_dir() {
+  if (in_project_dir<0) {
+    fprintf(stderr, "** Fluid internal error: enter_project_dir() calls unmatched\n");
+    return;
+  }
+  in_project_dir++;
+  // check if we are already in the project dir and do nothing if so
+  if (in_project_dir>1) return;
+  // check if there is an active project, and do nothing if there is none
+  if (!filename || !*filename) {
+    fprintf(stderr, "** Fluid internal error: enter_project_dir() no filename set\n");
+    return;
+  }
+  // store the current working directory for later
+  app_work_dir = fl_getcwd();
+  // set the current directory to the path of our .fl file
+  std::string project_path = fl_filename_path(fl_filename_absolute(filename));
+  if (fl_chdir(project_path.c_str()) == -1) {
+    fprintf(stderr, "** Fluid internal error: enter_project_dir() can't chdir to %s: %s\n",
+            project_path.c_str(), strerror(errno));
+    return;
+  }
+  //fprintf(stderr, "chdir from %s to %s\n", app_work_dir.c_str(), fl_getcwd().c_str());
+}
+
+/**
+ Change the current working directory to the previous directory.
+ \see enter_project_dir(), pwd, in_project_dir
+ */
+void leave_project_dir() {
+  if (in_project_dir == 0) {
+    fprintf(stderr, "** Fluid internal error: leave_project_dir() calls unmatched\n");
+    return;
+  }
+  in_project_dir--;
+  // still nested, stay in the project directory
+  if (in_project_dir > 0) return;
+  // no longer nested, return to the original, usually the application working directory
+  if (fl_chdir(app_work_dir.c_str()) < 0) {
+    fprintf(stderr, "** Fluid internal error: leave_project_dir() can't chdir back to %s : %s\n",
+            app_work_dir.c_str(), strerror(errno));
+  }
+}
+
+/**
+ Position the given window window based on entries in the app preferences.
+ Customisable by user; feature can be switched off.
+ The window is not shown or hidden by this function, but a value is returned
+ to indicate the state to the caller.
+ \param[in] w position this window
+ \param[in] prefsName name of the preferences item that stores the window settings
+ \param[in] Visible default value if window is hidden or shown
+ \param[in] X, Y, W, H default size and position if nothing is specified in the preferences
+ \return 1 if the caller should make the window visible, 0 if hidden.
+ */
+char position_window(Fl_Window *w, const char *prefsName, int Visible, int X, int Y, int W, int H) {
+  Fl_Preferences pos(fluid_prefs, prefsName);
+  if (prevpos_button->value()) {
+    pos.get("x", X, X);
+    pos.get("y", Y, Y);
+    if ( W!=0 ) {
+      pos.get("w", W, W);
+      pos.get("h", H, H);
+      w->resize( X, Y, W, H );
+    }
+    else
+      w->position( X, Y );
+  }
+  pos.get("visible", Visible, Visible);
+  return Visible;
+}
+
+/**
+ Save the position and visibility state of a window to the app preferences.
+ \param[in] w save this window data
+ \param[in] prefsName name of the preferences item that stores the window settings
+ */
+void save_position(Fl_Window *w, const char *prefsName) {
+  Fl_Preferences pos(fluid_prefs, prefsName);
+  pos.set("x", w->x());
+  pos.set("y", w->y());
+  pos.set("w", w->w());
+  pos.set("h", w->h());
+  pos.set("visible", (int)(w->shown() && w->visible()));
+}
+
+/**
+ Return the path and filename of a temporary file for cut or duplicated data.
+ \param[in] which 0 gets the cut/copy/paste buffer, 1 gets the duplication buffer
+ \return a pointer to a string in a static buffer
+ */
+static char* cutfname(int which = 0) {
+  static char name[2][FL_PATH_MAX];
+  static char beenhere = 0;
+
+  if (!beenhere) {
+    beenhere = 1;
+    fluid_prefs.getUserdataPath(name[0], sizeof(name[0]));
+    strlcat(name[0], "cut_buffer", sizeof(name[0]));
+    fluid_prefs.getUserdataPath(name[1], sizeof(name[1]));
+    strlcat(name[1], "dup_buffer", sizeof(name[1]));
+  }
+
+  return name[which];
+}
+
+/**
+ Timer to watch for external editor modifications.
+
+ If one or more external editors open, check if their files were modified.
+ If so: reload to ram, update size/mtime records, and change fluid's
+ 'modified' state.
+ */
+static void external_editor_timer(void*) {
+  int editors_open = ExternalCodeEditor::editors_open();
+  if ( G_debug ) printf("--- TIMER --- External editors open=%d\n", editors_open);
+  if ( editors_open > 0 ) {
+    // Walk tree looking for files modified by external editors.
+    int modified = 0;
+    for (Fl_Type *p = Fl_Type::first; p; p = p->next) {
+      if ( p->is_a(ID_Code) ) {
+        Fl_Code_Type *code = (Fl_Code_Type*)p;
+        // Code changed by external editor?
+        if ( code->handle_editor_changes() ) {  // updates ram, file size/mtime
+          modified++;
+        }
+        if ( code->is_editing() ) {             // editor open?
+          code->reap_editor();                  // Try to reap; maybe it recently closed
+        }
+      }
+    }
+    if ( modified ) set_modflag(1);
+  }
+  // Repeat timeout if editors still open
+  //    The ExternalCodeEditor class handles start/stopping timer, we just
+  //    repeat_timeout() if it's already on. NOTE: above code may have reaped
+  //    only open editor, which would disable further timeouts. So *recheck*
+  //    if editors still open, to ensure we don't accidentally re-enable them.
+  //
+  if ( ExternalCodeEditor::editors_open() ) {
+    Fl::repeat_timeout(2.0, external_editor_timer);
+  }
+}
+
+/**
+ Save the current design to the file given by \c filename.
+ If automatic, this overwrites an existing file. If interactive, if will
+ verify with the user.
+ \param[in] v if v is not NULL, or no filename is set, open a filechooser.
+ */
+void save_cb(Fl_Widget *, void *v) {
+  flush_text_widgets();
+  Fl_Native_File_Chooser fnfc;
+  const char *c = filename;
+  if (v || !c || !*c) {
+    fnfc.title("Save To:");
+    fnfc.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);
+    fnfc.filter("FLUID Files\t*.f[ld]");
+    if (fnfc.show() != 0) return;
+    c = fnfc.filename();
+    if (!fl_access(c, 0)) {
+      std::string basename = fl_filename_name(std::string(c));
+      if (fl_choice("The file \"%s\" already exists.\n"
+                    "Do you want to replace it?", "Cancel",
+                    "Replace", NULL, basename.c_str()) == 0) return;
+    }
+
+    if (v != (void *)2) set_filename(c);
+  }
+  if (!write_file(c)) {
+    fl_alert("Error writing %s: %s", c, strerror(errno));
+    return;
+  }
+
+  if (v != (void *)2) {
+    set_modflag(0, 1);
+    undo_save = undo_current;
+  }
+}
+
+/**
+ Save a design template.
+ \todo We should document the concept of templates.
+ */
+void save_template_cb(Fl_Widget *, void *) {
+  // Setup the template panel...
+  if (!template_panel) make_template_panel();
+
+  template_clear();
+  template_browser->add("New Template");
+  template_load();
+
+  template_name->show();
+  template_name->value("");
+
+  template_instance->hide();
+
+  template_delete->show();
+  template_delete->deactivate();
+
+  template_submit->label("Save");
+  template_submit->deactivate();
+
+  template_panel->label("Save Template");
+
+  // Show the panel and wait for the user to do something...
+  template_panel->show();
+  while (template_panel->shown()) Fl::wait();
+
+  // Get the template name, return if it is empty...
+  const char *c = template_name->value();
+  if (!c || !*c) return;
+
+  // Convert template name to filename_with_underscores
+  char savename[FL_PATH_MAX], *saveptr;
+  strlcpy(savename, c, sizeof(savename));
+  for (saveptr = savename; *saveptr; saveptr ++) {
+    if (isspace(*saveptr)) *saveptr = '_';
+  }
+
+  // Find the templates directory...
+  char filename[FL_PATH_MAX];
+  fluid_prefs.getUserdataPath(filename, sizeof(filename));
+
+  strlcat(filename, "templates", sizeof(filename));
+  if (fl_access(filename, 0)) fl_make_path(filename);
+
+  strlcat(filename, "/", sizeof(filename));
+  strlcat(filename, savename, sizeof(filename));
+
+  char *ext = filename + strlen(filename);
+  if (ext >= (filename + sizeof(filename) - 5)) {
+    fl_alert("The template name \"%s\" is too long!", c);
+    return;
+  }
+
+  // Save the .fl file...
+  strcpy(ext, ".fl");
+
+  if (!fl_access(filename, 0)) {
+    if (fl_choice("The template \"%s\" already exists.\n"
+                  "Do you want to replace it?", "Cancel",
+                  "Replace", NULL, c) == 0) return;
+  }
+
+  if (!write_file(filename)) {
+    fl_alert("Error writing %s: %s", filename, strerror(errno));
+    return;
+  }
+
+#if defined(HAVE_LIBPNG) && defined(HAVE_LIBZ)
+  // Get the screenshot, if any...
+  Fl_Type *t;
+
+  for (t = Fl_Type::first; t; t = t->next) {
+    // Find the first window...
+    if (t->is_a(ID_Window)) break;
+  }
+
+  if (!t) return;
+
+  // Grab a screenshot...
+  Fl_Window_Type *wt = (Fl_Window_Type *)t;
+  uchar *pixels;
+  int w, h;
+
+  if ((pixels = wt->read_image(w, h)) == NULL) return;
+
+  // Save to a PNG file...
+  strcpy(ext, ".png");
+
+  errno = 0;
+  if (fl_write_png(filename, pixels, w, h, 3) != 0) {
+    delete[] pixels;
+    fl_alert("Error writing %s: %s", filename, strerror(errno));
+    return;
+  }
+
+#  if 0 // The original PPM output code...
+  strcpy(ext, ".ppm");
+  fp = fl_fopen(filename, "wb");
+  fprintf(fp, "P6\n%d %d 255\n", w, h);
+  fwrite(pixels, w * h, 3, fp);
+  fclose(fp);
+#  endif // 0
+
+  delete[] pixels;
+#endif // HAVE_LIBPNG && HAVE_LIBZ
+}
+
+/**
+ Reload the file set by \c filename, replacing the current design.
+ If the design was modified, a dialog will ask for confirmation.
+ */
+void revert_cb(Fl_Widget *,void *) {
+  if (modflag) {
+    if (!fl_choice("This user interface has been changed. Really revert?",
+                   "Cancel", "Revert", NULL)) return;
+  }
+  undo_suspend();
+  if (!read_file(filename, 0)) {
+    undo_resume();
+    widget_browser->rebuild();
+    g_project.update_settings_dialog();
+    fl_message("Can't read %s: %s", filename, strerror(errno));
+    return;
+  }
+  widget_browser->rebuild();
+  undo_resume();
+  set_modflag(0, 0);
+  undo_clear();
+  g_project.update_settings_dialog();
+}
+
+/**
+ Exit Fluid; we hope you had a nice experience.
+ If the design was modified, a dialog will ask for confirmation.
+ */
+void exit_cb(Fl_Widget *,void *) {
+  if (shell_command_running()) {
+    int choice = fl_choice("Previous shell command still running!",
+                           "Cancel",
+                           "Exit",
+                           NULL);
+    if (choice == 0) { // user chose to cancel the exit operation
+      return;
+    }
+  }
+
+  flush_text_widgets();
+
+  // verify user intention
+  if (confirm_project_clear() == false)
+    return;
+
+  // Stop any external editor update timers
+  ExternalCodeEditor::stop_update_timer();
+
+  save_position(main_window,"main_window_pos");
+
+  if (widgetbin_panel) {
+    save_position(widgetbin_panel,"widgetbin_pos");
+    delete widgetbin_panel;
+  }
+  if (codeview_panel) {
+    Fl_Preferences svp(fluid_prefs, "codeview");
+    svp.set("autorefresh", cv_autorefresh->value());
+    svp.set("autoposition", cv_autoposition->value());
+    svp.set("tab", cv_tab->find(cv_tab->value()));
+    svp.set("code_choice", cv_code_choice);
+    save_position(codeview_panel,"codeview_pos");
+    delete codeview_panel;
+    codeview_panel = 0;
+  }
+  if (shell_run_window) {
+    save_position(shell_run_window,"shell_run_Window_pos");
+  }
+
+  if (about_panel)
+    delete about_panel;
+  if (help_dialog)
+    delete help_dialog;
+
+  if (g_shell_config)
+    g_shell_config->write(fluid_prefs, FD_STORE_USER);
+  g_layout_list.write(fluid_prefs, FD_STORE_USER);
+
+  undo_clear();
+
+  // Destroy tree
+  //    Doing so causes dtors to automatically close all external editors
+  //    and cleans up editor tmp files. Then remove fluid tmpdir /last/.
+  g_project.reset();
+  ExternalCodeEditor::tmpdir_clear();
+  delete_tmpdir();
+
+  exit(0);
+}
+
+/**
+ Clear the current project and create a new, empty one.
+
+ If the current project was modified, FLUID will give the user the opportunity
+ to save the old project first.
+
+ \param[in] user_must_confirm if set, a confimation dialog is presented to the
+    user before resetting the project. Default is `true`.
+ \return false if the operation was canceled
+ */
+bool new_project(bool user_must_confirm) {
+  // verify user intention
+  if ((user_must_confirm) &&  (confirm_project_clear() == false))
+    return false;
+
+  // clear the current project
+  g_project.reset();
+  set_filename(NULL);
+  set_modflag(0, 0);
+  widget_browser->rebuild();
+  g_project.update_settings_dialog();
+
+  // all is clear to continue
+  return true;
+}
+
+/**
+ Open the template browser and load a new file from templates.
+
+ If the current project was modified, FLUID will give the user the opportunity
+ to save the old project first.
+
+ \return false if the operation was canceled or failed otherwise
+ */
+bool new_project_from_template() {
+  // clear the current project first
+  if (new_project() == false)
+    return false;
+
+  // Setup the template panel...
+  if (!template_panel) make_template_panel();
+
+  template_clear();
+  template_browser->add("Blank");
+  template_load();
+
+  template_name->hide();
+  template_name->value("");
+
+  template_instance->show();
+  template_instance->deactivate();
+  template_instance->value("");
+
+  template_delete->show();
+
+  template_submit->label("New");
+  template_submit->deactivate();
+
+  template_panel->label("New");
+
+  //if ( template_browser->size() == 1 ) { // only one item?
+  template_browser->value(1);          // select it
+  template_browser->do_callback();
+  //}
+
+  // Show the panel and wait for the user to do something...
+  template_panel->show();
+  while (template_panel->shown()) Fl::wait();
+
+  // See if the user chose anything...
+  int item = template_browser->value();
+  if (item < 1) return false;
+
+  // Load the template, if any...
+  const char *tname = (const char *)template_browser->data(item);
+
+  if (tname) {
+    // Grab the instance name...
+    const char *iname = template_instance->value();
+
+    if (iname && *iname) {
+      // Copy the template to a temp file, then read it in...
+      char line[1024], *ptr, *next;
+      FILE *infile, *outfile;
+
+      if ((infile = fl_fopen(tname, "rb")) == NULL) {
+        fl_alert("Error reading template file \"%s\":\n%s", tname,
+                 strerror(errno));
+        set_modflag(0);
+        undo_clear();
+        return false;
+      }
+
+      if ((outfile = fl_fopen(cutfname(1), "wb")) == NULL) {
+        fl_alert("Error writing buffer file \"%s\":\n%s", cutfname(1),
+                 strerror(errno));
+        fclose(infile);
+        set_modflag(0);
+        undo_clear();
+        return false;
+      }
+
+      while (fgets(line, sizeof(line), infile)) {
+        // Replace @INSTANCE@ with the instance name...
+        for (ptr = line; (next = strstr(ptr, "@INSTANCE@")) != NULL; ptr = next + 10) {
+          fwrite(ptr, next - ptr, 1, outfile);
+          fputs(iname, outfile);
+        }
+
+        fputs(ptr, outfile);
+      }
+
+      fclose(infile);
+      fclose(outfile);
+
+      undo_suspend();
+      read_file(cutfname(1), 0);
+      fl_unlink(cutfname(1));
+      undo_resume();
+    } else {
+      // No instance name, so read the template without replacements...
+      undo_suspend();
+      read_file(tname, 0);
+      undo_resume();
+    }
+  }
+
+  widget_browser->rebuild();
+  g_project.update_settings_dialog();
+  set_modflag(0);
+  undo_clear();
+
+  return true;
+}
+
+/**
+ Open a native file chooser to allow choosing a project file for reading.
+
+ Path and filename are preset with the current project filename, if there
+ is one.
+
+ \param title a text describing the action after selecting a file (load, merge, ...)
+ \return the file path and name, or an empty string if the operation was canceled
+ */
+std::string open_project_filechooser(const std::string &title) {
+  Fl_Native_File_Chooser dialog;
+  dialog.title(title.c_str());
+  dialog.type(Fl_Native_File_Chooser::BROWSE_FILE);
+  dialog.filter("FLUID Files\t*.f[ld]\n");
+  if (filename) {
+    std::string current_project_file = filename;
+    dialog.directory(fl_filename_path(current_project_file).c_str());
+    dialog.preset_file(fl_filename_name(current_project_file).c_str());
+  }
+  if (dialog.show() != 0)
+    return std::string();
+  return std::string(dialog.filename());
+}
+
+/**
+ Load a project from the give file name and path.
+
+ The project file is inserted at the currently selected type.
+
+ If no filename is given, FLUID will open a file chooser dialog.
+
+ \param[in] filename_arg path and name of the new project file
+ \return false if the operation failed
+ */
+bool merge_project_file(const std::string &filename_arg) {
+  bool is_a_merge = (Fl_Type::first != NULL);
+  std::string title = is_a_merge ? "Merge Project File" : "Open Project File";
+
+  // ask for a filename if none was given
+  std::string new_filename = filename_arg;
+  if (new_filename.empty()) {
+    new_filename = open_project_filechooser(title);
+    if (new_filename.empty()) {
+      return false;
+    }
+  }
+
+  const char *c = new_filename.c_str();
+  const char *oldfilename = filename;
+  filename    = NULL;
+  set_filename(c);
+  if (is_a_merge) undo_checkpoint();
+  undo_suspend();
+  if (!read_file(c, is_a_merge)) {
+    undo_resume();
+    widget_browser->rebuild();
+    g_project.update_settings_dialog();
+    fl_message("Can't read %s: %s", c, strerror(errno));
+    free((void *)filename);
+    filename = oldfilename;
+    if (main_window) set_modflag(modflag);
+    return false;
+  }
+  undo_resume();
+  widget_browser->rebuild();
+  if (is_a_merge) {
+    // Inserting a file; restore the original filename...
+    set_filename(oldfilename);
+    set_modflag(1);
+  } else {
+    // Loaded a file; free the old filename...
+    set_modflag(0, 0);
+    undo_clear();
+  }
+  if (oldfilename) free((void *)oldfilename);
+  return true;
+}
+
+/**
+ Open a file chooser and load an exiting project file.
+
+ If the current project was modified, FLUID will give the user the opportunity
+ to save the old project first.
+
+ If no filename is given, FLUID will open a file chooser dialog.
+
+ \param[in] filename_arg load from this file, or show file chooser if empty
+ \return false if the operation was canceled or failed otherwise
+ */
+bool open_project_file(const std::string &filename_arg) {
+  // verify user intention
+  if (confirm_project_clear() == false)
+    return false;
+
+  // ask for a filename if none was given
+  std::string new_filename = filename_arg;
+  if (new_filename.empty()) {
+    new_filename = open_project_filechooser("Open Project File");
+    if (new_filename.empty()) {
+      return false;
+    }
+  }
+
+  // clear the project and merge a file by the given name
+  new_project(false);
+  return merge_project_file(new_filename);
+}
+
+#ifdef __APPLE__
+/**
+ Handle app launch with an associated filename (macOS only).
+ Should there be a modified design already, Fluid asks for user confirmation.
+ \param[in] c the filename of the new design
+ */
+void apple_open_cb(const char *c) {
+  open_project_file(std::string(c));
+}
+#endif // __APPLE__
+
+/**
+ Get the absolute path of the project file, for example `/Users/matt/dev/`.
+ \return the path ending in '/'
+ */
+std::string Fluid_Project::projectfile_path() const {
+  return end_with_slash(fl_filename_absolute(fl_filename_path(filename), g_launch_path));
+}
+
+/**
+ Get the project file name including extension, for example `test.fl`.
+ \return the file name without path
+ */
+std::string Fluid_Project::projectfile_name() const {
+  return fl_filename_name(filename);
+}
+
+/**
+ Get the absolute path of the generated C++ code file, for example `/Users/matt/dev/src/`.
+ \return the path ending in '/'
+ */
+std::string Fluid_Project::codefile_path() const {
+  std::string path = fl_filename_path(code_file_name);
+  if (batch_mode)
+    return end_with_slash(fl_filename_absolute(path, g_launch_path));
+  else
+    return end_with_slash(fl_filename_absolute(path, projectfile_path()));
+}
+
+/**
+ Get the generated C++ code file name including extension, for example `test.cxx`.
+ \return the file name without path
+ */
+std::string Fluid_Project::codefile_name() const {
+  std::string name = fl_filename_name(code_file_name);
+  if (name.empty()) {
+    return fl_filename_setext(fl_filename_name(filename), ".cxx");
+  } else if (name[0] == '.') {
+    return fl_filename_setext(fl_filename_name(filename), code_file_name);
+  } else {
+    return name;
+  }
+}
+
+/**
+ Get the absolute path of the generated C++ header file, for example `/Users/matt/dev/src/`.
+ \return the path ending in '/'
+ */
+std::string Fluid_Project::headerfile_path() const {
+  std::string path = fl_filename_path(header_file_name);
+  if (batch_mode)
+    return end_with_slash(fl_filename_absolute(path, g_launch_path));
+  else
+    return end_with_slash(fl_filename_absolute(path, projectfile_path()));
+}
+
+/**
+ Get the generated C++ header file name including extension, for example `test.cxx`.
+ \return the file name without path
+ */
+std::string Fluid_Project::headerfile_name() const {
+  std::string name = fl_filename_name(header_file_name);
+  if (name.empty()) {
+    return fl_filename_setext(fl_filename_name(filename), ".h");
+  } else if (name[0] == '.') {
+    return fl_filename_setext(fl_filename_name(filename), header_file_name);
+  } else {
+    return name;
+  }
+}
+
+/**
+ Get the absolute path of the generated i18n strings file, for example `/Users/matt/dev/`.
+ Although it may be more useful to put the text file into the same directory
+ with the source and header file, historically, the text is always saved with
+ the project file in interactive mode, and in the FLUID launch directory in
+ batch mode.
+ \return the path ending in '/'
+ */
+std::string Fluid_Project::stringsfile_path() const {
+  if (batch_mode)
+    return g_launch_path;
+  else
+    return projectfile_path();
+}
+
+/**
+ Get the generated i18n text file name including extension, for example `test.po`.
+ \return the file name without path
+ */
+std::string Fluid_Project::stringsfile_name() const {
+  switch (i18n_type) {
+    default: return fl_filename_setext(fl_filename_name(filename), ".txt");
+    case FD_I18N_GNU: return fl_filename_setext(fl_filename_name(filename), ".po");
+    case FD_I18N_POSIX: return fl_filename_setext(fl_filename_name(filename), ".msg");
+  }
+}
+
+/**
+ Get the name of the project file without the filename extension.
+ \return the file name without path or extension
+ */
+std::string Fluid_Project::basename() const {
+  return fl_filename_setext(fl_filename_name(filename), "");
+}
+
+/**
+ Generate the C++ source and header filenames and write those files.
+
+ This function creates the source filename by setting the file
+ extension to \c code_file_name and a header filename
+ with the extension \c code_file_name which are both
+ settable by the user.
+
+ If the code filename has not been set yet, a "save file as" dialog will be
+ presented to the user.
+
+ In batch_mode, the function will either be silent, or, if opening or writing
+ the files fails, write an error message to \c stderr and exit with exit code 1.
+
+ In interactive mode, it will pop up an error message, or, if the user
+ hasn't disabled that, pop up a confirmation message.
+
+ \param[in] dont_show_completion_dialog don't show the completion dialog
+ \return 1 if the operation failed, 0 if it succeeded
+ */
+int write_code_files(bool dont_show_completion_dialog)
+{
+  // -- handle user interface issues
+  flush_text_widgets();
+  if (!filename) {
+    save_cb(0,0);
+    if (!filename) return 1;
+  }
+
+  // -- generate the file names with absolute paths
+  Fd_Code_Writer f;
+  std::string code_filename = g_project.codefile_path() + g_project.codefile_name();
+  std::string header_filename = g_project.headerfile_path() + g_project.headerfile_name();
+
+  // -- write the code and header files
+  if (!batch_mode) enter_project_dir();
+  int x = f.write_code(code_filename.c_str(), header_filename.c_str());
+  std::string code_filename_rel = fl_filename_relative(code_filename);
+  std::string header_filename_rel = fl_filename_relative(header_filename);
+  if (!batch_mode) leave_project_dir();
+
+  // -- print error message in batch mode or pop up an error or confirmation dialog box
+  if (batch_mode) {
+    if (!x) {
+      fprintf(stderr, "%s and %s: %s\n",
+              code_filename_rel.c_str(),
+              header_filename_rel.c_str(),
+              strerror(errno));
+      exit(1);
+    }
+  } else {
+    if (!x) {
+      fl_message("Can't write %s or %s: %s",
+                 code_filename_rel.c_str(),
+                 header_filename_rel.c_str(),
+                 strerror(errno));
+    } else {
+      set_modflag(-1, 0);
+      if (dont_show_completion_dialog==false && completion_button->value()) {
+        fl_message("Wrote %s and %s",
+                   code_filename_rel.c_str(),
+                   header_filename_rel.c_str());
+      }
+    }
+  }
+  return 0;
+}
+
+/**
+ Callback to write C++ code and header files.
+ */
+void write_cb(Fl_Widget *, void *) {
+    write_code_files();
+}
+
+#if 0
+// Matt: disabled
+/**
+ Merge the possibly modified content of code files back into the project.
+ */
+int mergeback_code_files()
+{
+  flush_text_widgets();
+  if (!filename) return 1;
+  if (!g_project.write_mergeback_data) {
+    fl_message("MergeBack is not enabled for this project.\n"
+               "Please enable MergeBack in the project settings\n"
+               "dialog and re-save the project file and the code.");
+    return 0;
+  }
+
+  std::string proj_filename = g_project.projectfile_path() + g_project.projectfile_name();
+  std::string code_filename;
+#if 1
+  if (!batch_mode) {
+    Fl_Preferences build_records(Fl_Preferences::USER_L, "fltk.org", "fluid-build");
+    Fl_Preferences path(build_records, proj_filename.c_str());
+    int i, n = proj_filename.size();
+    for (i=0; i<n; i++) if (proj_filename[i]=='\\') proj_filename[i] = '/';
+    preferences_get(path, "code", code_filename, "");
+  }
+#endif
+  if (code_filename.empty())
+    code_filename = g_project.codefile_path() + g_project.codefile_name();
+  if (!batch_mode) enter_project_dir();
+  int c = merge_back(code_filename, proj_filename, FD_MERGEBACK_INTERACTIVE);
+  if (!batch_mode) leave_project_dir();
+
+  if (c==0) fl_message("Comparing\n  \"%s\"\nto\n  \"%s\"\n\n"
+                       "MergeBack found no external modifications\n"
+                       "in the source code.",
+                       code_filename.c_str(), proj_filename.c_str());
+  if (c==-2) fl_message("No corresponding source code file found.");
+  return c;
+}
+
+void mergeback_cb(Fl_Widget *, void *) {
+  mergeback_code_files();
+}
+#endif
+
+/**
+ Write the strings that are used in i18n.
+ */
+void write_strings_cb(Fl_Widget *, void *) {
+  flush_text_widgets();
+  if (!filename) {
+    save_cb(0,0);
+    if (!filename) return;
+  }
+  std::string filename = g_project.stringsfile_path() + g_project.stringsfile_name();
+  int x = write_strings(filename);
+  if (batch_mode) {
+    if (x) {
+      fprintf(stderr, "%s : %s\n", filename.c_str(), strerror(errno));
+      exit(1);
+    }
+  } else {
+    if (x) {
+      fl_message("Can't write %s: %s", filename.c_str(), strerror(errno));
+    } else if (completion_button->value()) {
+      fl_message("Wrote %s", g_project.stringsfile_name().c_str());
+    }
+  }
+}
+
+/**
+ Show the editor for the \c current Fl_Type.
+ */
+void openwidget_cb(Fl_Widget *, void *) {
+  if (!Fl_Type::current) {
+    fl_message("Please select a widget");
+    return;
+  }
+  Fl_Type::current->open();
+}
+
+/**
+ User chose to copy the currently selected widgets.
+ */
+void copy_cb(Fl_Widget*, void*) {
+  flush_text_widgets();
+  if (!Fl_Type::current) {
+    fl_beep();
+    return;
+  }
+  flush_text_widgets();
+  ipasteoffset = 10;
+  if (!write_file(cutfname(),1)) {
+    fl_message("Can't write %s: %s", cutfname(), strerror(errno));
+    return;
+  }
+}
+
+/**
+ User chose to cut the currently selected widgets.
+ */
+void cut_cb(Fl_Widget *, void *) {
+  if (!Fl_Type::current) {
+    fl_beep();
+    return;
+  }
+  flush_text_widgets();
+  if (!write_file(cutfname(),1)) {
+    fl_message("Can't write %s: %s", cutfname(), strerror(errno));
+    return;
+  }
+  undo_checkpoint();
+  set_modflag(1);
+  ipasteoffset = 0;
+  Fl_Type *p = Fl_Type::current->parent;
+  while (p && p->selected) p = p->parent;
+  delete_all(1);
+  if (p) select_only(p);
+  widget_browser->rebuild();
+}
+
+/**
+ User chose to delete the currently selected widgets.
+ */
+void delete_cb(Fl_Widget *, void *) {
+  if (!Fl_Type::current) {
+    fl_beep();
+    return;
+  }
+  undo_checkpoint();
+  set_modflag(1);
+  ipasteoffset = 0;
+  Fl_Type *p = Fl_Type::current->parent;
+  while (p && p->selected) p = p->parent;
+  delete_all(1);
+  if (p) select_only(p);
+  widget_browser->rebuild();
+}
+
+/**
+ User chose to paste the widgets from the cut buffer.
+
+ This function will paste the widgets in the cut buffer after the currently
+ selected widget. If the currently selected widget is a group widget and
+ it is not folded, the new widgets will be added inside the group.
+ */
+void paste_cb(Fl_Widget*, void*) {
+  pasteoffset = ipasteoffset;
+  undo_checkpoint();
+  undo_suspend();
+  Strategy strategy = Strategy::FROM_FILE_AFTER_CURRENT;
+  if (Fl_Type::current && Fl_Type::current->can_have_children()) {
+    if (Fl_Type::current->folded_ == 0) {
+      // If the current widget is a group widget and it is not folded,
+      // add the new widgets inside the group.
+      strategy = Strategy::FROM_FILE_AS_LAST_CHILD;
+      // The following alternative also works quite nicely
+      //strategy = Strategy::FROM_FILE_AS_FIRST_CHILD;
+    }
+  }
+  if (!read_file(cutfname(), 1, strategy)) {
+    widget_browser->rebuild();
+    fl_message("Can't read %s: %s", cutfname(), strerror(errno));
+  }
+  undo_resume();
+  widget_browser->display(Fl_Type::current);
+  widget_browser->rebuild();
+  pasteoffset = 0;
+  ipasteoffset += 10;
+}
+
+/**
+ Duplicate the selected widgets.
+
+ This code is a bit complex because it needs to find the last selected
+ widget with the lowest level, so that the new widgets are inserted after
+ this one.
+ */
+void duplicate_cb(Fl_Widget*, void*) {
+  if (!Fl_Type::current) {
+    fl_beep();
+    return;
+  }
+
+  // flush the text widgets to make sure the user's changes are saved:
+  flush_text_widgets();
+
+  // find the last selected node with the lowest level:
+  int lowest_level = 9999;
+  Fl_Type *new_insert = NULL;
+  if (Fl_Type::current->selected) {
+    for (Fl_Type *t = Fl_Type::first; t; t = t->next) {
+      if (t->selected && (t->level <= lowest_level)) {
+        lowest_level = t->level;
+        new_insert = t;
+      }
+    }
+  }
+  if (new_insert)
+    Fl_Type::current = new_insert;
+
+  // write the selected widgets to a file:
+  if (!write_file(cutfname(1),1)) {
+    fl_message("Can't write %s: %s", cutfname(1), strerror(errno));
+    return;
+  }
+
+  // read the file and add the widgets after the current one:
+  pasteoffset  = 0;
+  undo_checkpoint();
+  undo_suspend();
+  if (!read_file(cutfname(1), 1, Strategy::FROM_FILE_AFTER_CURRENT)) {
+    fl_message("Can't read %s: %s", cutfname(1), strerror(errno));
+  }
+  fl_unlink(cutfname(1));
+  widget_browser->display(Fl_Type::current);
+  widget_browser->rebuild();
+  undo_resume();
+}
+
+/**
+ User wants to sort selected widgets by y coordinate.
+ */
+static void sort_cb(Fl_Widget *,void *) {
+  undo_checkpoint();
+  sort((Fl_Type*)NULL);
+  widget_browser->rebuild();
+  set_modflag(1);
+}
+
+/**
+ Open the "About" dialog.
+ */
+void about_cb(Fl_Widget *, void *) {
+  if (!about_panel) make_about_panel();
+  about_panel->show();
+}
+
+/**
+ Open a dialog to show the HTML help page form the FLTK documentation folder.
+ \param[in] name name of the HTML help file.
+ */
+void show_help(const char *name) {
+  const char    *docdir;
+  char          helpname[FL_PATH_MAX];
+
+  if (!help_dialog) help_dialog = new Fl_Help_Dialog();
+
+  if ((docdir = fl_getenv("FLTK_DOCDIR")) == NULL) {
+    docdir = FLTK_DOCDIR;
+  }
+  snprintf(helpname, sizeof(helpname), "%s/%s", docdir, name);
+
+  // make sure that we can read the file
+  FILE *f = fopen(helpname, "rb");
+  if (f) {
+    fclose(f);
+    help_dialog->load(helpname);
+  } else {
+    // if we can not read the file, we display the canned version instead
+    // or ask the native browser to open the page on www.fltk.org
+    if (strcmp(name, "fluid.html")==0) {
+      if (!Fl_Shared_Image::find("embedded:/fluid_flow_chart_800.png"))
+        new Fl_PNG_Image("embedded:/fluid_flow_chart_800.png", fluid_flow_chart_800_png, sizeof(fluid_flow_chart_800_png));
+      help_dialog->value
+      (
+       "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n"
+       "<html><head><title>FLTK: Programming with FLUID</title></head><body>\n"
+       "<h2>What is FLUID?</h2>\n"
+       "The Fast Light User Interface Designer, or FLUID, is a graphical editor "
+       "that is used to produce FLTK source code. FLUID edits and saves its state "
+       "in <code>.fl</code> files. These files are text, and you can (with care) "
+       "edit them in a text editor, perhaps to get some special effects.<p>\n"
+       "FLUID can \"compile\" the <code>.fl</code> file into a <code>.cxx</code> "
+       "and a <code>.h</code> file. The <code>.cxx</code> file defines all the "
+       "objects from the <code>.fl</code> file and the <code>.h</code> file "
+       "declares all the global ones. FLUID also supports localization "
+       "(Internationalization) of label strings using message files and the GNU "
+       "gettext or POSIX catgets interfaces.<p>\n"
+       "A simple program can be made by putting all your code (including a <code>"
+       "main()</code> function) into the <code>.fl</code> file and thus making the "
+       "<code>.cxx</code> file a single source file to compile. Most programs are "
+       "more complex than this, so you write other <code>.cxx</code> files that "
+       "call the FLUID functions. These <code>.cxx</code> files must <code>"
+       "#include</code> the <code>.h</code> file or they can <code>#include</code> "
+       "the <code>.cxx</code> file so it still appears to be a single source file.<p>"
+       "<img src=\"embedded:/fluid_flow_chart_800.png\"></p>"
+       "<p>More information is available online at <a href="
+       "\"https://www.fltk.org/doc-1.4/fluid.html\">https://www.fltk.org/</a>"
+       "</body></html>"
+       );
+    } else if (strcmp(name, "license.html")==0) {
+      fl_open_uri("https://www.fltk.org/doc-1.4/license.html");
+      return;
+    } else if (strcmp(name, "index.html")==0) {
+      fl_open_uri("https://www.fltk.org/doc-1.4/index.html");
+      return;
+    } else {
+      snprintf(helpname, sizeof(helpname), "https://www.fltk.org/%s", name);
+      fl_open_uri(helpname);
+      return;
+    }
+  }
+  help_dialog->show();
+}
+
+/**
+ User wants help on Fluid.
+ */
+void help_cb(Fl_Widget *, void *) {
+  show_help("fluid.html");
+}
+
+/**
+ User wants to see the Fluid manual.
+ */
+void manual_cb(Fl_Widget *, void *) {
+  show_help("index.html");
+}
+
+// ---- Printing
+
+/**
+ Open the dialog to allow the user to print the current window.
+ */
+void print_menu_cb(Fl_Widget *, void *) {
+  int w, h, ww, hh;
+  int frompage, topage;
+  Fl_Type       *t;                     // Current widget
+  int           num_windows;            // Number of windows
+  Fl_Window_Type *windows[1000];        // Windows to print
+  int           winpage;                // Current window page
+  Fl_Window *win;
+
+  for (t = Fl_Type::first, num_windows = 0; t; t = t->next) {
+    if (t->is_a(ID_Window)) {
+      windows[num_windows] = (Fl_Window_Type *)t;
+      if (!((Fl_Window*)(windows[num_windows]->o))->shown()) continue;
+      num_windows ++;
+    }
+  }
+
+  Fl_Printer printjob;
+  if ( printjob.start_job(num_windows, &frompage, &topage) ) return;
+  int pagecount = 0;
+  for (winpage = 0; winpage < num_windows; winpage++) {
+    float scale = 1, scale_x = 1, scale_y = 1;
+    if (winpage+1 < frompage || winpage+1 > topage) continue;
+    printjob.start_page();
+    printjob.printable_rect(&w, &h);
+
+    // Get the time and date...
+    time_t curtime = time(NULL);
+    struct tm *curdate = localtime(&curtime);
+    char date[1024];
+    strftime(date, sizeof(date), "%c", curdate);
+    fl_font(FL_HELVETICA, 12);
+    fl_color(FL_BLACK);
+    fl_draw(date, (w - (int)fl_width(date))/2, fl_height());
+    sprintf(date, "%d/%d", ++pagecount, topage-frompage+1);
+    fl_draw(date, w - (int)fl_width(date), fl_height());
+
+    // Get the base filename...
+    std::string basename = fl_filename_name(std::string(filename));
+    fl_draw(basename.c_str(), 0, fl_height());
+
+    // print centered and scaled to fit in the page
+    win = (Fl_Window*)windows[winpage]->o;
+    ww = win->decorated_w();
+    if(ww > w) scale_x = float(w)/ww;
+    hh = win->decorated_h();
+    if(hh > h) scale_y = float(h)/hh;
+    if (scale_x < scale) scale = scale_x;
+    if (scale_y < scale) scale = scale_y;
+    if (scale < 1) {
+      printjob.scale(scale);
+      printjob.printable_rect(&w, &h);
+    }
+    printjob.origin(w/2, h/2);
+    printjob.print_window(win, -ww/2, -hh/2);
+    printjob.end_page();
+  }
+  printjob.end_job();
+}
+
+// ---- Main menu bar
+
+extern void select_layout_preset_cb(Fl_Widget *, void *user_data);
+extern void layout_suite_marker(Fl_Widget *, void *user_data);
+
+static void menu_file_new_cb(Fl_Widget *, void *) { new_project(); }
+static void menu_file_new_from_template_cb(Fl_Widget *, void *) { new_project_from_template(); }
+static void menu_file_open_cb(Fl_Widget *, void *) { open_project_file(""); }
+static void menu_file_insert_cb(Fl_Widget *, void *) { merge_project_file(""); }
+static void menu_file_open_history_cb(Fl_Widget *, void *v) { open_project_file(std::string((const char*)v)); }
+static void menu_layout_sync_resize_cb(Fl_Menu_ *m, void*) {
+  if (m->mvalue()->value()) Fl_Type::allow_layout = 1; else Fl_Type::allow_layout = 0; }
+/**
+ This is the main Fluid menu.
+
+ Design history is manipulated right inside this menu structure.
+ Some menu items change or deactivate correctly, but most items just trigger
+ various callbacks.
+
+ \c New_Menu creates new widgets and is explained in detail in another location.
+
+ \see New_Menu
+ \todo This menu needs some major modernization. Menus are too long and their
+    sorting is not always obvious.
+ \todo Shortcuts are all over the place (Alt, Ctrl, Command, Shift-Ctrl,
+    function keys), and there should be a help page listing all shortcuts.
+ */
+Fl_Menu_Item Main_Menu[] = {
+{"&File",0,0,0,FL_SUBMENU},
+  {"&New", FL_COMMAND+'n', menu_file_new_cb},
+  {"&Open...", FL_COMMAND+'o', menu_file_open_cb},
+  {"&Insert...", FL_COMMAND+'i', menu_file_insert_cb, 0, FL_MENU_DIVIDER},
+  {"&Save", FL_COMMAND+'s', save_cb, 0},
+  {"Save &As...", FL_COMMAND+FL_SHIFT+'s', save_cb, (void*)1},
+  {"Sa&ve A Copy...", 0, save_cb, (void*)2},
+  {"&Revert...", 0, revert_cb, 0, FL_MENU_DIVIDER},
+  {"New &From Template...", FL_COMMAND+'N', menu_file_new_from_template_cb, 0},
+  {"Save As &Template...", 0, save_template_cb, 0, FL_MENU_DIVIDER},
+  {"&Print...", FL_COMMAND+'p', print_menu_cb},
+  {"Write &Code", FL_COMMAND+FL_SHIFT+'c', write_cb, 0},
+// Matt: disabled {"MergeBack Code", FL_COMMAND+FL_SHIFT+'m', mergeback_cb, 0},
+  {"&Write Strings", FL_COMMAND+FL_SHIFT+'w', write_strings_cb, 0, FL_MENU_DIVIDER},
+  {relative_history[0], FL_COMMAND+'1', menu_file_open_history_cb, absolute_history[0]},
+  {relative_history[1], FL_COMMAND+'2', menu_file_open_history_cb, absolute_history[1]},
+  {relative_history[2], FL_COMMAND+'3', menu_file_open_history_cb, absolute_history[2]},
+  {relative_history[3], FL_COMMAND+'4', menu_file_open_history_cb, absolute_history[3]},
+  {relative_history[4], FL_COMMAND+'5', menu_file_open_history_cb, absolute_history[4]},
+  {relative_history[5], FL_COMMAND+'6', menu_file_open_history_cb, absolute_history[5]},
+  {relative_history[6], FL_COMMAND+'7', menu_file_open_history_cb, absolute_history[6]},
+  {relative_history[7], FL_COMMAND+'8', menu_file_open_history_cb, absolute_history[7]},
+  {relative_history[8], FL_COMMAND+'9', menu_file_open_history_cb, absolute_history[8]},
+  {relative_history[9], 0, menu_file_open_history_cb, absolute_history[9], FL_MENU_DIVIDER},
+  {"&Quit", FL_COMMAND+'q', exit_cb},
+  {0},
+{"&Edit",0,0,0,FL_SUBMENU},
+  {"&Undo", FL_COMMAND+'z', undo_cb},
+  {"&Redo", FL_COMMAND+FL_SHIFT+'z', redo_cb, 0, FL_MENU_DIVIDER},
+  {"C&ut", FL_COMMAND+'x', cut_cb},
+  {"&Copy", FL_COMMAND+'c', copy_cb},
+  {"&Paste", FL_COMMAND+'v', paste_cb},
+  {"Dup&licate", FL_COMMAND+'u', duplicate_cb},
+  {"&Delete", FL_Delete, delete_cb, 0, FL_MENU_DIVIDER},
+  {"Select &All", FL_COMMAND+'a', select_all_cb},
+  {"Select &None", FL_COMMAND+FL_SHIFT+'a', select_none_cb, 0, FL_MENU_DIVIDER},
+  {"Pr&operties...", FL_F+1, openwidget_cb},
+  {"&Sort",0,sort_cb},
+  {"&Earlier", FL_F+2, earlier_cb},
+  {"&Later", FL_F+3, later_cb},
+  {"&Group", FL_F+7, group_cb},
+  {"Ung&roup", FL_F+8, ungroup_cb,0, FL_MENU_DIVIDER},
+  {"Hide O&verlays",FL_COMMAND+FL_SHIFT+'o',toggle_overlays},
+  {"Hide Guides",FL_COMMAND+FL_SHIFT+'g',toggle_guides},
+  {"Hide Restricted",FL_COMMAND+FL_SHIFT+'r',toggle_restricted},
+  {"Show Widget &Bin...",FL_ALT+'b',toggle_widgetbin_cb},
+  {"Show Code View",FL_ALT+'c', (Fl_Callback*)toggle_codeview_cb, 0, FL_MENU_DIVIDER},
+  {"Settings...",FL_ALT+'p',show_settings_cb},
+  {0},
+{"&New", 0, 0, (void *)New_Menu, FL_SUBMENU_POINTER},
+{"&Layout",0,0,0,FL_SUBMENU},
+  {"&Align",0,0,0,FL_SUBMENU},
+    {"&Left",0,(Fl_Callback *)align_widget_cb,(void*)10},
+    {"&Center",0,(Fl_Callback *)align_widget_cb,(void*)11},
+    {"&Right",0,(Fl_Callback *)align_widget_cb,(void*)12},
+    {"&Top",0,(Fl_Callback *)align_widget_cb,(void*)13},
+    {"&Middle",0,(Fl_Callback *)align_widget_cb,(void*)14},
+    {"&Bottom",0,(Fl_Callback *)align_widget_cb,(void*)15},
+    {0},
+  {"&Space Evenly",0,0,0,FL_SUBMENU},
+    {"&Across",0,(Fl_Callback *)align_widget_cb,(void*)20},
+    {"&Down",0,(Fl_Callback *)align_widget_cb,(void*)21},
+    {0},
+  {"&Make Same Size",0,0,0,FL_SUBMENU},
+    {"&Width",0,(Fl_Callback *)align_widget_cb,(void*)30},
+    {"&Height",0,(Fl_Callback *)align_widget_cb,(void*)31},
+    {"&Both",0,(Fl_Callback *)align_widget_cb,(void*)32},
+    {0},
+  {"&Center In Group",0,0,0,FL_SUBMENU},
+    {"&Horizontal",0,(Fl_Callback *)align_widget_cb,(void*)40},
+    {"&Vertical",0,(Fl_Callback *)align_widget_cb,(void*)41},
+    {0},
+  {"Synchronized Resize", 0, (Fl_Callback*)menu_layout_sync_resize_cb, NULL, FL_MENU_TOGGLE|FL_MENU_DIVIDER },
+  {"&Grid and Size Settings...",FL_COMMAND+'g',show_grid_cb, NULL, FL_MENU_DIVIDER},
+  {"Presets", 0, layout_suite_marker, (void*)main_layout_submenu_, FL_SUBMENU_POINTER },
+  {"Application", 0, select_layout_preset_cb, (void*)0, FL_MENU_RADIO|FL_MENU_VALUE },
+  {"Dialog",      0, select_layout_preset_cb, (void*)1, FL_MENU_RADIO },
+  {"Toolbox",     0, select_layout_preset_cb, (void*)2, FL_MENU_RADIO },
+  {0},
+{"&Shell", 0, Fd_Shell_Command_List::menu_marker, (void*)Fd_Shell_Command_List::default_menu, FL_SUBMENU_POINTER},
+{"&Help",0,0,0,FL_SUBMENU},
+  {"&Rapid development with FLUID...",0,help_cb},
+  {"&FLTK Programmers Manual...",0,manual_cb, 0, FL_MENU_DIVIDER},
+  {"&About FLUID...",0,about_cb},
+  {0},
+{0}};
+
+/**
+ Change the app's and hence preview the design's scheme.
+
+ The scheme setting is stored in the app preferences
+ - in key \p 'scheme_name' since 1.4.0
+ - in key \p 'scheme' (index: 0 - 4) in 1.3.x
+
+ This callback is triggered by changing the scheme in the
+ Fl_Scheme_Choice widget (\p Edit/GUI Settings).
+
+ \param[in] choice the calling widget
+
+ \see init_scheme() for choice values and backwards compatibility
+ */
+void scheme_cb(Fl_Scheme_Choice *choice, void *) {
+  if (batch_mode)
+    return;
+
+  // set the new scheme only if the scheme was changed
+  const char *new_scheme = choice->text(choice->value());
+
+  if (Fl::is_scheme(new_scheme))
+    return;
+
+  Fl::scheme(new_scheme);
+  fluid_prefs.set("scheme_name", new_scheme);
+
+  // Backwards compatibility: store 1.3 scheme index (1-4).
+  // We assume that index 0-3 (base, plastic, gtk+, gleam) are in the
+  // same order as in 1.3.x (index 1-4), higher values are ignored
+
+  int scheme_index = scheme_choice->value();
+  if (scheme_index <= 3)                          // max. index for 1.3.x (Gleam)
+    fluid_prefs.set("scheme", scheme_index + 1);  // compensate for different indexing
+}
+
+/**
+  Read Fluid's scheme preferences and set the app's scheme.
+
+  Since FLTK 1.4.0 the scheme \b name is stored as a character string
+  with key "scheme_name" in the preference database.
+
+  In FLTK 1.3.x the scheme preference was stored as an integer index
+  with key "scheme" in the database. The known schemes were hardcoded in
+  Fluid's sources (here for reference):
+
+    | Index | 1.3 Scheme Name | Choice | 1.4 Scheme Name |
+    |-------|-----------------|-------|-----------------|
+    | 0 | Default (same as None) | n/a | n/a |
+    | 1 | None (same as Default) | 0 | base |
+    | 2 | Plastic | 1 | plastic |
+    | 3 | GTK+ | 2 | gtk+ |
+    | 4 | Gleam | 3 | gleam |
+    | n/a | n/a | 4 | oxy |
+
+  The new Fluid tries to keep backwards compatibility and reads both
+  keys (\p scheme and \p scheme_name). If the latter is defined, it is used.
+  If not the old \p scheme (index) is used - but we need to subtract one to
+  get the new Fl_Scheme_Choice index (column "Choice" above).
+*/
+void init_scheme() {
+  int scheme_index = 0;                     // scheme index for backwards compatibility (1.3.x)
+  char *scheme_name = 0;                    // scheme name since 1.4.0
+  fluid_prefs.get("scheme_name", scheme_name, "XXX"); // XXX means: not set => fallback 1.3.x
+  if (!strcmp(scheme_name, "XXX")) {
+    fluid_prefs.get("scheme", scheme_index, 0);
+    if (scheme_index > 0) {
+      scheme_index--;
+      scheme_choice->value(scheme_index);   // set the choice value
+    }
+    if (scheme_index < 0)
+      scheme_index = 0;
+    else if (scheme_index > scheme_choice->size() - 1)
+      scheme_index = 0;
+    scheme_name = const_cast<char *>(scheme_choice->text(scheme_index));
+    fluid_prefs.set("scheme_name", scheme_name);
+  }
+  // Set the new scheme only if it was not overridden by the -scheme
+  // command line option
+  if (Fl::scheme() == NULL) {
+    Fl::scheme(scheme_name);
+  }
+  free(scheme_name);
+}
+
+/**
+ Show or hide the widget bin.
+ The state is stored in the app preferences.
+ */
+void toggle_widgetbin_cb(Fl_Widget *, void *) {
+  if (!widgetbin_panel) {
+    make_widgetbin();
+    if (!position_window(widgetbin_panel,"widgetbin_pos", 1, 320, 30)) return;
+  }
+
+  if (widgetbin_panel->visible()) {
+    widgetbin_panel->hide();
+    widgetbin_item->label("Show Widget &Bin...");
+  } else {
+    widgetbin_panel->show();
+    widgetbin_item->label("Hide Widget &Bin");
+  }
+}
+
+/**
+ Show or hide the code preview window.
+ */
+void toggle_codeview_cb(Fl_Double_Window *, void *) {
+  codeview_toggle_visibility();
+}
+
+/**
+ Show or hide the code preview window, button callback.
+ */
+void toggle_codeview_b_cb(Fl_Button*, void *) {
+  codeview_toggle_visibility();
+}
+
+/**
+ Build the main app window and create a few other dialogs.
+ */
+void make_main_window() {
+  if (!batch_mode) {
+    fluid_prefs.get("show_guides", show_guides, 1);
+    fluid_prefs.get("show_restricted", show_restricted, 1);
+    fluid_prefs.get("show_ghosted_outline", show_ghosted_outline, 0);
+    fluid_prefs.get("show_comments", show_comments, 1);
+    make_shell_window();
+  }
+
+  if (!main_window) {
+    Fl_Widget *o;
+    loadPixmaps();
+    main_window = new Fl_Double_Window(WINWIDTH,WINHEIGHT,"fluid");
+    main_window->box(FL_NO_BOX);
+    o = make_widget_browser(0,MENUHEIGHT,BROWSERWIDTH,BROWSERHEIGHT);
+    o->box(FL_FLAT_BOX);
+    o->tooltip("Double-click to view or change an item.");
+    main_window->resizable(o);
+    main_menubar = new Fl_Menu_Bar(0,0,BROWSERWIDTH,MENUHEIGHT);
+    main_menubar->menu(Main_Menu);
+    // quick access to all dynamic menu items
+    save_item = (Fl_Menu_Item*)main_menubar->find_item(save_cb);
+    history_item = (Fl_Menu_Item*)main_menubar->find_item(menu_file_open_history_cb);
+    widgetbin_item = (Fl_Menu_Item*)main_menubar->find_item(toggle_widgetbin_cb);
+    codeview_item = (Fl_Menu_Item*)main_menubar->find_item((Fl_Callback*)toggle_codeview_cb);
+    overlay_item = (Fl_Menu_Item*)main_menubar->find_item((Fl_Callback*)toggle_overlays);
+    guides_item = (Fl_Menu_Item*)main_menubar->find_item((Fl_Callback*)toggle_guides);
+    restricted_item = (Fl_Menu_Item*)main_menubar->find_item((Fl_Callback*)toggle_restricted);
+    main_menubar->global();
+    fill_in_New_Menu();
+    main_window->end();
+  }
+
+  if (!batch_mode) {
+    load_history();
+    g_shell_config = new Fd_Shell_Command_List;
+    widget_browser->load_prefs();
+    make_settings_window();
+  }
+}
+
+/**
+ Load file history from preferences.
+
+ This loads the absolute filepaths of the last 10 used design files.
+ It also computes and stores the relative filepaths for display in
+ the main menu.
+ */
+void load_history() {
+  int   i;              // Looping var
+  int   max_files;
+
+  fluid_prefs.get("recent_files", max_files, 5);
+  if (max_files > 10) max_files = 10;
+
+  for (i = 0; i < max_files; i ++) {
+    fluid_prefs.get( Fl_Preferences::Name("file%d", i), absolute_history[i], "", sizeof(absolute_history[i]));
+    if (absolute_history[i][0]) {
+      // Make a shortened version of the filename for the menu...
+      std::string fn = fl_filename_shortened(absolute_history[i], 48);
+      strncpy(relative_history[i], fn.c_str(), sizeof(relative_history[i]) - 1);
+      if (i == 9) history_item[i].flags = FL_MENU_DIVIDER;
+      else history_item[i].flags = 0;
+    } else break;
+  }
+
+  for (; i < 10; i ++) {
+    if (i) history_item[i-1].flags |= FL_MENU_DIVIDER;
+    history_item[i].hide();
+  }
+}
+
+/**
+ Update file history from preferences.
+
+ Add this new filepath to the history and update the main menu.
+ Writes the new file history to the app preferences.
+
+ \param[in] flname path or filename of .fl file, will be converted into an
+    absolute file path based on the current working directory.
+ */
+void update_history(const char *flname) {
+  int   i;              // Looping var
+  char  absolute[FL_PATH_MAX];
+  int   max_files;
+
+
+  fluid_prefs.get("recent_files", max_files, 5);
+  if (max_files > 10) max_files = 10;
+
+  fl_filename_absolute(absolute, sizeof(absolute), flname);
+#ifdef _WIN32
+  // Make path canonical.
+  for (char *s = absolute; *s; s++) {
+    if (*s == '\\')
+      *s = '/';
+  }
+#endif
+
+
+  for (i = 0; i < max_files; i ++)
+#if defined(_WIN32) || defined(__APPLE__)
+    if (!strcasecmp(absolute, absolute_history[i])) break;
+#else
+    if (!strcmp(absolute, absolute_history[i])) break;
+#endif // _WIN32 || __APPLE__
+
+  if (i == 0) return;
+
+  if (i >= max_files) i = max_files - 1;
+
+  // Move the other flnames down in the list...
+  memmove(absolute_history + 1, absolute_history,
+          i * sizeof(absolute_history[0]));
+  memmove(relative_history + 1, relative_history,
+          i * sizeof(relative_history[0]));
+
+  // Put the new file at the top...
+  strlcpy(absolute_history[0], absolute, sizeof(absolute_history[0]));
+  std::string fn = fl_filename_shortened(absolute_history[0], 48);
+  strncpy(relative_history[0], fn.c_str(), sizeof(relative_history[0]) - 1);
+
+  // Update the menu items as needed...
+  for (i = 0; i < max_files; i ++) {
+    fluid_prefs.set( Fl_Preferences::Name("file%d", i), absolute_history[i]);
+    if (absolute_history[i][0]) {
+      if (i == 9) history_item[i].flags = FL_MENU_DIVIDER;
+      else history_item[i].flags = 0;
+    } else break;
+  }
+
+  for (; i < 10; i ++) {
+    fluid_prefs.set( Fl_Preferences::Name("file%d", i), "");
+    if (i) history_item[i-1].flags |= FL_MENU_DIVIDER;
+    history_item[i].hide();
+  }
+  fluid_prefs.flush();
+}
+
+/**
+ Set the filename of the current .fl design.
+ \param[in] c the new absolute filename and path
+ */
+void set_filename(const char *c) {
+  if (filename) free((void *)filename);
+  filename = c ? fl_strdup(c) : NULL;
+
+  if (filename && !batch_mode)
+    update_history(filename);
+
+  set_modflag(modflag);
+}
+
+
+/**
+ Set the "modified" flag and update the title of the main window.
+
+ The first argument sets the modification state of the current design against
+ the corresponding .fl design file. Any change to the widget tree will mark
+ the design 'modified'. Saving the design will mark it clean.
+
+ The second argument is optional and set the modification state of the current
+ design against the source code and header file. Any change to the tree,
+ including saving the tree, will mark the code 'outdated'. Generating source
+ code and header files will clear this flag until the next modification.
+
+ \param[in] mf 0 to clear the modflag, 1 to mark the design "modified", -1 to
+    ignore this parameter
+ \param[in] mfc default -1 to let \c mf control \c modflag_c, 0 to mark the
+    code files current, 1 to mark it out of date. -2 to ignore changes to mf.
+ */
+void set_modflag(int mf, int mfc) {
+  const char *code_ext = NULL;
+  char new_title[FL_PATH_MAX];
+
+  // Update the modflag_c to the worst possible condition. We could be a bit
+  // more graceful and compare modification times of the files, but C++ has
+  // no API for that until C++17.
+  if (mf!=-1) {
+    modflag = mf;
+    if (mfc==-1 && mf==1)
+      mfc = mf;
+  }
+  if (mfc>=0) {
+    modflag_c = mfc;
+  }
+
+  if (main_window) {
+    std::string basename;
+    if (!filename) basename = "Untitled.fl";
+    else basename = fl_filename_name(std::string(filename));
+    code_ext = fl_filename_ext(g_project.code_file_name.c_str());
+    char mod_star = modflag ? '*' : ' ';
+    char mod_c_star = modflag_c ? '*' : ' ';
+    snprintf(new_title, sizeof(new_title), "%s%c  %s%c",
+             basename.c_str(), mod_star, code_ext, mod_c_star);
+    const char *old_title = main_window->label();
+    // only update the title if it actually changed
+    if (!old_title || strcmp(old_title, new_title))
+      main_window->copy_label(new_title);
+  }
+  // if the UI was modified in any way, update the Code View panel
+  if (codeview_panel && codeview_panel->visible() && cv_autorefresh->value())
+    codeview_defer_update();
+}
+
+// ---- Main program entry point
+
+/**
+ Handle command line arguments.
+ \param[in] argc number of arguments in the list
+ \param[in] argv pointer to an array of arguments
+ \param[inout] i current argument index
+ \return number of arguments used; if 0, the argument is not supported
+ */
+static int arg(int argc, char** argv, int& i) {
+  if (argv[i][0] != '-')
+    return 0;
+  if (argv[i][1] == 'd' && !argv[i][2]) {
+    G_debug=1;
+    i++; return 1;
+  }
+  if (argv[i][1] == 'u' && !argv[i][2]) {
+    update_file++;
+    batch_mode++;
+    i++; return 1;
+  }
+  if (argv[i][1] == 'c' && !argv[i][2]) {
+    compile_file++;
+    batch_mode++;
+    i++; return 1;
+  }
+  if ((strcmp(argv[i], "-v")==0) || (strcmp(argv[i], "--version")==0)) {
+    show_version = 1;
+    i++; return 1;
+  }
+  if (argv[i][1] == 'c' && argv[i][2] == 's' && !argv[i][3]) {
+    compile_file++;
+    compile_strings++;
+    batch_mode++;
+    i++; return 1;
+  }
+  if (argv[i][1] == 'o' && !argv[i][2] && i+1 < argc) {
+    g_code_filename_arg = argv[i+1];
+    batch_mode++;
+    i += 2; return 2;
+  }
+#ifndef NDEBUG
+  if ((i+1 < argc) && (strcmp(argv[i], "--autodoc") == 0)) {
+    g_autodoc_path = argv[i+1];
+    i += 2; return 2;
+  }
+#endif
+  if (strcmp(argv[i], "--help")==0) {
+    return 0;
+  }
+  if (argv[i][1] == 'h' && !argv[i][2]) {
+    if ( (i+1 < argc) && (argv[i+1][0] != '-') ) {
+      g_header_filename_arg = argv[i+1];
+      batch_mode++;
+      i += 2;
+      return 2;
+    } else {
+      // a lone "-h" without a filename will output the help string
+      return 0;
+    }
+  }
+  return 0;
+}
+
+#if ! (defined(_WIN32) && !defined (__CYGWIN__))
+
+int quit_flag = 0;
+#include <signal.h>
+#ifdef _sigargs
+#define SIGARG _sigargs
+#else
+#ifdef __sigargs
+#define SIGARG __sigargs
+#else
+#define SIGARG int // you may need to fix this for older systems
+#endif
+#endif
+
+extern "C" {
+static void sigint(SIGARG) {
+  signal(SIGINT,sigint);
+  quit_flag = 1;
+}
+}
+
+#endif
+
+/**
+ Start Fluid.
+
+ Fluid can run in interactive mode with a full user interface to design new
+ user interfaces and write the C++ files to manage them,
+
+ Fluid can run form the command line in batch mode to convert .fl design files
+ into C++ source and header files. In batch mode, no display is needed,
+ particularly no X11 connection will be attempted on Linux/Unix.
+
+ \param[in] argc number of arguments in the list
+ \param[in] argv pointer to an array of arguments
+ \return in batch mode, an error code will be returned via \c exit() . This
+    function return 1, if there was an error in the parameters list.
+ \todo On Windows, Fluid can under certain conditions open a dialog box, even
+    in batch mode. Is that intentional? Does it circumvent issues with Windows'
+    stderr and stdout?
+ */
+int fluid_main(int argc,char **argv) {
+  int i = 1;
+
+  setlocale(LC_ALL, "");      // enable multi-language errors in file chooser
+  setlocale(LC_NUMERIC, "C"); // make sure numeric values are written correctly
+  g_launch_path = end_with_slash(fl_getcwd()); // store the current path at launch
+
+  Fl::args_to_utf8(argc, argv); // for MSYS2/MinGW
+  if (   (Fl::args(argc,argv,i,arg) == 0)     // unsupported argument found
+      || (batch_mode && (i != argc-1))        // .fl filename missing
+      || (!batch_mode && (i < argc-1))        // more than one filename found
+      || (argv[i] && (argv[i][0] == '-'))) {  // unknown option
+    static const char *msg =
+      "usage: %s <switches> name.fl\n"
+      " -u : update .fl file and exit (may be combined with '-c' or '-cs')\n"
+      " -c : write .cxx and .h and exit\n"
+      " -cs : write .cxx and .h and strings and exit\n"
+      " -o <name> : .cxx output filename, or extension if <name> starts with '.'\n"
+      " -h <name> : .h output filename, or extension if <name> starts with '.'\n"
+      " --help : brief usage information\n"
+      " --version, -v : print fluid version number\n"
+      " -d : enable internal debugging\n";
+    const char *app_name = NULL;
+    if ( (argc > 0) && argv[0] && argv[0][0] )
+      app_name = fl_filename_name(argv[0]);
+    if ( !app_name || !app_name[0])
+      app_name = "fluid";
+#ifdef _MSC_VER
+    // TODO: if this is fluid-cmd, use stderr and not fl_message
+    fl_message(msg, app_name);
+#else
+    fprintf(stderr, msg, app_name);
+#endif
+    return 1;
+  }
+  if (show_version) {
+    printf("fluid v%d.%d.%d\n", FL_MAJOR_VERSION, FL_MINOR_VERSION, FL_PATCH_VERSION);
+    ::exit(0);
+  }
+
+  const char *c = NULL;
+  if (g_autodoc_path.empty())
+    c = argv[i];
+
+  fl_register_images();
+
+  make_main_window();
+
+  if (c) set_filename(c);
+  if (!batch_mode) {
+#ifdef __APPLE__
+    fl_open_callback(apple_open_cb);
+#endif // __APPLE__
+    Fl::visual((Fl_Mode)(FL_DOUBLE|FL_INDEX));
+    Fl_File_Icon::load_system_icons();
+    main_window->callback(exit_cb);
+    position_window(main_window,"main_window_pos", 1, 10, 30, WINWIDTH, WINHEIGHT );
+    if (g_shell_config) {
+      g_shell_config->read(fluid_prefs, FD_STORE_USER);
+      g_shell_config->update_settings_dialog();
+      g_shell_config->rebuild_shell_menu();
+    }
+    g_layout_list.read(fluid_prefs, FD_STORE_USER);
+    main_window->show(argc,argv);
+    toggle_widgetbin_cb(0,0);
+    toggle_codeview_cb(0,0);
+    if (!c && openlast_button->value() && absolute_history[0][0] && g_autodoc_path.empty()) {
+      // Open previous file when no file specified...
+      open_project_file(absolute_history[0]);
+    }
+  }
+  undo_suspend();
+  if (c && !read_file(c,0)) {
+    if (batch_mode) {
+      fprintf(stderr,"%s : %s\n", c, strerror(errno));
+      exit(1);
+    }
+    fl_message("Can't read %s: %s", c, strerror(errno));
+  }
+  undo_resume();
+
+  // command line args override code and header filenames from the project file
+  // in batch mode only
+  if (batch_mode) {
+    if (!g_code_filename_arg.empty()) {
+      g_project.code_file_set = 1;
+      g_project.code_file_name = g_code_filename_arg;
+    }
+    if (!g_header_filename_arg.empty()) {
+      g_project.header_file_set = 1;
+      g_project.header_file_name = g_header_filename_arg;
+    }
+  }
+
+  if (update_file) {            // fluid -u
+    write_file(c,0);
+    if (!compile_file)
+      exit(0);
+  }
+
+  if (compile_file) {           // fluid -c[s]
+    if (compile_strings)
+      write_strings_cb(0,0);
+    write_cb(0,0);
+    exit(0);
+  }
+
+  // don't lock up if inconsistent command line arguments were given
+  if (batch_mode)
+    exit(0);
+
+  set_modflag(0);
+  undo_clear();
+#ifndef _WIN32
+  signal(SIGINT,sigint);
+#endif
+
+  // Set (but do not start) timer callback for external editor updates
+  ExternalCodeEditor::set_update_timer_callback(external_editor_timer);
+
+#ifndef NDEBUG
+  // check if the user wants FLUID to generate image for the user documentation
+  if (!g_autodoc_path.empty()) {
+    run_autodoc(g_autodoc_path);
+    set_modflag(0, 0);
+    exit_cb(0,0);
+    return 0;
+  }
+#endif
+
+#ifdef _WIN32
+  Fl::run();
+#else
+  while (!quit_flag) Fl::wait();
+  if (quit_flag) exit_cb(0,0);
+#endif // _WIN32
+
+  undo_clear();
+  return (0);
+}
+
+/// \}
+
diff --git a/fluid/app/fluid.h b/fluid/app/fluid.h
new file mode 100644
index 000000000..d02ae79cc
--- /dev/null
+++ b/fluid/app/fluid.h
@@ -0,0 +1,208 @@
+//
+// FLUID main entry for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2025 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#ifndef _FLUID_FLUID_H
+#define _FLUID_FLUID_H
+
+#include "tools/fluid_filename.h"
+
+#include <FL/Fl_Preferences.H>
+#include <FL/Fl_Menu_Item.H>
+
+#include <string>
+
+#define BROWSERWIDTH 300
+#define BROWSERHEIGHT 500
+#define WINWIDTH 300
+#define MENUHEIGHT 25
+#define WINHEIGHT (BROWSERHEIGHT+MENUHEIGHT)
+
+// ---- types
+
+class Fl_Double_Window;
+class Fl_Window;
+class Fl_Menu_Bar;
+class Fl_Type;
+class Fl_Choice;
+class Fl_Button;
+class Fl_Check_Button;
+
+/**
+ Indicate the storage location for tools like layout suites and shell macros.
+ \see class Fd_Shell_Command, class Fd_Layout_Suite
+ */
+typedef enum {
+  FD_STORE_INTERNAL,  ///< stored inside FLUID app
+  FD_STORE_USER,      ///< suite is stored in the user wide FLUID settings
+  FD_STORE_PROJECT,   ///< suite is stored within the current .fl project file
+  FD_STORE_FILE       ///< store suite in external file
+} Fd_Tool_Store;
+
+// ---- global variables
+
+extern Fl_Preferences fluid_prefs;
+extern Fl_Menu_Item Main_Menu[];
+extern Fl_Menu_Bar *main_menubar;
+extern Fl_Window *main_window;
+
+extern int show_guides;
+extern int show_restricted;
+extern int show_ghosted_outline;
+extern int show_comments;
+
+extern int G_use_external_editor;
+extern int G_debug;
+extern char G_external_editor_command[512];
+
+// File history info...
+extern char absolute_history[10][FL_PATH_MAX];
+extern char relative_history[10][FL_PATH_MAX];
+extern void load_history();
+extern void update_history(const char *);
+
+extern Fl_Menu_Item *save_item;
+extern Fl_Menu_Item *history_item;
+extern Fl_Menu_Item *widgetbin_item;
+extern Fl_Menu_Item *codeview_item;
+extern Fl_Menu_Item *overlay_item;
+extern Fl_Button *overlay_button;
+extern Fl_Menu_Item *guides_item;
+extern Fl_Menu_Item *restricted_item;
+extern Fl_Check_Button *guides_button;
+
+extern int modflag;
+
+extern int update_file;            // fluid -u
+extern int compile_file;           // fluid -c
+extern int compile_strings;        // fluic -cs
+extern int batch_mode;
+
+extern int pasteoffset;
+
+extern std::string g_code_filename_arg;
+extern std::string g_header_filename_arg;
+extern std::string g_launch_path;
+
+extern std::string g_autodoc_path;
+
+// ---- project class declaration
+
+/**
+ Enumeration of available internationalization types.
+ */
+typedef enum {
+  FD_I18N_NONE = 0, ///< No i18n, all strings are litearals
+  FD_I18N_GNU,      ///< GNU gettext internationalization
+  FD_I18N_POSIX     ///< Posix catgets internationalization
+} Fd_I18n_Type;
+
+/**
+ Data and settings for a FLUID project file.
+ */
+class Fluid_Project {
+public:
+  Fluid_Project();
+  ~Fluid_Project();
+  void reset();
+  void update_settings_dialog();
+
+  std::string projectfile_path() const;
+  std::string projectfile_name() const;
+  std::string codefile_path() const;
+  std::string codefile_name() const;
+  std::string headerfile_path() const;
+  std::string headerfile_name() const;
+  std::string stringsfile_path() const;
+  std::string stringsfile_name() const;
+  std::string basename() const;
+
+  /// One of the available internationalization types.
+  Fd_I18n_Type i18n_type;
+  /// Include file for GNU i18n, writes an #include statement into the source
+  /// file. This is usually `<libintl.h>` or `"gettext.h"` for GNU gettext.
+  std::string i18n_gnu_include;
+  // Optional name of a macro for conditional i18n compilation.
+  std::string i18n_gnu_conditional;
+  /// For the gettext/intl.h options, this is the function that translates text
+  /// at runtime. This is usually "gettext" or "_".
+  std::string i18n_gnu_function;
+  /// For the gettext/intl.h options, this is the function that marks the translation
+  /// of text at initialisation time. This is usually "gettext_noop" or "N_".
+  std::string i18n_gnu_static_function;
+
+  /// Include file for Posix i18n, write a #include statement into the source
+  /// file. This is usually `<nl_types.h>` for Posix catgets.
+  std::string i18n_pos_include;
+  // Optional name of a macro for conditional i18n compilation.
+  std::string i18n_pos_conditional;
+  /// Name of the nl_catd database
+  std::string i18n_pos_file;
+  /// Message set ID for the catalog.
+  std::string i18n_pos_set;
+
+  /// If set, generate code to include the header file form the c++ file
+  int include_H_from_C;
+  /// If set, handle keyboard shortcut Ctrl on macOS using Cmd instead
+  int use_FL_COMMAND;
+  /// Clear if UTF-8 characters in statics texts are written as escape sequences
+  int utf8_in_src;
+  /// If set, <FL/Fl.H> will not be included from the header code before anything else
+  int avoid_early_includes;
+  /// If set, command line overrides header file name in .fl file.
+  int header_file_set;
+  ///  If set, command line overrides source code file name in .fl file.
+  int code_file_set;
+  int write_mergeback_data;
+  /// Hold the default extension for header files, or the entire filename if set via command line.
+  std::string header_file_name;
+  /// Hold the default extension for source code  files, or the entire filename if set via command line.
+  std::string code_file_name;
+};
+
+extern Fluid_Project g_project;
+
+// ---- public functions
+
+extern int fluid_main(int argc,char **argv);
+
+extern bool new_project(bool user_must_confirm = true);
+extern void enter_project_dir();
+extern void leave_project_dir();
+extern void set_filename(const char *c);
+extern void set_modflag(int mf, int mfc=-1);
+
+extern const std::string &get_tmpdir();
+
+// ---- public callback functions
+
+extern void save_cb(Fl_Widget *, void *v);
+extern void save_template_cb(Fl_Widget *, void *);
+extern void revert_cb(Fl_Widget *,void *);
+extern void exit_cb(Fl_Widget *,void *);
+
+extern int write_code_files(bool dont_show_completion_dialog=false);
+extern void write_strings_cb(Fl_Widget *, void *);
+extern void align_widget_cb(Fl_Widget *, long);
+extern void toggle_widgetbin_cb(Fl_Widget *, void *);
+
+extern char position_window(Fl_Window *w, const char *prefsName, int Visible, int X, int Y, int W=0, int H=0);
+
+inline int fd_min(int a, int b) { return (a < b ? a : b); }
+inline int fd_max(int a, int b) { return (a > b ? a : b); }
+inline int fd_min(int a, int b, int c) { return fd_min(a, fd_min(b, c)); }
+
+#endif // _FLUID_FLUID_H
+
diff --git a/fluid/app/mergeback.cxx b/fluid/app/mergeback.cxx
new file mode 100644
index 000000000..f914f6e1e
--- /dev/null
+++ b/fluid/app/mergeback.cxx
@@ -0,0 +1,493 @@
+//
+// MergeBack routines for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#if 0
+// Matt: disabled
+
+#include "app/mergeback.h"
+
+#include "app/fluid.h"
+#include "app/undo.h"
+#include "io/code.h"
+#include "nodes/Fl_Function_Type.h"
+#include "nodes/Fl_Widget_Type.h"
+
+#include <FL/Fl_Window.H>
+#include <FL/fl_ask.H>
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <zlib.h>
+
+extern void propagate_load(Fl_Group*, void*);
+extern void load_panel();
+extern void redraw_browser();
+
+// TODO: add application user setting to control mergeback
+//        [] new projects default to mergeback
+//        [] check mergeback when loading project
+//        [] check mergeback when app gets focus
+//          [] always apply if safe
+// TODO: command line option for mergeback
+//        -mb or --merge-back
+//        -mbs or --merge-back-if-safe
+// NOTE: automatic mergeback on timer when file changes if app focus doesn't work
+// NOTE: allow the user to edit comment blocks
+
+/**
+ Merge external changes in a source code file back into the current project.
+
+ This experimental function reads a source code file line by line. When it
+ encounters a special tag in a line, the crc32 stored in the tag is compared
+ to the crc32 that was calculated from the code lines since the previous tag.
+
+ If the crc's differ, the user has modified the source file externally, and the
+ given block differs from the block as it was generated by FLUID. Depending on
+ the block type, the user has modified the widget code (FD_TAG_GENERIC), which
+ can not be transferred back into the project.
+
+ Modifications to code blocks and callbacks (CODE, CALLBACK) can be merged back
+ into the project. Their corresponding Fl_Type is found using the unique
+ node id that is part of the tag. The block is only merged back if the crc's
+ from the project and from the edited block differ.
+
+ The caller must make sure that this code file was generated by the currently
+ loaded project.
+
+ The user is informed in detailed dialogs what the function discovered and
+ offered to merge or cancel if appropriate. Just in case this function is
+ destructive, "undo" restores the state before a MergeBack.
+
+ Callers can set different task. FD_MERGEBACK_ANALYSE checks if there are any
+ modifications in the code file and returns -1 if there was an error, or a
+ bit field where bit 0 is set if internal structures were modified, bit 1 if
+ code was changed, and bit 2 if modified blocks were found, but no Type node.
+ Bit 3 is set, if code was changed in the code file *and* the project.
+
+ FD_MERGEBACK_INTERACTIVE checks for changes and presents a status dialog box
+ to the user if there were conflicting changes or if a mergeback is possible,
+ presenting the user the option to merge or cancel. Returns 0 if the project
+ remains unchanged, and 1 if the user merged changes back. -1 is returned if an
+ invalid tag was found.
+
+ FD_MERGEBACK_APPLY merges all changes back into the project without any
+ interaction. Returns 0 if nothing changed, and 1 if it merged any changes back.
+
+ FD_MERGEBACK_APPLY_IF_SAFE merges changes back only if there are no conflicts.
+ Returns 0 if nothing changed, and 1 if it merged any changes back, and -1 if
+ there were conflicts.
+
+ \note this function is currently part of Fd_Code_Writer to get easy access
+ to our crc32 code that also wrote the code file originally.
+
+ \param[in] s path and filename of the source code file
+ \param[in] task see above
+ \return -1 if an error was found in a tag
+ \return -2 if no code file was found
+ \return see above
+ */
+int merge_back(const std::string &s, const std::string &p, int task) {
+  if (g_project.write_mergeback_data) {
+    Fd_Mergeback mergeback;
+    return mergeback.merge_back(s, p, task);
+  } else {
+    // nothing to be done if the mergeback option is disabled in the project
+    return 0;
+  }
+}
+
+/** Allocate and initialize MergeBack class. */
+Fd_Mergeback::Fd_Mergeback() :
+  code(NULL),
+  line_no(0),
+  tag_error(0),
+  num_changed_code(0),
+  num_changed_structure(0),
+  num_uid_not_found(0),
+  num_possible_override(0)
+{
+}
+
+/** Release allocated resources. */
+Fd_Mergeback::~Fd_Mergeback()
+{
+  if (code) ::fclose(code);
+}
+
+/** Remove the first two spaces at every line start.
+ \param[inout] s block of C code
+ */
+void Fd_Mergeback::unindent(char *s) {
+  char *d = s;
+  bool line_start = true;
+  while (*s) {
+    if (line_start) {
+      if (*s>0 && isspace(*s)) s++;
+      if (*s>0 && isspace(*s)) s++;
+      line_start = false;
+    }
+    if (*s=='\r') s++;
+    if (*s=='\n') line_start = true;
+    *d++ = *s++;
+  }
+  *d = 0;
+}
+
+/**
+ Read a block of text from the source file and remove the leading two spaces in every line.
+ \param[in] start start of the block within the file
+ \param[in] end end of text within the file
+ \return a string holding the text that was found in the file
+ */
+std::string Fd_Mergeback::read_and_unindent_block(long start, long end) {
+  long bsize = end-start;
+  long here = ::ftell(code);
+  ::fseek(code, start, SEEK_SET);
+  char *block = (char*)::malloc(bsize+1);
+  size_t n = ::fread(block, bsize, 1, code);
+  if (n!=1)
+    block[0] = 0; // read error
+  else
+    block[bsize] = 0;
+  unindent(block);
+  std::string str = block;
+  ::free(block);
+  ::fseek(code, here, SEEK_SET);
+  return str;
+}
+
+/** Tell user the results of our MergeBack analysis and pop up a dialog to give
+ the user a choice to merge or cancel.
+ \return 1 if the user wants to merge (choice dialog was shown)
+ \return 0 if there is nothing to merge (no dialog was shown)
+ \return -1 if the user wants to cancel or an error occurred or an issue was presented
+        (message or choice dialog was shown)
+ */
+int Fd_Mergeback::ask_user_to_merge(const std::string &code_filename, const std::string &proj_filename) {
+  if (tag_error) {
+    fl_message("Comparing\n  \"%s\"\nto\n  \"%s\"\n\n"
+               "MergeBack found an error in line %d while reading tags\n"
+               "from the source code. Merging code back is not possible.",
+               code_filename.c_str(), proj_filename.c_str(), line_no);
+    return -1;
+  }
+  if (!num_changed_code && !num_changed_structure) {
+    return 0;
+  }
+  if (num_changed_structure && !num_changed_code) {
+    fl_message("Comparing\n  \"%1$s\"\nto\n  \"%2$s\"\n\n"
+               "MergeBack found %3$d modifications in the project structure\n"
+               "of the source code. These kind of changes can no be\n"
+               "merged back and will be lost when the source code is\n"
+               "generated again from the open project.",
+               code_filename.c_str(), proj_filename.c_str(), num_changed_structure);
+    return -1;
+  }
+  std::string msg = "Comparing\n  \"%1$s\"\nto\n  \"%2$s\"\n\n"
+                  "MergeBack found %3$d modifications in the source code.";
+  if (num_possible_override)
+    msg += "\n\nWARNING: %6$d of these modified blocks appear to also have\n"
+    "changed in the project. Merging will override changes in\n"
+    "the project with changes from the source code file.";
+  if (num_uid_not_found)
+    msg += "\n\nWARNING: for %4$d of these modifications no Type node\n"
+    "can be found and these modification can't be merged back.";
+  if (!num_possible_override && !num_uid_not_found)
+    msg += "\nMerging these changes back appears to be safe.";
+
+  if (num_changed_structure)
+    msg += "\n\nWARNING: %5$d modifications were found in the project\n"
+    "structure. These kind of changes can no be merged back\n"
+    "and will be lost when the source code is generated again\n"
+    "from the open project.";
+
+  if (num_changed_code==num_uid_not_found) {
+    fl_message(msg.c_str(),
+               code_filename.c_str(), proj_filename.c_str(),
+               num_changed_code, num_uid_not_found,
+               num_changed_structure, num_possible_override);
+    return -1;
+  } else {
+    msg +=    "\n\nClick Cancel to abort the MergeBack operation.\n"
+    "Click Merge to merge all code changes back into\n"
+    "the open project.";
+    int c = fl_choice(msg.c_str(), "Cancel", "Merge", NULL,
+                      code_filename.c_str(), proj_filename.c_str(),
+                      num_changed_code, num_uid_not_found,
+                      num_changed_structure, num_possible_override);
+    if (c==0) return -1;
+    return 1;
+  }
+}
+
+/** Analyse the block and its corresponding widget callback.
+ Return findings in num_changed_code, num_changed_code, and num_uid_not_found.
+ */
+void Fd_Mergeback::analyse_callback(unsigned long code_crc, unsigned long tag_crc, int uid) {
+  Fl_Type *tp = Fl_Type::find_by_uid(uid);
+  if (tp && tp->is_true_widget()) {
+    std::string cb = tp->callback(); cb += "\n";
+    unsigned long project_crc = Fd_Code_Writer::block_crc(cb.c_str());
+    // check if the code and project crc are the same, so this modification was already applied
+    if (project_crc!=code_crc) {
+      num_changed_code++;
+      // check if the block change on the project side as well, so we may override changes
+      if (project_crc!=tag_crc) {
+        num_possible_override++;
+      }
+    }
+  } else {
+    num_uid_not_found++;
+    num_changed_code++;
+  }
+}
+
+/** Analyse the block and its corresponding Code Type.
+ Return findings in num_changed_code, num_changed_code, and num_uid_not_found.
+ */
+void Fd_Mergeback::analyse_code(unsigned long code_crc, unsigned long tag_crc, int uid) {
+  Fl_Type *tp = Fl_Type::find_by_uid(uid);
+  if (tp && tp->is_a(ID_Code)) {
+    std::string code = tp->name(); code += "\n";
+    unsigned long project_crc = Fd_Code_Writer::block_crc(code.c_str());
+    // check if the code and project crc are the same, so this modification was already applied
+    if (project_crc!=code_crc) {
+      num_changed_code++;
+      // check if the block change on the project side as well, so we may override changes
+      if (project_crc!=tag_crc) {
+        num_possible_override++;
+      }
+    }
+  } else {
+    num_changed_code++;
+    num_uid_not_found++;
+  }
+}
+
+
+/** Analyse the code file and return findings in class member variables.
+
+ The code file must be open for reading already.
+
+ * tag_error is set if a tag was found, but could not be read
+ * line_no returns the line where an error occurred
+ * num_changed_code is set to the number of changed code blocks in the file.
+   Code changes can be merged back to the project.
+ * num_changed_structure is set to the number of structural changes.
+   Structural changes outside of code blocks can not be read back.
+ * num_uid_not_found number of blocks that were modified, but the corresponding
+   type or widget can not be found in the project
+ * num_possible_override number of blocks that were changed in the code file,
+   but also were changed in the project.
+
+ \return -1 if reading a tag failed, otherwise 0
+ */
+int Fd_Mergeback::analyse() {
+  // initialize local variables
+  unsigned long code_crc = 0;
+  bool line_start = true;
+  char line[1024];
+  // bail if the caller has not opened a file yet
+  if (!code) return 0;
+  // initialize member variables to return our findings
+  line_no = 0;
+  tag_error = 0;
+  num_changed_code = 0;
+  num_changed_structure = 0;
+  num_uid_not_found = 0;
+  num_possible_override = 0;
+  code_crc = 0;
+  // loop through all lines in the code file
+  ::fseek(code, 0, SEEK_SET);
+  for (;;) {
+    // get the next line until end of file
+    if (fgets(line, 1023, code)==0) break;
+    line_no++;
+    const char *tag = strstr(line, "//~fl~");
+    if (!tag) {
+      // if this line has no tag, add the contents to the CRC and continue
+      code_crc = Fd_Code_Writer::block_crc(line, -1, code_crc, &line_start);
+    } else {
+      // if this line has a tag, read all tag data
+      int tag_type = -1, uid = 0;
+      unsigned long tag_crc = 0;
+      int n = sscanf(tag, "//~fl~%d~%04x~%08lx~~", &tag_type, &uid, &tag_crc);
+      if (n!=3 || tag_type<0 || tag_type>FD_TAG_LAST ) { tag_error = 1; return -1; }
+      if (code_crc != tag_crc) {
+        switch (tag_type) {
+          case FD_TAG_GENERIC:
+            num_changed_structure++;
+            break;
+          case FD_TAG_MENU_CALLBACK:
+          case FD_TAG_WIDGET_CALLBACK:
+            analyse_callback(code_crc, tag_crc, uid);
+            break;
+          case FD_TAG_CODE:
+            analyse_code(code_crc, tag_crc, uid);
+            break;
+        }
+      }
+      // reset everything for the next block
+      code_crc = 0;
+      line_start = true;
+    }
+  }
+  return 0;
+}
+
+/** Apply callback mergebacks from the code file to the project.
+ \return 1 if the project changed
+ */
+int Fd_Mergeback::apply_callback(long block_end, long block_start, unsigned long code_crc, int uid) {
+  Fl_Type *tp = Fl_Type::find_by_uid(uid);
+  if (tp && tp->is_true_widget()) {
+    std::string cb = tp->callback(); cb += "\n";
+    unsigned long project_crc = Fd_Code_Writer::block_crc(cb.c_str());
+    if (project_crc!=code_crc) {
+      tp->callback(read_and_unindent_block(block_start, block_end).c_str());
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/** Apply callback mergebacks from the code file to the project.
+ \return 1 if the project changed
+ */
+int Fd_Mergeback::apply_code(long block_end, long block_start, unsigned long code_crc, int uid) {
+  Fl_Type *tp = Fl_Type::find_by_uid(uid);
+  if (tp && tp->is_a(ID_Code)) {
+    std::string cb = tp->name(); cb += "\n";
+    unsigned long project_crc = Fd_Code_Writer::block_crc(cb.c_str());
+    if (project_crc!=code_crc) {
+      tp->name(read_and_unindent_block(block_start, block_end).c_str());
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/** Apply all possible mergebacks from the code file to the project.
+ The code file must be open for reading already.
+ \return -1 if reading a tag failed, 0 if nothing changed, 1 if the project changed
+ */
+int Fd_Mergeback::apply() {
+  // initialize local variables
+  unsigned long code_crc = 0;
+  bool line_start = true;
+  char line[1024];
+  int changed = 0;
+  long block_start = 0;
+  long block_end = 0;
+  // bail if the caller has not opened a file yet
+  if (!code) return 0;
+  // initialize member variables to return our findings
+  line_no = 0;
+  tag_error = 0;
+  code_crc = 0;
+  // loop through all lines in the code file
+  ::fseek(code, 0, SEEK_SET);
+  for (;;) {
+    // get the next line until end of file
+    if (fgets(line, 1023, code)==0) break;
+    line_no++;
+    const char *tag = strstr(line, "//~fl~");
+    if (!tag) {
+      // if this line has no tag, add the contents to the CRC and continue
+      code_crc = Fd_Code_Writer::block_crc(line, -1, code_crc, &line_start);
+      block_end = ::ftell(code);
+    } else {
+      // if this line has a tag, read all tag data
+      int tag_type = -1, uid = 0;
+      unsigned long tag_crc = 0;
+      int n = sscanf(tag, "//~fl~%d~%04x~%08lx~~", &tag_type, &uid, &tag_crc);
+      if (n!=3 || tag_type<0 || tag_type>FD_TAG_LAST ) { tag_error = 1; return -1; }
+      if (code_crc != tag_crc) {
+        if (tag_type==FD_TAG_MENU_CALLBACK || tag_type==FD_TAG_WIDGET_CALLBACK) {
+          changed |= apply_callback(block_end, block_start, code_crc, uid);
+        } else if (tag_type==FD_TAG_CODE) {
+          changed |= apply_code(block_end, block_start, code_crc, uid);
+        }
+      }
+      // reset everything for the next block
+      code_crc = 0;
+      line_start = true;
+      block_start = ::ftell(code);
+    }
+  }
+  return changed;
+}
+
+/** Dispatch the MergeBack into analysis, interactive, or apply directly.
+ \param[in] s source code filename and path
+ \param[in] task one of FD_MERGEBACK_ANALYSE, FD_MERGEBACK_INTERACTIVE,
+            FD_MERGEBACK_APPLY_IF_SAFE, or FD_MERGEBACK_APPLY
+ \return -1 if an error was found in a tag
+ \return -2 if no code file was found
+ \return See more at ::merge_back(const std::string &s, int task).
+ */
+int Fd_Mergeback::merge_back(const std::string &s, const std::string &p, int task) {
+  int ret = 0;
+  code = fl_fopen(s.c_str(), "rb");
+  if (!code) return -2;
+  do { // no actual loop, just make sure we close the code file
+    if (task == FD_MERGEBACK_ANALYSE) {
+      analyse();
+      if (tag_error) {ret = -1; break; }
+      if (num_changed_structure) ret |= 1;
+      if (num_changed_code) ret |= 2;
+      if (num_uid_not_found) ret |= 4;
+      if (num_possible_override) ret |= 8;
+      break;
+    }
+    if (task == FD_MERGEBACK_INTERACTIVE) {
+      analyse();
+      ret = ask_user_to_merge(s, p);
+      if (ret != 1)
+        return ret;
+      task = FD_MERGEBACK_APPLY; // fall through
+    }
+    if (task == FD_MERGEBACK_APPLY_IF_SAFE) {
+      analyse();
+      if (tag_error || num_changed_structure || num_possible_override) {
+        ret = -1;
+        break;
+      }
+      if (num_changed_code==0) {
+        ret = 0;
+        break;
+      }
+      task = FD_MERGEBACK_APPLY; // fall through
+    }
+    if (task == FD_MERGEBACK_APPLY) {
+      ret = apply();
+      if (ret == 1) {
+        set_modflag(1);
+        redraw_browser();
+        load_panel();
+      }
+      ret = 1; // avoid message box in caller
+    }
+  } while (0);
+  fclose(code);
+  code = NULL;
+  return ret;
+}
+
+#endif
+
diff --git a/fluid/app/mergeback.h b/fluid/app/mergeback.h
new file mode 100644
index 000000000..f828e9669
--- /dev/null
+++ b/fluid/app/mergeback.h
@@ -0,0 +1,81 @@
+//
+// MergeBack routines for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+// Matt: disabled
+#if 0
+
+#ifndef _FLUID_MERGEBACK_H
+#define _FLUID_MERGEBACK_H
+
+#include <FL/fl_attr.h>
+
+#include <stdio.h>
+#include <string>
+
+const int FD_TAG_GENERIC = 0;
+const int FD_TAG_CODE = 1;
+const int FD_TAG_MENU_CALLBACK = 2;
+const int FD_TAG_WIDGET_CALLBACK = 3;
+const int FD_TAG_LAST = 3;
+
+const int FD_MERGEBACK_ANALYSE = 0;
+const int FD_MERGEBACK_INTERACTIVE = 1;
+const int FD_MERGEBACK_APPLY = 2;
+const int FD_MERGEBACK_APPLY_IF_SAFE = 3;
+
+/** Class that implements the MergeBack functionality.
+ \see merge_back(const std::string &s, int task)
+ */
+class Fd_Mergeback
+{
+protected:
+  /// Pointer to the C++ code file.
+  FILE *code;
+  /// Current line number in the C++ code file.
+  int line_no;
+  /// Set if there was an error reading a tag.
+  int tag_error;
+  /// Number of code blocks that were different than the CRC in their tag.
+  int num_changed_code;
+  /// Number of generic structure blocks that were different than the CRC in their tag.
+  int num_changed_structure;
+  /// Number of code block that were modified, but a type node by that uid was not found.
+  int num_uid_not_found;
+  /// Number of modified code block where the corresponding project block also changed.
+  int num_possible_override;
+
+  void unindent(char *s);
+  std::string read_and_unindent_block(long start, long end);
+  void analyse_callback(unsigned long code_crc, unsigned long tag_crc, int uid);
+  void analyse_code(unsigned long code_crc, unsigned long tag_crc, int uid);
+  int apply_callback(long block_end, long block_start, unsigned long code_crc, int uid);
+  int apply_code(long block_end, long block_start, unsigned long code_crc, int uid);
+
+public:
+  Fd_Mergeback();
+  ~Fd_Mergeback();
+  int merge_back(const std::string &s, const std::string &p, int task);
+  int ask_user_to_merge(const std::string &s, const std::string &p);
+  int analyse();
+  int apply();
+};
+
+extern int merge_back(const std::string &s, const std::string &p, int task);
+
+
+#endif // _FLUID_MERGEBACK_H
+
+#endif
diff --git a/fluid/app/shell_command.cxx b/fluid/app/shell_command.cxx
new file mode 100644
index 000000000..df71a00f5
--- /dev/null
+++ b/fluid/app/shell_command.cxx
@@ -0,0 +1,1005 @@
+//
+// FLUID main entry for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+// in progress:
+// FLUID comes with example shell commands to build the current project file
+// and run the project. This is accomplished by calling `fltk-config` on the
+// files generated by FLUID, and by calling the executable directly.
+//
+// If the user wants more complex commands, he can add or modify them in the
+// "Shell" settings panel. Modified shell commands are saved with the .fl
+// file.
+
+// The Shell panel has a list of shell commands in the upper half. Under the
+// list are buttons to add, duplicate, and delete shell commands. A popup
+// menu offers import and export functionality and a list of sample scripts.
+// We may want to add up and down buttons, so the user can change the
+// order of commands.
+
+// Selecting any shell command in the list fills in and activates a list of
+// options in the lower half of the panel. Those settings are:
+//  - Name: the name of the shell command in the list
+//  - Label: the label in the pulldown menu (could be the same as name?)
+//  - Shortcut: shortcut key to launch the command
+//  - Storage: where to store this shell command
+//  - Condition: pulldown menu to make the entry conditional for various
+//    target platforms, for example, a "Windows only" entry would only be added
+//    to the Shell menu on a Windows machine. Other options could be:
+//     - Linux only, macOS only, never (to make a list header!?), inactive?
+//  - Command: a multiline input for the actual shell command
+//  - Variables: a pulldown menu that insert variable names like $<sourcefile>
+//  - options to save project, code, and strings before running
+//  - test-run button
+
+// TODO: add @APPDIR@?
+// TODO: get a macro to find `fltk-config` @FLTK_CONFIG@
+// TODO:   add an input field so the user can insert their preferred file and path for fltk-config (user setting)
+//        `fltk-config` is actually tricky to find
+//        for live builds, we could check the program launch directory
+//          if we know where build/Xcode/bin/Debug/fluid is, we
+//          may or may not find ./build/Xcode/fltk-config
+//        on macOS with homebrew, we find /opt/homebrew/bin/fltk-config but the user
+//        can set their own install path.
+//        We can query the shell path, but that requires knowing the users shell (echo $SHELL).
+//        We can run the shell as a login shell with `-l`, so the user $PTH is set: /bin/bash -l -c 'fltk-config'
+//        The shell should output the path of the fltk-config that it found and why it is using that one.
+//        This can also output the fltk-config version.
+// TODO: add a bunch of sensible sample shell commands
+// TODO: when this new feature is used for the very first time, import two or three samples as initial user setting
+// TODO: make the settings dialog resizable
+// TODO: make g_shell_config static, not a pointer, but don't load anything in batch mode
+
+// FEATURE: Fd_Tool_Store icons are currently redundant with @file and @save and could be improved
+// FEATURE: hostname, username, getenv support?
+// FEATURE: add the files ./fluid.prefs and ./fluid.user.prefs as tool locations
+// FEATURE: interpret compiler output, for example: clang, and highlight errors and warnings
+//          `.../shell_command.cxx:71:2: error: test`
+//          `71 | #error test`
+//          `clang++: error: no such file or directory: '.../shell_command.o'`
+//          would make the error message clickable in the shell window and could select the widget,
+//          open the matching editor in the widget panel, and highlight the line in SourceView.
+
+/*
+ Some ideas:
+
+ default shell is in $SHELL on linux and macOS
+
+ On macOS, we can write Apple Scripts:
+
+ #!/usr/bin/env osascript
+ say "@BASENAME@"
+
+ osascript <<EOD
+ say "spark"
+ EOD
+
+  osascript <<EOD
+    tell application "Xcode"
+      build workspace document 1
+    end tell
+  EOD
+
+  powershell -c "$wshell = New-Object -ComObject wscript.shell; $wshell.SendKeys('^{ESCAPE}')
+ */
+
+#include "app/shell_command.h"
+
+#include "app/fluid.h"
+#include "io/file.h"
+#include "panels/settings_panel.h"
+
+#include <FL/Fl_Double_Window.H>
+#include <FL/Fl_Menu_Bar.H>
+#include <FL/fl_message.H>
+#include <FL/fl_string_functions.h>
+
+#include <errno.h>
+
+static std::string fltk_config_cmd;
+static Fl_Process s_proc;
+
+/**
+ See if shell command is running (public)
+ */
+bool shell_command_running() {
+  return s_proc.desc() ? true : false;
+}
+
+/**
+ Reads an entry from the group. A default value must be
+ supplied. The return value indicates if the value was available
+ (non-zero) or the default was used (0).
+
+ \param[in] prefs preference group
+ \param[in] key name of entry
+ \param[out] value returned from preferences or default value if none was set
+ \param[in] defaultValue default value to be used if no preference was set
+ \return 0 if the default value was used
+ */
+char preferences_get(Fl_Preferences &prefs, const char *key, std::string &value, const std::string &defaultValue) {
+  char *v = NULL;
+  char ret = prefs.get(key, v, defaultValue.c_str());
+  value = v;
+  ::free(v);
+  return ret;
+}
+
+/**
+ Sets an entry (name/value pair). The return value indicates if there
+ was a problem storing the data in memory. However it does not
+ reflect if the value was actually stored in the preference file.
+
+ \param[in] prefs preference group
+ \param[in] entry name of entry
+ \param[in] value set this entry to value (stops at the first nul character).
+ \return 0 if setting the value failed
+ */
+char preferences_set(Fl_Preferences &prefs, const char *key, const std::string &value) {
+  return prefs.set(key, value.c_str());
+}
+
+
+/** \class Fl_Process
+ Launch an external shell command.
+ */
+
+/**
+ Create a process manager
+ */
+Fl_Process::Fl_Process() {
+  _fpt= NULL;
+}
+
+/**
+ Destroy the project manager.
+ */
+Fl_Process::~Fl_Process() {
+  // TODO: check what we need to do if a task is still running
+  if (_fpt) close();
+}
+
+/**
+ Open a process.
+
+ \param[in] cmd the shell command that we want to run
+ \param[in] mode "r" or "w" for creating a stream that can read or write
+ \return a stream that is redirected from the shell command stdout
+ */
+FILE * Fl_Process::popen(const char *cmd, const char *mode) {
+#if defined(_WIN32)  && !defined(__CYGWIN__)
+  // PRECONDITIONS
+  if (!mode || !*mode || (*mode!='r' && *mode!='w') ) return NULL;
+  if (_fpt) close(); // close first before reuse
+
+  ptmode = *mode;
+  pin[0] = pin[1] = pout[0] = pout[1] = perr[0] = perr[1] = INVALID_HANDLE_VALUE;
+  // stderr to stdout wanted ?
+  int fusion = (strstr(cmd,"2>&1") !=NULL);
+
+  // Create windows pipes
+  if (!createPipe(pin) || !createPipe(pout) || (!fusion && !createPipe(perr) ) )
+    return freeHandles(); // error
+
+  // Initialize Startup Info
+  ZeroMemory(&si, sizeof(STARTUPINFO));
+  si.cb           = sizeof(STARTUPINFO);
+  si.dwFlags    = STARTF_USESTDHANDLES;
+  si.hStdInput    = pin[0];
+  si.hStdOutput   = pout[1];
+  si.hStdError  = fusion ? pout[1] : perr [1];
+
+  if ( CreateProcess(NULL, (LPTSTR) cmd,NULL,NULL,TRUE,
+                     DETACHED_PROCESS,NULL,NULL, &si, &pi)) {
+    // don't need theses handles inherited by child process:
+    clean_close(pin[0]); clean_close(pout[1]); clean_close(perr[1]);
+    HANDLE & h = *mode == 'r' ? pout[0] : pin[1];
+    _fpt = _fdopen(_open_osfhandle((fl_intptr_t) h,_O_BINARY),mode);
+    h= INVALID_HANDLE_VALUE;  // reset the handle pointer that is shared
+    // with _fpt so we don't free it twice
+  }
+
+  if (!_fpt)  freeHandles();
+  return _fpt;
+#else
+  _fpt=::popen(cmd,mode);
+  return _fpt;
+#endif
+}
+
+/**
+ Close the current process.
+ */
+int Fl_Process::close() {
+#if defined(_WIN32)  && !defined(__CYGWIN__)
+  if (_fpt) {
+    fclose(_fpt);
+    clean_close(perr[0]);
+    clean_close(pin[1]);
+    clean_close(pout[0]);
+    _fpt = NULL;
+    return 0;
+  }
+  return -1;
+#else
+  int ret = ::pclose(_fpt);
+  _fpt=NULL;
+  return ret;
+#endif
+}
+
+/**
+ non-null if file is open.
+
+ \return the current file descriptor of the process' stdout
+ */
+FILE *Fl_Process::desc() const {
+  return _fpt;
+}
+
+/**
+ Receive a single line from the current process.
+
+ \param[out] line buffer to receive the line
+ \param[in] s size of the provided buffer
+ \return NULL if an error occurred, otherwise a pointer to the string
+ */
+char *Fl_Process::get_line(char * line, size_t s) const {
+  return _fpt ? fgets(line, (int)s, _fpt) : NULL;
+}
+
+// returns fileno(FILE*):
+// (file must be open, i.e. _fpt must be non-null)
+// *FIXME* we should find a better solution for the 'fileno' issue
+// non null if file is open
+int Fl_Process::get_fileno() const {
+#ifdef _MSC_VER
+    return _fileno(_fpt); // suppress MSVC warning
+#else
+    return fileno(_fpt);
+#endif
+}
+
+#if defined(_WIN32)  && !defined(__CYGWIN__)
+
+bool Fl_Process::createPipe(HANDLE * h, BOOL bInheritHnd) {
+  SECURITY_ATTRIBUTES sa;
+  sa.nLength = sizeof(sa);
+  sa.lpSecurityDescriptor = NULL;
+  sa.bInheritHandle = bInheritHnd;
+  return CreatePipe (&h[0],&h[1],&sa,0) ? true : false;
+}
+
+FILE *Fl_Process::freeHandles()  {
+  clean_close(pin[0]);    clean_close(pin[1]);
+  clean_close(pout[0]);   clean_close(pout[1]);
+  clean_close(perr[0]);   clean_close(perr[1]);
+  return NULL; // convenient for error management
+}
+
+void Fl_Process::clean_close(HANDLE& h) {
+  if (h!= INVALID_HANDLE_VALUE) CloseHandle(h);
+  h = INVALID_HANDLE_VALUE;
+}
+
+#endif
+
+
+/**
+ Prepare FLUID for running a shell command according to the command flags.
+
+ \param[in] flags set various flags to save the project, code, and string before running the command
+ \return false if the previous command is still running
+ */
+static bool prepare_shell_command(int flags)  {
+//  settings_window->hide();
+  if (s_proc.desc()) {
+    fl_alert("Previous shell command still running!");
+    return false;
+  }
+  if (flags & Fd_Shell_Command::SAVE_PROJECT) {
+    save_cb(0, 0);
+  }
+  if (flags & Fd_Shell_Command::SAVE_SOURCECODE) {
+    write_code_files(true);
+  }
+  if (flags & Fd_Shell_Command::SAVE_STRINGS) {
+    write_strings_cb(0, 0);
+  }
+  return true;
+}
+
+/**
+ Called by the file handler when the command is finished.
+ */
+void shell_proc_done() {
+  shell_run_terminal->append("... END SHELL COMMAND ...\n");
+  shell_run_button->activate();
+  shell_run_window->label("FLUID Shell");
+  fl_beep();
+}
+
+void shell_timer_cb(void*) {
+  if (!s_proc.desc()) {
+    shell_proc_done();
+  } else {
+    Fl::add_timeout(0.25, shell_timer_cb);
+  }
+}
+
+// Support the full piped shell command...
+void shell_pipe_cb(FL_SOCKET, void*) {
+  char  line[1024]="";          // Line from command output...
+
+  if (s_proc.get_line(line, sizeof(line)) != NULL) {
+    // Add the line to the output list...
+    shell_run_terminal->append(line);
+  } else {
+    // End of file; tell the parent...
+    Fl::remove_timeout(shell_timer_cb);
+    Fl::remove_fd(s_proc.get_fileno());
+    s_proc.close();
+    shell_proc_done();
+  }
+}
+
+/** Find the script `fltk-config` that most closely relates to this version of FLUID.
+ This is not implemented yet.
+ */
+//static void find_fltk_config() {
+//
+//}
+
+static void expand_macro(std::string &cmd, const std::string &macro, const std::string &content) {
+  for (int i=0;;) {
+    i = (int)cmd.find(macro, i);
+    if (i==(int)std::string::npos) break;
+    cmd.replace(i, macro.size(), content);
+  }
+}
+
+static void expand_macros(std::string &cmd) {
+  expand_macro(cmd, "@BASENAME@",         g_project.basename());
+  expand_macro(cmd, "@PROJECTFILE_PATH@", g_project.projectfile_path());
+  expand_macro(cmd, "@PROJECTFILE_NAME@", g_project.projectfile_name());
+  expand_macro(cmd, "@CODEFILE_PATH@",    g_project.codefile_path());
+  expand_macro(cmd, "@CODEFILE_NAME@",    g_project.codefile_name());
+  expand_macro(cmd, "@HEADERFILE_PATH@",  g_project.headerfile_path());
+  expand_macro(cmd, "@HEADERFILE_NAME@",  g_project.headerfile_name());
+  expand_macro(cmd, "@TEXTFILE_PATH@",    g_project.stringsfile_path());
+  expand_macro(cmd, "@TEXTFILE_NAME@",    g_project.stringsfile_name());
+//  TODO: implement finding the script `fltk-config` for all platforms
+//  if (cmd.find("@FLTK_CONFIG@") != std::string::npos) {
+//    find_fltk_config();
+//    expand_macro(cmd, "@FLTK_CONFIG@",      fltk_config_cmd.c_str());
+//  }
+  if (cmd.find("@TMPDIR@") != std::string::npos)
+    expand_macro(cmd, "@TMPDIR@",           get_tmpdir());
+}
+
+/**
+ Show the terminal window where it was last positioned.
+ */
+void show_terminal_window() {
+  Fl_Preferences pos(fluid_prefs, "shell_run_Window_pos");
+  int x, y, w, h;
+  pos.get("x", x, -1);
+  pos.get("y", y, 0);
+  pos.get("w", w, 640);
+  pos.get("h", h, 480);
+  if (x!=-1) {
+    shell_run_window->resize(x, y, w, h);
+  }
+  shell_run_window->show();
+}
+
+/**
+ Prepare for and run a shell command.
+
+ \param[in] cmd the command that is sent to `/bin/sh -c ...` or `cmd.exe` on Windows machines
+ \param[in] flags various flags in preparation of the command
+ */
+void run_shell_command(const std::string &cmd, int flags) {
+  if (cmd.empty()) {
+    fl_alert("No shell command entered!");
+    return;
+  }
+
+  if (!prepare_shell_command(flags)) return;
+
+  std::string expanded_cmd = cmd;
+  expand_macros(expanded_cmd);
+
+  if (   ((flags & Fd_Shell_Command::DONT_SHOW_TERMINAL) == 0)
+      && (!shell_run_window->visible()))
+  {
+    show_terminal_window();
+  }
+
+  // Show the output window and clear things...
+  if (flags & Fd_Shell_Command::CLEAR_TERMINAL)
+    shell_run_terminal->printf("\033[2J\033[H");
+  if (flags & Fd_Shell_Command::CLEAR_HISTORY)
+    shell_run_terminal->printf("\033[3J");
+  shell_run_terminal->scrollbar->value(0);
+  shell_run_terminal->printf("\033[0;32m%s\033[0m\n", expanded_cmd.c_str());
+  shell_run_window->label(expanded_cmd.c_str());
+
+  if (s_proc.popen((char *)expanded_cmd.c_str()) == NULL) {
+    shell_run_terminal->printf("\033[1;31mUnable to run shell command: %s\033[0m\n",
+                               strerror(errno));
+    shell_run_window->label("FLUID Shell");
+    return;
+  }
+  shell_run_button->deactivate();
+
+  // if the function below does not for some reason, we will check periodically
+  // to see if the command is done
+  Fl::add_timeout(0.25, shell_timer_cb);
+  // this will tell us when the shell command is done
+  Fl::add_fd(s_proc.get_fileno(), shell_pipe_cb);
+}
+
+/**
+ Create an empty shell command structure.
+ */
+Fd_Shell_Command::Fd_Shell_Command()
+: shortcut(0),
+  storage(FD_STORE_USER),
+  condition(0),
+  flags(0),
+  shell_menu_item_(NULL)
+{
+}
+
+/**
+ Copy the aspects of a shell command dataset into a new shell command.
+
+ \param[in] rhs copy from this prototype
+ */
+Fd_Shell_Command::Fd_Shell_Command(const Fd_Shell_Command *rhs)
+: name(rhs->name),
+  label(rhs->label),
+  shortcut(rhs->shortcut),
+  storage(rhs->storage),
+  condition(rhs->condition),
+  condition_data(rhs->condition_data),
+  command(rhs->command),
+  flags(rhs->flags),
+  shell_menu_item_(NULL)
+{
+}
+
+/**
+ Create a default storage for a shell command and how it is accessible in FLUID.
+
+ \param[in] name is used as a stand-in for the command name and label
+ */
+Fd_Shell_Command::Fd_Shell_Command(const std::string &in_name)
+: name(in_name),
+  label(in_name),
+  shortcut(0),
+  storage(FD_STORE_USER),
+  condition(Fd_Shell_Command::ALWAYS),
+  command("echo \"Hello, FLUID!\""),
+  flags(Fd_Shell_Command::SAVE_PROJECT|Fd_Shell_Command::SAVE_SOURCECODE),
+  shell_menu_item_(NULL)
+{
+}
+
+/**
+ Create a storage for a shell command and how it is accessible in FLUID.
+
+ \param[in] in_name name of this command in the command list in the settings panel
+ \param[in] in_label label text in the main pulldown menu
+ \param[in] in_shortcut a keyboard shortcut that will also appear in the main menu
+ \param[in] in_storage storage location for this command
+ \param[in] in_condition commands can be hidden for certain platforms by setting a condition
+ \param[in] in_condition_data more details for future conditions, i.e. per user, per host, etc.
+ \param[in] in_command the shell command that we want to run
+ \param[in] in_flags some flags to tell FLUID to save the project, code, or strings before running the command
+ */
+Fd_Shell_Command::Fd_Shell_Command(const std::string &in_name,
+                 const std::string &in_label,
+                 Fl_Shortcut in_shortcut,
+                 Fd_Tool_Store in_storage,
+                 int in_condition,
+                 const std::string &in_condition_data,
+                 const std::string &in_command,
+                 int in_flags)
+: name(in_name),
+  label(in_label),
+  shortcut(in_shortcut),
+  storage(in_storage),
+  condition(in_condition),
+  condition_data(in_condition_data),
+  command(in_command),
+  flags(in_flags),
+  shell_menu_item_(NULL)
+{
+}
+
+/**
+ Run this command now.
+
+ Will open the Shell Panel and execute the command if no other command is
+ currently running.
+ */
+void Fd_Shell_Command::run() {
+  if (!command.empty())
+    run_shell_command(command, flags);
+}
+
+/**
+ Update the shell submenu in main menu with the shortcut and a copy of the label.
+ */
+void Fd_Shell_Command::update_shell_menu() {
+  if (shell_menu_item_) {
+    const char *old_label = shell_menu_item_->label();  // can be NULL
+    const char *new_label = label.c_str();              // never NULL
+    if (!old_label || (old_label && strcmp(old_label, new_label))) {
+      if (old_label) ::free((void*)old_label);
+      shell_menu_item_->label(fl_strdup(new_label));
+    }
+    shell_menu_item_->shortcut(shortcut);
+  }
+}
+
+/**
+ Check if the set condition is met.
+
+ \return true if this command appears in the main menu
+ */
+bool Fd_Shell_Command::is_active() {
+  switch (condition) {
+    case ALWAYS: return true;
+    case NEVER: return false;
+#ifdef _WIN32
+    case MAC_ONLY: return false;
+    case UX_ONLY: return false;
+    case WIN_ONLY: return true;
+    case MAC_AND_UX_ONLY: return false;
+#elif defined(__APPLE__)
+    case MAC_ONLY: return true;
+    case UX_ONLY: return false;
+    case WIN_ONLY: return false;
+    case MAC_AND_UX_ONLY: return true;
+#else
+    case MAC_ONLY: return false;
+    case UX_ONLY: return true;
+    case WIN_ONLY: return false;
+    case MAC_AND_UX_ONLY: return true;
+#endif
+    case USER_ONLY: return false; // TODO: get user name
+    case HOST_ONLY: return false; // TODO: get host name
+    case ENV_ONLY: {
+      const char *value = fl_getenv(condition_data.c_str());
+      if (value && *value) return true;
+      return false;
+    }
+  }
+  return false;
+}
+
+void Fd_Shell_Command::read(Fl_Preferences &prefs) {
+  int tmp;
+  preferences_get(prefs, "name", name, "<unnamed>");
+  preferences_get(prefs, "label", label, "<no label>");
+  prefs.get("shortcut", tmp, 0);
+  shortcut = (Fl_Shortcut)tmp;
+  prefs.get("storage", tmp, -1);
+  if (tmp != -1) storage = (Fd_Tool_Store)tmp;
+  prefs.get("condition", condition, ALWAYS);
+  preferences_get(prefs, "condition_data", condition_data, "");
+  preferences_get(prefs, "command", command, "");
+  prefs.get("flags", flags, 0);
+}
+
+void Fd_Shell_Command::write(Fl_Preferences &prefs, bool save_location) {
+  preferences_set(prefs, "name", name);
+  preferences_set(prefs, "label", label);
+  if (shortcut != 0) prefs.set("shortcut", (int)shortcut);
+  if (save_location) prefs.set("storage", (int)storage);
+  if (condition != ALWAYS) prefs.set("condition", condition);
+  if (!condition_data.empty()) preferences_set(prefs, "condition_data", condition_data);
+  if (!command.empty()) preferences_set(prefs, "command", command);
+  if (flags != 0) prefs.set("flags", flags);
+}
+
+void Fd_Shell_Command::read(class Fd_Project_Reader *in) {
+  const char *c = in->read_word(1);
+  if (strcmp(c, "{")!=0) return; // expecting start of group
+  storage = FD_STORE_PROJECT;
+  for (;;) {
+    c = in->read_word(1);
+    if (strcmp(c, "}")==0) break; // end of command list
+    else if (strcmp(c, "name")==0)
+      name = in->read_word();
+    else if (strcmp(c, "label")==0)
+      label = in->read_word();
+    else if (strcmp(c, "shortcut")==0)
+      shortcut = in->read_int();
+    else if (strcmp(c, "condition")==0)
+      condition = in->read_int();
+    else if (strcmp(c, "condition_data")==0)
+      condition_data = in->read_word();
+    else if (strcmp(c, "command")==0)
+      command = in->read_word();
+    else if (strcmp(c, "flags")==0)
+      flags = in->read_int();
+    else
+      in->read_word(); // skip an unknown word
+  }
+}
+
+void Fd_Shell_Command::write(class Fd_Project_Writer *out) {
+  out->write_string("\n  command {");
+  out->write_string("\n    name "); out->write_word(name.c_str());
+  out->write_string("\n    label "); out->write_word(label.c_str());
+  if (shortcut) out->write_string("\n    shortcut %d", shortcut);
+  if (condition) out->write_string("\n    condition %d", condition);
+  if (!condition_data.empty()) {
+    out->write_string("\n    condition_data "); out->write_word(condition_data.c_str());
+  }
+  if (!command.empty()) {
+    out->write_string("\n    command "); out->write_word(command.c_str());
+  }
+  if (flags) out->write_string("\n    flags %d", flags);
+  out->write_string("\n  }");
+}
+
+
+/**
+ Manage a list of shell commands and their parameters.
+ */
+Fd_Shell_Command_List::Fd_Shell_Command_List()
+: list(NULL),
+  list_size(0),
+  list_capacity(0),
+  shell_menu_(NULL)
+{
+}
+
+/**
+ Release all shell commands and destroy this class.
+ */
+Fd_Shell_Command_List::~Fd_Shell_Command_List() {
+  clear();
+}
+
+/**
+ Return the shell command at the given index.
+
+ \param[in] index must be between 0 and list_size-1
+ \return a pointer to the shell command data
+ */
+Fd_Shell_Command *Fd_Shell_Command_List::at(int index) const {
+  return list[index];
+}
+
+/**
+ Clear all shell commands.
+ */
+void Fd_Shell_Command_List::clear() {
+  if (list) {
+    for (int i=0; i<list_size; i++) {
+      delete list[i];
+    }
+    ::free(list);
+    list_size = 0;
+    list_capacity = 0;
+    list = 0;
+  }
+}
+
+/**
+ remove all shell commands of the given storage location from the list.
+ */
+void Fd_Shell_Command_List::clear(Fd_Tool_Store storage) {
+  for (int i=list_size-1; i>=0; i--) {
+    if (list[i]->storage == storage) {
+      remove(i);
+    }
+  }
+}
+
+/**
+ Read shell configuration from a preferences group.
+ */
+void Fd_Shell_Command_List::read(Fl_Preferences &prefs, Fd_Tool_Store storage) {
+  // import the old shell commands from previous user settings
+  if (&fluid_prefs == &prefs) {
+    int version;
+    prefs.get("shell_commands_version", version, 0);
+    if (version == 0) {
+      int save_fl, save_code, save_strings;
+      Fd_Shell_Command *cmd = new Fd_Shell_Command();
+      cmd->storage = FD_STORE_USER;
+      cmd->name = "Sample Shell Command";
+      cmd->label = "Sample Shell Command";
+      cmd->shortcut = FL_ALT+'g';
+      preferences_get(fluid_prefs, "shell_command", cmd->command, "echo \"Sample Shell Command\"");
+      fluid_prefs.get("shell_savefl", save_fl, 1);
+      fluid_prefs.get("shell_writecode", save_code, 1);
+      fluid_prefs.get("shell_writemsgs", save_strings, 0);
+      if (save_fl) cmd->flags |= Fd_Shell_Command::SAVE_PROJECT;
+      if (save_code) cmd->flags |= Fd_Shell_Command::SAVE_SOURCECODE;
+      if (save_strings) cmd->flags |= Fd_Shell_Command::SAVE_STRINGS;
+      add(cmd);
+    }
+    version = 1;
+    prefs.set("shell_commands_version", version);
+  }
+  Fl_Preferences shell_commands(prefs, "shell_commands");
+  int n = shell_commands.groups();
+  for (int i=0; i<n; i++) {
+    Fl_Preferences cmd_prefs(shell_commands, Fl_Preferences::Name(i));
+    Fd_Shell_Command *cmd = new Fd_Shell_Command();
+    cmd->storage = FD_STORE_USER;
+    cmd->read(cmd_prefs);
+    add(cmd);
+  }
+}
+
+/**
+ Write shell configuration to a preferences group.
+ */
+void Fd_Shell_Command_List::write(Fl_Preferences &prefs, Fd_Tool_Store storage) {
+  Fl_Preferences shell_commands(prefs, "shell_commands");
+  shell_commands.delete_all_groups();
+  int index = 0;
+  for (int i=0; i<list_size; i++) {
+    if (list[i]->storage == FD_STORE_USER) {
+      Fl_Preferences cmd(shell_commands, Fl_Preferences::Name(index++));
+      list[i]->write(cmd);
+    }
+  }
+}
+
+/**
+ Read shell configuration from a project file.
+ */
+void Fd_Shell_Command_List::read(Fd_Project_Reader *in) {
+  const char *c = in->read_word(1);
+  if (strcmp(c, "{")!=0) return; // expecting start of group
+  clear(FD_STORE_PROJECT);
+  for (;;) {
+    c = in->read_word(1);
+    if (strcmp(c, "}")==0) break; // end of command list
+    else if (strcmp(c, "command")==0) {
+      Fd_Shell_Command *cmd = new Fd_Shell_Command();
+      add(cmd);
+      cmd->read(in);
+    } else {
+      in->read_word(); // skip an unknown group
+    }
+  }
+}
+
+/**
+ Write shell configuration to a project file.
+ */
+void Fd_Shell_Command_List::write(Fd_Project_Writer *out) {
+  int n_in_project_file = 0;
+  for (int i=0; i<list_size; i++) {
+    if (list[i]->storage == FD_STORE_PROJECT)
+      n_in_project_file++;
+  }
+  if (n_in_project_file > 0) {
+    out->write_string("\nshell_commands {");
+    for (int i=0; i<list_size; i++) {
+      if (list[i]->storage == FD_STORE_PROJECT)
+        list[i]->write(out);
+    }
+    out->write_string("\n}");
+  }
+}
+
+/**
+ Add a previously created shell command to the end of the list.
+
+ \param[in] cmd a pointer to the command that we want to add
+ */
+void Fd_Shell_Command_List::add(Fd_Shell_Command *cmd) {
+  if (list_size == list_capacity) {
+    list_capacity += 16;
+    list = (Fd_Shell_Command**)::realloc(list, list_capacity * sizeof(Fd_Shell_Command*));
+  }
+  list[list_size++] = cmd;
+}
+
+/**
+ Insert a newly created shell command at the given position in the list.
+
+ \param[in] index must be between 0 and list_size-1
+ \param[in] cmd a pointer to the command that we want to add
+ */
+void Fd_Shell_Command_List::insert(int index, Fd_Shell_Command *cmd) {
+  if (list_size == list_capacity) {
+    list_capacity += 16;
+    list = (Fd_Shell_Command**)::realloc(list, list_capacity * sizeof(Fd_Shell_Command*));
+  }
+  ::memmove(list+index+1, list+index, (list_size-index)*sizeof(Fd_Shell_Command**));
+  list_size++;
+  list[index] = cmd;
+}
+
+/**
+ Remove and delete the command at the given index.
+
+ \param[in] index must be between 0 and list_size-1
+ */
+void Fd_Shell_Command_List::remove(int index) {
+  delete list[index];
+  list_size--;
+  ::memmove(list+index, list+index+1, (list_size-index)*sizeof(Fd_Shell_Command**));
+}
+
+/**
+ This is called whenever the user clicks a shell command menu in the main menu.
+
+ \param[in] u cast tp long to get the index of the shell command
+ */
+void menu_shell_cmd_cb(Fl_Widget*, void *u) {
+  long index = (long)(fl_intptr_t)u;
+  g_shell_config->list[index]->run();
+}
+
+/**
+ This is called when the user selects the menu to edit the shell commands.
+ It pops up the setting panel at the shell settings tab.
+ */
+void menu_shell_customize_cb(Fl_Widget*, void*) {
+  settings_window->show();
+  w_settings_tabs->value(w_settings_shell_tab);
+}
+
+/**
+ Rebuild the entire shell submenu from scratch and replace the old menu.
+ */
+void Fd_Shell_Command_List::rebuild_shell_menu() {
+  static Fl_Menu_Item *shell_submenu = NULL;
+  if (!shell_submenu)
+    shell_submenu = (Fl_Menu_Item*)main_menubar->find_item(menu_marker);
+
+  int i, j, num_active_items = 0;
+  // count the active commands
+  for (i=0; i<list_size; i++) {
+    if (list[i]->is_active()) num_active_items++;
+  }
+  // allocate a menu item array
+  Fl_Menu_Item *mi = (Fl_Menu_Item*)::calloc(num_active_items+2, sizeof(Fl_Menu_Item));
+  // set the menu item pointer for all active commands
+  for (i=j=0; i<list_size; i++) {
+    Fd_Shell_Command *cmd = list[i];
+    if (cmd->is_active()) {
+      cmd->shell_menu_item_ = mi + j;
+      mi[j].callback(menu_shell_cmd_cb);
+      mi[j].argument(i);
+      cmd->update_shell_menu();
+      j++;
+    }
+  }
+  if (j>0) mi[j-1].flags |= FL_MENU_DIVIDER;
+  mi[j].label(fl_strdup("Customize..."));
+  mi[j].shortcut(FL_ALT+'x');
+  mi[j].callback(menu_shell_customize_cb);
+  // replace the old menu array with the new one
+  Fl_Menu_Item *mi_old = shell_menu_;
+  shell_menu_ = mi;
+  shell_submenu->user_data(shell_menu_);
+  // free all resources from the old menu
+  if (mi_old && (mi_old != default_menu)) {
+    for (i=0; ; i++) {
+      const char *label = mi_old[i].label();
+      if (!label) break;
+      ::free((void*)label);
+    }
+    ::free(mi_old);
+  }
+}
+
+/**
+ Tell the settings dialog to query this list and update its GUI elements.
+ */
+void Fd_Shell_Command_List::update_settings_dialog() {
+  if (w_settings_shell_tab)
+    w_settings_shell_tab->do_callback(w_settings_shell_tab, LOAD);
+}
+
+/**
+ The default shell submenu in batch mode.
+ */
+Fl_Menu_Item Fd_Shell_Command_List::default_menu[] = {
+  {   "Customize...", FL_ALT+'x', menu_shell_customize_cb },
+  { NULL }
+};
+
+/**
+ Used to find the shell submenu within the main menu tree.
+ */
+void Fd_Shell_Command_List::menu_marker(Fl_Widget*, void*) {
+  // intentionally left empty
+}
+
+/**
+ Export all selected shell commands to an external file.
+
+ Verify that g_shell_config and w_settings_shell_list are not NULL. Open a
+ file chooser and export all items that are selected in w_settings_shell_list
+ into an external file.
+ */
+void Fd_Shell_Command_List::export_selected() {
+  if (!g_shell_config || (g_shell_config->list_size == 0)) return;
+  if (!w_settings_shell_list) return;
+
+  Fl_Native_File_Chooser dialog;
+  dialog.title("Export selected shell commands:");
+  dialog.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);
+  dialog.filter("FLUID Files\t*.flcmd\n");
+  dialog.directory(g_project.projectfile_path().c_str());
+  dialog.preset_file((g_project.basename() + ".flcmd").c_str());
+  if (dialog.show() != 0) return;
+
+  Fl_Preferences file(dialog.filename(), "flcmd.fluid.fltk.org", NULL, (Fl_Preferences::Root)(Fl_Preferences::C_LOCALE|Fl_Preferences::CLEAR));
+  Fl_Preferences shell_commands(file, "shell_commands");
+  int i, index = 0, n = w_settings_shell_list->size();
+  for (i = 0; i < n; i++) {
+    if (w_settings_shell_list->selected(i+1)) {
+      Fl_Preferences cmd(shell_commands, Fl_Preferences::Name(index++));
+      g_shell_config->list[i]->write(cmd, true);
+    }
+  }
+}
+
+/**
+ Import shell commands from an external file and add them to the list.
+
+ Verify that g_shell_config and w_settings_shell_list are not NULL. Open a
+ file chooser and import all items.
+ */
+void Fd_Shell_Command_List::import_from_file() {
+  if (!g_shell_config || (g_shell_config->list_size == 0)) return;
+  if (!w_settings_shell_list) return;
+
+  Fl_Native_File_Chooser dialog;
+  dialog.title("Import shell commands:");
+  dialog.type(Fl_Native_File_Chooser::BROWSE_FILE);
+  dialog.filter("FLUID Files\t*.flcmd\n");
+  dialog.directory(g_project.projectfile_path().c_str());
+  dialog.preset_file((g_project.basename() + ".flcmd").c_str());
+  if (dialog.show() != 0) return;
+
+  Fl_Preferences file(dialog.filename(), "flcmd.fluid.fltk.org", NULL, Fl_Preferences::C_LOCALE);
+  Fl_Preferences shell_commands(file, "shell_commands");
+  int i, n = shell_commands.groups();
+  for (i = 0; i < n; i++) {
+    Fl_Preferences cmd_prefs(shell_commands, Fl_Preferences::Name(i));
+    Fd_Shell_Command *cmd = new Fd_Shell_Command();
+    cmd->storage = FD_STORE_USER;
+    cmd->read(cmd_prefs);
+    g_shell_config->add(cmd);
+  }
+  w_settings_shell_list->do_callback(w_settings_shell_list, LOAD);
+  w_settings_shell_cmd->do_callback(w_settings_shell_cmd, LOAD);
+  w_settings_shell_toolbox->do_callback(w_settings_shell_toolbox, LOAD);
+  g_shell_config->rebuild_shell_menu();
+}
+
+/**
+ A pointer to the list of shell commands if we are not in batch mode.
+ */
+Fd_Shell_Command_List *g_shell_config = NULL;
+
diff --git a/fluid/app/shell_command.h b/fluid/app/shell_command.h
new file mode 100644
index 000000000..b45e2f8cc
--- /dev/null
+++ b/fluid/app/shell_command.h
@@ -0,0 +1,148 @@
+//
+// FLUID main entry for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2023 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#ifndef _FLUID_SHELL_COMMAND_H
+#define _FLUID_SHELL_COMMAND_H
+
+#include "app/fluid.h"
+
+#include <FL/Enumerations.H>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#  include <direct.h>
+#  include <windows.h>
+#  include <io.h>
+#  include <fcntl.h>
+#  include <commdlg.h>
+#  include <FL/platform.H>
+#else
+#  include <unistd.h>
+#endif
+
+struct Fl_Menu_Item;
+class Fl_Widget;
+class Fl_Preferences;
+
+char preferences_get(Fl_Preferences &prefs, const char *key, std::string &value, const std::string &defaultValue);
+char preferences_set(Fl_Preferences &prefs, const char *key, const std::string &value);
+
+void show_terminal_window();
+void run_shell_command(const std::string &cmd, int flags);
+bool shell_command_running(void);
+
+class Fl_Process {
+public:
+  Fl_Process();
+  ~Fl_Process();
+
+  FILE *popen(const char *cmd, const char *mode="r");
+  int  close();
+
+  FILE * desc() const;
+  char * get_line(char * line, size_t s) const;
+
+  int get_fileno() const;
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+protected:
+  HANDLE pin[2], pout[2], perr[2];
+  char ptmode;
+  PROCESS_INFORMATION pi;
+  STARTUPINFO si;
+
+  static bool createPipe(HANDLE * h, BOOL bInheritHnd=TRUE);
+
+private:
+  FILE * freeHandles();
+  static void clean_close(HANDLE& h);
+#endif
+
+protected:
+  FILE * _fpt;
+};
+
+class Fd_Shell_Command {
+public:
+  enum { ALWAYS, NEVER, MAC_ONLY, UX_ONLY, WIN_ONLY, MAC_AND_UX_ONLY, USER_ONLY, HOST_ONLY, ENV_ONLY }; // conditions
+  enum { SAVE_PROJECT = 1, SAVE_SOURCECODE = 2, SAVE_STRINGS = 4, SAVE_ALL = 7,
+    DONT_SHOW_TERMINAL = 8, CLEAR_TERMINAL = 16, CLEAR_HISTORY = 32 }; // flags
+  Fd_Shell_Command();
+  Fd_Shell_Command(const Fd_Shell_Command *rhs);
+  Fd_Shell_Command(const std::string &in_name);
+  Fd_Shell_Command(const std::string &in_name,
+                   const std::string &in_label,
+                   Fl_Shortcut in_shortcut,
+                   Fd_Tool_Store in_storage,
+                   int in_condition,
+                   const std::string &in_condition_data,
+                   const std::string &in_command,
+                   int in_flags);
+  std::string name;
+  std::string label;
+  Fl_Shortcut shortcut;
+  Fd_Tool_Store storage;
+  int condition; // always, hide, windows only, linux only, mac only, user, machine
+  std::string condition_data; // user name, machine name
+  std::string command;
+  int flags; // save_project, save_code, save_string, ...
+  Fl_Menu_Item *shell_menu_item_;
+  void run();
+  void read(Fl_Preferences &prefs);
+  void write(Fl_Preferences &prefs, bool save_location = false);
+  void read(class Fd_Project_Reader*);
+  void write(class Fd_Project_Writer*);
+  void update_shell_menu();
+  bool is_active();
+};
+
+class Fd_Shell_Command_List {
+public:
+  Fd_Shell_Command **list;
+  int list_size;
+  int list_capacity;
+  Fl_Menu_Item *shell_menu_;
+public:
+  Fd_Shell_Command_List();
+  ~Fd_Shell_Command_List();
+  Fd_Shell_Command *at(int index) const;
+  void add(Fd_Shell_Command *cmd);
+  void insert(int index, Fd_Shell_Command *cmd);
+  void remove(int index);
+  void clear();
+  void clear(Fd_Tool_Store store);
+//  void move_up();
+//  void move_down();
+//  int load(const std::string &filename);
+//  int save(const std::string &filename);
+  void read(Fl_Preferences &prefs, Fd_Tool_Store storage);
+  void write(Fl_Preferences &prefs, Fd_Tool_Store storage);
+  void read(class Fd_Project_Reader*);
+  void write(class Fd_Project_Writer*);
+  void rebuild_shell_menu();
+  void update_settings_dialog();
+
+  static Fl_Menu_Item default_menu[];
+  static void menu_marker(Fl_Widget*, void*);
+  static void export_selected();
+  static void import_from_file();
+};
+
+extern Fd_Shell_Command_List *g_shell_config;
+
+#endif // _FLUID_SHELL_COMMAND_H
diff --git a/fluid/app/undo.cxx b/fluid/app/undo.cxx
new file mode 100644
index 000000000..eb5001468
--- /dev/null
+++ b/fluid/app/undo.cxx
@@ -0,0 +1,263 @@
+//
+// FLUID undo support for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2025 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#include "app/undo.h"
+
+#include "app/fluid.h"
+#include "io/file.h"
+#include "nodes/Fl_Type.h"
+#include "nodes/Fl_Widget_Type.h"
+#include "widgets/widget_browser.h"
+
+#include <FL/Fl.H>
+#include <FL/Fl_Window.H>
+#include <FL/Fl_Preferences.H>
+#include <FL/Fl_Menu_Bar.H>
+#include <FL/fl_ask.H>
+#include "tools/fluid_filename.h"
+#include "../src/flstring.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#  include <io.h>
+#  include <windows.h>
+#  define getpid (int)GetCurrentProcessId
+#else
+#  include <unistd.h>
+#endif // _WIN32 && !__CYGWIN__
+
+
+//
+// This file implements an undo system using temporary files; ideally
+// we'd like to do this in memory, however the current data structures
+// and design aren't well-suited...  Instead, we save and restore
+// checkpoint files.
+//
+
+extern Fl_Window* the_panel;
+
+int undo_current = 0;                   // Current undo level in buffer
+int undo_last = 0;                      // Last undo level in buffer
+int undo_max = 0;                       // Maximum undo level used
+int undo_save = -1;                     // Last undo level that was saved
+static int undo_paused = 0;             // Undo checkpointing paused?
+int undo_once_type = 0;                 // Suspend further undos of the same type
+
+
+// Return the undo filename.
+// The filename is constructed in a static internal buffer and
+// this buffer is overwritten by every call of this function.
+// The return value is a pointer to this internal string.
+static char *undo_filename(int level) {
+  static char undo_path[FL_PATH_MAX] = ""; // Undo path
+  static unsigned int undo_path_len = 0;   // length w/o filename
+
+  if (!undo_path_len) {
+    fluid_prefs.getUserdataPath(undo_path, sizeof(undo_path));
+    undo_path_len = (unsigned int)strlen(undo_path);
+  }
+
+  // append filename: "undo_PID_LEVEL.fl"
+  snprintf(undo_path + undo_path_len,
+           sizeof(undo_path) - undo_path_len - 1,
+           "undo_%d_%d.fl", getpid(), level);
+  return undo_path;
+}
+
+
+// Redo menu callback
+void redo_cb(Fl_Widget *, void *) {
+  // int undo_item = main_menubar->find_index(undo_cb);
+  // int redo_item = main_menubar->find_index(redo_cb);
+  undo_once_type = 0;
+
+  if (undo_current >= undo_last) {
+    fl_beep();
+    return;
+  }
+
+  undo_suspend();
+  if (widget_browser) {
+    widget_browser->save_scroll_position();
+    widget_browser->new_list();
+  }
+  int reload_panel = (the_panel && the_panel->visible());
+  if (!read_file(undo_filename(undo_current + 1), 0)) {
+    // Unable to read checkpoint file, don't redo...
+    widget_browser->rebuild();
+    g_project.update_settings_dialog();
+    undo_resume();
+    return;
+  }
+  if (reload_panel) {
+    for (Fl_Type *t = Fl_Type::first; t; t=t->next) {
+      if (t->is_widget() && t->selected)
+        t->open();
+    }
+  }
+  if (widget_browser) widget_browser->restore_scroll_position();
+
+  undo_current ++;
+
+  // Update modified flag...
+  set_modflag(undo_current != undo_save);
+  widget_browser->rebuild();
+  g_project.update_settings_dialog();
+
+  // Update undo/redo menu items...
+  // if (undo_current >= undo_last) Main_Menu[redo_item].deactivate();
+  // Main_Menu[undo_item].activate();
+  undo_resume();
+}
+
+// Undo menu callback
+void undo_cb(Fl_Widget *, void *) {
+  // int undo_item = main_menubar->find_index(undo_cb);
+  // int redo_item = main_menubar->find_index(redo_cb);
+  undo_once_type = 0;
+
+  if (undo_current <= 0) {
+    fl_beep();
+    return;
+  }
+
+  if (undo_current == undo_last) {
+    write_file(undo_filename(undo_current));
+  }
+
+  undo_suspend();
+  // Undo first deletes all widgets which resets the widget_tree browser.
+  // Save the current scroll position, so we don't scroll back to 0 at undo.
+  // TODO: make the scroll position part of the .fl project file
+  if (widget_browser) {
+    widget_browser->save_scroll_position();
+    widget_browser->new_list();
+  }
+  int reload_panel = (the_panel && the_panel->visible());
+  if (!read_file(undo_filename(undo_current - 1), 0)) {
+    // Unable to read checkpoint file, don't undo...
+    widget_browser->rebuild();
+    g_project.update_settings_dialog();
+    set_modflag(0, 0);
+    undo_resume();
+    return;
+  }
+  if (reload_panel) {
+    for (Fl_Type *t = Fl_Type::first; t; t=t->next) {
+      if (t->is_widget() && t->selected) {
+        t->open();
+        break;
+      }
+    }
+  }
+  // Restore old browser position.
+  // Ideally, we would save the browser position inside the undo file.
+  if (widget_browser) widget_browser->restore_scroll_position();
+
+  undo_current --;
+
+  // Update modified flag...
+  set_modflag(undo_current != undo_save);
+
+  // Update undo/redo menu items...
+  // if (undo_current <= 0) Main_Menu[undo_item].deactivate();
+  // Main_Menu[redo_item].activate();
+  widget_browser->rebuild();
+  g_project.update_settings_dialog();
+  undo_resume();
+}
+
+/**
+ \param[in] type set a new type, or set to 0 to clear the once_type without setting a checkpoint
+ \return 1 if the checkpoint was set, 0 if this is a repeating event
+ */
+int undo_checkpoint_once(int type) {
+  if (type == 0) {
+    undo_once_type = 0;
+    return 0;
+  }
+  if (undo_paused) return 0;
+  if (undo_once_type != type) {
+    undo_checkpoint();
+    undo_once_type = type;
+    return 1;
+  } else {
+    // do not add more checkpoints for the same undo type
+    return 0;
+  }
+}
+
+// Save current file to undo buffer
+void undo_checkpoint() {
+  //  printf("undo_checkpoint(): undo_current=%d, undo_paused=%d, modflag=%d\n",
+  //         undo_current, undo_paused, modflag);
+
+  // Don't checkpoint if undo_suspend() has been called...
+  if (undo_paused) return;
+
+  // int undo_item = main_menubar->find_index(undo_cb);
+  // int redo_item = main_menubar->find_index(redo_cb);
+  undo_once_type = 0;
+
+  // Save the current UI to a checkpoint file...
+  const char *filename = undo_filename(undo_current);
+  if (!write_file(filename)) {
+    // Don't attempt to do undo stuff if we can't write a checkpoint file...
+    perror(filename);
+    return;
+  }
+
+  // Update the saved level...
+  if (modflag && undo_current <= undo_save) undo_save = -1;
+  else if (!modflag) undo_save = undo_current;
+
+  // Update the current undo level...
+  undo_current ++;
+  undo_last = undo_current;
+  if (undo_current > undo_max) undo_max = undo_current;
+
+  // Enable the Undo and disable the Redo menu items...
+  // Main_Menu[undo_item].activate();
+  // Main_Menu[redo_item].deactivate();
+}
+
+// Clear undo buffer
+void undo_clear() {
+  // int undo_item = main_menubar->find_index(undo_cb);
+  // int redo_item = main_menubar->find_index(redo_cb);
+  // Remove old checkpoint files...
+  for (int i = 0; i <= undo_max; i ++) {
+    fl_unlink(undo_filename(i));
+  }
+
+  // Reset current, last, and save indices...
+  undo_current = undo_last = undo_max = 0;
+  if (modflag) undo_save = -1;
+  else undo_save = 0;
+
+  // Disable the Undo and Redo menu items...
+  // Main_Menu[undo_item].deactivate();
+  // Main_Menu[redo_item].deactivate();
+}
+
+// Resume undo checkpoints
+void undo_resume() {
+  undo_paused--;
+}
+
+// Suspend undo checkpoints
+void undo_suspend() {
+  undo_paused++;
+}
diff --git a/fluid/app/undo.h b/fluid/app/undo.h
new file mode 100644
index 000000000..e8ffab891
--- /dev/null
+++ b/fluid/app/undo.h
@@ -0,0 +1,37 @@
+//
+// FLUID undo definitions for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2025 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file.  If this
+// file is missing or damaged, see the license at:
+//
+//     https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+//     https://www.fltk.org/bugs.php
+//
+
+#ifndef undo_h
+#define undo_h
+
+class Fl_Widget;
+
+#define kUndoWindowResize 1
+
+extern int undo_current;                // Current undo level in buffer
+extern int undo_last;                   // Last undo level in buffer
+extern int undo_save;                   // Last undo level that was saved
+extern int undo_once_type;              // Suspend further undos of the same type
+
+void redo_cb(Fl_Widget *, void *);      // Redo menu callback
+void undo_cb(Fl_Widget *, void *);      // Undo menu callback
+void undo_checkpoint();                 // Save current file to undo buffer
+int undo_checkpoint_once(int type);     // Save undo buffer once until a different checkpoint type is called
+void undo_clear();                      // Clear undo buffer
+void undo_resume();                     // Resume undo checkpoints
+void undo_suspend();                    // Suspend undo checkpoints
+
+#endif // !undo_h