Subversion Repositories openrisc

PDCurses Implementor's Guide

============================

Version 1.3 - 200?/??/?? - notes about official ports

Version 1.2 - 2007/07/11 - added PDC_init_pair(), PDC_pair_content(),

                           version history; removed pdc_atrtab

Version 1.1 - 2007/06/06 - minor cosmetic change

Version 1.0 - 2007/04/01 - initial revision

This document is for those wishing to port PDCurses to a new platform,

or just wanting to better understand how it works. Nothing here should

be needed for application programming; for that, refer to PDCurses.txt,

as built in doc/, or distributed as a file separate from this source

package. This document assumes that you've read the user-level

documentation and are very familiar with application-level curses

programming.

If you want to submit your port for possible inclusion into the main

PDCurses distribution, please follow these guidelines:

 - Don't modify anything in the pdcurses directory or in other port

   directories. Don't modify curses.h or curspriv.h unless absolutely

   necessary. (And prefer modifying curspriv.h over curses.h.)

 - Use the same indentation style, naming and scope conventions as the

   existing code.

 - Release all your code to the public domain -- no copyright. Code

   under GPL, BSD, etc. will not be accepted.

DATA STRUCTURES

---------------

A port of PDCurses must provide acs_map[], a 128-element array of

chtypes, with values laid out based on the Alternate Character Set of

the VT100 (see curses.h). PDC_transform_line() must use this table; when

it encounters a chtype with the A_ALTCHARSET flag set, and an A_CHARTEXT

value in the range 0-127, it must render it using the A_CHARTEXT portion

of the corresponding value from this table, instead of the original

value. Also, values may be read from this table by apps, and passed

through functions such as waddch(), which does no special processing on

control characters (0-31 and 127) when the A_ALTCHARSET flag is set.

Thus, any control characters used in acs_map[] should also have the

A_ALTCHARSET flag set. Implementations should provide suitable values

for all the ACS_ macros defined in curses.h; other values in the table

should be filled with their own indices (e.g., acs_map['E'] == 'E'). The

table can be either hardwired, or filled by PDC_scr_open(). Existing

ports define it in pdcdisp.c, but this is not required.

FUNCTIONS

---------

A port of PDCurses must implement the following functions, with extern

scope. These functions are traditionally divided into several modules,

as indicated below; this division is not required (only the functions

are), but may make it easier to follow for someone familiar with the

existing ports.

Any other functions you create as part of your implementation should

have static scope, if possible. If they can't be static, they should be

named with the "PDC_" prefix. This minimizes the risk of collision with

an application's choices.

Current PDCurses style also uses a single leading underscore with the

name of any static function; and modified BSD/Allman-style indentation,

approximately equivalent to "indent -kr -i8 -bl -bli0", with adjustments

to keep every line under 80 columns. This isn't essential, but a

consistent style helps readability.

pdcdisp.c:

----------

void    PDC_gotoyx(int y, int x);

Move the physical cursor (as opposed to the logical cursor affected by

wmove()) to the given location. This is called mainly from doupdate().

In general, this function need not compare the old location with the new

one, and should just move the cursor unconditionally.

void    PDC_transform_line(int lineno, int x, int len, const chtype *srcp);

The core output routine. It takes len chtype entities from srcp (a

pointer into curscr) and renders them to the physical screen at line

lineno, column x. It must also translate characters 0-127 via acs_map[],

if they're flagged with A_ALTCHARSET in the attribute portion of the

chtype.

pdcgetsc.c:

-----------

int     PDC_get_columns(void);

Returns the size of the screen in columns. It's used in resize_term() to

set the new value of COLS. (Some existing implementations also call it

internally from PDC_scr_open(), but this is not required.)

int     PDC_get_cursor_mode(void);

Returns the size/shape of the cursor. The format of the result is

unspecified, except that it must be returned as an int. This function is

called from initscr(), and the result is stored in SP->orig_cursor,

which is used by PDC_curs_set() to determine the size/shape of the

cursor in normal visibility mode (curs_set(1)).

int     PDC_get_rows(void);

Returns the size of the screen in rows. It's used in resize_term() to

set the new value of LINES. (Some existing implementations also call it

internally from PDC_scr_open(), but this is not required.)

pdckbd.c:

---------

bool    PDC_check_key(void);

Keyboard/mouse event check, called from wgetch(). Returns TRUE if

there's an event ready to process. This function must be non-blocking.

void    PDC_flushinp(void);

This is the core of flushinp(). It discards any pending key or mouse

events, removing them from any internal queue and from the OS queue, if

applicable.

int     PDC_get_key(void);

Get the next available key, or mouse event (indicated by a return of

KEY_MOUSE), and remove it from the OS' input queue, if applicable. This

function is called from wgetch(). This function may be blocking, and

traditionally is; but it need not be. If a valid key or mouse event

cannot be returned, for any reason, this function returns -1. Valid keys

are those that fall within the appropriate character set, or are in the

list of special keys found in curses.h (KEY_MIN through KEY_MAX). When

returning a special key code, this routine must also set SP->key_code to

TRUE; otherwise it must set it to FALSE. If SP->return_key_modifiers is

TRUE, this function may return modifier keys (shift, control, alt),

pressed alone, as special key codes; if SP->return_key_modifiers is

FALSE, it must not. If modifier keys are returned, it should only happen

if no other keys were pressed in the meantime; i.e., the return should

happen on key up. But if this is not possible, it may return the

modifier keys on key down (if and only if SP->return_key_modifiers is

TRUE).

int     PDC_modifiers_set(void);

Called from PDC_return_key_modifiers(). If your platform needs to do

anything in response to a change in SP->return_key_modifiers, do it

here. Returns OK or ERR, which is passed on by the caller.

int     PDC_mouse_set(void);

Called by mouse_set(), mouse_on(), and mouse_off() -- all the functions

that modify SP->_trap_mbe. If your platform needs to do anything in

response to a change in SP->_trap_mbe (for example, turning the mouse

cursor on or off), do it here. Returns OK or ERR, which is passed on by

the caller.

void    PDC_set_keyboard_binary(bool on);

Set keyboard input to "binary" mode. If you need to do something to keep

the OS from processing ^C, etc. on your platform, do it here. TRUE turns

the mode on; FALSE reverts it. This function is called from raw() and

noraw().

pdcscrn.c:

----------

bool    PDC_can_change_color(void);

Returns TRUE if init_color() and color_content() give meaningful

results, FALSE otherwise. Called from can_change_color().

int     PDC_color_content(short color, short *red, short *green, short *blue);

The core of color_content(). This does all the work of that function,

except checking for values out of range and null pointers.

int     PDC_init_color(short color, short red, short green, short blue);

The core of init_color(). This does all the work of that function,

except checking for values out of range.

void    PDC_init_pair(short pair, short fg, short bg);

The core of init_pair(). This does all the work of that function, except

checking for values out of range. The values passed to this function

should be returned by a call to PDC_pair_content() with the same pair

number. PDC_transform_line() should use the specified colors when

rendering a chtype with the given pair number.

int     PDC_pair_content(short pair, short *fg, short *bg);

The core of pair_content(). This does all the work of that function,

except checking for values out of range and null pointers.

void    PDC_reset_prog_mode(void);

The non-portable functionality of reset_prog_mode() is handled here --

whatever's not done in _restore_mode(). In current ports: In OS/2, this

sets the keyboard to binary mode; in Win32, it enables or disables the

mouse pointer to match the saved mode; in others it does nothing.

void    PDC_reset_shell_mode(void);

The same thing, for reset_shell_mode(). In OS/2 and Win32, it restores

the default console mode; in others it does nothing.

int     PDC_resize_screen(int nlines, int ncols);

This does the main work of resize_term(). It may respond to non-zero

parameters, by setting the screen to the specified size; to zero

parameters, by setting the screen to a size chosen by the user at

runtime, in an unspecified way (e.g., by dragging the edges of the

window); or both. It may also do nothing, if there's no appropriate

action for the platform.

void    PDC_restore_screen_mode(int i);

Called from _restore_mode() in kernel.c, this function does the actual

mode changing, if applicable. Currently used only in DOS and OS/2.

void    PDC_save_screen_mode(int i);

Called from _save_mode() in kernel.c, this function saves the actual

screen mode, if applicable. Currently used only in DOS and OS/2.

void    PDC_scr_close(void);

The platform-specific part of endwin(). It may restore the image of the

original screen saved by PDC_scr_open(), if the PDC_RESTORE_SCREEN

environment variable is set; either way, if using an existing terminal,

this function should restore it to the mode it had at startup, and move

the cursor to the lower left corner. (The X11 port does nothing.)

void    PDC_scr_free(void);

Frees the memory for SP allocated by PDC_scr_open(). Called by

delscreen().

int     PDC_scr_open(int argc, char **argv);

The platform-specific part of initscr(). It's actually called from

Xinitscr(); the arguments, if present, correspond to those used with

main(), and may be used to set the title of the terminal window, or for

other, platform-specific purposes. (The arguments are currently used

only in X11.) PDC_scr_open() must allocate memory for SP, and must

initialize acs_map[] (unless it's preset) and several members of SP,

including lines, cols, mouse_wait, orig_attr (and if orig_attr is TRUE,

orig_fore and orig_back), mono, _restore and _preserve. (Although SP is

used the same way in all ports, it's allocated here in order to allow

the X11 port to map it to a block of shared memory.) If using an

existing terminal, and the environment variable PDC_RESTORE_SCREEN is

set, this function may also store the existing screen image for later

restoration by PDC_scr_close().

pdcsetsc.c:

-----------

int     PDC_curs_set(int visibility);

Called from curs_set(). Changes the appearance of the cursor -- 0 turns

it off, 1 is normal (the terminal's default, if applicable, as

determined by SP->orig_cursor), and 2 is high visibility. The exact

appearance of these modes is not specified.

pdcutil.c:

----------

void    PDC_beep(void);

Emits a short audible beep. If this is not possible on your platform,

you must set SP->audible to FALSE during initialization (i.e., from

PDC_scr_open() -- not here); otherwise, set it to TRUE. This function is

called from beep().

void    PDC_napms(int ms);

This is the core delay routine, called by napms(). It pauses for about

(the X/Open spec says "at least") ms milliseconds, then returns. High

degrees of accuracy and precision are not expected (though desirable, if

you can achieve them). More important is that this function gives back

the process' time slice to the OS, so that PDCurses idles at low CPU

usage.

const char *PDC_sysname(void);

Returns a short string describing the platform, such as "DOS" or "X11".

This is used by longname(). It must be no more than 100 characters; it

should be much, much shorter (existing platforms use no more than 5).

--------------------------------------------------------------------------

The following functions are implemented in the platform directories, but

are accessed directly by apps. Refer to the user documentation for their

descriptions:

pdcclip.c:

----------

int     PDC_clearclipboard(void);

int     PDC_freeclipboard(char *contents);

int     PDC_getclipboard(char **contents, long *length);

int     PDC_setclipboard(const char *contents, long length);

pdckbd.c:

---------

unsigned long PDC_get_input_fd(void);

pdcsetsc.c:

-----------

int     PDC_set_blink(bool blinkon);

void    PDC_set_title(const char *title);