| /* |
| * BRLTTY - A background process providing access to the console screen (when in |
| * text mode) for a blind person using a refreshable braille display. |
| * |
| * Copyright (C) 1995-2023 by The BRLTTY Developers. |
| * |
| * BRLTTY comes with ABSOLUTELY NO WARRANTY. |
| * |
| * This is free software, placed under the terms of the |
| * GNU Lesser General Public License, as published by the Free Software |
| * Foundation; either version 2.1 of the License, or (at your option) any |
| * later version. Please see the file LICENSE-LGPL for details. |
| * |
| * Web Page: http://brltty.app/ |
| * |
| * This software is maintained by Dave Mielke <dave@mielke.cc>. |
| */ |
| |
| /* LogText/braille.c - Braille display library |
| * For Tactilog's LogText |
| * Author: Dave Mielke <dave@mielke.cc> |
| */ |
| |
| #include "prologue.h" |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| |
| #include "log.h" |
| #include "file.h" |
| #include "device.h" |
| #include "async_wait.h" |
| #include "ascii.h" |
| |
| #define BRL_STATUS_FIELDS sfGeneric |
| #define BRL_HAVE_STATUS_CELLS |
| #include "brl_driver.h" |
| #include "braille.h" |
| #include "io_serial.h" |
| |
| static SerialDevice *serialDevice = NULL; |
| |
| #define screenHeight 25 |
| #define screenWidth 80 |
| typedef unsigned char ScreenImage[screenHeight][screenWidth]; |
| static ScreenImage sourceImage; |
| static ScreenImage targetImage; |
| |
| static const char *downloadPath = "logtext-download"; |
| |
| typedef enum { |
| DEV_OFFLINE, |
| DEV_ONLINE, |
| DEV_READY |
| } DeviceStatus; |
| static DeviceStatus deviceStatus; |
| |
| static KeyTableCommandContext currentContext; |
| static unsigned char currentLine; |
| static unsigned char cursorRow; |
| static unsigned char cursorColumn; |
| |
| #ifndef __MINGW32__ |
| static int |
| makeFifo (const char *path, mode_t mode) { |
| struct stat status; |
| if (lstat(path, &status) != -1) { |
| if (S_ISFIFO(status.st_mode)) return 1; |
| logMessage(LOG_ERR, "Download object not a FIFO: %s", path); |
| } else if (errno == ENOENT) { |
| lockUmask(); |
| mode_t mask = umask(0); |
| int result = mkfifo(path, mode); |
| int error = errno; |
| umask(mask); |
| unlockUmask(); |
| |
| if (result != -1) return 1; |
| errno = error; |
| logSystemError("Download FIFO creation"); |
| } |
| return 0; |
| } |
| #endif /* __MINGW32__ */ |
| |
| static int |
| makeDownloadFifo (void) { |
| #ifdef __MINGW32__ |
| return 0; |
| #else /* __MINGW32__ */ |
| return makeFifo(downloadPath, S_IRUSR|S_IWUSR|S_IWGRP|S_IWOTH); |
| #endif /* __MINGW32__ */ |
| } |
| |
| static int |
| brl_construct (BrailleDisplay *brl, char **parameters, const char *device) { |
| { |
| static TranslationTable outputTable = { |
| #include "brl-out.h" |
| }; |
| |
| setOutputTable(outputTable); |
| makeInputTable(); |
| |
| { |
| const unsigned char byte = 0XFF; |
| |
| if (memchr(outputTable, byte, sizeof(outputTable))) { |
| outputTable[translateInputCell(byte)] = ASCII_SUB; |
| } |
| } |
| } |
| |
| if (!isSerialDeviceIdentifier(&device)) { |
| unsupportedDeviceIdentifier(device); |
| return 0; |
| } |
| |
| makeDownloadFifo(); |
| if ((serialDevice = serialOpenDevice(device))) { |
| if (serialRestartDevice(serialDevice, 9600)) { |
| brl->textRows = screenHeight; |
| brl->textColumns = screenWidth; |
| brl->buffer = &sourceImage[0][0]; |
| memset(sourceImage, 0, sizeof(sourceImage)); |
| deviceStatus = DEV_ONLINE; |
| return 1; |
| } |
| serialCloseDevice(serialDevice); |
| serialDevice = NULL; |
| } |
| return 0; |
| } |
| |
| static void |
| brl_destruct (BrailleDisplay *brl) { |
| serialCloseDevice(serialDevice); |
| serialDevice = NULL; |
| } |
| |
| static int |
| checkData (const unsigned char *data, unsigned int length) { |
| if ((length < 5) || (length != (data[4] + 5))) { |
| logMessage(LOG_ERR, "Bad length: %d", length); |
| } else if (data[0] != 255) { |
| logMessage(LOG_ERR, "Bad header: %d", data[0]); |
| } else if ((data[1] < 1) || (data[1] > screenHeight)) { |
| logMessage(LOG_ERR, "Bad line: %d", data[1]); |
| } else if (data[2] > screenWidth) { |
| logMessage(LOG_ERR, "Bad cursor: %d", data[2]); |
| } else if ((data[3] < 1) || (data[3] > screenWidth)) { |
| logMessage(LOG_ERR, "Bad column: %d", data[3]); |
| } else if (data[4] > (screenWidth - (data[3] - 1))) { |
| logMessage(LOG_ERR, "Bad count: %d", data[4]); |
| } else { |
| return 1; |
| } |
| return 0; |
| } |
| |
| static int |
| sendBytes (const unsigned char *bytes, size_t count) { |
| if (serialWriteData(serialDevice, bytes, count) == -1) { |
| logSystemError("LogText write"); |
| return 0; |
| } |
| return 1; |
| } |
| |
| static int |
| sendData (unsigned char line, unsigned char column, unsigned char count) { |
| unsigned char data[5 + count]; |
| unsigned char *target = data; |
| unsigned char *source = &targetImage[line][column]; |
| *target++ = 0XFF; |
| *target++ = line + 1; |
| *target++ = (line == cursorRow)? cursorColumn+1: 0; |
| *target++ = column + 1; |
| *target++ = count; |
| logBytes(LOG_DEBUG, "Output dots", source, count); |
| target = translateOutputCells(target, source, count); |
| count = target - data; |
| logBytes(LOG_DEBUG, "LogText write", data, count); |
| if (checkData(data, count)) { |
| if (sendBytes(data, count)) { |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| static int |
| sendLine (unsigned char line, int force) { |
| unsigned char *source = &sourceImage[line][0]; |
| unsigned char *target = &targetImage[line][0]; |
| unsigned char start = 0; |
| unsigned char count = screenWidth; |
| while (count > 0) { |
| if (source[count-1] != target[count-1]) break; |
| --count; |
| } |
| while (start < count) { |
| if (source[start] != target[start]) break; |
| ++start; |
| } |
| if ((count -= start) || force) { |
| logMessage(LOG_DEBUG, "LogText line: line=%d, column=%d, count=%d", line, start, count); |
| memcpy(&target[start], &source[start], count); |
| if (!sendData(line, start, count)) { |
| return 0; |
| } |
| } |
| return 1; |
| } |
| |
| static int |
| sendCurrentLine (void) { |
| return sendLine(currentLine, 0); |
| } |
| |
| static int |
| sendCursorRow (void) { |
| return sendLine(cursorRow, 1); |
| } |
| |
| static int |
| handleUpdate (unsigned char line) { |
| logMessage(LOG_DEBUG, "Request line: (0X%2.2X) 0X%2.2X dec=%d", KEY_UPDATE, line, line); |
| if (!line) return sendCursorRow(); |
| if (line <= screenHeight) { |
| currentLine = line - 1; |
| return sendCurrentLine(); |
| } |
| logMessage(LOG_WARNING, "Invalid line request: %d", line); |
| return 1; |
| } |
| |
| static int |
| brl_writeWindow (BrailleDisplay *brl, const wchar_t *text) { |
| if (deviceStatus == DEV_READY) { |
| sendCurrentLine(); |
| } |
| return 1; |
| } |
| |
| static int |
| isOnline (void) { |
| int online = serialTestLineDSR(serialDevice); |
| if (online) { |
| if (deviceStatus < DEV_ONLINE) { |
| deviceStatus = DEV_ONLINE; |
| logMessage(LOG_WARNING, "LogText online."); |
| } |
| } else { |
| if (deviceStatus > DEV_OFFLINE) { |
| deviceStatus = DEV_OFFLINE; |
| logMessage(LOG_WARNING, "LogText offline."); |
| } |
| } |
| return online; |
| } |
| |
| static int |
| brl_writeStatus (BrailleDisplay *brl, const unsigned char *status) { |
| if (isOnline()) { |
| if (status[GSC_FIRST] == GSC_MARKER) { |
| unsigned char row = status[gscScreenCursorRow]; |
| unsigned char column = status[gscScreenCursorColumn]; |
| row = MAX(1, MIN(row, screenHeight)) - 1; |
| column = MAX(1, MIN(column, screenWidth)) - 1; |
| if (deviceStatus < DEV_READY) { |
| memset(targetImage, 0, sizeof(targetImage)); |
| currentContext = KTB_CTX_DEFAULT; |
| currentLine = row; |
| cursorRow = screenHeight; |
| cursorColumn = screenWidth; |
| deviceStatus = DEV_READY; |
| } |
| if ((row != cursorRow) || (column != cursorColumn)) { |
| logMessage(LOG_DEBUG, "cursor moved: [%d,%d] -> [%d,%d]", cursorColumn, cursorRow, column, row); |
| cursorRow = row; |
| cursorColumn = column; |
| sendCursorRow(); |
| } |
| } |
| } |
| return 1; |
| } |
| |
| static int |
| readKey (void) { |
| unsigned char key; |
| unsigned char arg; |
| if (serialReadData(serialDevice, &key, 1, 0, 0) != 1) return EOF; |
| switch (key) { |
| default: |
| arg = 0; |
| break; |
| case KEY_FUNCTION: |
| case KEY_FUNCTION2: |
| case KEY_UPDATE: |
| while (serialReadData(serialDevice, &arg, 1, 0, 0) != 1) asyncWait(1); |
| break; |
| } |
| { |
| int result = COMPOUND_KEY(key, arg); |
| logMessage(LOG_DEBUG, "Key read: %4.4X", result); |
| return result; |
| } |
| } |
| |
| /*askUser |
| static unsigned char *selectedLine; |
| |
| static void |
| replaceCharacters (const unsigned char *address, size_t count) { |
| translateInputCells(&selectedLine[cursorColumn], address, count); |
| cursorColumn += count; |
| } |
| |
| static void |
| insertCharacters (const unsigned char *address, size_t count) { |
| memmove(&selectedLine[cursorColumn+count], &selectedLine[cursorColumn], screenWidth-cursorColumn-count); |
| replaceCharacters(address, count); |
| } |
| |
| static void |
| deleteCharacters (size_t count) { |
| memmove(&selectedLine[cursorColumn], &selectedLine[cursorColumn+count], screenWidth-cursorColumn-count); |
| memset(&selectedLine[screenWidth-count], translateInputCell(' '), count); |
| } |
| |
| static void |
| clearCharacters (void) { |
| cursorColumn = 0; |
| deleteCharacters(screenWidth); |
| } |
| |
| static void |
| selectLine (unsigned char line) { |
| selectedLine = &sourceImage[cursorRow = line][0]; |
| clearCharacters(); |
| deviceStatus = DEV_ONLINE; |
| } |
| |
| static unsigned char * |
| askUser (const unsigned char *prompt) { |
| unsigned char from; |
| unsigned char to; |
| selectLine(screenHeight-1); |
| logMessage(LOG_DEBUG, "Prompt: %s", prompt); |
| replaceCharacters(prompt, strlen(prompt)); |
| from = to = ++cursorColumn; |
| sendCursorRow(); |
| while (1) { |
| int key = readKey(); |
| if (key == EOF) { |
| asyncWait(1); |
| continue; |
| } |
| if ((key & KEY_MASK) == KEY_UPDATE) { |
| handleUpdate(key >> KEY_SHIFT); |
| continue; |
| } |
| if (isgraph(key)) { |
| if (to < screenWidth) { |
| unsigned char character = key & KEY_MASK; |
| insertCharacters(&character, 1); |
| ++to; |
| } else { |
| ringConsoleBell(); |
| } |
| } else { |
| switch (key) { |
| case CR: |
| if (to > from) { |
| size_t length = to - from; |
| unsigned char *response = malloc(length+1); |
| if (response) { |
| translateOutputCells(response, &selectedLine[from], length); |
| response[length] = 0; |
| logMessage(LOG_DEBUG, "Response: %s", response); |
| return response; |
| } else { |
| logSystemError("Download file path allocation"); |
| } |
| } |
| return NULL; |
| case BS: |
| if (cursorColumn > from) { |
| --cursorColumn; |
| deleteCharacters(1); |
| --to; |
| } else { |
| ringConsoleBell(); |
| } |
| break; |
| case DEL: |
| if (cursorColumn < to) { |
| deleteCharacters(1); |
| --to; |
| } else { |
| ringConsoleBell(); |
| } |
| break; |
| case KEY_FUNCTION_CURSOR_LEFT: |
| if (cursorColumn > from) { |
| --cursorColumn; |
| } else { |
| ringConsoleBell(); |
| } |
| break; |
| case KEY_FUNCTION_CURSOR_LEFT_JUMP: |
| if (cursorColumn > from) { |
| cursorColumn = from; |
| } else { |
| ringConsoleBell(); |
| } |
| break; |
| case KEY_FUNCTION_CURSOR_RIGHT: |
| if (cursorColumn < to) { |
| ++cursorColumn; |
| } else { |
| ringConsoleBell(); |
| } |
| break; |
| case KEY_FUNCTION_CURSOR_RIGHT_JUMP: |
| if (cursorColumn < to) { |
| cursorColumn = to; |
| } else { |
| ringConsoleBell(); |
| } |
| break; |
| default: |
| ringConsoleBell(); |
| break; |
| } |
| } |
| sendCursorRow(); |
| } |
| } |
| */ |
| |
| static void |
| downloadFile (void) { |
| if (makeDownloadFifo()) { |
| int file = open(downloadPath, O_RDONLY); |
| if (file != -1) { |
| struct stat status; |
| if (fstat(file, &status) != -1) { |
| unsigned char buffer[0X400]; |
| const unsigned char *address = buffer; |
| int count = 0; |
| while (1) { |
| const unsigned char *newline; |
| if (!count) { |
| count = read(file, buffer, sizeof(buffer)); |
| if (!count) { |
| static const unsigned char fileTrailer[] = {0X1A}; |
| sendBytes(fileTrailer, sizeof(fileTrailer)); |
| break; |
| } |
| if (count == -1) { |
| logSystemError("Download file read"); |
| break; |
| } |
| address = buffer; |
| } |
| if ((newline = memchr(address, '\n', count))) { |
| static const unsigned char lineTrailer[] = {ASCII_CR, ASCII_LF}; |
| size_t length = newline - address; |
| if (!sendBytes(address, length++)) break; |
| if (!sendBytes(lineTrailer, sizeof(lineTrailer))) break; |
| address += length; |
| count -= length; |
| } else { |
| if (!sendBytes(address, count)) break; |
| count = 0; |
| } |
| } |
| } else { |
| logSystemError("Download file status"); |
| } |
| if (close(file) == -1) { |
| logSystemError("Download file close"); |
| } |
| } else { |
| logSystemError("Download file open"); |
| } |
| } else { |
| logMessage(LOG_WARNING, "Download path not specified."); |
| } |
| } |
| |
| static int |
| brl_readCommand (BrailleDisplay *brl, KeyTableCommandContext context) { |
| int key = readKey(); |
| if (context != currentContext) { |
| logMessage(LOG_DEBUG, "Context switch: %d -> %d", currentContext, context); |
| switch (currentContext = context) { |
| case KTB_CTX_DEFAULT: |
| deviceStatus = DEV_ONLINE; |
| break; |
| default: |
| break; |
| } |
| } |
| if (key != EOF) { |
| switch (key) { |
| case KEY_FUNCTION_ENTER: |
| return BRL_CMD_KEY(ENTER); |
| case KEY_FUNCTION_TAB: |
| return BRL_CMD_KEY(TAB); |
| case KEY_FUNCTION_CURSOR_UP: |
| return BRL_CMD_KEY(CURSOR_UP); |
| case KEY_FUNCTION_CURSOR_DOWN: |
| return BRL_CMD_KEY(CURSOR_DOWN); |
| case KEY_FUNCTION_CURSOR_LEFT: |
| return BRL_CMD_KEY(CURSOR_LEFT); |
| case KEY_FUNCTION_CURSOR_RIGHT: |
| return BRL_CMD_KEY(CURSOR_RIGHT); |
| case KEY_FUNCTION_CURSOR_UP_JUMP: |
| return BRL_CMD_KEY(HOME); |
| case KEY_FUNCTION_CURSOR_DOWN_JUMP: |
| return BRL_CMD_KEY(END); |
| case KEY_FUNCTION_CURSOR_LEFT_JUMP: |
| return BRL_CMD_KEY(PAGE_UP); |
| case KEY_FUNCTION_CURSOR_RIGHT_JUMP: |
| return BRL_CMD_KEY(PAGE_DOWN); |
| case KEY_FUNCTION_F1: |
| return BRL_CMD_KFN(1); |
| case KEY_FUNCTION_F2: |
| return BRL_CMD_KFN(2); |
| case KEY_FUNCTION_F3: |
| return BRL_CMD_KFN(3); |
| case KEY_FUNCTION_F4: |
| return BRL_CMD_KFN(4); |
| case KEY_FUNCTION_F5: |
| return BRL_CMD_KFN(5); |
| case KEY_FUNCTION_F6: |
| return BRL_CMD_KFN(6); |
| case KEY_FUNCTION_F7: |
| return BRL_CMD_KFN(7); |
| case KEY_FUNCTION_F9: |
| return BRL_CMD_KFN(9); |
| case KEY_FUNCTION_F10: |
| return BRL_CMD_KFN(10); |
| case KEY_COMMAND: { |
| int command; |
| while ((command = readKey()) == EOF) asyncWait(1); |
| logMessage(LOG_DEBUG, "Received command: (0x%2.2X) 0x%4.4X", KEY_COMMAND, command); |
| switch (command) { |
| case KEY_COMMAND: |
| /* pressing the escape command twice will pass it through */ |
| return BRL_CMD_BLK(PASSDOTS) + translateInputCell(KEY_COMMAND); |
| case KEY_COMMAND_SWITCHVT_PREV: |
| return BRL_CMD_SWITCHVT_PREV; |
| case KEY_COMMAND_SWITCHVT_NEXT: |
| return BRL_CMD_SWITCHVT_NEXT; |
| case KEY_COMMAND_SWITCHVT_1: |
| return BRL_CMD_BLK(SWITCHVT) + 0; |
| case KEY_COMMAND_SWITCHVT_2: |
| return BRL_CMD_BLK(SWITCHVT) + 1; |
| case KEY_COMMAND_SWITCHVT_3: |
| return BRL_CMD_BLK(SWITCHVT) + 2; |
| case KEY_COMMAND_SWITCHVT_4: |
| return BRL_CMD_BLK(SWITCHVT) + 3; |
| case KEY_COMMAND_SWITCHVT_5: |
| return BRL_CMD_BLK(SWITCHVT) + 4; |
| case KEY_COMMAND_SWITCHVT_6: |
| return BRL_CMD_BLK(SWITCHVT) + 5; |
| case KEY_COMMAND_SWITCHVT_7: |
| return BRL_CMD_BLK(SWITCHVT) + 6; |
| case KEY_COMMAND_SWITCHVT_8: |
| return BRL_CMD_BLK(SWITCHVT) + 7; |
| case KEY_COMMAND_SWITCHVT_9: |
| return BRL_CMD_BLK(SWITCHVT) + 8; |
| case KEY_COMMAND_SWITCHVT_10: |
| return BRL_CMD_BLK(SWITCHVT) + 9; |
| case KEY_COMMAND_PAGE_UP: |
| return BRL_CMD_KEY(PAGE_UP); |
| case KEY_COMMAND_PAGE_DOWN: |
| return BRL_CMD_KEY(PAGE_DOWN); |
| case KEY_COMMAND_PREFMENU: |
| currentLine = 0; |
| cursorRow = 0; |
| cursorColumn = 31; |
| sendCursorRow(); |
| return BRL_CMD_PREFMENU; |
| case KEY_COMMAND_PREFSAVE: |
| return BRL_CMD_PREFSAVE; |
| case KEY_COMMAND_PREFLOAD: |
| return BRL_CMD_PREFLOAD; |
| case KEY_COMMAND_FREEZE_ON: |
| return BRL_CMD_FREEZE | BRL_FLG_TOGGLE_ON; |
| case KEY_COMMAND_FREEZE_OFF: |
| return BRL_CMD_FREEZE | BRL_FLG_TOGGLE_OFF; |
| case KEY_COMMAND_RESTARTBRL: |
| return BRL_CMD_RESTARTBRL; |
| case KEY_COMMAND_DOWNLOAD: |
| downloadFile(); |
| break; |
| default: |
| logMessage(LOG_WARNING, "Unknown command: (0X%2.2X) 0X%4.4X", KEY_COMMAND, command); |
| break; |
| } |
| break; |
| } |
| default: |
| switch (key & KEY_MASK) { |
| case KEY_UPDATE: |
| handleUpdate(key >> KEY_SHIFT); |
| break; |
| case KEY_FUNCTION: |
| logMessage(LOG_WARNING, "Unknown function: (0X%2.2X) 0X%4.4X", KEY_COMMAND, key>>KEY_SHIFT); |
| break; |
| default: { |
| unsigned char dots = translateInputCell(key); |
| logMessage(LOG_DEBUG, "Received character: 0X%2.2X dec=%d dots=%2.2X", key, key, dots); |
| return BRL_CMD_BLK(PASSDOTS) + dots; |
| } |
| } |
| break; |
| } |
| } |
| return EOF; |
| } |
