From b43a9990dff16bb65950057c4998dede50dfd760 Mon Sep 17 00:00:00 2001 From: jwalz Date: Sat, 5 Jan 2002 21:05:56 +0000 Subject: [PATCH] *** empty log message *** --- sys/mac/mttymain.c | 579 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 579 insertions(+) create mode 100644 sys/mac/mttymain.c diff --git a/sys/mac/mttymain.c b/sys/mac/mttymain.c new file mode 100644 index 000000000..fc3e28e51 --- /dev/null +++ b/sys/mac/mttymain.c @@ -0,0 +1,579 @@ +/* SCCS Id: @(#)mttymain.c 3.1 93/02/26 */ +/* Copyright (c) Jon W{tte, 1993 */ +/* NetHack may be freely redistributed. See license for details. */ + +#include "hack.h" +#include "macwin.h" +#include "mttypriv.h" +#include "mactty.h" +#include "wintty.h" + +#include + +#define MT_WINDOW 135 +#define MT_WIDTH 80 +#define MT_HEIGHT 24 + + +/* + * Names: + * + * Statics are prefixed _ + * Mac-tty becomes mt_ + */ + +static long _mt_attrs [5] [2] = { + { 0x000000, 0xffffff }, /* Normal */ + { 0xff8080, 0xffffff }, /* Underline */ + { 0x40c020, 0xe0e0e0 }, /* Bold */ + { 0x003030, 0xff0060 }, /* Blink */ + { 0xff8888, 0x000000 }, /* Inverse */ +}; + + +static char _attrs_inverse [5] = { + 0, 0, 0, 0, 0 , +}; + + +/* see color.h */ + +static long _mt_colors [CLR_MAX] [2] = { + { 0x000000, 0x808080 }, /* Black */ + { 0x880000, 0xffffff }, /* Red */ + { 0x008800, 0xffffff }, /* Green */ + { 0x553300, 0xffffff }, /* Brown */ + { 0x000088, 0xffffff }, /* Blue */ + { 0x880088, 0xffffff }, /* Magenta */ + { 0x008888, 0xffffff }, /* Cyan */ + { 0x888888, 0xffffff }, /* Gray */ + { 0x000000, 0xffffff }, /* No Color */ + { 0xff4400, 0xffffff }, /* Orange */ + { 0x00ff00, 0xffffff }, /* Bright Green */ + { 0xffff00, 0x606060 }, /* Yellow */ + { 0x0033ff, 0xffffff }, /* Bright Blue */ + { 0xff00ff, 0xffffff }, /* Bright Magenta */ + { 0x00ffff, 0xffffff }, /* Bright Cyan */ + { 0xffffff, 0x505050 }, /* White */ +}; + +static char _colors_inverse [CLR_MAX] = { + 1, 0, 0, 0 , + 0, 0, 0, 0 , + 0, 0, 0, 0 , + 0, 0, 0, 0 , +}; + + +#ifdef CHANGE_COLOR + +#define POWER_LIMIT 22 +#define SECONDARY_POWER_LIMIT 16 +#define CHANNEL_LIMIT 14 +#define SECONDARY_CHANNEL_LIMIT 12 + +void +tty_change_color (int color, long rgb, int reverse) { +long inverse, working_rgb = rgb; +int total_power = 0, max_channel = 0; +int cnt = 3; + + working_rgb >>= 4; + while (cnt -- > 0) { + total_power += working_rgb & 0xf; + max_channel = max (max_channel, working_rgb & 0xf); + working_rgb >>= 8; + } + + if (total_power >= POWER_LIMIT || + (total_power >= SECONDARY_POWER_LIMIT && + max_channel >= SECONDARY_CHANNEL_LIMIT) || + max_channel >= CHANNEL_LIMIT) + inverse = 0x000000; + else + inverse = 0xffffff; + + if (reverse) { + working_rgb = rgb; + rgb = inverse; + inverse = working_rgb; + } + + if (color >= CLR_MAX) { + if (color - CLR_MAX >= 5) + impossible ("Changing too many colors"); + else { + _mt_attrs [color - CLR_MAX] [0] = rgb; + _mt_attrs [color - CLR_MAX] [1] = inverse; + _attrs_inverse [color - CLR_MAX] = reverse; + } + } else if (color >= 0) { + _mt_colors [color] [0] = rgb; + _mt_colors [color] [1] = inverse; + _colors_inverse [color] = reverse; + } else + impossible ("Changing negative color"); +} + +void tty_change_background (int white_or_black) { + register int i; + + for (i = 0; i < CLR_MAX; i++) { + if (white_or_black) + _mt_colors [i] [1] = 0xffffff; /* white */ + else + _mt_colors [i] [1] = 0x000000; /* black */ + } + + /* special cases */ + if (white_or_black) { + _mt_colors [CLR_BLACK] [1] = 0x808080; /* differentiate black from no color */ + _mt_colors [CLR_WHITE] [1] = 0x505050; /* highlight white with grey background */ + _mt_colors [CLR_YELLOW] [1] = 0x606060; /* highlight yellow with grey background */ + _mt_colors [CLR_BLUE] [0] = 0x000088; /* make pure blue */ + _mt_colors [NO_COLOR] [0] = 0x000000; /* make no_color black on white */ + _mt_attrs [0] [0] = 0x000000; /* "normal" is black on white */ + _mt_attrs [0] [1] = 0xffffff; + } else { + _mt_colors [NO_COLOR] [0] = 0xffffff; /* make no_color white on black */ + _mt_colors [CLR_BLACK] [1] = 0x808080; /* differentiate black from no color */ + _mt_colors [CLR_BLUE] [0] = 0x222288; /* lighten blue - it's too dark on black */ + _mt_attrs [0] [0] = 0xffffff; /* "normal" is white on black */ + _mt_attrs [0] [1] = 0x000000; + } +} + +char * +tty_get_color_string (void) { +char *ptr; +int count; +static char color_buf [5 * (CLR_MAX + 5) + 1]; + + color_buf [0] = 0; + ptr = color_buf; + + for (count = 0; count < CLR_MAX; count ++) { + int flag = _colors_inverse [count] ? 1 : 0; + + sprintf (ptr, "%s%s%x%x%x", count ? "/" : "" , + flag ? "-" : "" , + (_mt_colors [count] [flag] >> 20) & 0xf , + (_mt_colors [count] [flag] >> 12) & 0xf , + (_mt_colors [count] [flag] >> 4) & 0xf); + ptr += strlen (ptr); + } + for (count = 0; count < 5; count ++) { + int flag = _attrs_inverse [count] ? 1 : 0; + + sprintf (ptr, "/%s%x%x%x" , + flag ? "-" : "" , + (_mt_attrs [count] [flag] >> 20) & 0xf , + (_mt_attrs [count] [flag] >> 12) & 0xf , + (_mt_attrs [count] [flag] >> 4) & 0xf); + ptr += strlen (ptr); + } + + return color_buf; +} +#endif + + +extern struct DisplayDesc *ttyDisplay; /* the tty display descriptor */ + +char kill_char = CHAR_ESC; +char erase_char = CHAR_BS; + +WindowPtr _mt_window = (WindowPtr) 0; +static Boolean _mt_in_color = 0; +extern short win_fonts [NHW_TEXT + 1]; + +static void +_mt_init_stuff (void) { +long resp, flag; +short num_cols, num_rows, win_width, win_height, font_num, font_size; +short char_width, row_height; +short hor, vert; + + LI = MT_HEIGHT; + CO = MT_WIDTH; + + if (!strcmp(windowprocs.name, "mac")) { + dprintf ("Mac Windows"); + LI -= 1; + } else { + dprintf ("TTY Windows"); + } + + /* + * If there is at least one screen CAPABLE of color, and if + * 32-bit QD is there, we use color. 32-bit QD is needed for the + * offscreen GWorld + */ + if (!Gestalt (gestaltQuickdrawVersion, &resp) && resp > 0x1ff) { + GDHandle gdh = GetDeviceList (); + while (gdh) { + if (TestDeviceAttribute (gdh, screenDevice)) { + if (HasDepth (gdh, 4, 1, 1) || + HasDepth (gdh, 8, 1, 1) || + HasDepth (gdh, 16, 1, 1) || + HasDepth (gdh, 32, 1, 1)) { + _mt_in_color = 1; + break; + } + } + gdh = GetNextDevice (gdh); + } + } + + mustwork (create_tty (&_mt_window, WIN_BASE_KIND + NHW_MAP, _mt_in_color)); + ((WindowPeek) _mt_window)->windowKind = (WIN_BASE_KIND + NHW_MAP); + SelectWindow (_mt_window); + SetPort (_mt_window); + SetOrigin (-1, -1); + + font_size = (iflags.large_font && !small_screen) ? 12 : 9; + mustwork (init_tty_number (_mt_window, win_fonts [NHW_MAP], font_size, CO, LI)); + + mustwork (get_tty_metrics (_mt_window, &num_cols, &num_rows, &win_width , + &win_height, &font_num, &font_size, &char_width, &row_height)); + + SizeWindow (_mt_window, win_width + 2, win_height + 2, 1); + if (RetrievePosition (kMapWindow, &vert, &hor)) { + dprintf ("Moving window to (%d,%d)", hor, vert); + MoveWindow (_mt_window, hor, vert, 1); + } + ShowWindow (_mt_window); + + /* Start in raw, always flushing mode */ + mustwork (get_tty_attrib (_mt_window, TTY_ATTRIB_FLAGS, &flag)); + flag |= TA_ALWAYS_REFRESH | TA_WRAP_AROUND; + mustwork (set_tty_attrib (_mt_window, TTY_ATTRIB_FLAGS, flag)); + + mustwork (get_tty_attrib (_mt_window, TTY_ATTRIB_CURSOR, &flag)); + flag |= (TA_BLINKING_CURSOR | TA_NL_ADD_CR); + mustwork (set_tty_attrib (_mt_window, TTY_ATTRIB_CURSOR, flag)); + + mustwork (set_tty_attrib (_mt_window, TTY_ATTRIB_FOREGROUND, _mt_colors [NO_COLOR] [0])); + mustwork (set_tty_attrib (_mt_window, TTY_ATTRIB_BACKGROUND, _mt_colors [NO_COLOR] [1])); + clear_tty (_mt_window);// + + InitMenuRes (); +} + + +int +tgetch (void) { +EventRecord event; +long sleepTime = 0; +int ret = 0; + + for (;!ret;) { + WaitNextEvent (-1, &event, sleepTime, 0); + HandleEvent (&event); + blink_cursor (_mt_window, event.when); + if (event.what == nullEvent) { + sleepTime = GetCaretTime (); + } else { + sleepTime = 0; + } + ret = GetFromKeyQueue (); + if (ret == CHAR_CR) ret = CHAR_LF; + } + return ret; +} + + +void +getreturn (char *str) { + FlushEvents (-1, 0); + msmsg ("Press space %s", str); + (void) tgetch (); +} + + +int +has_color (int color) { +#if defined(applec) || defined(__MWERKS__) +# pragma unused(color) +#endif +Rect r; +Point p = {0, 0}; +GDHandle gh; + + if (!_mt_in_color) { + return 0; + } + + r = _mt_window->portRect; + SetPort (_mt_window); + LocalToGlobal (&p); + OffsetRect (&r, p.h, p.v); + + gh = GetMaxDevice (&r); + if (!gh) { + return 0; + } + + return (*((*gh)->gdPMap))->pixelSize > 4; /* > 4 bpp */ +} + + +void +tty_delay_output (void) { +EventRecord event; +long toWhen = TickCount () + 3; + + while (TickCount () < toWhen) { + WaitNextEvent (updateMask, &event, 3L, 0); + if (event.what == updateEvt) { + HandleEvent (&event); + blink_cursor (_mt_window, event.when); + } + } +} + + +void +cmov (int x, int y) { + move_tty_cursor (_mt_window, x, y); + ttyDisplay->cury = y; + ttyDisplay->curx = x; +} + + +void +nocmov (int x, int y) { + cmov (x, y); +} + + +static void +_mt_set_colors (long *colors) { +short err; + + if (!_mt_in_color) { + return; + } + err = set_tty_attrib (_mt_window, TTY_ATTRIB_FOREGROUND, colors [0]); + err = set_tty_attrib (_mt_window, TTY_ATTRIB_BACKGROUND, colors [1]); +} + + +void +term_end_attr (int attr) { +#if defined(applec) || defined(__MWERKS__) +# pragma unused (attr) +#endif + _mt_set_colors (_mt_attrs [0]); +} + + +void +term_start_attr (int attr) { + switch (attr) { + case ATR_ULINE: + _mt_set_colors (_mt_attrs [1]); + break; + case ATR_BOLD: + _mt_set_colors (_mt_attrs [2]); + break; + case ATR_BLINK: + _mt_set_colors (_mt_attrs [3]); + break; + case ATR_INVERSE: + _mt_set_colors (_mt_attrs [4]); + break; + default: + _mt_set_colors (_mt_attrs [0]); + break; + } +} + + +void +standoutend (void) { + term_end_attr (ATR_INVERSE); +} + + +void +standoutbeg (void) { + term_start_attr (ATR_INVERSE); +} + + +void +term_end_color (void) { + _mt_set_colors (_mt_colors [NO_COLOR]); +} + + +void +cl_end (void) { + _mt_set_colors (_mt_attrs [0]); + clear_tty_window (_mt_window, ttyDisplay->curx, ttyDisplay->cury, + CO - 1, ttyDisplay->cury); +} + + +void +clear_screen (void) { + _mt_set_colors (_mt_attrs [0]); + clear_tty (_mt_window); +} + + +void +cl_eos (void) { + _mt_set_colors (_mt_attrs [0]); + clear_tty_window (_mt_window, ttyDisplay->curx, ttyDisplay->cury, CO - 1, + LI - 1); +} + + +void +home (void) { + cmov (0,0); +} + + +void +backsp (void) { +char eraser [] = { CHAR_BS, CHAR_BLANK, CHAR_BS, 0 }; +short err; + + err = add_tty_string (_mt_window, eraser); + err = update_tty (_mt_window); +} + + +void +msmsg (const char *str, ...) { +va_list args; +char buf [1000]; + + va_start (args, str); + vsprintf (buf, str, args); + va_end (args); + + xputs (buf); +} + + +void +term_end_raw_bold (void) { + term_end_attr (ATR_INVERSE); +} + + +void +term_start_raw_bold (void) { + term_start_attr (ATR_INVERSE); +} + + +void +term_start_color (int color) { + if (color >= 0 && color < CLR_MAX) { + _mt_set_colors (_mt_colors [color]); + } +} + + +void +setftty (void) { +long flag; + + mustwork (get_tty_attrib (_mt_window, TTY_ATTRIB_FLAGS, &flag)); +/* Buffered output in the game */ + flag &= ~ TA_ALWAYS_REFRESH; + flag |= TA_INHIBIT_VERT_SCROLL; /* don't scroll */ + mustwork (set_tty_attrib (_mt_window, TTY_ATTRIB_FLAGS, flag)); + + iflags.cbreak = 1; +} + + +void +tty_startup (int *width, int *height ) { + _mt_init_stuff (); + *width = CO; + *height = LI; +} + + +void +gettty (void) { +} + + +void +settty (const char *str) { +long flag; + + update_tty (_mt_window); + + mustwork (get_tty_attrib (_mt_window, TTY_ATTRIB_FLAGS, &flag)); +/* Buffered output in the game, raw in "raw" mode */ + flag &= ~ TA_INHIBIT_VERT_SCROLL; /* scroll */ + flag |= TA_ALWAYS_REFRESH; + mustwork (set_tty_attrib (_mt_window, TTY_ATTRIB_FLAGS, flag)); + + tty_raw_print ("\n"); + if (str) { + tty_raw_print (str); + } +} + + +void +tty_number_pad (int arg) { +#if defined(applec) || defined(__MWERKS__) +# pragma unused(arg) +#endif +} + + +void +tty_start_screen (void) { + iflags.cbreak = 1; +} + + +void +tty_end_screen (void) { +} + + +void +xputs (const char *str) { + add_tty_string (_mt_window, str); +} + + +int +term_puts (const char *str) { + xputs (str); + return strlen (str); +} + + +int +term_putc (int c) { +short err; + + err = add_tty_char (_mt_window, c); + return err ? EOF : c; +} + + +int +term_flush (void *desc) { + if (desc == stdout || desc == stderr) { + update_tty (_mt_window); + } else { + impossible ("Substituted flush for file"); + return fflush (desc); + } + return 0; +}