Initial commit.

This has working door.
Has -1 (idle timeout) and working time_left
countdown.

Needs -2 (hangup/connection lost) and
need -3 (time limit exceeded).

CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 3.2)
+
+# zf_log target (required)
+set(HEADERS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(HEADERS door.h)
+set(SOURCES door.cpp ansicolor.cpp lines.cpp panel.cpp anyoption.cpp)
+
+# add_subdirectory(opendoors)
+
+###########
+# Debug or Release
+###########
+if (NOT CMAKE_BUILD_TYPE)
+  ## set default to Debug
+  set(CMAKE_BUILD_TYPE Debug)  # override with -DCMAKE_BUILD_TYPE=Release
+  message("==> CMAKE_BUILD_TYPE empty. Changing it to Debug.")
+else()
+  message("==> CMAKE_BUILD_TYPE == ${CMAKE_BUILD_TYPE}.")
+endif()
+
+## https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html
+## During Debug, use debug version of libstdc++ (asserts on access to invalid iterators, etc!)
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+
+##############
+# C++ Standard
+##############
+set(CMAKE_CXX_STANDARD   14)
+# set(CMAKE_CXX_STANDARD   17)
+set(CMAKE_CXX_EXTENSIONS ON)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
+
+if(MSVC)
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4 /WX")
+else()
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror -pedantic-errors")
+endif()
+
+add_library(door++ ${HEADERS} ${SOURCES})
+
+# target_link_libraries(door++ pthread)
+
+target_include_directories(door++ PUBLIC $<BUILD_INTERFACE:${HEADERS_DIR}>)
+
+if(ZF_LOG_LIBRARY_PREFIX)
+	target_compile_definitions(door++ PRIVATE "ZF_LOG_LIBRARY_PREFIX=${ZF_LOG_LIBRARY_PREFIX}")
+endif()
+

LICENSE_anyoption

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kishan Thomas www.hackorama.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ansicolor.cpp

@@ -0,0 +1,275 @@
+#include "door.h"
+#include <string>
+
+namespace door {
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with sensible defaults (White on Black).
+ *
+ */
+ANSIColor::ANSIColor()
+    : fg(COLOR::WHITE), bg(COLOR::BLACK), reset(0), bold(0), blink(0),
+      inverse(0) {}
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with attribute set.
+ *
+ * @param a ATTR
+ */
+ANSIColor::ANSIColor(ATTR a) : ANSIColor() { Attr(a); }
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with a foreground color.
+ *
+ * @param f COLOR
+ */
+ANSIColor::ANSIColor(COLOR f) : ANSIColor() { fg = f; }
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with a foreground color and attribute.
+ *
+ * @param f COLOR
+ * @param a ATTR
+ */
+ANSIColor::ANSIColor(COLOR f, ATTR a) : ANSIColor() {
+  fg = f;
+  Attr(a);
+}
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with a foreground color and attributes.
+ *
+ * @param f COLOR
+ * @param a1 ATTR
+ * @param a2 ATTR
+ */
+ANSIColor::ANSIColor(COLOR f, ATTR a1, ATTR a2) : ANSIColor() {
+  fg = f;
+  Attr(a1);
+  Attr(a2);
+}
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with a foreground and background color.
+ *
+ * @param f COLOR
+ * @param b COLOR
+ */
+ANSIColor::ANSIColor(COLOR f, COLOR b) : ANSIColor() {
+  fg = f;
+  bg = b;
+}
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with a foreground color, background color,
+ * and attribute.
+ *
+ * @param f COLOR
+ * @param b COLOR
+ * @param a ATTR
+ */
+ANSIColor::ANSIColor(COLOR f, COLOR b, ATTR a) : ANSIColor() {
+  fg = f;
+  bg = b;
+  Attr(a);
+}
+
+/**
+ * Construct a new ANSIColor::ANSIColor object
+ * with foreground, background color and attributes.
+ *
+ * @param f COLOR
+ * @param b COLOR
+ * @param a1 ATTR
+ * @param a2 ATTR
+ */
+ANSIColor::ANSIColor(COLOR f, COLOR b, ATTR a1, ATTR a2) : ANSIColor() {
+  fg = f;
+  bg = b;
+  Attr(a1);
+  Attr(a2);
+}
+
+/**
+ * Set attribute.  We return the object so
+ * calls can be chained.
+ *
+ * @param a ATTR
+ * @return ANSIColor&
+ */
+ANSIColor &ANSIColor::Attr(ATTR a) {
+  switch (a) {
+  case ATTR::RESET:
+    reset = 1;
+    break;
+  case ATTR::BOLD:
+    bold = 1;
+    break;
+  case ATTR::BLINK:
+    blink = 1;
+    break;
+  case ATTR::INVERSE:
+    inverse = 1;
+    break;
+  }
+  return *this;
+}
+
+/**
+ * Equal operator.
+ *
+ * This compares colors and attributes, but ignores reset.
+ *
+ * @param c const ANSIColor &
+ * @return bool
+ */
+bool ANSIColor::operator==(const ANSIColor &c) const {
+  return ((fg == c.fg) and (bg == c.bg) and (bold == c.bold) and
+          (blink == c.blink) and (inverse == c.inverse));
+}
+
+/**
+ * Not-equal operator.
+ *
+ * This compares colors and attributes, but ignores reset.
+ *
+ * @param c const ANSIColor &
+ * @return bool
+ */
+bool ANSIColor::operator!=(const ANSIColor &c) const {
+  return !((fg == c.fg) and (bg == c.bg) and (bold == c.bold) and
+           (blink == c.blink) and (inverse == c.inverse));
+}
+
+/**
+ * Output the full ANSI codes for attributes and color.
+ * This does not look at the previous values.
+ */
+std::string ANSIColor::output(void) const {
+  std::string clr(CSI);
+
+  // check for special cases
+  if (reset and fg == COLOR::BLACK and bg == COLOR::BLACK) {
+    clr += "0m";
+    return clr;
+  }
+
+  if (reset) {
+    clr += "0;";
+  }
+  if (bold) {
+    clr += "1;";
+  } else {
+    if (!reset)
+      clr += "0;";
+  }
+  clr += std::to_string(30 + (int)fg) + ";";
+  clr += std::to_string(40 + (int)bg) + "m";
+  return clr;
+}
+
+/**
+ * Output only what ANSI attributes and colors have changed.
+ * This uses the previous ANSIColor value to determine what
+ * has changed.
+ *
+ * This sets previous to the current upon completion.
+ */
+std::string ANSIColor::output(ANSIColor &previous) const {
+  std::string clr(CSI);
+  // color output optimization
+
+  // check for special cases
+  if (reset and fg == COLOR::BLACK and bg == COLOR::BLACK) {
+    clr += "0m";
+    previous = *this;
+    return clr;
+  }
+
+  if (reset) {
+    // current has RESET, so default to always sending colors.
+    clr = output();
+    previous = *this;
+    return clr;
+  }
+
+  if (*this == previous) {
+    clr.clear();
+    return clr;
+  }
+
+  // resume "optimization"
+  if (bold != previous.bold) {
+    // not the same, so handle this.
+    if (bold) {
+      clr += "1;";
+      if (fg != previous.fg)
+        clr += std::to_string((int)fg + 30) + ";";
+      if (bg != previous.bg)
+        clr += std::to_string((int)bg + 40) + ";";
+    } else {
+      clr += "0;";
+      // RESET to turn OFF BOLD, clears previous
+      if (fg != COLOR::WHITE)
+        clr += std::to_string((int)fg + 30) + ";";
+      if (bg != COLOR::BLACK)
+        clr += std::to_string((int)bg + 40) + ";";
+    }
+  } else {
+    if (fg != previous.fg)
+      clr += std::to_string((int)fg + 30) + ";";
+    if (bg != previous.bg)
+      clr += std::to_string((int)bg + 40) + ";";
+  };
+
+  // Remove ';' if last character
+  std::string::iterator si = clr.end() - 1;
+  if (*si == ';') {
+    clr.erase(si);
+  }
+
+  if (clr.compare(CSI) == 0)
+    clr.clear();
+  else
+    clr += "m";
+
+  // final step, set previous to current and return the string;
+  previous = *this;
+  return clr;
+};
+
+/**
+ * This converts ANSI \ref COLOR and \ref ATTR to ANSI codes
+ * understood by the \ref Door output class.
+ */
+std::ostream &operator<<(std::ostream &os, const ANSIColor &c) {
+  std::string out;
+
+  Door *d = dynamic_cast<Door *>(&os);
+  if (d != nullptr) {
+    d->track = false;
+    out = c.output(d->previous);
+    // if (!out.empty())
+    if (out.compare("\x1b[") == 0)
+      std::abort();
+
+    *d << out;
+    d->track = true;
+  } else {
+    // "dumb" version that can't remember anything/ doesn't optimize color
+    // output.
+    std::string out = c.output();
+    os << out;
+  }
+  return os;
+}
+
+ANSIColor reset(ATTR::RESET);
+
+} // namespace door

anyoption.cpp

@@ -0,0 +1,1007 @@
+/*
+ * AnyOption 1.3
+ *
+ * kishan at hackorama dot com  www.hackorama.com JULY 2001
+ *
+ * + Acts as a common facade class for reading
+ *   command line options as well as options from
+ *   an option file with delimited type value pairs
+ *
+ * + Handles the POSIX style single character options ( -w )
+ *   as well as the newer GNU long options ( --width )
+ *
+ * + The option file assumes the traditional format of
+ *   first character based comment lines and type value
+ *   pairs with a delimiter , and flags which are not pairs
+ *
+ *  	# this is a comment
+ *  	# next line is an option value pair
+ *  	width : 100
+ *     	# next line is a flag
+ *      noimages
+ *
+ * + Supports printing out Help and Usage
+ *
+ * + Why not just use getopt() ?
+ *
+ *   getopt() Its a POSIX standard not part of ANSI-C.
+ *   So it may not be available on platforms like Windows.
+ *
+ * + Why it is so long ?
+ *
+ *   The actual code which does command line parsing
+ *   and option file parsing are done in  few methods.
+ *   Most of the extra code are for providing a flexible
+ *   common public interface to both a resource file
+ *   and command line supporting POSIX style and
+ *   GNU long option as well as mixing of both.
+ *
+ * + Please see "anyoption.h" for public method descriptions
+ *
+ */
+
+/* Updated August 2004
+ * Fix from  Michael D Peters (mpeters at sandia.gov)
+ * to remove static local variables, allowing multiple instantiations
+ * of the reader (for using multiple configuration files).  There is
+ * an error in the destructor when using multiple instances, so you
+ * cannot delete your objects (it will crash), but not calling the
+ * destructor only introduces a small memory leak, so I
+ * have not bothered tracking it down.
+ *
+ * Also updated to use modern C++ style headers, rather than
+ * deprecated iostream.h (it was causing my compiler problems)
+ */
+
+/*
+ * Updated September 2006
+ * Fix from Boyan Asenov for a bug in mixing up option indexes
+ * leading to exception when mixing different options types
+ */
+
+#include "anyoption.h"
+
+AnyOption::AnyOption() { init(); }
+
+AnyOption::AnyOption(int maxopt) { init(maxopt, maxopt); }
+
+AnyOption::AnyOption(int maxopt, int maxcharopt) { init(maxopt, maxcharopt); }
+
+AnyOption::~AnyOption() {
+  if (mem_allocated)
+    cleanup();
+}
+
+void AnyOption::init() { init(DEFAULT_MAXOPTS, DEFAULT_MAXOPTS); }
+
+void AnyOption::init(int maxopt, int maxcharopt) {
+
+  max_options = maxopt;
+  max_char_options = maxcharopt;
+  max_usage_lines = DEFAULT_MAXUSAGE;
+  usage_lines = 0;
+  argc = 0;
+  argv = NULL;
+  posix_style = true;
+  verbose = false;
+  filename = NULL;
+  appname = NULL;
+  option_counter = 0;
+  optchar_counter = 0;
+  new_argv = NULL;
+  new_argc = 0;
+  max_legal_args = 0;
+  command_set = false;
+  file_set = false;
+  values = NULL;
+  g_value_counter = 0;
+  mem_allocated = false;
+  opt_prefix_char = '-';
+  file_delimiter_char = ':';
+  file_comment_char = '#';
+  equalsign = '=';
+  comment = '#';
+  delimiter = ':';
+  endofline = '\n';
+  whitespace = ' ';
+  nullterminate = '\0';
+  set = false;
+  once = true;
+  hasoptions = false;
+  autousage = false;
+  print_usage = false;
+  print_help = false;
+
+  strcpy(long_opt_prefix, "--");
+
+  if (alloc() == false) {
+    cout << endl << "OPTIONS ERROR : Failed allocating memory";
+    cout << endl;
+    cout << "Exiting." << endl;
+    exit(0);
+  }
+}
+
+bool AnyOption::alloc() {
+  int i = 0;
+  int size = 0;
+
+  if (mem_allocated)
+    return true;
+
+  size = (max_options + 1) * sizeof(const char *);
+  options = (const char **)malloc(size);
+  optiontype = (int *)malloc((max_options + 1) * sizeof(int));
+  optionindex = (int *)malloc((max_options + 1) * sizeof(int));
+  if (options == NULL || optiontype == NULL || optionindex == NULL)
+    return false;
+  else
+    mem_allocated = true;
+  for (i = 0; i < max_options; i++) {
+    options[i] = NULL;
+    optiontype[i] = 0;
+    optionindex[i] = -1;
+  }
+  optionchars = (char *)malloc((max_char_options + 1) * sizeof(char));
+  optchartype = (int *)malloc((max_char_options + 1) * sizeof(int));
+  optcharindex = (int *)malloc((max_char_options + 1) * sizeof(int));
+  if (optionchars == NULL || optchartype == NULL || optcharindex == NULL) {
+    mem_allocated = false;
+    return false;
+  }
+  for (i = 0; i < max_char_options; i++) {
+    optionchars[i] = '0';
+    optchartype[i] = 0;
+    optcharindex[i] = -1;
+  }
+
+  size = (max_usage_lines + 1) * sizeof(const char *);
+  usage = (const char **)malloc(size);
+
+  if (usage == NULL) {
+    mem_allocated = false;
+    return false;
+  }
+  for (i = 0; i < max_usage_lines; i++)
+    usage[i] = NULL;
+
+  return true;
+}
+
+void AnyOption::allocValues(int index, size_t length) {
+  if (values[index] == NULL) {
+    values[index] = (char *)malloc(length);
+  } else {
+    free(values[index]);
+    values[index] = (char *)malloc(length);
+  }
+}
+
+bool AnyOption::doubleOptStorage() {
+  const char **options_saved = options;
+  options = (const char **)realloc(options, ((2 * max_options) + 1) *
+                                                sizeof(const char *));
+  if (options == NULL) {
+    free(options_saved);
+    return false;
+  }
+  int *optiontype_saved = optiontype;
+  optiontype =
+      (int *)realloc(optiontype, ((2 * max_options) + 1) * sizeof(int));
+  if (optiontype == NULL) {
+    free(optiontype_saved);
+    return false;
+  }
+  int *optionindex_saved = optionindex;
+  optionindex =
+      (int *)realloc(optionindex, ((2 * max_options) + 1) * sizeof(int));
+  if (optionindex == NULL) {
+    free(optionindex_saved);
+    return false;
+  }
+  /* init new storage */
+  for (int i = max_options; i < 2 * max_options; i++) {
+    options[i] = NULL;
+    optiontype[i] = 0;
+    optionindex[i] = -1;
+  }
+  max_options = 2 * max_options;
+  return true;
+}
+
+bool AnyOption::doubleCharStorage() {
+  char *optionchars_saved = optionchars;
+  optionchars =
+      (char *)realloc(optionchars, ((2 * max_char_options) + 1) * sizeof(char));
+  if (optionchars == NULL) {
+    free(optionchars_saved);
+    return false;
+  }
+  int *optchartype_saved = optchartype;
+  optchartype =
+      (int *)realloc(optchartype, ((2 * max_char_options) + 1) * sizeof(int));
+  if (optchartype == NULL) {
+    free(optchartype_saved);
+    return false;
+  }
+  int *optcharindex_saved = optcharindex;
+  optcharindex =
+      (int *)realloc(optcharindex, ((2 * max_char_options) + 1) * sizeof(int));
+  if (optcharindex == NULL) {
+    free(optcharindex_saved);
+    return false;
+  }
+  /* init new storage */
+  for (int i = max_char_options; i < 2 * max_char_options; i++) {
+    optionchars[i] = '0';
+    optchartype[i] = 0;
+    optcharindex[i] = -1;
+  }
+  max_char_options = 2 * max_char_options;
+  return true;
+}
+
+bool AnyOption::doubleUsageStorage() {
+  const char **usage_saved = usage;
+  usage = (const char **)realloc(usage, ((2 * max_usage_lines) + 1) *
+                                            sizeof(const char *));
+  if (usage == NULL) {
+    free(usage_saved);
+    return false;
+  }
+  for (int i = max_usage_lines; i < 2 * max_usage_lines; i++)
+    usage[i] = NULL;
+  max_usage_lines = 2 * max_usage_lines;
+  return true;
+}
+
+void AnyOption::cleanup() {
+  free(options);
+  free(optiontype);
+  free(optionindex);
+  free(optionchars);
+  free(optchartype);
+  free(optcharindex);
+  free(usage);
+  if (values != NULL) {
+    for (int i = 0; i < g_value_counter; i++) {
+      free(values[i]);
+      values[i] = NULL;
+    }
+    free(values);
+  }
+  if (new_argv != NULL)
+    free(new_argv);
+}
+
+void AnyOption::setCommandPrefixChar(char _prefix) {
+  opt_prefix_char = _prefix;
+}
+
+void AnyOption::setCommandLongPrefix(const char *_prefix) {
+  if (strlen(_prefix) > MAX_LONG_PREFIX_LENGTH) {
+    strncpy(long_opt_prefix, _prefix, MAX_LONG_PREFIX_LENGTH);
+    long_opt_prefix[MAX_LONG_PREFIX_LENGTH] = nullterminate;
+  } else {
+    strcpy(long_opt_prefix, _prefix);
+  }
+}
+
+void AnyOption::setFileCommentChar(char _comment) {
+  file_delimiter_char = _comment;
+}
+
+void AnyOption::setFileDelimiterChar(char _delimiter) {
+  file_comment_char = _delimiter;
+}
+
+bool AnyOption::CommandSet() const { return (command_set); }
+
+bool AnyOption::FileSet() const { return (file_set); }
+
+void AnyOption::noPOSIX() { posix_style = false; }
+
+bool AnyOption::POSIX() const { return posix_style; }
+
+void AnyOption::setVerbose() { verbose = true; }
+
+void AnyOption::printVerbose() const {
+  if (verbose)
+    cout << endl;
+}
+void AnyOption::printVerbose(const char *msg) const {
+  if (verbose)
+    cout << msg;
+}
+
+void AnyOption::printVerbose(char *msg) const {
+  if (verbose)
+    cout << msg;
+}
+
+void AnyOption::printVerbose(char ch) const {
+  if (verbose)
+    cout << ch;
+}
+
+bool AnyOption::hasOptions() const { return hasoptions; }
+
+void AnyOption::autoUsagePrint(bool _autousage) { autousage = _autousage; }
+
+void AnyOption::useCommandArgs(int _argc, char **_argv) {
+  argc = _argc;
+  argv = _argv;
+  command_set = true;
+  appname = argv[0];
+  if (argc > 1)
+    hasoptions = true;
+}
+
+void AnyOption::useFiileName(const char *_filename) {
+  filename = _filename;
+  file_set = true;
+}
+
+/*
+ * set methods for options
+ */
+
+void AnyOption::setCommandOption(const char *opt) {
+  addOption(opt, COMMAND_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setCommandOption(char opt) {
+  addOption(opt, COMMAND_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setCommandOption(const char *opt, char optchar) {
+  addOption(opt, COMMAND_OPT);
+  addOption(optchar, COMMAND_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setCommandFlag(const char *opt) {
+  addOption(opt, COMMAND_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setCommandFlag(char opt) {
+  addOption(opt, COMMAND_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setCommandFlag(const char *opt, char optchar) {
+  addOption(opt, COMMAND_FLAG);
+  addOption(optchar, COMMAND_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setFileOption(const char *opt) {
+  addOption(opt, FILE_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setFileOption(char opt) {
+  addOption(opt, FILE_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setFileOption(const char *opt, char optchar) {
+  addOption(opt, FILE_OPT);
+  addOption(optchar, FILE_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setFileFlag(const char *opt) {
+  addOption(opt, FILE_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setFileFlag(char opt) {
+  addOption(opt, FILE_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setFileFlag(const char *opt, char optchar) {
+  addOption(opt, FILE_FLAG);
+  addOption(optchar, FILE_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setOption(const char *opt) {
+  addOption(opt, COMMON_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setOption(char opt) {
+  addOption(opt, COMMON_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setOption(const char *opt, char optchar) {
+  addOption(opt, COMMON_OPT);
+  addOption(optchar, COMMON_OPT);
+  g_value_counter++;
+}
+
+void AnyOption::setFlag(const char *opt) {
+  addOption(opt, COMMON_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setFlag(const char opt) {
+  addOption(opt, COMMON_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::setFlag(const char *opt, char optchar) {
+  addOption(opt, COMMON_FLAG);
+  addOption(optchar, COMMON_FLAG);
+  g_value_counter++;
+}
+
+void AnyOption::addOption(const char *opt, int type) {
+  if (option_counter >= max_options) {
+    if (doubleOptStorage() == false) {
+      addOptionError(opt);
+      return;
+    }
+  }
+  options[option_counter] = opt;
+  optiontype[option_counter] = type;
+  optionindex[option_counter] = g_value_counter;
+  option_counter++;
+}
+
+void AnyOption::addOption(char opt, int type) {
+  if (!POSIX()) {
+    printVerbose("Ignoring the option character \"");
+    printVerbose(opt);
+    printVerbose("\" ( POSIX options are turned off )");
+    printVerbose();
+    return;
+  }
+
+  if (optchar_counter >= max_char_options) {
+    if (doubleCharStorage() == false) {
+      addOptionError(opt);
+      return;
+    }
+  }
+  optionchars[optchar_counter] = opt;
+  optchartype[optchar_counter] = type;
+  optcharindex[optchar_counter] = g_value_counter;
+  optchar_counter++;
+}
+
+void AnyOption::addOptionError(const char *opt) const {
+  cout << endl;
+  cout << "OPTIONS ERROR : Failed allocating extra memory " << endl;
+  cout << "While adding the option : \"" << opt << "\"" << endl;
+  cout << "Exiting." << endl;
+  cout << endl;
+  exit(0);
+}
+
+void AnyOption::addOptionError(char opt) const {
+  cout << endl;
+  cout << "OPTIONS ERROR : Failed allocating extra memory " << endl;
+  cout << "While adding the option: \"" << opt << "\"" << endl;
+  cout << "Exiting." << endl;
+  cout << endl;
+  exit(0);
+}
+
+void AnyOption::processOptions() {
+  if (!valueStoreOK())
+    return;
+}
+
+void AnyOption::processCommandArgs(int max_args) {
+  max_legal_args = max_args;
+  processCommandArgs();
+}
+
+void AnyOption::processCommandArgs(int _argc, char **_argv, int max_args) {
+  max_legal_args = max_args;
+  processCommandArgs(_argc, _argv);
+}
+
+void AnyOption::processCommandArgs(int _argc, char **_argv) {
+  useCommandArgs(_argc, _argv);
+  processCommandArgs();
+}
+
+void AnyOption::processCommandArgs() {
+  if (!(valueStoreOK() && CommandSet()))
+    return;
+
+  if (max_legal_args == 0)
+    max_legal_args = argc;
+  new_argv = (int *)malloc((max_legal_args + 1) * sizeof(int));
+  for (int i = 1; i < argc; i++) { /* ignore first argv */
+    if (argv[i][0] == long_opt_prefix[0] &&
+        argv[i][1] == long_opt_prefix[1]) { /* long GNU option */
+      int match_at = parseGNU(argv[i] + 2); /* skip -- */
+      if (match_at >= 0 && i < argc - 1)    /* found match */
+        setValue(options[match_at], argv[++i]);
+    } else if (argv[i][0] == opt_prefix_char) { /* POSIX char */
+      if (POSIX()) {
+        char ch = parsePOSIX(argv[i] + 1); /* skip - */
+        if (ch != '0' && i < argc - 1)     /* matching char */
+          setValue(ch, argv[++i]);
+      } else { /* treat it as GNU option with a - */
+        int match_at = parseGNU(argv[i] + 1); /* skip - */
+        if (match_at >= 0 && i < argc - 1)    /* found match */
+          setValue(options[match_at], argv[++i]);
+      }
+    } else { /* not option but an argument keep index */
+      if (new_argc < max_legal_args) {
+        new_argv[new_argc] = i;
+        new_argc++;
+      } else { /* ignore extra arguments */
+        printVerbose("Ignoring extra argument: ");
+        printVerbose(argv[i]);
+        printVerbose();
+        printAutoUsage();
+      }
+      printVerbose("Unknown command argument option : ");
+      printVerbose(argv[i]);
+      printVerbose();
+      printAutoUsage();
+    }
+  }
+}
+
+char AnyOption::parsePOSIX(char *arg) {
+
+  for (unsigned int i = 0; i < strlen(arg); i++) {
+    char ch = arg[i];
+    if (matchChar(ch)) { /* keep matching flags till an option */
+      /*if last char argv[++i] is the value */
+      if (i == strlen(arg) - 1) {
+        return ch;
+      } else { /* else the rest of arg is the value */
+        i++;   /* skip any '=' and ' ' */
+        while (arg[i] == whitespace || arg[i] == equalsign)
+          i++;
+        setValue(ch, arg + i);
+        return '0';
+      }
+    }
+  }
+  printVerbose("Unknown command argument option : ");
+  printVerbose(arg);
+  printVerbose();
+  printAutoUsage();
+  return '0';
+}
+
+int AnyOption::parseGNU(char *arg) {
+  size_t split_at = 0;
+  /* if has a '=' sign get value */
+  for (size_t i = 0; i < strlen(arg); i++) {
+    if (arg[i] == equalsign) {
+      split_at = i;    /* store index */
+      i = strlen(arg); /* get out of loop */
+    }
+  }
+  if (split_at > 0) { /* it is an option value pair */
+    char *tmp = (char *)malloc((split_at + 1) * sizeof(char));
+    for (size_t i = 0; i < split_at; i++)
+      tmp[i] = arg[i];
+    tmp[split_at] = '\0';
+
+    if (matchOpt(tmp) >= 0) {
+      setValue(options[matchOpt(tmp)], arg + split_at + 1);
+      free(tmp);
+    } else {
+      printVerbose("Unknown command argument option : ");
+      printVerbose(arg);
+      printVerbose();
+      printAutoUsage();
+      free(tmp);
+      return -1;
+    }
+  } else { /* regular options with no '=' sign  */
+    return matchOpt(arg);
+  }
+  return -1;
+}
+
+int AnyOption::matchOpt(char *opt) {
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], opt) == 0) {
+      if (optiontype[i] == COMMON_OPT ||
+          optiontype[i] == COMMAND_OPT) { /* found option return index */
+        return i;
+      } else if (optiontype[i] == COMMON_FLAG ||
+                 optiontype[i] == COMMAND_FLAG) { /* found flag, set it */
+        setFlagOn(opt);
+        return -1;
+      }
+    }
+  }
+  printVerbose("Unknown command argument option : ");
+  printVerbose(opt);
+  printVerbose();
+  printAutoUsage();
+  return -1;
+}
+bool AnyOption::matchChar(char c) {
+  for (int i = 0; i < optchar_counter; i++) {
+    if (optionchars[i] == c) { /* found match */
+      if (optchartype[i] == COMMON_OPT ||
+          optchartype[i] ==
+              COMMAND_OPT) { /* an option store and stop scanning */
+        return true;
+      } else if (optchartype[i] == COMMON_FLAG ||
+                 optchartype[i] ==
+                     COMMAND_FLAG) { /* a flag store and keep scanning */
+        setFlagOn(c);
+        return false;
+      }
+    }
+  }
+  printVerbose("Unknown command argument option : ");
+  printVerbose(c);
+  printVerbose();
+  printAutoUsage();
+  return false;
+}
+
+bool AnyOption::valueStoreOK() {
+  if (!set) {
+    if (g_value_counter > 0) {
+      const int size = g_value_counter * sizeof(char *);
+      values = (char **)malloc(size);
+      for (int i = 0; i < g_value_counter; i++)
+        values[i] = NULL;
+      set = true;
+    }
+  }
+  return set;
+}
+
+/*
+ * public get methods
+ */
+char *AnyOption::getValue(const char *option) {
+  if (!valueStoreOK())
+    return NULL;
+
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], option) == 0)
+      return values[optionindex[i]];
+  }
+  return NULL;
+}
+
+bool AnyOption::getFlag(const char *option) {
+  if (!valueStoreOK())
+    return false;
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], option) == 0)
+      return findFlag(values[optionindex[i]]);
+  }
+  return false;
+}
+
+char *AnyOption::getValue(char option) {
+  if (!valueStoreOK())
+    return NULL;
+  for (int i = 0; i < optchar_counter; i++) {
+    if (optionchars[i] == option)
+      return values[optcharindex[i]];
+  }
+  return NULL;
+}
+
+bool AnyOption::getFlag(char option) {
+  if (!valueStoreOK())
+    return false;
+  for (int i = 0; i < optchar_counter; i++) {
+    if (optionchars[i] == option)
+      return findFlag(values[optcharindex[i]]);
+  }
+  return false;
+}
+
+bool AnyOption::findFlag(char *val) {
+  if (val == NULL)
+    return false;
+
+  if (strcmp(TRUE_FLAG, val) == 0)
+    return true;
+
+  return false;
+}
+
+/*
+ * private set methods
+ */
+bool AnyOption::setValue(const char *option, char *value) {
+  if (!valueStoreOK())
+    return false;
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], option) == 0) {
+      size_t length = (strlen(value) + 1) * sizeof(char);
+      allocValues(optionindex[i], length);
+      strncpy(values[optionindex[i]], value, length);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AnyOption::setFlagOn(const char *option) {
+  if (!valueStoreOK())
+    return false;
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], option) == 0) {
+      size_t length = (strlen(TRUE_FLAG) + 1) * sizeof(char);
+      allocValues(optionindex[i], length);
+      strncpy(values[optionindex[i]], TRUE_FLAG, length);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AnyOption::setValue(char option, char *value) {
+  if (!valueStoreOK())
+    return false;
+  for (int i = 0; i < optchar_counter; i++) {
+    if (optionchars[i] == option) {
+      size_t length = (strlen(value) + 1) * sizeof(char);
+      allocValues(optcharindex[i], length);
+      strncpy(values[optcharindex[i]], value, length);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AnyOption::setFlagOn(char option) {
+  if (!valueStoreOK())
+    return false;
+  for (int i = 0; i < optchar_counter; i++) {
+    if (optionchars[i] == option) {
+      size_t length = (strlen(TRUE_FLAG) + 1) * sizeof(char);
+      allocValues(optcharindex[i], length);
+      strncpy(values[optcharindex[i]], TRUE_FLAG, length);
+      return true;
+    }
+  }
+  return false;
+}
+
+int AnyOption::getArgc() const { return new_argc; }
+
+char *AnyOption::getArgv(int index) const {
+  if (index < new_argc) {
+    return (argv[new_argv[index]]);
+  }
+  return NULL;
+}
+
+/* option file sub routines */
+
+bool AnyOption::processFile() {
+  if (!(valueStoreOK() && FileSet()))
+    return false;
+  return hasoptions = (consumeFile(readFile()));
+}
+
+bool AnyOption::processFile(const char *_filename) {
+  useFiileName(_filename);
+  return (processFile());
+}
+
+char *AnyOption::readFile() { return (readFile(filename)); }
+
+/*
+ * read the file contents to a character buffer
+ */
+
+char *AnyOption::readFile(const char *fname) {
+  char *buffer;
+  ifstream is;
+  is.open(fname, ifstream::in);
+  if (!is.good()) {
+    is.close();
+    return NULL;
+  }
+  is.seekg(0, ios::end);
+  size_t length = (size_t)is.tellg();
+  is.seekg(0, ios::beg);
+  buffer = (char *)malloc((length + 1) * sizeof(char));
+  is.read(buffer, length);
+  is.close();
+  buffer[length] = nullterminate;
+  return buffer;
+}
+
+/*
+ * scans a char* buffer for lines that does not
+ * start with the specified comment character.
+ */
+bool AnyOption::consumeFile(char *buffer) {
+
+  if (buffer == NULL)
+    return false;
+
+  char *cursor = buffer; /* preserve the ptr */
+  char *pline = NULL;
+  int linelength = 0;
+  bool newline = true;
+  for (unsigned int i = 0; i < strlen(buffer); i++) {
+    if (*cursor == endofline) { /* end of line */
+      if (pline != NULL)        /* valid line */
+        processLine(pline, linelength);
+      pline = NULL;
+      newline = true;
+    } else if (newline) { /* start of line */
+      newline = false;
+      if ((*cursor != comment)) { /* not a comment */
+        pline = cursor;
+        linelength = 0;
+      }
+    }
+    cursor++; /* keep moving */
+    linelength++;
+  }
+  free(buffer);
+  return true;
+}
+
+/*
+ *  find a valid type value pair separated by a delimiter
+ *  character and pass it to valuePairs()
+ *  any line which is not valid will be considered a value
+ *  and will get passed on to justValue()
+ *
+ *  assuming delimiter is ':' the behaviour will be,
+ *
+ *  width:10    - valid pair valuePairs( width, 10 );
+ *  width : 10  - valid pair valuepairs( width, 10 );
+ *
+ *  ::::        - not valid
+ *  width       - not valid
+ *  :10         - not valid
+ *  width:      - not valid
+ *  ::          - not valid
+ *  :           - not valid
+ *
+ */
+
+void AnyOption::processLine(char *theline, int length) {
+  char *pline = (char *)malloc((length + 1) * sizeof(char));
+  for (int i = 0; i < length; i++)
+    pline[i] = *(theline++);
+  pline[length] = nullterminate;
+  char *cursor = pline; /* preserve the ptr */
+  if (*cursor == delimiter || *(cursor + length - 1) == delimiter) {
+    justValue(pline); /* line with start/end delimiter */
+  } else {
+    bool found = false;
+    for (int i = 1; i < length - 1 && !found; i++) { /* delimiter */
+      if (*cursor == delimiter) {
+        *(cursor - 1) = nullterminate; /* two strings */
+        found = true;
+        valuePairs(pline, cursor + 1);
+      }
+      cursor++;
+    }
+    cursor++;
+    if (!found) /* not a pair */
+      justValue(pline);
+  }
+  free(pline);
+}
+
+/*
+ * removes trailing and preceding white spaces from a string
+ */
+char *AnyOption::chomp(char *str) {
+  while (*str == whitespace)
+    str++;
+  char *end = str + strlen(str) - 1;
+  while (*end == whitespace)
+    end--;
+  *(end + 1) = nullterminate;
+  return str;
+}
+
+void AnyOption::valuePairs(char *type, char *value) {
+  if (strlen(chomp(type)) == 1) { /* this is a char option */
+    for (int i = 0; i < optchar_counter; i++) {
+      if (optionchars[i] == type[0]) { /* match */
+        if (optchartype[i] == COMMON_OPT || optchartype[i] == FILE_OPT) {
+          setValue(type[0], chomp(value));
+          return;
+        }
+      }
+    }
+  }
+  /* if no char options matched */
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], type) == 0) { /* match */
+      if (optiontype[i] == COMMON_OPT || optiontype[i] == FILE_OPT) {
+        setValue(type, chomp(value));
+        return;
+      }
+    }
+  }
+  printVerbose("Unknown option in resource file : ");
+  printVerbose(type);
+  printVerbose();
+}
+
+void AnyOption::justValue(char *type) {
+
+  if (strlen(chomp(type)) == 1) { /* this is a char option */
+    for (int i = 0; i < optchar_counter; i++) {
+      if (optionchars[i] == type[0]) { /* match */
+        if (optchartype[i] == COMMON_FLAG || optchartype[i] == FILE_FLAG) {
+          setFlagOn(type[0]);
+          return;
+        }
+      }
+    }
+  }
+  /* if no char options matched */
+  for (int i = 0; i < option_counter; i++) {
+    if (strcmp(options[i], type) == 0) { /* match */
+      if (optiontype[i] == COMMON_FLAG || optiontype[i] == FILE_FLAG) {
+        setFlagOn(type);
+        return;
+      }
+    }
+  }
+  printVerbose("Unknown option in resource file : ");
+  printVerbose(type);
+  printVerbose();
+}
+
+/*
+ * usage and help
+ */
+
+void AnyOption::printAutoUsage() {
+  if (autousage)
+    printUsage();
+}
+
+void AnyOption::printUsage() {
+
+  if (once) {
+    once = false;
+    cout << endl;
+    for (int i = 0; i < usage_lines; i++)
+      cout << usage[i] << endl;
+    cout << endl;
+  }
+}
+
+void AnyOption::addUsage(const char *line) {
+  if (usage_lines >= max_usage_lines) {
+    if (doubleUsageStorage() == false) {
+      addUsageError(line);
+      exit(1);
+    }
+  }
+  usage[usage_lines] = line;
+  usage_lines++;
+}
+
+void AnyOption::addUsageError(const char *line) {
+  cout << endl;
+  cout << "OPTIONS ERROR : Failed allocating extra memory " << endl;
+  cout << "While adding the usage/help  : \"" << line << "\"" << endl;
+  cout << "Exiting." << endl;
+  cout << endl;
+  exit(0);
+}

anyoption.h

@@ -0,0 +1,272 @@
+#ifndef _ANYOPTION_H
+#define _ANYOPTION_H
+
+#define _CRT_SECURE_NO_WARNINGS /* Microsoft C/C++ Compiler: Disable C4996     \
+                                   warnings for security-enhanced CRT          \
+                                   functions */
+
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+
+#define COMMON_OPT 1
+#define COMMAND_OPT 2
+#define FILE_OPT 3
+#define COMMON_FLAG 4
+#define COMMAND_FLAG 5
+#define FILE_FLAG 6
+
+#define COMMAND_OPTION_TYPE 1
+#define COMMAND_FLAG_TYPE 2
+#define FILE_OPTION_TYPE 3
+#define FILE_FLAG_TYPE 4
+#define UNKNOWN_TYPE 5
+
+#define DEFAULT_MAXOPTS 10
+#define MAX_LONG_PREFIX_LENGTH 2
+
+#define DEFAULT_MAXUSAGE 3
+#define DEFAULT_MAXHELP 10
+
+#define TRUE_FLAG "true"
+
+using namespace std;
+
+class AnyOption {
+
+public: /* the public interface */
+  AnyOption();
+
+  explicit AnyOption(int maxoptions);
+  explicit AnyOption(int maxoptions, int maxcharoptions);
+  ~AnyOption();
+
+  /*
+   * following set methods specifies the
+   * special characters and delimiters
+   * if not set traditional defaults will be used
+   */
+
+  void setCommandPrefixChar(char _prefix);    /* '-' in "-w" */
+  void setCommandLongPrefix(const char *_prefix); /* '--' in "--width" */
+  void setFileCommentChar(char _comment);     /* '#' in shell scripts */
+  void setFileDelimiterChar(char _delimiter); /* ':' in "width : 100" */
+
+  /*
+   * provide the input for the options
+   * like argv[] for commnd line and the
+   * option file name  to use;
+   */
+
+  void useCommandArgs(int _argc, char **_argv);
+  void useFiileName(const char *_filename);
+
+  /*
+   * turn off the POSIX style options
+   * this means anything starting with a '-' or "--"
+   * will be considered a valid option
+   * which also means you cannot add a bunch of
+   * POIX options chars together like "-lr"  for "-l -r"
+   *
+   */
+
+  void noPOSIX();
+
+  /*
+   * prints warning verbose if you set anything wrong
+   */
+  void setVerbose();
+
+  /*
+   * there are two types of options
+   *
+   * Option - has an associated value ( -w 100 )
+   * Flag  - no value, just a boolean flag  ( -nogui )
+   *
+   * the options can be either a string ( GNU style )
+   * or a character ( traditional POSIX style )
+   * or both ( --width, -w )
+   *
+   * the options can be common to the command line and
+   * the option file, or can belong only to either of
+   * command line and option file
+   *
+   * following set methods, handle all the above
+   * cases of options.
+   */
+
+  /* options command to command line and option file */
+  void setOption(const char *opt_string);
+  void setOption(char opt_char);
+  void setOption(const char *opt_string, char opt_char);
+  void setFlag(const char *opt_string);
+  void setFlag(char opt_char);
+  void setFlag(const char *opt_string, char opt_char);
+
+  /* options read from command line only */
+  void setCommandOption(const char *opt_string);
+  void setCommandOption(char opt_char);
+  void setCommandOption(const char *opt_string, char opt_char);
+  void setCommandFlag(const char *opt_string);
+  void setCommandFlag(char opt_char);
+  void setCommandFlag(const char *opt_string, char opt_char);
+
+  /* options read from an option file only  */
+  void setFileOption(const char *opt_string);
+  void setFileOption(char opt_char);
+  void setFileOption(const char *opt_string, char opt_char);
+  void setFileFlag(const char *opt_string);
+  void setFileFlag(char opt_char);
+  void setFileFlag(const char *opt_string, char opt_char);
+
+  /*
+   * process the options, registered using
+   * useCommandArgs() and useFileName();
+   */
+  void processOptions();
+  void processCommandArgs();
+  void processCommandArgs(int max_args);
+  bool processFile();
+
+  /*
+   * process the specified options
+   */
+  void processCommandArgs(int _argc, char **_argv);
+  void processCommandArgs(int _argc, char **_argv, int max_args);
+  bool processFile(const char *_filename);
+
+  /*
+   * get the value of the options
+   * will return NULL if no value is set
+   */
+  char *getValue(const char *_option);
+  bool getFlag(const char *_option);
+  char *getValue(char _optchar);
+  bool getFlag(char _optchar);
+
+  /*
+   * Print Usage
+   */
+  void printUsage();
+  void printAutoUsage();
+  void addUsage(const char *line);
+  void printHelp();
+  /* print auto usage printing for unknown options or flag */
+  void autoUsagePrint(bool flag);
+
+  /*
+   * get the argument count and arguments sans the options
+   */
+  int getArgc() const;
+  char *getArgv(int index) const;
+  bool hasOptions() const;
+
+private:                /* the hidden data structure */
+  int argc;             /* command line arg count  */
+  char **argv;          /* commnd line args */
+  const char *filename; /* the option file */
+  char *appname;        /* the application name from argv[0] */
+
+  int *new_argv;      /* arguments sans options (index to argv) */
+  int new_argc;       /* argument count sans the options */
+  int max_legal_args; /* ignore extra arguments */
+
+  /* option strings storage + indexing */
+  int max_options;      /* maximum number of options */
+  const char **options; /* storage */
+  int *optiontype;      /* type - common, command, file */
+  int *optionindex;     /* index into value storage */
+  int option_counter;   /* counter for added options  */
+
+  /* option chars storage + indexing */
+  int max_char_options; /* maximum number options */
+  char *optionchars;    /*  storage */
+  int *optchartype;     /* type - common, command, file */
+  int *optcharindex;    /* index into value storage */
+  int optchar_counter;  /* counter for added options  */
+
+  /* values */
+  char **values;       /* common value storage */
+  int g_value_counter; /* globally updated value index LAME! */
+
+  /* help and usage */
+  const char **usage;  /* usage */
+  int max_usage_lines; /* max usage lines reserved */
+  int usage_lines;     /* number of usage lines */
+
+  bool command_set;   /* if argc/argv were provided */
+  bool file_set;      /* if a filename was provided */
+  bool mem_allocated; /* if memory allocated in init() */
+  bool posix_style;   /* enables to turn off POSIX style options */
+  bool verbose;       /* silent|verbose */
+  bool print_usage;   /* usage verbose */
+  bool print_help;    /* help verbose */
+
+  char opt_prefix_char;                             /*  '-' in "-w" */
+  char long_opt_prefix[MAX_LONG_PREFIX_LENGTH + 1]; /* '--' in "--width" */
+  char file_delimiter_char;                         /* ':' in width : 100 */
+  char file_comment_char; /*  '#' in "#this is a comment" */
+  char equalsign;
+  char comment;
+  char delimiter;
+  char endofline;
+  char whitespace;
+  char nullterminate;
+
+  bool set;  // was static member
+  bool once; // was static member
+
+  bool hasoptions;
+  bool autousage;
+
+private: /* the hidden utils */
+  void init();
+  void init(int maxopt, int maxcharopt);
+  bool alloc();
+  void allocValues(int index, size_t length);
+  void cleanup();
+  bool valueStoreOK();
+
+  /* grow storage arrays as required */
+  bool doubleOptStorage();
+  bool doubleCharStorage();
+  bool doubleUsageStorage();
+
+  bool setValue(const char *option, char *value);
+  bool setFlagOn(const char *option);
+  bool setValue(char optchar, char *value);
+  bool setFlagOn(char optchar);
+
+  void addOption(const char *option, int type);
+  void addOption(char optchar, int type);
+  void addOptionError(const char *opt) const;
+  void addOptionError(char opt) const;
+  bool findFlag(char *value);
+  void addUsageError(const char *line);
+  bool CommandSet() const;
+  bool FileSet() const;
+  bool POSIX() const;
+
+  char parsePOSIX(char *arg);
+  int parseGNU(char *arg);
+  bool matchChar(char c);
+  int matchOpt(char *opt);
+
+  /* dot file methods */
+  char *readFile();
+  char *readFile(const char *fname);
+  bool consumeFile(char *buffer);
+  void processLine(char *theline, int length);
+  char *chomp(char *str);
+  void valuePairs(char *type, char *value);
+  void justValue(char *value);
+
+  void printVerbose(const char *msg) const;
+  void printVerbose(char *msg) const;
+  void printVerbose(char ch) const;
+  void printVerbose() const;
+};
+
+#endif /* ! _ANYOPTION_H */

door.cpp

@@ -0,0 +1,961 @@
+#include "door.h"
+#include <algorithm>
+#include <chrono>
+#include <ctype.h>
+#include <string.h>
+#include <string>
+#include <thread>
+
+#include <libgen.h> // basename
+
+// time/date output std::put_time()
+// https://en.cppreference.com/w/cpp/io/manip/put_time
+#include <ctime>
+#include <iomanip>
+
+// alarm signal
+#include <signal.h>
+#include <unistd.h>
+
+#include <iconv.h>
+
+#include <algorithm>
+#include <iostream>
+
+void to_lower(std::string &text) {
+  transform(text.begin(), text.end(), text.begin(), ::tolower);
+}
+
+namespace door {
+
+static bool hangup = false;
+
+void sig_handler(int signal) {
+  hangup = true;
+  ofstream sigf;
+  sigf.open("signal.log", std::ofstream::out | std::ofstream::app);
+
+  sigf << "SNAP! GOT: " << signal << std::endl;
+  sigf.close();
+  // 13 SIGPIPE -- ok, what do I do with this, eh?
+}
+
+class IConv {
+  iconv_t ic;
+
+public:
+  IConv(const char *to, const char *from);
+  ~IConv();
+
+  int convert(char *input, char *output, size_t outbufsize);
+};
+
+IConv::IConv(const char *to, const char *from) : ic(iconv_open(to, from)) {}
+IConv::~IConv() { iconv_close(ic); }
+
+int IConv::convert(char *input, char *output, size_t outbufsize) {
+  size_t inbufsize = strlen(input);
+  // size_t orig_size = outbufsize;
+  // memset(output, 0, outbufsize);
+  // https://www.gnu.org/savannah-checkouts/gnu/libiconv/documentation/libiconv-1.15/iconv.3.html
+  int r = iconv(ic, &input, &inbufsize, &output, &outbufsize);
+  *output = 0;
+  return r;
+}
+
+static IConv converter("UTF-8", "CP437");
+
+void cp437toUnicode(std::string input, std::string &out) {
+  char buffer[10240];
+  char output[16384];
+
+  strcpy(buffer, input.c_str());
+  converter.convert(buffer, output, sizeof(output));
+  out.assign(output);
+}
+
+void cp437toUnicode(const char *input, std::string &out) {
+  char buffer[10240];
+  char output[16384];
+
+  strcpy(buffer, input);
+  converter.convert(buffer, output, sizeof(output));
+  out.assign(output);
+}
+
+bool unicode = false;
+
+/**
+ * Construct a new Door object using the commandline parameters
+ * given to the main function.
+ *
+ * @example door_example.cpp
+ */
+Door::Door(std::string dname, int argc, char *argv[])
+    : std::ostream(this), doorname{dname}, has_dropfile{false},
+      seconds_elapsed{0}, previous(COLOR::WHITE), track{true}, cx{1}, cy{1},
+      inactivity{120}, node{1} {
+
+  // Setup commandline options
+  opt.addUsage("Door++ library by BUGZ (C) 2021");
+  opt.addUsage("");
+  opt.addUsage(" -h  --help                 Displays this help");
+  opt.addUsage(" -l  --local                Local Mode");
+  opt.addUsage(" -d  --dropfile [FILENAME]  Load Dropfile");
+  opt.addUsage(" -n  --node N               Set node number");
+  // opt.addUsage(" -b  --bbsname NAME         Set BBS Name");
+  opt.addUsage(" -u  --username NAME        Set Username");
+  opt.addUsage(" -t  --timeleft N           Set time left");
+  opt.addUsage("     --maxtime N            Set max time");
+  opt.addUsage("");
+  opt.setFlag("help", 'h');
+  opt.setFlag("local", 'l');
+  opt.setOption("dropfile", 'd');
+  // opt.setOption("bbsname", 'b');
+  opt.setOption("username", 'u');
+  opt.setOption("timeleft", 't');
+  opt.setOption("maxtime");
+
+  opt.processCommandArgs(argc, argv);
+
+  if (!opt.hasOptions()) {
+    opt.printUsage();
+    exit(1);
+  }
+
+  if (opt.getFlag("help") || opt.getFlag('h')) {
+    opt.printUsage();
+    exit(1);
+  }
+
+  if (opt.getValue("username") != nullptr) {
+    username = opt.getValue("username");
+  }
+
+  if (opt.getValue("node") != nullptr) {
+    node = atoi(opt.getValue("node"));
+  }
+
+  if (opt.getValue("timeleft") != nullptr) {
+    time_left = atoi(opt.getValue("timeleft"));
+  } else {
+    // sensible default
+    time_left = 25;
+  }
+
+  /*
+  if (opt.getValue("bbsname") != nullptr) {
+    bbsname = opt.getValue("bbsname");
+  }
+  */
+
+  parse_dropfile(opt.getValue("dropfile"));
+
+  /*
+  If the dropfile has time_left, we'll use it.
+
+  Adjust time_left by maxtime value (if given).
+   */
+
+  if (opt.getValue("maxtime") != nullptr) {
+    int maxtime = atoi(opt.getValue("maxtime"));
+    if (time_left > maxtime) {
+      logf << "Adjusting time from " << time_left << " to " << maxtime
+           << std::endl;
+      time_left = maxtime;
+    }
+  }
+
+  if (opt.getFlag("local")) {
+    if (username.empty()) {
+      std::cout << "Local mode requires username to be set." << std::endl;
+      opt.printUsage();
+      exit(1);
+    }
+  } else {
+    // we must have a dropfile, or else!
+    if (!has_dropfile) {
+      std::cout << "I require a dropfile.  And a shrubbery." << std::endl;
+      opt.printUsage();
+      exit(1);
+    }
+  }
+
+  // Set program name
+  // strcpy(od_control.od_prog_name, dname.c_str());
+  // od_prog_copyright, od_prog_version
+  std::string logFileName = dname + ".log";
+  logf.open(logFileName.c_str(), std::ofstream::out | std::ofstream::app);
+
+  log("Door init");
+  // strcpy(od_control.od_logfile_name, logFileName.c_str());
+  // Initialize Door
+  //  od_init();
+
+  init();
+
+  // door.sys doesn't give BBS name. system_name
+  detect_unicode_and_screen();
+  logf << "Screen " << width << " X " << height << std::endl;
+}
+
+Door::~Door() {
+  // od_exit(0, FALSE);
+
+  // alarm(0);
+  // signal(SIGALRM, SIG_DFL);
+
+  // restore default mode
+  // tcsetattr(STDIN_FILENO, TCSANOW, &tio_default);
+  tcsetattr(STDIN_FILENO, TCOFLUSH, &tio_default);
+  logf.close();
+  signal(SIGHUP, SIG_DFL);
+  signal(SIGPIPE, SIG_DFL);
+
+  // time thread
+  stop_thread.set_value();
+  time_thread.join();
+}
+
+// https://www.tutorialspoint.com/how-do-i-terminate-a-thread-in-cplusplus11
+
+void Door::time_thread_run(std::future<void> future) {
+  while (future.wait_for(std::chrono::milliseconds(1)) ==
+         std::future_status::timeout) {
+    // std::cout << "Executing the thread....." << std::endl;
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    seconds_elapsed++;
+    // logf << "TICK " << seconds_elapsed << std::endl;
+    if (seconds_elapsed % 60 == 0) {
+      time_left--;
+    }
+  }
+}
+
+void Door::init(void) {
+  // https://viewsourcecode.org/snaptoken/kilo/02.enteringRawMode.html
+  // https://viewsourcecode.org/snaptoken/kilo/03.rawInputAndOutput.html
+  // ok!  I didn't know about VTIME !  That's something different!
+
+  // enable terminal RAW mode
+  struct termios tio_raw;
+  tcgetattr(STDIN_FILENO, &tio_default);
+  tio_raw = tio_default;
+  cfmakeraw(&tio_raw);
+  // local terminal magic
+  tio_raw.c_cc[VMIN] = 0;
+  tio_raw.c_cc[VTIME] = 1;
+
+  bpos = 0;
+  tcsetattr(STDIN_FILENO, TCSANOW, &tio_raw);
+
+  startup = std::time(nullptr);
+  signal(SIGHUP, sig_handler);
+  signal(SIGPIPE, sig_handler);
+
+  // time thread
+  std::future<void> stop_future = stop_thread.get_future();
+  time_thread =
+      std::thread(&Door::time_thread_run, this, std::move(stop_future));
+}
+
+void Door::detect_unicode_and_screen(void) {
+  unicode = false;
+  width = 0;
+  height = 0;
+
+  if (!isatty(STDIN_FILENO)) {
+    // https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode
+    *this << "\377\375\042\377\373\001"; // fix telnet client
+  }
+
+  *this << "\x1b[0;30;40m;\x1b[2J\x1b[H"; // black on black, clrscr, go home
+  *this << "\u2615"
+        << "\x1b[6n";                   // hot beverage + cursor pos
+  *this << "\x1b[999C\x1b[999B\x1b[6n"; // goto end of screen + cursor pos
+  *this << "\x1b[H";                    // go home
+
+  this->flush();
+  usleep(1000 * 1000);
+
+  if (haskey()) {
+    char buffer[101];
+    int len;
+    len = read(STDIN_FILENO, &buffer, sizeof(buffer) - 1);
+    // logf << "read " << len << std::endl;
+    if (len > 0) {
+      buffer[len] = 0;
+      int x;
+      /*
+      for (x = 0; x < len; x++) {
+        if (buffer[x] < 0x20)
+          logf << std::hex << (int)buffer[x] << " ";
+        else
+          logf << buffer[x] << " ";
+      }
+      */
+      for (x = 0; x < len; x++) {
+        if (buffer[x] == 0)
+          buffer[x] = ' ';
+      }
+
+      /*
+      logf << std::endl;
+      logf << "BUFFER [" << (char *)buffer << "]" << std::endl;
+      */
+      // this did not work -- because of the null characters in the buffer.
+      if (strstr(buffer, "1;2R") != nullptr) {
+        unicode = true;
+        log("unicode enabled \u2615"); // "U0001f926");
+      }
+      // Get the terminal screen size
+      // \x1b[1;2R\x1b[41;173R
+      // log(buffer);
+
+      char *cp;
+      cp = strchr(buffer, '\x1b');
+      if (cp != nullptr) {
+        cp = strchr(cp + 1, '\x1b');
+      } else {
+        log("Failed terminal size detection.  See buffer:");
+        log(buffer);
+        return;
+      }
+
+      if (cp != nullptr) {
+        cp++;
+        if (*cp == '[') {
+          cp++;
+          height = atoi(cp);
+          cp = strchr(cp, ';');
+          if (cp != nullptr) {
+            cp++;
+            width = atoi(cp);
+          } else {
+            height = 0;
+          }
+        }
+      }
+    }
+  } else {
+    logf << "FAIL-WHALE, no response to terminal getposition." << std::endl;
+  }
+}
+
+void Door::parse_dropfile(const char *filepath) {
+  if (filepath == nullptr)
+    return;
+
+  // Ok, parse file here...
+  std::ifstream file(filepath);
+  std::string line;
+  while (std::getline(file, line)) {
+    // These are "DOS" files.  Remove trailing \r.
+    if (!line.empty() && line[line.size() - 1] == '\r')
+      line.erase(line.size() - 1);
+    dropfilelines.push_back(line);
+  }
+  file.close();
+
+  std::string filename;
+  {
+    // converting const char * to char * for basename.
+    char *temp = strdup(filepath);
+    filename = basename(temp);
+    free(temp);
+  }
+
+  to_lower(filename);
+
+  // for now, just door.sys.
+
+  if (filename == "door.sys") {
+    // Ok, parse away!
+    node = atoi(dropfilelines[3].c_str());
+    username = dropfilelines[9];
+    location = dropfilelines[10];
+    time_left = atoi(dropfilelines[18].c_str());
+    sysop = dropfilelines[34];
+    handle = dropfilelines[35];
+  } else {
+    std::string msg = "Unknown dropfile: ";
+    msg += filename;
+    log(msg);
+    *this << msg << std::endl;
+    exit(2);
+  }
+  has_dropfile = true;
+}
+
+void Door::log(std::string output) {
+  // todo:  have logging
+
+  std::time_t t = std::time(nullptr);
+  std::tm tm = *std::localtime(&t);
+  logf << std::put_time(&tm, "%c ") << output << std::endl;
+}
+
+bool Door::haskey(void) {
+  fd_set socket_set;
+  struct timeval tv;
+  int select_ret = -1;
+
+  while (select_ret == -1) {
+    FD_ZERO(&socket_set);
+    FD_SET(STDIN_FILENO, &socket_set);
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 1;
+
+    select_ret = select(STDIN_FILENO + 1, &socket_set, NULL, NULL, &tv);
+    if (select_ret == -1) {
+      if (errno == EINTR)
+        continue;
+      log("haskey select_ret = -1");
+      return (-2);
+    }
+    if (select_ret == 0)
+      return false;
+  }
+  return true;
+}
+
+/*
+  low-lever read a key from terminal or stdin.
+  Returns key, or
+  -1 (no key available)
+  -2 (read error)
+ */
+signed int Door::getch(void) {
+  fd_set socket_set;
+  struct timeval tv;
+  int select_ret = -1;
+  int recv_ret;
+  char key;
+
+  if (door::hangup)
+    return -1;
+
+  while (select_ret == -1) {
+    FD_ZERO(&socket_set);
+    FD_SET(STDIN_FILENO, &socket_set);
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 100;
+
+    select_ret = select(STDIN_FILENO + 1, &socket_set, NULL, NULL, &tv);
+    // select(STDIN_FILENO + 1, &socket_set, NULL, NULL, bWait ? NULL : &tv);
+    if (select_ret == -1) {
+      if (errno == EINTR)
+        continue;
+      log("getch select_ret = -1");
+      return (-2);
+    }
+    if (select_ret == 0)
+      return (-1);
+  }
+
+  recv_ret = read(STDIN_FILENO, &key, 1);
+  if (recv_ret != 1) {
+    // possibly log this.
+    log("rect_ret != 1");
+    return -2;
+  }
+  return key;
+}
+
+void Door::unget(char c) {
+  if (bpos < sizeof(buffer) - 1) {
+    buffer[bpos] = c;
+    bpos++;
+  }
+}
+
+char Door::get(void) {
+  if (bpos == 0)
+    return 0;
+  bpos--;
+  return buffer[bpos];
+}
+
+signed int Door::getkey(void) {
+  signed int c, c2;
+
+  if (bpos != 0) {
+    c = get();
+  } else {
+    c = getch();
+  }
+
+  if (c < 0)
+    return c;
+
+  /*
+  We get 0x0d 0x00 for [Enter] (Syncterm)
+  This strips out the null.
+  */
+  if (c == 0x0d) {
+    c2 = getch();
+    if ((c2 != 0) and (c2 >= 0))
+      unget(c2);
+    return c;
+  }
+
+  if (c == 0x1b) {
+    // possible extended key
+    c2 = getch();
+    if (c2 < 0) {
+      // nope, just plain ESC key
+      return c;
+    }
+
+    // consume extended key values int extended buffer
+    char extended[16];
+    unsigned int pos = 0;
+    extended[pos] = (char)c2;
+    extended[pos + 1] = 0;
+    pos++;
+    while ((pos < sizeof(extended) - 1) and ((c2 = getch()) >= 0)) {
+      // special case here where I'm sending out cursor location requests
+      // and the \x1b[X;YR strings are getting buffered.
+      if (c2 == 0x1b) {
+        unget(c2);
+        break;
+      }
+      extended[pos] = (char)c2;
+      extended[pos + 1] = 0;
+      pos++;
+    }
+
+    // convert extended buffer to special key
+    if (extended[0] == '[') {
+      switch (extended[1]) {
+      case 'A':
+        return XKEY_UP_ARROW;
+      case 'B':
+        return XKEY_DOWN_ARROW;
+      case 'C':
+        return XKEY_RIGHT_ARROW;
+      case 'D':
+        return XKEY_LEFT_ARROW;
+      case 'H':
+        return XKEY_HOME;
+      case 'F':
+        return XKEY_END; // terminal
+      case 'K':
+        return XKEY_END;
+      case 'U':
+        return XKEY_PGUP;
+      case 'V':
+        return XKEY_PGDN;
+      case '@':
+        return XKEY_INSERT;
+      }
+
+      if (extended[pos - 1] == '~') {
+        // \x1b[digits~
+        int number = atoi(extended + 1);
+        switch (number) {
+        case 2:
+          return XKEY_INSERT; // terminal
+        case 3:
+          return XKEY_DELETE; // terminal
+        case 5:
+          return XKEY_PGUP; // terminal
+        case 6:
+          return XKEY_PGDN; // terminal
+        case 15:
+          return XKEY_F5; // terminal
+        case 17:
+          return XKEY_F6; // terminal
+        case 18:
+          return XKEY_F7; // terminal
+        case 19:
+          return XKEY_F8; // terminal
+        case 20:
+          return XKEY_F9; // terminal
+        case 21:
+          return XKEY_F10; // terminal
+        case 23:
+          return XKEY_F11;
+        case 24:
+          return XKEY_F12; // terminal
+        }
+      }
+    }
+
+    if (extended[0] == 'O') {
+      switch (extended[1]) {
+      case 'P':
+        return XKEY_F1;
+      case 'Q':
+        return XKEY_F2;
+      case 'R':
+        return XKEY_F3;
+      case 'S':
+        return XKEY_F4;
+      case 't':
+        return XKEY_F5; // syncterm
+      }
+    }
+
+    // unknown -- This needs to be logged
+    logf << "\r\nDEBUG:\r\nESC + ";
+    for (unsigned int x = 0; x < pos; x++) {
+      char z = extended[x];
+      if (iscntrl(z)) {
+        logf << (int)z << " ";
+      } else {
+        logf << "'" << (char)z << "'"
+             << " ";
+      };
+    }
+    logf << "\r\n";
+    logf.flush();
+
+    return XKEY_UNKNOWN;
+  }
+  return c;
+}
+
+int Door::get_input(void) {
+  signed int c;
+  c = getkey();
+  if (c < 0)
+    return 0;
+  return c;
+
+  /*
+  tODInputEvent event;
+  od_get_input(&event, OD_NO_TIMEOUT, GETIN_NORMAL);
+  */
+}
+
+/*
+The following code will wait for 1.5 second:
+
+#include <sys/select.h>
+#include <sys/time.h>
+#include <unistd.h>`
+
+int main() {
+    struct timeval t;
+    t.tv_sec = 1;
+    t.tv_usec = 500000;
+    select(0, NULL, NULL, NULL, &t);
+}
+
+ */
+signed int Door::sleep_key(int secs) {
+  fd_set socket_set;
+  struct timeval tv;
+  int select_ret = -1;
+  /*
+  int recv_ret;
+  char key;
+  */
+
+  while (select_ret == -1) {
+    FD_ZERO(&socket_set);
+    FD_SET(STDIN_FILENO, &socket_set);
+
+    tv.tv_sec = secs;
+    tv.tv_usec = 0;
+
+    select_ret = select(STDIN_FILENO + 1, &socket_set, NULL, NULL, &tv);
+    // select(STDIN_FILENO + 1, &socket_set, NULL, NULL, bWait ? NULL : &tv);
+    if (select_ret == -1) {
+      if (errno == EINTR)
+        continue;
+      return (-2);
+    }
+    if (select_ret == 0)
+      return (-1);
+  }
+  return getkey();
+}
+
+/**
+ * Take given buffer and output it.
+ *
+ * This originally stored output in the buffer.  We now directly output
+ * via the OpenDoor od_disp_emu.
+ *
+ * @param s const char *
+ * @param n std::streamsize
+ * @return std::streamsize
+ */
+std::streamsize Door::xsputn(const char *s, std::streamsize n) {
+  static std::string buffer;
+  buffer.append(s, n);
+  // setp(&(*buffer.begin()), &(*buffer.end()));
+  std::cout << buffer;
+  std::cout.flush();
+  // od_disp_emu(buffer.c_str(), TRUE);
+  // Tracking character position could be a problem / local terminal unicode.
+  if (track)
+    cx += n;
+  buffer.clear();
+  return n;
+}
+
+/**
+ * Stores a character into the buffer.
+ * This does still use the buffer.
+ * @todo Replace this also with a direct call to od_disp_emu.
+ *
+ * @param c char
+ * @return int
+ */
+int Door::overflow(char c) {
+  /*
+  char temp[2];
+  temp[0] = c;
+  temp[1] = 0;
+  */
+
+  // buffer.push_back(c);
+  // od_disp_emu(temp, TRUE);
+  std::cout << c;
+  std::cout.flush();
+  if (track)
+    cx++;
+  // setp(&(*buffer.begin()), &(*buffer.end()));
+  return c;
+}
+
+/**
+ * Construct a new Color Output:: Color Output object
+ * We default to BLACK/BLACK (not really a valid color),
+ * pos=0 and len=0.
+ */
+ColorOutput::ColorOutput() : c(COLOR::BLACK, COLOR::BLACK) {
+  pos = 0;
+  len = 0;
+}
+
+/**
+ * Reset pos and len to 0.
+ */
+void ColorOutput::reset(void) {
+  pos = 0;
+  len = 0;
+}
+
+/**
+ * Construct a new Render:: Render object
+ *
+ * Render consists of constant text,
+ * and vector of ColorOutput
+ *
+ * @param txt Text
+ */
+Render::Render(const std::string txt) : text{txt} {}
+
+/**
+ * Output the Render.
+ *
+ * This consists of going through the vector, getting
+ * the fragment (from pos and len), and outputting the
+ * color and fragment.
+ *
+ * @param os
+ */
+void Render::output(std::ostream &os) {
+  for (auto out : outputs) {
+    std::string fragment = text.substr(out.pos, out.len);
+    os << out.c << fragment;
+  }
+}
+
+/**
+ * Construct a new Clrscr:: Clrscr object
+ *
+ * This is used to clear the screen.
+ */
+Clrscr::Clrscr() {}
+
+/**
+ * Clear the screen using ANSI codes.
+ *
+ * Not all systems home the cursor after clearing the screen.
+ * We automatically home the cursor as well.
+ *
+ * @param os std::ostream&
+ * @param clr const Clrscr&
+ * @return std::ostream&
+ */
+std::ostream &operator<<(std::ostream &os, const Clrscr &clr) {
+  Door *d = dynamic_cast<Door *>(&os);
+  if (d != nullptr) {
+    d->track = false;
+    *d << "\x1b[2J"
+          "\x1b[H";
+    d->cx = 1;
+    d->cy = 1;
+    d->track = true;
+  } else {
+    os << "\x1b[2J"
+          "\x1b[H";
+  }
+  return os;
+}
+
+Clrscr cls;
+
+/**
+ * This is used to issue NL+CR
+ *
+ */
+NewLine::NewLine() {}
+
+/**
+ * Output Newline + CarriageReturn
+ * @param os std::ostream
+ * @param nl const NewLine
+ * @return std::ostream&
+ */
+std::ostream &operator<<(std::ostream &os, const NewLine &nl) {
+  Door *d = dynamic_cast<Door *>(&os);
+  if (d != nullptr) {
+    d->track = false;
+    *d << "\r\n";
+    d->cx = 1;
+    d->cy++;
+    d->track = true;
+  } else {
+    os << "\r\n";
+  };
+  return os;
+}
+
+NewLine nl;
+
+/**
+ * Construct a new Goto:: Goto object
+ *
+ * @param xpos
+ * @param ypos
+ */
+Goto::Goto(int xpos, int ypos) {
+  x = xpos;
+  y = ypos;
+}
+
+/**
+ * Output the ANSI codes to position the cursor to the given y,x position.
+ *
+ * @todo Optimize the ANSI goto string output.
+ * @todo Update the Door object so it know where the cursor
+ * is positioned.
+ *
+ * @param os std::ostream
+ * @param g const Goto
+ * @return std::ostream&
+ */
+std::ostream &operator<<(std::ostream &os, const Goto &g) {
+  Door *d = dynamic_cast<Door *>(&os);
+  if (d != nullptr) {
+    d->track = false;
+    *d << "\x1b[";
+    if (g.y > 1)
+      *d << std::to_string(g.y);
+    os << ";";
+    if (g.x > 1)
+      *d << std::to_string(g.x);
+    *d << "H";
+    d->cx = g.x;
+    d->cy = g.y;
+    d->track = true;
+  } else {
+    os << "\x1b[" << std::to_string(g.y) << ";" << std::to_string(g.x) << "H";
+  };
+  return os;
+}
+
+// EXAMPLES
+
+/// BlueYellow Render example function
+renderFunction rBlueYellow = [](const std::string &txt) -> Render {
+  Render r(txt);
+
+  ColorOutput co;
+
+  bool uc = true;
+  ANSIColor blue(COLOR::BLUE, ATTR::BOLD);
+  ANSIColor cyan(COLOR::YELLOW, ATTR::BOLD);
+
+  co.pos = 0;
+  co.len = 0;
+  co.c = blue;
+  // d << blue;
+
+  int tpos = 0;
+  for (char const &c : txt) {
+    if (uc) {
+      if (!isupper(c)) {
+        // possible color change
+        if (co.len != 0) {
+          r.outputs.push_back(co);
+          co.reset();
+          co.pos = tpos;
+        }
+
+        co.c = cyan;
+        // d << cyan;
+        uc = false;
+      }
+    } else {
+      if (isupper(c)) {
+        if (co.len != 0) {
+          r.outputs.push_back(co);
+          co.reset();
+          co.pos = tpos;
+        }
+        co.c = blue;
+
+        // d << blue;
+        uc = true;
+      }
+    }
+    co.len++;
+    tpos++;
+    // d << c;
+  }
+  if (co.len != 0) {
+    r.outputs.push_back(co);
+  }
+  return r;
+};
+
+/*
+std::function<void(Door &d, std::string &txt)> BlueYellow2 =
+    [](Door &d, std::string &txt) -> void {
+  bool uc = true;
+  ANSIColor blue(COLOR::BLACK, COLOR::CYAN);
+  ANSIColor cyan(COLOR::YELLOW, COLOR::BLUE, ATTR::BOLD);
+
+  d << blue;
+  for (char const &c : txt) {
+    if (uc) {
+      if (c == ':') {
+        d << cyan;
+        uc = false;
+      }
+    }
+    d << c;
+  }
+};
+
+std::function<void(Door &d, std::string &txt)> Aweful =
+    [](Door &d, std::string &txt) -> void {
+  for (char const &c : txt) {
+    // Color clr((Colors)((c % 14) + 1), Colors::BLACK, 0);
+    // Use only BRIGHT/LIGHT colors.
+    ANSIColor clr((COLOR)(c % 8), ATTR::BOLD);
+    d << clr << c;
+  }
+};
+*/
+
+} // namespace door

door.h

@@ -0,0 +1,682 @@
+// #include <OpenDoor.h> // Now using odoors for c++
+
+#include "anyoption.h"
+#include <cstdint>
+#include <ctime>
+#include <fstream>
+#include <functional>
+#include <future>
+#include <iostream>
+#include <memory>
+#include <ostream>
+#include <vector>
+
+// raw mode
+#include <termios.h>
+#include <unistd.h>
+
+#define CSI "\x1b["
+
+// getkey definitions
+#define XKEY_START 0x1000
+
+#define XKEY_UP_ARROW 0x1001
+#define XKEY_DOWN_ARROW 0x1002
+#define XKEY_RIGHT_ARROW 0x1003
+#define XKEY_LEFT_ARROW 0x1004
+
+#define XKEY_HOME 0x1010
+#define XKEY_END 0x1011
+#define XKEY_PGUP 0x1012
+#define XKEY_PGDN 0x1023
+#define XKEY_INSERT 0x1024
+#define XKEY_DELETE 0x7f
+
+#define XKEY_F1 0x1021
+#define XKEY_F2 0x1022
+#define XKEY_F3 0x1023
+#define XKEY_F4 0x1024
+#define XKEY_F5 0x1025
+#define XKEY_F6 0x1026
+#define XKEY_F7 0x1027
+#define XKEY_F8 0x1028
+#define XKEY_F9 0x1029
+#define XKEY_F10 0x102a
+#define XKEY_F11 0x102b
+#define XKEY_F12 0x102c
+
+#define XKEY_UNKNOWN 0x1111
+
+/**
+ * @brief The BBS door project.
+ * This is an attempt at writing a C++ BBS door toolkit.
+ */
+
+namespace door {
+
+extern bool unicode;
+
+/*
+Translate CP437 strings to unicode for output.
+
+if (door::unicode) {
+  // perform translation
+}
+
+ */
+void cp437toUnicode(std::string input, std::string &out);
+void cp437toUnicode(const char *input, std::string &out);
+
+/*
+door 2.0
+ */
+
+/**
+ * ANSI Color codes
+ */
+
+/**
+ * @brief The colors available under ANSI-BBS
+ */
+enum class COLOR : std::int8_t {
+  /// BLACK (0)
+  BLACK,
+  /// RED (1)
+  RED,
+  /// GREEN (2)
+  GREEN,
+  /// BROWN (3)
+  BROWN,
+  /// YELLOW (3)
+  YELLOW = 3,
+  /// BLUE (4)
+  BLUE,
+  /// MAGENTA (5)
+  MAGENTA,
+  /// CYAN (6)
+  CYAN,
+  /// WHITE (7)
+  WHITE
+};
+
+/**
+ * @brief ANSI-BBS text attributes
+ */
+enum class ATTR : std::int8_t {
+  /// RESET forces all attributes (and Colors) to be sent.
+  RESET,
+  /// BOLD is the same as BRIGHT.
+  BOLD,
+  /// BRIGHT is the same as BOLD.
+  BRIGHT = 1,
+  /// SLOW BLINK
+  BLINK = 5,
+  /// INVERSE is Background on Foreground.
+  INVERSE = 7
+};
+
+/**
+ * @class ANSIColor
+ * This holds foreground, background and ANSI-BBS attribute
+ * information.
+ * The special attribute RESET forces attribute and color
+ * output always.
+ *
+ * @brief Foreground, Background and Attributes
+ *
+ */
+class ANSIColor {
+  /// Foreground color
+  COLOR fg;
+  /// Background color
+  COLOR bg;
+  // Track attributes (ATTR)
+  /// reset flag / always send color and attributes
+  unsigned int reset : 1;
+  /// bold / bright flag
+  unsigned int bold : 1;
+  /// blink slow blinking text
+  unsigned int blink : 1;
+  /// inverse
+  unsigned int inverse : 1;
+
+public:
+  // default initialization here
+  ANSIColor();
+  ANSIColor(ATTR a);
+  ANSIColor(COLOR f);
+  ANSIColor(COLOR f, ATTR a);
+  ANSIColor(COLOR f, ATTR a1, ATTR a2);
+  ANSIColor(COLOR f, COLOR b);
+  ANSIColor(COLOR f, COLOR b, ATTR a);
+  ANSIColor(COLOR f, COLOR b, ATTR a1, ATTR a2);
+  ANSIColor &Attr(ATTR a);
+  bool operator==(const ANSIColor &c) const;
+  bool operator!=(const ANSIColor &c) const;
+
+  /**
+   * @return std::string
+   */
+  std::string output(void) const;
+
+  /**
+   * @param previous the previous attributes and colors
+   * @return std::string
+   */
+  std::string output(ANSIColor &previous) const;
+
+  /**
+   * @param os Output stream
+   * @param c ANSIColor
+   * @return std::ostream&
+   */
+  friend std::ostream &operator<<(std::ostream &os, const ANSIColor &c);
+};
+
+/**
+ * @class Door
+ *
+ * This handles output to the caller, via ostream.
+ *
+ */
+class Door : public std::ostream, private std::streambuf {
+
+private:
+  virtual std::streamsize xsputn(const char *s, std::streamsize n);
+  virtual int overflow(char c);
+  std::string doorname;
+  void parse_dropfile(const char *filepath);
+  void init(void);
+  std::time_t startup;
+  struct termios tio_default;
+  // getkey functions
+  signed int getch(void);
+  void unget(char c);
+  char get(void);
+  char buffer[5];
+  unsigned int bpos;
+  bool has_dropfile;
+  std::string dropfilename;
+  vector<std::string> dropfilelines;
+  ofstream logf;
+  void detect_unicode_and_screen(void);
+
+  // time thread - time left
+  std::promise<void> stop_thread;
+  // std::future<void> stop_future;
+
+  // atomic seconds_elapsed ?
+  int seconds_elapsed;
+  void time_thread_run(std::future<void> future);
+  std::thread time_thread;
+
+public:
+  /**
+   * @param argc int
+   * @param argv char *[]
+   */
+  Door(std::string dname, int argc, char *argv[]);
+  /// Default copy ctor deleted
+  Door(Door &) = delete;
+  virtual ~Door();
+  void log(std::string output);
+  AnyOption opt;
+
+  /**
+   * Previous ANSI-BBS colors and attributes sent.
+   * This is used to optimize our output.
+   * \see ANSIColor::output()
+   */
+  ANSIColor previous;
+  bool track;
+  int cx;
+  int cy;
+  int width;
+  int height;
+  int inactivity;
+  std::string username;
+  std::string handle;
+  std::string location;
+  std::string sysop;
+  // std::string bbsname;
+  int node;
+  atomic<int> time_left;
+
+  signed int getkey(void);
+  bool haskey(void);
+  int get_input(void);
+  signed int sleep_key(int secs);
+};
+
+// Use this to define the deprecated colorizer  [POC]
+// typedef std::function<void(Door &, std::string &)> colorFunction;
+
+/**
+ * @class ColorOutput
+ * This works with \ref Render to create the output.  This consists
+ * of ANSIColor and text position + length.
+ *
+ * @brief This holds an ANSIColor and text position + length
+ *
+ */
+class ColorOutput {
+public:
+  ColorOutput();
+  void reset(void);
+
+  /// Color to use for this fragment
+  ANSIColor c;
+  /// Starting position of Render.text
+  int pos;
+  /// Length
+  int len;
+};
+
+/*
+No, don't do this.
+
+Instead, return an iterator/generator.
+ */
+
+/**
+ * @class Render
+ * This holds the string, and a vector that contains ColorOutput parts.
+ *
+ * @see Render::output()
+ *
+ * @brief Rendering a string with ANSIColor
+ *
+ */
+class Render {
+public:
+  Render(const std::string txt);
+  /// Complete text to be rendered.
+  const std::string text;
+  /// Vector of ColorOutput object.
+  std::vector<ColorOutput> outputs;
+  void output(std::ostream &os);
+};
+
+/**
+ * This defines the render output function.  This is used
+ * to define the setRender functions, as well as the creation
+ * of render functions.
+ *
+ * @brief Render output function
+ *
+ */
+typedef std::function<Render(const std::string &)> renderFunction;
+
+/**
+ * This defines the update function.
+ *
+ * This updates the text.
+ */
+typedef std::function<std::string(void)> updateFunction;
+
+/**
+ * @class Clrscr
+ * Clear the screen
+ * @brief Clear the screen
+ */
+class Clrscr {
+public:
+  Clrscr(void);
+  friend std::ostream &operator<<(std::ostream &os, const Clrscr &clr);
+};
+
+/**
+ * Clear the BBS terminal.
+ *
+ */
+extern Clrscr cls;
+
+/**
+ * @class NewLine
+ * Carriage return + Newline
+ * @brief CR+LF
+ */
+class NewLine {
+public:
+  NewLine(void);
+  friend std::ostream &operator<<(std::ostream &os, const NewLine &nl);
+};
+
+/**
+ * CRLF
+ */
+extern NewLine nl;
+
+/**
+ * This resets the colors to normal state.
+ *
+ * @brief reset colors to normal
+ */
+extern ANSIColor reset;
+
+/// @deprecated Not used
+enum class Justify { NONE, LEFT, RIGHT, CENTER };
+
+/**
+ * @class Goto
+ * This handles outputting ANSI codes to position the cursor on the screen.
+ *
+ * @brief ANSI Goto X, Y position
+ */
+class Goto {
+  /// X-Position
+  int x;
+  /// Y-Position
+  int y;
+
+public:
+  Goto(int xpos, int ypos);
+  /**
+   * Default Goto constructor copier
+   */
+  Goto(Goto &) = default;
+  friend std::ostream &operator<<(std::ostream &os, const Goto &g);
+};
+
+/* should we try to derive a base class, so you can have multilines of
+ * multilines? */
+
+class LineBase {
+public:
+  virtual ~LineBase() = default;
+  virtual bool update(void) = 0;
+  // friend std::ostream &operator<<(std::ostream &os, const LineBase &lb) = 0;
+};
+
+class BasicLine {
+private:
+  std::string text;
+  bool hasColor;
+  ANSIColor color;
+  /// renderFunction to use when rendering Line.
+  renderFunction render;
+  /// updateFunction to use when updating.
+  updateFunction updater;
+
+public:
+  BasicLine(std::string txt);
+  BasicLine(std::string txt, ANSIColor c);
+  BasicLine(const BasicLine &rhs) = default;
+  virtual ~BasicLine() = default;
+
+  bool hasRender(void);
+  void setText(std::string txt);
+  void setColor(ANSIColor c);
+  void setRender(renderFunction rf);
+  void setUpdater(updateFunction uf);
+  bool update(void);
+
+  friend std::ostream &operator<<(std::ostream &os, const BasicLine &l);
+};
+
+class MultiLine {
+private:
+  std::vector<std::shared_ptr<BasicLine>> lines;
+
+public:
+  MultiLine();
+  void append(std::shared_ptr<BasicLine> bl);
+
+  bool update(void);
+  friend std::ostream &operator<<(std::ostream &os, const MultiLine &l);
+};
+
+/**
+ * @class Line
+ * This holds text and ANSIColor information, and knows how to
+ * send them out to the Door.
+ * @brief Text and ANSIColor
+ */
+class Line {
+private:
+  /// Text of the line
+  std::string text;
+
+  /// Do we have color?
+  bool hasColor;
+  /// Line color
+  ANSIColor color;
+  /// Padding characters
+  std::string padding;
+  /// Padding color
+  ANSIColor paddingColor;
+
+  /// renderFunction to use when rendering Line.
+  renderFunction render;
+  /// updateFunction to use when updating.
+  updateFunction updater;
+
+public:
+  Line(std::string &txt, int width = 0);
+  Line(const char *txt, int width = 0);
+  Line(const Line &rhs);
+  // ~Line();
+
+  bool hasRender(void);
+  int length(void); //  const;
+  /**
+   * @param width int
+   */
+  void makeWidth(int width);
+  /**
+   * @param padstring std::string &
+   * @param padColor ANSIColor
+   */
+  void setPadding(std::string &padstring, ANSIColor padColor);
+  /**
+   * @param padstring const char *
+   * @param padColor ANSIColor
+   */
+  void setPadding(const char *padstring, ANSIColor padcolor);
+  void setText(std::string &txt);
+  void setText(const char *txt);
+
+  void setColor(ANSIColor c);
+  void setRender(renderFunction rf);
+  void setUpdater(updateFunction uf);
+  bool update(void);
+
+  /**
+   * @todo This might be a problem, because const Line wouldn't
+   * allow me to track "updates".  I.E.  I send the line, I'd
+   * need to change the line's State to "nothing changed".
+   * Then, if something did change, the next update request would
+   * be able to know that yes, this does indeed need to be sent.
+   *
+   * @bug This also might cause problems if I display a shared
+   * BasicLine (in multiple places), and then update it.  It
+   * would only update in the first place (the others wouldn't
+   * show it needs an update).
+   */
+  friend std::ostream &operator<<(std::ostream &os, const Line &l);
+};
+
+/// Example BlueYellow renderFunction
+extern renderFunction rBlueYellow;
+
+/**
+ * The different Borders supported by Panel.
+ *
+ */
+enum class BorderStyle {
+  /// NONE (0)
+  NONE,
+  /// SINGLE (1)
+  SINGLE,
+  /// DOUBLE (2)
+  DOUBLE,
+  /// SINGLE top DOUBLE side (3)
+  SINGLE_DOUBLE,
+  /// DOUBLE top SINGLE side (4)
+  DOUBLE_SINGLE,
+  /// BLANK (5)
+  BLANK
+};
+
+class Panel {
+protected:
+  int x;
+  int y;
+  int width; // or padding ?
+  BorderStyle border_style;
+  ANSIColor border_color;
+  /**
+   * @todo Fix this to use shared_ptr.
+   * I don't think unique_ptr is the right way to go with this.  I want to reuse
+   * things, and that means shared_ptr!
+   *
+   */
+  std::vector<std::unique_ptr<Line>> lines;
+  bool hidden;
+  // when you show panel, should it mark it as
+  // redisplay everything??  maybe??
+  bool shown_once; // ?? maybe  shown_once_already ?
+  std::unique_ptr<Line> title;
+  int offset;
+
+public:
+  Panel(int x, int y, int width);
+  // Panel(const Panel &);
+  Panel(Panel &) = delete; // default;
+  Panel(Panel &&ref);
+
+  void set(int x, int y);
+  void setTitle(std::unique_ptr<Line> T, int off = 1);
+  void setStyle(BorderStyle bs);
+  void setColor(ANSIColor c);
+  void hide(void);
+  void show(void);
+  void addLine(std::unique_ptr<Line> l);
+  // bool delLine(std::shared_ptr<Line> l); // ?
+  /*
+  void display(void);
+  void update(void);
+  */
+  friend std::ostream &operator<<(std::ostream &os, const Panel &p);
+};
+
+/*
+Menu - defaults to double lines.
+Has colorize for selected item / non-selected.
+Arrow keys + ENTER, or keypress to select an item.
+[O] Option Displayed Here
+
+[ + ] = c1
+O = c2
+Remaining UC TEXT = c3
+Remaining LC text = c4
+
+// Colors for CS and CU (color selected, color unselected)
+ */
+
+class Menu : public Panel {
+private:
+  unsigned int chosen;
+  std::vector<char> options;
+  renderFunction selectedRender;
+  renderFunction unselectedRender;
+  /*
+  std::function<void(Door &d, std::string &)> selectedColorizer;
+  std::function<void(Door &d, std::string &)> unselectedColorizer;
+  */
+
+public:
+  static renderFunction defaultSelectedRender;
+  static renderFunction defaultUnselectedRender;
+  /*
+  static std::function<void(Door &d, std::string &)> defaultSelectedColorizer;
+  static std::function<void(Door &d, std::string &)> defaultUnselectedColorizer;
+  */
+
+  Menu(int x, int y, int width);
+  // Menu(const Menu &);
+  Menu(const Menu &) = delete;
+  Menu(Menu &&);
+
+  void addSelection(char c, const char *line);
+  void defaultSelection(int d);
+  void setRender(bool selected, renderFunction render);
+  /*
+  void setColorizer(bool selected,
+                    std::function<void(Door &d, std::string &)> colorizer);
+  */
+
+  int choose(Door &door);
+
+  static renderFunction makeRender(ANSIColor c1, ANSIColor c2, ANSIColor c3,
+                                   ANSIColor c4);
+
+  // static std::function<void(Door &d, std::string &)>
+  // makeColorizer(ANSIColor c1, ANSIColor c2, ANSIColor c3, ANSIColor c4);
+};
+
+class Screen {
+private:
+  bool hidden;
+  std::vector<std::shared_ptr<Panel>> parts;
+
+public:
+  Screen(void);
+  Screen(Screen &) = default;
+  void addPanel(std::shared_ptr<Panel> p);
+  bool delPanel(std::shared_ptr<Panel> p); // HMM.  Or ptr?
+  void hide(void);
+  void show(void);
+
+  friend std::ostream &operator<<(std::ostream &os, const Screen &s);
+};
+
+/*
+screen - contains panels.
+  - default to 1,1 X 80,24
+  - refresh(style) could redraw panels by order they were added,
+  or could redraw panels from top to bottom, left to right.
+
+crazy ideas:
+  hide panels / z-order
+  how to handle panel on top of other panels?
+  Can I have you win + show animated final score calculations?
+
+panel - has X,Y and width, optional length.  contains lines.
+  length could be simply number of "lines".
+  - has optional border.  double/single/Ds/Sd  TOPbottom
+  - has optional title.
+  - has optional footer.
+
+  addLine()
+  append() - Appends another line to current line.
+
+  set(X,Y) - set a "line" at a given X,Y position.
+
+menu - another type of panel, contains menu options/lines.
+
+lightmenu - like above, but allows arrow keys to select menu options.
+
+line - contains text.
+  (Maybe a "dirty" flag is needed here?)
+  - has optional (width)
+  - has optional (justify - L, R, Center)
+  - has optional padding (# of blank chars)
+  - has color (of text)
+  - has formatter/coloring function (to colorize the text)
+  Example would be one that sets capital letters to one color, lower to another.
+  Another example would be one that displays Score: XXX, where Score is one
+  color, : is another, and XXX is yet another.  Properly padded, of course.
+  - has "lambda" function to update the value? (Maybe?)
+  Idea would be that I could update the score, and panel.update().  It would
+  call all the line.update() functions and only update anything that has
+  changed.
+
+  Crazy ideas:
+  Can I delete a line, and have it automatically removed from a panel?
+
+lightline - text, changes format/coloring if focus/nofocus is set?
+
+ */
+
+} // namespace door

getkey.cpp

@@ -0,0 +1,388 @@
+#include <iostream>
+
+// raw mode
+#include <termios.h>
+#include <unistd.h>
+
+#include "door.h"
+
+// let's try this!
+#include <signal.h>
+#include <unistd.h>
+
+void done(int signal) {
+  std::cout << "\r\nWORP WORP\r\n";
+  std::cout.flush();
+}
+
+#include <ctype.h>
+
+struct termios tio_default;
+
+void raw(void) {
+  // enable terminal RAW mode
+  struct termios tio_raw;
+  tcgetattr(STDIN_FILENO, &tio_default);
+  tio_raw = tio_default;
+  cfmakeraw(&tio_raw);
+  /*
+  This works in the console, but fails with a terminal.
+  Ok, I am getting (what I would expect), but we're never timing out
+  now.  (So it has to fill up the buffer before exiting...)
+  CRAP!
+  */
+
+  // Ok!  I need the extra sauce here
+
+  tio_raw.c_cc[VMIN] = 0;
+  tio_raw.c_cc[VTIME] = 1;
+
+  // tio_raw.c_iflag &= ~(ICRNL | IXON);
+
+  tcsetattr(STDIN_FILENO, TCSANOW, &tio_raw);
+}
+
+void reset(void) { tcsetattr(STDIN_FILENO, TCOFLUSH, &tio_default); }
+
+#define CRNL "\r\n"
+
+/*
+NOTE:  cr (from syncterm), gives 0x0d 0x00
+
+ */
+signed int getch(void) {
+  fd_set socket_set;
+  struct timeval tv;
+  int select_ret = -1;
+  int recv_ret;
+  char key;
+
+  while (select_ret == -1) {
+    FD_ZERO(&socket_set);
+    FD_SET(STDIN_FILENO, &socket_set);
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 100;
+
+    select_ret = select(STDIN_FILENO + 1, &socket_set, NULL, NULL, &tv);
+    // select(STDIN_FILENO + 1, &socket_set, NULL, NULL, bWait ? NULL : &tv);
+    if (select_ret == -1) {
+      if (errno == EINTR)
+        continue;
+      return (-2);
+    }
+    if (select_ret == 0)
+      return (-1);
+  }
+
+  recv_ret = read(STDIN_FILENO, &key, 1);
+  if (recv_ret != 1) {
+    std::cout << "eof?" << CRNL;
+    std::cout.flush();
+    return -2;
+  }
+  return key;
+}
+
+char buffer[10];
+int bpos = 0;
+
+void unget(char c) {
+  if (bpos < sizeof(buffer) - 1) {
+    buffer[bpos] = c;
+    bpos++;
+  }
+}
+
+char get(void) {
+  if (bpos == 0) {
+    return 0;
+  }
+  bpos--;
+  char c = buffer[bpos];
+  return c;
+}
+
+signed int getkey(void) {
+  signed int c, c2;
+
+  if (bpos != 0) {
+    c = get();
+  } else {
+    c = getch();
+  };
+
+  if (c < 0)
+    return c;
+
+  /*
+  What happens:  syncterm gives us 0x0d 0x00 on [Enter].
+  This strips out the possible null.
+   */
+
+  if (c == 0x0d) {
+    c2 = getch();
+    if ((c2 != 0) and (c2 >= 0))
+      unget(c2);
+    return c;
+  }
+
+  if (c == 0x1b) {
+    // possible extended key
+    c2 = getch();
+    if (c2 < 0) {
+      // nope, just plain ESC
+      return c;
+    }
+
+    char extended[10];
+    int pos = 0;
+    extended[pos] = (char)c2;
+    extended[pos + 1] = 0;
+    pos++;
+    while ((pos < sizeof(extended) - 1) and ((c2 = getch()) >= 0)) {
+      // handle special case when I'm smashing out cursor location requests
+      // and \x1b[X;YR strings get buffered
+      if (c2 == 0x1b) {
+        unget(c2);
+        break;
+      }
+      extended[pos] = (char)c2;
+      extended[pos + 1] = 0;
+      pos++;
+    }
+
+    // FUTURE:  Display debug when we fail to identify the key
+#ifdef DEBUGGS
+    std::cout << CRNL "DEBUG:" CRNL "ESC + ";
+    for (int x = 0; x < pos; x++) {
+      char z = extended[x];
+      if (iscntrl(z)) {
+        std::cout << (int)z << " ";
+      } else {
+        std::cout << "'" << (char)z << "'"
+                  << " ";
+      };
+    }
+#endif
+
+    if (extended[0] == '[') {
+      switch (extended[1]) {
+      case 'A':
+        return XKEY_UP_ARROW;
+      case 'B':
+        return XKEY_DOWN_ARROW;
+      case 'C':
+        return XKEY_RIGHT_ARROW;
+      case 'D':
+        return XKEY_LEFT_ARROW;
+      case 'H':
+        return XKEY_HOME;
+      case 'F':
+        return XKEY_END; // terminal
+      case 'K':
+        return XKEY_END;
+      case 'U':
+        return XKEY_PGUP;
+      case 'V':
+        return XKEY_PGDN;
+      case '@':
+        return XKEY_INSERT;
+      };
+
+      if (extended[pos - 1] == '~') {
+        // This ends with ~
+        int number = atoi(extended + 1);
+        switch (number) {
+        case 2:
+          return XKEY_INSERT; // terminal
+        case 3:
+          return XKEY_DELETE; // terminal
+        case 5:
+          return XKEY_PGUP; // terminal
+        case 6:
+          return XKEY_PGDN; // terminal
+        case 15:
+          return XKEY_F5; // terminal
+        case 17:
+          return XKEY_F6; // terminal
+        case 18:
+          return XKEY_F7; // terminal
+        case 19:
+          return XKEY_F8; // terminal
+        case 20:
+          return XKEY_F9; // terminal
+        case 21:
+          return XKEY_F10; // terminal
+        case 23:
+          return XKEY_F11;
+        case 24:
+          return XKEY_F12; // terminal
+        }
+      }
+    }
+
+    if (extended[0] == 'O') {
+      switch (extended[1]) {
+      case 'P':
+        return XKEY_F1;
+      case 'Q':
+        return XKEY_F2;
+      case 'R':
+        return XKEY_F3;
+      case 'S':
+        return XKEY_F4;
+      case 't':
+        return XKEY_F5; // syncterm
+      }
+    }
+
+    // unknown -- display debug output
+    std::cout << CRNL "DEBUG:" CRNL "ESC + ";
+    for (int x = 0; x < pos; x++) {
+      char z = extended[x];
+      if (iscntrl(z)) {
+        std::cout << (int)z << " ";
+      } else {
+        std::cout << "'" << (char)z << "'"
+                  << " ";
+      };
+    }
+
+    return XKEY_UNKNOWN;
+  }
+  return c;
+}
+
+#ifdef JUNKY_MONKEY
+
+int nogetkey(void) {
+  char c;
+  if (read(STDIN_FILENO, &c, 1) == 1) {
+    std::cout << std::hex << (int)c << ":";
+
+    if (c == 0) {
+      std::cout << "0x00" CRNL;
+    }
+    std::cout.flush();
+
+    if (c == 0x1b) {
+      // Ok, this might be something special...
+      char buffer[5] = "";
+      int pos = 0;
+      while ((pos < sizeof(buffer) - 1) and
+             (read(STDIN_FILENO, &buffer[pos], 1) == 1)) {
+        std::cout << "~" << std::hex << (int)buffer[pos] << "~";
+        std::cout.flush();
+
+        pos++;
+        buffer[pos] = 0;
+      };
+
+      if (pos == 0)
+        return 0x1b;
+
+      // Ok, translate the keys
+      if (buffer[0] == '[') {
+        switch (buffer[1]) {
+        case 'A':
+          return XKEY_UP_ARROW;
+        case 'B':
+          return XKEY_DOWN_ARROW;
+        case 'C':
+          return XKEY_RIGHT_ARROW;
+        case 'D':
+          return XKEY_LEFT_ARROW;
+        }
+      }
+
+      std::cout << CRNL "DEBUG:" CRNL;
+      for (int x = 0; x < pos; x++) {
+        char z = buffer[x];
+        if (iscntrl(z)) {
+          std::cout << (int)z << " ";
+        } else {
+          std::cout << "'" << (char)z << "'"
+                    << " ";
+        };
+
+        // std::cout << (int)buffer[x] << ", ";
+      };
+
+      std::cout << CRNL;
+      std::cout.flush();
+      return 0x1000;
+    };
+    return (int)c;
+  }
+  return -1;
+  /*
+      if (iscntrl(c)) {
+        printf("%d\r\n", c);
+      } else {
+        printf("%d ('%c')\r\n", c, c);
+      }
+  */
+}
+
+int main(void) {
+  std::cout
+      << "\377\375\042\377\373\001"; //  "\xff\xfc\x22"; // IAC WONT LINEMODE
+  std::cout << "\x1b[2J\x1b[H";
+
+  raw();
+
+  std::cout << "\u2615"
+            << "\x1b[6n";
+
+  std::cout << "\x1b[999C\x1b[999B\x1b[6n";
+  std::cout.flush();
+
+  std::cout << "\x1b[2J\x1b[H";
+  std::cout << "isatty = " << isatty(STDIN_FILENO) << CRNL;
+
+  // no, I don't get a SIGHUP.  Hmm, maybe that's a "terminal" thing,
+  // and I'm not in a terminal...
+
+  // signal(SIGHUP, done);
+
+  // Ok!  Great!
+  signed int c = 0;
+  std::cout << "RAW MODE" CRNL;
+  std::cout.flush();
+
+  while (c != 'Q') {
+    c = getkey();
+    if (c >= 0) {
+      if (c == 0x1b) {
+        // This is ESC, so..
+        std::cout << "\x1b[6n";
+        std::cout.flush();
+      }
+      if (c > 256) {
+        std::cout << "[" << std::hex << c << "]";
+      } else {
+        if (iscntrl(c)) {
+          std::cout << int(c);
+        } else {
+          std::cout << int(c) << "('" << (char)c << "')";
+        }
+      }
+      std::cout << " ";
+      std::cout.flush();
+    }
+
+    /*
+    if (std::cin.eof()) {
+      std::cout << "BLARGH" CRNL;
+      break;
+    }
+    */
+  };
+
+  std::cout << CRNL "DONE" CRNL;
+
+  reset();
+}
+
+#endif

lines.cpp

@@ -0,0 +1,292 @@
+#include "door.h"
+
+namespace door {
+
+BasicLine::BasicLine(std::string txt) : text{txt}, hasColor{false} {}
+
+BasicLine::BasicLine(std::string txt, ANSIColor c)
+    : text{txt}, hasColor{true}, color{c} {}
+
+bool BasicLine::hasRender(void) {
+  if (render)
+    return true;
+  return false;
+}
+
+void BasicLine::setText(std::string txt) { text = txt; }
+
+void BasicLine::setColor(ANSIColor c) {
+  color = c;
+  hasColor = true;
+}
+
+void BasicLine::setRender(renderFunction rf) { render = rf; }
+
+void BasicLine::setUpdater(updateFunction uf) { updater = uf; }
+
+/**
+ * Update BasicLine, if we have an updater.
+ *
+ * If we have an updater, call it.  If the text is different,
+ * update setText() and return true.
+ * Otherwise false.
+ *
+ * This doesn't detect changes (like if the render has been changed, for
+ * example)
+ *
+ * @return bool
+ */
+bool BasicLine::update(void) {
+  if (updater) {
+    std::string temp = updater();
+    if (temp == text)
+      return false;
+    setText(temp);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Output Line
+ *
+ * This looks for padding and paddingColor.
+ * This uses the render function if set.
+ *
+ * @param os std::ostream
+ * @param l const BasicLine &
+ * @return std::ostream&
+ */
+std::ostream &operator<<(std::ostream &os, const BasicLine &l) {
+  if (l.render) {
+    // This has a renderer.  Use it.
+    Render r = l.render(l.text);
+    r.output(os);
+  } else {
+    if (l.hasColor) {
+      os << l.color;
+    };
+    os << l.text;
+  }
+  return os;
+}
+
+MultiLine::MultiLine(){};
+void MultiLine::append(std::shared_ptr<BasicLine> bl) { lines.push_back(bl); }
+
+bool MultiLine::update() {
+  bool updated = false;
+
+  for (auto line : lines) {
+    if (line->update())
+      updated = true;
+  }
+  return updated;
+}
+
+/**
+ * Output Line
+ *
+ * This looks for padding and paddingColor.
+ * This uses the render function if set.
+ *
+ * @param os std::ostream
+ * @param ml const MultiLine &
+ * @return std::ostream&
+ */
+std::ostream &operator<<(std::ostream &os, const MultiLine &ml) {
+  for (auto line : ml.lines) {
+    os << *line;
+  }
+  return os;
+}
+
+/**
+ * Construct a new Line:: Line object with
+ * string and total width.
+ *
+ * @param txt std::string
+ * @param width int
+ */
+Line::Line(std::string &txt, int width) : text{txt} {
+  if (width)
+    makeWidth(width);
+  hasColor = false;
+}
+
+/**
+ * Construct a new Line:: Line object with
+ * const char * and total width
+ *
+ * @param txt const char *
+ * @param width int
+ */
+Line::Line(const char *txt, int width) : text{txt} {
+  if (width)
+    makeWidth(width);
+  hasColor = false;
+}
+
+/**
+ * Construct a new Line:: Line object from an
+ * existing Line
+ *
+ * @param rhs const Line&
+ */
+Line::Line(const Line &rhs)
+    : text{rhs.text}, hasColor{rhs.hasColor}, color{rhs.color},
+      padding{rhs.padding}, paddingColor{rhs.paddingColor} {
+  if (rhs.render) {
+    render = rhs.render;
+  }
+}
+
+/**
+ * Has a render function been set?
+ *
+ * @return bool
+ */
+bool Line::hasRender(void) {
+  if (render) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Return total length of Line
+ *
+ * text.length + 2 * padding length
+ *
+ * @return int
+ */
+int Line::length(void) {
+  if (!padding.empty())
+    return padding.length() * 2 + text.length();
+  return text.length();
+}
+
+/**
+ * Make text the given width by padding string with spaces.
+ *
+ * @param width int
+ */
+void Line::makeWidth(int width) {
+  int need = width - text.length();
+  if (need > 0) {
+    text.append(std::string(need, ' '));
+  }
+}
+
+/**
+ * Set Line text.
+ * @param txt std::string
+ */
+void Line::setText(std::string &txt) { text = txt; }
+/**
+ * Set Line text.
+ * @param txt const char *
+ */
+void Line::setText(const char *txt) { text = txt; }
+
+/**
+ * set padding (color and text)
+ *
+ * @param padstring std::string
+ * @param padColor ANSIColor
+ */
+void Line::setPadding(std::string &padstring, ANSIColor padColor) {
+  padding = padstring;
+  paddingColor = padColor;
+}
+
+/**
+ * set padding (color and text)
+ *
+ * @param padstring const char *
+ * @param padColor ANSIColor
+ */
+void Line::setPadding(const char *padstring, ANSIColor padColor) {
+  padding = padstring;
+  paddingColor = padColor;
+}
+
+/**
+ * set color
+ *
+ * @param c ANSIColor
+ */
+void Line::setColor(ANSIColor c) {
+  color = c;
+  hasColor = true;
+}
+
+/**
+ * set render
+ *
+ * Set the renderFunction to use for this Line.  This
+ * replaces the colorizer.
+ * @param rf renderFunction
+ */
+void Line::setRender(renderFunction rf) { render = rf; }
+
+/**
+ * set updater function
+ *
+ * This can update the line text when called.
+ * @todo Define an updateFunction.
+ * @param newUpdater updateFunction
+ */
+void Line::setUpdater(updateFunction newUpdater) { updater = newUpdater; }
+
+/**
+ * Call updater, report if the text was actually changed.
+ *
+ * @return bool
+ */
+bool Line::update(void) {
+  if (updater) {
+    std::string newText = updater();
+    if (newText != text) {
+      text = newText;
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Output Line
+ *
+ * This looks for padding and paddingColor.
+ * This uses the render function if set.
+ *
+ * @param os std::ostream
+ * @param l const Line &
+ * @return std::ostream&
+ */
+std::ostream &operator<<(std::ostream &os, const Line &l) {
+  // Door *d = dynamic_cast<Door *>(&os);
+
+  if (!l.padding.empty()) {
+    os << l.paddingColor << l.padding;
+  }
+  if (l.render) {
+    // This has a renderer.  Use it.
+    Render r = l.render(l.text);
+    r.output(os);
+  } else {
+    if (l.hasColor) {
+      os << l.color;
+    };
+    os << l.text;
+  }
+  if (!l.padding.empty()) {
+    os << l.paddingColor << l.padding;
+  }
+
+  return os;
+}
+
+} // namespace door

panel.cpp

@@ -0,0 +1,633 @@
+#include "door.h"
+#include <string.h>
+
+// #include <memory>
+
+namespace door {
+
+Panel::Panel(int xp, int yp, int panelWidth) : border_color() {
+  x = xp;
+  y = yp;
+  width = panelWidth;
+  hidden = false;
+  border_style = BorderStyle::NONE;
+  // border_color = ANSIColor();
+}
+
+Panel::Panel(Panel &&ref) {
+  x = ref.x;
+  y = ref.y;
+  width = ref.width;
+  hidden = ref.hidden;
+  border_style = ref.border_style;
+  title = std::move(ref.title);
+  offset = ref.offset;
+  lines = std::move(lines);
+}
+
+/*
+Panel::Panel(const Panel &original) : border_color(original.border_color) {
+  x = original.x;
+  y = original.y;
+  width = original.width;
+  hidden = original.hidden;
+  border_style = original.border_style;
+  // door::Line title_copy(*original.title);
+  // title = std::move(std::make_unique<door::Line>(title_copy));
+
+  // What's wrong with making copies of unique_ptr objects?
+  title = std::move(std::make_unique<door::Line>(*original.title));
+  offset = original.offset;
+
+  for (auto &line : original.lines) {
+    // door::Line l(*line);
+    // lines.push_back(std::move(std::make_unique<door::Line>(l)));
+    // door::Line l(*line);
+    lines.push_back(std::move(std::make_unique<door::Line>(*line)));
+  }
+}
+*/
+
+void Panel::set(int xp, int yp) {
+  x = xp;
+  y = yp;
+}
+
+void Panel::setTitle(std::unique_ptr<Line> t, int off) {
+  title = std::move(t);
+  offset = off;
+}
+
+void Panel::setStyle(BorderStyle bs) { border_style = bs; }
+// Panel::Panel(Panel &old) = { }
+void Panel::setColor(ANSIColor c) { border_color = c; }
+
+void Panel::hide(void) { hidden = true; }
+void Panel::show(void) { hidden = false; }
+void Panel::addLine(std::unique_ptr<Line> l) { lines.push_back(std::move(l)); }
+// or possibly std::move(l)); }
+
+/*
+bool Panel::delLine(std::shared_ptr<Line> l) {
+  size_t size = lines.size();
+  remove(lines.begin(), lines.end(), l);
+  return (size != lines.size());
+}
+*/
+
+/**
+ * Utility structure that stores the characters needed to
+ * render boxes.
+ *
+ * We assume that Top can be used in Bottom and Middle.
+ * We assume that Side can be used on Left and Right.
+ */
+struct box_styles {
+  /// Top Left
+  const char *tl;
+  /// Top Right
+  const char *tr;
+  /// Top
+  const char *top;
+  /// Side
+  const char *side;
+  /// Bottom Left
+  const char *bl;
+  /// Bottom Right
+  const char *br;
+  /// Middle Left
+  const char *ml;
+  /// Middle Right
+  const char *mr;
+};
+
+/**
+ *
+ * use https://en.wikipedia.org/wiki/Code_page_437 for translations between
+ * CP437 and unicode symbols.
+ *
+ * This holds the characters needed to render the different box styles.
+ * tl tr top side bl br ml mr
+ */
+struct box_styles UBOXES[] = {{"\u250c", "\u2510", "\u2500", "\u2502", "\u2514",
+                               "\u2518", "\u251c", "\u2524"},
+                              {"\u2554", "\u2557", "\u2550", "\u2551", "\u255a",
+                               "\u255d", "\u2560", "\u2563"},
+                              {"\u2553", "\u2556", "\u2500", "\u2551", "\u2559",
+                               "\u255c", "\u255f", "\u2562"},
+                              {"\u2552", "\u2555", "\u2550", "\u2502", "\u2558",
+                               "\u255b", "\u255e", "\u2561"}};
+
+struct box_styles BOXES[] = {
+    /*
+            # ┌──┐
+            # │  │
+            # ├──┤
+            # └──┘
+     */
+    {
+        "\xda",
+        "\xbf",
+        "\xc4",
+        "\xb3",
+        "\xc0",
+        "\xd9",
+        "\xc3",
+        "\xb4",
+    },
+    /*
+            # ╔══╗
+            # ║  ║
+            # ╠══╣
+            # ╚══╝
+     */
+    {
+        "\xc9",
+        "\xbb",
+        "\xcd",
+        "\xba",
+        "\xc8",
+        "\xbc",
+        "\xcc",
+        "\xb9",
+    },
+    /*
+    # ╓──╖
+    # ║  ║
+    # ╟──╢
+    # ╙──╜
+     */
+    {
+        "\xd6",
+        "\xb7",
+        "\xc4",
+        "\xba",
+        "\xd3",
+        "\xbd",
+        "\xc7",
+        "\xb6",
+    },
+    /*
+            # ╒══╕
+            # │  │
+            # ╞══╡
+            # ╘══╛
+     */
+    {
+        "\xd5",
+        "\xb8",
+        "\xcd",
+        "\xb3",
+        "\xd4",
+        "\xbe",
+        "\xc6",
+        "\xb5",
+    },
+};
+
+/*
+void Panel::display(void) {
+
+}
+
+void Panel::update(void) {
+
+}
+*/
+
+// operator<< Panel is called to output the Menu.
+// Menu has been massively changed to use Render instead of Colorizer.
+
+std::ostream &operator<<(std::ostream &os, const Panel &p) {
+  if (p.hidden)
+    return os;
+
+  // Handle borders
+  int style = (int)p.border_style;
+  struct box_styles s;
+
+  // If there's no style, then everything works.
+  // If I try style, it prints out first line
+  // and dies.  (Yet it says there's 4 lines!)
+
+  if (style > 0) {
+    // Ok, there needs to be something in this style;
+    if (style < 5) {
+      if (unicode)
+        s = UBOXES[style - 1];
+      else
+        s = BOXES[style - 1];
+    } else {
+      s.bl = s.br = s.mr = s.ml = " ";
+      s.top = s.side = " ";
+      s.tl = s.tr = " ";
+    }
+  }
+
+  /*
+    Door *d = dynamic_cast<Door *>(&os);
+    if (d != nullptr) {
+  */
+  /*
+    os << "style " << style << "."
+       << " width " << p.width;
+    os << " SIZE " << p.lines.size() << " ! " << nl;
+  */
+
+  // os << s.tl << s.top << s.tr << s.side << s.br << s.bl;
+
+  int row = p.y;
+
+  if (style > 0) {
+    // Top line of border (if needed)
+    os << door::Goto(p.x, row);
+    os << p.border_color << s.tl;
+
+    if (p.title) {
+      for (int c = 0; c < p.offset; c++)
+        os << s.top;
+      os << *(p.title);
+      os << p.border_color;
+      int left = p.width - (p.offset + (p.title)->length());
+      if (left > 0) {
+        for (int c = 0; c < left; c++)
+          os << s.top;
+      };
+      os << s.tr;
+    } else {
+      for (int c = 0; c < p.width; c++)
+        os << s.top;
+      os << s.tr;
+    };
+    // os << "";
+
+    ++row;
+  };
+
+  for (auto &line : p.lines) {
+    os << door::Goto(p.x, row);
+    if (style > 0) {
+      os << p.border_color << s.side;
+    };
+
+    // os << "[" << row << "," << p.x << "] ";
+    os << *line;
+
+    if (style > 0) {
+      os << p.border_color << s.side;
+    };
+
+    // os << "row " << row;
+    row++;
+    // forcing reset works.  But why doesn't it work without this?
+    // os << Color();
+  }
+
+  // Display bottom (if needed)
+  if (style > 0) {
+    os << door::Goto(p.x, row);
+    os << p.border_color << s.bl;
+    for (int c = 0; c < p.width; c++)
+      os << s.top;
+    // os << "";
+    os << s.br;
+  };
+  // };
+  // os << flush;
+  return os;
+} // namespace door
+
+/*
+std::function<void(Door &d, std::string &)> Menu::defaultSelectedColorizer =
+    Menu::makeColorizer(ANSIColor(COLOR::BLUE, COLOR::WHITE),
+                        ANSIColor(COLOR::BLUE, COLOR::WHITE),
+                        ANSIColor(COLOR::BLUE, COLOR::WHITE),
+                        ANSIColor(COLOR::BLUE, COLOR::WHITE));
+
+std::function<void(Door &d, std::string &)> Menu::defaultUnselectedColorizer =
+    makeColorizer(ANSIColor(COLOR::WHITE, COLOR::BLUE, ATTR::BOLD),
+                  ANSIColor(COLOR::WHITE, COLOR::BLUE, ATTR::BOLD),
+                  ANSIColor(COLOR::WHITE, COLOR::BLUE, ATTR::BOLD),
+                  ANSIColor(COLOR::YELLOW, COLOR::BLUE, ATTR::BOLD));
+*/
+
+renderFunction Menu::defaultSelectedRender = Menu::makeRender(
+    ANSIColor(COLOR::BLUE, COLOR::WHITE), ANSIColor(COLOR::BLUE, COLOR::WHITE),
+    ANSIColor(COLOR::BLUE, COLOR::WHITE), ANSIColor(COLOR::BLUE, COLOR::WHITE));
+renderFunction Menu::defaultUnselectedRender =
+    Menu::makeRender(ANSIColor(COLOR::WHITE, COLOR::BLUE, ATTR::BOLD),
+                     ANSIColor(COLOR::WHITE, COLOR::BLUE, ATTR::BOLD),
+                     ANSIColor(COLOR::WHITE, COLOR::BLUE, ATTR::BOLD),
+                     ANSIColor(COLOR::YELLOW, COLOR::BLUE, ATTR::BOLD));
+
+Menu::Menu(int x, int y, int width) : Panel(x, y, width) {
+  setStyle(BorderStyle::DOUBLE);
+  // Setup initial sensible default values.
+  // setColorizer(true, defaultSelectedColorizer);
+  setRender(true, defaultSelectedRender);
+  /* makeColorizer(Color(Colors::BLUE, Colors::WHITE, 0),
+                                   Color(Colors::BLUE, Colors::WHITE, 0),
+                                   Color(Colors::BLUE, Colors::WHITE, 0),
+                                   Color(Colors::BLUE, Colors::WHITE, 0))); */
+  setRender(false, defaultUnselectedRender);
+  // setColorizer(false, defaultUnselectedColorizer);
+  /* makeColorizer(Color(Colors::LWHITE, Colors::BLUE, 0),
+                                    Color(Colors::LWHITE, Colors::BLUE),
+                                    Color(Colors::LWHITE, Colors::BLUE, 0),
+                                    Color(Colors::LYELLOW, Colors::BLUE))); */
+  chosen = 0;
+}
+
+/*
+Menu::Menu(const Menu &original)
+    : Panel(original.x, original.y, original.width) {
+  x = original.x;
+  y = original.y;
+  width = original.width;
+  setStyle(original.border_style);
+  setRender(true, original.selectedRender);
+  setRender(false, original.unselectedRender);
+  options = original.options;
+  chosen = 0;
+}
+*/
+
+Menu::Menu(Menu &&ref) : Panel(ref.x, ref.y, ref.width) {
+  x = ref.x;
+  y = ref.y;
+  width = ref.width;
+  border_style = ref.border_style;
+  setRender(true, ref.selectedRender);
+  setRender(false, ref.unselectedRender);
+  options = ref.options;
+  lines = std::move(ref.lines);
+  chosen = ref.chosen;
+}
+
+void Menu::addSelection(char c, const char *line) {
+  std::string menuline;
+  menuline.reserve(5 + strlen(line));
+  menuline = "[ ] ";
+  menuline[1] = c;
+  menuline += line;
+
+  // problem:  How do I update the "Lines" from this point?
+  // L->makeWidth(width);
+
+  addLine(std::make_unique<Line>(menuline, width));
+  options.push_back(c);
+}
+
+void Menu::defaultSelection(int d) { chosen = d; }
+
+/*
+void Menu::setColorizer(bool selected,
+                        std::function<void(Door &d, std::string &)> colorizer) {
+  if (selected)
+    selectedColorizer = colorizer;
+  else
+    unselectedColorizer = colorizer;
+}
+*/
+
+void Menu::setRender(bool selected, renderFunction render) {
+  if (selected)
+    selectedRender = render;
+  else
+    unselectedRender = render;
+}
+
+renderFunction Menu::makeRender(ANSIColor c1, ANSIColor c2, ANSIColor c3,
+                                ANSIColor c4) {
+  renderFunction render = [c1, c2, c3, c4](const std::string &txt) -> Render {
+    Render r(txt);
+
+    bool option = true;
+    ColorOutput co;
+
+    /*
+      bool uc = true;
+      ANSIColor blue(COLOR::BLUE, ATTR::BOLD);
+      ANSIColor cyan(COLOR::YELLOW, ATTR::BOLD);
+    */
+
+    co.pos = 0;
+    co.len = 0;
+    co.c = c1;
+    // d << blue;
+
+    int tpos = 0;
+    for (char const &c : txt) {
+      if (option) {
+        if (c == '[' or c == ']') {
+          if (co.c != c1)
+            if (co.len != 0) {
+              r.outputs.push_back(co);
+              co.reset();
+              co.pos = tpos;
+            }
+          co.c = c1;
+          if (c == ']')
+            option = false;
+        } else {
+          if (co.c != c2)
+            if (co.len != 0) {
+              r.outputs.push_back(co);
+              co.reset();
+              co.pos = tpos;
+            }
+          co.c = c2;
+        }
+      } else {
+        if (isupper(c)) {
+          // possible color change
+          if (co.c != c3)
+            if (co.len != 0) {
+              r.outputs.push_back(co);
+              co.reset();
+              co.pos = tpos;
+            }
+          co.c = c3;
+        } else {
+          if (co.c != c4)
+            if (co.len != 0) {
+              r.outputs.push_back(co);
+              co.reset();
+              co.pos = tpos;
+            }
+          co.c = c4;
+        }
+      }
+      co.len++;
+      tpos++;
+    }
+    if (co.len != 0) {
+      r.outputs.push_back(co);
+    }
+    return r;
+  };
+  return render;
+}
+
+/*
+std::function<void(Door &d, std::string &)>
+Menu::makeColorizer(ANSIColor c1, ANSIColor c2, ANSIColor c3, ANSIColor c4) {
+  std::function<void(Door & d, std::string & txt)> colorize =
+      [c1, c2, c3, c4](Door &d, std::string txt) {
+        bool option = true;
+        for (char const &c : txt) {
+          if (option) {
+            if (c == '[' or c == ']') {
+              d << c1 << c;
+              if (c == ']')
+                option = false;
+            } else {
+              d << c2 << c;
+            }
+          } else {
+            if (isupper(c)) {
+              d << c3 << c;
+            } else {
+              d << c4 << c;
+            }
+          }
+        }
+      };
+  return colorize;
+}
+*/
+
+/*
+  Should this return the index number, or
+  the actual option?
+ */
+
+/**
+ * @todo Fix this, so it only updates the lines that have been changed when the
+ * user selects something.  Also, add the "Up/Down Move" maybe to the bottom?
+ *
+ * Needs timeout.
+ *
+ * Should we return the index offset, or return the actual char?  (Like in the
+ * case of Quit or Help?)
+ *
+ * @param door
+ * @return int
+ */
+int Menu::choose(Door &door) {
+  // Display menu and make a choice
+  // step 1:  fix up the lines
+
+  bool updated = true;
+  bool update_and_exit = false;
+
+  while (true) {
+    if (updated) {
+      for (unsigned int x = 0; x < lines.size(); x++) {
+
+        if (x == chosen) {
+          lines[x]->setRender(
+              selectedRender); // setColorize(selectedColorizer);
+        } else {
+          lines[x]->setRender(
+              unselectedRender); // setColorize(unselectedColorizer);
+        }
+      }
+      // this outputs the entire menu
+      door << *this;
+      // door << flush;
+      // door.update();
+    };
+
+    if (update_and_exit)
+      return chosen + 1;
+
+    // Maybe we want to position the cursor on the currently
+    // selected item?
+
+    updated = false;
+    // Ok, when the option changes, can I control what gets updated??!?
+    int event = door.sleep_key(door.inactivity);
+
+    if (event == -1) {
+      // timeout!
+      return -1;
+    }
+
+    // od_get_input(&event, OD_NO_TIMEOUT, GETIN_NORMAL);
+
+    if (event > XKEY_START) {
+      switch (event) {
+      case XKEY_UP_ARROW:
+        if (chosen > 0) {
+          chosen--;
+          updated = true;
+        }
+        break;
+      case XKEY_DOWN_ARROW:
+        if (chosen < lines.size() - 1) {
+          chosen++;
+          updated = true;
+        }
+        break;
+
+      case XKEY_HOME:
+        if (chosen != 0) {
+          chosen = 0;
+          updated = true;
+        }
+        break;
+      case XKEY_END:
+        if (chosen != lines.size() - 1) {
+          chosen = lines.size() - 1;
+          updated = true;
+        }
+      }
+    } else if (event == 0x0d) {
+      // ENTER -- use current selection
+      return chosen + 1;
+    }
+    for (unsigned int x = 0; x < lines.size(); x++) {
+      if (toupper(options[x]) == toupper(event)) {
+        // is the selected one current chosen?
+
+        if (chosen == x) {
+          return x + 1;
+        }
+        // No, it isn't!
+        // Update the screen, and then exit
+        updated = true;
+        chosen = x;
+        update_and_exit = true;
+      }
+    }
+  }
+
+  return 0;
+}
+
+Screen::Screen() { hidden = false; }
+
+/*
+Screen::Screen(Screen &s) {
+  hidden = s.hidden;
+  parts = s.parts;
+}
+*/
+
+void Screen::addPanel(std::shared_ptr<Panel> p) { parts.push_back(p); }
+
+void Screen::hide(void) { hidden = true; }
+void Screen::show(void) { hidden = false; }
+
+std::ostream &operator<<(std::ostream &os, const Screen &s) {
+  if (!s.hidden) {
+    for (auto part : s.parts) {
+      os << part;
+    };
+    // os << flush;
+  }
+  return os;
+}
+
+} // namespace door