#charset "us-ascii"
#pragma once
/*
* Copyright (c) 1999, 2006 Michael J. Roberts
*
* This file is part of TADS 3
*
* This header defines the tads-io intrinsic function set.
*
* The TADS input/output function set provides access to the user
* interface. This lets you read input from the keyboard and display
* output on the monitor or terminal. It also provides access to windowing
* features (via the "banner" functions) on systems that support multiple
* display windows (which doesn't necessarily mean GUI-type systems: many
* character-mode systems support the banner operations as well, simply by
* dividing up the character-mode screen into rectangular regions).
*/
/*
* tads-io - the TADS Input/Output intrinsic function set
*/
intrinsic 'tads-io/030007'
{
/*
* Display values on the console. One or more values can be displayed.
* Each value can be a string, in which case the string is displayed as
* given (with HTML interpretation); an integer, in which case it's
* converted to a string, using a decimal (base 10) radix and
* displayed; a BigNumber, in which case it's converted to a string
* using the default formatting; or nil, in which case nothing is
* displayed.
*/
tadsSay(val, ...);
/*
* Set the output log file (which records the output transcript) or the
* command log file (which records command lines the user enters).
* 'fname' is the name of the file to open, and 'logType' gives the
* type of log to open, as a LogTypeXxx value.
*/
setLogFile(fname, logType?);
/*
* Clear the display. This clears the main window.
*/
clearScreen();
/*
* Show the "more" prompt, if supported on the platform. This causes a
* "more" prompt to be displayed, according to local system
* conventions, as though consecutive text output had exceeded the
* screen/window height.
*/
morePrompt();
/*
* Read a line of text from the keyboard. Pauses to let the user edit
* and enter a command line, then returns the entered text as a string.
*/
inputLine();
/*
* Read a single keystroke from the keyboard. Waits until the user
* presses a key, then returns the keystroke as a string.
*/
inputKey();
/*
* Read a single input event. Waits until an input event is available,
* then returns the event as a list. The first element of the list is
* an InEvtXxx value indicating the type of the event; the remainder of
* the list varies according to the event type. If 'timeout' is
* provided, it gives the maximum waiting interval in milliseconds; if
* no input event occurs within this interval, the function returns an
* InEvtTimeout event.
*/
inputEvent(timeout?);
/*
* Display a simple "message box" dialog (known on some systems as an
* "alert" dialog). This displays a dialog that includes a short
* message for the user to read, an icon indicating the general nature
* of the condition that gave rise to the dialog (an error, a warning,
* a choice for the user to make, etc.), and a set of push-buttons that
* dismiss the dialog and (in some cases) let the user choose among
* options. 'icon' is an InDlgIconXxx value giving the type of icon to
* show, if any; 'prompt' is the message string to display; 'buttons'
* gives the set of buttons to display; 'defaultButton' is the index
* (starting at 1) among the buttons of the default button; and
* 'cancelButton' is the index of the cancellation button.
*
* 'buttons' can be given as an InDlgXxx constant (InDlgOk,
* InDlgOkCancel, etc.) to select one of the standard sets of buttons.
* Or, it can be a list giving a custom set of buttons, in which case
* each element of the list is either a string giving a custom label
* for the button, or one of the InDlgLblXxx values to select a
* standard label. The standard labels should be used when possible,
* as these will be automatically localized; labels given explicitly as
* strings will be used exactly as given. If a list of custom button
* labels is given, the buttons are displayed in the dialog in the
* order of the list (usually left to right, but this could vary
* according to system conventions and localization).
*
* Each custom button label string can incorporate an ampersand ("&").
* The letter immediately following the ampersand, if provided, is used
* as the keyboard shortcut for the button. This is particularly
* important on character-mode systems, where the "dialog" is typically
* shown merely as a text prompt, and the user responds by selecting
* the letter of the desired option. Typically, you should use the
* first character of a button label as its keyboard shortcut, but this
* obviously won't work when two button labels have the same first
* letter; in these cases, you should choose another letter from the
* button label, preferably something like the first letter of the
* second word of the button label, or the first letter of the stressed
* syllable of the most important word of the label.
*
* The return value is the index among the buttons of the button that
* the user selects to dismiss the dialog. The function doesn't return
* until the user selects one of the buttons.
*/
inputDialog(icon, prompt, buttons, defaultButton, cancelButton);
/*
* Display a file selector dialog. This prompts the user to select a
* file. On GUI systems, this will typically display the standard
* system file selection dialog; on character-mode systems, it might
* simply display the prompt string and let the user type the name of a
* file directly.
*
* 'prompt' is the message string to display in the dialog to let the
* user know what type of file is being requested. 'dialogType' is one
* of the InFileXxx constants specifying whether the request is to
* select an existing file or to specify the name for a new file.
* 'fileType' is a FileTypeXxx constant giving the format of the file
* being requested; this is used on some systems to filter the
* displayed list of existing files so that only files of the same
* format are included, to reduce clutter. 'flags' is reserved for
* future use and should simply be set to zero.
*
* The return value is a list. The first element is an integer giving
* the status: InFileSuccess indicates that the user successfully
* selected a file, whose name is given as a string in the second
* element of the result list; InFileFailure indicates a system error
* of some kind showing the dialog; and InFileCancel indicates that the
* user explicitly canceled the dialog.
*
* On success (return list[1] == InFileSuccess), the list contains the
* following additional elements:
*
*. [2] = the selected filename
*. [3] = nil (reserved for future use)
*. [4] = script warning message, or nil if no warning
*
* The warning message is a string to be displayed to the user to warn
* about a possible error condition in the script input. The script
* reader checks the file specified in the script to see if it's valid;
* if the dialog type is Open, the script reader verifies that the file
* exists, and for a Save dialog the reader warns if the file *does*
* already exist or is not writable. In the conventional UI, the
* script reader displays these warnings directly to the user through
* the console UI, but this isn't possible in the Web UI since the user
* might be running on a remote browser. Instead, the script reader
* still checks for the possible errors, but rather than displaying any
* warnings, it returns them here. The caller is responsible for
* displaying the warning and asking the user for confirmation.
*
* For localization purposes, the warning message starts with a
* two-letter code indicating the specific error, followed by a space,
* followed by the English text of the warning. The codes are:
*
*. OV - the script might overwrite an existing file (Save dialog)
*. WR - the file can't be created/written (Save dialog)
*. RD - the file doesn't exist/can't be read (Open dialog)
*
* Note that the warning message will always be nil if the script
* reader displayed the warning message itself. This means that your
* program can unconditionally display this message if it's non-nil -
* there's no danger that the script reader will have redundantly
* displayed the message.
*/
inputFile(prompt, dialogType, fileType, flags);
/*
* Pause for the given number of milliseconds.
*/
timeDelay(delayMilliseconds);
/*
* Retrieve local system information. 'infoType' is a SysInfoXxx
* constant giving the type of information to retrieve. Additional
* arguments and the return value vary according to the infoType value.
*/
systemInfo(infoType, ...);
/*
* Set the status-line display mode. This is meaningful only with
* text-only interpreters that don't support banner windows; other
* interpreters ignore this. 'mode' is a StatModeXxx constant giving
* the new mode.
*/
statusMode(mode);
/*
* Write text on the right half of the status line. This is meaningful
* only for text-only interpreters that don't support banner windows;
* other interpreters ignore this. On non-banner interpreters, this
* sets the right half of the status line to display the given text,
* right-justified.
*/
statusRight(txt);
/*
* Determine if a multimedia resource exists. 'fname' is the name of a
* resource (a JPEG image file, PNG image file, etc), given in
* URL-style path notation. Returns true if the resource is available,
* nil if not.
*/
resExists(fname);
/*
* Set the script input file. This opens the given file as the script
* input file. 'filename' is a string giving the name of the file to
* open, and 'flags' is a combination of ScriptFileXxx bit flags giving
* the mode to use to read the file. When a script file is active, the
* system reads command-line input from the file rather than from the
* keyboard. This lets the program replay an input script.
*
* Note that the ScriptFileEvent flag is ignored if included in the
* 'flags' parameter. The script reader automatically determines the
* script type by examining the file's contents, so you can't set the
* type using flags. This flag is used only in "get status" requests
* (ScriptReqGetStatus) - it's included in the returned flags if
* applicable. The purpose of this flag is to let you determine what
* the script reader decided about the script, rather than telling the
* script reader how to interpret the script.
*
* If 'filename' is nil, this cancels the current script. If the
* script was invoked from an enclosing script, this resumes the
* enclosing script, otherwise it resumes reading input from the
* keyboard. The 'flags' argument is ignored in this case.
*
* New in 3.0.17: if 'filename' is one of the ScriptReqXxx constants,
* this performs a special script request. See the ScriptReqXxx
* constants for details. Note that calling this function with a
* ScriptReqXxx constant on an VM prior to 3.0.17 will result in a
* run-time error, so you can use try-catch to detect whether the
* request is supported.
*/
setScriptFile(filename, flags?);
/*
* Get the local default character set. 'which' is a CharsetXxx value
* giving which local character set to retrieve. Returns a string
* giving the name of the given local character set.
*/
getLocalCharSet(which);
/*
* Flush text output and update the main display window. This ensures
* that any text displayed with tadsSay() is actually displayed, for
* the user to see (rather than being held in internal buffers).
*/
flushOutput();
/*
* Read a line of text from the keyboard. Waits for the user to edit
* and enter a command line. If a 'timeout' value is specified, it
* gives the maximum interval to wait for the user to finish entering
* the input, in milliseconds. If the timeout expires before the user
* finishes entering the line, the function stops waiting and returns.
*
* The return value is a list. The first element is an InEvtXxx code
* giving the status. If the status is InEvtLine, the second element
* is a string giving the command line the user entered. If the status
* is InEvtTimeout, the second element is a string giving the text of
* the command line so far - that is, the text that the user had typed
* up to the point when the timeout expired. Other status codes have
* no additional list elements.
*
* When an InEvtTimeout status is returned, the caller must either
* cancel the interrupted input line with inputLineCancel(), or must
* make another call to inputLineTimeout() without any intervening call
* to any output function that displays anything in the main window, or
* any input function other than inputLineTimeout().
*/
inputLineTimeout(timeout?);
/*
* Cancel an input line that was interrupted by timeout. This function
* must be called after an inputLineTimeout() returns with an
* InEvtTimeout status indication and before any subsequent output
* function that displays anything in the main window, or any input
* fucntion other than inputLineTimeout().
*
* This function updates the UI to reflect that command line editing is
* no longer in progress. If 'reset' is true, it also resets the
* internal memory of the command editing session, so that a subsequent
* call to inputLineTimeout() will start from scratch with an empty
* command line. If 'reset' is nil, this function merely adjusts the
* UI, but does not clear the internal memory; the next call to
* inputLineTimeout() will automatically restore the editing status,
* re-displaying what the user had typed so far on the interrupted
* command line and restoring the cursor position to its position when
* the timeout occurred.
*
* Note that it's not necessary (or desirable) to call this function
* after a timed-out input line if the next input/output function that
* affects the main window is simply another call to
* inputLineTimeout(). In this case, inputLineTimeout() simply picks
* up where it left off, without any indication to the user that the
* input editing was ever interrupted.
*/
inputLineCancel(reset);
/*
* Create a banner window. Returns the "handle" of the new window,
* which is used to identify the window in subsequent bannerXxx()
* functions. Not all interpreters support banner windows; if the
* interpreter does not support this feature, the return value is nil.
*
* 'parent' is the handle of the parent window; if this is nil, the
* banner is split off from the main display window. 'where' is a
* BannerXxx value giving the list position; if this is BannerBefore or
* BannerAfter, 'other' is the handle of an existing banner window
* child of the same parent. 'windowType' is a BannerTypeXxx value
* giving the type of window to create. 'align' is a BannerAlignXxx
* value giving the alignment - that is, the edge of the parent window
* to which the new banner window attaches. 'size' is the size of the
* window, in the units given by 'sizeUnits', which is a BannerSizeXxx
* value. 'styleFlags' is a combination of BannerStyleXxx bit flags
* that specifies the desired combination of visual styles and UI
* behavior for the new window.
*/
bannerCreate(parent, where, other, windowType, align,
size, sizeUnits, styleFlags);
/*
* Delete a banner window. 'handle' is the handle to the window to be
* removed.
*/
bannerDelete(handle);
/*
* Clear the contents of a banner window. 'color' is the color to use
* for the screen color after clearing the window, given as a ColorXxx
* value (see below).
*/
bannerClear(handle);
/*
* Write text to a banner window. The text is displayed in the given
* banner. For a BannerTypeText window, HTML tags in the text are
* interpreted; for a BannerTypeTextGrid window, the text is written
* exactly as given, without any HTML interpretation.
*
* The value list is handled the same way as the arguments to tadsSay()
* in terms of type conversions.
*/
bannerSay(handle, ...);
/*
* Flush all buffers for a banner window. This ensures that any text
* written with bannerSay() is actually displayed for the user to see
* (rather than being held in internal buffers).
*/
bannerFlush(handle);
/*
* Size a banner to fit its contents. This resizes the banner such
* that the contents just fit. In the case of a top- or bottom-aligned
* banner, the height is set just high enough to hold all of the text
* currently displayed. In the case of a left- or right-aligned
* banner, the width is set just wide enough to hold the widest single
* word that can't be broken across lines. In all cases, the size
* includes any fixed margin space, to ensure that all of the text in
* the window is actually visible without scrolling.
*
* Note that not all systems support this function. On systems where
* the function is not supported, this call has no effect. Because of
* this, you should always use this function in conjunction with an
* "advisory" call to bannerSetSize().
*/
bannerSizeToContents(handle);
/*
* Go to to an output position. This is meaningful only for
* BannerTypeTextGrid windows. This sets the next text output position
* to the given row and column in the text grid; the next call to
* bannerSay() will display its output starting at this position.
*/
bannerGoTo(handle, row, col);
/*
* Set text foreground and background colors. This affects the color
* of subsequently displayed text; text displayed previously is not
* affected. The colors are given as ColorXxx values (see below). If
* 'bg' is ColorTransparent, then text is shown with the current screen
* color in the window.
*/
bannerSetTextColor(handle, fg, bg);
/*
* Set the "screen color" in the banner window. This is the color used
* to fill parts of the window that aren't displaying any text, and as
* the background color for all text displayed when the text background
* color is ColorTransparent. Setting the screen color immediately
* sets the color for the entire window - even text previously
* displayed in the window is affected by this change.
*/
bannerSetScreenColor(handle, color);
/*
* Get information on the banner. This returns a list giving a
* detailed set of information describing the banner.
*/
bannerGetInfo(handle);
/*
* Set the size of a banner. This explicitly sets the banner's height
* (for a top or bottom banner) or width (for a left or right) banner
* to the 'size', which is specified in units given by 'sizeUnits',
* which is a BannerSizeXxx constant. If 'isAdvisory' is true, the
* caller is indicating that this call will be followed soon by a call
* to bannerSizeToContents(). On systems that support sizing to
* contents, an "advisory" call to bannerSetSize() will simply be
* ignored in anticipation of the upcoming call to
* bannerSizeToContents(). On systems that don't support sizing to
* contents, an advisory call will actually resize the window.
*/
bannerSetSize(handle, size, sizeUnits, isAdvisory);
/*
* Create a log file console. This creates a console that has no
* display, but simply captures its output to the given log file.
* Writing to a log console is different from writing to a regular text
* file in that we apply all of the normal formatting (including
* text-only-mode HTML interpretation) to the output sent to this
* console.
*/
logConsoleCreate(filename, charset, width);
/*
* Close a log console. This closes the file associated with the log
* console and deletes the console object. The given console handle is
* no longer valid after this function is called.
*/
logConsoleClose(handle);
/*
* Write text to a log console. This works the same as tadsSay(), but
* writes the output to the given log console rather than to the main
* output window.
*/
logConsoleSay(handle, ...);
/*
* Log an input event that's obtained externally - i.e., from a source
* other than the system input APIs (inputLine, inputKey, inputEvent,
* etc). This adds the event to any command or event log that the
* system is currently writing, as set with setLogFile().
*
* It's only necessary to call this function when obtaining user input
* from custom code that bypasses the system input APIs. The system
* input functions all log events automatically, so you must not call
* this for input obtained from them (doing so would write each input
* twice, since it's already being written once by the input
* functions). For example, this is useful for the Web UI, since it
* obtains input via network transactions with the javascript client.
*
* 'evt' is a list describing the event, using the same format that
* inputEvent() returns. Note one special extension: if the first
* element of the list is a string, the string is used as the tag name
* if we're writing an event script. This can be used to write custom
* events or events with no InEvtXxx type code, such as <dialog> input
* events.
*/
logInputEvent(evt);
}
/* log file types */
#define LogTypeTranscript 1 /* log all input and output to a transcript */
#define LogTypeCommand 2 /* log only command-line input */
#define LogTypeScript 3 /* log all input events */
/*
* The special log console handle for the main console window's transcript.
* This can be used as the handle in logConsoleSay(), to write text
* directly to the main console's log file, if any. Note that this console
* cannot be closed via logConsoleClose(); use setLogFile(nil) instead.
*/
#define MainWindowLogHandle (-1)
/*
* constants for the event codes returned by the inputEvent() and
* inputLineTimeout() intrinsic functions
*/
#define InEvtKey 1
#define InEvtTimeout 2
#define InEvtHref 3
#define InEvtNoTimeout 4
#define InEvtNotimeout 4 /* (note minor capitalization variation) */
#define InEvtEof 5
#define InEvtLine 6
#define InEvtSysCommand 0x100
#define InEvtEndQuietScript 10000
#define InEvtEndScript 10003
/*
* Command codes for InEvtSysCommand
*/
#define SaveCommand 0x0001 /* SAVE the current position */
#define RestoreCommand 0x0002 /* RESTORE a saved position */
#define UndoCommand 0x0003 /* UNDO one turn */
#define QuitCommand 0x0004 /* QUIT the game */
#define CloseCommand 0x0005 /* close the game window */
#define HelpCommand 0x0006 /* show game HELP */
/*
* constants for inputDialog()
*/
#define InDlgOk 1
#define InDlgOkCancel 2
#define InDlgYesNo 3
#define InDlgYesNoCancel 4
#define InDlgIconNone 0
#define InDlgIconWarning 1
#define InDlgIconInfo 2
#define InDlgIconQuestion 3
#define InDlgIconError 4
#define InDlgLblOk 1
#define InDlgLblCancel 2
#define InDlgLblYes 3
#define InDlgLblNo 4
/*
* inputFile() dialog types
*/
#define InFileOpen 1 /* open an existing file for reading */
#define InFileSave 2 /* save to the file */
/*
* inputFile() return codes - these are returned in the first element of
* the list returned from inputFile()
*/
#define InFileSuccess 0 /* success - 2nd list element is filename */
#define InFileFailure 1 /* an error occurred asking for a file */
#define InFileCancel 2 /* player canceled the file selector */
/*
* constants for inputFile() file type codes
*/
#define FileTypeLog 2 /* a transcript (log) file */
#define FileTypeData 4 /* arbitrary data file */
#define FileTypeCmd 5 /* command input file */
#define FileTypeText 7 /* text file */
#define FileTypeBin 8 /* binary data file */
#define FileTypeUnknown 11 /* unknown file type */
#define FileTypeT3Image 12 /* T3 executable image (game) file */
#define FileTypeT3Save 15 /* T3 saved state file */
/*
* constants for systemInfo information type codes
*/
#define SysInfoVersion 2
#define SysInfoOsName 3
#define SysInfoJpeg 5
#define SysInfoPng 6
#define SysInfoWav 7
#define SysInfoMidi 8
#define SysInfoWavMidiOvl 9
#define SysInfoWavOvl 10
#define SysInfoPrefImages 11
#define SysInfoPrefSounds 12
#define SysInfoPrefMusic 13
#define SysInfoPrefLinks 14
#define SysInfoMpeg 15
#define SysInfoMpeg1 16
#define SysInfoMpeg2 17
#define SysInfoMpeg3 18
#define SysInfoLinksHttp 20
#define SysInfoLinksFtp 21
#define SysInfoLinksNews 22
#define SysInfoLinksMailto 23
#define SysInfoLinksTelnet 24
#define SysInfoPngTrans 25
#define SysInfoPngAlpha 26
#define SysInfoOgg 27
#define SysInfoMng 28
#define SysInfoMngTrans 29
#define SysInfoMngAlpha 30
#define SysInfoTextHilite 31
#define SysInfoTextColors 32
#define SysInfoBanners 33
#define SysInfoInterpClass 34
#define SysInfoAudioFade 35
#define SysInfoAudioCrossfade 36
/* SysInfoTextColors support level codes */
#define SysInfoTxcNone 0
#define SysInfoTxcParam 1
#define SysInfoTxcAnsiFg 2
#define SysInfoTxcAnsiFgBg 3
#define SysInfoTxcRGB 4
/* SysInfoInterpClass codes */
#define SysInfoIClassText 1
#define SysInfoIClassTextGUI 2
#define SysInfoIClassHTML 3
/* SysInfoAudioFade and SysInfoAudioCrossfade result codes */
#define SysInfoFadeMPEG 0x0001
#define SysInfoFadeOGG 0x0002
#define SysInfoFadeWAV 0x0004
#define SysInfoFadeMIDI 0x0008
/*
* constants for statusMode
*/
#define StatModeNormal 0 /* displaying normal text */
#define StatModeStatus 1 /* display status line text */
/*
* flags for setScriptFile
*/
#define ScriptFileQuiet 1 /* do not display output while reading script */
#define ScriptFileNonstop 2 /* turn off MORE prompt while reading script */
#define ScriptFileEvent 4 /* this is an event script (query only) */
/*
* Script Request - get current script status. In 3.0.17+, passing this
* constant as the 'filename' argument to getScriptFile() will perform a
* "get script status" request. If there's no script file in progress, the
* function returns nil. If a script file is being read, the function
* returns an integer value giving a combination of ScriptFileXxx flag
* values indicating the current script status. Note that a return value
* of 0 (zero) means that a script is running but none of the ScriptFileXxx
* flags are applicable.
*/
#define ScriptReqGetStatus 0x7000
/*
* selectors for getLocalCharSet
*/
#define CharsetDisplay 1 /* the display/keyboard character set */
#define CharsetFileName 2 /* the file system character set */
#define CharsetFileCont 3 /* default file contents character set */
/*
* banner insertion point specifies (for 'where' in bannerCreate)
*/
#define BannerFirst 1
#define BannerLast 2
#define BannerBefore 3
#define BannerAfter 4
/*
* banner types
*/
#define BannerTypeText 1 /* ordinary text stream window */
#define BannerTypeTextGrid 2 /* text grid window */
/*
* banner alignment types
*/
#define BannerAlignTop 0
#define BannerAlignBottom 1
#define BannerAlignLeft 2
#define BannerAlignRight 3
/*
* banner size unit types
*/
#define BannerSizePercent 1 /* size is a percentage of available space */
#define BannerSizeAbsolute 2 /* size is in natural units of window type */
/*
* banner style flags
*/
#define BannerStyleBorder 0x0001 /* banner has a visible border */
#define BannerStyleVScroll 0x0002 /* vertical scrollbar */
#define BannerStyleHScroll 0x0004 /* horizontal scrollbar */
#define BannerStyleAutoVScroll 0x0008 /* automatic vertical scrolling */
#define BannerStyleAutoHScroll 0x0010 /* automatic horizontal scrolling */
#define BannerStyleTabAlign 0x0020 /* <TAB> alignment support */
#define BannerStyleMoreMode 0x0040 /* use MORE mode */
#define BannerStyleHStrut 0x0080 /* include in parent's auto width */
#define BannerStyleVStrut 0x0100 /* include in parent's auto height */
/*
* Color codes. A color can be specified with explicit RGB
* (red-green-blue) component values, or can be "parameterized," which
* means that the color uses a pre-defined color for a particular purpose.
*
* RGB colors are specified with each component given in the range 0 to
* 255; the color (0,0,0) is pure black, and (255,255,255) is pure white.
*
* The special value "transparent" is not a color at all, but rather
* specifies that the current screen color should be used.
*
* The "Text" and "TextBg" colors are the current default text and text
* background colors. The actual colors displayed for these values depend
* on the system, and on some systems these colors might be configurable by
* the user through a preferences selection. These are the same colors
* selected by the HTML parameterized color names 'text' and 'bgcolor'.
*
* The "StatusText" and "StatusBg" colors are the current default
* statusline text and background colors, which depend on the system and
* may be user-configurable on some systems. These are the same colors
* selected by the HTML parameterized color names 'statustext' and
* 'statusbg'.
*
* The "input" color is the current default input text color.
*/
#define ColorRGB(r, g, b) \
((((r) & 0xff) << 16) + (((g) & 0xff) << 8) + ((b) & 0xff))
#define ColorTransparent 0x01000000
#define ColorText 0x02000000
#define ColorTextBg 0x03000000
#define ColorStatusText 0x04000000
#define ColorStatusBg 0x05000000
#define ColorInput 0x06000000
/* some specific colors by name, for convenience */
#define ColorBlack ColorRGB(0x00, 0x00, 0x00)
#define ColorWhite ColorRGB(0xff, 0xff, 0xff)
#define ColorRed ColorRGB(0xff, 0x00, 0x00)
#define ColorBlue ColorRGB(0x00, 0x00, 0xFF)
#define ColorGreen ColorRGB(0x00, 0x80, 0x00)
#define ColorYellow ColorRGB(0xFF, 0xFF, 0x00)
#define ColorCyan ColorRGB(0x00, 0xFF, 0xFF)
#define ColorAqua ColorRGB(0x00, 0xFF, 0xFF)
#define ColorMagenta ColorRGB(0xFF, 0x00, 0xFF)
#define ColorSilver ColorRGB(0xC0, 0xC0, 0xC0)
#define ColorGray ColorRGB(0x80, 0x80, 0x80)
#define ColorMaroon ColorRGB(0x80, 0x00, 0x00)
#define ColorPurple ColorRGB(0x80, 0x00, 0x80)
#define ColorFuchsia ColorRGB(0xFF, 0x00, 0xFF)
#define ColorLime ColorRGB(0x00, 0xFF, 0x00)
#define ColorOlive ColorRGB(0x80, 0x80, 0x00)
#define ColorNavy ColorRGB(0x00, 0x00, 0x80)
#define ColorTeal ColorRGB(0x00, 0x80, 0x80)
TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3