Files
Ebitor/gimeterm.c
T
Brian Holman 53bf6abdd5 Import Ebitor 0.1.1 upstream source snapshot
Original author: Pierre Sarrazin.
Source: http://sarrazip.com/dev/ebitor-0.1.1.tar.gz
Archive SHA-256: 6911a9d2ee80925622f1d82db1b77710a1f896865e63d29a04dc16489b150e83
2026-11-09 23:45:41 -07:00

320 lines
8.9 KiB
C

/* gimeterm.c - CoCo 3 GIME hardware text mode terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "gimeterm.h"
#include "Ebitor.h"
struct Ebitor;
static byte gimeterm_width, gimeterm_height; // max 80x24
static byte gimeterm_winLeftCol, gimeterm_winTopRow; // 0..79, 0..24
static word *gimeterm_screenBuffer; // address of 40/64/80x24/25 screen buffer
static byte gimeterm_screenColumns; // 40, 64 or 80 (regardless of gimeterm_width)
static byte gimeterm_cursorCol, gimeterm_cursorRow; // lower than gimeterm_width, gimeterm_cursorRow
static byte (*gimeterm_inkeyFuncPtr)(void *cookie); // returns 0 if no key pressed
static void *gimeterm_inkeyFuncCookie; // passed to gimeterm_inkeyFuncPtr
static word *gimeterm_timerPtr; // points to a word that gets incremented 60 times per second
static byte gimeterm_textAttribute;
static byte gimeterm_invertedTextAttribute;
static word *
getPosInWindow(byte col, byte row)
{
return gimeterm_screenBuffer + ((word) (gimeterm_winTopRow + row) * gimeterm_screenColumns + gimeterm_winLeftCol + col);
}
#define getCursorAddress() (getPosInWindow(gimeterm_cursorCol, gimeterm_cursorRow))
static void
gimeterm_clearRowsAt(word *rowStartDest, byte numRows)
{
word w = 0x2000 | gimeterm_textAttribute;
for (byte i = numRows; i--; rowStartDest += gimeterm_screenColumns) // for each window row to clear
memset16(rowStartDest, w, gimeterm_width);
}
void
gimeterm_clear(void)
{
gimeterm_clearRowsAt(getPosInWindow(0, 0), gimeterm_height);
}
void
gimeterm_init(void *screenBuffer, byte screenMode, const gimeterm_Window *window,
byte (*inkeyFuncPtr)(void *), void *inkeyFuncCookie,
word *timerPtr)
{
gimeterm_screenBuffer = (word *) screenBuffer;
gimeterm_screenColumns = screenMode;
gimeterm_inkeyFuncPtr = inkeyFuncPtr;
gimeterm_inkeyFuncCookie = inkeyFuncCookie;
gimeterm_timerPtr = timerPtr;
gimeterm_setWindow(window);
}
void
gimeterm_setWindow(const gimeterm_Window *window)
{
gimeterm_width = window->window.width;
gimeterm_height = window->window.height;
gimeterm_winLeftCol = window->window.leftCol;
gimeterm_winTopRow = window->window.topRow;
gimeterm_cursorCol = window->window.cursorCol;
gimeterm_cursorRow = window->window.cursorRow;
gimeterm_textAttribute = window->textAttribute;
gimeterm_invertedTextAttribute = window->invertedTextAttribute;
}
void
gimeterm_getWindow(gimeterm_Window *dest)
{
dest->window.width = gimeterm_width;
dest->window.height = gimeterm_height;
dest->window.leftCol = gimeterm_winLeftCol;
dest->window.topRow = gimeterm_winTopRow;
dest->window.cursorCol = gimeterm_cursorCol;
dest->window.cursorRow = gimeterm_cursorRow;
dest->textAttribute = gimeterm_textAttribute;
dest->invertedTextAttribute = gimeterm_invertedTextAttribute;
}
void
gimeterm_locate(byte column, byte row)
{
gimeterm_cursorCol = column;
gimeterm_cursorRow = row;
}
void
gimeterm_getCursorPos(byte *column, byte *row)
{
*column = gimeterm_cursorCol;
*row = gimeterm_cursorRow;
}
BOOL
gimeterm_newline(void)
{
gimeterm_cursorCol = 0; // back to start of window row
if (++gimeterm_cursorRow >= gimeterm_height)
{
--gimeterm_cursorRow;
gimeterm_cursorCol = 0; // back to start of last row (avoid writing outside window)
return FALSE; // reached end of window
}
return TRUE;
}
BOOL
gimeterm_putchar(int c)
{
word *cursor = getCursorAddress();
if (c == '\r')
{
word w = 0x2000 | gimeterm_textAttribute;
for ( ; gimeterm_cursorCol < gimeterm_width; ++gimeterm_cursorCol)
*cursor++ = w;
return gimeterm_newline();
}
((byte *) cursor)[0] = (byte) c;
((byte *) cursor)[1] = gimeterm_textAttribute;
if (++gimeterm_cursorCol >= gimeterm_width) // if past end of window row
return gimeterm_newline();
return TRUE;
}
BOOL
gimeterm_print(const char *str)
{
for ( ; *str; ++str)
if (!gimeterm_putchar(*str))
return FALSE; // reached end of window
return TRUE;
}
BOOL
gimeterm_printPrefix(const char *str, size_t prefixLength)
{
for (size_t i = 0; i < prefixLength; ++i)
if (!gimeterm_putchar(str[i]))
return FALSE; // reached end of window
return TRUE;
}
// Use inverted colors for the next print operations.
//
void
gimeterm_invertColors(void)
{
byte temp = gimeterm_textAttribute;
gimeterm_textAttribute = gimeterm_invertedTextAttribute;
gimeterm_invertedTextAttribute = temp;
}
// Does not move the cursor.
//
void
gimeterm_clrtoeol(void)
{
memset16(getCursorAddress(), 0x2000 | gimeterm_textAttribute, gimeterm_width - gimeterm_cursorCol);
}
void
gimeterm_scrollWindowUp(byte numRows)
{
if (numRows == 0)
return;
word *rowStartDest = getPosInWindow(0, 0); // top window row
const word *rowStartSrc = rowStartDest + ((word) numRows * gimeterm_screenColumns);
size_t bytesPerWindowRow = gimeterm_width << 1;
for (byte i = gimeterm_height - numRows; i--; rowStartSrc += gimeterm_screenColumns, rowStartDest += gimeterm_screenColumns) // for each window row to scroll
memcpy(rowStartDest, rowStartSrc, bytesPerWindowRow);
gimeterm_clearRowsAt(rowStartDest, numRows);
}
void
gimeterm_scrollWindowDown(byte numRows)
{
if (numRows == 0)
return;
word *rowStartDest = getPosInWindow(0, gimeterm_height - 1); // bottom window row
const word *rowStartSrc = rowStartDest - ((word) numRows * gimeterm_screenColumns);
size_t bytesPerWindowRow = gimeterm_width << 1;
for (byte i = gimeterm_height - numRows; i--; rowStartSrc -= gimeterm_screenColumns, rowStartDest -= gimeterm_screenColumns) // for each window row to scroll
memmove(rowStartDest, rowStartSrc, bytesPerWindowRow);
const word w = 0x2000 | gimeterm_textAttribute;
for (byte i = numRows; i--; rowStartDest -= gimeterm_screenColumns) // for each window row to clear
memset16(rowStartDest, w, gimeterm_width);
}
void
gimeterm_eraseCurrentLine(void)
{
memset16(getPosInWindow(0, gimeterm_cursorRow), 0x2000 | gimeterm_textAttribute, gimeterm_width);
gimeterm_cursorCol = 0;
}
// Animates a cursor using the timerPtr passed to gimeterm_init().
// Uses the inkeyFuncPtr and inkeyFuncCookie passed to gimeterm_init() to poll the keyboard.
// attributeByte: Address of a GIME 40/80-column screen attribute byte.
// cursorAttribute: Byte to put at *attributeByte to animate the cursor.
// Returns the key pressed, without interpretation.
//
static byte
gimeterm_waitKeyAtPosition(byte *attributeByte, byte cursorAttribute)
{
byte origByteOnScreen = *attributeByte;
// Wait for key with animated cursor.
byte key;
for (word startTime = *gimeterm_timerPtr; ; )
{
key = (*gimeterm_inkeyFuncPtr)(gimeterm_inkeyFuncCookie);
if (key)
break;
*attributeByte = (((*gimeterm_timerPtr - startTime) & 0x38) == 0x38 ? origByteOnScreen : cursorAttribute);
}
*attributeByte = origByteOnScreen;
return key;
}
byte
gimeterm_waitKey(void)
{
byte *cursor = (byte *) getCursorAddress() + 1; // point to attribute byte
return gimeterm_waitKeyAtPosition(cursor, gimeterm_invertedTextAttribute);
}
word
gimeterm_waitEditorKey(void)
{
for (;;)
{
byte key = gimeterm_waitKey();
switch (key)
{
case 3: // Break
return ebitor_KEY_ESCAPE;
case 8: // left arrow
return ebitor_KEY_ARROW_LEFT;
case 9: // right arrow
return ebitor_KEY_ARROW_RIGHT;
case '^': // up arrow
return ebitor_KEY_ARROW_UP;
case 10: // down arrow
return ebitor_KEY_ARROW_DOWN;
case 12: // Clear used as backspace
return '\b'; // backspace
case 13: // Enter
return '\r';
default:
if (key >= ' ' && key != 127)
return key;
}
}
}
byte
gimeterm_setTextAttribute(byte newAttribute)
{
byte orig = gimeterm_textAttribute;
gimeterm_textAttribute = newAttribute;
return orig;
}
byte
gimeterm_setInvertedTextAttribute(byte newAttribute)
{
byte orig = gimeterm_invertedTextAttribute;
gimeterm_invertedTextAttribute = newAttribute;
return orig;
}