/* ScummVM - Graphic Adventure Engine * * ScummVM is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * 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; either version 2 * of the License, or (at your option) any later version. * * 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * */ #include "glk/hugo/hugo.h" namespace Glk { namespace Hugo { void Hugo::hugo_init_screen() { // Open the main window... mainwin = currentwin = glk_window_open(0, 0, 0, wintype_TextBuffer, 1); assert(mainwin); // ...and set it up for default output glk_set_window(mainwin); // By setting the width and height so high, we're basically forcing the Glk library // to deal with text-wrapping and page ends SCREENWIDTH = 0x7fff; SCREENHEIGHT = 0x7fff; FIXEDCHARWIDTH = 1; FIXEDLINEHEIGHT = 1; hugo_settextwindow(1, 1, SCREENWIDTH/FIXEDCHARWIDTH, SCREENHEIGHT/FIXEDLINEHEIGHT); } void Hugo::hugo_getline(const char *prmpt) { event_t ev; char gotline = 0; /* Just in case we try to get line input from a Glk-illegal window that hasn't been created, switch as a failsafe to mainwin */ if (currentwin == nullptr) glk_set_window(currentwin = mainwin); /* Print prompt */ glk_put_string(prmpt); /* Request line input */ glk_request_line_event(currentwin, buffer, MAXBUFFER, 0); while (!gotline) { if (shouldQuit()) return; /* Grab an event */ glk_select(&ev); switch (ev.type) { case evtype_LineInput: /* (Will always be currentwin, but anyway) */ if (ev.window == currentwin) { gotline = true; } break; default: break; } } /* The line we have received in commandbuf is not null-terminated */ buffer[ev.val1] = '\0'; /* i.e., the length */ /* Copy the input to the script file (if open) */ if (script) { Common::String text = Common::String::format("%s%s\n", prmpt, buffer); script->putBuffer(text.c_str(), text.size()); } } int Hugo::hugo_waitforkey() { event_t ev; char gotchar = 0; /* Just in case we try to get key input from a Glk-illegal window that hasn't been created, switch as a failsafe to mainwin */ if (currentwin == nullptr) glk_set_window(currentwin = mainwin); #if defined (NO_KEYPRESS_CURSOR) if (currentwin != mainwin) { glk_window_move_cursor(currentwin, currentpos / CHARWIDTH, currentline - 1); hugo_print("*"); glk_window_move_cursor(currentwin, currentpos / CHARWIDTH, currentline - 1); } #endif glk_request_char_event(currentwin); while (!gotchar) { /* Grab an event */ glk_select(&ev); switch (ev.type) { case evtype_CharInput: /* (Will always be mainwin, but anyway) */ if (ev.window == currentwin) { gotchar = true; } break; default: break; } } /* Convert Glk special keycodes: */ switch (ev.val1) { case keycode_Left: ev.val1 = 8; break; case keycode_Right: ev.val1 = 21; break; case keycode_Up: ev.val1 = 11; break; case keycode_Down: ev.val1 = 10; break; case keycode_Return: ev.val1 = 13; break; case keycode_Escape: ev.val1 = 27; break; } #if defined (NO_KEYPRESS_CURSOR) if (currentwin != mainwin) { glk_window_move_cursor(currentwin, currentpos / CHARWIDTH, currentline - 1); hugo_print(" "); glk_window_move_cursor(currentwin, currentpos / CHARWIDTH, currentline - 1); } #endif return ev.val1; } int Hugo::hugo_iskeywaiting() { var[system_status] = STAT_UNAVAILABLE; return 0; } int Hugo::hugo_timewait(int n) { uint32 millisecs; event_t ev; if (!glk_gestalt(gestalt_Timer, 0)) return false; if (n == 0) return true; millisecs = 1000 / n; if (millisecs == 0) millisecs = 1; // For the time being, we're going to disallow // millisecond delays in Glk (1) because there's no // point, and (2) so that we can tell we're running // under Glk. if (millisecs < 1000) return false; glk_request_timer_events(millisecs); while (1) { glk_select(&ev); if (ev.type == evtype_Timer) break; } glk_request_timer_events(0); return true; } void Hugo::hugo_clearfullscreen() { glk_window_clear(mainwin); if (secondwin) glk_window_clear(secondwin); if (auxwin) glk_window_clear(auxwin); /* See hugo_print() for the need for this */ if (currentwin == mainwin) mainwin_bgcolor = glk_bgcolor; /* Must be set: */ currentpos = 0; currentline = 1; if (!inwindow) just_cleared_screen = true; } void Hugo::hugo_clearwindow() { /* Clears the currently defined window, moving the cursor to the top-left corner of the window */ /* If the engine thinks we're in a window, but Glk was unable to comply, don't clear the window, because it's not really a window */ if (inwindow && currentwin == mainwin) return; if (currentwin == nullptr) return; glk_window_clear(currentwin); /* See hugo_print() for the need for this */ if (currentwin == mainwin) mainwin_bgcolor = glk_bgcolor; /* If we're in a fixed-font (i.e., textgrid) auxiliary window when we call for a clear, close auxwin and reset the current window to mainwin */ if (auxwin) { stream_result_t sr; glk_window_close(auxwin, &sr); auxwin = nullptr; glk_set_window(currentwin = mainwin); } /* Must be set: */ currentpos = 0; currentline = 1; if (!inwindow) just_cleared_screen = true; } void Hugo::hugo_settextmode() { charwidth = FIXEDCHARWIDTH; lineheight = FIXEDLINEHEIGHT; } void Hugo::hugo_settextwindow(int left, int top, int right, int bottom) { /* Hugo's arbitrarily positioned windows don't currently mesh with what Glk has to offer, so we have to ignore any non-Glk-ish Windows and just maintain the current parameters */ if ((top != 1 || bottom >= physical_windowbottom / FIXEDLINEHEIGHT + 1) /* Pre-v2.4 didn't support proper windowing */ && (game_version >= 24 || !inwindow)) { in_valid_window = false; /* Glk-illegal floating window; setting currentwin to nullptr will tell hugo_print() not to print in it: */ if (bottom<physical_windowbottom / FIXEDLINEHEIGHT + 1) { currentwin = nullptr; glk_set_window(mainwin); return; } else glk_set_window(currentwin = mainwin); } /* Otherwise this is a valid window (positioned along the top of the screen a la a status window), so... */ else { /* Arbitrary height of 4 lines for pre-v2.4 windows */ if (game_version < 24) bottom = 4; /* ...either create a new window if none exists... */ if (!secondwin) { glk_stylehint_set(wintype_TextGrid, style_Normal, stylehint_ReverseColor, 1); glk_stylehint_set(wintype_TextGrid, style_Subheader, stylehint_ReverseColor, 1); glk_stylehint_set(wintype_TextGrid, style_Emphasized, stylehint_ReverseColor, 1); //winid_t p = glk_window_get_parent(mainwin); secondwin = glk_window_open(mainwin,//p, winmethod_Above | winmethod_Fixed, bottom, wintype_TextGrid, 0); } /* ...or resize the existing one if necessary */ else if (bottom != secondwin_bottom) { winid_t p; p = glk_window_get_parent(secondwin); glk_window_set_arrangement(p, winmethod_Above | winmethod_Fixed, bottom, secondwin); } if (secondwin) { if (game_version < 24) glk_window_clear(secondwin); glk_set_window(currentwin = secondwin); in_valid_window = true; secondwin_bottom = bottom; } else { currentwin = nullptr; glk_set_window(mainwin); secondwin_bottom = 0; return; } } physical_windowleft = (left - 1)*FIXEDCHARWIDTH; physical_windowtop = (top - 1)*FIXEDLINEHEIGHT; physical_windowright = right*FIXEDCHARWIDTH - 1; physical_windowbottom = bottom*FIXEDLINEHEIGHT - 1; physical_windowwidth = (right - left + 1)*FIXEDCHARWIDTH; physical_windowheight = (bottom - top + 1)*FIXEDLINEHEIGHT; } int Hugo::heglk_get_linelength() { static uint width; // Try to use whatever fixed-width linelength is available if (secondwin) glk_window_get_size(secondwin, &width, nullptr); else if (auxwin) glk_window_get_size(auxwin, &width, nullptr); // Otherwise try to approximate it by the proportionally spaced linelength else glk_window_get_size(mainwin, &width, nullptr); // -1 to override automatic line wrapping return width - 1; } int Hugo::heglk_get_screenheight() { static uint height = 0, mainheight = 0; if (secondwin) glk_window_get_size(secondwin, nullptr, &height); else if (auxwin) glk_window_get_size(auxwin, nullptr, &height); glk_window_get_size(mainwin, nullptr, &mainheight); return height + mainheight; } void Hugo::hugo_settextpos(int x, int y) { if (currentwin == nullptr) return; // Try to determine if we're trying to position fixed-width text in the main window, // as in a menu, for example if (!just_cleared_screen && !inwindow && !(glk_current_font & PROP_FONT) && y != 1 /* not just cls */ && y < SCREENHEIGHT - 0x0f) /* 0x0f is arbitrary */ { /* See if we're already in the auxiliary window */ if (currentwin != auxwin) { /* If not, create it, making it 100% of mainwin's height */ if (auxwin == nullptr) { auxwin = glk_window_open(mainwin, winmethod_Below | winmethod_Proportional, 100, wintype_TextGrid, 0); } else glk_window_clear(auxwin); glk_set_window(currentwin = auxwin); } } /* On the other hand, if we were in a textgrid window and no longer need to be, get out */ else if (auxwin) { stream_result_t sr; /* Close auxwin */ glk_window_close(auxwin, &sr); auxwin = nullptr; /* Clear the screen (both windows) */ glk_window_clear(mainwin); glk_window_clear(secondwin); glk_set_window(currentwin = mainwin); } just_cleared_screen = false; /* Can only move the Glk cursor in a textgrid window */ if (currentwin != mainwin) glk_window_move_cursor(currentwin, x - 1, y - 1); /* Must be set: */ currentline = y; currentpos = (x - 1)*CHARWIDTH; /* Note: zero-based */ } void Hugo::hugo_print(const char *a) { static char just_printed_linefeed = false; /* static already_modified_style = false; */ /* Can't print in a Glk-illegal window since it hasn't been created */ if (currentwin == nullptr) return; /* In lieu of colors, in case we're highlighting something such as a menu selection: */ /* if (!inwindow and glk_bgcolor!=mainwin_bgcolor) { if (!already_modified_style) { if (glk_current_font & BOLD_FONT) glk_set_style(style_Normal); else glk_set_style(style_Emphasized); } already_modified_style = true; } else already_modified_style = false; */ if (a[0] == '\n') { if (!just_printed_linefeed) { glk_put_string("\n"); } else just_printed_linefeed = false; } else if (a[0] == '\r') { if (!just_printed_linefeed) { glk_put_string("\n"); just_printed_linefeed = true; } else just_printed_linefeed = false; } else { glk_put_string(a); just_printed_linefeed = false; } } void Hugo::hugo_font(int f) { static char using_prop_font = false; glk_current_font = f; glk_set_style(style_Normal); if (f & BOLD_FONT) glk_set_style(style_Subheader); if (f & UNDERLINE_FONT) glk_set_style(style_Emphasized); if (f & ITALIC_FONT) glk_set_style(style_Emphasized); if (f & PROP_FONT) using_prop_font = true; /* Have to comment this out, it seems, because it will mess up the alignment of the input in the main window if (!(f & PROP_FONT)) glk_set_style(style_Preformatted); */ /* Workaround to decide if we have to open auxwin for positioned non-proportional text: */ if (!(f & PROP_FONT)) { /* If at top of screen, and changing to a fixed- width font (a situation which wouldn't normally be adjusted for by hugo_settextpos()) */ if (!inwindow && currentline == 1 && currentpos == 0 && using_prop_font) { just_cleared_screen = false; hugo_settextpos(1, 2); glk_window_move_cursor(currentwin, 0, 0); } } } void Hugo::hugo_settextcolor(int c) { // Set the foreground color to hugo_color(c) glk_fcolor = hugo_color(c); } void Hugo::hugo_setbackcolor(int c) { // Set the background color to hugo_color(c) glk_bgcolor = hugo_color(c); } int Hugo::hugo_color(int c) { if (c == 16) c = DEF_FCOLOR; else if (c == 17) c = DEF_BGCOLOR; else if (c == 18) c = DEF_SLFCOLOR; else if (c == 19) c = DEF_SLBGCOLOR; else if (c == 20) c = hugo_color(fcolor); /* match foreground */ /* Uncomment this block of code and change "c = ..." values if the system palette differs from the Hugo palette. If colors are unavailable on the system in question, it may suffice to have black, white, and brightwhite (i.e. boldface). It is expected that colored text will be visible on any other-colored background. switch (c) { case HUGO_BLACK: c = 0; break; case HUGO_BLUE: c = 1; break; case HUGO_GREEN: c = 2; break; case HUGO_CYAN: c = 3; break; case HUGO_RED: c = 4; break; case HUGO_MAGENTA: c = 5; break; case HUGO_BROWN: c = 6; break; case HUGO_WHITE: c = 7; break; case HUGO_DARK_GRAY: c = 8; break; case HUGO_LIGHT_BLUE: c = 9; break; case HUGO_LIGHT_GREEN: c = 10; break; case HUGO_LIGHT_CYAN: c = 11; break; case HUGO_LIGHT_RED: c = 12; break; case HUGO_LIGHT_MAGENTA: c = 13; break; case HUGO_YELLOW: c = 14; break; case HUGO_BRIGHT_WHITE: c = 15; break; */ return c; } int Hugo::hugo_charwidth(char a) const { if (a == FORCED_SPACE) return CHARWIDTH; /* same as ' ' */ else if ((unsigned char)a >= ' ') /* alphanumeric characters */ return CHARWIDTH; /* for non-proportional */ return 0; } int Hugo::hugo_textwidth(const char *a) const { int i, slen, len = 0; slen = (int)strlen(a); for (i = 0; i<slen; i++) { if (a[i] == COLOR_CHANGE) i += 2; else if (a[i] == FONT_CHANGE) i++; else len += hugo_charwidth(a[i]); } return len; } int Hugo::hugo_strlen(const char *a) const { int i, slen, len = 0; slen = (int)strlen(a); for (i = 0; i<slen; i++) { if (a[i] == COLOR_CHANGE) i += 2; else if (a[i] == FONT_CHANGE) i++; else len++; } return len; } /* * Replacements for things the Glk port doesn't support: * */ void Hugo::hugo_setgametitle(const char *t) {} int Hugo::hugo_hasvideo() const { return false; } int Hugo::hugo_playvideo(HUGO_FILE infile, long reslength, char loop_flag, char background, int volume) { delete infile; return true; } void Hugo::hugo_stopvideo(void) {} } // End of namespace Hugo } // End of namespace Glk