Logo Search packages:      
Sourcecode: falconseye version File versions  Download package

mactty.c

/*    SCCS Id: @(#)mactty.c   3.1   93/03/01                */
/* 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"
#include <Resources.h>

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 wether 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 ();
}


/*
 * Allocate a pointer using the set memory-allocator
 */
static short
alloc_ptr (void **ptr, long size) {
      *ptr = NewPtr (size);
      return MemError ();
}


/*
 * 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);
      } 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;
                        }
                  }
            }
      }
      return s_err;
}


/*
 * Snatch a window from the resource fork. Create the record.
 * Otherwise, do nothing.
 */

short create_tty (WindowPtr *window, short resource_id, Boolean in_color) {
tty_record * record;
Boolean was_allocated = !!*window;

      if (in_color) {
            *window = GetNewCWindow (resource_id, (Ptr) *window, (WindowPtr) -1L);
      } else {
            *window = GetNewWindow (resource_id, (Ptr) *window, (WindowPtr) -1L);
      }
      if (!*window) {
            return mem_err ();
      }

      record = (tty_record *) NewPtrClear (sizeof (tty_record));
      if (!record) {
            if (was_allocated) {
                  CloseWindow (*window);
            } else {
                  DisposeWindow (*window);
            }
            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;

            SetPort (*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 (record->was_allocated) {
                  CloseWindow (window);
            } else {
                  DisposeWindow (window);
            }
            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);
      }
}


/*
 * 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);
      } 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));
            }
      }
      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);
            SetPort (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 = (BitMap *) &record->offscreen_world->portPixMap;
      }
      else  source = &record->its_bits;
      
      CopyBits (source, &(record->its_window->portBits), 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);
}


/*
 * 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;
}


/*
 * 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 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, 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(applec) || defined(__MWERKS__)
# 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 */

Generated by  Doxygen 1.6.0   Back to index