nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity
Files
aa9e03eef8b7d4e29f07224ba6b4b14eeeaa87cd
nethack/sys/mac/mactty.c
Pasi Kallinen 217671e00f Remove built-in speaker support 
The changes to amiga, mac and msdos builds are untested.
2019-05-11 11:10:00 +03:00

1261 lines
30 KiB
C
Raw Blame History

/* NetHack 3.6 mactty.c $NHDT-Date: 1432512797 2015/05/25 00:13:17 $ $NHDT-Branch: master $:$NHDT-Revision: 1.9 $ */
/* Copyright (c) Jon W{tte 1993. */
/* NetHack may be freely redistributed. See license for details. */
/*
* mactty.c
*
* This file contains the actual code for the tty library. For a
* description, see the file mactty.h, which contains all you
* need to know to use the library.
*/
#include "hack.h" /* to get flags */
#include "mttypriv.h"
#if !TARGET_API_MAC_CARBON
#include <Sound.h>
#include <Resources.h>
#endif
char game_active = 0; /* flag to window rendering routines not to use ppat */
/* these declarations are here because I can't include macwin.h without
* including the world */
extern void dprintf(char *, ...); /* dprintf.c */
/*
* Borrowed from the Mac tty port
*/
extern WindowPtr _mt_window;
static void select_onscreen_window(tty_record *record);
static void select_offscreen_port(tty_record *record);
#define MEMORY_MARGIN 30000
/*
* Convenience macro for most functions - put last in declaration
*/
#define RECORD_EXISTS(record) \
tty_record *record; \
if (!window || !(record = (tty_record *) GetWRefCon(window))) \
return general_failure;
/*
* Simple macro for deciding whether we draw at once or delay
*/
#define DRAW_DIRECT (TA_ALWAYS_REFRESH & record->attribute[TTY_ATTRIB_FLAGS])
/*
* Table of special characters. Zero is ALWAYS special; it means
* end of string and would be MISSED if it was not included here.
*/
#define COOKED_CONTROLS 0X00002581
#define RAW_CONTROLS 1
static unsigned long s_control = COOKED_CONTROLS;
/*
* Memory-related error
*/
static short
mem_err(void)
{
short ret_val = MemError();
if (!ret_val) {
ret_val = general_failure;
}
return ret_val;
}
/*
* Make a rectangle empty
*/
static void
empty_rect(Rect *r)
{
r->right = -20000;
r->left = 20000;
r->top = 20000;
r->bottom = -20000;
}
/*
* Union twp rect together
*/
static void
union_rect(Rect *r1, Rect *r2, Rect *dest)
{
dest->left = min(r1->left, r2->left);
dest->top = min(r1->top, r2->top);
dest->bottom = max(r1->bottom, r2->bottom);
dest->right = max(r1->right, r2->right);
}
/*
* Dispose a pointer using the set memory-allocator
*/
static short
dispose_ptr(void *ptr)
{
if (!ptr) {
return noErr; /* Silently accept disposing nulls */
}
DisposePtr(ptr);
return MemError();
}
#if 0 /* Use alloc.c instead */
/*
* Allocate a pointer using the set memory-allocator
*/
static short
alloc_ptr (void **ptr, long size) {
*ptr = NewPtr (size);
return MemError ();
}
#endif
/*
* Set up a GWorld in the record
*/
static short
allocate_offscreen_world(tty_record *record)
{
GWorldPtr gw = (GWorldPtr) 0;
GWorldFlags world_flags = 0;
long mem_here, mem_there, other, required_mem;
Point p = { 0, 0 };
Rect r_screen;
GDHandle gdh;
short s_err;
select_onscreen_window(record);
LocalToGlobal(&p);
r_screen = record->its_bits.bounds;
OffsetRect(&r_screen, p.h, p.v);
gdh = GetMaxDevice(&r_screen);
required_mem = (long) (*((*gdh)->gdPMap))->pixelSize
* ((long) record->its_bits.bounds.right
* record->its_bits.bounds.bottom)
>> 3;
PurgeSpace(&other, &mem_here);
if (other < mem_here + MEMORY_MARGIN) {
mem_here = other - MEMORY_MARGIN;
}
dprintf("Heap %ld Required %ld", mem_here, required_mem);
if (required_mem > mem_here) {
mem_there = required_mem;
if (required_mem > TempMaxMem(&mem_there)) {
dprintf("No memory");
return memFullErr;
}
world_flags |= useTempMem;
}
s_err = NewGWorld(&gw, 0, &r_screen, (CTabHandle) 0, (GDHandle) 0,
world_flags);
if (!s_err) {
record->offscreen_world = gw;
select_offscreen_port(record);
SetOrigin(0, 0);
select_onscreen_window(record);
dprintf("New GWorld @ %lx;dm", gw);
}
return s_err;
}
/*
* Done with GWorld, release data
*/
static short
deallocate_gworld(tty_record *record)
{
if (record->offscreen_world) {
DisposeGWorld(record->offscreen_world);
record->offscreen_world = (GWorldPtr) 0;
}
return noErr;
}
/*
* Get rid of offscreen bitmap
*/
static short
free_bits(tty_record *record)
{
short s_err;
if (record->uses_gworld) {
s_err = deallocate_gworld(record);
#if !TARGET_API_MAC_CARBON
} else {
s_err = dispose_ptr(record->its_bits.baseAddr);
if (!s_err) {
record->its_bits.baseAddr = (char *) 0;
if (record->offscreen_port) {
ClosePort(record->offscreen_port);
s_err = dispose_ptr(record->offscreen_port);
if (!s_err) {
record->offscreen_port = (GrafPtr) 0;
}
}
}
#endif
}
return s_err;
}
/*
* Snatch a window from the resource fork. Create the record.
* Otherwise, do nothing.
*/
short
create_tty(WindowRef *window, short resource_id, Boolean in_color)
{
tty_record *record;
Boolean was_allocated = !!*window;
if (in_color) {
*window = GetNewCWindow(resource_id, (Ptr) *window, (WindowRef) -1L);
} else {
*window = GetNewWindow(resource_id, (Ptr) *window, (WindowRef) -1L);
}
if (!*window) {
return mem_err();
}
record = (tty_record *) NewPtrClear(sizeof(tty_record));
if (!record) {
#if !TARGET_API_MAC_CARBON
if (was_allocated) {
CloseWindow(*window);
} else {
#endif
DisposeWindow(*window);
#if !TARGET_API_MAC_CARBON
}
#endif
return mem_err();
}
record->its_window = *window;
SetWRefCon(*window, (long) record);
record->was_allocated = was_allocated;
record->its_bits.baseAddr = (char *) 0;
record->curs_state = TRUE;
/*
* We need to keep the window world around if we switch worlds
*/
record->offscreen_world = (GWorldPtr) 0;
record->uses_gworld = in_color;
if (in_color) {
GDHandle gh;
SetPortWindowPort(*window);
GetGWorld(&(record->its_window_world), &gh);
} else {
record->its_window_world = (GWorldPtr) 0;
}
#if CLIP_RECT_ONLY
empty_rect(&(record->invalid_rect));
#else
record->invalid_part = NewRgn();
if (!record->invalid_part) {
return destroy_tty(*window);
}
#endif
return noErr;
}
short
init_tty_number(WindowPtr window, short font_number, short font_size,
short x_size, short y_size)
{
RECORD_EXISTS(record);
record->font_number = font_number;
record->font_size = font_size;
record->x_size = x_size;
record->y_size = y_size;
return force_tty_coordinate_system_recalc(window);
}
/*
* Done with a window - destroy it. Release the memory only if
* it wasn't allocated when we got it!
*/
short
destroy_tty(WindowPtr window)
{
short s_err;
RECORD_EXISTS(record);
s_err = free_bits(record);
if (!s_err) {
#if !TARGET_API_MAC_CARBON
if (record->was_allocated) {
CloseWindow(window);
} else {
#endif
DisposeWindow(window);
#if !TARGET_API_MAC_CARBON
}
#endif
s_err = dispose_ptr(record);
}
return s_err;
}
static void
do_set_port_font(tty_record *record)
{
PenNormal();
TextFont(record->font_number);
TextSize(record->font_size);
if (0L != (record->attribute[TTY_ATTRIB_FLAGS] & TA_OVERSTRIKE)) {
TextMode(srcOr);
} else {
TextMode(srcCopy);
}
}
void
tty_nhbell(void)
{
Handle h = GetNamedResource('snd ', "\pNetHack Bell");
if (h) {
HLock(h);
SndPlay((SndChannelPtr) 0, (SndListHandle) h, 0);
ReleaseResource(h);
} else
SysBeep(30);
}
/*
* Fill in some fields from some other fields that may have changed
*/
static void
calc_font_sizes(tty_record *record)
{
FontInfo font_info;
do_set_port_font(record);
GetFontInfo(&font_info);
record->char_width = font_info.widMax;
record->ascent_height = font_info.ascent + font_info.leading;
record->row_height = record->ascent_height + font_info.descent;
}
/*
* Allocate memory for the bitmap holding the tty window
*/
static short
alloc_bits(tty_record *record)
{
short s_err;
SetRect(&record->its_bits.bounds, 0, 0,
record->char_width * record->x_size,
record->row_height * record->y_size);
/*
* Clear two highest and lowest bit - not a color pixMap, and even in size
*/
record->its_bits.rowBytes =
((record->its_bits.bounds.right + 15) >> 3) & 0x1ffe;
if (record->uses_gworld) {
s_err = allocate_offscreen_world(record);
#if !TARGET_API_MAC_CARBON
} else {
s_err = alloc_ptr((void **) &(record->its_bits.baseAddr),
record->its_bits.rowBytes
* record->its_bits.bounds.bottom);
if (!s_err) {
s_err = alloc_ptr((void **) &(record->offscreen_port),
sizeof(GrafPort));
}
if (!s_err) {
OpenPort(record->offscreen_port);
SetPort(record->offscreen_port);
ClipRect(&(record->its_bits.bounds));
SetPortBits(&(record->its_bits));
}
#endif
}
return s_err;
}
/*
* Save the current port/world in a safe place for later retrieval
*/
static void
save_port(tty_record *record, void *save)
{
GWorldPtr gw;
GDHandle gh;
GrafPtr gp;
if (record->uses_gworld) {
GetGWorld(&gw, &gh);
*(GWorldPtr *) save = gw;
} else {
GetPort(&gp);
*(GrafPtr *) save = gp;
}
}
/*
* Restore current port/world after a save
*/
static void
use_port(tty_record *record, void *port)
{
if (record->uses_gworld) {
PixMapHandle pix_map;
SetGWorld((GWorldPtr) port, (GDHandle) 0);
pix_map = GetGWorldPixMap(record->offscreen_world);
if (pix_map) {
if (port == record->offscreen_world)
LockPixels(pix_map);
else
UnlockPixels(pix_map);
}
} else {
SetPort((GrafPtr) port);
}
}
/*
* Use offscreen drawing - lock the pixels through use_port
*/
static void
select_offscreen_port(tty_record *record)
{
if (record->uses_gworld) {
use_port(record, record->offscreen_world);
} else {
use_port(record, record->offscreen_port);
}
}
/*
* Use the window - unlock pixels
*/
static void
select_onscreen_window(tty_record *record)
{
if (record->uses_gworld) {
use_port(record, record->its_window_world);
SetPortWindowPort(record->its_window);
} else {
use_port(record, record->its_window);
}
}
/*
* Do bits copy depending on if we're using color or not
*/
static void
copy_bits(tty_record *record, Rect *bounds, short xfer_mode,
RgnHandle mask_rgn)
{
GWorldFlags pix_state;
BitMap *source;
if (record->uses_gworld) {
pix_state = GetPixelsState(GetGWorldPixMap(record->offscreen_world));
LockPixels(GetGWorldPixMap(record->offscreen_world));
source = (BitMapPtr) *GetGWorldPixMap(record->offscreen_world);
} else
source = &record->its_bits;
SetPortWindowPort(record->its_window);
CopyBits(source,
GetPortBitMapForCopyBits(GetWindowPort(record->its_window)),
bounds, bounds, xfer_mode, mask_rgn);
if (record->uses_gworld) {
SetPixelsState(GetGWorldPixMap(record->offscreen_world), pix_state);
}
}
/*
* Fill an area with the background color
*/
static void
erase_rect(tty_record *record, Rect *area)
{
if (game_active && u.uhp > 0 && iflags.use_stone
&& record->its_window == _mt_window) {
PixPatHandle ppat;
ppat = GetPixPat(iflags.use_stone + 127); /* find which pat to get */
if (ppat) { /* in game window, using backgroung pattern, and have
pattern */
FillCRect(area, ppat);
DisposePixPat(ppat);
return;
}
}
EraseRect(area);
}
/*
* Recalculate the window based on new size, font, extent values,
* and re-allocate the bitmap.
*/
short
force_tty_coordinate_system_recalc(WindowPtr window)
{
short s_err;
RECORD_EXISTS(record);
s_err = free_bits(record);
if (s_err) {
return s_err;
}
calc_font_sizes(record);
s_err = alloc_bits(record);
if (s_err) {
/*
* Catastrophe! We could not allocate memory for the bitmap! Things
* may go very
* much downhill from here!
*/
dprintf("alloc_bits returned null in "
"force_tty_coordinate_system_recalc!");
return s_err;
}
select_offscreen_port(record);
do_set_port_font(record);
return clear_tty(window);
}
#if 0
/*
* Update TTY according to new color environment for the window
*/
static short
tty_environment_changed (tty_record *record) {
Point p = {0, 0};
Rect r_screen;
if (record->uses_gworld) {
r_screen = record->its_bits.bounds;
LocalToGlobal (&p);
OffsetRect (&r_screen, p.h, p.v);
UpdateGWorld (&(record->offscreen_world), 0, &r_screen,
(CTabHandle) 0, (GDHandle) 0, stretchPix);
select_offscreen_port (record);
SetOrigin (0, 0);
select_onscreen_window (record);
}
return 0;
}
#endif
/*
* Read a lot of interesting and useful information from the current tty
*/
short
get_tty_metrics(WindowPtr window, short *x_size, short *y_size,
short *x_size_pixels, short *y_size_pixels,
short *font_number, short *font_size, short *char_width,
short *row_height)
{
RECORD_EXISTS(record);
/*
* First, test that we actually have something to draw to...
*/
if ((((char *) 0 == record->its_bits.baseAddr) && !record->uses_gworld)
|| (((GWorldPtr) 0 == record->offscreen_world)
&& record->uses_gworld)) {
return general_failure;
}
*x_size = record->x_size;
*y_size = record->y_size;
*x_size_pixels = record->its_bits.bounds.right;
*y_size_pixels = record->its_bits.bounds.bottom;
*font_number = record->font_number;
*font_size = record->font_size;
*char_width = record->char_width;
*row_height = record->row_height;
return noErr;
}
/*
* Map a position on the map to screen coordinates
*/
static void
pos_rect(tty_record *record, Rect *r, short x_pos, short y_pos, short x_end,
short y_end)
{
SetRect(r, x_pos * (record->char_width), y_pos * (record->row_height),
(1 + x_end) * (record->char_width),
(1 + y_end) * (record->row_height));
}
static void
accumulate_rect(tty_record *record, Rect *rect)
{
#if CLIP_RECT_ONLY
union_rect(rect, &(record->invalid_rect), &(record->invalid_rect));
#else
RgnHandle rh = NewRgn();
RectRgn(rh, rect);
UnionRgn(record->invalid_part, rh, record->invalid_part);
DisposeRgn(rh);
#endif
}
/*
* get and set window invalid region. exposed for HandleUpdateEvent in
* macwin.c
* to correct display problem
*/
short
get_invalid_region(WindowPtr window, Rect *inval_rect)
{
RECORD_EXISTS(record);
#if CLIP_RECT_ONLY
if (record->invalid_rect.right <= record->invalid_rect.left
|| record->invalid_rect.bottom <= record->invalid_rect.top) {
return general_failure;
}
*inval_rect = record->invalid_rect;
#else
if (EmptyRgn(record->invalid_part)) {
return general_failure;
}
*inval_rect = (*(record->invalid_part))->rgnBBox;
#endif
return noErr;
}
short
set_invalid_region(WindowPtr window, Rect *inval_rect)
{
RECORD_EXISTS(record);
accumulate_rect(record, inval_rect);
return noErr;
}
/*
* Invert the specified position
*/
static void
curs_pos(tty_record *record, short x_pos, short y_pos, short to_state)
{
Rect r;
if (record->curs_state == to_state) {
return;
}
record->curs_state = to_state;
pos_rect(record, &r, x_pos, y_pos, x_pos, y_pos);
if (DRAW_DIRECT) {
void *old_port;
save_port(record, &old_port);
select_onscreen_window(record);
InvertRect(&r);
use_port(record, old_port);
} else {
accumulate_rect(record, &r);
}
}
/*
* Move the cursor (both as displayed and where drawing goes)
* HOWEVER: The cursor is NOT stored in the bitmap!
*/
short
move_tty_cursor(WindowPtr window, short x_pos, short y_pos)
{
RECORD_EXISTS(record);
if (record->x_curs == x_pos && record->y_curs == y_pos) {
return noErr;
}
if (record->x_size <= x_pos || x_pos < 0 || record->y_size <= y_pos
|| y_pos < 0) {
return general_failure;
}
curs_pos(record, record->x_curs, record->y_curs, 0);
record->x_curs = x_pos;
record->y_curs = y_pos;
curs_pos(record, x_pos, y_pos, 1);
return noErr;
}
/*
* Update the screen to match the current bitmap, after adding stuff
* with add_tty_char etc.
*/
short
update_tty(WindowPtr window)
{
Rect r;
RECORD_EXISTS(record);
#if CLIP_RECT_ONLY
if (record->invalid_rect.right <= record->invalid_rect.left
|| record->invalid_rect.bottom <= record->invalid_rect.top) {
return noErr;
}
r = record->invalid_rect;
#else
if (EmptyRgn(record->invalid_part)) {
return noErr;
}
r = (*(record->invalid_part))->rgnBBox;
#endif
select_onscreen_window(record);
copy_bits(record, &r, srcCopy, (RgnHandle) 0);
#if CLIP_RECT_ONLY
empty_rect(&(record->invalid_rect));
#else
SetEmptyRgn(record->invalid_part);
#endif
if (record->curs_state) {
pos_rect(record, &r, record->x_curs, record->y_curs, record->x_curs,
record->y_curs);
InvertRect(&r);
}
return noErr;
}
/*
* Low level add to screen
*/
static void
do_add_string(tty_record *record, char *str, short len)
{
Rect r;
if (len < 1) {
return;
}
select_offscreen_port(record);
MoveTo(record->x_curs * record->char_width,
record->y_curs * record->row_height + record->ascent_height);
DrawText(str, 0, len);
pos_rect(record, &r, record->x_curs, record->y_curs,
record->x_curs + len - 1, record->y_curs);
select_onscreen_window(record);
if (DRAW_DIRECT) {
copy_bits(record, &r, srcCopy, (RgnHandle) 0);
} else {
accumulate_rect(record, &r);
}
}
/*
* Low-level cursor handling routine
*/
static void
do_add_cursor(tty_record *record, short x_pos)
{
record->x_curs = x_pos;
if (record->x_curs >= record->x_size) {
if (0L != (record->attribute[TTY_ATTRIB_FLAGS] & TA_WRAP_AROUND)) {
record->y_curs++;
record->x_curs = 0;
if (record->y_curs >= record->y_size) {
if (0L != (record->attribute[TTY_ATTRIB_FLAGS]
& TA_INHIBIT_VERT_SCROLL)) {
record->y_curs = record->y_size;
} else {
scroll_tty(record->its_window, 0,
1 + record->y_curs - record->y_size);
}
}
} else {
record->x_curs = record->x_size;
}
}
}
/*
* Do control character
*/
static void
do_control(tty_record *record, short character)
{
int recurse = 0;
/*
* Check recursion because nl_add_cr and cr_add_nl may both be set and
* invoke each other
*/
do {
switch (character) {
case CHAR_CR:
record->x_curs = 0;
if (!recurse
&& (record->attribute[TTY_ATTRIB_CURSOR] & TA_CR_ADD_NL)) {
recurse = 1;
} else {
recurse = 0;
break;
} /* FALL-THROUGH: if CR-LF, don't bother with loop */
case CHAR_LF:
record->y_curs++;
if (record->y_curs >= record->y_size) {
scroll_tty(record->its_window, 0,
1 + record->y_curs - record->y_size);
}
if (!recurse
&& (record->attribute[TTY_ATTRIB_CURSOR] & TA_NL_ADD_CR)) {
character = CHAR_CR;
recurse = 1;
} else
recurse = 0;
break;
case CHAR_BELL:
tty_nhbell();
break;
case CHAR_BS:
if (record->x_curs > 0)
record->x_curs--;
default:
break;
}
} while (recurse);
}
/*
* Add a single character. It is drawn directly if the correct flag is set,
* else deferred to the next update event or call of update_tty()
*/
short
add_tty_char(WindowPtr window, short character)
{
register char is_control;
char ch;
RECORD_EXISTS(record);
if (!(record->attribute[TTY_ATTRIB_FLAGS] & TA_WRAP_AROUND)
&& record->x_curs >= record->x_size)
return noErr; /* Optimize away drawing across border without wrap */
if (record->curs_state != 0)
curs_pos(record, record->x_curs, record->y_curs, 0);
ch = character;
is_control = (ch < sizeof(long) * 8) && ((s_control & (1 << ch)) != 0L);
if (is_control)
do_control(record, ch);
else {
do_add_string(record, (char *) &ch, 1);
do_add_cursor(record, record->x_curs + 1);
}
return noErr;
}
/*
* Add a null-terminated string of characters
*/
short
add_tty_string(WindowPtr window, const char *string)
{
register const unsigned char *start_c;
register const unsigned char *the_c;
register unsigned char ch, is_control = 0, tty_wrap;
register short max_x, pos_x;
RECORD_EXISTS(record);
if (record->curs_state != 0)
curs_pos(record, record->x_curs, record->y_curs, 0);
the_c = (const unsigned char *) string;
max_x = record->x_size;
tty_wrap = (record->attribute[TTY_ATTRIB_FLAGS] & TA_WRAP_AROUND);
for (;;) {
pos_x = record->x_curs;
if (!tty_wrap && pos_x >= max_x)
break; /* Optimize away drawing across border without wrap */
start_c = the_c;
ch = *the_c;
while (pos_x < max_x) {
is_control =
(ch < sizeof(long) * 8) && ((s_control & (1 << ch)) != 0L);
if (is_control)
break;
the_c++;
ch = *the_c;
pos_x++;
}
do_add_string(record, (char *) start_c, the_c - start_c);
do_add_cursor(record, pos_x);
if (!ch)
break;
if (is_control) {
do_control(record, ch);
the_c++;
}
}
return noErr;
}
/*
* Read or change attributes for the tty. Note that some attribs may
* very well clear and reallocate the bitmap when changed, whereas
* others (color, highlight, ...) are guaranteed not to.
*/
short
get_tty_attrib(WindowPtr window, tty_attrib attrib, long *value)
{
RECORD_EXISTS(record);
if (attrib < 0 || attrib >= TTY_NUMBER_ATTRIBUTES) {
return general_failure;
}
*value = record->attribute[attrib];
return noErr;
}
short
set_tty_attrib(WindowPtr window, tty_attrib attrib, long value)
{
RGBColor rgb_color;
RECORD_EXISTS(record);
if (attrib < 0 || attrib >= TTY_NUMBER_ATTRIBUTES) {
return general_failure;
}
record->attribute[attrib] = value;
/*
* Presently, no attributes generate a new bitmap.
*/
switch (attrib) {
case TTY_ATTRIB_CURSOR:
/*
* Check if we should change tables
*/
if (0L != (value & TA_RAW_OUTPUT)) {
s_control = RAW_CONTROLS;
} else {
s_control = COOKED_CONTROLS;
}
break;
case TTY_ATTRIB_FLAGS:
/*
* Check if we should flush the output going from cached to
* draw-direct
*/
if (0L != (value & TA_ALWAYS_REFRESH)) {
update_tty(window);
}
break;
case TTY_ATTRIB_FOREGROUND:
/*
* Set foreground color
*/
TA_TO_RGB(value, rgb_color);
select_offscreen_port(record);
RGBForeColor(&rgb_color);
select_onscreen_window(record);
break;
case TTY_ATTRIB_BACKGROUND:
/*
* Set background color
*/
TA_TO_RGB(value, rgb_color);
select_offscreen_port(record);
RGBBackColor(&rgb_color);
select_onscreen_window(record);
break;
default:
break;
}
return noErr;
}
/*
* Scroll the window. Positive is up/left. scroll_tty ( window, 0, 1 ) is a
* line feed.
* Scroll flushes the accumulated update area by calling update_tty().
*/
short
scroll_tty(WindowPtr window, short delta_x, short delta_y)
{
RgnHandle rgn;
short s_err;
RECORD_EXISTS(record);
s_err = update_tty(window);
rgn = NewRgn();
select_offscreen_port(record);
ScrollRect(&(record->its_bits.bounds), -delta_x * record->char_width,
-delta_y * record->row_height, rgn);
EraseRgn(rgn);
SetEmptyRgn(rgn);
select_onscreen_window(record);
ScrollRect(&(record->its_bits.bounds), -delta_x * record->char_width,
-delta_y * record->row_height, rgn);
EraseRgn(rgn);
DisposeRgn(rgn);
record->y_curs -= delta_y;
record->x_curs -= delta_x;
return noErr;
}
/*
* Clear the screen. Immediate.
*/
short
clear_tty(WindowPtr window)
{
RECORD_EXISTS(record);
record->curs_state = 0;
select_offscreen_port(record);
erase_rect(record, &(record->its_bits.bounds));
accumulate_rect(record, &(record->its_bits.bounds));
update_tty(window);
return noErr;
}
/*
* Blink cursor on window if necessary
*/
short
blink_cursor(WindowPtr window, long when)
{
RECORD_EXISTS(record);
if ((record->attribute[TTY_ATTRIB_CURSOR] & TA_BLINKING_CURSOR)) {
if (when > record->last_cursor + GetCaretTime()) {
curs_pos(record, record->x_curs, record->y_curs,
!record->curs_state);
record->last_cursor = when;
update_tty(window);
}
}
return 0;
}
/*
* Draw an image of the tty - used for update events and can be called
* for screen dumps.
*/
short
image_tty(EventRecord *theEvent, WindowPtr window)
{
#if defined(__SC__) || defined(__MRC__)
#pragma unused(theEvent)
#endif
RECORD_EXISTS(record);
#if CLIP_RECT_ONLY
record->invalid_rect = record->its_bits.bounds;
#else
RgnHandle rh = NewRgn();
RectRgn(rh, record->its_bits.bounds);
UnionRgn(record->invalid_part, rh, record->invalid_part);
DisposeRgn(rh);
#endif
return update_tty(window);
}
/*
* Clear an area
*/
short
clear_tty_window(WindowPtr window, short from_x, short from_y, short to_x,
short to_y)
{
Rect r;
RECORD_EXISTS(record);
if (from_x > to_x || from_y > to_y) {
return general_failure;
}
pos_rect(record, &r, from_x, from_y, to_x, to_y);
select_offscreen_port(record);
erase_rect(record, &r);
accumulate_rect(record, &r);
if (DRAW_DIRECT) {
update_tty(window);
} else
select_onscreen_window(record);
return noErr;
}
#if EXTENDED_SUPPORT
/*
* Delete or insert operations used by many terminals can bottleneck through
* here. Note that the order of executin for row/colum insertions is NOT
* specified. Negative values for num_ mean delete, zero means no effect.
*/
short
mangle_tty_rows_columns(WindowPtr window, short from_row, short num_rows,
short from_column, short num_columns)
{
Rect r;
RgnHandle rh = NewRgn();
RECORD_EXISTS(record);
update_tty(window); /* Always make sure screen is OK */
curs_pos(record, record->x_curs, record->y_curs, 0);
if (num_rows) {
pos_rect(record, &r, 0, from_row, record->x_size - 1,
record->y_size - 1);
select_offscreen_port(record);
ScrollRect(&r, 0, num_rows * record->row_height, rh);
EraseRgn(rh);
SetEmptyRgn(rh);
select_onscreen_window(record);
ScrollRect(&r, 0, num_rows * record->row_height, rh);
EraseRgn(rh);
SetEmptyRgn(rh);
}
if (num_columns) {
pos_rect(record, &r, from_column, 0, record->x_size - 1,
record->y_size - 1);
select_offscreen_port(record);
ScrollRect(&r, num_columns * record->char_width, 0, rh);
EraseRgn(rh);
SetEmptyRgn(rh);
select_onscreen_window(record);
ScrollRect(&r, num_columns * record->char_width, 0, rh);
EraseRgn(rh);
SetEmptyRgn(rh);
}
DisposeRgn(rh);
if (record->x_curs >= from_column) {
record->x_curs += num_columns;
}
if (record->y_curs >= from_row) {
record->y_curs += num_rows;
}
curs_pos(record, record->x_curs, record->y_curs, 1);
return noErr;
}
/*
* Frame an area in an aesthetically pleasing way.
*/
short
frame_tty_window(WindowPtr window, short from_x, short from_y, short to_x,
short to_y, short frame_fatness)
{
Rect r;
RECORD_EXISTS(record);
if (from_x > to_x || from_y > to_y) {
return general_failure;
}
pos_rect(record, &r, from_x, from_y, to_x, to_y);
select_offscreen_port(record);
PenSize(frame_fatness, frame_fatness);
FrameRect(&r);
PenNormal();
accumulate_rect(record, &r);
if (DRAW_DIRECT) {
update_tty(window);
} else
select_onscreen_window(record);
}
/*
* Highlighting a specific part of the tty window
*/
short
invert_tty_window(WindowPtr window, short from_x, short from_y, short to_x,
short to_y)
{
Rect r;
RECORD_EXISTS(record);
if (from_x > to_x || from_y > to_y) {
return general_failure;
}
pos_rect(record, &r, from_x, from_y, to_x, to_y);
select_offscreen_port(record);
InvertRect(&r);
accumulate_rect(record, &r);
if (DRAW_DIRECT) {
update_tty(window);
} else
select_onscreen_window(record);
}
static void
canonical_rect(Rect *r, short x1, short y1, short x2, short y2)
{
if (x1 < x2) {
if (y1 < y2) {
SetRect(r, x1, x2, y1, y2);
} else {
SetRect(r, x1, x2, y2, y1);
}
} else {
if (y1 < y2) {
SetRect(r, x2, x1, y1, y2);
} else {
SetRect(r, x2, x1, y2, y1);
}
}
}
/*
* Line drawing - very device dependent
*/
short
draw_tty_line(WindowPtr window, short from_x, short from_y, short to_x,
short to_y)
{
Rect r;
RECORD_EXISTS(record);
select_offscreen_port(record);
MoveTo(from_x, from_y);
LineTo(to_x, to_y);
canonical_rect(&r, from_x, from_y, to_x, to_y);
accumulate_rect(record, &r);
if (DRAW_DIRECT) {
update_tty(window);
} else
select_onscreen_window(record);
}
#endif /* EXTENDED_SUPPORT */
View Git Blame Copy Permalink