/* unix.c V1.1.1
 *
 * Unix (med X11) systemspesifikk kode for TIKI-100_emul
 * Copyright (C) Asbjørn Djupdal 2001
 */

#include "TIKI-100_emul.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#ifndef FIONREAD
#include <sys/filio.h>  /* antar at FIONREAD er definert i sys/filio.h */
#endif

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h>
#include <X11/keysym.h>

#define STATUSBAR_HEIGHT 19

/* protos */
int main (int argc, char *argv[]);
static void update (int x, int y, int w, int h);
static void createStatusBar (void);
static byte keysymToTikikey (KeySym keysym);
static void commandline (void);
static void readDiskImage (int drive, char *filename);
static void setParam (int portfd, struct serParams *params);
static void setPrintCmd (char *p);
static void setPrintFile (char *p);

/* variabler */

static byte *dsk[2] = {NULL, NULL};
static int dsksize[2] = {0, 0};
static int resolution = MEDRES;
static byte pressedKeys[256];
static boolean updateWindow = FALSE;
static unsigned int xmin = (unsigned)~0;
static unsigned int ymin = (unsigned)~0;
static unsigned int xmax = 0;
static unsigned int ymax = 0;
static boolean scanlines;
static boolean slowDown;
static int width[3];
static int height[3];
static int times40;
static int times80;
static byte *screen;
static FILE *printCmd = 0;
static FILE *printFile = 0;
static int port1 = 0;
static int port2 = 0;
static boolean lock = FALSE;
static boolean grafikk = FALSE;
static boolean disk[2] = {FALSE, FALSE};
static boolean dyn_cmap;
static Colormap default_cmap;
static unsigned long pixels[16];
static unsigned long blackpix, whitepix, backpix, diodepix;
static Display *display;
static Window mainwindow;
static Pixmap mainpixmap;
static GC colorGC[16];
static GC blackGC, backGC, diodeGC;
static XrmDatabase options_db = NULL;
static XSizeHints xsh;

static XrmOptionDescRec options[] = {
  {"-display", "*display", XrmoptionSepArg, NULL},
  {"-d", "*display", XrmoptionSepArg, NULL},
  {"-geometry", "*geometry", XrmoptionSepArg, NULL},
  {"-g", "*geometry", XrmoptionSepArg, NULL},
  {"-diska", "*diska", XrmoptionSepArg, NULL},
  {"-diskb", "*diskb", XrmoptionSepArg, NULL},
  {"-bevarforhold", "*bevarforhold", XrmoptionNoArg, "on"},
  {"-ikkebevarforhold", "*bevarforhold", XrmoptionNoArg, "off"},
  {"-40x", "*40x", XrmoptionSepArg, NULL},
  {"-80x", "*80x", XrmoptionSepArg, NULL},
  {"-begrens", "*begrens", XrmoptionNoArg, "on"},
  {"-ikkebegrens", "*begrens", XrmoptionNoArg, "off"},
  {"-port1", "*port1", XrmoptionSepArg, NULL},
  {"-port2", "*port2", XrmoptionSepArg, NULL},
  {"-pk", "*pk", XrmoptionSepArg, NULL},
  {"-pf", "*pf", XrmoptionSepArg, NULL},
  {"-st28b", "*st28b", XrmoptionNoArg, "on"},
  {"-ikkest28b", "*st28b", XrmoptionNoArg, "off"}
};

static int num_opts = (sizeof options / sizeof options[0]);

typedef struct KeyConv {
  byte tikikey;
  KeySym keysym;
} KeyConv;

/* Tabell som konverterer X11-keysym til TIKI-100 tasteverdier */
static const KeyConv keyConvTable[] = {
  {KEY_CTRL,    XK_Control_L},   {KEY_CTRL,       XK_Control_R}, {KEY_SHIFT,    XK_Shift_L},
  {KEY_SHIFT,   XK_Shift_R},     {KEY_BRYT,       XK_Break},     {KEY_BRYT,     XK_F10},
  {KEY_CR,      XK_Return},      {KEY_SPACE,      XK_space},     {KEY_SLETT,    XK_BackSpace},
  {KEY_SLETT,   XK_Delete},      {KEY_GRAFIKK,    XK_F8},        {KEY_ANGRE,    XK_Redo},
  {KEY_ANGRE,   XK_F9},          {KEY_LOCK,       XK_Caps_Lock}, {KEY_LOCK,     XK_Shift_Lock},
  {KEY_LOCK,    XK_F7},          {KEY_HJELP,      XK_Help},      {KEY_HJELP,    XK_F11},
  {KEY_LEFT,    XK_Left},        {KEY_UTVID,      XK_Insert},    {KEY_UTVID,    XK_F12},
  {KEY_F1,      XK_F1},          {KEY_F4,         XK_F4},        {KEY_RIGHT,    XK_Right},
  {KEY_F2,      XK_F2},          {KEY_F3,         XK_F3},        {KEY_F5,       XK_F5},
  {KEY_F6,      XK_F6},          {KEY_DOWN,       XK_Down},      {KEY_PGUP,     XK_Page_Up},
  {KEY_PGDOWN,  XK_Page_Down},   {KEY_UP,         XK_Up},        {KEY_HOME,     XK_Home},
  {KEY_TABLEFT, XK_Prior},       {KEY_TABRIGHT,   XK_Tab},       {KEY_TABRIGHT, XK_Next},
  {KEY_NUMDIV,  XK_KP_Divide},   {KEY_NUMPLUS,    XK_KP_Add},    {KEY_NUMMINUS, XK_KP_Subtract},
  {KEY_NUMMULT, XK_KP_Multiply}, {KEY_NUMPERCENT, XK_percent},   {KEY_NUMEQU,   XK_KP_Equal},
  {KEY_ENTER,   XK_KP_Enter},    {KEY_NUM0,       XK_KP_0},      {KEY_NUM1,     XK_KP_1},
  {KEY_NUM2,    XK_KP_2},        {KEY_NUM3,       XK_KP_3},      {KEY_NUM4,     XK_KP_4},
  {KEY_NUM5,    XK_KP_5},        {KEY_NUM6,       XK_KP_6},      {KEY_NUM7,     XK_KP_7},
  {KEY_NUM8,    XK_KP_8},        {KEY_NUM9,       XK_KP_9},      {KEY_NUMDOT,   XK_KP_Separator},
  {KEY_NUMDOT,  XK_KP_Decimal},  {(byte)'a',      XK_a},         {(byte)'b',    XK_b},
  {(byte)'c',   XK_c},           {(byte)'d',      XK_d},         {(byte)'e',    XK_e},
  {(byte)'f',   XK_f},           {(byte)'g',      XK_g},         {(byte)'h',    XK_h},
  {(byte)'i',   XK_i},           {(byte)'j',      XK_j},         {(byte)'k',    XK_k},
  {(byte)'l',   XK_l},           {(byte)'m',      XK_m},         {(byte)'n',    XK_n},
  {(byte)'o',   XK_o},           {(byte)'p',      XK_p},         {(byte)'q',    XK_q},
  {(byte)'r',   XK_r},           {(byte)'s',      XK_s},         {(byte)'t',    XK_t},
  {(byte)'u',   XK_u},           {(byte)'v',      XK_v},         {(byte)'w',    XK_w},
  {(byte)'x',   XK_x},           {(byte)'y',      XK_y},         {(byte)'z',    XK_z},
  {(byte)'1',   XK_1},           {(byte)'2',      XK_2},         {(byte)'3',    XK_3},
  {(byte)'4',   XK_4},           {(byte)'5',      XK_5},         {(byte)'6',    XK_6},
  {(byte)'7',   XK_7},           {(byte)'8',      XK_8},         {(byte)'9',    XK_9},
  {(byte)'0',   XK_0},           {(byte)'<',      XK_less},      {(byte)',',    XK_comma},
  {(byte)'.',   XK_period},      {(byte)'-',      XK_minus},     {(byte)'æ',    XK_ae},
  {(byte)'ø',   XK_oslash},      {(byte)'å',      XK_aring},     {(byte)'\'',   XK_apostrophe},
  {(byte)'^',   XK_asciicircum}, {(byte)'+',      XK_plus},      {(byte)'@',    XK_at}
};

/*****************************************************************************/

int main (int argc, char *argv[]) {
  char *resType;     /* for resourcekall */
  XrmValue resValue; /* -- " -- */
  XrmDatabase cline_db = NULL;
  
  XrmInitialize();

  /* parse kommandolinjeopsoner */
  XrmParseCommand (&cline_db, options, num_opts, "tikiemul", &argc, argv);

  /* feil i argumenter */
  if (argc > 1) {
    printf ("TIKI-100_emul V1.1.1 brukes:\n"
            "    tikiemul [-opsjoner...]\n"
            "\n"
            "Opsjoner:\n"
            "    -display displaynavn      X-server som skal benyttes\n"
            "    -d displaynavn            Forkortelse for den over\n"
            "    -geometry geom            Vindusposisjon\n"
            "    -g geom                   Forkortelse for den over\n"
            "    -diska diskettfilnavn     Diskettfil i stasjon a\n"
            "    -diskb diskettfilnavn     Diskettfil i stasjon b\n"
            "    -bevarforhold             Emulatorvindu formlik TIKI-100 skjerm\n"
            "    -ikkebevarforhold         Negasjonen av den over\n"
            "    -40x forstørrelsesfaktor  Forstørring av 40-modus vindu\n"
            "    -80x forstørrelsesfaktor  Forstørring av 80-modus vindu\n"
            "    -begrens                  Begrens hastighet til vanlig TIKI-hastighet\n"
            "    -ikkebegrens              Negasjonen av den over\n"
            "    -port1 devicenavn         Skru på serieport P1\n"
            "    -port2 devicenavn         Skru på serieport P2\n"
            "    -pk utskriftskommando     Send utskrift til kommando\n"
            "    -pf utskriftsfil          Send utskrift til fil\n"
            "    -st28b                    Sett bøyle ST 28 b\n"
            "    -ikkest28b                Negasjonen av den over\n"
            "\n"
            "Underveis i emulering kan du trykke på Escapetasten for å gå inn i\n"
            "kommandomodus. Kommandoen 'hjelp' gir en liste over gyldige kommandoer.\n"
            "\n");
    exit (1);
  }

  /* åpne display */
  XrmGetResource (cline_db, "tikiemul.display", "Tikiemul.display", &resType, &resValue);
  if ((display = XOpenDisplay (resValue.addr)) == NULL) {
    fprintf (stderr, "Kan ikke åpne display %s\n", XDisplayName (resValue.addr));
    exit (1);
  }

  { /* hent defaults fra server */
    char *xrms;

    xrms = XResourceManagerString (display);
    if (xrms != NULL) {
      options_db = XrmGetStringDatabase (xrms);
      XrmMergeDatabases (cline_db, &options_db);
    } else {
      options_db = cline_db;
    }
  }
  
  /* finn geometry */
  XrmGetResource (options_db, "tikiemul.geometry", "Tikiemul.geometry", &resType, &resValue);
  XGeometry (display, DefaultScreen (display), resValue.addr, "+0+0", 1,
             1, 1, 0, 0, &(xsh.x), &(xsh.y), &(xsh.width), &(xsh.height));
  
  /* skal forhold bevares? */
  XrmGetResource (options_db, "tikiemul.bevarforhold", "Tikiemul.bevarforhold",
                  &resType, &resValue);
  scanlines = FALSE;
  if (resValue.addr) {
    if (!strcmp (resValue.addr, "on")) {
      scanlines = TRUE;
    }
  }

  /* finn forstørring og vindusstørrelse */
  XrmGetResource (options_db, "tikiemul.40x", "Tikiemul.40x", &resType, &resValue);
  if (resValue.addr) times40 = atoi (resValue.addr);
  if (times40 > 4) times40 = 4;
  if (times40 < 1) times40 = 1;
  width[0] = 256 * times40;
  height[0] = 256 * times40;
  XrmGetResource (options_db, "tikiemul.80x", "Tikiemul.80x", &resType, &resValue);
  if (resValue.addr) times80 = atoi (resValue.addr);
  if (times80 > 2) times80 = 2;
  if (times80 < 1) times80 = 1;
  width[1] = 512 * times80;
  height[1] = 256 * times80 * (scanlines ? 2 : 1);
  width[2] = 1024;
  height[2] = 256 * (scanlines ? 4 : 1);

  /* skal hastighet begrenses? */
  XrmGetResource (options_db, "tikiemul.begrens", "Tikiemul.begrens", &resType, &resValue);
  slowDown = TRUE;
  if (resValue.addr) {
    if (!strcmp (resValue.addr, "off")) {
      slowDown = FALSE;
    }
  }

  /* hent inn eventuelle diskfiler */
  XrmGetResource (options_db, "tikiemul.diska", "Tikiemul.diska", &resType, &resValue);
  if (resValue.addr) readDiskImage (0, resValue.addr);
  XrmGetResource (options_db, "tikiemul.diskb", "Tikiemul.diskb", &resType, &resValue);
  if (resValue.addr) readDiskImage (1, resValue.addr);
  
  /* sett opp farger */
  default_cmap = DefaultColormap (display, DefaultScreen (display));
  {
    int visclass = DefaultVisual (display, DefaultScreen (display))->class;

    whitepix = WhitePixel (display, DefaultScreen (display));
    blackpix = BlackPixel (display, DefaultScreen (display));
    { /* farger for statusbar */
      XColor color;
      XColor exact;

      if (!XAllocNamedColor (display, default_cmap, "grey80", &exact, &color)) {
        backpix = blackpix;
      } else {
        backpix = color.pixel;
      }
      if (!XAllocNamedColor (display, default_cmap, "green", &exact, &color)) {
        diodepix = whitepix;
      } else {
        diodepix = color.pixel;
      }
    }

    if (visclass == PseudoColor || visclass == DirectColor) {
      /* dynamisk colormap - skaff r/w-fargeceller */
      if (!XAllocColorCells (display, default_cmap, False, NULL, 0, pixels, 16)) {
        printf ("For få ledige fargeceller\n");
        free (dsk[0]);
        free (dsk[1]);
        XCloseDisplay (display);
        exit (1);
      }
      dyn_cmap = TRUE;
    } else if (visclass == TrueColor || visclass == StaticColor) {
      /* statisk colormap - skaff ny pixel hver gang farge forandres */
      int i;

      if (!(screen = malloc (1024 * 256))) {
        fprintf (stderr, "Ikke nok minne\n");
        free (dsk[0]);
        free (dsk[1]);
        XCloseDisplay (display);
        exit (1);
      }
      memset (screen, 0, 1024 * 256);

      for (i = 0; i < 16; i++) {
        pixels[i] = blackpix;
      }
      dyn_cmap = FALSE;
    } else {
      /* svart/hvitt display, kan ikke brukes */
      fprintf (stderr, "Display ikke tilstrekkelig!\n");
      free (dsk[0]);
      free (dsk[1]);
      XCloseDisplay (display);
      exit (1);
    }
  }

  { /* graphics context, en for hver farge */
    int i;
    XGCValues gcv;

    gcv.foreground = blackpix;
    blackGC = XCreateGC (display, DefaultRootWindow (display),
                        GCForeground | GCBackground, &gcv);
    gcv.foreground = backpix;
    backGC = XCreateGC (display, DefaultRootWindow (display),
                        GCForeground | GCBackground, &gcv);
    gcv.foreground = diodepix;
    diodeGC = XCreateGC (display, DefaultRootWindow (display),
                         GCForeground | GCBackground, &gcv);
    
    for (i = 0; i < 16; i++) {
      gcv.foreground = pixels[i];
      colorGC[i] = XCreateGC (display, DefaultRootWindow (display),
                              GCForeground | GCBackground, &gcv);
    }
  }

  /* lag vindu */
  mainwindow =
    XCreateSimpleWindow (display, DefaultRootWindow (display),
                         xsh.x, xsh.y, width[1], height[1] + STATUSBAR_HEIGHT,
                         1, pixels[0], pixels[0]);

  { /* gi hint til window manager */
    XWMHints xwmh;
    
    xsh.flags = (PPosition | PSize | PMinSize | PMaxSize);
    xsh.width = width[1];
    xsh.height = height[1] + STATUSBAR_HEIGHT;
    xsh.min_width = xsh.width;
    xsh.min_height = xsh.height;
    xsh.max_width = xsh.width;
    xsh.max_height = xsh.height;
    XSetStandardProperties (display, mainwindow, "tikiemul", "tikiemul", None,
                            argv, argc, &xsh);
    xwmh.flags = (InputHint | StateHint);
    xwmh.input = True;
    xwmh.initial_state = NormalState;
    XSetWMHints (display, mainwindow, &xwmh);
  }
    
  { /* lag pixmap. Alt tegnes til pixmap, kopieres til vindu hver loopEmul() */
    int maxheight = height[0];

    if (height[1] > maxheight) maxheight = height[1];
    if (height[2] > maxheight) maxheight = height[2];

    mainpixmap = XCreatePixmap (display, mainwindow, 1024, maxheight + STATUSBAR_HEIGHT,
                                DefaultDepth (display, DefaultScreen (display)));
    XFillRectangle (display, mainpixmap, colorGC[0], 0, 0, xsh.width, xsh.height);
    update (0, 0, xsh.width, xsh.height);
  }

  /* lag statusbar */
  createStatusBar();

  /* gi beskjed om hvilke events som trengs */
  XSelectInput (display, mainwindow,
                ExposureMask | KeyPressMask | KeyReleaseMask);
  
  /* gjør vindu synlig */
  XMapWindow (display, mainwindow);

  /* init pressedKeys tabell */
  memset (pressedKeys, 1, 256);

  /* bøyle st28b? */
  XrmGetResource (options_db, "tikiemul.st28b", "Tikiemul.st28b", &resType, &resValue);
  if (resValue.addr) {
    if (!strcmp (resValue.addr, "on")) {
      setST28b (TRUE);
    } else {
      setST28b (FALSE);
    }
  }

  /* sett opp printfil/kommando */
  XrmGetResource (options_db, "tikiemul.pk", "Tikiemul.pk", &resType, &resValue);
  if (resValue.addr) {
    setPrintCmd (resValue.addr);
  }
  XrmGetResource (options_db, "tikiemul.pf", "Tikiemul.pf", &resType, &resValue);
  if (resValue.addr) {
    setPrintFile (resValue.addr);
  }

  /* sett opp serieporter */
  XrmGetResource (options_db, "tikiemul.port1", "Tikiemul.port1", &resType, &resValue);
  if (resValue.addr) {
    if ((port1 = open (resValue.addr, O_RDWR | O_NOCTTY | O_NDELAY)) == -1) {
      fprintf (stderr, "Kan ikke åpne port %s\n", resValue.addr);
      port1 = 0;
    } else {
      fcntl (port1, F_SETFL, 0);
    }
  }
  XrmGetResource (options_db, "tikiemul.port2", "Tikiemul.port2", &resType, &resValue);
  if (resValue.addr) {
    if ((port2 = open (resValue.addr, O_RDWR | O_NOCTTY | O_NDELAY)) == -1) {
      fprintf (stderr, "Kan ikke åpne port %s\n", resValue.addr);
      port2 = 0;
    } else {
      fcntl (port2, F_SETFL, 0);
    }
  }

  /* kjør emulator */
  if (!runEmul()) {
    fprintf (stderr, "Finner ikke ROM-fil\n");
  }
  
  /* avslutt */
  if (port2) close (port2);
  if (port1) close (port1);
  if (printFile) fclose (printFile);
  if (printCmd) fclose (printCmd);
  XFreePixmap (display, mainpixmap);
  {
    int i;

    XFreeGC (display, blackGC);
    XFreeGC (display, backGC);
    XFreeGC (display, diodeGC);

    for (i = 0; i < 16; i++) {
      XFreeGC (display, colorGC[i]);
    }
  }
  XDestroyWindow (display, mainwindow);
  if (dyn_cmap) {
    XFreeColors (display, default_cmap, pixels, 16, 0);
  } else {
    free (screen);
  }
  free (dsk[0]);
  free (dsk[1]);
  XCloseDisplay (display);
  
  exit (0);
}
/* oppdater gitt rektangel ved neste loopEmul() */
static void update (int x, int y, int w, int h) {
  if (xmin > x) xmin = x;
  if (ymin > y) ymin = y;
  if (xmax < (x + w)) xmax = x + w;
  if (ymax < (y + h)) ymax = y + h;
  updateWindow = TRUE;  
}
/* tegner statusbar */
static void createStatusBar (void) {
  /* statuslinje */
  XFillRectangle (display, mainpixmap, backGC,
                  0, xsh.height - STATUSBAR_HEIGHT, xsh.width, STATUSBAR_HEIGHT);

  /* "hull" til dioder */
  XFillRectangle (display, mainpixmap, blackGC,
                  20, xsh.height - STATUSBAR_HEIGHT + 3, 10, 10);
  XFillRectangle (display, mainpixmap, blackGC,
                  40, xsh.height - STATUSBAR_HEIGHT + 3, 10, 10);
  XFillRectangle (display, mainpixmap, blackGC,
                  60, xsh.height - STATUSBAR_HEIGHT + 3, 10, 10);
  XFillRectangle (display, mainpixmap, blackGC,
                  80, xsh.height - STATUSBAR_HEIGHT + 3, 10, 10);

  /* oppdater diodelys */
  lockLight (lock);
  grafikkLight (grafikk);
  diskLight (0, disk[0]);
  diskLight (1, disk[1]);

  update (0, xsh.height - STATUSBAR_HEIGHT, xsh.width, STATUSBAR_HEIGHT);
}
/* Forandre oppløsning */
void changeRes (int newRes) {
  resolution = newRes;

  switch (resolution) {
    case LOWRES:
      xsh.width = width[0];
      xsh.height = height[0];
      break;
    case MEDRES:
      xsh.width = width[1];
      xsh.height = height[1];
      break;
    case HIGHRES:
      xsh.width = width[2];
      xsh.height = height[2];
      break;
  }
  xsh.height += STATUSBAR_HEIGHT;

  /* slett gammelt innhold */
  XFillRectangle (display, mainpixmap, colorGC[0], 0, 0, xsh.width, xsh.height - STATUSBAR_HEIGHT);
  update (0, 0, xsh.width, xsh.height - STATUSBAR_HEIGHT);

  /* nye hints til window manager */
  xsh.flags = (PSize | PMinSize | PMaxSize);
  xsh.min_width = xsh.width;
  xsh.min_height = xsh.height;
  xsh.max_width = xsh.width;
  xsh.max_height = xsh.height;
  XSetNormalHints (display, mainwindow, &xsh);

  /* forandre vindusstørrelse */
  XResizeWindow (display, mainwindow, xsh.width, xsh.height);

  if (!dyn_cmap) {
    /* slett gammelt innhold i screen */
    memset (screen, 0, 1024 * 256);
  }

  /* lag statusbar */
  createStatusBar();
}
/* Plotter en pixel med farge tatt fra pallett */
void plotPixel (int x, int y, int color) {
  if (!dyn_cmap) {
    screen[x + y * 1024] = color;
  }

  switch (resolution) {
    case LOWRES:
      x = x * times40;
      y = y * times40;
      break;
    case MEDRES:
      x = x * times80;
      y = y * times80 * (scanlines ? 2 : 1);
      break;
    case HIGHRES:
      y = y * (scanlines ? 4 : 1);
      break;
  }

  XDrawPoint (display, mainpixmap, colorGC[color], x, y);

  update (x, y, 1, 1);
}
/* Scroller skjerm 'distance' linjer oppover */
void scrollScreen (int distance) {
  if (!dyn_cmap) {
    /* scroll screen */
    if (distance > 0) {
      memmove (screen, screen + distance * 1024, (256 - distance) * 1024);
      memset (screen + (256 - distance) * 1024, 0, distance * 1024);
    } else {
      memmove (screen + (-distance * 1024), screen, (byte)distance * 1024);
      memset (screen, 0, -distance * 1024);
    }      
  }
  switch (resolution) {
    case LOWRES:
      distance *= times40;
      break;
    case MEDRES:
      distance *= times80 * (scanlines ? 2 : 1);
      break;
    case HIGHRES:
      distance *= (scanlines ? 4 : 1);
      break;
  }
  /* scroll pixmap */
  if (distance > 0) {
    XCopyArea (display, mainpixmap, mainpixmap, colorGC[1],
               0, distance, xsh.width, xsh.height - STATUSBAR_HEIGHT - distance, 0, 0);
    XFillRectangle (display, mainpixmap, colorGC[0], 0, xsh.height - STATUSBAR_HEIGHT - distance,
                    xsh.width, distance);
  } else {
    XCopyArea (display, mainpixmap, mainpixmap, colorGC[1],
               0, 0, xsh.width, xsh.height - STATUSBAR_HEIGHT - (-distance), 0, -distance);
    XFillRectangle (display, mainpixmap, colorGC[0], 0, 0,
                    xsh.width, -distance);
  }
  /* oppdater hele vinduet */
  update (0, 0, xsh.width, xsh.height - STATUSBAR_HEIGHT);
}
/* Ny farge, gitt pallett nummer og intensitet 0-255 */
void changePalette (int colornumber, byte red, byte green, byte blue) {
  XColor color;

  color.red = red << 8;
  color.green = green << 8;
  color.blue = blue << 8;
  if (dyn_cmap) {
    color.flags = DoRed | DoGreen | DoBlue;
    color.pixel = pixels[colornumber];
    XStoreColor (display, default_cmap, &color);
  } else {
    XGCValues gcv;

    /* skaff pixel */
    if (!XAllocColor (display, default_cmap, &color)) {
      fprintf (stderr, "Farge %x %x %x ikke tilgjengelig, bruker hvit!\n", red, green, blue);
      color.pixel = whitepix;
    }
    pixels[colornumber] = color.pixel;
    /* forandre GC */
    gcv.foreground = pixels[colornumber];
    XChangeGC (display, colorGC[colornumber], GCForeground, &gcv);
    { /* oppdater skjerm */
      int x, y;

      for (y = 0; y < 256; y++) {
        for (x = 0; x < 1024; x++) {
          if (screen[x + y * 1024]  == colornumber) {
            plotPixel (x, y, colornumber);
          }
        }
      }
    }
  }
}
/* Kalles periodisk. Lar system kode måle / senke emuleringshastighet
 * Kan også brukes til sjekk av brukeraktivitet
 * ms er antall "emulerte" millisekunder siden forrige gang loopEmul ble kalt
 */
void loopEmul (int ms) {
  int events;
  XEvent event;
  
  /* senk hastighet */
  if (slowDown) {
    static boolean firsttime = TRUE; /* brukes for å initialisere lastTOD */
    static struct timeval lastTOD;
    struct timeval currentTOD;
    
    if (firsttime) { /* initialiser lastTOD */
      gettimeofday (&lastTOD, NULL);
      firsttime = FALSE;
    } else {
      long sleepPeriod;
      
      gettimeofday (&currentTOD, NULL);

      /* finner soveintervall */
      if ((currentTOD.tv_sec - lastTOD.tv_sec) != 0) { /* har krysset sekundgrense */
        sleepPeriod = (ms * 1000) - (currentTOD.tv_usec + (1000000 - lastTOD.tv_usec));
      } else {
        sleepPeriod = (ms * 1000) - (currentTOD.tv_usec - lastTOD.tv_usec);
      }

      lastTOD = currentTOD;

      /* ta en liten lur */
      if (sleepPeriod > 0) {
        usleep (sleepPeriod);

        /* lastTOD += sleepPeriod */
        lastTOD.tv_usec = lastTOD.tv_usec + sleepPeriod;
        if (lastTOD.tv_usec > 999999) {
          lastTOD.tv_sec++;
          lastTOD.tv_usec -= 1000000;
        }
      }
    }
  }

  /* oppdater skjerm */
  if (updateWindow) {
    XCopyArea (display, mainpixmap, mainwindow, colorGC[1],
               xmin, ymin, xmax - xmin, ymax - ymin, xmin, ymin);
    xmin = (unsigned)~0; ymin = (unsigned)~0; xmax = 0; ymax = 0;
    updateWindow = FALSE;
  }
  
  XFlush (display);

  /* sjekk events */
  if ((events = XEventsQueued (display, QueuedAfterReading))) {
    while (events--) {
      XNextEvent (display, &event);
      switch (event.type) {
        case MappingNotify:
          XRefreshKeyboardMapping ((XMappingEvent *)&event);
          break;
        case Expose:
          XCopyArea (display, mainpixmap, mainwindow, colorGC[1],
                     event.xexpose.x, event.xexpose.y,
                     event.xexpose.width, event.xexpose.height,
                     event.xexpose.x, event.xexpose.y);
          break;
        case KeyPress: {
          if (XKeycodeToKeysym (display, event.xkey.keycode, 0) == XK_Escape) {
            commandline();
          } else {
            pressedKeys[keysymToTikikey (XKeycodeToKeysym (display, event.xkey.keycode, 0))]
              = 0;
          }
          break;
        }
        case KeyRelease: {
          pressedKeys[keysymToTikikey (XKeycodeToKeysym (display, event.xkey.keycode, 0))]
            = 1;
          break;
        }
      }
    }
  }

  /* sjekk serieporter */
  if (port1) {
    int bytes;

    ioctl (port1, FIONREAD, &bytes);
    if (bytes) {
      charAvailable (0);
    }
  }
  if (port2) {
    int bytes;

    ioctl (port2, FIONREAD, &bytes);
    if (bytes) {
      charAvailable (1);
    }
  }
}
/* oversetter fra keysym til tikitaster */
static byte keysymToTikikey (KeySym keysym) {
  int i;

  /* lineærsøk gjennom tabell */
  for (i = 0; i < (sizeof keyConvTable / sizeof (struct KeyConv)); i++) {
    if (keyConvTable[i].keysym == keysym)
      return keyConvTable[i].tikikey;
  }
  return KEY_NONE;
}
/* tar imot kommandoer via konsoll */
static void commandline (void) {
  while (TRUE) {
    char cmdline[256];
    char *cmd;
    
    printf ("Kommando [h for hjelp]> ");
    fflush (stdout);

    fgets (cmdline, 256, stdin);

    if ((cmd = strtok (cmdline, " \t\n"))) {
      if (!strcmp (cmd, "h") || !strcmp (cmd, "hjelp")) {
        /* vis hjelpetekst */
        puts ("\n***** Kommandoer *****");
        puts ("hjelp                      : Vis denne hjelpeteksten");
        puts ("h                          : ");
        puts ("disk <stasjon> <filnavn>   : Hent inn diskettfil");
        puts ("d <stasjon> <filnavn>      : ");        
        puts ("lagre <stasjon> <filnavn>  : Lagre diskettfil");
        puts ("l <stasjon> <filnavn>      : ");
        puts ("fjern <stasjon>            : Fjern diskettfil");
        puts ("f <stasjon>                : ");
        puts ("pk [kommandonavn]          : Send utskrift til print-kommando");
        puts ("pf [filnavn]               : Send utskrift til fil");
        puts ("reset                      : Reset emulator");
        puts ("fortsett                   : Fortsett emulering");
        puts ("c                          : ");
        puts ("om                         : Om emulator");
        puts ("avslutt                    : Avslutt emulator");
        puts ("q                          : ");
#ifdef DEBUG
        puts ("monitor                    : Z80-monitor");
        puts ("m                          : ");
#endif
        puts ("");
      } else if (!strcmp (cmd, "d") || !strcmp (cmd, "disk")) {
        /* hent diskfil */
        char *driveString = strtok (NULL, " \t\n");
        char *filename = strtok (NULL, " \t\n");

        if (!filename) {
          fprintf (stderr, "For få argumenter\n");
          continue;
        }

        if (!strcmp (driveString, "a") || !strcmp (driveString, "a:")) {
          readDiskImage (0, filename);
        } else if (!strcmp (driveString, "b") || !strcmp (driveString, "b:")) {
          readDiskImage (1, filename);
        } else fprintf (stderr, "Ugyldig stasjon\n");
      } else if (!strcmp (cmd, "l") || !strcmp (cmd, "lagre")) {
        /* lagre diskfil */
        int drive;
        char *driveString = strtok (NULL, " \t\n");
        char *filename = strtok (NULL, " \t\n");

        if (!filename) {
          fprintf (stderr, "For få argumenter\n");
          continue;
        }

        if (!strcmp (driveString, "a") || !strcmp (driveString, "a:")) {
          drive = 0;
        } else if (!strcmp (driveString, "b") || !strcmp (driveString, "b:")) {
          drive = 1;
        } else {
          fprintf (stderr, "Ugyldig stasjon\n");
          continue;
        }
        if (dsksize[drive] != 0) {
          int fd;

          if ((fd = creat (filename, 0640)) != -1) {
            if (write (fd, dsk[drive], dsksize[drive]) == -1) {
              fprintf (stderr, "Kan ikke skrive til fil %s\n", filename);
            }
            close (fd);
          } else fprintf (stderr, "Kan ikke skrive til fil %s\n", filename);
        }
      } else if (!strcmp (cmd, "f") || !strcmp (cmd, "fjern")) {
        /* fjern diskfil */
        int drive;
        char *driveString = strtok (NULL, " \t\n");

        if (!driveString) {
          fprintf (stderr, "For få argumenter\n");
          continue;
        }

        if (!strcmp (driveString, "a") || !strcmp (driveString, "a:")) {
          drive = 0;
        } else if (!strcmp (driveString, "b") || !strcmp (driveString, "b:")) {
          drive = 1;
        } else {
          fprintf (stderr, "Ugyldig stasjon\n");
          continue;
        }
        removeDisk (drive);
        free (dsk[drive]);
        dsk[drive] = NULL;
        dsksize[drive] = 0;
      } else if (!strcmp (cmd, "pk")) {
        char *pc = strtok (NULL, " \t\n");

        if (!pc) {
          if (printCmd) {
            pclose (printCmd);
            printCmd = 0;
          }
        } else {
          setPrintCmd (pc);
        }
      } else if (!strcmp (cmd, "pf")) {
        char *pf = strtok (NULL, " \t\n");

        if (!pf) {
          if (printFile) {
            fclose (printFile);
            printFile = 0;
          }
        } else {
          setPrintFile (pf);
        }
      } else if (!strcmp (cmd, "reset")) {
        /* reset */
        resetEmul();
      } else if (!strcmp (cmd, "c") || !strcmp (cmd, "fortsett")) {
        /* fortsett emulering */
        return;
      } else if (!strcmp (cmd, "om")) {
        /* vis "om"-tekst */
        puts ("\nTIKI-100_emul V1.1.1 - en freeware TIKI 100 Rev. C emulator.");
        puts ("Z80 emulering copyright (C) Marat Fayzullin 1994,1995,1996,1997.");
        puts ("Resten copyright (C) Asbjørn Djupdal 2000-2001.\n");
      } else if (!strcmp (cmd, "q") || !strcmp (cmd, "avslutt")) {
        /* avslutt */
        quitEmul();
        return;
#ifdef DEBUG
      } else if (!strcmp (cmd, "m") || !strcmp (cmd, "monitor")) {
        /* z80-debugger */
        trace();
        return;
#endif
      } else {
        fprintf (stderr, "Ugyldig kommando\n");
      }
    }
  }
}
/* setter opp printkommando/fil */
static void setPrintCmd (char *p) {
  if (printCmd) pclose (printCmd);
  if (!(printCmd = popen (p, "w"))) {
    fprintf (stderr, "Kan ikke starte printkommando\n");
  }
}
static void setPrintFile (char *p) {
  if (printFile) fclose (printFile);
  if (!(printFile = fopen (p, "wb"))) {
    fprintf (stderr, "Kan ikke lage printerfil %s\n", p);
  }
}
/* henter inn diskbilde fra fil */
static void readDiskImage (int drive, char *filename) {
  int fd;
    
  if ((fd = open (filename, O_RDONLY)) != -1) {
    struct stat fileInfo;

    removeDisk (drive);
    free (dsk[drive]);
    fstat (fd, &fileInfo);
    if ((dsk[drive] = malloc (fileInfo.st_size))) {
      dsksize[drive] = read (fd, dsk[drive], fileInfo.st_size);

      switch (dsksize[drive]) {
        case 40*1*18*128:
          insertDisk (drive, dsk[drive], 40, 1, 18, 128);
          break;
        case 40*1*10*512:
          insertDisk (drive, dsk[drive], 40, 1, 10, 512);
          break;
        case 40*2*10*512:
          insertDisk (drive, dsk[drive], 40, 2, 10, 512);
          break;
        case 80*2*10*512:
          insertDisk (drive, dsk[drive], 80, 2, 10, 512);
          break;
        case -1:
          fprintf (stderr, "Klarer ikke lese fra fil %s\n", filename);
          break;
        default:
          fprintf (stderr, "Kjenner ikke diskformatet\n");
          dsksize[drive] = 0;
          free (dsk[drive]);
          dsk[drive] = NULL;
          break;
      }
    } else {
      fprintf (stderr, "Ikke nok minne til diskettfil\n");
      dsksize[drive] = 0;
    }
    close (fd);
  } else {
    fprintf (stderr, "Klarer ikke lese fra fil %s\n", filename);
  }
}

/* Tenn/slukk lock lys */
void lockLight (boolean status) {
  GC gc = (status ? diodeGC : blackGC);

  XFillRectangle (display, mainpixmap, gc,
                  21, xsh.height - STATUSBAR_HEIGHT + 4, 8, 8);

  update (21, xsh.height - STATUSBAR_HEIGHT + 4, 9, 9);
  lock = status;
}
/* Tenn/slukk grafikk lys */
void grafikkLight (boolean status) {
  GC gc = (status ? diodeGC : blackGC);

  XFillRectangle (display, mainpixmap, gc,
                  41, xsh.height - STATUSBAR_HEIGHT + 4, 8, 8);

  update (41, xsh.height - STATUSBAR_HEIGHT + 4, 9, 9);
  grafikk = status;
}
/* Tenn/slukk disk lys for gitt stasjon */
void diskLight (int drive, boolean status) {
  GC gc = (status ? diodeGC : blackGC);
  int x = (drive ? 81 : 61);

  XFillRectangle (display, mainpixmap, gc,
                  x, xsh.height - STATUSBAR_HEIGHT + 4, 8, 8);

  update (x, xsh.height - STATUSBAR_HEIGHT + 4, 9, 9);
  disk[drive] = status;
}
/* Sjekk status til hver av de gitte tastene
 * Sett bit n i returkode hvis tast n IKKE er nedtrykt
 */
byte testKey (byte keys[8]) {
  return pressedKeys[keys[0]] | (pressedKeys[keys[1]] << 1) | (pressedKeys[keys[2]] << 2) |
    (pressedKeys[keys[3]] << 3) | (pressedKeys[keys[4]] << 4) | (pressedKeys[keys[5]] << 5) |
    (pressedKeys[keys[6]] << 6) | (pressedKeys[keys[7]] << 7);
}
/* setter seriekanalparametre */
void setParams (struct serParams *p1Params, struct serParams *p2Params) {
  if (port1) setParam (port1, p1Params);
  if (port2) setParam (port2, p2Params);
}
static void setParam (int portfd, struct serParams *params) {
  struct termios options;

  tcgetattr (portfd, &options);

  options.c_iflag = 0;
  options.c_oflag = 0;
  options.c_lflag = 0;
  memset (options.c_cc, 0, sizeof (options.c_cc));

  options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
  options.c_cflag |= (CLOCAL | CREAD);

  /* rec/send bits */
  options.c_cflag &= ~CSIZE;
  switch (params->sendBits) {
    case 5:
      options.c_cflag |= CS5;
      break;
    case 6:
      options.c_cflag |= CS6;
      break;
    case 7:
      options.c_cflag |= CS7;
      break;
    default:
    case 8:
      options.c_cflag |= CS8;
      break;
  }
  /* parity */
  switch (params->parity) {
    case PAR_NONE:
      options.c_cflag &= ~PARENB;
      options.c_iflag &= ~(INPCK | ISTRIP);
      break;
    case PAR_EVEN:
      options.c_cflag |= PARENB;
      options.c_cflag &= ~PARODD;
      options.c_iflag |= (INPCK | ISTRIP);
      break;
    case PAR_ODD:
      options.c_cflag |= PARENB;
      options.c_cflag |= PARODD;
      options.c_iflag |= (INPCK | ISTRIP);
      break;
  }
  /* stopbits */
  switch (params->stopBits) {
    case ONE_SB:
      options.c_cflag &= ~CSTOPB;
      break;
    case ONE_PT_FIVE_SB:
    case TWO_SB:
      options.c_cflag |= CSTOPB;
      break;
  }
  /* baud */
  if (params->baud < 62) {
    params->baud = B50;
  } else if (params->baud < 92) {
    params->baud = B75;
  } else if (params->baud < 122) {
    params->baud = B110;
  } else if (params->baud < 142) {
    params->baud = B134;
  } else if (params->baud < 175) {
    params->baud = B150;
  } else if (params->baud < 250) {
    params->baud = B200;
  } else if (params->baud < 450) {
    params->baud = B300;
  } else if (params->baud < 900) {
    params->baud = B600;
  } else if (params->baud < 1500) {
    params->baud = B1200;
  } else if (params->baud < 2100) {
    params->baud = B1800;
  } else if (params->baud < 3600) {
    params->baud = B2400;
  } else if (params->baud < 7200) {
    params->baud = B4800;
  } else if (params->baud < 14400) {
    params->baud = B9600;
  } else {
    params->baud = B19200;
  }
  cfsetispeed (&options, params->baud);
  cfsetospeed (&options, params->baud);

  tcsetattr (portfd, TCSADRAIN, &options);
}
/* send tegn til seriekanal */
void sendChar (int port, byte value) {
  int portfd = port ? port2 : port1;

  if (portfd) {
    if (write (portfd, &value, 1) == -1) {
      /* klarer ikke sende tegn */
    }
  }
}
/* hent tegn fra seriekanal */
byte getChar (int port) {
  int portfd = port ? port2 : port1;
  byte value;
  
  if (portfd) {
    read (portfd, &value, 1);

    { /* flere tegn? */
      int bytes;

      ioctl (portfd, FIONREAD, &bytes);
      if (bytes) {
        charAvailable (port);
      }
    }
  }
  return value;
}
/* send tegn til skriver */
void printChar (byte value) {
  if (printCmd) {
    if (fputc (value, printCmd) == EOF) {
      /* klarer ikke skrive til printkommando */
    }
  }
  if (printFile) {
    if (fputc (value, printFile) == EOF) {
      /* klarer ikke skrive til printfil */
    }
  }
}