implemented "M-`" in TTY mode

[sxed.git] / src / backx11 / rawtty.c

/*
 * SXED -- sexy text editor engine, 2022-2023
 *
 * low-level TTY functions
 *
 * coded by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
 * Understanding is not required. Only obedience.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3 of the License ONLY.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
#include "rawtty.h"
#ifdef USE_TTY_BACKEND

#include <errno.h>
#include <locale.h>
#include <poll.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>

#include <sys/ioctl.h>
#include <sys/types.h>

#ifdef USE_EMB_SQ3
# include "../libsq3/sqlite3.h"
#else
# include <sqlite3.h>
#endif

#include "../libsxed/sxed_encode.h"
#include "../libsxed/sxed_memman.h"
#include "../libsfrm/sxed_frame_db.h"
#include "x11_cwin.h"


//==========================================================================
//
//  ttyGetEventTypeName
//
//==========================================================================
const char *ttyGetEventTypeName (const enum TTYEventType type) {
  switch (type) {
    case TTY_None: return "None";
    case TTY_Error: return "Error";
    case TTY_Unknown: return "Unknown";
    case TTY_FirstKeyEvent: return "FirstKeyEvent";
    case TTY_Char: return "Char";
    case TTY_ModChar: return "ModChar";
    case TTY_Up: return "Up";
    case TTY_Down: return "Down";
    case TTY_Left: return "Left";
    case TTY_Right: return "Right";
    case TTY_Insert: return "Insert";
    case TTY_Delete: return "Delete";
    case TTY_PageUp: return "PageUp";
    case TTY_PageDown: return "PageDown";
    case TTY_Home: return "Home";
    case TTY_End: return "End";
    case TTY_Escape: return "Escape";
    case TTY_Backspace: return "Backspace";
    case TTY_Tab: return "Tab";
    case TTY_Enter: return "Enter";
    case TTY_Pad5: return "Pad5";
    case TTY_F1: return "F1";
    case TTY_F2: return "F2";
    case TTY_F3: return "F3";
    case TTY_F4: return "F4";
    case TTY_F5: return "F5";
    case TTY_F6: return "F6";
    case TTY_F7: return "F7";
    case TTY_F8: return "F8";
    case TTY_F9: return "F9";
    case TTY_F10: return "F10";
    case TTY_F11: return "F11";
    case TTY_F12: return "F12";
    case TTY_LastKeyEvent: return "LastKeyEvent";
    case TTY_MLeftDown: return "MLeftDown";
    case TTY_MLeftUp: return "MLeftUp";
    case TTY_MLeftMotion: return "MLeftMotion";
    case TTY_MMiddleDown: return "MMiddleDown";
    case TTY_MMiddleUp: return "MMiddleUp";
    case TTY_MMiddleMotion: return "MMiddleMotion";
    case TTY_MRightDown: return "MRightDown";
    case TTY_MRightUp: return "MRightUp";
    case TTY_MRightMotion: return "MRightMotion";
    case TTY_MWheelUp: return "MWheelUp";
    case TTY_MWheelDown: return "MWheelDown";
    case TTY_MMotion: return "MMotion";
    case TTY_MLeftClick: return "MLeftClick";
    case TTY_MMiddleClick: return "MMiddleClick";
    case TTY_MRightClick: return "MRightClick";
    case TTY_MLeftDouble: return "MLeftDouble";
    case TTY_MMiddleDouble: return "MMiddleDouble";
    case TTY_MRightDouble: return "MRightDouble";
    case TTY_PasteStart: return "PasteStart";
    case TTY_PasteEnd: return "PasteEnd";
    case TTY_FocusIn: return "FocusIn";
    case TTY_FocusOut: return "FocusOut";
  }
  return "UNKNOWN";
}


// ////////////////////////////////////////////////////////////////////////// //
static sxed_bool isAvailable = 0;
enum TermType {
  term_other,
  term_rxvt,
  term_urxvt,
  term_xterm,
  term_linuxcon, // linux console
};


static sxed_bool isInitialized = 0;
static int ttyControlFD = -1;
static sxed_bool isGood = 0;
static sxed_bool isRawMode = 0;
static sxed_bool isWaitKey = 0;
static sxed_bool wasIOError = 0;
static struct termios origMode;

static enum TermType termType = term_other;
static sxed_bool ttyIsFuckedFlag = 0;
static sxed_bool xtermMetaSendsEscape = 1; /// you should add `XTerm*metaSendsEscape: true` to "~/.Xdefaults"

static sxed_bool dbgCharDump = 0;


typedef struct SXED_PACKED PageKeyDBHdr_t {
  struct PageKeyDBHdr_t *next;
  uint16_t used; // used bytes
  /* next items are pairs of byte-counted strings: esc, keyname */
} PageKeyDBHdr;


static PageKeyDBHdr *keydb_head = nullptr;
static PageKeyDBHdr *keydb_tail = nullptr;
static uint32_t keydb_item_count = 0;


//==========================================================================
//
//  keydb_append
//
//==========================================================================
static void keydb_append (const char *name, const char *esc) {
  if (!name || !esc || !name[0] || !esc[0]) return;
  const size_t nlen = strlen(name);
  const size_t elen = strlen(esc);
  if (nlen > 255 || elen > 255) {
    fprintf(stderr, "FATAL: invalid tty key database!\n");
    exit(1);
  }

  if (!keydb_head) {
    keydb_head = sxed_mm_alloc_page();
    if (!keydb_head) {
      fprintf(stderr, "FATAL: out of memory for tty key database!\n");
      exit(1);
    }
    keydb_tail = keydb_head;
    keydb_head->next = nullptr;
    keydb_head->used = (uint16_t)sizeof(PageKeyDBHdr);
  }

  if ((uint32_t)keydb_tail->used+(uint32_t)nlen+(uint32_t)elen+2 > SXED_MEMPAGE_SIZE) {
    // need a new page!
    PageKeyDBHdr *npg = sxed_mm_alloc_page();
    if (!npg) {
      fprintf(stderr, "FATAL: out of memory for tty key database!\n");
      exit(1);
    }
    keydb_tail->next = npg;
    keydb_tail = npg;
    npg->next = nullptr;
    npg->used = (uint16_t)sizeof(PageKeyDBHdr);
  }

  PageKeyDBHdr *pg = keydb_tail;
  uint8_t *pp = ((uint8_t *)pg)+pg->used;
  pg->used += (uint16_t)nlen+(uint16_t)elen+2;
  // esc
  *pp++ = (uint8_t)elen;
  memcpy(pp, esc, elen); pp += elen;
  *pp++ = (uint8_t)nlen;
  memcpy(pp, name, nlen);

  ++keydb_item_count;
}


//==========================================================================
//
//  kdbStrEquCI
//
//==========================================================================
static sxed_bool kdbStrEquCI (const uint8_t *s0, uint32_t s0len, const char *s1) {
  const size_t s1len = strlen(s1);
  if (s1len != s0len) return 0;
  while (s0len--) {
    uint8_t c0 = *s0++;
    if (c0 >= 'A' && c0 <= 'Z') c0 = c0-'A'+'a';
    uint8_t c1 = *(const uint8_t *)s1; ++s1;
    if (c1 >= 'A' && c1 <= 'Z') c1 = c1-'A'+'a';
    if (c0 != c1) return 0;
  }
  return 1;
}


//==========================================================================
//
//  keydb_parse_name
//
//==========================================================================
static sxed_bool keydb_parse_name (TTYEvent *evt, const uint8_t *name, uint32_t nlen) {
  if (!name || !nlen || !evt) return 0;
  memset(evt, 0, sizeof(*evt));

  // parse modifiers
  while (nlen > 3 && name[1] == '-') {
    sxed_bool ok = 1;
    switch (name[0]) {
      case 'C': evt->mods |= TTY_Ctrl; break;
      case 'M': evt->mods |= TTY_Alt; break;
      case 'S': evt->mods |= TTY_Shift; break;
      case 'H': evt->mods |= TTY_Hyper; break;
      default: ok = 0;
    }
    if (!ok) break;
    nlen -= 2;
    name += 2;
  }

  // parse key name

  // fX?
  if (nlen == 2 && (name[0] == 'f' || name[0] == 'F') &&
      (name[1] >= '1' && name[1] <= '9'))
  {
    evt->type = (enum TTYEventType)(TTY_F1+name[1]-'1');
    return 1;
  }

  // f1[12]?
  if (nlen == 3 && (name[0] == 'f' || name[0] == 'F') &&
      name[1] == '1' && (name[2] == '1' || name[2] == '2'))
  {
    evt->type = (enum TTYEventType)(TTY_F11+name[2]-'1');
    return 1;
  }

  if (kdbStrEquCI(name, nlen, "left")) { evt->type = TTY_Left; return 1; }
  if (kdbStrEquCI(name, nlen, "right")) { evt->type = TTY_Right; return 1; }
  if (kdbStrEquCI(name, nlen, "up")) { evt->type = TTY_Up; return 1; }
  if (kdbStrEquCI(name, nlen, "down")) { evt->type = TTY_Down; return 1; }
  if (kdbStrEquCI(name, nlen, "home")) { evt->type = TTY_Home; return 1; }
  if (kdbStrEquCI(name, nlen, "end")) { evt->type = TTY_End; return 1; }

  if (kdbStrEquCI(name, nlen, "pgup")) { evt->type = TTY_PageUp; return 1; }
  if (kdbStrEquCI(name, nlen, "pg_up")) { evt->type = TTY_PageUp; return 1; }
  if (kdbStrEquCI(name, nlen, "pageup")) { evt->type = TTY_PageUp; return 1; }
  if (kdbStrEquCI(name, nlen, "page_up")) { evt->type = TTY_PageUp; return 1; }

  if (kdbStrEquCI(name, nlen, "pgdn")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "pg_dn")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "pgdown")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "pg_down")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "pagedn")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "page_dn")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "pagedown")) { evt->type = TTY_PageDown; return 1; }
  if (kdbStrEquCI(name, nlen, "page_down")) { evt->type = TTY_PageDown; return 1; }

  if (kdbStrEquCI(name, nlen, "ins")) { evt->type = TTY_Insert; return 1; }
  if (kdbStrEquCI(name, nlen, "insert")) { evt->type = TTY_Insert; return 1; }

  if (kdbStrEquCI(name, nlen, "del")) { evt->type = TTY_Delete; return 1; }
  if (kdbStrEquCI(name, nlen, "delete")) { evt->type = TTY_Delete; return 1; }

  if (kdbStrEquCI(name, nlen, "ret")) { evt->type = TTY_Enter; return 1; }
  if (kdbStrEquCI(name, nlen, "return")) { evt->type = TTY_Enter; return 1; }
  if (kdbStrEquCI(name, nlen, "ent")) { evt->type = TTY_Enter; return 1; }
  if (kdbStrEquCI(name, nlen, "enter")) { evt->type = TTY_Enter; return 1; }

  if (kdbStrEquCI(name, nlen, "tab")) { evt->type = TTY_Tab; return 1; }

  if (kdbStrEquCI(name, nlen, "bs")) { evt->type = TTY_Backspace; return 1; }
  if (kdbStrEquCI(name, nlen, "back")) { evt->type = TTY_Backspace; return 1; }
  if (kdbStrEquCI(name, nlen, "backspace")) { evt->type = TTY_Backspace; return 1; }

  if (kdbStrEquCI(name, nlen, "esc")) { evt->type = TTY_Escape; return 1; }
  if (kdbStrEquCI(name, nlen, "escape")) { evt->type = TTY_Escape; return 1; }

  if (kdbStrEquCI(name, nlen, "pad5")) { evt->type = TTY_Pad5; return 1; }

  if (kdbStrEquCI(name, nlen, "pastestart")) { evt->type = TTY_PasteStart; return 1; }
  if (kdbStrEquCI(name, nlen, "paste_start")) { evt->type = TTY_PasteStart; return 1; }

  if (kdbStrEquCI(name, nlen, "pasteend")) { evt->type = TTY_PasteEnd; return 1; }
  if (kdbStrEquCI(name, nlen, "paste_end")) { evt->type = TTY_PasteEnd; return 1; }

  if (kdbStrEquCI(name, nlen, "focusin")) { evt->type = TTY_FocusIn; return 1; }
  if (kdbStrEquCI(name, nlen, "focus_in")) { evt->type = TTY_FocusIn; return 1; }

  if (kdbStrEquCI(name, nlen, "focusout")) { evt->type = TTY_FocusOut; return 1; }
  if (kdbStrEquCI(name, nlen, "focus_out")) { evt->type = TTY_FocusOut; return 1; }

  return 0;
}


//==========================================================================
//
//  keydb_find_esc
//
//==========================================================================
static sxed_bool keydb_find_esc (TTYEvent *evt, const void *esc, uint32_t esclen) {
  if (!esc || !esclen || esclen > 255) return 0;
  if (keydb_item_count == 0) return 0;
  for (PageKeyDBHdr *pg = keydb_head; pg; pg = pg->next) {
    uint8_t *pp = (uint8_t *)pg;
    uint32_t ofs = (uint32_t)sizeof(PageKeyDBHdr);
    while (ofs < pg->used) {
      if (pp[ofs] == esclen && memcmp(pp+ofs+1, esc, esclen) == 0) {
        pp += esclen+1;
        if (keydb_parse_name(evt, pp+ofs+1, pp[ofs])) {
          #if 0
          FILE *fo = fopen("z_tty_kdb.log", "a");
          fwrite(esc, esclen, 1, fo);
          fprintf(fo, " : ");
          fwrite(pp+ofs+1, pp[ofs], 1, fo);
          fprintf(fo, " : mods=0x%04x; type=%u (%s)\n", evt->mods, (unsigned)evt->type,
                  ttyGetEventTypeName(evt->type));
          fclose(fo);
          #endif
          return 1;
        }
        return 0;
      }
      ofs += pp[ofs]+1;
      ofs += pp[ofs]+1;
    }
  }
  return 0;
}


//==========================================================================
//
//  keydb_load
//
//==========================================================================
static void keydb_load (const char *termname) {
  if (!termname || !termname[0]) return;

  const char *dbpath = sxed_dbman_get_db_path();
  if (!dbpath) return;
  const char *dbfile = "tty.db";
  char *dbname = sxed_mm_malloc(strlen(dbpath)+strlen(dbfile)+4);
  if (!dbname) {
    fprintf(stderr, "FATAL: out of memory for tty key database!\n");
    exit(1);
  }
  strcpy(dbname, dbpath);
  strcat(dbname, dbfile);

  sqlite3 *dbh;

  if (sqlite3_open_v2(dbname, &dbh, SQLITE_OPEN_READONLY, nullptr) != SQLITE_OK) {
    //sxed_logf("WARNING: cannot open database file '%s'!", dbname);
    sxed_mm_mfree(dbname);
    return;
  }
  sxed_mm_mfree(dbname);

  // set various options and limits
  sqlite3_busy_timeout(dbh, 1000); // busy timeout: 1 second
  sqlite3_limit(dbh, SQLITE_LIMIT_LENGTH, 1024*1024); // 1MB for the whole row is more than enough
  sqlite3_limit(dbh, SQLITE_LIMIT_SQL_LENGTH, 65536); // i believe that this is more than enough
  sqlite3_limit(dbh, SQLITE_LIMIT_COLUMN, 32); // no, really

  const char *sql = ""
    "SELECT esc, name FROM tty_keys\n"
    "WHERE term=:term\n"
    "";
  sqlite3_stmt *stmt = nullptr;
  const char *sqlEnd = nullptr;
  int pres = sqlite3_prepare_v2(dbh, sql, (int)strlen(sql), &stmt, &sqlEnd);
  if (pres != SQLITE_OK || *sqlEnd) {
    const int err = sqlite3_extended_errcode(dbh);
    sxed_logf("FATAL: cannot prepare SQL statement; err=%d: %s!", err, sqlite3_errstr(err));
    if (stmt) sqlite3_finalize(stmt);
    return;
  }

  const int argidx = sqlite3_bind_parameter_index(stmt, ":term");
  if (argidx <= 0) {
    fprintf(stderr, "FATAL: internal ttydb error (bind index)!\n");
    exit(1);
  }

  if (sqlite3_bind_text(stmt, argidx, termname, (int)strlen(termname), SQLITE_STATIC) != SQLITE_OK) {
    fprintf(stderr, "FATAL: internal ttydb error (bind)!\n");
    exit(1);
  }

  for (;;) {
    const int res = sqlite3_step(stmt);
    if (res == SQLITE_DONE) break;
    if (res != SQLITE_ROW) {
      fprintf(stderr, "FATAL: internal ttydb error (reading)!\n");
      exit(1);
    }

    const char *esc = (const char *)sqlite3_column_text(stmt, 0);
    const char *name = (const char *)sqlite3_column_text(stmt, 1);
    keydb_append(name, esc);
  }

  sqlite3_finalize(stmt);
  sqlite3_close_v2(dbh);

  #if 0
  if (keydb_item_count) {
    sxed_logf("loaded tty database for '%s' (%u item%s)", termname, keydb_item_count,
              (keydb_item_count == 1 ? "" : "s"));
  }
  #endif
}


//==========================================================================
//
//  ttyIsUsingKeyDB
//
//==========================================================================
sxed_bool ttyIsUsingKeyDB (void) {
  return (keydb_item_count != 0);
}


//==========================================================================
//
//  ttyGetTermType
//
//==========================================================================
const char *ttyGetTermType (void) {
  switch (termType) {
    case term_other: return "other";
    case term_rxvt: return "rxvt";
    case term_urxvt: return "urxvt";
    case term_xterm: return "xterm";
    case term_linuxcon: return "linux";
  }
  return "unknown";
}


//==========================================================================
//
//  ttyEnableDebugCharDump
//
//==========================================================================
void ttyEnableDebugCharDump (void) {
  dbgCharDump = 1;
}


//==========================================================================
//
//  ttyCanSetTitle
//
//==========================================================================
sxed_bool ttyCanSetTitle (void) {
  return (isAvailable && termType != term_linuxcon);
}


//==========================================================================
//
//  ttyGetControlFD
//
//==========================================================================
int ttyGetControlFD (void) {
  return ttyControlFD;
}


//==========================================================================
//
//  ttyWasIOError
//
//==========================================================================
sxed_bool ttyWasIOError (void) {
  return wasIOError;
}


//==========================================================================
//
//  ttyIsBrokenWrap
//
//==========================================================================
sxed_bool ttyIsBrokenWrap (void) {
  return (termType == term_other);
}


//==========================================================================
//
//  ttyIsUtfuck
//
//==========================================================================
sxed_bool ttyIsUtfuck (void) {
  return ttyIsFuckedFlag;
}


//==========================================================================
//
//  ttyIsAvailable
//
//  returns `false` if TTY is not available at all
//
//==========================================================================
sxed_bool ttyIsAvailable (void) {
  return isAvailable;
}


//==========================================================================
//
//  ttyIsGood
//
//  returns `true` if TTY is good and supports fancy features
//  if TTY is not good, no other API will work, and calling 'em is UB
//
//==========================================================================
sxed_bool ttyIsGood (void) {
  return isGood;
}


//==========================================================================
//
//  ttyIsInRawMode
//
//  returns current TTY mode as was previously set by `ttySetRawMode()`
//
//==========================================================================
sxed_bool ttyIsInRawMode (void) {
  return isRawMode;
}


//==========================================================================
//
//  ttyGetWidth
//
//==========================================================================
int ttyGetWidth (void) {
  if (!isGood) return 80;
  struct winsize sz;
  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &sz) != -1) return sz.ws_col;
  return 80;
}


//==========================================================================
//
//  ttyGetHeight
//
//==========================================================================
int ttyGetHeight (void) {
  if (!isGood) return 25;
  struct winsize sz;
  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &sz) != -1) return sz.ws_row;
  return 25;
}


//==========================================================================
//
//  setTTYMode
//
//==========================================================================
static sxed_bool setTTYMode (const struct termios *m) {
  if (tcsetattr(ttyControlFD, TCSAFLUSH, m) == 0) return 1;
  if (tcsetattr(ttyControlFD, TCSAFLUSH, m) == 0) return 1;
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, m) == 0) return 1;
  if (tcsetattr(STDIN_FILENO, TCSANOW, m) == 0) return 1;
  if (tcsetattr(STDOUT_FILENO, TCSAFLUSH, m) == 0) return 1;
  if (tcsetattr(STDOUT_FILENO, TCSANOW, m) == 0) return 1;
  return 0;
}


//==========================================================================
//
//  ttySetRawMode
//
//  switch TTY to raw or to normal mode
//
//==========================================================================
sxed_bool ttySetRawMode (sxed_bool enable) {
  if (!isGood) return 0; // oops
  if (isRawMode == enable) return 1; // already done
  if (enable) {
    // go to raw mode
    //enum { IUCLC = 512 }; //0001000
    //termios raw = origMode; // modify the original mode
    #ifdef RAW_TTY_OLD_SWITCH_CODE
    struct termios raw;
    memset((void *)&raw, 0, sizeof(raw));
    //tcflush(STDIN_FILENO, TCIOFLUSH);
    raw.c_iflag = IGNBRK;
    // output modes: disable post processing
    raw.c_oflag = /*OPOST|*/ONLCR;
    // control modes: set 8 bit chars
    raw.c_cflag = CS8|CLOCAL;
    // control chars: set return condition: min number of bytes and timer
    // we want read to return every single byte, without timeout
    raw.c_cc[VMIN] = (isWaitKey ? 1 : 0); // wait/poll mode
    raw.c_cc[VTIME] = 0; // no timer
    // put terminal in raw mode after flushing
    #else
    struct termios raw;
    tcflush(STDIN_FILENO, TCIOFLUSH);
    tcflush(STDOUT_FILENO, TCIOFLUSH);
    memcpy((void *)&raw, &origMode, sizeof(raw));
    raw.c_iflag &= ~(INLCR|IGNCR|ICRNL|IXON|IXOFF);
    raw.c_iflag |= IGNBRK;
    // output modes: disable post processing
    raw.c_oflag &= ~(OPOST|OCRNL|ONOCR|ONLRET);
    raw.c_oflag |= ONLCR;
    // control modes: set 8 bit chars
    //raw.c_cflag = CS8|CLOCAL;
    raw.c_lflag &= ~(ISIG|ICANON|ECHO|IEXTEN);
    // control chars: set return condition: min number of bytes and timer
    // we want read to return every single byte, without timeout
    raw.c_cc[VMIN] = (isWaitKey ? 1 : 0); // wait/poll mode
    raw.c_cc[VTIME] = 0; // no timeout
    #endif
    if (!setTTYMode(&raw)) return 0;
    // G0 is ASCII, G1 is graphics, no autowrap
    const char *setupStr = "\x1b(B\x1b)0\x0f\x1b[?7l";
    ttyRawWriteCounted(setupStr, strlen(setupStr));
  } else {
    // go to cooked mode
    if (!setTTYMode(&origMode)) return 0;
    // turn on autowrap
    const char *setupStr = "\x1b[?7h";
    ttyRawWriteCounted(setupStr, strlen(setupStr));
  }
  isRawMode = enable;
  return 1;
}


//==========================================================================
//
//  ttyIsWaitKey
//
//==========================================================================
sxed_bool ttyIsWaitKey (void) {
  return isWaitKey;
}


//==========================================================================
//
//  ttySetWaitKey
//
//  set wait/poll mode
//
//==========================================================================
sxed_bool ttySetWaitKey (sxed_bool doWait) {
  if (!isGood || !isRawMode) return 0;
  if (isWaitKey == doWait) return 1;
  struct termios raw;
  if (tcgetattr(ttyControlFD, &raw) != 0) return 0; //redirected = false;
  raw.c_cc[VMIN] = (doWait ? 1 : 0); // wait/poll mode
  if (tcsetattr(ttyControlFD, TCSAFLUSH, &raw) != 0) {
    if (tcsetattr(ttyControlFD, TCSANOW, &raw) != 0) {
      return 0;
    }
  }
  isWaitKey = doWait;
  return 1;
}


//==========================================================================
//
//  ttyRawWriteCounted
//
//==========================================================================
void ttyRawWriteCounted (const void *str, uint32_t slen) {
  if (!str || !slen) return;
  if (wasIOError) return;
  const uint8_t *buf = (const uint8_t *)str;
  while (slen) {
    const ssize_t wr = write(STDOUT_FILENO, buf, slen);
    if (wr < 0) {
      if (errno == EINTR) continue;
    }
    if (wr <= 0) {
      wasIOError = 1;
      break;
    }
    slen -= (uint32_t)wr;
    buf += (uint32_t)wr;
  }
}


//==========================================================================
//
//  ttyRawWrite
//
//==========================================================================
void ttyRawWrite (const char *str) {
  if (str && str[0]) ttyRawWriteCounted(str, strlen(str));
}


//==========================================================================
//
//  ttyBeep
//
//==========================================================================
void ttyBeep (void) {
  if (isAvailable) ttyRawWriteCounted("\x07", 1);
}


//==========================================================================
//
//  ttyEnableBracketedPaste
//
//==========================================================================
void ttyEnableBracketedPaste (void) {
  if (isGood) ttyRawWrite("\x1b[?2004h");
}


//==========================================================================
//
//  ttyDisableBracketedPaste
//
//==========================================================================
void ttyDisableBracketedPaste (void) {
  if (isGood) ttyRawWrite("\x1b[?2004l");
}


//==========================================================================
//
//  ttyEnableFocusReports
//
//==========================================================================
void ttyEnableFocusReports (void) {
  if (isGood) ttyRawWrite("\x1b[?1004h");
}


//==========================================================================
//
//  ttyDisableFocusReports
//
//==========================================================================
void ttyDisableFocusReports (void) {
  if (isGood) ttyRawWrite("\x1b[?1004l");
}


//==========================================================================
//
//  ttyEnableMouseReports
//
//==========================================================================
void ttyEnableMouseReports (void) {
  if (isGood) ttyRawWrite("\x1b[?1000h\x1b[?1006h\x1b[?1002h");
}


//==========================================================================
//
//  ttyDisableMouseReports
//
//==========================================================================
void ttyDisableMouseReports (void) {
  if (isGood) ttyRawWrite("\x1b[?1002l\x1b[?1006l\x1b[?1000l");
}


//==========================================================================
//
//  ttyWaitKey
//
//  Wait for keypress.
//
//  toMSec = timeout in milliseconds; <0: infinite; 0: don't wait; default is -1
//
//  returns `true` if key was pressed, false if no key was pressed in the given time
//
//==========================================================================
int ttyWaitKey (int toMSec) {
  if (!isGood || !isRawMode || wasIOError) return -1;
  /*
  struct timeval tv;
  fd_set fds;
  FD_ZERO(&fds);
  FD_SET(STDIN_FILENO, &fds); //STDIN_FILENO is 0
  if (toMSec <= 0) {
    tv.tv_sec = 0;
    tv.tv_usec = 0;
  } else {
    tv.tv_sec = (int)(toMSec/1000);
    tv.tv_usec = (toMSec%1000)*1000;
  }
  select(STDIN_FILENO+1, &fds, nullptr, nullptr, (toMSec < 0 ? nullptr : &tv));
  return FD_ISSET(STDIN_FILENO, &fds);
  */
  for (;;) {
    struct pollfd pfd;
    pfd.fd = STDIN_FILENO;
    pfd.events = POLLIN;
    pfd.revents = 0;
    const int res = poll(&pfd, 1, (toMSec < 0 ? -1 : toMSec));
    if (res == 0) return 0;
    if (res < 0) {
      if (toMSec >= 0) return 0;
      if (errno == EINTR) continue;
      wasIOError = 1;
      return -1;
    }
    if (pfd.revents&(POLLERR|POLLHUP|POLLNVAL)) {
      wasIOError = 1;
      return -1;
    }
    return 1;
  }
}


//==========================================================================
//
//  ttyIsKeyHit
//
//  Check if key was pressed. Don't block.
//
//  returns `true` if key was pressed, false if no key was pressed
//
//==========================================================================
int ttyIsKeyHit (void) {
  return ttyWaitKey(0);
}


//==========================================================================
//
//  ttyReadKeyByte
//
//  Read one byte from stdin.
//
//  toMSec = timeout in milliseconds; <0: infinite; 0: don't wait; default is -1
//
//  returns read byte or -1 on error/timeout
//
//==========================================================================
int ttyReadKeyByte (int toMSec) {
  if (!isGood || !isRawMode || wasIOError) return -1;
  if (ttyWaitKey(toMSec) < 1) return -1;
  uint8_t res;
  for (;;) {
    ssize_t rd = read(STDIN_FILENO, &res, 1);
    if (rd < 0 && errno == EINTR) continue;
    if (rd != 1) {
      wasIOError = 1;
      return -1;
    }
    break;
  }
  return res;
}


//==========================================================================
//
//  skipCSI
//
//==========================================================================
static void skipCSI (TTYEvent *type, int toEscMSec) {
  type->type = TTY_Unknown;
  for (;;) {
    int ch = ttyReadKeyByte(toEscMSec);
    if (ch < 0 || ch == 27) { type->type = TTY_Escape; type->ch = 27; break; }
    if (ch != ';' && (ch < '0' || ch > '9')) break;
  }
}


//==========================================================================
//
//  badCSI
//
//==========================================================================
static void badCSI (TTYEvent *type) {
  //const double tsv = type->time;
  memset((void *)type, 0, sizeof(*type));
  type->type = TTY_Unknown;
  //type->time = tsv;
}


//==========================================================================
//
//  xtermMods
//
//==========================================================================
static sxed_bool xtermMods (TTYEvent *type, unsigned mci) {
  switch (mci) {
    case 2: type->mods |= TTY_Shift; return 1;
    case 3: type->mods |= TTY_Alt; return 1;
    case 4: type->mods |= TTY_Alt|TTY_Shift; return 1;
    case 5: type->mods |= TTY_Ctrl; return 1;
    case 6: type->mods |= TTY_Ctrl|TTY_Shift; return 1;
    case 7: type->mods |= TTY_Alt|TTY_Ctrl; return 1;
    case 8: type->mods |= TTY_Alt|TTY_Ctrl|TTY_Shift; return 1;
    default: break;
  }
  return 0;
}


//==========================================================================
//
//  xtermSpecial
//
//==========================================================================
static void xtermSpecial (TTYEvent *type, char ch) {
  switch (ch) {
    case 'A': type->type = TTY_Up; break;
    case 'B': type->type = TTY_Down; break;
    case 'C': type->type = TTY_Right; break;
    case 'D': type->type = TTY_Left; break;
    case 'E': type->type = TTY_Pad5; break;
    case 'H': type->type = TTY_Home; break;
    case 'F': type->type = TTY_End; break;
    case 'P': type->type = TTY_F1; break;
    case 'Q': type->type = TTY_F2; break;
    case 'R': type->type = TTY_F3; break;
    case 'S': type->type = TTY_F4; break;
    case 'Z':
      type->type = TTY_Tab;
      type->ch = 9;
      if ((type->mods&(TTY_Alt|TTY_Ctrl|TTY_Shift)) == 0) type->mods |= TTY_Shift;
      break;
    default: badCSI(type); break;
  }
}


//==========================================================================
//
//  linconSpecial
//
//==========================================================================
static void linconSpecial (TTYEvent *type, char ch) {
  switch (ch) {
    case 'A': type->type = TTY_F1; break;
    case 'B': type->type = TTY_F2; break;
    case 'C': type->type = TTY_F3; break;
    case 'D': type->type = TTY_F4; break;
    default: badCSI(type); break;
  }
}


//==========================================================================
//
//  csiSpecial
//
//==========================================================================
static void csiSpecial (TTYEvent *type, unsigned n) {
  switch (n) {
    case 1: type->type = TTY_Home; return; // xterm
    case 2: type->type = TTY_Insert; return;
    case 3: type->type = TTY_Delete; return;
    case 4: type->type = TTY_End; return;
    case 5: type->type = TTY_PageUp; return;
    case 6: type->type = TTY_PageDown; return;
    case 7: type->type = TTY_Home; return; // rxvt
    case 8: type->type = TTY_End; return;
    case 1+10: type->type = TTY_F1; return;
    case 2+10: type->type = TTY_F2; return;
    case 3+10: type->type = TTY_F3; return;
    case 4+10: type->type = TTY_F4; return;
    case 5+10: type->type = TTY_F5; return;
    case 6+11: type->type = TTY_F6; return;
    case 7+11: type->type = TTY_F7; return;
    case 8+11: type->type = TTY_F8; return;
    case 9+11: type->type = TTY_F9; return;
    case 10+11: type->type = TTY_F10; return;
    case 11+12: type->type = TTY_F11; return;
    case 12+12: type->type = TTY_F12; return;
    default: badCSI(type); break;
  }
}


//==========================================================================
//
//  parseMouse
//
//  {\e}[<0;58;32M (button;x;y;[Mm])
//
//==========================================================================
static void parseMouse (TTYEvent *type, int toEscMSec) {
  unsigned nn[3] = {0,0,0};
  unsigned nc = 0;
  sxed_bool press = 0;
  for (;;) {
    int ch = ttyReadKeyByte(toEscMSec);
    if (ch < 0 || ch == 27) { type->type = TTY_Escape; type->ch = 27; return; }
    if (ch == ';') {
      ++nc;
    } else if (ch >= '0' && ch <= '9') {
      if (nc < 3) nn[nc] = nn[nc]*10+ch-'0';
    } else {
           if (ch == 'M') press = 1;
      else if (ch == 'm') press = 0;
      else { type->type = TTY_Unknown; return; }
      break;
    }
  }
  if (nn[1] > 0) --nn[1];
  if (nn[2] > 0) --nn[2];
  //if (nn[1] < 0) nn[1] = 1;
  if (nn[1] > 0x7fffu) nn[1] = 0x7fffu;
  //if (nn[2] < 0) nn[2] = 1;
  if (nn[2] > 0x7fffu) nn[2] = 0x7fffu;
  switch (nn[0]) {
    case 0: type->type = (press ? TTY_MLeftDown : TTY_MLeftUp); break;
    case 1: type->type = (press ? TTY_MMiddleDown : TTY_MMiddleUp); break;
    case 2: type->type = (press ? TTY_MRightDown : TTY_MRightUp); break;
    case 32: if (!press) { type->type = TTY_Unknown; return; } type->type = TTY_MLeftMotion; break;
    case 33: if (!press) { type->type = TTY_Unknown; return; } type->type = TTY_MMiddleMotion; break;
    case 34: if (!press) { type->type = TTY_Unknown; return; } type->type = TTY_MRightMotion; break;
    case 64: if (!press) { type->type = TTY_Unknown; return; } type->type = TTY_MWheelUp; break;
    case 65: if (!press) { type->type = TTY_Unknown; return; } type->type = TTY_MWheelDown; break;
    default: type->type = TTY_Unknown; return;
  }
  type->x = nn[1];
  type->y = nn[2];
}


//==========================================================================
//
//  ttyReadKeyUseDB
//
//==========================================================================
static sxed_bool ttyReadKeyUseDB (TTYEvent *type, int toEscMSec) {
  uint8_t esc[129];
  uint32_t epos = 1;
  sxed_bool urxvt_idiocity = 0;
  int ch;

  esc[0] = 27;

  ch = ttyReadKeyByte(toEscMSec);
  if (ch < 0) {
    if (wasIOError) {
      type->type = TTY_Error;
      return 0;
    }
    type->type = TTY_Escape;
    type->ch = 27;
    return 1;
  }

  if (ch == 27) {
    if (termType != term_urxvt || ttyIsKeyHit() < 1) {
      type->type = TTY_Escape;
      type->ch = 27;
      return 1;
    }
    // urxvt does M-Fx as "esc, esc, [, ..."
    ch = ttyReadKeyByte(0);
    if (ch < 0) {
      if (wasIOError) {
        type->type = TTY_Error;
        return 0;
      }
      type->type = TTY_Escape;
      type->ch = 27;
      return 1;
    }
    if (ch != '[') {
      //FIXME: need to unread a char
      type->type = TTY_Escape;
      type->ch = 27;
      return 1;
    }
    urxvt_idiocity = 1;
  }

  if (ch == '[' || ch == ']' || ch == '(' || ch == ')' ||
      ch == 'O'/*xterm idiocity*/)
  {
    esc[epos++] = (uint8_t)ch;
    for (;;) {
      ch = ttyReadKeyByte(toEscMSec);
      if (ch < 0) {
        type->type = TTY_Error;
        return 0;
      }
      esc[epos] = (uint8_t)ch;
      if (epos < 128) ++epos;
      if ((ch >= '0' && ch <= '9') || ch == ';') continue;
      break;
    }
  } else if (ch == 9) {
    type->type = TTY_Tab;
    type->mods |= TTY_Alt;
    type->ch = 9;
    return 1;
  } else if (ch >= 1 && ch <= 26) {
    type->type = TTY_ModChar;
    type->mods |= TTY_Alt|TTY_Ctrl;
    type->ch = (unsigned)(ch+64);
         if (type->ch == 'H') { type->type = TTY_Backspace; type->mods &= ~TTY_Ctrl; type->ch = 8; }
    else if (type->ch == 'J') { type->type = TTY_Enter; type->mods &= ~TTY_Ctrl; type->ch = 13; }
    return 1;
  } else if (/*(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '`'*/1) {
    type->mods |= TTY_Alt;
    type->type = TTY_ModChar;
    if (ch >= 'A' && ch <= 'Z') type->mods |= TTY_Shift; // ignore capslock
    if (ch >= 'a' && ch <= 'z') ch -= 32;
    type->ch = (unsigned)ch;
    return 1;
  } else {
    type->type = TTY_Unknown;
    return 1;
  }

  if (epos >= 128) {
    type->type = TTY_Unknown;
    return 1;
  }

  if (!keydb_find_esc(type, esc, epos)) {
    memset(type, 0, sizeof(*type));
    type->type = TTY_Unknown;
  } else {
    if (urxvt_idiocity) type->mods |= TTY_Alt;
  }

  return 1;
}


//==========================================================================
//
//  ttyReadKey
//
//  Read key from stdin.
//
//  WARNING! no utf-8 support yet!
//
//  toMSec = timeout in milliseconds; <0: infinite; 0: don't wait; default is -1
//  toEscMSec = timeout in milliseconds for escape sequences
//
//==========================================================================
SXED_PUBLIC sxed_bool ttyReadKey (TTYEvent *type, int toMSec, int toEscMSec) {
  if (!type) return 0;
  memset((void *)type, 0, sizeof(*type));
  //type->time = Sys_Time();

  int ch = ttyReadKeyByte(toMSec);

  // error?
  if (ch < 0) {
    type->type = TTY_Error;
    return 0;
  }

  // zero char is C-Space
  if (ch == 0) {
    type->type = TTY_ModChar;
    type->mods |= TTY_Ctrl;
    type->ch = ' ';
    return 1;
  }

  // backspace
  if (ch == 8 || ch == 127) {
    type->type = TTY_Backspace;
    type->ch = 8;
    return 1;
  }

  // tab
  if (ch == 9) {
    type->type = TTY_Tab;
    type->ch = 9;
    return 1;
  }

  //if (ch == 10) { key.key = TtyEvent.TTY_Enter; key.ch = 13; return key; }
  if (ch == 13) {
    type->type = TTY_Enter;
    type->ch = 13;
    return 1;
  }

  type->type = TTY_Unknown;

  // escape?
  if (ch == 27) {
    // from db?
    if (keydb_item_count != 0) {
      return ttyReadKeyUseDB(type, toEscMSec);
    }
    ch = ttyReadKeyByte(toEscMSec);
    int urxvt_idiocity = 0;
    if (ch < 0 || ch == 27) {
      if (ch != 27 || termType != term_urxvt || ttyIsKeyHit() < 1) {
        type->type = TTY_Escape;
        type->ch = 27;
        return 1;
      }
      // urxvt does M-Fx as "esc, esc, [, ..."
      ch = ttyReadKeyByte(0);
      if (ch != '[') {
        //FIXME: need to unread a char
        type->type = TTY_Escape;
        type->ch = 27;
        return 1;
      }
      urxvt_idiocity = 1;
    }
    // xterm stupidity
    if (termType != term_rxvt && termType != term_urxvt && ch == 'O') {
      ch = ttyReadKeyByte(toEscMSec);
      if (ch < 0 || ch == 27) { type->type = TTY_Escape; type->ch = 27; return 1; }
      if (ch >= 'A' && ch <= 'Z') xtermSpecial(type, (char)ch);
      if (ch >= 'a' && ch <= 'z') { type->mods |= TTY_Shift; xtermSpecial(type, (char)(ch-32)); }
      return 1;
    }
    // CSI
    if (ch == '[') {
      unsigned nn[2] = {0,0};
      unsigned nc = 0;
      sxed_bool wasDigit = 0;
      sxed_bool firstChar = 1;
      sxed_bool linuxCon = 0;
      // parse csi
      for (;;) {
        ch = ttyReadKeyByte(toEscMSec);
        if (firstChar) {
          firstChar = 0;
          if (ch == '<') { parseMouse(type, toEscMSec); return 1; }
          if (ch == 'I') { type->type = TTY_FocusIn; return 1; }
          if (ch == 'O') { type->type = TTY_FocusOut; return 1; }
          if (ch == '[') { linuxCon = 1; continue; }
        }
        if (ch < 0 || ch == 27) { type->type = TTY_Escape; type->ch = 27; return 1; }
        if (ch == ';') {
          ++nc;
          if (nc > 2) { skipCSI(type, toEscMSec); return 1; }
          wasDigit = 0;
        } else if (ch >= '0' && ch <= '9') {
          if (nc >= 2) { skipCSI(type, toEscMSec); return 1; }
          nn[nc] = nn[nc]*10+ch-'0';
          wasDigit = 1;
        } else {
          if (wasDigit) ++nc;
          break;
        }
      }
      if (dbgCharDump) {
        FILE *fo = fopen("zzz.zzz", "a");
        fprintf(fo, "nc=%u", nc);
        for (unsigned idx = 0; idx < nc; ++idx) {
          fprintf(fo, "; n%u=%u", idx, nn[idx]);
        }
        fprintf(fo, "; ch=%c\n", ch);
        fclose(fo);
      }
      // process specials
      if (nc == 0) {
             if (linuxCon) linconSpecial(type, (char)ch);
        else if (ch >= 'A' && ch <= 'Z') xtermSpecial(type, (char)ch);
      } else if (nc == 1) {
        if (ch == '~' && nn[0] == 200) { type->type = TTY_PasteStart; return 1; }
        if (ch == '~' && nn[0] == 201) { type->type = TTY_PasteEnd; return 1; }
        switch (ch) {
          case '~':
            if (urxvt_idiocity) {
              switch (nn[0]) {
                case 11: type->mods |= TTY_Alt; type->type = TTY_F1; return 1;
                case 12: type->mods |= TTY_Alt; type->type = TTY_F2; return 1;
                case 13: type->mods |= TTY_Alt; type->type = TTY_F3; return 1;
                case 14: type->mods |= TTY_Alt; type->type = TTY_F4; return 1;
                case 15: type->mods |= TTY_Alt; type->type = TTY_F5; return 1;
                case 17: type->mods |= TTY_Alt; type->type = TTY_F6; return 1;
                case 18: type->mods |= TTY_Alt; type->type = TTY_F7; return 1;
                case 19: type->mods |= TTY_Alt; type->type = TTY_F8; return 1;
                case 20: type->mods |= TTY_Alt; type->type = TTY_F9; return 1;
                case 21: type->mods |= TTY_Alt; type->type = TTY_F10; return 1;
                //case 23: type->mods |= TTY_Alt; type->type = TTY_F11; return 1; // M-S-F1
                //case 24: type->mods |= TTY_Alt; type->type = TTY_F12; return 1; // M-S-F2

                case 23: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F1; return 1;
                case 24: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F2; return 1;
                case 25: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F3; return 1;
                case 26: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F4; return 1;
                case 28: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F5; return 1;
                case 29: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F6; return 1;
                case 31: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F7; return 1;
                case 32: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F8; return 1;
                case 33: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F9; return 1;
                case 34: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F10; return 1;
                default: break;
              }
            } else {
              switch (nn[0]) {
                case 23: type->mods |= TTY_Shift; type->type = TTY_F1; return 1;
                case 24: type->mods |= TTY_Shift; type->type = TTY_F2; return 1;
                case 25: type->mods |= TTY_Shift; type->type = TTY_F3; return 1;
                case 26: type->mods |= TTY_Shift; type->type = TTY_F4; return 1;
                case 28: type->mods |= TTY_Shift; type->type = TTY_F5; return 1;
                case 29: type->mods |= TTY_Shift; type->type = TTY_F6; return 1;
                case 31: type->mods |= TTY_Shift; type->type = TTY_F7; return 1;
                case 32: type->mods |= TTY_Shift; type->type = TTY_F8; return 1;
                case 33: type->mods |= TTY_Shift; type->type = TTY_F9; return 1;
                case 34: type->mods |= TTY_Shift; type->type = TTY_F10; return 1;
                default: break;
              }
            }
            break;
          case '^': type->mods |= TTY_Ctrl; break;
          case '$':
            if (urxvt_idiocity) {
              switch (nn[0]) {
                case 23: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F11; return 1;
                case 24: type->mods |= TTY_Alt|TTY_Shift; type->type = TTY_F12; return 1;
              }
            }
            type->mods |= TTY_Shift;
            break;
          case '@': type->mods |= TTY_Ctrl|TTY_Shift; break;
          case 'A' ... 'Z': xtermMods(type, nn[0]); xtermSpecial(type, (char)ch); return 1;
          default: badCSI(type); return 1;
        }
        csiSpecial(type, nn[0]);
      } else if (nc == 2 && xtermMods(type, nn[1])) {
        if (nn[0] == 1 && ch >= 'A' && ch <= 'Z') {
          xtermSpecial(type, (char)ch);
        } else if (ch == '~') {
          csiSpecial(type, nn[0]);
        }
      } else {
        badCSI(type);
      }
      return 1;
    } // end of CSI

    if (ch == 9) {
      type->type = TTY_Tab;
      type->mods |= TTY_Alt;
      type->ch = 9;
      return 1;
    }

    if (ch >= 1 && ch <= 26) {
      type->type = TTY_ModChar;
      type->mods |= TTY_Alt|TTY_Ctrl;
      type->ch = (unsigned)(ch+64);
           if (type->ch == 'H') { type->type = TTY_Backspace; type->mods &= ~TTY_Ctrl; type->ch = 8; }
      else if (type->ch == 'J') { type->type = TTY_Enter; type->mods &= ~TTY_Ctrl; type->ch = 13; }
      return 1;
    }

    if (/*(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '`'*/1) {
      type->mods |= TTY_Alt;
      type->type = TTY_ModChar;
      if (ch >= 'A' && ch <= 'Z') type->mods |= TTY_Shift; // ignore capslock
      if (ch >= 'a' && ch <= 'z') ch -= 32;
      type->ch = (unsigned)ch;
      return 1;
    }
    return 1;
  }

  if (ch == 9) {
    type->type = TTY_Tab;
    type->ch = 9;
  } else if (ch < 32) {
    // ctrl+letter
    type->type = TTY_ModChar;
    type->mods |= TTY_Ctrl;
    type->ch = (unsigned)(ch+64);
         if (type->ch == 'H') { type->type = TTY_Backspace; type->mods &= ~TTY_Ctrl; type->ch = 8; }
    else if (type->ch == 'J') { type->type = TTY_Enter; type->mods &= ~TTY_Ctrl; type->ch = 13; }
  } else {
    type->type = TTY_Char;
    type->ch = (unsigned)ch;
    if (ttyIsFuckedFlag && ch >= 0x80) {
      uint32_t udc = 0;
      for (;;) {
        udc = sxed_utf8d_consume(udc, ch&0xff);
        if (sxed_utf8_valid_cp(udc)) {
          // done
          type->ch = (udc == SXED_UTF8_REPLACEMENT_CP ? '?' : udc);
          break;
        }
        // want more shit!
        ch = ttyReadKeyByte(toEscMSec);
        if (ch < 0) {
          type->ch = '?';
          break;
        }
      }
    } else {
      // xterm does alt+letter with 7th bit set
      if (keydb_item_count == 0 && !xtermMetaSendsEscape && termType == term_xterm &&
          ch >= 0x80 && ch <= 0xff)
      {
        ch -= 0x80;
        if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_') {
          type->mods |= TTY_Alt;
          type->type = TTY_ModChar;
          if (ch >= 'A' && ch <= 'Z') type->mods |= TTY_Shift; // ignore capslock
          if (ch >= 'a' && ch <= 'z') ch -= 32;
          type->ch = (unsigned)ch;
          return 1;
        }
      }
    }
  }

  return 1;
}


//==========================================================================
//
//  isStartsWithCI
//
//==========================================================================
static sxed_bool isStartsWithCI (const char *s, const char *pat) {
  if (!s || !pat || !s[0] || !pat[0]) return 0;
  while (*s && *pat) {
    char cs = *s++;
    if (cs >= 'A' && cs <= 'Z') cs = cs-'A'+'a';
    char cp = *pat++;
    if (cp >= 'A' && cp <= 'Z') cp = cp-'A'+'a';
    if (cs != cp) return 0;
  }
  return (pat[0] == 0);
}


//==========================================================================
//
//  ttyInitialize
//
//==========================================================================
void ttyInitialize (void) {
  if (isInitialized) return;
  isInitialized = 1;

  isAvailable = (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO));
  ttyIsFuckedFlag = 0;

  const char *lang = setlocale(LC_ALL, nullptr);
  //fprintf(stderr, "LOCALE: <%s>\n", lang);
  if (lang) {
    while (*lang) {
      if ((lang[0] == 'U' || lang[0] == 'u') &&
          (lang[1] == 'T' || lang[1] == 't') &&
          (lang[2] == 'F' || lang[2] == 'f'))
      {
        ttyIsFuckedFlag = 1;
        break;
      }
      ++lang;
    }
  }

  ttyControlFD = -1;
  if (isAvailable) {
    if (tcgetattr(STDIN_FILENO, &origMode) == 0) ttyControlFD = STDIN_FILENO;
    else if (tcgetattr(STDOUT_FILENO, &origMode) == 0) ttyControlFD = STDOUT_FILENO;
  }
  isGood = (ttyControlFD >= 0);

  const char *tt = getenv("TERM");
  if (tt) {
         if (isStartsWithCI(tt, "rxvt-unicode")) termType = term_urxvt;
    else if (isStartsWithCI(tt, "rxvt")) termType = term_rxvt;
    else if (isStartsWithCI(tt, "xterm")) termType = term_xterm;
    else if (isStartsWithCI(tt, "linux")) termType = term_linuxcon;
  }
}


//==========================================================================
//
//  ttyLoadDatabase
//
//==========================================================================
void ttyLoadDatabase (void) {
  if (!isInitialized) ttyInitialize();
  if (isGood && keydb_item_count == 0) keydb_load(getenv("TERM"));
}


//==========================================================================
//
//  rawtty_ctor_deinitializer
//
//==========================================================================
static __attribute__((destructor)) void rawtty_ctor_deinitializer (void) {
  if (isInitialized) {
    if (isRawMode) {
      // switch to normal screen
      ttyRawWrite("\x1b[?1049l");
    }
    ttySetRawMode(0);
    if (isGood) ttyRawWrite("\x1b[0m"); // reset color
  }
}


//==========================================================================
//
//  tty_convert_event_char
//
//==========================================================================
static inline KeySym tty_convert_event_char (const TTYEvent *type) {
  if (type->ch >= 'a' && type->ch <= 'z') return type->ch-'a'+XK_a;
  if (type->ch >= 'A' && type->ch <= 'Z') return type->ch-'A'+XK_a;
  if (type->ch >= '0' && type->ch <= '9') return type->ch-'0'+XK_0;
  switch (type->ch) {
    case 9: return XK_Tab;
    case 13: return XK_Return;
    case 27: return XK_Escape;
    case 32: return XK_space;
    case '`': return XK_grave;
    case 127: return XK_BackSpace;
  }
  return XK_VoidSymbol;
}


//==========================================================================
//
//  tty_convert_event
//
//==========================================================================
sxed_bool tty_convert_event (const TTYEvent *type, sxed_keycode *kcode, char textbuf[128]) {
  if (!type || !kcode) return 0;
  KeySym ksym = XK_VoidSymbol;
  memset(kcode, 0, sizeof(*kcode));

  uint32_t kmods = 0;
  if (type->mods&TTY_Shift) kmods |= SXED_X11_KMOD_SHIFT;
  if (type->mods&TTY_Alt) kmods |= SXED_X11_KMOD_ALT;
  if (type->mods&TTY_Ctrl) kmods |= SXED_X11_KMOD_CTRL;
  if (type->mods&TTY_Hyper) kmods |= SXED_X11_KMOD_HYPER;

  //if (ksym >= XK_A && ksym <= XK_Z) ksym = ksym-XK_A+XK_a;
  //if (ksym == XK_VoidSymbol) ksym = 0;
  switch (type->type) {
    case TTY_Char:
      ksym = tty_convert_event_char(type);
      if (type->ch && type->ch != 127) {
        if (type->ch >= 32 && type->ch < 127) {
          textbuf[0] = (char)type->ch;
          textbuf[1] = 0;
          kcode->text = textbuf;
          kcode->ascii = (char)type->ch;
        } else {
          const uint32_t uch = (ttyIsUtfuck() ? type->ch : sxed_koi2uni(type->ch));
          const uint32_t ulen = sxed_utf8_encode(textbuf, uch);
          textbuf[ulen] = 0;
          kcode->text = textbuf;
        }
      }
      break;

    case TTY_ModChar: // char with some modifier
      ksym = tty_convert_event_char(type);
      break;

    case TTY_Up: ksym = XK_Up; break;
    case TTY_Down: ksym = XK_Down; break;
    case TTY_Left: ksym = XK_Left; break;
    case TTY_Right: ksym = XK_Right; break;
    case TTY_Insert: ksym = XK_Insert; break;
    case TTY_Delete: ksym = XK_Delete; break;
    case TTY_PageUp: ksym = XK_Page_Up; break;
    case TTY_PageDown: ksym = XK_Page_Down; break;
    case TTY_Home: ksym = XK_Home; break;
    case TTY_End: ksym = XK_End; break;

    case TTY_Escape: ksym = XK_Escape; break;
    case TTY_Backspace: ksym = XK_BackSpace; break;
    case TTY_Tab: ksym = XK_Tab; break;
    case TTY_Enter: ksym = XK_Return; break;

    case TTY_F1: ksym = XK_F1; break;
    case TTY_F2: ksym = XK_F2; break;
    case TTY_F3: ksym = XK_F3; break;
    case TTY_F4: ksym = XK_F4; break;
    case TTY_F5: ksym = XK_F5; break;
    case TTY_F6: ksym = XK_F6; break;
    case TTY_F7: ksym = XK_F7; break;
    case TTY_F8: ksym = XK_F8; break;
    case TTY_F9: ksym = XK_F9; break;
    case TTY_F10: ksym = XK_F10; break;
    case TTY_F11: ksym = XK_F11; break;
    case TTY_F12: ksym = XK_F12; break;

    default: return 0;
  }

  if (ksym == XK_VoidSymbol && !kcode->text) return 0;

  kcode->key_mods = kmods|(uint32_t)ksym;
  return 1;
}


#endif