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
This commit is contained in:
commit
53bf6abdd5
19 files changed
+5400
No files matched your search
@@ -0,0 +1,939 @@
|
|||||||
|
/* Ebitor.c
|
||||||
|
|
||||||
|
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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
This file uses the terms "terminal" and "window" interchangeably.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
MODE_COMMAND,
|
||||||
|
MODE_INSERTION,
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
Ebitor Ebitor_instance;
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_init(char *bufferBegin, size_t bufferSize,
|
||||||
|
byte termWidth, byte termHeight,
|
||||||
|
ebitor_clear clear,
|
||||||
|
ebitor_locateFunc locate,
|
||||||
|
ebitor_getCursorPosFunc getCursorPos,
|
||||||
|
ebitor_printFunc print,
|
||||||
|
ebitor_printPrefixFunc printPrefix,
|
||||||
|
ebitor_clrtoeolFunc clrtoeol,
|
||||||
|
ebitor_scrollTerminalUpFunc scrollTerminalUp,
|
||||||
|
ebitor_scrollTerminalDownFunc scrollTerminalDown,
|
||||||
|
ebitor_waitKeyFunc waitKey)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
self->termWidth = termWidth;
|
||||||
|
self->termHeight = termHeight;
|
||||||
|
self->bufferBegin = bufferBegin;
|
||||||
|
self->bufferEnd = bufferBegin + bufferSize;
|
||||||
|
self->bufferFilledSize = 0;
|
||||||
|
self->cursorOffset = 0;
|
||||||
|
self->savedCursorCol = 0;
|
||||||
|
self->savedCursorRow = 0;
|
||||||
|
self->mode = MODE_COMMAND;
|
||||||
|
self->insertBuffer.size = 0;
|
||||||
|
|
||||||
|
self->clear = clear;
|
||||||
|
self->locate = locate;
|
||||||
|
self->getCursorPos = getCursorPos;
|
||||||
|
self->print = print;
|
||||||
|
self->printPrefix = printPrefix;
|
||||||
|
self->clrtoeol = clrtoeol;
|
||||||
|
self->scrollTerminalUp = scrollTerminalUp;
|
||||||
|
self->scrollTerminalDown = scrollTerminalDown;
|
||||||
|
self->waitKey = waitKey;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_shutdown(void)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
Ebitor *
|
||||||
|
Ebitor_getInstance(void)
|
||||||
|
{
|
||||||
|
return &Ebitor_instance;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_setContentLength(size_t newLength)
|
||||||
|
{
|
||||||
|
size_t max = Ebitor_instance.bufferEnd - Ebitor_instance.bufferBegin;
|
||||||
|
Ebitor_instance.bufferFilledSize = min(newLength, max);
|
||||||
|
|
||||||
|
Ebitor_setLogicalCursorAtBeginning();
|
||||||
|
|
||||||
|
Ebitor_instance.mode = MODE_COMMAND;
|
||||||
|
Ebitor_instance.insertBuffer.size = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Ebitor_getContentLength(void)
|
||||||
|
{
|
||||||
|
return Ebitor_instance.bufferFilledSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Move the contents of insert buffer to the cursor position in the edit buffer.
|
||||||
|
// Insert buffer ends up empty.
|
||||||
|
// Cursor offset updated to point to after the copied characters.
|
||||||
|
//
|
||||||
|
void
|
||||||
|
Ebitor_flushInsertBuffer(void)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
if (self->insertBuffer.size == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Check if there is room in the edit buffer for the contents of the insert buffer.
|
||||||
|
//
|
||||||
|
size_t availRoom = self->bufferEnd - self->bufferBegin - self->bufferFilledSize;
|
||||||
|
if (self->insertBuffer.size > availRoom)
|
||||||
|
self->insertBuffer.size = availRoom;
|
||||||
|
|
||||||
|
// Create a hole in the edit buffer where to copy the insert buffer.
|
||||||
|
//
|
||||||
|
memmove(self->bufferBegin + self->cursorOffset + self->insertBuffer.size,
|
||||||
|
self->bufferBegin + self->cursorOffset,
|
||||||
|
self->bufferFilledSize - self->cursorOffset);
|
||||||
|
|
||||||
|
memcpy(self->bufferBegin + self->cursorOffset, self->insertBuffer.buffer, self->insertBuffer.size);
|
||||||
|
|
||||||
|
self->bufferFilledSize += self->insertBuffer.size;
|
||||||
|
self->cursorOffset += self->insertBuffer.size;
|
||||||
|
self->insertBuffer.size = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_startCommandMode(void)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
if (self->mode != MODE_COMMAND)
|
||||||
|
{
|
||||||
|
Ebitor_flushInsertBuffer();
|
||||||
|
self->mode = MODE_COMMAND;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_insertChar(char c)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
if (self->mode == MODE_COMMAND)
|
||||||
|
{
|
||||||
|
// Go to insertion mode.
|
||||||
|
self->mode = MODE_INSERTION;
|
||||||
|
self->insertBuffer.buffer[0] = c;
|
||||||
|
self->insertBuffer.size = 1;
|
||||||
|
}
|
||||||
|
else // already in insertion mode
|
||||||
|
{
|
||||||
|
self->insertBuffer.buffer[self->insertBuffer.size++] = c;
|
||||||
|
|
||||||
|
if (self->insertBuffer.size == INSERT_BUFFER_SIZE) // if full
|
||||||
|
{
|
||||||
|
Ebitor_flushInsertBuffer();
|
||||||
|
assert(self->insertBuffer.size == 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// If no \r is found, returns the end of the filled part of the edit buffer.
|
||||||
|
//
|
||||||
|
size_t
|
||||||
|
Ebitor_findEOL(size_t startOffset)
|
||||||
|
{
|
||||||
|
const Ebitor *self = &Ebitor_instance;
|
||||||
|
char *p = (char *) memchr(self->bufferBegin + startOffset, '\r', self->bufferFilledSize - startOffset);
|
||||||
|
return p ? p - self->bufferBegin : self->bufferFilledSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Ebitor_findSOL(size_t startOffset)
|
||||||
|
{
|
||||||
|
const Ebitor *self = &Ebitor_instance;
|
||||||
|
char *p = self->bufferBegin + startOffset;
|
||||||
|
while (p > self->bufferBegin) // while possible to go back
|
||||||
|
{
|
||||||
|
--p;
|
||||||
|
if (*p == '\r')
|
||||||
|
return p + 1 - self->bufferBegin;
|
||||||
|
}
|
||||||
|
return p - self->bufferBegin;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Ebitor_findPreviousSOL(size_t solOffset)
|
||||||
|
{
|
||||||
|
const Ebitor *self = &Ebitor_instance;
|
||||||
|
if (solOffset == 0)
|
||||||
|
return solOffset;
|
||||||
|
assert(self->bufferBegin[solOffset - 1] == '\r');
|
||||||
|
return Ebitor_findSOL(solOffset - 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_fillTerminalToBottom(size_t firstLogicalCharOffsetToPrint, byte firstRowToFill)
|
||||||
|
{
|
||||||
|
const Ebitor *self = &Ebitor_instance;
|
||||||
|
//printf("(%u,%u;%u)", firstLogicalCharOffsetToPrint, firstRowToFill, self->bufferFilledSize);
|
||||||
|
assert(firstLogicalCharOffsetToPrint <= self->bufferFilledSize);
|
||||||
|
if (firstRowToFill >= self->termHeight)
|
||||||
|
return; // failsafe -- nothing to do
|
||||||
|
|
||||||
|
self->locate(0, firstRowToFill);
|
||||||
|
|
||||||
|
if (firstLogicalCharOffsetToPrint == self->bufferFilledSize) // if nothing to print
|
||||||
|
{
|
||||||
|
self->clrtoeol(); // erase a line that may have been merged up
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reprint the rest of the window, while preserving the cursor position.
|
||||||
|
// The portion to print starts at self->cursorOffset and ends either at
|
||||||
|
// the end of the filled edit buffer, or at the bottom of the window.
|
||||||
|
//
|
||||||
|
const char *begin = self->bufferBegin + firstLogicalCharOffsetToPrint;
|
||||||
|
const char *end = self->bufferBegin + self->bufferFilledSize;
|
||||||
|
byte c = 0, r = firstRowToFill;
|
||||||
|
const char *p = begin;
|
||||||
|
for ( ; r < self->termHeight && p < end; ++p)
|
||||||
|
{
|
||||||
|
if (*p == '\r')
|
||||||
|
{
|
||||||
|
c = 0;
|
||||||
|
++r;
|
||||||
|
}
|
||||||
|
else // printable char
|
||||||
|
{
|
||||||
|
++c;
|
||||||
|
if (c == self->termWidth)
|
||||||
|
{
|
||||||
|
c = 0;
|
||||||
|
++r;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// p points to the first char NOT to be printed.
|
||||||
|
|
||||||
|
self->printPrefix(begin, p - begin);
|
||||||
|
|
||||||
|
if (r < self->termHeight)
|
||||||
|
self->clrtoeol();
|
||||||
|
if (r < self->termHeight - 1)
|
||||||
|
{
|
||||||
|
self->locate(0, r + 1);
|
||||||
|
self->clrtoeol();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_fillWindowFromHomeToRow(size_t firstLogicalCharOffsetToPrint, byte numRowsToFill)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
if (numRowsToFill == 0)
|
||||||
|
return;
|
||||||
|
self->locate(0, 0);
|
||||||
|
size_t offset = firstLogicalCharOffsetToPrint;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
size_t eolOffset = Ebitor_findEOL(offset);
|
||||||
|
while (eolOffset - offset >= self->termWidth) // if current row to be filled completely
|
||||||
|
{
|
||||||
|
self->printPrefix(self->bufferBegin + offset, self->termWidth);
|
||||||
|
if (--numRowsToFill == 0)
|
||||||
|
return;
|
||||||
|
offset += self->termWidth;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (offset != eolOffset)
|
||||||
|
self->printPrefix(self->bufferBegin + offset, eolOffset - offset);
|
||||||
|
self->print("\r");
|
||||||
|
if (--numRowsToFill == 0)
|
||||||
|
return;
|
||||||
|
if (eolOffset == self->bufferFilledSize) // if EOF instead of \r
|
||||||
|
break; // go blank remaining rows to fill
|
||||||
|
|
||||||
|
offset = eolOffset + 1; // pass \r
|
||||||
|
}
|
||||||
|
|
||||||
|
for ( ; numRowsToFill--; )
|
||||||
|
self->print("\r");
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_setLogicalCursorAtBeginning(void)
|
||||||
|
{
|
||||||
|
Ebitor_instance.cursorOffset = 0;
|
||||||
|
Ebitor_instance.savedCursorCol = 0;
|
||||||
|
Ebitor_instance.savedCursorRow = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Ebitor_getLogicalCursorOffset(void)
|
||||||
|
{
|
||||||
|
return Ebitor_instance.cursorOffset;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
Ebitor_refresh(byte cursorCol, byte cursorRow)
|
||||||
|
{
|
||||||
|
Ebitor_instance.clear();
|
||||||
|
|
||||||
|
// Reprint the window starting at the logical offset that corresponds to
|
||||||
|
// the top-left corner of the terminal.
|
||||||
|
//
|
||||||
|
size_t homeOffset = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
|
||||||
|
Ebitor_fillTerminalToBottom(homeOffset, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
Ebitor_processLeftArrow(byte cursorCol, byte cursorRow)
|
||||||
|
{
|
||||||
|
assert(Ebitor_instance.mode == MODE_COMMAND);
|
||||||
|
|
||||||
|
if (Ebitor_instance.cursorOffset == 0) // if already at start of edit buffer
|
||||||
|
return; // nothing to do
|
||||||
|
|
||||||
|
if (cursorCol > 0) // if not at leftmost window column
|
||||||
|
{
|
||||||
|
Ebitor_instance.locate(cursorCol - 1, cursorRow);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// Cursor at leftmost window column.
|
||||||
|
// If at start of logical line, go to end of previous logical line.
|
||||||
|
// Otherwise, scroll up if needed, then go to rightmost window column
|
||||||
|
// on previous window row.
|
||||||
|
//
|
||||||
|
size_t solOffset = Ebitor_findSOL(Ebitor_instance.cursorOffset);
|
||||||
|
if (solOffset == Ebitor_instance.cursorOffset) // if at start of logical line
|
||||||
|
{
|
||||||
|
size_t prevSOLOffset = Ebitor_findPreviousSOL(Ebitor_instance.cursorOffset);
|
||||||
|
assert(prevSOLOffset != Ebitor_instance.cursorOffset); // previous line found, because cursorOffset not 0
|
||||||
|
size_t prevLineLen = solOffset - prevSOLOffset - 1; // minus one to exclude \r
|
||||||
|
byte lastRowLen = (byte) (prevLineLen % Ebitor_instance.termWidth); // e.g., if 37-char logical line on 32-column terminal, then 5
|
||||||
|
if (cursorRow == 0)
|
||||||
|
{
|
||||||
|
// At top row of window. There is a line before the current one, b/c cursorOffset > 0.
|
||||||
|
// Scroll the window down one row.
|
||||||
|
// Print the last 'lastRowLen' chars of that line. Leave the cursor after these.
|
||||||
|
size_t offsetToPrint = Ebitor_instance.cursorOffset - 1 - lastRowLen;
|
||||||
|
Ebitor_instance.scrollTerminalDown(1);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + offsetToPrint, lastRowLen);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
--cursorRow;
|
||||||
|
Ebitor_instance.locate(lastRowLen, cursorRow);
|
||||||
|
}
|
||||||
|
else // not at start of logical line
|
||||||
|
{
|
||||||
|
// Current logical line starts before cursorOffset.
|
||||||
|
if (cursorRow == 0)
|
||||||
|
{
|
||||||
|
// Cursor is home. Print full window row of chars from current logical line.
|
||||||
|
Ebitor_instance.scrollTerminalDown(1);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + (Ebitor_instance.cursorOffset - Ebitor_instance.termWidth), Ebitor_instance.termWidth);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
--cursorRow;
|
||||||
|
Ebitor_instance.locate(Ebitor_instance.termWidth - 1, cursorRow);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
--Ebitor_instance.cursorOffset;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
Ebitor_processRightArrow(byte cursorCol, byte cursorRow)
|
||||||
|
{
|
||||||
|
assert(Ebitor_instance.mode == MODE_COMMAND);
|
||||||
|
|
||||||
|
if (Ebitor_instance.cursorOffset == Ebitor_instance.bufferFilledSize) // if already at EOF
|
||||||
|
return; // nothing to do
|
||||||
|
|
||||||
|
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
|
||||||
|
if (Ebitor_instance.cursorOffset == eolOffset // if at end of logical line
|
||||||
|
|| cursorCol + 1 == Ebitor_instance.termWidth) // or if at rightmost window column
|
||||||
|
{
|
||||||
|
if (cursorRow == Ebitor_instance.termHeight - 1) // if starting on last window row
|
||||||
|
{
|
||||||
|
Ebitor_instance.scrollTerminalUp(1);
|
||||||
|
Ebitor_instance.locate(0, cursorRow);
|
||||||
|
|
||||||
|
// If the move still leaves the logical cursor in the current logical line,
|
||||||
|
// then print then the next row of the current logical line.
|
||||||
|
// Otherwise, print the first row of the next logical line.
|
||||||
|
//
|
||||||
|
if (Ebitor_instance.cursorOffset < eolOffset)
|
||||||
|
{
|
||||||
|
size_t nextCharOffset = Ebitor_instance.cursorOffset + 1;
|
||||||
|
size_t lineLenFromNextChar = eolOffset - nextCharOffset;
|
||||||
|
byte toPrint = (byte) min(lineLenFromNextChar, (size_t) Ebitor_instance.termWidth);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + nextCharOffset, toPrint);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
size_t nextLineOffset = eolOffset + 1; // after the \r
|
||||||
|
size_t nextLineLen = Ebitor_findEOL(nextLineOffset) - nextLineOffset;
|
||||||
|
byte charsOnFirstRow = (byte) min(nextLineLen, (size_t) Ebitor_instance.termWidth);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + nextLineOffset, charsOnFirstRow);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
++cursorRow;
|
||||||
|
|
||||||
|
cursorCol = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
++cursorCol; // move cursor right
|
||||||
|
|
||||||
|
assert(cursorRow < Ebitor_instance.termHeight);
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
|
||||||
|
++Ebitor_instance.cursorOffset;
|
||||||
|
assert(Ebitor_instance.cursorOffset <= Ebitor_instance.bufferFilledSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// May change *cursorCol and *cursorRow.
|
||||||
|
// Does not change any fields of Ebitor_instance.
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
Ebitor_scrollDownAndPrintRow(byte *cursorRow, size_t newOffsetToPrintFrom, size_t numCharsToPrint, BOOL affectTerminal)
|
||||||
|
{
|
||||||
|
if (*cursorRow == 0) // if cursor is on top row of terminal
|
||||||
|
{
|
||||||
|
Ebitor_instance.scrollTerminalDown(1); // scroll terminal down to free top row
|
||||||
|
|
||||||
|
if (affectTerminal)
|
||||||
|
{
|
||||||
|
// Print the previous logical line on the top terminal row,
|
||||||
|
// or a portion of that line if it is longer than a terminal row.
|
||||||
|
//
|
||||||
|
Ebitor_instance.locate(0, *cursorRow);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + newOffsetToPrintFrom, numCharsToPrint);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
assert(*cursorRow > 0);
|
||||||
|
--*cursorRow;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
Ebitor_processUpArrow(byte cursorCol, byte cursorRow, BOOL affectTerminal)
|
||||||
|
{
|
||||||
|
assert(Ebitor_instance.mode == MODE_COMMAND);
|
||||||
|
|
||||||
|
// Do nothing if already on 1st logical line.
|
||||||
|
//
|
||||||
|
size_t solOffset = Ebitor_findSOL(Ebitor_instance.cursorOffset);
|
||||||
|
|
||||||
|
// If the current logical line starts before the cursor row, go up in that logical line.
|
||||||
|
//
|
||||||
|
size_t newCursorOffset;
|
||||||
|
if (Ebitor_instance.cursorOffset - solOffset >= Ebitor_instance.termWidth)
|
||||||
|
{
|
||||||
|
// Current logical line starts before cursor row.
|
||||||
|
// Place cursor earlier in current logical line.
|
||||||
|
//
|
||||||
|
newCursorOffset = Ebitor_instance.cursorOffset - Ebitor_instance.termWidth;
|
||||||
|
|
||||||
|
Ebitor_scrollDownAndPrintRow(&cursorRow, newCursorOffset, Ebitor_instance.termWidth, affectTerminal);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// Cursor is on first window row of current logical line.
|
||||||
|
// Place cursor on last window row of preceding logical line, if any.
|
||||||
|
//
|
||||||
|
if (solOffset == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
size_t prevSOLOffset = Ebitor_findPreviousSOL(solOffset);
|
||||||
|
assert(prevSOLOffset < solOffset);
|
||||||
|
size_t prevLineLen = solOffset - prevSOLOffset - 1; // exclude \r
|
||||||
|
byte charsOnLastRow = (byte) (prevLineLen % Ebitor_instance.termWidth); // after last char of previous line
|
||||||
|
size_t offsetOfLastRowOfPrevLine = solOffset - 1 - charsOnLastRow;
|
||||||
|
|
||||||
|
Ebitor_scrollDownAndPrintRow(&cursorRow, offsetOfLastRowOfPrevLine, charsOnLastRow, affectTerminal);
|
||||||
|
|
||||||
|
if (charsOnLastRow < cursorCol) // avoid putting cursor in empty space
|
||||||
|
cursorCol = charsOnLastRow;
|
||||||
|
|
||||||
|
newCursorOffset = offsetOfLastRowOfPrevLine + cursorCol;
|
||||||
|
}
|
||||||
|
Ebitor_instance.cursorOffset = newCursorOffset; // move the logical cursor
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// May change *cursorCol and *cursorRow.
|
||||||
|
// Does not change any fields of Ebitor_instance.
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
Ebitor_scrollUpAndPrintRow(byte *cursorCol, byte *cursorRow, size_t newOffsetToPrintFrom, byte numCharsToPrint, BOOL affectTerminal)
|
||||||
|
{
|
||||||
|
if (*cursorRow == Ebitor_instance.termHeight - 1) // scroll if cursor on last window row
|
||||||
|
{
|
||||||
|
if (affectTerminal)
|
||||||
|
{
|
||||||
|
Ebitor_instance.scrollTerminalUp(1);
|
||||||
|
Ebitor_instance.locate(0, *cursorRow);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + newOffsetToPrintFrom, numCharsToPrint);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
++*cursorRow;
|
||||||
|
assert(*cursorRow < Ebitor_instance.termHeight);
|
||||||
|
|
||||||
|
if (*cursorCol > numCharsToPrint) // avoid putting cursor in empty space
|
||||||
|
*cursorCol = numCharsToPrint;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
Ebitor_processDownArrow(byte cursorCol, byte cursorRow, BOOL affectTerminal)
|
||||||
|
{
|
||||||
|
assert(Ebitor_instance.mode == MODE_COMMAND);
|
||||||
|
|
||||||
|
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
|
||||||
|
|
||||||
|
// If the current logical line has characters beyond the current cursor row,
|
||||||
|
// move down this logical line.
|
||||||
|
//
|
||||||
|
size_t newCursorOffset;
|
||||||
|
if (cursorCol + (eolOffset - Ebitor_instance.cursorOffset) >= Ebitor_instance.termWidth)
|
||||||
|
{
|
||||||
|
const size_t newOffsetToPrintFrom = Ebitor_instance.cursorOffset - cursorCol + Ebitor_instance.termWidth;
|
||||||
|
const byte charsOnNewRow = (byte) min(eolOffset - newOffsetToPrintFrom, (size_t) Ebitor_instance.termWidth);
|
||||||
|
|
||||||
|
Ebitor_scrollUpAndPrintRow(&cursorCol, &cursorRow, newOffsetToPrintFrom, charsOnNewRow, affectTerminal);
|
||||||
|
|
||||||
|
newCursorOffset = min(Ebitor_instance.cursorOffset + Ebitor_instance.termWidth, eolOffset);
|
||||||
|
}
|
||||||
|
else if (eolOffset < Ebitor_instance.bufferFilledSize) // logical line ends on current window row, so if it has a \r:
|
||||||
|
{
|
||||||
|
assert(Ebitor_instance.bufferBegin[eolOffset] == '\r');
|
||||||
|
const size_t newOffsetToPrintFrom = eolOffset + 1; // after the \r
|
||||||
|
assert(newOffsetToPrintFrom <= Ebitor_instance.bufferFilledSize);
|
||||||
|
const size_t nextLineLen = Ebitor_findEOL(newOffsetToPrintFrom) - newOffsetToPrintFrom;
|
||||||
|
const byte charsOnNewRow = (byte) min(nextLineLen, (size_t) Ebitor_instance.termWidth);
|
||||||
|
|
||||||
|
Ebitor_scrollUpAndPrintRow(&cursorCol, &cursorRow, newOffsetToPrintFrom, charsOnNewRow, affectTerminal);
|
||||||
|
|
||||||
|
newCursorOffset = newOffsetToPrintFrom + cursorCol; // move the logical cursor
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return;
|
||||||
|
|
||||||
|
Ebitor_instance.cursorOffset = newCursorOffset;
|
||||||
|
if (affectTerminal)
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_processUpOrDownArrowsAndRefresh(BOOL isUpArrow, size_t numRepetitions)
|
||||||
|
{
|
||||||
|
Ebitor_locateCursorAtSavedPosition();
|
||||||
|
|
||||||
|
byte cursorCol, cursorRow;
|
||||||
|
Ebitor_instance.getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
|
||||||
|
Ebitor_startCommandMode();
|
||||||
|
|
||||||
|
// Point to the right arrow processing function, depending on isUpArrow.
|
||||||
|
void (*processArrow)(byte cursorCol, byte cursorRow, BOOL affectTerminal) = isUpArrow ? Ebitor_processUpArrow : Ebitor_processDownArrow;
|
||||||
|
|
||||||
|
for ( ; numRepetitions--; )
|
||||||
|
(*processArrow)(cursorCol, cursorRow, FALSE); // do not affect terminal
|
||||||
|
|
||||||
|
Ebitor_scrollToShowLogicalOffset(Ebitor_instance.cursorOffset, 0);
|
||||||
|
Ebitor_saveCursorPosition();
|
||||||
|
|
||||||
|
Ebitor_refresh(Ebitor_instance.savedCursorCol, Ebitor_instance.savedCursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// key: Value returned by a function of type ebitor_waitKeyFunc.
|
||||||
|
//
|
||||||
|
void
|
||||||
|
Ebitor_processKey(word key)
|
||||||
|
{
|
||||||
|
byte cursorCol, cursorRow;
|
||||||
|
Ebitor_instance.getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
|
||||||
|
switch (key)
|
||||||
|
{
|
||||||
|
case '\b': // erase previous char
|
||||||
|
Ebitor_processBackspace(cursorCol, cursorRow);
|
||||||
|
break;
|
||||||
|
case '\r':
|
||||||
|
{
|
||||||
|
Ebitor_instance.clrtoeol();
|
||||||
|
|
||||||
|
if (cursorRow < Ebitor_instance.termHeight - 1) // if not on last window row
|
||||||
|
++cursorRow;
|
||||||
|
else // on last window row
|
||||||
|
Ebitor_instance.scrollTerminalUp(1);
|
||||||
|
|
||||||
|
Ebitor_fillTerminalToBottom(Ebitor_instance.cursorOffset, cursorRow);
|
||||||
|
Ebitor_instance.locate(0, cursorRow);
|
||||||
|
|
||||||
|
Ebitor_insertChar('\r');
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case ebitor_KEY_ARROW_LEFT:
|
||||||
|
// Go to command mode if not already in it.
|
||||||
|
// This flushes the insert buffer, if any.
|
||||||
|
//
|
||||||
|
Ebitor_startCommandMode();
|
||||||
|
|
||||||
|
Ebitor_processLeftArrow(cursorCol, cursorRow);
|
||||||
|
break;
|
||||||
|
case ebitor_KEY_ARROW_RIGHT:
|
||||||
|
Ebitor_startCommandMode();
|
||||||
|
Ebitor_processRightArrow(cursorCol, cursorRow);
|
||||||
|
break;
|
||||||
|
case ebitor_KEY_ARROW_UP:
|
||||||
|
Ebitor_startCommandMode();
|
||||||
|
Ebitor_processUpArrow(cursorCol, cursorRow, TRUE);
|
||||||
|
break;
|
||||||
|
case ebitor_KEY_ARROW_DOWN:
|
||||||
|
Ebitor_startCommandMode();
|
||||||
|
Ebitor_processDownArrow(cursorCol, cursorRow, TRUE);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
Ebitor_processPrintableChar(key, cursorCol, cursorRow);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_locateCursorAtSavedPosition(void)
|
||||||
|
{
|
||||||
|
Ebitor_instance.locate(Ebitor_instance.savedCursorCol, Ebitor_instance.savedCursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_saveCursorPosition(void)
|
||||||
|
{
|
||||||
|
Ebitor_instance.getCursorPos(&Ebitor_instance.savedCursorCol, &Ebitor_instance.savedCursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_processEditing(BOOL startWithRefresh)
|
||||||
|
{
|
||||||
|
if (startWithRefresh)
|
||||||
|
Ebitor_refresh(Ebitor_instance.savedCursorCol, Ebitor_instance.savedCursorRow);
|
||||||
|
|
||||||
|
Ebitor_locateCursorAtSavedPosition();
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
assert(Ebitor_instance.cursorOffset <= Ebitor_instance.bufferFilledSize);
|
||||||
|
|
||||||
|
word key = Ebitor_instance.waitKey();
|
||||||
|
if (key == ebitor_KEY_ESCAPE)
|
||||||
|
break;
|
||||||
|
|
||||||
|
Ebitor_processKey(key);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ebitor_startCommandMode(); // put inserted chars in edit buffer
|
||||||
|
|
||||||
|
// Remember the cursor position for the next time this method is called.
|
||||||
|
//
|
||||||
|
Ebitor_saveCursorPosition();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Determines which logical offset is currently at position (0, 0) on the terminal,
|
||||||
|
// assuming that the current logical cursor is at terminal position (cursorCol, cursorRow).
|
||||||
|
//
|
||||||
|
size_t
|
||||||
|
Ebitor_getLogicalOffsetAtHome(byte cursorCol, byte cursorRow)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
Ebitor_startCommandMode(); // put insert buffer into edit buffer, so that all the text is contiguous
|
||||||
|
|
||||||
|
assert(self->cursorOffset >= cursorCol);
|
||||||
|
size_t offset = self->cursorOffset - cursorCol; // initialize at start of terminal row
|
||||||
|
//printf("[gLOAH(%u,%u):co=%u,o=%u]", cursorCol, cursorRow, self->cursorOffset, offset);
|
||||||
|
for (;;) // bring 'offset' back to the logical offset that is at (0, 0) on the terminal
|
||||||
|
{
|
||||||
|
//printf("(cr=%u,o=%u)", cursorRow, offset);
|
||||||
|
if (cursorRow == 0)
|
||||||
|
return offset;
|
||||||
|
if (offset == 0)
|
||||||
|
return 0;
|
||||||
|
//printf("(CHAR %u)", self->bufferBegin[offset - 1]);
|
||||||
|
if (self->bufferBegin[offset - 1] != '\r')
|
||||||
|
{
|
||||||
|
offset -= self->termWidth; // go back to start of terminal row
|
||||||
|
--cursorRow;
|
||||||
|
}
|
||||||
|
else // if offset is at the start of a logical line
|
||||||
|
{
|
||||||
|
//printf("(FOR)");
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
size_t startOfLogicalLine = Ebitor_findSOL(offset - 1); // start of previous line
|
||||||
|
size_t logicalLineLen = offset - 1 - startOfLogicalLine;
|
||||||
|
//printf("(soll=%u,lll=%u)", startOfLogicalLine, logicalLineLen);
|
||||||
|
offset -= 1 + logicalLineLen % self->termWidth; // go back to \r, then back to start of row
|
||||||
|
--cursorRow;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
if (cursorRow == 0)
|
||||||
|
return offset;
|
||||||
|
if (offset == startOfLogicalLine)
|
||||||
|
break; // reached start of logical line
|
||||||
|
|
||||||
|
// In the current logical line, terminal location (0, cursorRow) is now preceded by
|
||||||
|
// a number of logical chars divisible by termWidth.
|
||||||
|
assert((offset - startOfLogicalLine) % self->termWidth == 0);
|
||||||
|
offset -= self->termWidth;
|
||||||
|
--cursorRow;
|
||||||
|
}
|
||||||
|
//printf("[cr=%u,o=%u]", cursorRow, offset);
|
||||||
|
assert(cursorRow > 0);
|
||||||
|
if (offset == 0)
|
||||||
|
return 0;
|
||||||
|
//printf("[%u]", self->bufferBegin[offset - 1]);
|
||||||
|
assert(self->bufferBegin[offset - 1] == '\r');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_getLogicalOffsetBelowWindow(size_t homeOffset, size_t *resultOffset, BOOL *isInWindow)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
byte termRow = 0;
|
||||||
|
size_t offset = homeOffset;
|
||||||
|
byte numEditorLines = self->termHeight;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
const size_t eolOffset = Ebitor_findEOL(offset);
|
||||||
|
while (eolOffset - offset >= self->termWidth)
|
||||||
|
{
|
||||||
|
offset += self->termWidth;
|
||||||
|
++termRow;
|
||||||
|
if (termRow >= numEditorLines) // if off window
|
||||||
|
{
|
||||||
|
*resultOffset = offset;
|
||||||
|
*isInWindow = FALSE;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (eolOffset == self->bufferFilledSize)
|
||||||
|
{
|
||||||
|
*resultOffset = eolOffset;
|
||||||
|
*isInWindow = TRUE;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
assert(self->bufferBegin[eolOffset] == '\r');
|
||||||
|
offset = eolOffset + 1; // pass '\r', which goes to next row
|
||||||
|
++termRow;
|
||||||
|
if (termRow >= numEditorLines) // if off window
|
||||||
|
{
|
||||||
|
*resultOffset = offset;
|
||||||
|
*isInWindow = FALSE;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
char
|
||||||
|
Ebitor_isRegionVisible(size_t regionOffset, size_t regionLength, byte cursorCol, byte cursorRow,
|
||||||
|
size_t *homeOffset, size_t *firstOffWindowOffset)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
//printf("[iRV(%u,%u,%u,%u): BFS=%u]",
|
||||||
|
// regionOffset, regionLength, cursorCol, cursorRow, self->bufferFilledSize);
|
||||||
|
assert(regionOffset + regionLength <= self->bufferFilledSize);
|
||||||
|
assert(self->insertBuffer.size == 0);
|
||||||
|
|
||||||
|
*homeOffset = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
|
||||||
|
if (regionOffset < *homeOffset) // if region is entirely or partly before the text that starts at home
|
||||||
|
return -1; // region is (entirely or partly) before displayed text
|
||||||
|
|
||||||
|
// Get the offset of the first character that is below the bottom of the terminal.
|
||||||
|
//
|
||||||
|
BOOL isInWindow;
|
||||||
|
Ebitor_getLogicalOffsetBelowWindow(*homeOffset, firstOffWindowOffset, &isInWindow);
|
||||||
|
|
||||||
|
if (!isInWindow && regionOffset + regionLength > *firstOffWindowOffset)
|
||||||
|
return +1; // region is (entirely or partly) after displayed text
|
||||||
|
|
||||||
|
return 0; // region is entirely in the displayed text
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Ebitor_countRowsToScrollDown(size_t logicalOffsetToShow, size_t homeOffset,
|
||||||
|
size_t *logicalOffsetAtStartOfTermRow)
|
||||||
|
{
|
||||||
|
// Count the number of terminal rows from logicalOffsetToShow to homeOffset.
|
||||||
|
// This is how many rows we need to scroll the terminal down.
|
||||||
|
//
|
||||||
|
assert(logicalOffsetToShow < homeOffset);
|
||||||
|
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
size_t solOffset = Ebitor_findSOL(logicalOffsetToShow);
|
||||||
|
|
||||||
|
// Bring logicalOffsetToShow back to the preceding logical position that is displayed
|
||||||
|
// at the start of a window row.
|
||||||
|
// We have: logicalOffsetToShow == solOffset + R * termWidth + C, where R >= 0 and C < termWidth.
|
||||||
|
// We replace logicalOffsetToShow with solOffset + R * termWidth.
|
||||||
|
// Example: A line has 67 chars and the terminal width is 32
|
||||||
|
// We have logicalOffsetToShow - solOffset == 67.
|
||||||
|
// 67 % 32 == 3, so we bring logicalOffsetToShow to 64.
|
||||||
|
//
|
||||||
|
*logicalOffsetAtStartOfTermRow = logicalOffsetToShow - (logicalOffsetToShow - solOffset) % self->termWidth;
|
||||||
|
|
||||||
|
size_t numTermRows = 0;
|
||||||
|
size_t offset = *logicalOffsetAtStartOfTermRow;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
const size_t eolOffset = Ebitor_findEOL(offset);
|
||||||
|
while (eolOffset - offset >= self->termWidth)
|
||||||
|
{
|
||||||
|
offset += self->termWidth;
|
||||||
|
++numTermRows;
|
||||||
|
if (offset == homeOffset)
|
||||||
|
return numTermRows;
|
||||||
|
}
|
||||||
|
offset = eolOffset + 1; // pass \r
|
||||||
|
++numTermRows;
|
||||||
|
if (offset == homeOffset)
|
||||||
|
return numTermRows;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Ebitor_countRowsToScrollUp(size_t logicalOffsetToShow, size_t firstOffWindowOffset)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
assert(firstOffWindowOffset <= logicalOffsetToShow);
|
||||||
|
assert((firstOffWindowOffset - Ebitor_findSOL(firstOffWindowOffset)) % self->termWidth == 0);
|
||||||
|
|
||||||
|
size_t numTermRows = 1;
|
||||||
|
|
||||||
|
size_t offset = firstOffWindowOffset;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
assert((offset - Ebitor_findSOL(offset)) % self->termWidth == 0);
|
||||||
|
|
||||||
|
if (offset == logicalOffsetToShow) // if target reached
|
||||||
|
return numTermRows;
|
||||||
|
|
||||||
|
const size_t eolOffset = Ebitor_findEOL(offset);
|
||||||
|
|
||||||
|
while (eolOffset - offset >= self->termWidth) // as long as term row at 'offset' is filled
|
||||||
|
{
|
||||||
|
if (logicalOffsetToShow - offset < self->termWidth)
|
||||||
|
return numTermRows; // logicalOffsetToShow is on current row
|
||||||
|
++numTermRows; // logicalOffsetToShow is on next row or later
|
||||||
|
offset += self->termWidth;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Term row at 'offset' is not filled completely, so the current logical line ends on this row.
|
||||||
|
//
|
||||||
|
if (logicalOffsetToShow <= eolOffset) // if target logical position is on current row
|
||||||
|
return numTermRows;
|
||||||
|
offset = eolOffset;
|
||||||
|
if (offset == self->bufferFilledSize) // if EOF
|
||||||
|
return numTermRows; // can't scroll more than this
|
||||||
|
|
||||||
|
++offset; // pass the \r; now at position that would be at start of window row
|
||||||
|
++numTermRows;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_locateAndSavePos(byte col, byte row)
|
||||||
|
{
|
||||||
|
Ebitor_instance.locate(col, row);
|
||||||
|
Ebitor_instance.savedCursorCol = col;
|
||||||
|
Ebitor_instance.savedCursorRow = row;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// startOfRowOffset: Logical offset of a character that is in column 0.
|
||||||
|
// Returns the logical offset of another character down the text that is also in column 0.
|
||||||
|
// If there are not enough rows, stops at the last row.
|
||||||
|
//
|
||||||
|
size_t
|
||||||
|
Ebitor_goDownRows(size_t startOfRowOffset, size_t numRows)
|
||||||
|
{
|
||||||
|
size_t offset = startOfRowOffset;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
size_t eolOffset = Ebitor_findEOL(offset);
|
||||||
|
while (eolOffset - offset >= Ebitor_instance.termWidth) // while terminal row filled
|
||||||
|
{
|
||||||
|
offset += Ebitor_instance.termWidth;
|
||||||
|
if (--numRows == 0)
|
||||||
|
return offset;
|
||||||
|
}
|
||||||
|
// EOL is on current row.
|
||||||
|
if (eolOffset == Ebitor_instance.bufferFilledSize) // if EOL is EOF
|
||||||
|
return offset;
|
||||||
|
offset = eolOffset + 1; // pass \r
|
||||||
|
// 'offset' is now at start of next logical line, which is displayed at column 0.
|
||||||
|
if (--numRows == 0)
|
||||||
|
return offset;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,285 @@
|
|||||||
|
/* Ebitor.h
|
||||||
|
|
||||||
|
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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _H_Ebitor
|
||||||
|
#define _H_Ebitor
|
||||||
|
|
||||||
|
#ifdef _CMOC_VERSION_ /* If compiling with CMOC. */
|
||||||
|
#include <coco.h>
|
||||||
|
|
||||||
|
#else /* To compile with GCC (useful to get more warnings). */
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
typedef uint8_t byte;
|
||||||
|
typedef uint16_t word;
|
||||||
|
typedef uint8_t BOOL;
|
||||||
|
enum { FALSE, TRUE };
|
||||||
|
void *memichr(const void *s, int c, size_t n);
|
||||||
|
int memicmp(const void *s1, const void *s2, size_t n);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
// Control codes, >= 256.
|
||||||
|
// Characters in 32..126 and 128..255 are assumed to be printable.
|
||||||
|
//
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
ebitor_KEY_ARROW_LEFT = 256,
|
||||||
|
ebitor_KEY_ARROW_RIGHT,
|
||||||
|
ebitor_KEY_ARROW_UP,
|
||||||
|
ebitor_KEY_ARROW_DOWN,
|
||||||
|
ebitor_KEY_ESCAPE,
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
struct Ebitor;
|
||||||
|
|
||||||
|
|
||||||
|
// Clear the entire terminal.
|
||||||
|
// Does not move the cursor.
|
||||||
|
//
|
||||||
|
typedef void (*ebitor_clear)(void);
|
||||||
|
|
||||||
|
// Position the terminal's cursor.
|
||||||
|
// column, row: Start at 0.
|
||||||
|
//
|
||||||
|
typedef void (*ebitor_locateFunc)(byte column, byte row);
|
||||||
|
|
||||||
|
// Obtains the current position of the terminal's cursor.
|
||||||
|
// *column, *row: Will start at 0.
|
||||||
|
//
|
||||||
|
typedef void (*ebitor_getCursorPosFunc)(byte *column, byte *row);
|
||||||
|
|
||||||
|
// Prints an ASCIIZ to the terminal.
|
||||||
|
// Character '\r' does a carriage return and line feed AND clears
|
||||||
|
// the rest of the row it is applied to (with spaces).
|
||||||
|
// Returns FALSE if the printing reached the end of the terminal.
|
||||||
|
// In this case, the cursor can be assumed to be at the first
|
||||||
|
// position of the last row of the window.
|
||||||
|
//
|
||||||
|
typedef BOOL (*ebitor_printFunc)(const char *str);
|
||||||
|
|
||||||
|
// Prints a given number of characters to the terminal.
|
||||||
|
// Character '\r' does a carriage return and line feed AND clears
|
||||||
|
// the rest of the row it is applied to (with spaces).
|
||||||
|
// No other control code is supported.
|
||||||
|
// Returns FALSE if the printing reached the end of the terminal.
|
||||||
|
//
|
||||||
|
typedef BOOL (*ebitor_printPrefixFunc)(const char *str, size_t prefixLength);
|
||||||
|
|
||||||
|
// Clears the current terminal line from the cursor position to the end of the terminal line.
|
||||||
|
// Does not move the terminal's cursor.
|
||||||
|
//
|
||||||
|
typedef void (*ebitor_clrtoeolFunc)(void);
|
||||||
|
|
||||||
|
// Moves the contents of the terminal up by the given number of rows.
|
||||||
|
// Fills the bottom row(s) of the terminal with spaces.
|
||||||
|
// Does not move the terminal's cursor.
|
||||||
|
//
|
||||||
|
typedef void (*ebitor_scrollTerminalUpFunc)(byte numRows);
|
||||||
|
|
||||||
|
// Moves the contents of the terminal down by the given number of rows.
|
||||||
|
// Fills the top row(s) of the terminal with spaces.
|
||||||
|
// Does not move the terminal's cursor.
|
||||||
|
//
|
||||||
|
typedef void (*ebitor_scrollTerminalDownFunc)(byte numRows);
|
||||||
|
|
||||||
|
// Blocks while waiting for a key press on the terminal.
|
||||||
|
// Returns a printable character, or a control character (e.g., '\b', '\r') or
|
||||||
|
// a control code (see the ebitor_KEY_* enum).
|
||||||
|
//
|
||||||
|
typedef word (*ebitor_waitKeyFunc)(void);
|
||||||
|
|
||||||
|
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
INSERT_BUFFER_SIZE = 64, // Must be >= 2.
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
typedef struct InsertBuffer
|
||||||
|
{
|
||||||
|
char buffer[INSERT_BUFFER_SIZE];
|
||||||
|
size_t size; // prefix of buffer[] that is filled
|
||||||
|
} InsertBuffer;
|
||||||
|
|
||||||
|
|
||||||
|
typedef struct Ebitor
|
||||||
|
{
|
||||||
|
byte termWidth; // number of columns of the terminal (all the columns used)
|
||||||
|
byte termHeight; // number of rows of the terminal (all the rows are used)
|
||||||
|
char *bufferBegin;
|
||||||
|
char *bufferEnd;
|
||||||
|
size_t bufferFilledSize; // prefix of [bufferBegin, bufferEnd) that is filled
|
||||||
|
size_t cursorOffset; // in [bufferBegin, bufferEnd); does not count the chars in insertBuffer
|
||||||
|
byte savedCursorCol; // cursor column when editing stopped
|
||||||
|
byte savedCursorRow; // cursor row when editing stopped
|
||||||
|
byte mode; // MODE_* enum value
|
||||||
|
InsertBuffer insertBuffer;
|
||||||
|
|
||||||
|
// Terminal-specific functions.
|
||||||
|
|
||||||
|
ebitor_clear clear;
|
||||||
|
ebitor_locateFunc locate;
|
||||||
|
ebitor_printFunc print;
|
||||||
|
ebitor_printPrefixFunc printPrefix;
|
||||||
|
ebitor_clrtoeolFunc clrtoeol;
|
||||||
|
ebitor_scrollTerminalUpFunc scrollTerminalUp;
|
||||||
|
ebitor_scrollTerminalDownFunc scrollTerminalDown;
|
||||||
|
ebitor_waitKeyFunc waitKey;
|
||||||
|
ebitor_getCursorPosFunc getCursorPos;
|
||||||
|
|
||||||
|
} Ebitor;
|
||||||
|
|
||||||
|
|
||||||
|
// termWidth: Number of columns of the terminal (all the columns are used).
|
||||||
|
// termHeight: Number of rows of the terminal (all the rows are used).
|
||||||
|
// See the comments above concerning the behavior expected of the callbacks.
|
||||||
|
//
|
||||||
|
void Ebitor_init(char *bufferBegin, size_t bufferSize,
|
||||||
|
byte termWidth, byte termHeight,
|
||||||
|
ebitor_clear clear,
|
||||||
|
ebitor_locateFunc locate,
|
||||||
|
ebitor_getCursorPosFunc getCursorPos,
|
||||||
|
ebitor_printFunc print,
|
||||||
|
ebitor_printPrefixFunc printPrefix,
|
||||||
|
ebitor_clrtoeolFunc clrtoeol,
|
||||||
|
ebitor_scrollTerminalUpFunc scrollTerminalUp,
|
||||||
|
ebitor_scrollTerminalDownFunc scrollTerminalDown,
|
||||||
|
ebitor_waitKeyFunc waitKey);
|
||||||
|
|
||||||
|
|
||||||
|
// Return the address of the lone instance of struct Ebitor.
|
||||||
|
// Should be used only for self-testing code and/or debugging.
|
||||||
|
//
|
||||||
|
Ebitor *Ebitor_getInstance(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Tells the editor how much text is currently in its buffer.
|
||||||
|
// Typically called after filling the buffer passed to Ebitor_init()
|
||||||
|
// from a file.
|
||||||
|
// Also puts the cursor at the beginning.
|
||||||
|
// newLength: Must not exceed the bufferSize parameter passed
|
||||||
|
// to Ebitor_init().
|
||||||
|
//
|
||||||
|
void Ebitor_setContentLength(size_t newLength);
|
||||||
|
|
||||||
|
|
||||||
|
size_t Ebitor_getContentLength(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Processes the user's keyboard commands to edit the text.
|
||||||
|
// Invokes the callbacks given to Ebitor_init().
|
||||||
|
// Saves the terminal cursor position upon exiting.
|
||||||
|
// The next call will start by restoring the terminal cursor to the saved position.
|
||||||
|
// Other functions can affect the saved position, e.g., Ebitor_findStringAndScrollToShow().
|
||||||
|
// startWithRefresh: Start by filling the terminal with what is currently supposed to appear,
|
||||||
|
// depending on the position of the logical cursor and of the terminal cursor.
|
||||||
|
//
|
||||||
|
void Ebitor_processEditing(BOOL startWithRefresh);
|
||||||
|
|
||||||
|
|
||||||
|
// Processes the given key as if it had been typed by the user.
|
||||||
|
//
|
||||||
|
// key: Must be a printable character or an ebitor_KEY_* value, but NOT ebitor_KEY_ESCAPE.
|
||||||
|
//
|
||||||
|
// Ebitor_locateCursorAtSavedPosition() must be called before calling this function;
|
||||||
|
// then, this function can be called one or more times; when this sequence of calls
|
||||||
|
// is done, Ebitor_saveCursorPosition() must be called.
|
||||||
|
//
|
||||||
|
void Ebitor_processKey(word key);
|
||||||
|
|
||||||
|
|
||||||
|
// Simulate a user pressing the up or down arrow multiple times, then refreshes the terminal.
|
||||||
|
// When the number of repetitions is large, this function is more efficient than calling
|
||||||
|
// Ebitor_processKey() multiple times, because the terminal would get updated with each call
|
||||||
|
// to Ebitor_processKey().
|
||||||
|
// isUpArrow: TRUE to simulate an up arrow key, FALSE for a down arrow.
|
||||||
|
// numRepetitions: The number of times to repeat the specified arrow key.
|
||||||
|
// Allowed to be zero.
|
||||||
|
//
|
||||||
|
void Ebitor_processUpOrDownArrowsAndRefresh(BOOL isUpArrow, size_t numRepetitions);
|
||||||
|
|
||||||
|
|
||||||
|
// Remembers the current position of the cursor.
|
||||||
|
// The cursor can later be restored to that position by a call to Ebitor_locateCursorAtSavedPosition().
|
||||||
|
//
|
||||||
|
void Ebitor_saveCursorPosition(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Puts the cursor at the position saved by the most recent call to Ebitor_saveCursorPosition().
|
||||||
|
// The latter must have been called at least once.
|
||||||
|
//
|
||||||
|
void Ebitor_locateCursorAtSavedPosition(void);
|
||||||
|
|
||||||
|
|
||||||
|
size_t Ebitor_getLogicalCursorOffset(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Determines which logical offset is currently at position (0, 0) on the terminal.
|
||||||
|
//
|
||||||
|
size_t Ebitor_getLogicalOffsetAtHome(byte cursorCol, byte cursorRow);
|
||||||
|
|
||||||
|
|
||||||
|
// Also puts the terminal cursor at the home position.
|
||||||
|
//
|
||||||
|
void Ebitor_setLogicalCursorAtBeginning(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Searches for the string in strSearchedFor and if found, scrolls the terminal and
|
||||||
|
// positions the cursor so that the the found string is visible.
|
||||||
|
// If the string is not found, the terminal is not scrolled and the cursor is not moved.
|
||||||
|
// startLogicalOffset: Position in the text where to start the search.
|
||||||
|
// strSearchedFor: Non empty, NUL-terminated.
|
||||||
|
// foundLogicalOffset: (Must not be null.) Receives the logical position where the string
|
||||||
|
// was found, if TRUE is returned. Not filled if FALSE is returned.
|
||||||
|
// Returns TRUE if found, FALSE if not.
|
||||||
|
//
|
||||||
|
BOOL Ebitor_findStringAndScrollToShow(size_t startLogicalOffset, const char *strSearchedFor,
|
||||||
|
size_t *foundLogicalOffset);
|
||||||
|
|
||||||
|
|
||||||
|
// Locates the terminal cursor at the terminal location equivalent to logicalOffsetToShow.
|
||||||
|
// Makes this terminal cursor the currently saved one.
|
||||||
|
// Scrolls enough to make sure that 'lengthToShow' characters from logicalOffsetToShow
|
||||||
|
// are visible in the terminal.
|
||||||
|
// lengthToShow is allowed to be zero.
|
||||||
|
// This saved position will be used by the next call to Ebitor_processEditing().
|
||||||
|
// Puts the logical cursor at logicalOffsetToShow.
|
||||||
|
// Scrolls and/or redraws lines as necessary.
|
||||||
|
//
|
||||||
|
void Ebitor_scrollToShowLogicalOffset(size_t logicalOffsetToShow, size_t lengthToShow);
|
||||||
|
|
||||||
|
|
||||||
|
// Returns the offset of the start of the line that contains the given offset.
|
||||||
|
//
|
||||||
|
size_t Ebitor_findSOL(size_t startOffset);
|
||||||
|
|
||||||
|
|
||||||
|
// Returns the offset of the end-of-line delimiter of the line that contains the given offset.
|
||||||
|
// If the current line is the last one and has no such delimiter, then the length of the
|
||||||
|
// filled buffer is returned.
|
||||||
|
//
|
||||||
|
size_t Ebitor_findEOL(size_t startOffset);
|
||||||
|
|
||||||
|
|
||||||
|
void Ebitor_shutdown(void);
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* _H_Ebitor */
|
||||||
@@ -0,0 +1,105 @@
|
|||||||
|
/* Ebitor_private.h
|
||||||
|
|
||||||
|
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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _H_Ebitor_private
|
||||||
|
#define _H_Ebitor_private
|
||||||
|
|
||||||
|
#include "Ebitor.h"
|
||||||
|
|
||||||
|
#include <assert.h>
|
||||||
|
|
||||||
|
|
||||||
|
#define min(a, b) ((a) < (b) ? (a) : (b))
|
||||||
|
|
||||||
|
|
||||||
|
extern Ebitor Ebitor_instance;
|
||||||
|
|
||||||
|
|
||||||
|
void Ebitor_startCommandMode(void);
|
||||||
|
|
||||||
|
|
||||||
|
// key: Must be a printable character in 32..255.
|
||||||
|
//
|
||||||
|
void Ebitor_processPrintableChar(word key, byte cursorCol, byte cursorRow);
|
||||||
|
|
||||||
|
|
||||||
|
// Prints the edit buffer starting from firstLogicalCharOffsetToPrint and stopping
|
||||||
|
// when the end of the edit buffer or the end of the window has been reached.
|
||||||
|
// The printing starts at column 0 of firstRowToFill.
|
||||||
|
//
|
||||||
|
void Ebitor_fillTerminalToBottom(size_t firstLogicalCharOffsetToPrint, byte firstRowToFill);
|
||||||
|
|
||||||
|
|
||||||
|
// Does not move the logical cursor.
|
||||||
|
//
|
||||||
|
void Ebitor_insertChar(char c);
|
||||||
|
|
||||||
|
|
||||||
|
// Determines if the region of the text at 'regionOffset' and of the given 'regionLength'
|
||||||
|
// is entirely visible in the terminal, assuming that the cursor offset is at (cursorCol, cursorRow)
|
||||||
|
// on the terminal.
|
||||||
|
// Assumes that the region specification is valid, i.e., it is within the filled buffer.
|
||||||
|
// Assumes that the insert buffer is empty.
|
||||||
|
//
|
||||||
|
// *homeOffset gets filled by Ebitor_getLogicalOffsetAtHome().
|
||||||
|
// Returns -1 if region is (entirely or partly) before displayed text (*firstOffWindowOffset does NOT get filled).
|
||||||
|
// Returns +1 if region is (entirely or partly) after displayed text (*firstOffWindowOffset gets filled).
|
||||||
|
// Returns 0 if region is entirely in the displayed text (*firstOffWindowOffset gets filled).
|
||||||
|
//
|
||||||
|
char Ebitor_isRegionVisible(size_t regionOffset, size_t regionLength, byte cursorCol, byte cursorRow,
|
||||||
|
size_t *homeOffset, size_t *firstOffWindowOffset);
|
||||||
|
|
||||||
|
|
||||||
|
// firstOffWindowOffset: Must designate a position that would be displayed at the start of a window row.
|
||||||
|
//
|
||||||
|
size_t Ebitor_countRowsToScrollUp(size_t logicalOffsetToShow, size_t firstOffWindowOffset);
|
||||||
|
|
||||||
|
|
||||||
|
// Stores in *logicalOffsetAtStartOfTermRow the number rows by which the terminal
|
||||||
|
// must be scrolled down to show the given logical offset (logicalOffsetToShow) in the first row.
|
||||||
|
// homeOffset: Value obtained from Ebitor_getLogicalOffsetAtHome().
|
||||||
|
//
|
||||||
|
size_t Ebitor_countRowsToScrollDown(size_t logicalOffsetToShow, size_t homeOffset,
|
||||||
|
size_t *logicalOffsetAtStartOfTermRow);
|
||||||
|
|
||||||
|
|
||||||
|
void Ebitor_processBackspace(byte cursorCol, byte cursorRow);
|
||||||
|
|
||||||
|
|
||||||
|
// solOffset: Must be the start of the edit buffer or be preceded by an EOL terminator.
|
||||||
|
// Returns solOffset itself if no previous line.
|
||||||
|
//
|
||||||
|
size_t Ebitor_findPreviousSOL(size_t solOffset);
|
||||||
|
|
||||||
|
|
||||||
|
// firstLogicalCharOffsetToPrint: Must designate a character that is to appear at the start of a terminal row.
|
||||||
|
//
|
||||||
|
void Ebitor_fillWindowFromHomeToRow(size_t firstLogicalCharOffsetToPrint, byte numRowsToFill);
|
||||||
|
|
||||||
|
|
||||||
|
// startOfRowOffset: Logical offset of a character that is in column 0.
|
||||||
|
// Returns the logical offset of another character down the text that is also in column 0.
|
||||||
|
// If there are not enough rows, stops at the last row.
|
||||||
|
//
|
||||||
|
size_t Ebitor_goDownRows(size_t startOfRowOffset, size_t numRows);
|
||||||
|
|
||||||
|
|
||||||
|
void Ebitor_locateAndSavePos(byte col, byte row);
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* _H_Ebitor_private */
|
||||||
@@ -0,0 +1,216 @@
|
|||||||
|
# By Pierre Sarrazin <http://sarrazip.com/>
|
||||||
|
#
|
||||||
|
# This file is in the public domain.
|
||||||
|
#
|
||||||
|
# To compile the demo program and the test program, do "make" or "make all".
|
||||||
|
# To make a DECB floppy disk image with those programs, do "make dsk".
|
||||||
|
#
|
||||||
|
# The OS-9 version needs the BControl library, available from the CMOC home page.
|
||||||
|
# Before building, create a symlink named 'bcontrol' that points to the
|
||||||
|
# BControl source code.
|
||||||
|
# Then to build, do "make TARGET=os9".
|
||||||
|
# To deploy to the OS-9 hard disk image designtaed by OS9_DSK, make sure that
|
||||||
|
# the "os9" command of the ToolShed package (version 2.2. or later) is in the path,
|
||||||
|
# then do "make TARGET=os9 deploy".
|
||||||
|
|
||||||
|
PACKAGE = ebitor
|
||||||
|
VERSION = 0.1.1
|
||||||
|
|
||||||
|
TARGET = coco
|
||||||
|
|
||||||
|
# Sources and headers of the library.
|
||||||
|
CORELIBSRC = \
|
||||||
|
Ebitor.c \
|
||||||
|
findStringAndScrollToShow.c \
|
||||||
|
processPrintableChar.c \
|
||||||
|
processBackspace.c \
|
||||||
|
scrollToShowLogicalOffset.c
|
||||||
|
COCOLIBSRC = sg4term.c gimeterm.c
|
||||||
|
OS9LIBSRC = os9term.c
|
||||||
|
LIBSRC = $(CORELIBSRC)
|
||||||
|
CORELIBHEADERS = \
|
||||||
|
Ebitor.h \
|
||||||
|
Ebitor_private.h \
|
||||||
|
Window.h
|
||||||
|
COCOLIBHEADERS = sg4term.h gimeterm.h
|
||||||
|
OS9LIBHEADERS = os9term.h
|
||||||
|
LIBHEADERS = $(CORELIBHEADERS)
|
||||||
|
|
||||||
|
# Add platform-specific sources and headers.
|
||||||
|
ifeq "$(TARGET)" "coco"
|
||||||
|
LIBSRC += $(COCOLIBSRC)
|
||||||
|
LIBHEADERS += $(COCOLIBHEADERS)
|
||||||
|
else ifeq "$(TARGET)" "os9"
|
||||||
|
LIBSRC += $(OS9LIBSRC)
|
||||||
|
LIBHEADERS += $(OS9LIBHEADERS)
|
||||||
|
else ifeq "$(TARGET)" "usim"
|
||||||
|
LIBSRC += $(COCOLIBSRC)
|
||||||
|
LIBHEADERS += $(COCOLIBHEADERS)
|
||||||
|
endif
|
||||||
|
|
||||||
|
STATICLIB = lib$(PACKAGE).a
|
||||||
|
|
||||||
|
ifeq "$(TARGET)" "coco"
|
||||||
|
EXEEXT = .bin
|
||||||
|
else ifeq "$(TARGET)" "usim"
|
||||||
|
EXEEXT = .srec
|
||||||
|
else ifeq "$(TARGET)" "os9"
|
||||||
|
EXEEXT =
|
||||||
|
endif
|
||||||
|
|
||||||
|
# Interactive demo program where the user can use the editor.
|
||||||
|
ifneq "$(TARGET)" "usim"
|
||||||
|
DEMOSRC = ebitdemo.c
|
||||||
|
DEMOBIN = ebitdemo$(EXEEXT)
|
||||||
|
endif
|
||||||
|
|
||||||
|
ifeq "$(TARGET)" "coco"
|
||||||
|
|
||||||
|
# Minimal interactive demo that only runs in 32x16 under DECB.
|
||||||
|
SMOLDEMOSRC = smoldemo.c
|
||||||
|
SMOLDEMOBIN = smoldemo$(EXEEXT)
|
||||||
|
|
||||||
|
endif
|
||||||
|
|
||||||
|
ifneq "$(TARGET)" "os9"
|
||||||
|
|
||||||
|
# Non-interactive self-test suite (uses sg4term.c).
|
||||||
|
TESTSRC = ebittest.c
|
||||||
|
TESTBIN = ebittest$(EXEEXT)
|
||||||
|
|
||||||
|
endif
|
||||||
|
|
||||||
|
# List of sources and headers across all supported platforms.
|
||||||
|
DISTLIBSRC = $(CORELIBSRC) $(COCOLIBSRC) $(OS9LIBSRC)
|
||||||
|
DISTLIBHEADERS = $(CORELIBHEADERS) $(COCOLIBHEADERS) $(OS9LIBHEADERS)
|
||||||
|
DISTFILES = README.md Makefile $(DISTLIBHEADERS) $(DISTLIBSRC) $(DEMOSRC) $(SMOLDEMOSRC) $(TESTSRC)
|
||||||
|
|
||||||
|
|
||||||
|
DSK = $(PACKAGE)-$(VERSION)-$(TARGET).dsk
|
||||||
|
|
||||||
|
# Compilation and linking flags. Left empty under OS-9.
|
||||||
|
# With no --org option, the DECB .bin entry point is $2800.
|
||||||
|
ifneq "$(TARGET)" "os9"
|
||||||
|
DEMOORG = --limit=7F00
|
||||||
|
SMOLDEMOORG = --limit=7F00
|
||||||
|
TESTORG = --limit=7F00
|
||||||
|
endif
|
||||||
|
INTERMEDIATE = #--intermediate
|
||||||
|
|
||||||
|
# Omit -DNDEBUG to enable the assert statements in the library.
|
||||||
|
NDEBUG = -DNDEBUG
|
||||||
|
|
||||||
|
OPTIM = -fomit-frame-pointer
|
||||||
|
WARNINGS = -Wfor-condition-sizes #-Wgives-byte
|
||||||
|
WERROR = -Werror #-Wno-uncalled-static
|
||||||
|
STACKSPACE = 2048
|
||||||
|
CFLAGS = --$(TARGET) $(NDEBUG) $(INTERMEDIATE) $(OPTIM) $(WARNINGS) $(WERROR) \
|
||||||
|
-DVERSION=\"$(VERSION)\" --stack-space=$(STACKSPACE)
|
||||||
|
LDFLAGS = --$(TARGET) $(INTERMEDIATE)
|
||||||
|
|
||||||
|
|
||||||
|
DEMOOBJ = $(DEMOSRC:.c=.o)
|
||||||
|
SMOLDEMOOBJ = $(SMOLDEMOSRC:.c=.o)
|
||||||
|
TESTOBJ = $(TESTSRC:.c=.o)
|
||||||
|
LIBOBJ = $(LIBSRC:.c=.o)
|
||||||
|
|
||||||
|
# Libraries possibly needed by this package.
|
||||||
|
ifeq "$(TARGET)" "os9"
|
||||||
|
BCONTROL_LIB = bcontrol
|
||||||
|
BCONTROL_LIB_DIR = bcontrol
|
||||||
|
DEMO_CFLAGS = -I $(BCONTROL_LIB_DIR)
|
||||||
|
DEMO_LDFLAGS = -L $(BCONTROL_LIB_DIR) -l$(BCONTROL_LIB)
|
||||||
|
endif
|
||||||
|
|
||||||
|
# Tools.
|
||||||
|
CMOC = cmoc
|
||||||
|
LWAR = lwar
|
||||||
|
PERL = perl
|
||||||
|
TAR = tar
|
||||||
|
WRITECOCOFILE = writecocofile
|
||||||
|
INSTALL_LOADER = install-coco-boot-loader
|
||||||
|
XROAR = xroar
|
||||||
|
|
||||||
|
all: $(DEMOBIN) $(SMOLDEMOBIN) $(TESTBIN)
|
||||||
|
|
||||||
|
$(DEMOBIN): $(DEMOOBJ) $(STATICLIB)
|
||||||
|
$(CMOC) -o $(DEMOBIN) $(LDFLAGS) $(DEMOORG) $(DEMOOBJ) -L. -l$(PACKAGE) $(DEMO_LDFLAGS)
|
||||||
|
|
||||||
|
ifeq "$(TARGET)" "coco"
|
||||||
|
|
||||||
|
$(SMOLDEMOBIN): $(SMOLDEMOOBJ) $(STATICLIB)
|
||||||
|
$(CMOC) -o $(SMOLDEMOBIN) $(LDFLAGS) $(SMOLDEMOORG) $(SMOLDEMOOBJ) -L. -l$(PACKAGE)
|
||||||
|
|
||||||
|
endif
|
||||||
|
|
||||||
|
ifneq "$(TARGET)" "os9"
|
||||||
|
|
||||||
|
$(TESTBIN): $(TESTOBJ) $(STATICLIB)
|
||||||
|
$(CMOC) -o $(TESTBIN) $(LDFLAGS) $(TESTORG) $(TESTOBJ) -L. -l$(PACKAGE)
|
||||||
|
|
||||||
|
endif
|
||||||
|
|
||||||
|
$(STATICLIB): $(LIBOBJ)
|
||||||
|
$(LWAR) --create $(STATICLIB) $(LIBOBJ)
|
||||||
|
|
||||||
|
ifeq "$(TARGET)" "coco"
|
||||||
|
|
||||||
|
$(DSK): dsk
|
||||||
|
|
||||||
|
.PHONY: dsk
|
||||||
|
dsk: $(DEMOBIN) $(SMOLDEMOBIN) $(TESTBIN)
|
||||||
|
$(PERL) -e 'print chr(255) x (35*18*256)' > $(DSK)
|
||||||
|
$(WRITECOCOFILE) $(DSK) $(DEMOBIN)
|
||||||
|
$(WRITECOCOFILE) $(DSK) $(SMOLDEMOBIN)
|
||||||
|
$(WRITECOCOFILE) $(DSK) $(TESTBIN)
|
||||||
|
|
||||||
|
endif
|
||||||
|
|
||||||
|
ifeq "$(TARGET)" "os9"
|
||||||
|
OS9_DSK = 68sdc.vhd
|
||||||
|
OS9COPY = os9 copy
|
||||||
|
OS9ATTR = os9 attr -q
|
||||||
|
|
||||||
|
.PHONY: deploy
|
||||||
|
deploy: $(DEMOBIN)
|
||||||
|
$(OS9COPY) $(DEMOBIN) $(OS9_DSK),CMDS -r
|
||||||
|
$(OS9ATTR) -epe $(OS9_DSK),CMDS/$(DEMOBIN)
|
||||||
|
endif
|
||||||
|
|
||||||
|
%.o: %.c
|
||||||
|
$(CMOC) -c $(CFLAGS) $(DEMO_CFLAGS) -o $@ $<
|
||||||
|
|
||||||
|
clean:
|
||||||
|
rm -f $(DEMOBIN) $(DEMOOBJ) \
|
||||||
|
$(SMOLDEMOBIN) $(SMOLDEMOOBJ) \
|
||||||
|
$(TESTBIN) $(TESTOBJ) \
|
||||||
|
$(STATICLIB) $(LIBOBJ)
|
||||||
|
|
||||||
|
distclean: clean
|
||||||
|
rm -f $(DEMOSRC:.c=.d) $(SMOLDEMOSRC:.c=.d) $(LIBSRC:.c=.d)
|
||||||
|
|
||||||
|
.PHONY: dist distcheck
|
||||||
|
dist:
|
||||||
|
$(TAR) -czf $(PACKAGE)-$(VERSION).tar.gz --transform 's,^,$(PACKAGE)-$(VERSION)/,' $(DISTFILES)
|
||||||
|
|
||||||
|
# To do a distcheck with TARGET=os9, also pass BCONTROL_LIB_DIR=FIXME.
|
||||||
|
#
|
||||||
|
distcheck: dist
|
||||||
|
mkdir ,distcheck
|
||||||
|
$(TAR) -C ,distcheck -xzf $(PACKAGE)-$(VERSION).tar.gz
|
||||||
|
$(MAKE) -C ,distcheck/$(PACKAGE)-$(VERSION) all dsk
|
||||||
|
rm -fr ,distcheck
|
||||||
|
@echo "SUCCESS: $(PACKAGE)-$(VERSION).tar.gz ready for distribution"
|
||||||
|
|
||||||
|
# Automatic prerequisite generation.
|
||||||
|
%.d: %.c
|
||||||
|
$(CMOC) --deps-only $(CFLAGS) $(DEMO_CFLAGS) $<
|
||||||
|
|
||||||
|
.PHONY: cleandeps
|
||||||
|
cleandeps:
|
||||||
|
rm -f $(DEMOSRC:.c=.d) $(SMOLDEMOSRC:.c=.d) $(TESTSRC:.c=.d) $(LIBSRC:.c=.d)
|
||||||
|
|
||||||
|
include $(DEMOSRC:.c=.d)
|
||||||
|
include $(SMOLDEMOSRC:.c=.d)
|
||||||
|
include $(TESTSRC:.c=.d)
|
||||||
|
include $(LIBSRC:.c=.d)
|
||||||
@@ -0,0 +1,150 @@
|
|||||||
|
# Ebitor: A reusable text editor C library for 8-bit systems
|
||||||
|
|
||||||
|
Ebitor is a C library that implements a bare bones text editor
|
||||||
|
that can be adapted to work in any terminal. It features text
|
||||||
|
search and can be extended by the client program.
|
||||||
|
|
||||||
|
Copyright © 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
|
||||||
|
|
||||||
|
This code comes with ABSOLUTELY NO WARRANTY.
|
||||||
|
|
||||||
|
It is recommended to make backups of any files whose contents
|
||||||
|
are subjected to this editor.
|
||||||
|
|
||||||
|
|
||||||
|
## License: GPLv3
|
||||||
|
|
||||||
|
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/>.
|
||||||
|
|
||||||
|
See file COPYING.
|
||||||
|
|
||||||
|
|
||||||
|
## Introduction
|
||||||
|
|
||||||
|
This is NOT an editor application, it is only a **C library**.
|
||||||
|
It is intended for programmers who want to integrate a full-screen
|
||||||
|
editor into their own application.
|
||||||
|
|
||||||
|
This library implements a bare bones editor: It has very few features.
|
||||||
|
More features can be implemented by the client program. They would
|
||||||
|
typically be invoked by the user by typing the escape key followed by
|
||||||
|
another key. For example, the Break key followed by A could be used to
|
||||||
|
put the cursor at the start of the current line.
|
||||||
|
|
||||||
|
|
||||||
|
## Features
|
||||||
|
|
||||||
|
- Used as a library, not a program.
|
||||||
|
- Terminal functions are entirely provided by the client program.
|
||||||
|
This allows this editor to be used with any terminal type.
|
||||||
|
- CoCo 32x16, 40x25, 64x25, 80x25 terminal drivers provided.
|
||||||
|
- OS-9 40- and 80-column driver provided.
|
||||||
|
The 32-column terminal is not supported.
|
||||||
|
(The OS-9 version needs the BControl library, available from
|
||||||
|
the CMOC home page.)
|
||||||
|
- Does not require dynamic memory allocation.
|
||||||
|
- Folds lines that are longer than the terminal width.
|
||||||
|
Does not support non-folding with horizontal scrolling.
|
||||||
|
- Only one editor can be operated at a given time.
|
||||||
|
- Should be compiled with the CMOC compiler.
|
||||||
|
See <http://sarrazip.com/dev/cmoc.html>.
|
||||||
|
The code assumes a 64k addressable space.
|
||||||
|
- The only controls provided are moving the cursor with the arrow
|
||||||
|
keys, and a backspace key to erase the previous character.
|
||||||
|
Other controls like page-up, page-down and string search must be
|
||||||
|
implemented by the client program.
|
||||||
|
The library offers function Ebitor_findStringAndScrollToShow()
|
||||||
|
to facilitate the latter.
|
||||||
|
|
||||||
|
|
||||||
|
## Building Ebitor
|
||||||
|
|
||||||
|
In a Unix-like development environment, do `make` to compile
|
||||||
|
for the CoCo, or `make TARGET=os9` to compile for OS-9.
|
||||||
|
|
||||||
|
See `Makefile` for details.
|
||||||
|
|
||||||
|
|
||||||
|
## Programming for Ebitor
|
||||||
|
|
||||||
|
See `smoldemo.c` for a minimal example and `ebitdemo.c` for a
|
||||||
|
substantial one. To compile these demos, do `make`, then run
|
||||||
|
`smoldemo.bin` or `ebitdemo.bin` on a CoCo or an emulator.
|
||||||
|
|
||||||
|
Either of these demos first #includes header files for one or
|
||||||
|
more terminal structs, e.g., `sgterm.h` for SG-4 mode (32x16),
|
||||||
|
`gimeterm.h` for the CoCo 3 text modes, or `os9term.h` for an
|
||||||
|
OS-9 40- or 80-character terminal.
|
||||||
|
|
||||||
|
Then it #includes `Ebitor.h` to use the editor structs and functions.
|
||||||
|
|
||||||
|
The demo's first step is to fill an ebitor_Window object that defines
|
||||||
|
the text window that the editor will use. Then it calls Ebitor's
|
||||||
|
`sg4term_init()` function, in the case of ,`smoldemo.c` to initialize
|
||||||
|
the 32x16 screen terminal.
|
||||||
|
|
||||||
|
Then `Ebitor_init()` is called to initialize the editor. This call
|
||||||
|
receives several pointers to several functions that Ebitor will need,
|
||||||
|
e.g., clearing the terminal, locating the cursor, etc. In the case of
|
||||||
|
the 32x16 screen, `sg4term_clear` and `sg4term_locate` are passed.
|
||||||
|
|
||||||
|
Then the demo enters its main editing loop. This loop must call
|
||||||
|
`Ebitor_processEditing()`. This function will operate until the user
|
||||||
|
presses the escape key, typically Break on a CoCo.
|
||||||
|
|
||||||
|
Then the editing loop shows a prompt to ask the user what to do after
|
||||||
|
pressing the escape key. Both demos offer to quit the program or to
|
||||||
|
show a help page. `ebitdemo.c` also offers to find some text.
|
||||||
|
|
||||||
|
If the user presses the escape key again instead of choosing one
|
||||||
|
of those options, the editing loop just goes back to the call to
|
||||||
|
`Ebitor_processEditing()`.
|
||||||
|
|
||||||
|
When exiting the editor loop, `Ebitor_shutdown()` must be called.
|
||||||
|
|
||||||
|
|
||||||
|
## Porting to other environments
|
||||||
|
|
||||||
|
`Ebitor_init()` accepts pointers to functions that handle the
|
||||||
|
terminal operations needed by the editor. Porting to a different
|
||||||
|
type of terminal mainly involves writing functions that fill the
|
||||||
|
same roles, and passing the addresses of those functions to
|
||||||
|
`Ebitor_init()`.
|
||||||
|
|
||||||
|
A good starting point can be to make a copy of sg4term.h and
|
||||||
|
sg4term.c under new names, then reworking the code for the new
|
||||||
|
terminal type.
|
||||||
|
|
||||||
|
|
||||||
|
## Memory requirements
|
||||||
|
|
||||||
|
The Ebitor library code should take about 5100 bytes in memory under DECB,
|
||||||
|
but about 5400 under OS-9.
|
||||||
|
|
||||||
|
The SG4 (32x16) terminal code (sg4term.c) should take about 1300 bytes.
|
||||||
|
|
||||||
|
The GIME (CoCo 3) terminal code (gimeterm.c) should take about 1300 bytes.
|
||||||
|
|
||||||
|
The OS-9 terminal code should take about 1000 bytes.
|
||||||
|
|
||||||
|
These sizes do not count:
|
||||||
|
* the text buffer in which the edited text is stored;
|
||||||
|
* the stack space needed during operation;
|
||||||
|
* the space that would be used if the assert() statements were enabled
|
||||||
|
by compiling without NDEBUG.
|
||||||
|
|
||||||
|
|
||||||
|
## Version history
|
||||||
|
|
||||||
|
0.1.0 - 2027-07-27 - First public release.
|
||||||
@@ -0,0 +1,36 @@
|
|||||||
|
/* Window.h
|
||||||
|
|
||||||
|
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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _H_EbitorWindow
|
||||||
|
#define _H_EbitorWindow
|
||||||
|
|
||||||
|
#include <coco.h>
|
||||||
|
|
||||||
|
|
||||||
|
typedef struct ebitor_Window
|
||||||
|
{
|
||||||
|
byte width;
|
||||||
|
byte height;
|
||||||
|
byte leftCol;
|
||||||
|
byte topRow;
|
||||||
|
byte cursorCol;
|
||||||
|
byte cursorRow;
|
||||||
|
} ebitor_Window;
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* _H_EbitorWindow */
|
||||||
+1041
File diff suppressed because it is too large.
Load diff
+818
@@ -0,0 +1,818 @@
|
|||||||
|
/* ebittest.c
|
||||||
|
|
||||||
|
This file is in the public domain.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#undef NDEBUG /* enable asserts */
|
||||||
|
|
||||||
|
#include "sg4term.h"
|
||||||
|
#include "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
|
||||||
|
static const char *predefinedKeyPresses = "";
|
||||||
|
|
||||||
|
|
||||||
|
static byte
|
||||||
|
readPredefinedKeyOrKeyboard(void)
|
||||||
|
{
|
||||||
|
if (*predefinedKeyPresses != '\0')
|
||||||
|
return *predefinedKeyPresses++;
|
||||||
|
return 0; // not supposed to be reached
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static const ebitor_Window testWindow = { 32, 15, 0, 0, 0, 0 };
|
||||||
|
|
||||||
|
|
||||||
|
static size_t currentTestIndex;
|
||||||
|
|
||||||
|
|
||||||
|
static byte
|
||||||
|
inkey1(void *cookie)
|
||||||
|
{
|
||||||
|
byte code = readPredefinedKeyOrKeyboard();
|
||||||
|
return code;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Declarations of private functions used by the self tests.
|
||||||
|
//
|
||||||
|
// char Ebitor_isRegionVisible(size_t regionOffset, size_t regionLength, byte cursorCol, byte cursorRow,
|
||||||
|
// size_t *homeOffset, size_t *firstOffScreenOffset);
|
||||||
|
// size_t Ebitor_countRowsToScrollUp(size_t logicalOffsetToShow, size_t firstOffScreenOffset);
|
||||||
|
// size_t Ebitor_countRowsToScrollDown(size_t logicalOffsetToShow, size_t homeOffset, size_t *logicalOffsetAtStartOfTermRow);
|
||||||
|
|
||||||
|
|
||||||
|
static char textBuffer[600];
|
||||||
|
|
||||||
|
|
||||||
|
static const char *initContents = ""
|
||||||
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ01234\r"
|
||||||
|
"L0\r"
|
||||||
|
"L1\r"
|
||||||
|
"L2\r"
|
||||||
|
"L3\r"
|
||||||
|
"L4\r"
|
||||||
|
"L5\r"
|
||||||
|
"L6\r"
|
||||||
|
"L7\r"
|
||||||
|
"L8\r"
|
||||||
|
"L9\r"
|
||||||
|
"L10\r"
|
||||||
|
"L11\r"
|
||||||
|
"L12\r"
|
||||||
|
"L13\r"
|
||||||
|
"L14ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz\r"
|
||||||
|
"L15\r"
|
||||||
|
"L16\r"
|
||||||
|
"L17\r"
|
||||||
|
;
|
||||||
|
|
||||||
|
|
||||||
|
// Uses initContents. Fills textBuffer. Calls Ebitor_setContentLength().
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
setRepeatedTestContent(size_t numRepetitions)
|
||||||
|
{
|
||||||
|
size_t initContentLength = strlen(initContents);
|
||||||
|
assert(initContentLength < sizeof(textBuffer) / numRepetitions);
|
||||||
|
char *dest = textBuffer;
|
||||||
|
for (size_t i = numRepetitions; i--; dest += initContentLength)
|
||||||
|
memcpy(dest, initContents, initContentLength);
|
||||||
|
Ebitor_setContentLength(initContentLength * numRepetitions);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_setContentLength
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
setTestContent(void)
|
||||||
|
{
|
||||||
|
setRepeatedTestContent(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
test_scrollWindowUp(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
char text[3];
|
||||||
|
sg4term_getChars(0, 14, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L13", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
sg4term_scrollWindowUp(1);
|
||||||
|
|
||||||
|
sg4term_getChars(0, 13, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L13", sizeof(text)) == 0); // L13 moved one row up
|
||||||
|
sg4term_getChars(0, 14, text, sizeof(text));
|
||||||
|
assert(memcmp(text, " ", sizeof(text)) == 0); // bottom row cleared
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
test_scrollWindowDown(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
char text[3];
|
||||||
|
sg4term_getChars(0, 0, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "ABC", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
sg4term_scrollWindowDown(1);
|
||||||
|
|
||||||
|
sg4term_getChars(0, 1, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "ABC", sizeof(text)) == 0); // ABC moved one row down
|
||||||
|
sg4term_getChars(0, 0, text, sizeof(text));
|
||||||
|
assert(memcmp(text, " ", sizeof(text)) == 0); // top row cleared
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_isRegionVisible
|
||||||
|
//: Tested: Ebitor_countRowsToScrollUp
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_countRowsToScrollUp(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
size_t homeOffset = 0xFEDC, firstOffScreenOffset = 0xEDCB; // dummy values to be overwritten
|
||||||
|
|
||||||
|
// Check that a substring near the end of the text is not displayed.
|
||||||
|
//
|
||||||
|
char *p = strstr(editor->bufferBegin, "L16\r");
|
||||||
|
assert(p);
|
||||||
|
size_t regionOffset = p - editor->bufferBegin;
|
||||||
|
printf("[regionOffset=%u]", regionOffset);
|
||||||
|
char code = Ebitor_isRegionVisible(regionOffset, 3, editor->savedCursorCol, editor->savedCursorRow,
|
||||||
|
&homeOffset, &firstOffScreenOffset);
|
||||||
|
printf("[C=%d,H=%u,F=%u]", code, homeOffset, firstOffScreenOffset);
|
||||||
|
assert(code == 1); // substring comes after the displayed text
|
||||||
|
assert(homeOffset == 0); // top of screen shows top of text
|
||||||
|
size_t expectedFirstOffScreenOffset = strstr(editor->bufferBegin, "L14ABC") - editor->bufferBegin;
|
||||||
|
assert(firstOffScreenOffset == expectedFirstOffScreenOffset);
|
||||||
|
|
||||||
|
// Test that a character not at the start of a terminal row can be scrolled up to.
|
||||||
|
//
|
||||||
|
size_t logicalOffsetToShow = regionOffset + 1;
|
||||||
|
size_t numTermRows = Ebitor_countRowsToScrollUp(logicalOffsetToShow, firstOffScreenOffset);
|
||||||
|
printf("[N=%u]", numTermRows);
|
||||||
|
assert(numTermRows == 5);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_isRegionVisible
|
||||||
|
//: Tested: Ebitor_countRowsToScrollDown
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_countRowsToScrollDown(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
// Show the text and move the cursor below the initially displayed text.
|
||||||
|
predefinedKeyPresses = "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Cursor is at bottom left of editable area.
|
||||||
|
assert(editor->savedCursorCol == 0);
|
||||||
|
assert(editor->savedCursorRow == 14);
|
||||||
|
|
||||||
|
// Logical cursor is at end of text.
|
||||||
|
assert(editor->cursorOffset == editor->bufferFilledSize);
|
||||||
|
|
||||||
|
size_t homeOffset = 0, firstOffScreenOffset = 0xFEDC;
|
||||||
|
|
||||||
|
// Check that a substring near the beginning of the text is not displayed.
|
||||||
|
//
|
||||||
|
char *p = strstr(editor->bufferBegin, "L2\r");
|
||||||
|
assert(p);
|
||||||
|
size_t regionOffset = p - editor->bufferBegin;
|
||||||
|
printf("[regionOffset=%u]", regionOffset);
|
||||||
|
char code = Ebitor_isRegionVisible(regionOffset, 2, editor->savedCursorCol, editor->savedCursorRow,
|
||||||
|
&homeOffset, &firstOffScreenOffset);
|
||||||
|
printf("[C=%d,H=%u,F=%u]", code, homeOffset, firstOffScreenOffset);
|
||||||
|
assert(code == -1); // substring comes before the displayed text
|
||||||
|
assert(homeOffset == strstr(editor->bufferBegin, "L6\r") - editor->bufferBegin);
|
||||||
|
assert(firstOffScreenOffset == 0xFEDC); // dummy value not touched
|
||||||
|
|
||||||
|
size_t logicalOffsetToShow = regionOffset + 1;
|
||||||
|
size_t logicalOffsetAtStartOfTermRow = 0;
|
||||||
|
size_t numTermRows = Ebitor_countRowsToScrollDown(logicalOffsetToShow, homeOffset, &logicalOffsetAtStartOfTermRow);
|
||||||
|
printf("[N=%u,A=%u]", numTermRows, logicalOffsetAtStartOfTermRow);
|
||||||
|
assert(numTermRows == 4);
|
||||||
|
assert(logicalOffsetAtStartOfTermRow == regionOffset); // b/c regionOffset is at start of line ("L2")
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_scrollToShowLogicalOffset
|
||||||
|
//: Tested: Ebitor_getLogicalOffsetAtHome
|
||||||
|
//: Tested: Ebitor_isRegionVisible
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_scrollToShowLogicalOffset(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
// Initial screen shows top of text.
|
||||||
|
// Target a line that is below the screen.
|
||||||
|
//
|
||||||
|
char *p = strstr(editor->bufferBegin, "L16\r");
|
||||||
|
assert(p);
|
||||||
|
size_t offsetInLine = 1;
|
||||||
|
size_t regionOffset = p - editor->bufferBegin + offsetInLine;
|
||||||
|
size_t regionLen = 2;
|
||||||
|
//printf("[regionOffset=%u]", regionOffset);
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
Ebitor_scrollToShowLogicalOffset(regionOffset, regionLen);
|
||||||
|
|
||||||
|
byte cursorCol, cursorRow;
|
||||||
|
editor->getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
//printf("[%u,%u]", cursorCol, cursorRow);
|
||||||
|
assert(cursorCol == offsetInLine);
|
||||||
|
assert(cursorRow == editor->termHeight - 1); // last window row
|
||||||
|
|
||||||
|
size_t h = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
|
||||||
|
//printf("[HO=%u]", h);
|
||||||
|
assert(h == strstr(editor->bufferBegin, "L4\r") - editor->bufferBegin);
|
||||||
|
|
||||||
|
size_t homeOffset = 0xFFFF, firstOffScreenOffset = 0xFFFF;
|
||||||
|
char code = Ebitor_isRegionVisible(regionOffset, regionLen, cursorCol, cursorRow,
|
||||||
|
&homeOffset, &firstOffScreenOffset);
|
||||||
|
//printf("[%d,%u,%u]", code, homeOffset, firstOffScreenOffset);
|
||||||
|
assert(code == 0); // region now visible
|
||||||
|
assert(homeOffset == h);
|
||||||
|
assert(firstOffScreenOffset == strstr(editor->bufferBegin, "L17\r") - editor->bufferBegin);
|
||||||
|
|
||||||
|
// Check that terminal contents got scrolled up.
|
||||||
|
char text[3];
|
||||||
|
sg4term_getChars(0, 7, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L11", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
// Now scroll up to a line that is currently above the displayed text.
|
||||||
|
//
|
||||||
|
regionOffset = strstr(editor->bufferBegin, "L2\r") - editor->bufferBegin + offsetInLine;
|
||||||
|
regionLen = 1; // just the "2"
|
||||||
|
//printf("[regionOffset=%u]", regionOffset);
|
||||||
|
code = Ebitor_isRegionVisible(regionOffset, regionLen, cursorCol, cursorRow,
|
||||||
|
&homeOffset, &firstOffScreenOffset);
|
||||||
|
//printf("[%d,%u,%u]", code, homeOffset, firstOffScreenOffset);
|
||||||
|
assert(code == -1); // "L2" line is above the displayed text
|
||||||
|
assert(homeOffset == h);
|
||||||
|
assert(firstOffScreenOffset == strstr(editor->bufferBegin, "L17\r") - editor->bufferBegin);
|
||||||
|
|
||||||
|
Ebitor_scrollToShowLogicalOffset(regionOffset, regionLen);
|
||||||
|
|
||||||
|
editor->getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
//printf("[%u,%u]", cursorCol, cursorRow);
|
||||||
|
assert(cursorCol == offsetInLine);
|
||||||
|
assert(cursorRow == 0);
|
||||||
|
|
||||||
|
homeOffset = 0xFFFF, firstOffScreenOffset = 0xFFFF;
|
||||||
|
code = Ebitor_isRegionVisible(regionOffset, regionLen, cursorCol, cursorRow,
|
||||||
|
&homeOffset, &firstOffScreenOffset);
|
||||||
|
//printf("[%d,%u,%u]", code, homeOffset, firstOffScreenOffset);
|
||||||
|
assert(code == 0); // region now visible
|
||||||
|
assert(homeOffset == regionOffset - offsetInLine);
|
||||||
|
assert(firstOffScreenOffset == strstr(editor->bufferBegin, "L15\r") - editor->bufferBegin);
|
||||||
|
|
||||||
|
// Check that terminal contents got scrolled down.
|
||||||
|
sg4term_getChars(0, 7, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L9 ", sizeof(text)) == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_findStringAndScrollToShow
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_findStringAndScrollToShow(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
BOOL found;
|
||||||
|
size_t foundLogicalOffset;
|
||||||
|
|
||||||
|
// Search for a string below the displayed text.
|
||||||
|
|
||||||
|
found = Ebitor_findStringAndScrollToShow(0, "l16", &foundLogicalOffset);
|
||||||
|
assert(found);
|
||||||
|
|
||||||
|
char text[3];
|
||||||
|
sg4term_getChars(0, 14, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L16", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
byte cursorCol, cursorRow;
|
||||||
|
editor->getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(cursorCol == 0 && cursorRow == 14);
|
||||||
|
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "L16\r", 4) == 0);
|
||||||
|
|
||||||
|
// Search for a string above the displayed text.
|
||||||
|
|
||||||
|
found = Ebitor_findStringAndScrollToShow(0, "l2", &foundLogicalOffset);
|
||||||
|
assert(found);
|
||||||
|
|
||||||
|
sg4term_getChars(0, 0, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L2 ", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
editor->getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(cursorCol == 0 && cursorRow == 0);
|
||||||
|
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "L2\r", 3) == 0);
|
||||||
|
|
||||||
|
// Search for a string already in the displayed text.
|
||||||
|
found = Ebitor_findStringAndScrollToShow(0, "678", &foundLogicalOffset);
|
||||||
|
assert(found);
|
||||||
|
|
||||||
|
sg4term_getChars(3, 13, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "678", sizeof(text)) == 0);
|
||||||
|
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "678", 3) == 0);
|
||||||
|
|
||||||
|
// Search for a string that is not in the text.
|
||||||
|
|
||||||
|
found = Ebitor_findStringAndScrollToShow(0, "ABSENT", &foundLogicalOffset);
|
||||||
|
assert(!found);
|
||||||
|
|
||||||
|
sg4term_getChars(3, 13, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "678", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
editor->getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(cursorCol == 3 && cursorRow == 13);
|
||||||
|
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "678", 3) == 0);
|
||||||
|
|
||||||
|
size_t homeOffset = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
|
||||||
|
//printf("[homeOffset=%u]", homeOffset);
|
||||||
|
assert(homeOffset == strlen("ABCDEFGHIJKLMNOPQRSTUVWXYZ01234\r" "L0\r" "L1\r"));
|
||||||
|
|
||||||
|
// Search for a string that appears more than once.
|
||||||
|
size_t numOccurrences = 0;
|
||||||
|
size_t startLogicalOffset = 0;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
found = Ebitor_findStringAndScrollToShow(startLogicalOffset, "L1", &foundLogicalOffset);
|
||||||
|
//printf("[%d,%u]", found, foundLogicalOffset); waitkey(1);
|
||||||
|
if (!found)
|
||||||
|
break;
|
||||||
|
assert(startLogicalOffset <= foundLogicalOffset);
|
||||||
|
assert(foundLogicalOffset <= editor->bufferFilledSize - 2);
|
||||||
|
++numOccurrences;
|
||||||
|
assert(numOccurrences <= 9);
|
||||||
|
|
||||||
|
editor->getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "L1", 2) == 0);
|
||||||
|
|
||||||
|
// Try to find another occurrence.
|
||||||
|
startLogicalOffset = foundLogicalOffset + 1;
|
||||||
|
}
|
||||||
|
assert(numOccurrences == 9);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_findStringAndScrollToShow
|
||||||
|
//: Tested: Ebitor_processEditing
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_findDisplayedLineAfterScrollDown(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setTestContent();
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 0);
|
||||||
|
|
||||||
|
// Find "L3", which is displayed.
|
||||||
|
//
|
||||||
|
size_t foundLogicalOffset = 0xFFFF;
|
||||||
|
BOOL found = Ebitor_findStringAndScrollToShow(0, "L3", &foundLogicalOffset);
|
||||||
|
assert(found);
|
||||||
|
assert(foundLogicalOffset == 41);
|
||||||
|
assert(editor->cursorOffset == 41);
|
||||||
|
|
||||||
|
byte cursorCol, cursorRow;
|
||||||
|
sg4term_getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(cursorCol == 0);
|
||||||
|
assert(cursorRow == 4);
|
||||||
|
|
||||||
|
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 4);
|
||||||
|
|
||||||
|
// Go down enough to screen window up one row.
|
||||||
|
// FALSE means no refresh, to check that Ebitor_findStringAndScrollToShow()
|
||||||
|
// did NOT scroll the window.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses = "\n\n\n\n\n\n\n\n\n\n\n\x03";
|
||||||
|
Ebitor_processEditing(FALSE);
|
||||||
|
|
||||||
|
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == testWindow.height - 1);
|
||||||
|
|
||||||
|
char text[3];
|
||||||
|
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L14", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
// Find "L3" again and check that the screen has not scrolled.
|
||||||
|
//
|
||||||
|
found = Ebitor_findStringAndScrollToShow(0, "L3", &foundLogicalOffset);
|
||||||
|
assert(found);
|
||||||
|
assert(foundLogicalOffset == 41);
|
||||||
|
assert(editor->cursorOffset == 41);
|
||||||
|
|
||||||
|
sg4term_getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(cursorCol == 0);
|
||||||
|
assert(cursorRow == 3);
|
||||||
|
|
||||||
|
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 3);
|
||||||
|
|
||||||
|
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L14", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
// Process nothing, but check that the screen has been redisplayed correctly.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L14", sizeof(text)) == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_processUpOrDownArrowsAndRefresh
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_goPageUpOnEmptyBuffer(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Page up:
|
||||||
|
Ebitor_processUpOrDownArrowsAndRefresh(TRUE, testWindow.height);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_processUpOrDownArrowsAndRefresh
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_goPageUpOnSingleLine(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
predefinedKeyPresses = "\r\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Page up:
|
||||||
|
Ebitor_processUpOrDownArrowsAndRefresh(TRUE, testWindow.height);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_scrollToShowLogicalOffset
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_goTwoPagesUp(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setRepeatedTestContent(2);
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses =
|
||||||
|
"\n\n\n\n\n\n\n\n\n\n" // go to bottom of text (scrolls down 2 pages)
|
||||||
|
"\n\n\n\n\n\n\n\n\n\n"
|
||||||
|
"\n\n\n\n\n\n\n\n\n\n"
|
||||||
|
"\n\n\n\n\n\n\n\n\n\n"
|
||||||
|
"\n\n"
|
||||||
|
"\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Go back up to the first "L2" line.
|
||||||
|
size_t targetOffset = 32 + 3 + 3;
|
||||||
|
Ebitor_scrollToShowLogicalOffset(targetOffset, 2);
|
||||||
|
|
||||||
|
assert(editor->cursorOffset == targetOffset);
|
||||||
|
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_scrollToShowLogicalOffset
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_goTwoPagesDown(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
setRepeatedTestContent(2);
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Scroll down to the second "L13" line.
|
||||||
|
//
|
||||||
|
const char *target = strstr(textBuffer, "L11\r");
|
||||||
|
assert(target);
|
||||||
|
target = strstr(target + 1, "L11\r");
|
||||||
|
assert(target);
|
||||||
|
|
||||||
|
size_t targetOffset = target - textBuffer;
|
||||||
|
Ebitor_scrollToShowLogicalOffset(targetOffset, 3);
|
||||||
|
|
||||||
|
assert(editor->cursorOffset == targetOffset);
|
||||||
|
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == testWindow.height - 1);
|
||||||
|
|
||||||
|
// Check that the scrolling was correct.
|
||||||
|
//
|
||||||
|
char text[3];
|
||||||
|
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "L11", sizeof(text)) == 0);
|
||||||
|
sg4term_getChars(0, 2, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "ABC", sizeof(text)) == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Checks that the terminal cursor goes down when the user presses the down arrow key.
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_goOneRowDown(void)
|
||||||
|
{
|
||||||
|
setRepeatedTestContent(2);
|
||||||
|
|
||||||
|
// Show the text.
|
||||||
|
predefinedKeyPresses = "\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Down arrow, then return from Ebitor_processEditing().
|
||||||
|
predefinedKeyPresses = "\x0A\x03";
|
||||||
|
Ebitor_processEditing(FALSE);
|
||||||
|
|
||||||
|
// Check that cursor went down one row.
|
||||||
|
byte column, row;
|
||||||
|
sg4term_getCursorPos(&column, &row);
|
||||||
|
assert(column == 0);
|
||||||
|
assert(row == 1);
|
||||||
|
|
||||||
|
// Check that logical offset is at start of 2nd logical line.
|
||||||
|
assert(Ebitor_getLogicalCursorOffset() == strstr(textBuffer, "\r") + 1 - textBuffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//: Tested: Ebitor_setContentLength
|
||||||
|
//: Tested: Ebitor_processEditing
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_bufferFill(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
|
||||||
|
// Fill textBuffer (with letters) almost to the limit.
|
||||||
|
//
|
||||||
|
size_t filledSize = sizeof(textBuffer) - 5;
|
||||||
|
for (size_t i = 0; i < filledSize; ++i)
|
||||||
|
textBuffer[i] = 'A' + (char) (i % 26);
|
||||||
|
Ebitor_setContentLength(filledSize);
|
||||||
|
|
||||||
|
assert(editor->bufferFilledSize == sizeof(textBuffer) - 5);
|
||||||
|
|
||||||
|
// Interactively add too many chars.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses = "12345678\x03";
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
assert(editor->bufferFilledSize == sizeof(textBuffer)); // no room for "678"
|
||||||
|
|
||||||
|
char text[7];
|
||||||
|
sg4term_getChars(0, 0, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "12345AB", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
// Backspace.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses = "\f\x03";
|
||||||
|
Ebitor_processEditing(FALSE);
|
||||||
|
|
||||||
|
assert(editor->bufferFilledSize == sizeof(textBuffer) - 1);
|
||||||
|
|
||||||
|
sg4term_getChars(0, 0, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "1234ABC", sizeof(text)) == 0);
|
||||||
|
|
||||||
|
// Backspace too much.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses = "\f\f\f\f\f\f\f\x03";
|
||||||
|
Ebitor_processEditing(FALSE);
|
||||||
|
|
||||||
|
assert(editor->bufferFilledSize == sizeof(textBuffer) - 5);
|
||||||
|
|
||||||
|
sg4term_getChars(0, 0, text, sizeof(text));
|
||||||
|
assert(memcmp(text, "ABCDEFG", sizeof(text)) == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Tests a fix made in Ebitor_processPrintableChar() on 2025-01-09
|
||||||
|
// re: not calling Ebitor_fillTerminalToBottom() with firstRowToFill
|
||||||
|
// equal to Ebitor_instance.termHeight.
|
||||||
|
// In this test, the last visible row has 1 character less than the
|
||||||
|
// terminal width, then the user adds a character to the start of
|
||||||
|
// that row.
|
||||||
|
//
|
||||||
|
//: Tested: Ebitor_setContentLength
|
||||||
|
//: Tested: Ebitor_processEditing
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
test_addCharToLastVisibleRowWithAlmostFullLine(void)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
|
||||||
|
// Fill textBuffer (with letters) almost to the limit.
|
||||||
|
//
|
||||||
|
strcpy(textBuffer,
|
||||||
|
"L0\r"
|
||||||
|
"L1\r"
|
||||||
|
"L2\r"
|
||||||
|
"L3\r"
|
||||||
|
"L4\r"
|
||||||
|
"L5\r"
|
||||||
|
"L6\r"
|
||||||
|
"L7\r"
|
||||||
|
"L8\r"
|
||||||
|
"L9\r"
|
||||||
|
"L10\r"
|
||||||
|
"L11\r"
|
||||||
|
"L12\r"
|
||||||
|
"L13\r"
|
||||||
|
"L14--+----1----+----2----+----3\r" // last visible row, initially; 1 char short of filling row
|
||||||
|
"L15\r");
|
||||||
|
Ebitor_setContentLength(strlen(textBuffer));
|
||||||
|
|
||||||
|
// Interactively add a char at start of last visible row.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses =
|
||||||
|
"\n\n\n\n\n\n\n\n\n\n\n\n\n\n" // go from row 0 to row 14
|
||||||
|
"*" // add printable char
|
||||||
|
"\x03" // return from Ebitor_processEditing()
|
||||||
|
;
|
||||||
|
Ebitor_processEditing(TRUE);
|
||||||
|
|
||||||
|
// Check content of last 3 visible rows.
|
||||||
|
//
|
||||||
|
char text[32 * 3 + 1];
|
||||||
|
sg4term_getChars(0, testWindow.height - 3, text, sizeof(text) - 1);
|
||||||
|
text[32 * 3] = '\0';
|
||||||
|
|
||||||
|
assert(strcmp(text,
|
||||||
|
"L13 "
|
||||||
|
"*L14--+----1----+----2----+----3"
|
||||||
|
" ") == 0);
|
||||||
|
|
||||||
|
// 2 down arrows, then check that L15 appears.
|
||||||
|
//
|
||||||
|
predefinedKeyPresses = "\n\n\x03";
|
||||||
|
Ebitor_processEditing(FALSE);
|
||||||
|
sg4term_getChars(0, testWindow.height - 3, text, sizeof(text) - 1);
|
||||||
|
assert(strcmp(text,
|
||||||
|
"*L14--+----1----+----2----+----3"
|
||||||
|
" "
|
||||||
|
"L15 ") == 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#ifdef USIM
|
||||||
|
char screenBuffer[512];
|
||||||
|
word timer;
|
||||||
|
#define TIMER_ADDRESS (&timer)
|
||||||
|
#else /* CoCo: */
|
||||||
|
char *screenBuffer = (char *) 0x0400;
|
||||||
|
#define TIMER_ADDRESS ((word *) 0x112)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
// screenMode: 32, 40, 64, 80.
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
initEbitor(byte screenMode, const ebitor_Window *window)
|
||||||
|
{
|
||||||
|
Ebitor *editor = Ebitor_getInstance();
|
||||||
|
|
||||||
|
word irqServiceRoutineAddress = * (word *) 0xFFF8;
|
||||||
|
BOOL isCoCo3 = (irqServiceRoutineAddress == 0xFEF7);
|
||||||
|
|
||||||
|
if (screenMode != 32 && !isCoCo3)
|
||||||
|
{
|
||||||
|
printf("MODE %u IS ONLY SUPPORTED ON\nA COCO 3.\n", screenMode);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (screenMode)
|
||||||
|
{
|
||||||
|
case 32:
|
||||||
|
#ifdef _COCO_BASIC_
|
||||||
|
width(32); // by SECB
|
||||||
|
cls(3);
|
||||||
|
#endif
|
||||||
|
sg4term_init(screenBuffer, window, inkey1, NULL, TIMER_ADDRESS);
|
||||||
|
|
||||||
|
Ebitor_init(textBuffer, sizeof(textBuffer),
|
||||||
|
window->width, window->height,
|
||||||
|
sg4term_clear,
|
||||||
|
sg4term_locate,
|
||||||
|
sg4term_getCursorPos,
|
||||||
|
sg4term_print,
|
||||||
|
sg4term_printPrefix,
|
||||||
|
sg4term_clrtoeol,
|
||||||
|
sg4term_scrollWindowUp,
|
||||||
|
sg4term_scrollWindowDown,
|
||||||
|
sg4term_waitEditorKey);
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
assert(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
typedef void (*TestFunction)(void);
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
runTest(TestFunction testFunc)
|
||||||
|
{
|
||||||
|
byte screenMode = 32;
|
||||||
|
#ifdef _COCO_BASIC_
|
||||||
|
width(32);
|
||||||
|
locate(0, 0);
|
||||||
|
#endif
|
||||||
|
initEbitor(screenMode, &testWindow);
|
||||||
|
testFunc();
|
||||||
|
Ebitor_shutdown();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
TestFunction tests[] =
|
||||||
|
{
|
||||||
|
test_scrollWindowUp,
|
||||||
|
test_scrollWindowDown,
|
||||||
|
test_countRowsToScrollUp,
|
||||||
|
test_countRowsToScrollDown,
|
||||||
|
test_scrollToShowLogicalOffset,
|
||||||
|
test_findStringAndScrollToShow,
|
||||||
|
test_findDisplayedLineAfterScrollDown,
|
||||||
|
test_goPageUpOnEmptyBuffer,
|
||||||
|
test_goPageUpOnSingleLine,
|
||||||
|
test_goTwoPagesUp,
|
||||||
|
test_goTwoPagesDown,
|
||||||
|
test_bufferFill,
|
||||||
|
test_goOneRowDown,
|
||||||
|
test_addCharToLastVisibleRowWithAlmostFullLine,
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
runSelfTests(void)
|
||||||
|
{
|
||||||
|
size_t numTests = sizeof(tests) / sizeof(tests[0]);
|
||||||
|
for (currentTestIndex = 0; currentTestIndex < numTests; ++currentTestIndex)
|
||||||
|
runTest(tests[currentTestIndex]);
|
||||||
|
#ifdef _COCO_BASIC_
|
||||||
|
cls(255);
|
||||||
|
#endif
|
||||||
|
printf("\n* RAN %u TEST(S) *\n", numTests);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
failedAssertHandler(const char *file, int lineno, const char *condition)
|
||||||
|
{
|
||||||
|
printf("[***FAILED ASSERT IN TEST #%u: %s:%d: %s]",
|
||||||
|
currentTestIndex, file, lineno, condition);
|
||||||
|
for (;;)
|
||||||
|
;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
int
|
||||||
|
main()
|
||||||
|
{
|
||||||
|
#ifdef _COCO_BASIC_
|
||||||
|
rgb();
|
||||||
|
#endif
|
||||||
|
_SetFailedAssertHandler(failedAssertHandler);
|
||||||
|
runSelfTests();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
@@ -0,0 +1,49 @@
|
|||||||
|
/* findStringAndScrollToShow.c
|
||||||
|
|
||||||
|
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 "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
BOOL
|
||||||
|
Ebitor_findStringAndScrollToShow(size_t startLogicalOffset, const char *strSearchedFor,
|
||||||
|
size_t *foundLogicalOffset)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
Ebitor_startCommandMode(); // put insert buffer into edit buffer, so that all the text is contiguous
|
||||||
|
|
||||||
|
size_t lenStrSearchedFor = strlen(strSearchedFor);
|
||||||
|
if (lenStrSearchedFor == 0 || startLogicalOffset >= self->bufferFilledSize)
|
||||||
|
return FALSE;
|
||||||
|
|
||||||
|
const char * const bufferEnd = self->bufferBegin + self->bufferFilledSize;
|
||||||
|
const char *startPtr = self->bufferBegin + startLogicalOffset;
|
||||||
|
const char *foundPtr;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
foundPtr = (char *) memichr(startPtr, strSearchedFor[0], bufferEnd - startPtr);
|
||||||
|
if (!foundPtr)
|
||||||
|
return FALSE;
|
||||||
|
if (memicmp(foundPtr + 1, strSearchedFor + 1, lenStrSearchedFor - 1) == 0)
|
||||||
|
break;
|
||||||
|
startPtr = foundPtr + 1;
|
||||||
|
} while (startPtr < bufferEnd);
|
||||||
|
|
||||||
|
*foundLogicalOffset = foundPtr - self->bufferBegin;
|
||||||
|
Ebitor_scrollToShowLogicalOffset(*foundLogicalOffset, lenStrSearchedFor);
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
+319
@@ -0,0 +1,319 @@
|
|||||||
|
/* 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;
|
||||||
|
}
|
||||||
+146
@@ -0,0 +1,146 @@
|
|||||||
|
/* gimeterm.h - 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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
These functions implement a terminal compliant with the specs in Ebitor.h.
|
||||||
|
|
||||||
|
Each screen cell is a character byte followed by an attribute byte,
|
||||||
|
i.e., 2 bytes per screen character.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _H_gimeterm
|
||||||
|
#define _H_gimeterm
|
||||||
|
|
||||||
|
#include "Window.h"
|
||||||
|
|
||||||
|
|
||||||
|
typedef struct gimeterm_Window
|
||||||
|
{
|
||||||
|
ebitor_Window window;
|
||||||
|
|
||||||
|
// Default text attribute used by functions that put characters on the screen.
|
||||||
|
// See gimeterm_setTextAttribute().
|
||||||
|
//
|
||||||
|
byte textAttribute;
|
||||||
|
|
||||||
|
// Attribute to use to show characters with inverted colors.
|
||||||
|
// See gimeterm_setInvertedTextAttribute().
|
||||||
|
//
|
||||||
|
byte invertedTextAttribute;
|
||||||
|
|
||||||
|
} gimeterm_Window;
|
||||||
|
|
||||||
|
|
||||||
|
// Defines a window in a GIME hardware text screen.
|
||||||
|
// Does NOT clear the window.
|
||||||
|
// Does NOT change the video mode.
|
||||||
|
//
|
||||||
|
// screenBuffer: Address of the screen.
|
||||||
|
// screenMode: 40, 64 or 80.
|
||||||
|
// window: Initial window in the given screen.
|
||||||
|
// inkeyFuncPtr: Must return 0 (and not block) if no key pressed.
|
||||||
|
// inkeyFuncCookie: Will be passed to inkeyFuncPtr.
|
||||||
|
// timerPtr: Address of an unsigned 16-bit integer that gets incremented 60 times per second.
|
||||||
|
//
|
||||||
|
void gimeterm_init(void *screenBuffer, byte screenMode,
|
||||||
|
const gimeterm_Window *window,
|
||||||
|
byte (*inkeyFuncPtr)(void *cookie), void *inkeyFuncCookie,
|
||||||
|
word *timerPtr);
|
||||||
|
|
||||||
|
// Changes the current window.
|
||||||
|
//
|
||||||
|
void gimeterm_setWindow(const gimeterm_Window *state);
|
||||||
|
|
||||||
|
// Copies the state of the current window into the designated object.
|
||||||
|
//
|
||||||
|
void gimeterm_getWindow(gimeterm_Window *dest);
|
||||||
|
|
||||||
|
// Fills the window defined by gimeterm_init() with spaces and the 'textAttribute'
|
||||||
|
// passed to gimeterm_init().
|
||||||
|
// Does not move the cursor.
|
||||||
|
//
|
||||||
|
void gimeterm_clear(void);
|
||||||
|
|
||||||
|
// column, row: Coordinates relative to the window defined by gimeterm_init().
|
||||||
|
// Does not check if the parameters are valid.
|
||||||
|
// This may be useful to write outside the window, as long as no carriage return is written.
|
||||||
|
//
|
||||||
|
void gimeterm_locate(byte column, byte row);
|
||||||
|
|
||||||
|
// column, row: Receive coordinates relative to the window defined by gimeterm_init().
|
||||||
|
//
|
||||||
|
void gimeterm_getCursorPos(byte *column, byte *row);
|
||||||
|
|
||||||
|
// CAUTION: This function does NOT scroll when it reaches the end of the window.
|
||||||
|
// Character 13 does a carriage return and line feed AND clears
|
||||||
|
// the rest of the row it is applied to (with spaces and gimeterm_textAttribute).
|
||||||
|
// No other control code is supported.
|
||||||
|
//
|
||||||
|
// Returns FALSE if the cursor has fallen off the bottom of the window.
|
||||||
|
// The caller should scroll the window up and reposition the cursor.
|
||||||
|
//
|
||||||
|
BOOL gimeterm_putchar(int c);
|
||||||
|
|
||||||
|
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
|
||||||
|
//
|
||||||
|
BOOL gimeterm_print(const char *str);
|
||||||
|
|
||||||
|
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
|
||||||
|
//
|
||||||
|
BOOL gimeterm_printPrefix(const char *str, size_t prefixLength);
|
||||||
|
|
||||||
|
// Returns FALSE if the cursor has fallen off the bottom of the window.
|
||||||
|
// The caller should scroll the window up and reposition the cursor.
|
||||||
|
//
|
||||||
|
BOOL gimeterm_newline(void);
|
||||||
|
|
||||||
|
// Use inverted colors for the next print operations.
|
||||||
|
//
|
||||||
|
void gimeterm_invertColors(void);
|
||||||
|
|
||||||
|
void gimeterm_clrtoeol(void);
|
||||||
|
void gimeterm_scrollWindowUp(byte numRows);
|
||||||
|
void gimeterm_scrollWindowDown(byte numRows);
|
||||||
|
|
||||||
|
// Fills the line where the cursor is with spaces and puts the cursor at the start of this line.
|
||||||
|
//
|
||||||
|
void gimeterm_eraseCurrentLine(void);
|
||||||
|
|
||||||
|
// Animates a cursor while waiting.
|
||||||
|
// Returns an ASCII code or an ebitor_KEY_* code.
|
||||||
|
//
|
||||||
|
word gimeterm_waitEditorKey(void);
|
||||||
|
|
||||||
|
|
||||||
|
// The following functions are not part of the Ebitor terminal function set.
|
||||||
|
|
||||||
|
|
||||||
|
byte gimeterm_waitKey(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Returns the attribute used up to now.
|
||||||
|
//
|
||||||
|
byte gimeterm_setTextAttribute(byte newAttribute);
|
||||||
|
|
||||||
|
|
||||||
|
// Returns the inverted text attribute used up to now.
|
||||||
|
//
|
||||||
|
byte gimeterm_setInvertedTextAttribute(byte newAttribute);
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* _H_gimeterm */
|
||||||
@@ -0,0 +1,296 @@
|
|||||||
|
/* os9term.c - OS-9 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 "os9term.h"
|
||||||
|
|
||||||
|
#include "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
struct Ebitor;
|
||||||
|
|
||||||
|
|
||||||
|
static byte os9term_width, os9term_height;
|
||||||
|
static byte os9term_winLeftCol, os9term_winTopRow;
|
||||||
|
static byte os9term_cursorCol, os9term_cursorRow; // lower than os9term_winLeftCol, os9term_winTopRow
|
||||||
|
static byte (*os9term_waitKeyFuncPtr)(void *cookie); // blocks until key available
|
||||||
|
static void *os9term_waitKeyFuncCookie; // argument passed to sg4term_inkeyFuncPtr
|
||||||
|
|
||||||
|
|
||||||
|
// Changes the OS-9 terminal's working area.
|
||||||
|
// Sends the CWArea sequence to standard output.
|
||||||
|
// Source: "NitrOS-9 EOU Level 2 Windowing System Manual".
|
||||||
|
// Only works in 40- and 80-column modes.
|
||||||
|
// This puts the OS-9 terminal cursor at the home position of the window.
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
setWorkingAreaExtraHeight(byte increment)
|
||||||
|
{
|
||||||
|
byte buf[] = { 0x1B, 0x25, os9term_winLeftCol, os9term_winTopRow, os9term_width, os9term_height + increment };
|
||||||
|
putstr((char *) buf, sizeof(buf));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_clear(void)
|
||||||
|
{
|
||||||
|
byte c, r;
|
||||||
|
os9term_getCursorPos(&c, &r);
|
||||||
|
|
||||||
|
// Tell OS-9 to work in a window that only contains the text editing area, not the status line.
|
||||||
|
// This way, the status line does not get cleared.
|
||||||
|
setWorkingAreaExtraHeight(0);
|
||||||
|
|
||||||
|
putchar(12);
|
||||||
|
|
||||||
|
// Restore the OS-9 window that includes the status line.
|
||||||
|
setWorkingAreaExtraHeight(1);
|
||||||
|
|
||||||
|
os9term_locate(c, r);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
asm byte *
|
||||||
|
os9term_get32x16ScreenBuffer(void)
|
||||||
|
{
|
||||||
|
asm
|
||||||
|
{
|
||||||
|
pshs y ; protect global variable segment pointer
|
||||||
|
lda #1 ; path number
|
||||||
|
ldb #$1C ; SS.AlfaS (Return Alfa Display Status)
|
||||||
|
os9 $8D ; I$GetStt
|
||||||
|
bcs @error
|
||||||
|
tfr x,d ; return screen buffer address in D
|
||||||
|
bra @done
|
||||||
|
@error
|
||||||
|
clra ; return 0 in D
|
||||||
|
clrb
|
||||||
|
@done
|
||||||
|
puls y
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
asm byte
|
||||||
|
os9term_getGIMEScreenType(byte *screenTypeCode)
|
||||||
|
{
|
||||||
|
asm
|
||||||
|
{
|
||||||
|
lda #1 ; path number
|
||||||
|
ldb #$93 ; SS.ScTyp: Returns the type of a screen to a calling program
|
||||||
|
os9 $8D ; I$GetStt
|
||||||
|
bcs @error
|
||||||
|
clrb
|
||||||
|
sta [2,s] ; put code in *screenTypeCode
|
||||||
|
@error
|
||||||
|
; Error code returned in B, as per CMOC calling convention.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
byte
|
||||||
|
os9term_init(byte width, byte height,
|
||||||
|
byte winLeftCol, byte winTopRow,
|
||||||
|
byte (*waitKeyFuncPtr)(void *), void *waitKeyFuncCookie)
|
||||||
|
{
|
||||||
|
os9term_width = width;
|
||||||
|
os9term_height = height;
|
||||||
|
os9term_winLeftCol = winLeftCol;
|
||||||
|
os9term_winTopRow = winTopRow;
|
||||||
|
os9term_cursorCol = 0;
|
||||||
|
os9term_cursorRow = 0;
|
||||||
|
os9term_waitKeyFuncPtr = waitKeyFuncPtr;
|
||||||
|
os9term_waitKeyFuncCookie = waitKeyFuncCookie;
|
||||||
|
|
||||||
|
return 0; // success
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_locate(byte column, byte row)
|
||||||
|
{
|
||||||
|
char str[] = { 2, 32 + column, 32 + row };
|
||||||
|
putstr(str, sizeof(str));
|
||||||
|
os9term_cursorCol = column;
|
||||||
|
os9term_cursorRow = row;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_getCursorPos(byte *column, byte *row)
|
||||||
|
{
|
||||||
|
*column = os9term_cursorCol;
|
||||||
|
*row = os9term_cursorRow;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Character 13 does a carriage return and line feed AND clears
|
||||||
|
// the rest of the row it is applied to (with spaces).
|
||||||
|
// No other control code is supported.
|
||||||
|
// Updates os9term_cursorCol and os9term_cursorRow.
|
||||||
|
//
|
||||||
|
static BOOL
|
||||||
|
os9term_putchar(int c) //FIXME: Does not check against window height. Should return FALSE. See gimeterm.c.
|
||||||
|
{
|
||||||
|
if (c == '\r')
|
||||||
|
{
|
||||||
|
os9term_cursorCol = 0;
|
||||||
|
++os9term_cursorRow;
|
||||||
|
putchar(4); // clears to end of line
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
++os9term_cursorCol;
|
||||||
|
if (os9term_cursorCol >= os9term_width)
|
||||||
|
{
|
||||||
|
os9term_cursorCol = 0;
|
||||||
|
if (os9term_cursorRow < os9term_height - 1)
|
||||||
|
++os9term_cursorRow;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
putchar((char) c);
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
BOOL
|
||||||
|
os9term_print(const char *str)
|
||||||
|
{
|
||||||
|
for ( ; *str; ++str)
|
||||||
|
if (!os9term_putchar(*str))
|
||||||
|
return FALSE; // reached end of window
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
BOOL
|
||||||
|
os9term_printPrefix(const char *str, size_t prefixLength)
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < prefixLength; ++i)
|
||||||
|
if (!os9term_putchar(str[i]))
|
||||||
|
return FALSE; // reached end of window
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_invertColors(void)
|
||||||
|
{
|
||||||
|
// Not supported.
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Does not move the cursor.
|
||||||
|
//
|
||||||
|
void
|
||||||
|
os9term_clrtoeol(void)
|
||||||
|
{
|
||||||
|
for (byte c = os9term_cursorCol; c < os9term_width; ++c)
|
||||||
|
putchar(' ');
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_scrollWindowUp(byte numRows)
|
||||||
|
{
|
||||||
|
if (numRows == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Tell OS-9 to work in a window that only contains the text editing area, not the status line.
|
||||||
|
// This way, the status line does not get scrolled up.
|
||||||
|
setWorkingAreaExtraHeight(0);
|
||||||
|
|
||||||
|
// Move cursor to bottom row if not already on that row.
|
||||||
|
char goBottom[] = { 2, 32, (32 - 1) + os9term_height };
|
||||||
|
putstr(goBottom, sizeof(goBottom));
|
||||||
|
|
||||||
|
for ( ; numRows--; )
|
||||||
|
putchar(10); // cursor down
|
||||||
|
|
||||||
|
// Restore the OS-9 window that includes the status line.
|
||||||
|
setWorkingAreaExtraHeight(1);
|
||||||
|
|
||||||
|
// Restore original cursor position.
|
||||||
|
char restore[] = { 2, 32 + os9term_cursorCol, 32 + os9term_cursorRow };
|
||||||
|
putstr(restore, sizeof(restore));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_scrollWindowDown(byte numRows)
|
||||||
|
{
|
||||||
|
if (numRows == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Tell OS-9 to work in a window that only contains the text editing area, not the status line.
|
||||||
|
// This way, the status line does not get scrolled down.
|
||||||
|
// This puts the OS-9 cursor at the home position.
|
||||||
|
setWorkingAreaExtraHeight(0);
|
||||||
|
|
||||||
|
for ( ; numRows--; )
|
||||||
|
putstr("\x1F\x30", 2); // insert line, scroll the following lines down
|
||||||
|
|
||||||
|
// Restore the OS-9 window that includes the status line.
|
||||||
|
setWorkingAreaExtraHeight(1);
|
||||||
|
|
||||||
|
// Restore original cursor position.
|
||||||
|
char restore[] = { 2, 32 + os9term_cursorCol, 32 + os9term_cursorRow };
|
||||||
|
putstr(restore, sizeof(restore));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
os9term_eraseCurrentLine(void)
|
||||||
|
{
|
||||||
|
putchar(3);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
word
|
||||||
|
os9term_waitEditorKey(void)
|
||||||
|
{
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
byte key = (*os9term_waitKeyFuncPtr)(os9term_waitKeyFuncCookie);
|
||||||
|
|
||||||
|
switch (key)
|
||||||
|
{
|
||||||
|
case 177: // F1
|
||||||
|
// N.B.: If 'key' is 123 when pressing F1, it may be because
|
||||||
|
// the BControl library has been compiled for DECB
|
||||||
|
// instead of OS-9. In that case, recompile it by
|
||||||
|
// passing TARGET=os9 to make.
|
||||||
|
return ebitor_KEY_ESCAPE;
|
||||||
|
case 8: // left arrow
|
||||||
|
return ebitor_KEY_ARROW_LEFT;
|
||||||
|
case 9: // right arrow
|
||||||
|
return ebitor_KEY_ARROW_RIGHT;
|
||||||
|
case 12: // up arrow
|
||||||
|
return ebitor_KEY_ARROW_UP;
|
||||||
|
case 10: // down arrow
|
||||||
|
return ebitor_KEY_ARROW_DOWN;
|
||||||
|
case 16: // Ctrl-Left
|
||||||
|
return '\b'; // backspace
|
||||||
|
case 13: // Enter
|
||||||
|
return '\r';
|
||||||
|
default:
|
||||||
|
if (key >= ' ' && key != 127) // if not control char (127 = Delete)
|
||||||
|
return key;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,111 @@
|
|||||||
|
/* os9term.h - OS-9 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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
These functions implement a terminal compliant with the specs in Ebitor.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _H_os9term
|
||||||
|
#define _H_os9term
|
||||||
|
|
||||||
|
#include "Window.h"
|
||||||
|
|
||||||
|
|
||||||
|
// Returns the address of the 32x16 screen buffer is standard out
|
||||||
|
// is current in that mode. Otherwise, returns NULL.
|
||||||
|
//
|
||||||
|
byte *os9term_get32x16ScreenBuffer(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Returns an OS-9 error code upon failure, or 0 upon success
|
||||||
|
// (*screenTypeCode is then 1, 2 or 5..8).
|
||||||
|
// Suitable to be called when the terminal uses a GIME mode.
|
||||||
|
// Returns error code 208 when run in a 32x16 terminal.
|
||||||
|
//
|
||||||
|
byte os9term_getGIMEScreenType(byte *screenTypeCode);
|
||||||
|
|
||||||
|
|
||||||
|
// Defines a window in an OS-9 terminal.
|
||||||
|
//
|
||||||
|
// Assumes that there is an extra row below the designated window.
|
||||||
|
// For example, on a 40x25 screen, the window would be (40, 24, 0, 0),
|
||||||
|
// and the 25th row would be the status line.
|
||||||
|
//
|
||||||
|
// Does NOT clear the window (see os9term_clear()).
|
||||||
|
//
|
||||||
|
// width, height: Dimensions in characters of the window.
|
||||||
|
// winLeftCol, winTopRow: Zero-based coordinates of the top left of the window.
|
||||||
|
// waitKeyFuncPtr: Pointer to a function that waits until a key is pressed and
|
||||||
|
// returns its ASCII code, e.g., 65 for 'A', 12 for the up arrow.
|
||||||
|
// waitKeyFuncCookie: Value to be passed to (*waitKeyFuncPtr)().
|
||||||
|
//
|
||||||
|
// Returns 0 upon success, or an error code upon failure:
|
||||||
|
// 1: Terminal type not supported (e.g., the current terminal is 32x16).
|
||||||
|
// 2: Failed to determine is the screen is a GIME text screen.
|
||||||
|
// 3: The screen is in a GIME mode but not in a 40- or 80-column mode.
|
||||||
|
//
|
||||||
|
byte os9term_init(byte width, byte height,
|
||||||
|
byte winLeftCol, byte winTopRow,
|
||||||
|
byte (*waitKeyFuncPtr)(void *), void *waitKeyFuncCookie);
|
||||||
|
|
||||||
|
// Must be called before leaving the process.
|
||||||
|
//
|
||||||
|
void os9term_shutdown(void);
|
||||||
|
|
||||||
|
|
||||||
|
// Fills the window defined by os9term_init() with spaces.
|
||||||
|
// Does not move the cursor.
|
||||||
|
//
|
||||||
|
void os9term_clear(void);
|
||||||
|
|
||||||
|
// column, row: Coordinates relative to the window defined by os9term_init().
|
||||||
|
// Does not check if the parameters are valid.
|
||||||
|
// This may be useful to write outside the window, as long as no carriage return is written.
|
||||||
|
//
|
||||||
|
void os9term_locate(byte column, byte row);
|
||||||
|
|
||||||
|
// column, row: Receive coordinates relative to the window defined by os9term_init().
|
||||||
|
//
|
||||||
|
void os9term_getCursorPos(byte *column, byte *row);
|
||||||
|
|
||||||
|
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
|
||||||
|
//
|
||||||
|
BOOL os9term_print(const char *str);
|
||||||
|
|
||||||
|
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
|
||||||
|
//
|
||||||
|
BOOL os9term_printPrefix(const char *str, size_t prefixLength);
|
||||||
|
|
||||||
|
// Use inverted colors for the next print operations.
|
||||||
|
//
|
||||||
|
void os9term_invertColors(void);
|
||||||
|
|
||||||
|
void os9term_clrtoeol(void);
|
||||||
|
void os9term_scrollWindowUp(byte numRows);
|
||||||
|
void os9term_scrollWindowDown(byte numRows);
|
||||||
|
|
||||||
|
// Fills the line where the cursor is with spaces and puts the cursor at the start of this line.
|
||||||
|
//
|
||||||
|
void os9term_eraseCurrentLine(void);
|
||||||
|
|
||||||
|
// Returns an ASCII code or an ebitor_KEY_* code.
|
||||||
|
//
|
||||||
|
word os9term_waitEditorKey(void);
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* _H_os9term */
|
||||||
@@ -0,0 +1,109 @@
|
|||||||
|
/* processBackspace.c
|
||||||
|
|
||||||
|
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 "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_processBackspace(byte cursorCol, byte cursorRow)
|
||||||
|
{
|
||||||
|
Ebitor_startCommandMode();
|
||||||
|
|
||||||
|
// This check must be done after Ebitor_startCommandMode(), which can update cursorOffset
|
||||||
|
if (Ebitor_instance.cursorOffset == 0) // if at start of edit buffer
|
||||||
|
return; // nothing to do
|
||||||
|
|
||||||
|
size_t solOffset = Ebitor_findSOL(Ebitor_instance.cursorOffset);
|
||||||
|
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
|
||||||
|
|
||||||
|
// E.g.: ...ABCDEF..............FOOBAR
|
||||||
|
// ^ ^ ^ ^bufferFilledSize
|
||||||
|
// | | `eolOffset
|
||||||
|
// | `cursorOffset
|
||||||
|
// `solOffset
|
||||||
|
|
||||||
|
// Print rest of line at preceding position.
|
||||||
|
//
|
||||||
|
BOOL erasingPrevCR = (cursorCol == 0);
|
||||||
|
if (!erasingPrevCR)
|
||||||
|
{
|
||||||
|
--cursorCol;
|
||||||
|
}
|
||||||
|
else // at column 0:
|
||||||
|
{
|
||||||
|
if (Ebitor_instance.cursorOffset == solOffset) // if at start of logical line
|
||||||
|
{
|
||||||
|
// About to erase previous line's terminator.
|
||||||
|
assert(Ebitor_instance.bufferBegin[solOffset - 1] == '\r'); // b/c cursorOffset > 0, there must be a line before
|
||||||
|
|
||||||
|
size_t prevSOLOffset = Ebitor_findPreviousSOL(solOffset);
|
||||||
|
assert(prevSOLOffset < solOffset);
|
||||||
|
size_t prevLineLen = solOffset - prevSOLOffset - 1; // exclude \r
|
||||||
|
cursorCol = (byte) (prevLineLen % Ebitor_instance.termWidth); // after last char of previous line
|
||||||
|
if (cursorRow == 0)
|
||||||
|
{
|
||||||
|
Ebitor_instance.scrollTerminalDown(1);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + (solOffset - 1 - prevLineLen), prevLineLen);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
--cursorRow;
|
||||||
|
}
|
||||||
|
else // inside a logical line:
|
||||||
|
{
|
||||||
|
cursorCol = Ebitor_instance.termWidth - 1;
|
||||||
|
if (cursorRow == 0)
|
||||||
|
{
|
||||||
|
Ebitor_instance.scrollTerminalDown(1);
|
||||||
|
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + (Ebitor_instance.cursorOffset - Ebitor_instance.termWidth), Ebitor_instance.termWidth);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
--cursorRow;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert(cursorRow < Ebitor_instance.termHeight);
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
char *cursorPtr = Ebitor_instance.bufferBegin + Ebitor_instance.cursorOffset;
|
||||||
|
assert(Ebitor_instance.cursorOffset <= eolOffset);
|
||||||
|
size_t numCharsToPrint = eolOffset - Ebitor_instance.cursorOffset;
|
||||||
|
if (Ebitor_instance.printPrefix(cursorPtr, numCharsToPrint))
|
||||||
|
{
|
||||||
|
// We have not reached the end of the window.
|
||||||
|
|
||||||
|
Ebitor_instance.clrtoeol(); // erase last char of logical line
|
||||||
|
|
||||||
|
if (erasingPrevCR)
|
||||||
|
{
|
||||||
|
// Print the lines that follow the cursor row.
|
||||||
|
// This will make a new line visible at the bottom, if the text is long enough.
|
||||||
|
// TODO: This might be optimized by only writing the bottom row.
|
||||||
|
//
|
||||||
|
size_t firstLogicalCharOffsetToPrint = (eolOffset == Ebitor_instance.bufferFilledSize ? eolOffset : eolOffset + 1);
|
||||||
|
|
||||||
|
byte dummy, r;
|
||||||
|
Ebitor_instance.getCursorPos(&dummy, &r);
|
||||||
|
|
||||||
|
Ebitor_fillTerminalToBottom(firstLogicalCharOffsetToPrint, r + 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
|
||||||
|
memmove(cursorPtr - 1, cursorPtr, Ebitor_instance.bufferFilledSize - Ebitor_instance.cursorOffset);
|
||||||
|
--Ebitor_instance.cursorOffset;
|
||||||
|
--Ebitor_instance.bufferFilledSize;
|
||||||
|
}
|
||||||
@@ -0,0 +1,110 @@
|
|||||||
|
/* processPrintableChar.c
|
||||||
|
|
||||||
|
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 "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_processPrintableChar(word key, byte cursorCol, byte cursorRow)
|
||||||
|
{
|
||||||
|
if (key < 256)
|
||||||
|
{
|
||||||
|
// Reject if no room in edit buffer.
|
||||||
|
//
|
||||||
|
if (Ebitor_instance.bufferFilledSize + Ebitor_instance.insertBuffer.size + 1 > Ebitor_instance.bufferEnd - Ebitor_instance.bufferBegin)
|
||||||
|
return;
|
||||||
|
|
||||||
|
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
|
||||||
|
// eolOffset either designates a \r, or the end of the filled edit buffer.
|
||||||
|
|
||||||
|
// If the character is about to be printed on the last row, check if scrolling up is needed.
|
||||||
|
// Count the number of times a printable character will be printed in the last window column
|
||||||
|
// plus the number of carriage returns that will be printed, when printing the rest of the
|
||||||
|
// affected line.
|
||||||
|
// If a scroll is done, the cursor is moved one row up.
|
||||||
|
//
|
||||||
|
if (cursorRow == Ebitor_instance.termHeight - 1)
|
||||||
|
{
|
||||||
|
BOOL needScroll = FALSE;
|
||||||
|
byte col = cursorCol;
|
||||||
|
++col; // cursor position after printing 'key'
|
||||||
|
if (col == Ebitor_instance.termWidth) // if past last column
|
||||||
|
needScroll = TRUE;
|
||||||
|
const char *p = Ebitor_instance.bufferBegin + Ebitor_instance.cursorOffset;
|
||||||
|
const char *end = Ebitor_instance.bufferBegin + eolOffset;
|
||||||
|
//locate(0, 8); printf("[%u,%u]", Ebitor_instance.cursorOffset, eolOffset);
|
||||||
|
for ( ; p < end; ++p)
|
||||||
|
{
|
||||||
|
if (*p == '\r')
|
||||||
|
{
|
||||||
|
col = 0;
|
||||||
|
needScroll = TRUE;
|
||||||
|
}
|
||||||
|
else // *p is printable
|
||||||
|
{
|
||||||
|
++col;
|
||||||
|
if (col == Ebitor_instance.termWidth)
|
||||||
|
needScroll = TRUE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (needScroll)
|
||||||
|
{
|
||||||
|
Ebitor_instance.scrollTerminalUp(1);
|
||||||
|
--cursorRow;
|
||||||
|
assert(cursorRow >= 0);
|
||||||
|
assert(cursorRow < Ebitor_instance.termHeight);
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Print the character just typed.
|
||||||
|
//
|
||||||
|
char c = (char) key;
|
||||||
|
Ebitor_instance.printPrefix(&c, 1);
|
||||||
|
|
||||||
|
// Reprint the rest of the line, if any, while preserving the new cursor position.
|
||||||
|
//
|
||||||
|
size_t lenRest = eolOffset - Ebitor_instance.cursorOffset;
|
||||||
|
if (lenRest > 0)
|
||||||
|
{
|
||||||
|
Ebitor_instance.getCursorPos(&cursorCol, &cursorRow);
|
||||||
|
assert(cursorRow < Ebitor_instance.termHeight);
|
||||||
|
if (Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + Ebitor_instance.cursorOffset, lenRest))
|
||||||
|
{
|
||||||
|
// We did not reach the end of the window.
|
||||||
|
|
||||||
|
byte afterPrintCol, afterPrintRow;
|
||||||
|
Ebitor_instance.getCursorPos(&afterPrintCol, &afterPrintRow);
|
||||||
|
if (afterPrintCol == 0) // if printing ends at column 0
|
||||||
|
{
|
||||||
|
Ebitor_instance.print("\r"); // show an empty row
|
||||||
|
if (eolOffset < Ebitor_instance.bufferFilledSize // if something after current EOL
|
||||||
|
&& afterPrintRow + 1 < Ebitor_instance.termHeight) // and there is room in the terminal window
|
||||||
|
Ebitor_fillTerminalToBottom(eolOffset + 1, afterPrintRow + 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ebitor_instance.locate(cursorCol, cursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ebitor_instance.cursorOffset is not incremented here b/c 'c' is only
|
||||||
|
// added to the insert buffer. When the latter will be moved
|
||||||
|
// to the edit buffer, Ebitor_instance.cursorOffset will be incremented.
|
||||||
|
//
|
||||||
|
Ebitor_insertChar(c);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,104 @@
|
|||||||
|
/* scrollToShowLogicalOffset.c
|
||||||
|
|
||||||
|
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 "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
Ebitor_scrollToShowLogicalOffset(size_t logicalOffsetToShow, size_t lengthToShow)
|
||||||
|
{
|
||||||
|
Ebitor *self = &Ebitor_instance;
|
||||||
|
byte cursorCol = self->savedCursorCol, cursorRow = self->savedCursorRow;
|
||||||
|
|
||||||
|
size_t homeOffset, firstOffWindowOffset;
|
||||||
|
char code = Ebitor_isRegionVisible(logicalOffsetToShow, lengthToShow, cursorCol, cursorRow,
|
||||||
|
&homeOffset, &firstOffWindowOffset);
|
||||||
|
//printf("(%u,%u,%u->CODE=%d,HO=%u,F=%u)",
|
||||||
|
// logicalOffsetToShow, cursorCol, cursorRow, code, homeOffset, firstOffWindowOffset);
|
||||||
|
if (code < 0) // if region to show is before displayed text
|
||||||
|
{
|
||||||
|
size_t logicalOffsetAtStartOfTermRow;
|
||||||
|
size_t numTermRows = Ebitor_countRowsToScrollDown(logicalOffsetToShow, homeOffset, &logicalOffsetAtStartOfTermRow);
|
||||||
|
assert(numTermRows > 0);
|
||||||
|
if (numTermRows < self->termHeight) // if NOT scrolling all current rows off
|
||||||
|
{
|
||||||
|
assert(logicalOffsetAtStartOfTermRow <= logicalOffsetToShow);
|
||||||
|
assert(logicalOffsetToShow - logicalOffsetAtStartOfTermRow < self->termWidth);
|
||||||
|
self->scrollTerminalDown((byte) numTermRows);
|
||||||
|
}
|
||||||
|
else // redraw whole window
|
||||||
|
numTermRows = self->termHeight;
|
||||||
|
|
||||||
|
Ebitor_fillWindowFromHomeToRow(logicalOffsetAtStartOfTermRow, (byte) numTermRows);
|
||||||
|
|
||||||
|
byte cursorCol = (byte) (logicalOffsetToShow - logicalOffsetAtStartOfTermRow);
|
||||||
|
Ebitor_locateAndSavePos(cursorCol, 0);
|
||||||
|
}
|
||||||
|
else if (code > 0) // region to show is after displayed text
|
||||||
|
{
|
||||||
|
size_t numTermRows = Ebitor_countRowsToScrollUp(logicalOffsetToShow, firstOffWindowOffset);
|
||||||
|
assert(numTermRows > 0);
|
||||||
|
if (numTermRows < self->termHeight) // if NOT scrolling all current rows off
|
||||||
|
{
|
||||||
|
self->scrollTerminalUp((byte) numTermRows);
|
||||||
|
Ebitor_fillTerminalToBottom(firstOffWindowOffset, self->termHeight - (byte) numTermRows);
|
||||||
|
}
|
||||||
|
else // redraw whole window
|
||||||
|
{
|
||||||
|
size_t newHomeOffset = Ebitor_goDownRows(homeOffset, numTermRows);
|
||||||
|
assert(newHomeOffset <= self->bufferFilledSize);
|
||||||
|
Ebitor_fillWindowFromHomeToRow(newHomeOffset, self->termHeight);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t solOffset = Ebitor_findSOL(logicalOffsetToShow);
|
||||||
|
byte cursorCol = (byte) ((logicalOffsetToShow - solOffset) % self->termWidth);
|
||||||
|
Ebitor_locateAndSavePos(cursorCol, self->termHeight - 1);
|
||||||
|
}
|
||||||
|
else // code == 0: region is complete in displayed text
|
||||||
|
{
|
||||||
|
// Locate the cursor at logicalOffsetToShow.
|
||||||
|
byte cursorCol = 0, cursorRow = 0; // position of homeOffset
|
||||||
|
size_t offset = homeOffset;
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
// Here, offset is in column 0 of the terminal.
|
||||||
|
//
|
||||||
|
size_t eolOffset = Ebitor_findEOL(offset);
|
||||||
|
if (logicalOffsetToShow <= eolOffset) // if target position is on current logical line
|
||||||
|
{
|
||||||
|
cursorCol = (byte) ((logicalOffsetToShow - offset) % self->termWidth);
|
||||||
|
cursorRow += (byte) ((logicalOffsetToShow - offset) / self->termWidth);
|
||||||
|
// No overflow possible b/c we know logicalOffsetToShow is on window
|
||||||
|
|
||||||
|
assert(cursorRow < self->termHeight);
|
||||||
|
Ebitor_locateAndSavePos(cursorCol, cursorRow);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
assert(eolOffset < self->bufferFilledSize); // b/c logicalOffsetToShow is after eolOffset
|
||||||
|
size_t numRowsInLine = (eolOffset - offset) / self->termWidth + 1;
|
||||||
|
assert(cursorRow + numRowsInLine < self->termHeight);
|
||||||
|
// No overflow possible b/c we know logicalOffsetToShow is on window
|
||||||
|
|
||||||
|
offset = eolOffset + 1; // go to char after \r; this char is at column 0
|
||||||
|
cursorRow += (byte) numRowsInLine;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self->cursorOffset = logicalOffsetToShow;
|
||||||
|
}
|
||||||
@@ -0,0 +1,318 @@
|
|||||||
|
/* sg4term.c - CoCo 32x16 SG4 mode (6847) 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 "sg4term.h"
|
||||||
|
|
||||||
|
#include "Ebitor_private.h"
|
||||||
|
|
||||||
|
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
sg4term_SPACE_CODE = 0x60,
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
struct Ebitor;
|
||||||
|
|
||||||
|
|
||||||
|
static byte sg4term_width, sg4term_height; // max 32x16
|
||||||
|
static byte sg4term_winLeftCol, sg4term_winTopRow; // 0..31, 0..15
|
||||||
|
static char *sg4term_screenBuffer; // address of 32x16 screen buffer
|
||||||
|
static byte sg4term_cursorCol, sg4term_cursorRow; // lower than sg4term_winLeftCol, sg4term_winTopRow
|
||||||
|
static byte (*sg4term_inkeyFuncPtr)(void *cookie); // returns 0 if no key pressed
|
||||||
|
static void *sg4term_inkeyFuncCookie; // argument passed to sg4term_inkeyFuncPtr
|
||||||
|
static word *sg4term_timerPtr; // points to a word that gets incremented 60 times per second
|
||||||
|
static char sg4term_attributeInversionFlag;
|
||||||
|
|
||||||
|
|
||||||
|
static char *
|
||||||
|
getPosInWindow(byte col, byte row)
|
||||||
|
{
|
||||||
|
return sg4term_screenBuffer + ((word) (sg4term_winTopRow + row) << 5) + (sg4term_winLeftCol + col);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#define getCursorAddress() (getPosInWindow(sg4term_cursorCol, sg4term_cursorRow))
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
sg4term_clearRowsAt(char *rowStartDest, byte numRows)
|
||||||
|
{
|
||||||
|
char value = sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag;
|
||||||
|
for (byte i = numRows; i--; rowStartDest += 32) // for each window row to clear
|
||||||
|
memset(rowStartDest, value, sg4term_width);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_clear(void)
|
||||||
|
{
|
||||||
|
sg4term_clearRowsAt(getPosInWindow(0, 0), sg4term_height);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_init(char *screenBuffer, const ebitor_Window *window,
|
||||||
|
byte (*inkeyFuncPtr)(void *), void *inkeyFuncCookie, word *timerPtr)
|
||||||
|
{
|
||||||
|
sg4term_screenBuffer = screenBuffer;
|
||||||
|
sg4term_width = window->width;
|
||||||
|
sg4term_height = window->height;
|
||||||
|
sg4term_winLeftCol = window->leftCol;
|
||||||
|
sg4term_winTopRow = window->topRow;
|
||||||
|
sg4term_cursorCol = window->cursorCol;
|
||||||
|
sg4term_cursorRow = window->cursorRow;
|
||||||
|
sg4term_inkeyFuncPtr = inkeyFuncPtr;
|
||||||
|
sg4term_inkeyFuncCookie = inkeyFuncCookie;
|
||||||
|
sg4term_timerPtr = timerPtr;
|
||||||
|
sg4term_attributeInversionFlag = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_locate(byte column, byte row)
|
||||||
|
{
|
||||||
|
sg4term_cursorCol = column;
|
||||||
|
sg4term_cursorRow = row;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_getCursorPos(byte *column, byte *row)
|
||||||
|
{
|
||||||
|
*column = sg4term_cursorCol;
|
||||||
|
*row = sg4term_cursorRow;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static BOOL
|
||||||
|
sg4term_newline(void)
|
||||||
|
{
|
||||||
|
sg4term_cursorCol = 0; // back to start of window row
|
||||||
|
if (++sg4term_cursorRow >= sg4term_height)
|
||||||
|
{
|
||||||
|
--sg4term_cursorRow;
|
||||||
|
sg4term_cursorCol = 0; // back to start of last row (avoid writing outside window)
|
||||||
|
return FALSE; // reached end of window
|
||||||
|
}
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
asm char
|
||||||
|
sg4term_convertASCIIToScreenByte(char c)
|
||||||
|
{
|
||||||
|
asm
|
||||||
|
{
|
||||||
|
ldb 3,s // low byte of 'c' (big endian)
|
||||||
|
cmpb #64
|
||||||
|
blo @typo // typographical char
|
||||||
|
cmpb #96
|
||||||
|
blo @done // upper-case letter
|
||||||
|
cmpb #128
|
||||||
|
bhs @done // graphical char
|
||||||
|
subb #96 // lower-case letter
|
||||||
|
bra @store
|
||||||
|
@typo
|
||||||
|
addb #64
|
||||||
|
@store
|
||||||
|
stb 3,s
|
||||||
|
@done
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// CAUTION: This function does NOT scroll when it reaches the end of the window.
|
||||||
|
// Character 13 does a carriage return and line feed AND clears
|
||||||
|
// the rest of the row it is applied to (with spaces).
|
||||||
|
// No other control code is supported.
|
||||||
|
//
|
||||||
|
static BOOL
|
||||||
|
sg4term_putchar(int c)
|
||||||
|
{
|
||||||
|
char *cursor = getCursorAddress();
|
||||||
|
if (c == '\r')
|
||||||
|
{
|
||||||
|
char charToWrite = sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag;
|
||||||
|
for ( ; sg4term_cursorCol < sg4term_width; ++sg4term_cursorCol)
|
||||||
|
*cursor++ = charToWrite;
|
||||||
|
return sg4term_newline();
|
||||||
|
}
|
||||||
|
|
||||||
|
*cursor++ = sg4term_convertASCIIToScreenByte((char) c) ^ sg4term_attributeInversionFlag;
|
||||||
|
if (++sg4term_cursorCol >= sg4term_width) // if past end of window row
|
||||||
|
return sg4term_newline();
|
||||||
|
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
BOOL
|
||||||
|
sg4term_print(const char *str)
|
||||||
|
{
|
||||||
|
for ( ; *str; ++str)
|
||||||
|
if (!sg4term_putchar(*str))
|
||||||
|
return FALSE; // reached end of window
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
BOOL
|
||||||
|
sg4term_printPrefix(const char *str, size_t prefixLength)
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < prefixLength; ++i)
|
||||||
|
if (!sg4term_putchar(str[i]))
|
||||||
|
return FALSE; // reached end of window
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_invertColors(void)
|
||||||
|
{
|
||||||
|
sg4term_attributeInversionFlag ^= 0x40;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Does not move the cursor.
|
||||||
|
//
|
||||||
|
void
|
||||||
|
sg4term_clrtoeol(void)
|
||||||
|
{
|
||||||
|
memset(getCursorAddress(), sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag, sg4term_width - sg4term_cursorCol);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_scrollWindowUp(byte numRows)
|
||||||
|
{
|
||||||
|
if (numRows == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
char *rowStartDest = getPosInWindow(0, 0); // top window row
|
||||||
|
const char *rowStartSrc = rowStartDest + ((word) numRows << 5);
|
||||||
|
|
||||||
|
for (byte i = sg4term_height - numRows; i--; rowStartSrc += 32, rowStartDest += 32) // for each window row to scroll
|
||||||
|
memmove(rowStartDest, rowStartSrc, sg4term_width);
|
||||||
|
sg4term_clearRowsAt(rowStartDest, numRows);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_scrollWindowDown(byte numRows)
|
||||||
|
{
|
||||||
|
if (numRows == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
char *rowStartDest = getPosInWindow(0, sg4term_height - 1); // bottom window row
|
||||||
|
const char *rowStartSrc = rowStartDest - ((word) numRows << 5);
|
||||||
|
|
||||||
|
for (byte i = sg4term_height - numRows; i--; rowStartSrc -= 32, rowStartDest -= 32) // for each window row to scroll
|
||||||
|
memmove(rowStartDest, rowStartSrc, sg4term_width);
|
||||||
|
byte c = sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag;
|
||||||
|
for (byte i = numRows; i--; rowStartDest -= 32) // for each window row to clear
|
||||||
|
memset(rowStartDest, c, sg4term_width);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_eraseCurrentLine(void)
|
||||||
|
{
|
||||||
|
memset(getPosInWindow(0, sg4term_cursorRow), sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag, sg4term_width);
|
||||||
|
sg4term_cursorCol = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
word
|
||||||
|
sg4term_waitEditorKey(void)
|
||||||
|
{
|
||||||
|
char *cursor = getCursorAddress();
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
byte origByteOnScreen = *cursor;
|
||||||
|
|
||||||
|
// Wait for key with animated cursor if sg4term_timerPtr is not null.
|
||||||
|
// Otherwise, wait for key with inverted character at cursor.
|
||||||
|
byte key;
|
||||||
|
if (sg4term_timerPtr == NULL)
|
||||||
|
{
|
||||||
|
*cursor = origByteOnScreen ^ 0x40;
|
||||||
|
do
|
||||||
|
key = (*sg4term_inkeyFuncPtr)(sg4term_inkeyFuncCookie);
|
||||||
|
while (key == 0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
for (word startTime = *sg4term_timerPtr; ; )
|
||||||
|
{
|
||||||
|
key = (*sg4term_inkeyFuncPtr)(sg4term_inkeyFuncCookie);
|
||||||
|
if (key)
|
||||||
|
break;
|
||||||
|
*cursor = origByteOnScreen ^ (((*sg4term_timerPtr - startTime) & 0x38) == 0x38 ? 0x00 : 0x40);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
*cursor = origByteOnScreen;
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static char
|
||||||
|
sg4term_convertScreenByteToASCII(char b)
|
||||||
|
{
|
||||||
|
if ((byte) b >= 128)
|
||||||
|
return 0; // 128..255: no equivalent in ASCII
|
||||||
|
if (b < 32)
|
||||||
|
return b + 96;
|
||||||
|
if (b < 64) // 32..63
|
||||||
|
return 0; // no equivalent in ASCII
|
||||||
|
if (b < 96) // 64..95
|
||||||
|
return b;
|
||||||
|
return b - 64; // 96..127
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
sg4term_getChars(byte column, byte row, char *dest, size_t len)
|
||||||
|
{
|
||||||
|
assert(column < sg4term_width && row < sg4term_height);
|
||||||
|
const char *p = getPosInWindow(column, row);
|
||||||
|
for (size_t i = len; i--; )
|
||||||
|
*dest++ = sg4term_convertScreenByteToASCII(*p++);
|
||||||
|
}
|
||||||
@@ -0,0 +1,95 @@
|
|||||||
|
/* sg4term.h - CoCo 32x16 SG4 mode (6847) 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/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
These functions implement a terminal compliant with the specs in Ebitor.h
|
||||||
|
in a sub-window of a CoCo 32x16 screen (SG4 mode).
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _H_sg4term
|
||||||
|
#define _H_sg4term
|
||||||
|
|
||||||
|
#include "Window.h"
|
||||||
|
|
||||||
|
|
||||||
|
// Defines a window in a 6847 screen in 32x16 (SG4) mode.
|
||||||
|
// Does NOT clear the window.
|
||||||
|
// screenBuffer: Address of the 32x16 screen.
|
||||||
|
// width: 2..32.
|
||||||
|
// height: 2..16.
|
||||||
|
// winLeftCol: 0..30.
|
||||||
|
// winTopRow: 0..14.
|
||||||
|
// inkeyFuncPtr: Must return 0 (and not block) if no key pressed.
|
||||||
|
// inkeyFuncCookie: Will be passed to inkeyFuncPtr.
|
||||||
|
// timerPtr: Address of an unsigned 16-bit integer that gets incremented 60 times per second.
|
||||||
|
// If NULL, the cursor will not be animated.
|
||||||
|
//
|
||||||
|
void sg4term_init(char *screenBuffer, const ebitor_Window *window,
|
||||||
|
byte (*inkeyFuncPtr)(void *cookie), void *inkeyFuncCookie, word *timerPtr);
|
||||||
|
|
||||||
|
|
||||||
|
// Fills the window defined by sg4term_init() with spaces.
|
||||||
|
//
|
||||||
|
void sg4term_clear(void);
|
||||||
|
|
||||||
|
// column, row: Coordinates relative to the window defined by sg4term_init().
|
||||||
|
// Does not check if the parameters are valid.
|
||||||
|
// This may be useful to write outside the window, as long as no carriage return is written.
|
||||||
|
//
|
||||||
|
void sg4term_locate(byte column, byte row);
|
||||||
|
|
||||||
|
// column, row: Receive coordinates relative to the window defined by sg4term_init().
|
||||||
|
//
|
||||||
|
void sg4term_getCursorPos(byte *column, byte *row);
|
||||||
|
|
||||||
|
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
|
||||||
|
//
|
||||||
|
BOOL sg4term_print(const char *str);
|
||||||
|
|
||||||
|
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
|
||||||
|
//
|
||||||
|
BOOL sg4term_printPrefix(const char *str, size_t prefixLength);
|
||||||
|
|
||||||
|
// Use inverted colors for the next print operations.
|
||||||
|
//
|
||||||
|
void sg4term_invertColors(void);
|
||||||
|
|
||||||
|
void sg4term_clrtoeol(void);
|
||||||
|
void sg4term_scrollWindowUp(byte numRows);
|
||||||
|
void sg4term_scrollWindowDown(byte numRows);
|
||||||
|
|
||||||
|
// Fills the line where the cursor is with spaces and puts the cursor at the start of this line.
|
||||||
|
//
|
||||||
|
void sg4term_eraseCurrentLine(void);
|
||||||
|
|
||||||
|
// Animates a cursor while waiting.
|
||||||
|
// Returns an ASCII code or an ebitor_KEY_* code.
|
||||||
|
//
|
||||||
|
word sg4term_waitEditorKey(void);
|
||||||
|
|
||||||
|
// Converts an ASCII code to a 6847 SG4 character code.
|
||||||
|
// Negative codes (graphics characters) are returned unmodified.
|
||||||
|
//
|
||||||
|
char sg4term_convertASCIIToScreenByte(char c);
|
||||||
|
|
||||||
|
// Returns ASCII codes in dest[0..len-1]. Does nothing if len is 0.
|
||||||
|
//
|
||||||
|
void sg4term_getChars(byte column, byte row, char *dest, size_t len);
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* _H_sg4term */
|
||||||
+153
@@ -0,0 +1,153 @@
|
|||||||
|
/* smoldemo.c - Minimal demo of the Ebitor full screen text editor.
|
||||||
|
By Pierre Sarrazin <http://sarrazip.com/>
|
||||||
|
This file is in the public domain.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "sg4term.h" /* 32x16 terminal to be used by the editor */
|
||||||
|
#include "Ebitor.h" /* the editor */
|
||||||
|
|
||||||
|
#include <assert.h>
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
BASIC_TIMER_ADDRESS = 0x112, // incremented 60 times per second by Basic IRQ routine
|
||||||
|
BASIC_32X16_SCREEN = 0x0400, // address of 32x16 screen buffer
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
// Contains the edited text.
|
||||||
|
//
|
||||||
|
char textBuffer[600];
|
||||||
|
|
||||||
|
|
||||||
|
// newStatus: Must be shorter than the terminal width.
|
||||||
|
// Does not move the terminal cursor.
|
||||||
|
//
|
||||||
|
static void
|
||||||
|
setStatus(const ebitor_Window *window, const char *newStatus)
|
||||||
|
{
|
||||||
|
byte origCursorCol, origCursorRow;
|
||||||
|
sg4term_getCursorPos(&origCursorCol, &origCursorRow);
|
||||||
|
|
||||||
|
sg4term_locate(0, window->height); // cursor deliberately on row below window
|
||||||
|
sg4term_invertColors();
|
||||||
|
sg4term_eraseCurrentLine(); // also puts cursor at start of line
|
||||||
|
sg4term_print(newStatus);
|
||||||
|
sg4term_invertColors();
|
||||||
|
|
||||||
|
sg4term_locate(origCursorCol, origCursorRow);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
showHelp(const ebitor_Window *window)
|
||||||
|
{
|
||||||
|
sg4term_clear();
|
||||||
|
setStatus(window, "HELP PAGE");
|
||||||
|
sg4term_locate(0, 0);
|
||||||
|
sg4term_print(
|
||||||
|
"BACKSPACE IS THE CLEAR KEY.\r"
|
||||||
|
"\r"
|
||||||
|
"COMMANDS AFTER PRESSING BREAK:"
|
||||||
|
"\r"
|
||||||
|
"Q: QUIT THIS EDITOR\r"
|
||||||
|
"H: SHOW THIS HELP PAGE\r"
|
||||||
|
"\r"
|
||||||
|
"PRESS A KEY TO CONTINUE: ");
|
||||||
|
sg4term_waitEditorKey();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static byte
|
||||||
|
inkey1(void *cookie)
|
||||||
|
{
|
||||||
|
return inkey();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Does not animate a cursor.
|
||||||
|
//
|
||||||
|
byte
|
||||||
|
waitUpperCaseKey(void)
|
||||||
|
{
|
||||||
|
byte key;
|
||||||
|
while ((key = (byte) toupper(inkey())) == 0)
|
||||||
|
;
|
||||||
|
return key;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
int
|
||||||
|
main()
|
||||||
|
{
|
||||||
|
width(32); // on a CoCo 3, switches to 32x16 if not already in that mode
|
||||||
|
rgb(); // on a CoCo 3, resets the palette in case it is not at the default
|
||||||
|
|
||||||
|
ebitor_Window window;
|
||||||
|
|
||||||
|
window.cursorCol = window.cursorRow = 0;
|
||||||
|
|
||||||
|
// Specify a window for the editor.
|
||||||
|
// A border is left unused, to show that the sg4 driver
|
||||||
|
// can use a subwindow of the screen.
|
||||||
|
// Excludes the status line, which this demo renders below this window.
|
||||||
|
window.width = 32 - 2;
|
||||||
|
window.height = 16 - 3;
|
||||||
|
window.leftCol = 1;
|
||||||
|
window.topRow = 1;
|
||||||
|
|
||||||
|
width(32); // by SECB
|
||||||
|
cls(3);
|
||||||
|
sg4term_init((char *) BASIC_32X16_SCREEN, &window,
|
||||||
|
inkey1, NULL, (word *) BASIC_TIMER_ADDRESS);
|
||||||
|
|
||||||
|
Ebitor_init(textBuffer, sizeof(textBuffer),
|
||||||
|
window.width, window.height,
|
||||||
|
sg4term_clear,
|
||||||
|
sg4term_locate,
|
||||||
|
sg4term_getCursorPos,
|
||||||
|
sg4term_print,
|
||||||
|
sg4term_printPrefix,
|
||||||
|
sg4term_clrtoeol,
|
||||||
|
sg4term_scrollWindowUp,
|
||||||
|
sg4term_scrollWindowDown,
|
||||||
|
sg4term_waitEditorKey);
|
||||||
|
|
||||||
|
// Main editing loop.
|
||||||
|
//
|
||||||
|
for (BOOL refresh = TRUE, resetStatus = TRUE; ; )
|
||||||
|
{
|
||||||
|
if (resetStatus)
|
||||||
|
setStatus(&window, "PRESS BREAK FOR MENU");
|
||||||
|
else
|
||||||
|
resetStatus = TRUE;
|
||||||
|
|
||||||
|
Ebitor_processEditing(refresh);
|
||||||
|
|
||||||
|
refresh = FALSE;
|
||||||
|
|
||||||
|
setStatus(&window, "Q=QUIT, H=HELP");
|
||||||
|
byte key = waitUpperCaseKey();
|
||||||
|
if (key == 3) // if break key
|
||||||
|
continue; // back to processing
|
||||||
|
if (key == 'Q')
|
||||||
|
break; // quit
|
||||||
|
switch ((char) key)
|
||||||
|
{
|
||||||
|
case 'H':
|
||||||
|
showHelp(&window);
|
||||||
|
refresh = TRUE;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ebitor_shutdown();
|
||||||
|
|
||||||
|
cls(255); // equivalent to Basic's CLS command without an argument
|
||||||
|
printf("FINAL TEXT:\n\n%s\n", textBuffer);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
Reference in new issue
Block a user