door.h

#ifndef DOOR_H
#define DOOR_H
 
#include "anyoption.h"
#include <cstdint>
#include <ctime>
#include <fstream>
#include <functional>
#include <future>
#include <iostream>
#include <list>
#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
 
namespace door {
 
extern bool unicode;
extern bool full_cp437;
extern bool debug_capture;
extern std::list<char> pushback;
 
/*
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
 */
 
enum class COLOR : std::int8_t {
  BLACK,
  RED,
  GREEN,
  BROWN,
  YELLOW = 3,
  BLUE,
  MAGENTA,
  CYAN,
  WHITE
};
 
enum class ATTR : std::int8_t {
  RESET,
  BOLD,
  BRIGHT = 1,
  BLINK = 5,
  INVERSE = 7
};
 
class ANSIColor {
  COLOR fg;
  COLOR bg;
  // Track attributes (ATTR)
  unsigned int reset : 1;
  unsigned int bold : 1;
  unsigned int blink : 1;
  unsigned int inverse : 1;
 
public:
  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;
  void setFg(COLOR f);
  void setFg(COLOR f, ATTR a);
  void setBg(COLOR b);
  COLOR getFg() { return fg; };
  COLOR getBg() { return bg; };
  void attr(ATTR a);
 
  std::string output(void) const;
  std::string debug(void);
  std::string output(ANSIColor &previous) const;
  friend std::ostream &operator<<(std::ostream &os, const ANSIColor &c);
};
 
class Door : public std::ostream, private std::streambuf {
 
private:
  std::streamsize xsputn(const char *s, std::streamsize n) override;
  int overflow(int c) override;
  std::string doorname;
  void parse_dropfile(const char *filepath);
  void init(void);
  std::time_t startup;
  struct termios tio_default;
  signed int getch(void);
  signed int getkey_or_pushback(void);
  bool has_dropfile;
  bool debugging;
  std::string dropfilename;
  vector<std::string> dropfilelines;
  ofstream logf;
  void detect_unicode_and_screen(void);
  std::promise<void> stop_thread;
 
  int seconds_elapsed;
  void time_thread_run(std::future<void> future);
  std::thread time_thread;
 
public:
  Door(std::string dname, int argc, char *argv[]);
  Door(Door &) = delete;
  virtual ~Door();
  ofstream &log(void);
  AnyOption opt;
  std::string debug_buffer;
 
  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;
  atomic<int> time_used;
 
  signed int getkey(void);
  bool haskey(void);
  signed int sleep_key(int secs);
  std::string input_string(int max);
  int get_one_of(const char *keys);
};
 
// Use this to define the deprecated colorizer  [POC]
// typedef std::function<void(Door &, std::string &)> colorFunction;
 
class ColorOutput {
public:
  ColorOutput();
  void reset(void);
 
  ANSIColor c;
  int pos;
  int len;
};
 
/*
No, don't do this.
 
Instead, return an iterator/generator.
 */
 
class Render {
public:
  Render(const std::string txt);
  const std::string text;
  std::vector<ColorOutput> outputs;
  void append(ANSIColor color, int len = 1);
  void output(std::ostream &os);
};
 
typedef std::function<Render(const std::string &)> renderFunction;
 
typedef std::function<std::string(void)> updateFunction;
 
class Clrscr {
public:
  Clrscr(void);
  friend std::ostream &operator<<(std::ostream &os, const Clrscr &clr);
};
 
extern Clrscr cls;
 
class NewLine {
public:
  NewLine(void);
  friend std::ostream &operator<<(std::ostream &os, const NewLine &nl);
};
 
extern NewLine nl;
 
extern ANSIColor reset;
 
enum class Justify { NONE, LEFT, RIGHT, CENTER };
 
class Goto {
  int x;
  int y;
 
public:
  Goto(int xpos, int ypos);
  Goto(const Goto &) = default;
  void set(int xpos, int ypos);
  friend std::ostream &operator<<(std::ostream &os, const Goto &g);
};
 
extern const char SaveCursor[];
extern const char RestoreCursor[];
 
#ifdef EXPERIMENTAL
 
/* 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 render;
  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);
};
 
#endif
 
class Line {
private:
  std::string text;
 
  bool hasColor;
  ANSIColor color;
  std::string padding;
  ANSIColor paddingColor;
 
  renderFunction render;
  updateFunction updater;
 
  int width;
 
  // void makeWidth(int width);
 
public:
  Line(const std::string &txt, int width = 0);
  Line(const char *txt, int width = 0);
  Line(const std::string &txt, int width, ANSIColor c);
  Line(const char *txt, int width, ANSIColor c);
  Line(const std::string &txt, int width, renderFunction rf);
  Line(const char *txt, int width, renderFunction rf);
  Line(const Line &rhs);
  Line(Line &&rhs);
  // ~Line();
 
  bool hasRender(void);
  int length(void); //  const;
  void fit(void);
  void setPadding(std::string &padstring, ANSIColor padColor);
  void setPadding(const char *padstring, ANSIColor padcolor);
  void setText(std::string &txt);
  void setText(const char *txt);
  const char *getText(void) { return text.c_str(); };
  void setColor(ANSIColor c);
  void setRender(renderFunction rf);
  void setUpdater(updateFunction uf);
  bool update(void);
 
  std::string debug(void);
 
  friend std::ostream &operator<<(std::ostream &os, const Line &l);
};
 
extern renderFunction rBlueYellow;
 
enum class BorderStyle {
  NONE,
  SINGLE,
  DOUBLE,
  SINGLE_DOUBLE,
  DOUBLE_SINGLE,
  BLANK
};
 
class Panel {
protected:
  int x;
  int y;
  int width; // or padding ?
  BorderStyle border_style;
  ANSIColor border_color;
  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(int width);
 
  // Panel(const Panel &);
  Panel(Panel &) = delete; // default;
  Panel(Panel &&ref);
 
  void set(int x, int y);
  /*
  void get(int &x, int &y) {
    x = this->x;
    y = this->y;
  }; */
  void setTitle(std::unique_ptr<Line> T, int off = 1);
  void setStyle(BorderStyle bs);
  void setColor(ANSIColor c);
  int getWidth(void) { return width; };
  int getHeight(void) {
    if (border_style == BorderStyle::NONE)
      return lines.size();
    else
      return lines.size() + 2;
  };
  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);
  */
 
  bool update(Door &d);
  void update(Door &d, int line);
  void update(void);
  door::Goto gotoEnd(void);
  std::unique_ptr<Line> spacer_line(bool single);
  void lineSetBack(ANSIColor back);
  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(int width);
  // Menu(const Menu &);
  Menu(const Menu &) = delete;
  Menu(Menu &&);
 
  void addSelection(char c, const char *line);
  void addSelection(char c, const char *line, updateFunction update);
  void defaultSelection(int d);
  void setRender(bool selected, renderFunction render);
 
  int choose(Door &door);
  char which(int d);
 
  static renderFunction makeRender(ANSIColor c1, ANSIColor c2, ANSIColor c3,
                                   ANSIColor c4);
};
 
class Screen {
private:
  // bool hidden;
  std::vector<std::unique_ptr<Panel>> panels;
 
public:
  Screen(void);
  Screen(Screen &) = default;
  void addPanel(std::unique_ptr<Panel> p);
  /*
bool delPanel(std::shared_ptr<Panel> p);
 
void hide(void);
void show(void);
*/
  bool update(Door &d);
  void update(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
#endif