#charset "us-ascii"
/*
* TADS 3 Library - Menu System
*
* Copyright 2003 by Stephen Granade
*. Modifications copyright 2003, 2010 Michael J. Roberts
*
* This module is designed to make it easy to add on-screen menu trees to
* a game. Note that we're not using the term "menu" in its modern GUI
* sense of a compact, mouse-driven pop-up list. The style of menu we
* implement is more like the kind you'd find in old character-mode
* terminal programs, where a list of text items takes over the main
* window contents.
*
* Note that in plain-text mode (for interpreters without banner
* capabilities), a menu won't be fully usable if it exceeds nine
* subitems: each item in a menu is numbered, and the user selects an
* item by entering its number; but we only accept a single digit as
* input, so only items 1 through 9 can be selected on any given menu.
* In practice you probably wouldn't want to create larger menus anyway,
* for usability reasons, but this is something to keep in mind. If you
* need more items, you can group some of them into a submenu.
*
* The user interface for the menu system is implemented in menucon.t for
* traditional console interpreter, and in menuweb.t for the Web UI.
*
* Stephen Granade adapted this module from his TADS 2 menu system, and
* Mike Roberts made some minor cosmetic changes to integrate it with the
* main TADS 3 library.
*/
#include "adv3.h"
/*
* General instructions:
*
* Menus consist of MenuItems, MenuTopicItems, and MenuLongTopicItems.
*
* - MenuItems are the menu (and sub-menu) items that the player will
* select. Their "title" attribute is what will be shown in the menu,
* and the "heading" attribute is shown as the heading while the menu
* itself is active; by default, the heading simply uses the title.
*
* - MenuTopicItems are for lists of topic strings that the player will
* be shown, like hints. "title" is what will be shown in the menu;
* "menuContents" is a list of either strings to be displayed, one at a
* time, or objects which each must return a string via a "menuContents"
* method.
*
* - MenuLongTopicItems are for longer discourses. "title" is what will
* be shown in the menu; "menuContents" is either a string to be printed
* or a routine to be called.
*
* adv3.h contains templates for MenuItems, for your convenience.
*
* A simple example menu:
*
* FirstMenu: MenuItem 'Test menu';
*. + MenuItem 'Pets';
*. ++ MenuItem 'Chinchillas';
*. +++ MenuTopicItem 'About them'
*. menuContents = ['Furry', 'South American', 'Curious',
* 'Note: Not a coat'];
*. +++ MenuTopicItem 'Benefits'
*. menuContents = ['Non-allergenic', 'Cute', 'Require little space'];
*. +++ MenuTopicItem 'Downsides'
*. menuContents = ['Require dust baths', 'Startle easily'];
*. ++ MenuItem 'Cats';
*. +++ MenuLongTopicItem 'Pure evil'
*. menuContents = 'Cats are, quite simply, pure evil. I would provide
*. ample evidence were there room for it in this
*. simple example.';
*. +++ MenuTopicItem 'Benefits'
*. menuContents = ['They, uh, well...', 'Okay, I can\'t think of any.'];
*/
/* ------------------------------------------------------------------------ */
/*
* Menu output stream. We run topic contents through this output stream
* to allow topics to use the special paragraph and style tag markups.
*/
transient menuOutputStream: OutputStream
/*
* Process a function call through the stream. If the function
* generates any output, we capture it. If the function simply
* returns text, we run it through the filters.
*/
captureOutput(val)
{
/* reset our buffer */
buf_.deleteChars(1);
/* call the function while capturing its output */
outputManager.withOutputStream(menuOutputStream, function()
{
/* if it's a function, invoke it */
if (dataType(val) != TypeSString)
val = val();
/* if we have a string, run it through my filters */
if (dataType(val) == TypeSString)
writeToStream(val);
});
/* return my captured output */
return toString(buf_);
}
/* we capture our output to a string buffer */
writeFromStream(txt) { buf_.append(txt); }
/* initialize */
execute()
{
inherited();
buf_ = new StringBuffer();
addOutputFilter(typographicalOutputFilter);
addOutputFilter(menuParagraphManager);
addOutputFilter(styleTagFilter);
}
/* our capture buffer (a StringBuffer object) */
buf_ = nil
;
/*
* Paragraph manager for the menu output stream.
*/
transient menuParagraphManager: ParagraphManager
;
/* ------------------------------------------------------------------------ */
/*
* A basic menu object. This is an abstract base class that
* encapsulates some behavior common to different menu classes, and
* allows the use of the + syntax (like "+ MenuItem") to define
* containment.
*/
class MenuObject: object
/* our contents list */
contents = []
/*
* Since we're inheriting from object, but need to use the "+"
* syntax, we need to set up the contents appropriately
*/
initializeLocation()
{
if (location != nil)
location.addToContents(self);
}
/* add a menu item */
addToContents(obj)
{
/*
* If the menu has a nil menuOrder, and it inherits menuOrder
* from us, then it must be a dynamically-created object that
* doesn't provide a custom menuOrder. Provide a suitable
* default of a value one higher than the highest menuOrder
* currently in our list, to ensure that the item always sorts
* after any items currently in the list.
*/
if (obj.menuOrder == nil && !overrides(obj, MenuObject, &menuOrder))
{
local maxVal;
/* find the maximum current menuOrder value */
maxVal = nil;
foreach (local cur in contents)
{
/*
* if this one has a value, and it's the highest so far
* (or the only one with a value we've found so far),
* take it as the maximum so far
*/
if (cur.menuOrder != nil
&& (maxVal == nil || cur.menuOrder > maxVal))
maxVal = cur.menuOrder;
}
/* if we didn't find any values, use 0 as the arbitrary default */
if (maxVal == nil)
maxVal = 0;
/* go one higher than the maximum of the existing items */
obj.menuOrder = maxVal;
}
/* add the item to our contents list */
contents += obj;
}
/*
* The menu order. When we're about to show a list of menu items,
* we'll sort the list in ascending order of this property, then in
* ascending order of title. By default, we set this order value to
* be equal to the menu item's sourceTextOrder. This makes the menu
* order default to the order of objects as defined in the source. If
* some other basis is desired, override topicOrder.
*/
menuOrder = (sourceTextOrder)
/*
* Compare this menu object to another, for the purposes of sorting a
* list of menu items. Returns a positive number if this menu item
* sorts after the other one, a negative number if this menu item
* sorts before the other one, 0 if the relative order is arbitrary.
*
* By default, we'll sort by menuOrder if the menuOrder values are
* different, otherwise arbitrarily.
*/
compareForMenuSort(other)
{
/*
* if one menuOrder value is nil, sort it earlier than the other;
* if they're both nil, they sort as equivalent
*/
if (menuOrder == nil && other.menuOrder == nil)
return 0;
else if (menuOrder == nil)
return -1;
else if (other.menuOrder == nil)
return 1;
/* return the difference of the sort order values */
return menuOrder - other.menuOrder;
}
/*
* Finish initializing our contents list. This will be called on
* each MenuObject *after* we've called initializeLocation() on every
* object. In other words, every menu will already have been added
* to its parent's contents; this can do anything else that's needed
* to initialize the contents list. For example, some subclasses
* might want to sort their contents here, so that they list their
* menus in a defined order. By default, we sort the menu items by
* menuOrder; subclasses can override this as needed.
*/
initializeContents()
{
/* sort our contents list in the object-defined sorting order */
contents = contents.sort(
SortAsc, {a, b: a.compareForMenuSort(b)});
}
;
/*
* This preinit object makes sure the MenuObjects all have their
* contents initialized properly.
*/
PreinitObject
execute()
{
/* initialize each menu's location */
forEachInstance(MenuObject, { menu: menu.initializeLocation() });
/* do any extra work to initialize each menu's contents list */
forEachInstance(MenuObject, { menu: menu.initializeContents() });
}
;
/* ------------------------------------------------------------------------ */
/*
* A MenuItem is a given item in the menu tree. In general all you need
* to do to use menus is create a tree of MenuItems with titles.
*
* To display a menu tree, call displayMenu() on the top menu in the
* tree. That routine displays the menu and processes user input until
* the user dismisses the menu, automatically displaying submenus as
* necessary.
*/
class MenuItem: MenuObject
/* the name of the menu; this is listed in the parent menu */
title = ''
/*
* the heading - this is shown when this menu is active; by default,
* we simply use the title
*/
heading = (title)
/*
* Display properties. These properties control the way the menu
* appears on the screen. By default, a menu looks to its parent
* menu for display properties; this makes it easy to customize an
* entire menu tree, since changes in the top-level menu will cascade
* to all children that don't override these settings. However, each
* menu can customize its own appearance by overriding these
* properties itself.
*
* 'fgcolor' and 'bgcolor' are the foreground (text) and background
* colors, expressed as HTML color names (so '#nnnnnn' values can be
* used to specify RGB colors).
*
* 'indent' is the number of pixels to indent the menu's contents
* from the left margin. This is used only in HTML mode.
*
* 'fullScreenMode' indicates whether the menu should take over the
* entire screen, or limit itself to the space it actually requires.
* Full screen mode makes the menu block out any game window text.
* Limited mode leaves the game window partially uncovered, but can
* be a bit jumpy, since the window changes size as the user
* navigates through different menus.
*/
/* foreground (text) and background colors, as HTML color names */
fgcolor = (location != nil ? location.fgcolor : 'text')
bgcolor = (location != nil ? location.bgcolor : 'bgcolor')
/*
* Foreground and background colors for the top instructions bar.
* By default, we use the color scheme of the parent menu, or the
* inverse of our main menu color scheme if we're the top menu.
*/
topbarfg = (location != nil ? location.topbarfg : 'statustext')
topbarbg = (location != nil ? location.topbarbg : 'statusbg')
/* number of spaces to indent the menu's contents */
indent = (location != nil ? location.indent : '10')
/*
* full-screen mode: make our menu take up the whole screen (apart
* from the instructions bar, of course)
*/
fullScreenMode = (location != nil ? location.fullScreenMode : true)
/*
* The keys used to navigate the menus, in order:
*
* [quit, previous, up, down, select]
*
* Since multiple keys can be used for the same navigation, the list
* is implemented as a List of Lists. Keys must be given as
* lower-case in order to match input, since we convert all input
* keys to lower-case before matching them.
*
* In the sublist for each key, we use the first element as the key
* name we show in the instruction bar at the top of the screen.
*
* By default, we use our parent menu's key list, if we have a
* parent; if we have no parent, we use the standard keys from the
* library messages.
*/
keyList = (location != nil ? location.keyList : gLibMessages.menuKeyList)
/*
* the current key list - we'll set this on entry to the start of
* each showMenuXxx method, so that we keep track of the actual key
* list in use, as inherited from the top-level menu
*/
curKeyList = nil
/*
* Title for the link to the previous menu, if any. If the menu has
* a parent menu, we'll display this link next to the menu title in
* the top instructions/title bar. If this is nil, we won't display
* a link at all. Note that this can contain an HTML fragment; for
* example, you could use an <IMG> tag to display an icon here.
*/
prevMenuLink = (location != nil ? gLibMessages.prevMenuLink : nil)
/*
* Update our contents. By default, we'll do nothing; subclasses
* can override this to manage dynamic menus if desired. This is
* called just before the menu is displayed, each time it's
* displayed.
*/
updateContents() { }
/*
* Get the next menu in our list following the given menu. Returns
* nil if we don't find the given menu, or the given menu is the last
* menu.
*/
getNextMenu(menu)
{
/* find the menu in our contents list */
local idx = contents.indexOf(menu);
/*
* if we found it, and it's not the last, return the menu at the
* next index; otherwise return nil
*/
return (idx != nil && idx < contents.length()
? contents[idx + 1] : nil);
}
/*
* Get the menu previous tot he given menu. Returns nil if we don't
* find the given menu or the given menu is the first one.
*/
getPrevMenu(menu)
{
/* find the menu in our contents list */
local idx = contents.indexOf(menu);
/*
* if we found it, and it's not the first, return the menu at the
* prior index; otherwise return nil
*/
return (idx != nil && idx > 1 ? contents[idx - 1] : nil);
}
/* get the index in the parent of the given child menu */
getChildIndex(child)
{
return contents.indexOf(child);
}
;
/* ------------------------------------------------------------------------ */
/*
* MenuTopicItem displays a series of entries successively. This is
* intended to be used for displaying something like a list of hints for
* a topic. Set menuContents to be a list of strings to be displayed.
*/
class MenuTopicItem: MenuItem
/* the name of this topic, as it appears in our parent menu */
title = ''
/* heading, displayed while we're showing this topic list */
heading = (title)
/* hyperlink text for showing the next menu */
nextMenuTopicLink = (gLibMessages.nextMenuTopicLink)
/*
* A list of strings and/or MenuTopicSubItem items. Each one of
* these is meant to be something like a single hint on our topic.
* We display these items one at a time when our menu item is
* selected.
*/
menuContents = []
/* the index of the last item we displayed from our menuContents list */
lastDisplayed = 1
/*
* The maximum number of our sub-items that we'll display at once.
* This is only used on interpreters with banner capabilities, and is
* ignored in full-screen mode.
*/
chunkSize = 6
/* we'll display this after we've shown all of our items */
menuTopicListEnd = (gLibMessages.menuTopicListEnd)
;
/* ------------------------------------------------------------------------ */
/*
* A menu topic sub-item can be used to represent an item in a
* MenuTopicItem's list of display items. This can be useful when
* displaying a topic must trigger a side-effect.
*/
class MenuTopicSubItem: object
/*
* Get the item's text. By default, we just return an empty string.
* This should be overridden to return the appropriate text, and can
* also trigger any desired side-effects.
*/
getItemText() { return ''; }
;
/* ------------------------------------------------------------------------ */
/*
* Long Topic Items are used to print out big long gobs of text on a
* subject. Use it for printing long treatises on your design
* philosophy and the like.
*/
class MenuLongTopicItem: MenuItem
/* the title of the menu, shown in parent menus */
title = ''
/* the heading, shown while we're displaying our contents */
heading = (title)
/* either a string to be displayed, or a method returning a string */
menuContents = ''
/*
* Flag - this is a "chapter" in a list of chapters. If this is set
* to true, then we'll offer the options to proceed directly to the
* next and previous chapters. If this is nil, we'll simply wait for
* acknowledgment and return to the parent menu.
*/
isChapterMenu = nil
/* the message we display at the end of our text */
menuLongTopicEnd = (gLibMessages.menuLongTopicEnd)
;
TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3