void GlkInterface::gos_update_height() {
uint height_upper;
uint height_lower;
if (gos_curwin) {
glk_window_get_size(gos_upper, nullptr, &height_upper);
glk_window_get_size(gos_lower, nullptr, &height_lower);
h_screen_rows = height_upper + height_lower + 1;
SET_BYTE(H_SCREEN_ROWS, h_screen_rows);
}
}
/**
* glk_exit:
*
* If you want to shut down your program in the middle of your `glk_main()`
* function, you can call glk_exit().
*
* This function does not return.
*
* If you print some text to a window and then shut down your program, you can
* assume that the player will be able to read it. Most likely the Glk library
* will give a “`Hit any key to exit`” prompt.
* (There are other possiblities, however.
* A terminal-window version of Glk might simply exit and leave the last screen
* state visible in the terminal window.)
*
* <note><para>
* You should only shut down your program with glk_exit() or by returning from
* your <function>glk_main()</function> function. If you call the ANSI
* <function>exit()</function> function, bad things may happen. Some versions of
* the Glk library may be designed for multiple sessions, for example, and you
* would be cutting off all the sessions instead of just yours. You would
* probably also prevent final text from being visible to the player.
* </para></note>
*
* > # Chimara #
* > If there are any windows open at the time glk_exit() is called, then
* > Chimara will leave them open.
* > This way, the final text remains visible.
* > Note that bad things most definitely <emphasis>will</emphasis> happen if
* > you use the ANSI `exit()`.
*/
void
glk_exit(void)
{
ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
shutdown_glk_pre();
/* Find the biggest text buffer window */
winid_t win, largewin = NULL;
glui32 largearea = 0;
for(win = glk_window_iterate(NULL, NULL); win; win = glk_window_iterate(win, NULL)) {
if(win->type == wintype_TextBuffer) {
glui32 w, h;
if(!largewin) {
largewin = win;
glk_window_get_size(largewin, &w, &h);
largearea = w * h;
} else {
glk_window_get_size(win, &w, &h);
if(w * h > largearea) {
largewin = win;
largearea = w * h;
}
}
}
}
if(largewin) {
glk_set_window(largewin);
glk_set_style(style_Alert);
glk_put_string("\n");
glk_put_string(glk_data->final_message);
glk_put_string("\n");
flush_window_buffer(largewin);
}
/* Wait for a keypress if any text grid or buffer windows are open */
gboolean should_wait = FALSE;
g_mutex_lock(&glk_data->shutdown_lock);
for(win = glk_window_iterate(NULL, NULL); win; win = glk_window_iterate(win, NULL)) {
if(win->type == wintype_TextGrid || win->type == wintype_TextBuffer) {
g_signal_handler_unblock(win->widget, win->shutdown_keypress_handler);
should_wait = TRUE;
}
}
if (should_wait)
g_cond_wait(&glk_data->shutdown_key_pressed, &glk_data->shutdown_lock);
g_mutex_unlock(&glk_data->shutdown_lock);
shutdown_glk_post();
gdk_threads_add_idle((GSourceFunc)emit_stopped_signal, glk_data->self);
g_thread_exit(NULL);
}
int heglk_get_screenheight(void)
{
static glui32 height = 0, mainheight = 0;
if (secondwin)
glk_window_get_size(secondwin, NULL, &height);
else if (auxwin)
glk_window_get_size(auxwin, NULL, &height);
glk_window_get_size(mainwin, NULL, &mainheight);
return height+mainheight;
}
void GlkInterface::split_window(zword lines) {
if (!gos_upper)
return;
// The top line is always set for V1 to V3 games
if (h_version < V4)
lines++;
if (!lines || lines > curr_status_ht) {
uint height;
glk_window_get_size(gos_upper, nullptr, &height);
if (lines != height)
glk_window_set_arrangement(
glk_window_get_parent(gos_upper),
winmethod_Above | winmethod_Fixed,
lines, nullptr);
curr_status_ht = lines;
}
mach_status_ht = lines;
if (cury > lines)
{
glk_window_move_cursor(gos_upper, 0, 0);
curx = cury = 1;
}
gos_update_width();
if (h_version == V3)
glk_window_clear(gos_upper);
}
static void draw_statuswin(void)
{
glui32 width, height;
if (!statuswin) {
/* It is possible that the window was not successfully
created. If that's the case, don't try to draw it. */
return;
}
glk_set_window(statuswin);
glk_window_clear(statuswin);
glk_window_get_size(statuswin, &width, &height);
/* Draw a decorative compass rose in the center. */
width = (width/2);
if (width > 0)
width--;
height = (height/2);
if (height > 0)
height--;
glk_window_move_cursor(statuswin, width, height+0);
glk_put_string("\\|/");
glk_window_move_cursor(statuswin, width, height+1);
glk_put_string("-*-");
glk_window_move_cursor(statuswin, width, height+2);
glk_put_string("/|\\");
}
int os_banner_getinfo(void *banner_handle, os_banner_info_t *info)
{
osbanid_t banner = banner_handle;
if (!banner || !banner->valid || !banner->win)
return 1;
winid_t win = banner->win;
glui32 gwintype = banner->type;
glui32 gwinmeth = banner->method;
glui32 gstyletab = banner->status;
if (gwinmeth & winmethod_Above)
info->align = OS_BANNER_ALIGN_TOP;
if (gwinmeth & winmethod_Below)
info->align = OS_BANNER_ALIGN_BOTTOM;
if (gwinmeth & winmethod_Left)
info->align = OS_BANNER_ALIGN_LEFT;
if (gwinmeth & winmethod_Right)
info->align = OS_BANNER_ALIGN_RIGHT;
info->style = gstyletab ? OS_BANNER_STYLE_TAB_ALIGN : 0;
glk_window_get_size(win, &(banner->cwidth), &(banner->cheight));
info->rows = banner->cheight;
info->columns = banner->cwidth;
info->pix_width = 0;
info->pix_height = 0;
info->os_line_wrap = gstyletab ? 0 : (gwintype == wintype_TextBuffer);
return 1;
}
int heglk_get_linelength(void)
{
static glui32 width;
/* Try to use whatever fixed-width linelength is available */
if (secondwin)
glk_window_get_size(secondwin, &width, NULL);
else if (auxwin)
glk_window_get_size(auxwin, &width, NULL);
/* Otherwise try to approximate it by the proportionally
spaced linelength
*/
else
glk_window_get_size(mainwin, &width, NULL);
/* -1 to override automatic line wrapping */
return width-1;
}
int os_banner_get_charheight(void *banner_handle)
{
osbanid_t banner = banner_handle;
if (!banner || !banner->valid || !banner->win)
return 0;
glk_window_get_size(banner->win, &(banner->cwidth), &(banner->cheight));
return banner->cheight;
}
void GlkInterface::showBeyondZorkTitle() {
uint winW, winH, imgW, imgH;
winid_t win = glk_window_open(0, 0, 0, wintype_Graphics, 0);
glk_window_get_size(win, &winW, &winH);
if (os_picture_data(1, &imgW, &imgH)) {
os_draw_picture(1, win, Common::Rect(0, 0, winW, winH));
_events->waitForPress();
}
glk_window_close(win, nullptr);
}
void GlkInterface::reset_status_ht() {
uint height;
if (gos_upper) {
glk_window_get_size(gos_upper, nullptr, &height);
if ((uint)mach_status_ht != height) {
glk_window_set_arrangement(
glk_window_get_parent(gos_upper),
winmethod_Above | winmethod_Fixed,
mach_status_ht, nullptr);
}
}
}
void GlkInterface::gos_update_width() {
uint width;
if (gos_upper) {
glk_window_get_size(gos_upper, &width, nullptr);
h_screen_cols = width;
SET_BYTE(H_SCREEN_COLS, width);
if ((uint)curx > width) {
glk_window_move_cursor(gos_upper, 0, cury - 1);
curx = 1;
}
}
}
void print_two_rows(winid_t win)
{
glui32 width, height;
glk_window_get_size(win, &width, &height);
glk_set_window(win);
glk_window_clear(win);
glui32 x = (width >= 6)? width / 2 - 3 : 0;
glui32 y = (height > 0)? (height - 1) / 2 : 0;
glk_window_move_cursor(win, x, y);
glk_put_string("C: 2");
glk_window_move_cursor(win, x + 3, y + 1);
glk_put_string("rows");
}
void center_text(winid_t win, char *text)
{
glui32 width, height;
glk_window_get_size(win, &width, &height);
glk_set_window(win);
glk_window_clear(win);
if(glk_window_get_type(win) == wintype_TextGrid) {
glk_window_move_cursor(win, width / 2 - strlen(text) / 2, height / 2);
glk_put_string(text);
} else if(glk_window_get_type(win) == wintype_TextBuffer) {
int count;
for(count = 0; count < height / 2; count++)
glk_put_char('\n');
for(count = 0;
count < (int)(SPACE_FACTOR * (width / 2 - strlen(text) / 2));
count++)
glk_put_char(' ');
glk_put_string(text);
}
}
/* This draws some corner decorations in *every* key window -- the
one created at startup, and any later ones. It finds them all
with glk_window_iterate. */
static void draw_keywins(void)
{
winid_t win;
glui32 rock;
glui32 width, height;
for (win = glk_window_iterate(NULL, &rock);
win;
win = glk_window_iterate(win, &rock)) {
if (rock == KEYWINROCK) {
glk_set_window(win);
glk_window_clear(win);
glk_window_get_size(win, &width, &height);
glk_window_move_cursor(win, 0, 0);
glk_put_char('O');
glk_window_move_cursor(win, width-1, 0);
glk_put_char('O');
glk_window_move_cursor(win, 0, height-1);
glk_put_char('O');
glk_window_move_cursor(win, width-1, height-1);
glk_put_char('O');
}
}
}
/*======================================================================*/
void statusline(void)
{
#ifdef HAVE_GLK
glui32 glkWidth;
char line[100];
int pcol = col;
if (!statusLineOption) return;
if (glkStatusWin == NULL)
return;
glk_set_window(glkStatusWin);
glk_window_clear(glkStatusWin);
glk_window_get_size(glkStatusWin, &glkWidth, NULL);
#ifdef HAVE_GARGLK
int i;
glk_set_style(style_User1);
for (i = 0; i < glkWidth; i++)
glk_put_char(' ');
#endif
onStatusLine = TRUE;
col = 1;
glk_window_move_cursor(glkStatusWin, 1, 0);
sayInstance(where(HERO, TRUE));
// TODO Add status message1 & 2 as author customizable messages
if (header->maximumScore > 0)
sprintf(line, "Score %d(%d)/%d moves", current.score, (int)header->maximumScore, current.tick);
else
sprintf(line, "%d moves", current.tick);
glk_window_move_cursor(glkStatusWin, glkWidth-strlen(line)-1, 0);
glk_put_string(line);
needSpace = FALSE;
col = pcol;
onStatusLine = FALSE;
glk_set_window(glkMainWin);
#else
#ifdef HAVE_ANSI
char line[100];
int i;
int pcol = col;
if (!statusLineOption) return;
/* ansi_position(1,1); ansi_bold_on(); */
printf("\x1b[1;1H");
printf("\x1b[7m");
onStatusLine = TRUE;
col = 1;
sayInstance(where(HERO, FALSE));
if (header->maximumScore > 0)
sprintf(line, "Score %d(%d)/%d moves", current.score, header->maximumScore, current.tick);
else
sprintf(line, "%ld moves", (long)current.tick);
for (i=0; i < pageWidth - col - strlen(line); i++) putchar(' ');
printf(line);
printf("\x1b[m");
printf("\x1b[%d;1H", pageLength);
needSpace = FALSE;
capitalize = TRUE;
onStatusLine = FALSE;
col = pcol;
#endif
#endif
}
void GlkInterface::initialize() {
uint width, height;
/*
* Init glk stuff
*/
// monor
glk_stylehint_set(wintype_AllTypes, style_Preformatted, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Preformatted, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Preformatted, stylehint_Oblique, 0);
// monob
glk_stylehint_set(wintype_AllTypes, style_Subheader, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Subheader, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_Subheader, stylehint_Oblique, 0);
// monoi
glk_stylehint_set(wintype_AllTypes, style_Alert, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Alert, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Alert, stylehint_Oblique, 1);
// monoz
glk_stylehint_set(wintype_AllTypes, style_BlockQuote, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_BlockQuote, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_BlockQuote, stylehint_Oblique, 1);
// propr
glk_stylehint_set(wintype_TextBuffer, style_Normal, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Normal, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Normal, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Normal, stylehint_Oblique, 0);
// propb
glk_stylehint_set(wintype_TextBuffer, style_Header, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Header, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Header, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_Header, stylehint_Oblique, 0);
// propi
glk_stylehint_set(wintype_TextBuffer, style_Emphasized, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Emphasized, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Emphasized, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Emphasized, stylehint_Oblique, 1);
// propi
glk_stylehint_set(wintype_TextBuffer, style_Note, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Note, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Note, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_Note, stylehint_Oblique, 1);
/*
* Get the screen size
*/
gos_lower = glk_window_open(0, 0, 0, wintype_TextGrid, 0);
if (!gos_lower)
gos_lower = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
glk_window_get_size(gos_lower, &width, &height);
glk_window_close(gos_lower, nullptr);
gos_channel = nullptr;
/*
* Icky magic bit setting
*/
if (h_version == V3 && _tandyBit)
h_config |= CONFIG_TANDY;
if (h_version == V3 && gos_upper)
h_config |= CONFIG_SPLITSCREEN;
if (h_version == V3 && !gos_upper)
h_config |= CONFIG_NOSTATUSLINE;
if (h_version >= V4)
h_config |= CONFIG_BOLDFACE | CONFIG_EMPHASIS |
CONFIG_FIXED | CONFIG_TIMEDINPUT | CONFIG_COLOUR;
if (h_version >= V5)
h_flags &= ~(GRAPHICS_FLAG | MOUSE_FLAG | MENU_FLAG);
if ((h_version >= 5) && (h_flags & SOUND_FLAG))
h_flags |= SOUND_FLAG;
if ((h_version == 3) && (h_flags & OLD_SOUND_FLAG))
h_flags |= OLD_SOUND_FLAG;
if ((h_version == 6) && (_sound != 0))
h_config |= CONFIG_SOUND;
if (h_version >= V5 && (h_flags & UNDO_FLAG))
if (_undo_slots == 0)
h_flags &= ~UNDO_FLAG;
h_screen_cols = width;
h_screen_rows = height;
h_screen_height = h_screen_rows;
h_screen_width = h_screen_cols;
h_font_width = 1;
h_font_height = 1;
// Must be after screen dimensions are computed
if (g_conf->_graphics) {
if (_blorb)
// Blorb file containers allow graphics
h_flags |= GRAPHICS_FLAG;
else if ((h_version == V6 || _storyId == BEYOND_ZORK) && initPictures())
// Earlier Infocom game with picture files
h_flags |= GRAPHICS_FLAG;
}
// Use the ms-dos interpreter number for v6, because that's the
// kind of graphics files we understand
h_interpreter_number = h_version == 6 ? INTERP_MSDOS : INTERP_AMIGA;
h_interpreter_version = 'F';
// Set these per spec 8.3.2.
h_default_foreground = WHITE_COLOUR;
h_default_background = BLACK_COLOUR;
if (h_flags & COLOUR_FLAG)
h_flags &= ~COLOUR_FLAG;
/*
* Open the windows
*/
if (_storyId == BEYOND_ZORK)
showBeyondZorkTitle();
gos_lower = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
gos_upper = glk_window_open(gos_lower,
winmethod_Above | winmethod_Fixed,
0,
wintype_TextGrid, 0);
glk_set_window(gos_lower);
gos_curwin = gos_lower;
// Set the screen colors
garglk_set_zcolors(_defaultForeground, _defaultBackground);
// Add any sound folder or zip
addSound();
}
void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
{
gidispatch_function_t *gidispatch_function;
char *prototype;
int argument = 0;
int slot = 0;
gidispatch_function = gidispatch_get_function_by_id(funcnum);
prototype = gidispatch_prototype(funcnum);
printf("DEBUG: dispatch call name=%s, prototype=%s, numargs=%u -- ", gidispatch_function->name, prototype, (unsigned int)numargs);
if (strcmp(prototype, "4IuIuIuIs") == 0) {
printf("%u, %u, %u, %d\n", arglist[0].uint, arglist[1].uint, arglist[2].uint, arglist[3].sint);
} else if (strcmp(prototype, "3IuIu:Iu") == 0) {
printf("%u, %u, returning a glui32\n", arglist[0].uint, arglist[1].uint);
} else if (strcmp(prototype, "3Qa<Iu:Qa") == 0) {
printf("win at %p, outref to a glui32, returning a winid_t\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "3Qc<Iu:Qc") == 0) {
printf("fileref at %p, outref to a glui32, returning a frefid_t\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "1Qa:") == 0) {
printf("win at %p\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "6QaIuIuIuIu:Qa") == 0) {
printf("win at %p, %u, %u, %u, %u, returning a winid_t\n", arglist[0].opaqueref, arglist[1].uint, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "4IuIuIuIs:") == 0) {
printf("%u, %u, %u, %d\n", arglist[0].uint, arglist[1].uint, arglist[2].uint, arglist[3].sint);
} else if (strcmp(prototype, "1Qb:") == 0) {
printf("stream at %p\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "1Iu:") == 0) {
printf("%u\n", arglist[0].uint);
} else if (strcmp(prototype, "2Qb<[2IuIu]:") == 0) {
printf("stream at %p, some struct stuff here\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "3IuIuIu:") == 0) {
printf("%u, %u, %u\n", arglist[0].uint, arglist[1].uint, arglist[2].uint);
} else if (strcmp(prototype, "1:Qb") == 0) {
printf("returning a strid_t\n");
} else if (strcmp(prototype, "4&+#!IuIuIu:Qb") == 0) {
printf("retained, nonnull, array of glui32 at %p for length %u, %u, %u, returning a strid_t\n", arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "2Qc:Iu") == 0) {
printf("fileref at %p, returning a glui32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "1<+[4IuQaIuIu]:") == 0) {
printf("some struct stuff here, nonnull\n");
} else if (strcmp(prototype, "1:Qb") == 0) {
printf("returning a strid_t\n");
} else if (strcmp(prototype, "2Qb:Is") == 0) {
printf("stream at %p, returning a glsi32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "2Qc:Iu") == 0) {
printf("fileref at %p, returning a glui32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "3Qa&+#!CnIu:") == 0) {
printf("win at %p, retained, nonnull, array of char at %p for length %u, %u\n", arglist[0].opaqueref, arglist[2].array, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "3Qb<Iu:Qb") == 0) {
printf("stream at %p, outref to a glui32, returning a strid_t\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "4&+#!CnIuIu:Qb") == 0) {
printf("retained, nonnull, array of char at %p for length %u, %u, %u, returning a strid_t\n", arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "4&+#!IuIuIu:Qb") == 0) {
printf("retained, nonnull, array of glui32 at %p for length %u, %u, %u, returning a strid_t\n", arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "4IuSIu:Qc") == 0) {
printf("%u, %s, %u, returning a frefid_t\n", arglist[0].uint, arglist[1].charstr, arglist[2].uint);
} else if (strcmp(prototype, "4QcIuIu:Qb") == 0) {
printf("fileref at %p, %u, %u, returning a strid_t\n", arglist[0].opaqueref, arglist[1].uint, arglist[2].uint);
} else if (strcmp(prototype, "3Qa<Iu<Iu:") == 0) {
printf("win at %p, outref to a glui32, outref to a glui32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "6QaIuIsIsIuIu:") == 0) {
printf("win at %p, %u, %d, %d, %u, %u\n", arglist[0].opaqueref, arglist[1].uint, arglist[2].sint, arglist[3].sint, arglist[4].uint, arglist[5].uint);
} else if (strcmp(prototype, "4Iu<Iu<Iu:Iu") == 0) {
printf("%u, outref to a glui32, outref to a glui32, returning a glui32\n", arglist[0].uint);
} else {
printf("unhandled prototype\n");
}
switch (funcnum) {
case 0x0004: /* gestalt */
arglist[3].uint = glk_gestalt(arglist[0].uint, arglist[1].uint);
break;
case 0x0005: /* gestalt_ext */
if (arglist[2].ptrflag) {
arglist[6].uint = glk_gestalt_ext(arglist[0].uint, arglist[1].uint,
arglist[3].array, arglist[4].uint);
}
else {
arglist[4].uint = glk_gestalt_ext(arglist[0].uint, arglist[1].uint,
NULL, 0);
}
break;
case 0x0020: /* window_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_window_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_window_iterate(arglist[0].opaqueref, NULL);
break;
case 0x0023: /* window_open */
arglist[6].opaqueref = glk_window_open(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, arglist[3].uint, arglist[4].uint);
break;
case 0x0025: /* window_get_size */
{
int ix = 1;
glui32 *ptr1, *ptr2;
if (!arglist[ix].ptrflag) {
ptr1 = NULL;
}
else {
ix++;
ptr1 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr2 = NULL;
}
else {
ix++;
ptr2 = &(arglist[ix].uint);
}
ix++;
glk_window_get_size(arglist[0].opaqueref, ptr1, ptr2);
}
break;
case 0x0028: /* window_get_type */
arglist[2].uint = glk_window_get_type(arglist[0].opaqueref);
break;
case 0x002A: /* window_clear */
glk_window_clear(arglist[0].opaqueref);
break;
case 0x002B: /* window_move_cursor */
glk_window_move_cursor(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x002F: /* set_window */
glk_set_window(arglist[0].opaqueref);
break;
case 0x0040: /* stream_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_stream_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_stream_iterate(arglist[0].opaqueref, NULL);
break;
case 0x0042: /* stream_open_file */
arglist[4].opaqueref = glk_stream_open_file(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x0043: /* stream_open_memory */
if (arglist[0].ptrflag)
arglist[6].opaqueref = glk_stream_open_memory(arglist[1].array,
arglist[2].uint, arglist[3].uint, arglist[4].uint);
else
arglist[4].opaqueref = glk_stream_open_memory(NULL,
0, arglist[1].uint, arglist[2].uint);
break;
case 0x0044: /* stream_close */
if (arglist[1].ptrflag) {
stream_result_t dat;
glk_stream_close(arglist[0].opaqueref, &dat);
arglist[2].uint = dat.readcount;
arglist[3].uint = dat.writecount;
}
else {
glk_stream_close(arglist[0].opaqueref, NULL);
}
break;
case 0x0047: /* stream_set_current */
glk_stream_set_current(arglist[0].opaqueref);
break;
case 0x0048: /* stream_get_current */
arglist[1].opaqueref = glk_stream_get_current();
break;
case 0x0061: /* fileref_create_by_name */
arglist[4].opaqueref = glk_fileref_create_by_name(arglist[0].uint,
arglist[1].charstr, arglist[2].uint);
break;
case 0x0062: /* fileref_create_by_prompt */
arglist[4].opaqueref = glk_fileref_create_by_prompt(arglist[0].uint,
arglist[1].uint, arglist[2].uint);
break;
case 0x0067: /* fileref_does_file_exist */
arglist[2].uint = glk_fileref_does_file_exist(arglist[0].opaqueref);
break;
case 0x0086: /* set_style */
glk_set_style(arglist[0].uint);
break;
case 0x0087: /* set_style_stream */
glk_set_style_stream(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x0090: /* get_char_stream */
arglist[2].sint = glk_get_char_stream(arglist[0].opaqueref);
break;
case 0x00B0: /* stylehint_set */
glk_stylehint_set(arglist[0].uint, arglist[1].uint,
arglist[2].uint, arglist[3].sint);
break;
case 0x00C0: /* select */
if (arglist[0].ptrflag) {
event_t dat;
glk_select(&dat);
arglist[1].uint = dat.type;
arglist[2].opaqueref = dat.win;
arglist[3].uint = dat.val1;
arglist[4].uint = dat.val2;
}
else {
glk_select(NULL);
}
break;
case 0x00D0: /* request_line_event */
if (arglist[1].ptrflag)
glk_request_line_event(arglist[0].opaqueref, arglist[2].array,
arglist[3].uint, arglist[4].uint);
else
glk_request_line_event(arglist[0].opaqueref, NULL,
0, arglist[2].uint);
break;
case 0x00D2: /* request_char_event */
glk_request_char_event(arglist[0].opaqueref);
break;
case 0x00E0: /* image_get_info */
{
int ix = 1;
glui32 *ptr1, *ptr2;
if (!arglist[ix].ptrflag) {
ptr1 = NULL;
}
else {
ix++;
ptr1 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr2 = NULL;
}
else {
ix++;
ptr2 = &(arglist[ix].uint);
}
ix++;
ix++;
arglist[ix].uint = glk_image_get_info(arglist[0].uint, ptr1, ptr2);
}
break;
case 0x00E1: /* image_draw */
arglist[5].uint = glk_image_draw(arglist[0].opaqueref,
arglist[1].uint,
arglist[2].sint, arglist[3].sint);
break;
case 0x00E2: /* image_draw_scaled */
arglist[7].uint = glk_image_draw_scaled(arglist[0].opaqueref,
arglist[1].uint,
arglist[2].sint, arglist[3].sint,
arglist[4].uint, arglist[5].uint);
break;
case 0x00EA: /* window_fill_rect */
glk_window_fill_rect(arglist[0].opaqueref, arglist[1].uint,
arglist[2].sint, arglist[3].sint,
arglist[4].uint, arglist[5].uint);
break;
case 0x0128: /* put_char_uni */
glk_put_char_uni(arglist[0].uint);
break;
case 0x0139: /* stream_open_memory_uni */
if (arglist[0].ptrflag)
arglist[6].opaqueref = glk_stream_open_memory_uni(arglist[1].array,
arglist[2].uint, arglist[3].uint, arglist[4].uint);
else
arglist[4].opaqueref = glk_stream_open_memory_uni(NULL,
0, arglist[1].uint, arglist[2].uint);
break;
default:
printf("Unhandled call to %s via dispatch\n", gidispatch_function->name);
#if 0
case 0x0001: /* exit */
glk_exit();
break;
case 0x0002: /* set_interrupt_handler */
/* cannot be invoked through dispatch layer */
break;
case 0x0003: /* tick */
glk_tick();
break;
case 0x0021: /* window_get_rock */
arglist[2].uint = glk_window_get_rock(arglist[0].opaqueref);
break;
case 0x0022: /* window_get_root */
arglist[1].opaqueref = glk_window_get_root();
break;
case 0x0024: /* window_close */
if (arglist[1].ptrflag) {
stream_result_t dat;
glk_window_close(arglist[0].opaqueref, &dat);
arglist[2].uint = dat.readcount;
arglist[3].uint = dat.writecount;
}
else {
glk_window_close(arglist[0].opaqueref, NULL);
}
break;
case 0x0026: /* window_set_arrangement */
glk_window_set_arrangement(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, arglist[3].opaqueref);
break;
case 0x0027: /* window_get_arrangement */
{
int ix = 1;
glui32 *ptr1, *ptr2;
winid_t *ptr3;
if (!arglist[ix].ptrflag) {
ptr1 = NULL;
}
else {
ix++;
ptr1 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr2 = NULL;
}
else {
ix++;
ptr2 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr3 = NULL;
}
else {
ix++;
ptr3 = (winid_t *)(&(arglist[ix].opaqueref));
}
ix++;
glk_window_get_arrangement(arglist[0].opaqueref, ptr1, ptr2, ptr3);
}
break;
case 0x0029: /* window_get_parent */
arglist[2].opaqueref = glk_window_get_parent(arglist[0].opaqueref);
break;
case 0x002C: /* window_get_stream */
arglist[2].opaqueref = glk_window_get_stream(arglist[0].opaqueref);
break;
case 0x002D: /* window_set_echo_stream */
glk_window_set_echo_stream(arglist[0].opaqueref, arglist[1].opaqueref);
break;
case 0x002E: /* window_get_echo_stream */
arglist[2].opaqueref = glk_window_get_echo_stream(arglist[0].opaqueref);
break;
case 0x0030: /* window_get_sibling */
arglist[2].opaqueref = glk_window_get_sibling(arglist[0].opaqueref);
break;
case 0x0041: /* stream_get_rock */
arglist[2].uint = glk_stream_get_rock(arglist[0].opaqueref);
break;
case 0x0045: /* stream_set_position */
glk_stream_set_position(arglist[0].opaqueref, arglist[1].sint,
arglist[2].uint);
break;
case 0x0046: /* stream_get_position */
arglist[2].uint = glk_stream_get_position(arglist[0].opaqueref);
break;
case 0x0048: /* stream_get_current */
arglist[1].opaqueref = glk_stream_get_current();
break;
case 0x0060: /* fileref_create_temp */
arglist[3].opaqueref = glk_fileref_create_temp(arglist[0].uint,
arglist[1].uint);
break;
case 0x0063: /* fileref_destroy */
glk_fileref_destroy(arglist[0].opaqueref);
break;
case 0x0064: /* fileref_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_fileref_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_fileref_iterate(arglist[0].opaqueref, NULL);
break;
case 0x0065: /* fileref_get_rock */
arglist[2].uint = glk_fileref_get_rock(arglist[0].opaqueref);
break;
case 0x0066: /* fileref_delete_file */
glk_fileref_delete_file(arglist[0].opaqueref);
break;
case 0x0068: /* fileref_create_from_fileref */
arglist[4].opaqueref = glk_fileref_create_from_fileref(arglist[0].uint,
arglist[1].opaqueref, arglist[2].uint);
break;
case 0x0080: /* put_char */
glk_put_char(arglist[0].uch);
break;
case 0x0081: /* put_char_stream */
glk_put_char_stream(arglist[0].opaqueref, arglist[1].uch);
break;
case 0x0082: /* put_string */
glk_put_string(arglist[0].charstr);
break;
case 0x0083: /* put_string_stream */
glk_put_string_stream(arglist[0].opaqueref, arglist[1].charstr);
break;
case 0x0084: /* put_buffer */
if (arglist[0].ptrflag)
glk_put_buffer(arglist[1].array, arglist[2].uint);
else
glk_put_buffer(NULL, 0);
break;
case 0x0085: /* put_buffer_stream */
if (arglist[1].ptrflag)
glk_put_buffer_stream(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
glk_put_buffer_stream(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0091: /* get_line_stream */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_line_stream(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_line_stream(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0092: /* get_buffer_stream */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_buffer_stream(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_buffer_stream(arglist[0].opaqueref,
NULL, 0);
break;
case 0x00A0: /* char_to_lower */
arglist[2].uch = glk_char_to_lower(arglist[0].uch);
break;
case 0x00A1: /* char_to_upper */
arglist[2].uch = glk_char_to_upper(arglist[0].uch);
break;
case 0x00B1: /* stylehint_clear */
glk_stylehint_clear(arglist[0].uint, arglist[1].uint,
arglist[2].uint);
break;
case 0x00B2: /* style_distinguish */
arglist[4].uint = glk_style_distinguish(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x00B3: /* style_measure */
if (arglist[3].ptrflag)
arglist[6].uint = glk_style_measure(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, &(arglist[4].uint));
else
arglist[5].uint = glk_style_measure(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, NULL);
break;
case 0x00C1: /* select_poll */
if (arglist[0].ptrflag) {
event_t dat;
glk_select_poll(&dat);
arglist[1].uint = dat.type;
arglist[2].opaqueref = dat.win;
arglist[3].uint = dat.val1;
arglist[4].uint = dat.val2;
}
else {
glk_select_poll(NULL);
}
break;
case 0x00D1: /* cancel_line_event */
if (arglist[1].ptrflag) {
event_t dat;
glk_cancel_line_event(arglist[0].opaqueref, &dat);
arglist[2].uint = dat.type;
arglist[3].opaqueref = dat.win;
arglist[4].uint = dat.val1;
arglist[5].uint = dat.val2;
}
else {
glk_cancel_line_event(arglist[0].opaqueref, NULL);
}
break;
case 0x00D3: /* cancel_char_event */
glk_cancel_char_event(arglist[0].opaqueref);
break;
case 0x00D4: /* request_mouse_event */
glk_request_mouse_event(arglist[0].opaqueref);
break;
case 0x00D5: /* cancel_mouse_event */
glk_cancel_mouse_event(arglist[0].opaqueref);
break;
case 0x00D6: /* request_timer_events */
glk_request_timer_events(arglist[0].uint);
break;
#ifdef GLK_MODULE_IMAGE
case 0x00E8: /* window_flow_break */
glk_window_flow_break(arglist[0].opaqueref);
break;
case 0x00E9: /* window_erase_rect */
glk_window_erase_rect(arglist[0].opaqueref,
arglist[1].sint, arglist[2].sint,
arglist[3].uint, arglist[4].uint);
break;
case 0x00EB: /* window_set_background_color */
glk_window_set_background_color(arglist[0].opaqueref, arglist[1].uint);
break;
#endif /* GLK_MODULE_IMAGE */
#ifdef GLK_MODULE_SOUND
case 0x00F0: /* schannel_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_schannel_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_schannel_iterate(arglist[0].opaqueref, NULL);
break;
case 0x00F1: /* schannel_get_rock */
arglist[2].uint = glk_schannel_get_rock(arglist[0].opaqueref);
break;
case 0x00F2: /* schannel_create */
arglist[2].opaqueref = glk_schannel_create(arglist[0].uint);
break;
case 0x00F3: /* schannel_destroy */
glk_schannel_destroy(arglist[0].opaqueref);
break;
case 0x00F8: /* schannel_play */
arglist[3].uint = glk_schannel_play(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x00F9: /* schannel_play_ext */
arglist[5].uint = glk_schannel_play_ext(arglist[0].opaqueref,
arglist[1].uint, arglist[2].uint, arglist[3].uint);
break;
case 0x00FA: /* schannel_stop */
glk_schannel_stop(arglist[0].opaqueref);
break;
case 0x00FB: /* schannel_set_volume */
glk_schannel_set_volume(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x00FC: /* sound_load_hint */
glk_sound_load_hint(arglist[0].uint, arglist[1].uint);
break;
#endif /* GLK_MODULE_SOUND */
#ifdef GLK_MODULE_HYPERLINKS
case 0x0100: /* set_hyperlink */
glk_set_hyperlink(arglist[0].uint);
break;
case 0x0101: /* set_hyperlink_stream */
glk_set_hyperlink_stream(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x0102: /* request_hyperlink_event */
glk_request_hyperlink_event(arglist[0].opaqueref);
break;
case 0x0103: /* cancel_hyperlink_event */
glk_cancel_hyperlink_event(arglist[0].opaqueref);
break;
#endif /* GLK_MODULE_HYPERLINKS */
#ifdef GLK_MODULE_UNICODE
case 0x0120: /* buffer_to_lower_case_uni */
if (arglist[0].ptrflag)
arglist[5].uint = glk_buffer_to_lower_case_uni(arglist[1].array, arglist[2].uint, arglist[3].uint);
else
arglist[3].uint = glk_buffer_to_lower_case_uni(NULL, 0, arglist[1].uint);
break;
case 0x0121: /* buffer_to_upper_case_uni */
if (arglist[0].ptrflag)
arglist[5].uint = glk_buffer_to_upper_case_uni(arglist[1].array, arglist[2].uint, arglist[3].uint);
else
arglist[3].uint = glk_buffer_to_upper_case_uni(NULL, 0, arglist[1].uint);
break;
case 0x0122: /* buffer_to_title_case_uni */
if (arglist[0].ptrflag)
arglist[6].uint = glk_buffer_to_title_case_uni(arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
else
arglist[4].uint = glk_buffer_to_title_case_uni(NULL, 0, arglist[1].uint, arglist[2].uint);
break;
case 0x0129: /* put_string_uni */
glk_put_string_uni(arglist[0].unicharstr);
break;
case 0x012A: /* put_buffer_uni */
if (arglist[0].ptrflag)
glk_put_buffer_uni(arglist[1].array, arglist[2].uint);
else
glk_put_buffer_uni(NULL, 0);
break;
case 0x012B: /* put_char_stream_uni */
glk_put_char_stream_uni(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x012C: /* put_string_stream_uni */
glk_put_string_stream_uni(arglist[0].opaqueref, arglist[1].unicharstr);
break;
case 0x012D: /* put_buffer_stream_uni */
if (arglist[1].ptrflag)
glk_put_buffer_stream_uni(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
glk_put_buffer_stream_uni(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0130: /* get_char_stream_uni */
arglist[2].sint = glk_get_char_stream_uni(arglist[0].opaqueref);
break;
case 0x0131: /* get_buffer_stream_uni */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_buffer_stream_uni(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_buffer_stream_uni(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0132: /* get_line_stream_uni */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_line_stream_uni(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_line_stream_uni(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0138: /* stream_open_file_uni */
arglist[4].opaqueref = glk_stream_open_file_uni(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x0140: /* request_char_event_uni */
glk_request_char_event_uni(arglist[0].opaqueref);
break;
case 0x0141: /* request_line_event_uni */
if (arglist[1].ptrflag)
glk_request_line_event_uni(arglist[0].opaqueref, arglist[2].array,
arglist[3].uint, arglist[4].uint);
else
glk_request_line_event_uni(arglist[0].opaqueref, NULL,
0, arglist[2].uint);
break;
#endif /* GLK_MODULE_UNICODE */
#endif /* 0 */
}
}
void os_init_screen(void)
{
glui32 width, height;
/*
* Init glk stuff
*/
/* monor */
glk_stylehint_set(wintype_AllTypes, style_Preformatted, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Preformatted, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Preformatted, stylehint_Oblique, 0);
/* monob */
glk_stylehint_set(wintype_AllTypes, style_Subheader, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Subheader, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_Subheader, stylehint_Oblique, 0);
/* monoi */
glk_stylehint_set(wintype_AllTypes, style_Alert, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Alert, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Alert, stylehint_Oblique, 1);
/* monoz */
glk_stylehint_set(wintype_AllTypes, style_BlockQuote, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_BlockQuote, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_BlockQuote, stylehint_Oblique, 1);
/* propr */
glk_stylehint_set(wintype_TextBuffer, style_Normal, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Normal, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Normal, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Normal, stylehint_Oblique, 0);
/* propb */
glk_stylehint_set(wintype_TextBuffer, style_Header, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Header, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Header, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_Header, stylehint_Oblique, 0);
/* propi */
glk_stylehint_set(wintype_TextBuffer, style_Emphasized, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Emphasized, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Emphasized, stylehint_Weight, 0);
glk_stylehint_set(wintype_AllTypes, style_Emphasized, stylehint_Oblique, 1);
/* propi */
glk_stylehint_set(wintype_TextBuffer, style_Note, stylehint_Proportional, 1);
glk_stylehint_set(wintype_TextGrid, style_Note, stylehint_Proportional, 0);
glk_stylehint_set(wintype_AllTypes, style_Note, stylehint_Weight, 1);
glk_stylehint_set(wintype_AllTypes, style_Note, stylehint_Oblique, 1);
gos_lower = glk_window_open(0, 0, 0, wintype_TextGrid, 0);
if (!gos_lower)
gos_lower = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
glk_window_get_size(gos_lower, &width, &height);
glk_window_close(gos_lower, NULL);
gos_lower = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
gos_upper = glk_window_open(gos_lower,
winmethod_Above | winmethod_Fixed,
0,
wintype_TextGrid, 0);
gos_channel = NULL;
glk_set_window(gos_lower);
gos_curwin = gos_lower;
/*
* Icky magic bit setting
*/
if (h_version == V3 && user_tandy_bit)
h_config |= CONFIG_TANDY;
if (h_version == V3 && gos_upper)
h_config |= CONFIG_SPLITSCREEN;
if (h_version == V3 && !gos_upper)
h_config |= CONFIG_NOSTATUSLINE;
if (h_version >= V4)
h_config |= CONFIG_BOLDFACE | CONFIG_EMPHASIS |
CONFIG_FIXED | CONFIG_TIMEDINPUT | CONFIG_COLOUR;
if (h_version >= V5)
h_flags &= ~(GRAPHICS_FLAG | MOUSE_FLAG | MENU_FLAG);
if ((h_version >= 5) && (h_flags & SOUND_FLAG))
h_flags |= SOUND_FLAG;
if ((h_version == 3) && (h_flags & OLD_SOUND_FLAG))
h_flags |= OLD_SOUND_FLAG;
if ((h_version == 6) && (option_sound != 0))
h_config |= CONFIG_SOUND;
if (h_version >= V5 && (h_flags & UNDO_FLAG))
if (option_undo_slots == 0)
h_flags &= ~UNDO_FLAG;
h_screen_cols = width;
h_screen_rows = height;
h_screen_height = h_screen_rows;
h_screen_width = h_screen_cols;
h_font_width = 1;
h_font_height = 1;
/* Must be after screen dimensions are computed. */
if (h_version == V6) {
h_flags &= ~GRAPHICS_FLAG;
}
/* Use the ms-dos interpreter number for v6, because that's the
* kind of graphics files we understand. Otherwise, use DEC. */
h_interpreter_number = h_version == 6 ? INTERP_MSDOS : INTERP_DEC_20;
h_interpreter_version = 'F';
{
/* Set these per spec 8.3.2. */
h_default_foreground = WHITE_COLOUR;
h_default_background = BLACK_COLOUR;
if (h_flags & COLOUR_FLAG) h_flags &= ~COLOUR_FLAG;
}
}
/* React to character input in a key window. */
static void perform_key(winid_t win, glui32 key)
{
glui32 width, height, len;
int ix;
char buf[128], keyname[64];
if (key == 'h' || key == 'v') {
winid_t newwin;
glui32 loc;
/* Open a new keywindow. */
if (key == 'h')
loc = winmethod_Right | winmethod_Proportional;
else
loc = winmethod_Below | winmethod_Proportional;
newwin = glk_window_open(win,
loc, 50, wintype_TextGrid, KEYWINROCK);
/* Since the new window has rock value KEYWINROCK, the
draw_keywins() routine will redraw it. */
if (newwin) {
/* Request character input. In this program, only keywins
get char input, so the CharInput events always call
perform_key() -- and so the new window will respond
to keys just as this one does. */
glk_request_char_event(newwin);
/* We now have to redraw the keywins, because any or all of
them could have changed size when we opened newwin.
glk_window_open() does not generate Arrange events; we
have to do the redrawing manually. */
draw_keywins();
}
/* Re-request character input for this window, so that future
keys are accepted. */
glk_request_char_event(win);
return;
}
else if (key == 'c') {
/* Close this keywindow. */
glk_window_close(win, NULL);
/* Again, any key windows could have changed size. Also the
status window could have (if this was the last key window). */
draw_keywins();
draw_statuswin();
return;
}
/* Print a string naming the key that was just hit. */
switch (key) {
case ' ':
str_cpy(keyname, "space");
break;
case keycode_Left:
str_cpy(keyname, "left");
break;
case keycode_Right:
str_cpy(keyname, "right");
break;
case keycode_Up:
str_cpy(keyname, "up");
break;
case keycode_Down:
str_cpy(keyname, "down");
break;
case keycode_Return:
str_cpy(keyname, "return");
break;
case keycode_Delete:
str_cpy(keyname, "delete");
break;
case keycode_Escape:
str_cpy(keyname, "escape");
break;
case keycode_Tab:
str_cpy(keyname, "tab");
break;
case keycode_PageUp:
str_cpy(keyname, "page up");
break;
case keycode_PageDown:
str_cpy(keyname, "page down");
break;
case keycode_Home:
str_cpy(keyname, "home");
break;
case keycode_End:
str_cpy(keyname, "end");
break;
default:
if (key <= keycode_Func1 && key >= keycode_Func12) {
str_cpy(keyname, "function key");
}
else if (key < 32) {
str_cpy(keyname, "ctrl-");
keyname[5] = '@' + key;
keyname[6] = '\0';
}
else if (key <= 255) {
keyname[0] = key;
keyname[1] = '\0';
}
else {
str_cpy(keyname, "unknown key");
}
break;
}
str_cpy(buf, "Key: ");
str_cat(buf, keyname);
len = str_len(buf);
/* Print the string centered in this window. */
glk_set_window(win);
glk_window_get_size(win, &width, &height);
glk_window_move_cursor(win, 0, height/2);
for (ix=0; ix<width; ix++)
glk_put_char(' ');
width = width/2;
len = len/2;
if (width > len)
width = width-len;
else
width = 0;
glk_window_move_cursor(win, width, height/2);
glk_put_string(buf);
/* Re-request character input for this window, so that future
keys are accepted. */
glk_request_char_event(win);
}