snark13
05916a3cc6
MD-навигация после загрузки (стрелки/PgUp/PgDn/Home/End/←/→) вынесена из switch в main() в md_key(scan) — peer к raw_key(): возвращает 1/0, сама перерисовывает область+статус. main() теперь симметричен для обоих видов: F-клавиши (F1/F8/F10, для RAW ещё F2/F3) разбираются в цикле, навигация делегируется md_key()/raw_key(). HPAN_STEP вынесен в mdview2.h (был продублирован в ядре и raw). load_key() (навигация во время прогрессивной загрузки, bounded по drawable_lines) остаётся в ядре — у неё нет RAW-аналога. Поведение сохранено (F1 теперь без лишнего render_updated_status — show_help и так перерисовывает всё). Размер: exe 28115→28173 (+58 Б — стоимость границы функции, как у raw_key). Сборка чистая. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
342 lines
13 KiB
C
342 lines
13 KiB
C
/*
|
|
* mdview2_raw.c — RAW-просмотр исходного текста (без markdown-форматирования).
|
|
*
|
|
* Работает по АКТИВНОМУ буферу документа через fb() (8-бит = исходные байты,
|
|
* UTF-8 = декодированный в CP866 буфер), ремап ≥0x80 (CP1251/KOI8) — на
|
|
* отрисовке. Индекс/кэш markdown не используются: позиция — байт-offset,
|
|
* 1 байт = 1 ячейка, \t показываем пробелом. Два режима:
|
|
* VIEW_RAW_WRAP — длинные строки переносятся кратно 80 (рвём слова);
|
|
* VIEW_RAW_HSCROLL — строка в один ряд, горизонтальный скролл.
|
|
*
|
|
* Память: 0 доп. EMM; near-буфер строки + переиспользование g_scratch_phys.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <conio.h>
|
|
#include <bios/text.h>
|
|
#include "mdview2.h"
|
|
|
|
#if WITH_RAW /* весь модуль — опционален (mdview_conf.h); при 0 пустой объектник */
|
|
|
|
static uint32_t raw_top = 0; /* байт-offset верхней строки экрана */
|
|
static uint16_t raw_hpan = 0; /* гориз. сдвиг (только HSCROLL) */
|
|
|
|
/* ---- примитивы навигации по физическим строкам / переносам -------- */
|
|
|
|
static uint32_t raw_line_start(uint32_t off)
|
|
{
|
|
while (off && fb(off - 1) != '\n') off--;
|
|
return off;
|
|
}
|
|
|
|
/* WRAP: начало следующего ряда от off (\n завершает строку; иначе +80). */
|
|
static uint32_t raw_next_wrap(uint32_t off)
|
|
{
|
|
uint32_t e = off, lim = off + SCREEN_W;
|
|
while (e < file_size) {
|
|
if (fb(e) == '\n') return e + 1;
|
|
e++;
|
|
if (e >= lim) { /* прошли 80 без \n */
|
|
if (e < file_size && fb(e) == '\n') return e + 1; /* ровно 80 + \n */
|
|
return e; /* длинная строка → продолжение */
|
|
}
|
|
}
|
|
return e; /* EOF */
|
|
}
|
|
|
|
/* WRAP: начало предыдущего ряда. */
|
|
// static uint32_t raw_prev_wrap(uint32_t off)
|
|
// {
|
|
// if (off == 0) return 0;
|
|
// uint32_t ls = raw_line_start(off);
|
|
// if (off > ls) /* тот же абзац: на 80 назад */
|
|
// return off - SCREEN_W;
|
|
// /* off == начало строки: последний ряд предыдущей физической строки.
|
|
// * Последнюю 80-границу ищем циклом (без 32-битного деления). */
|
|
// uint32_t pls = raw_line_start(off - 1); /* off-1 — это \n пред. строки */
|
|
// uint32_t last = pls;
|
|
// while (last + SCREEN_W < (off - 1)) last += SCREEN_W;
|
|
// return last;
|
|
// }
|
|
|
|
static uint32_t raw_prev_wrap(uint32_t off)
|
|
{
|
|
if (off == 0) return 0;
|
|
uint32_t pls = raw_line_start(off - 1); /* off-1 — это \n пред. строки */
|
|
while (pls + SCREEN_W < (off - 1)) pls += SCREEN_W;
|
|
return pls;
|
|
}
|
|
|
|
/* HSCROLL: начало следующей/предыдущей физической строки. */
|
|
static uint32_t raw_next_line(uint32_t off)
|
|
{
|
|
while (off < file_size && fb(off) != '\n') off++;
|
|
return (off < file_size) ? off + 1 : off;
|
|
}
|
|
// static uint32_t raw_prev_line(uint32_t off)
|
|
// {
|
|
// if (off == 0) return 0;
|
|
// uint32_t p = off - 1; /* \n, завершивший пред. строку */
|
|
// if (p == 0) return 0;
|
|
// p--;
|
|
// while (p != 0 && fb(p) != '\n') p--;
|
|
// return (fb(p) == '\n') ? p + 1 : 0;
|
|
// }
|
|
|
|
static uint32_t raw_prev_line(uint32_t off)
|
|
{
|
|
if (off == 0) return 0;
|
|
return raw_line_start(off - 1);
|
|
}
|
|
|
|
/* ---- отрисовка ряда (общий near-буфер → g_scratch_phys → win_rest) - */
|
|
|
|
static uint8_t raw_buf[SCREEN_W + 1]; /* только символы (атрибут единый, задаётся при выводе) */
|
|
|
|
/* В RAW атрибут единый (ATTR_TEXT): буфер — только 80 символов, без пар
|
|
* (char,attr). Кладём один байт-глиф (\t→пробел, ремап ≥0x80). */
|
|
static void raw_cell(uint8_t i, uint8_t ch)
|
|
{
|
|
if (ch >= 0x80 && g_remap) ch = g_remap[ch - 0x80];
|
|
raw_buf[i] = ch;
|
|
}
|
|
/* Вывод готового 80-символьного буфера в строку экрана одним BIOS-вызовом
|
|
* (char-буфер + единый attr — без WINREST/scratch-страницы). */
|
|
static void raw_flush(uint8_t row)
|
|
{
|
|
bios_set_place(row, 0);
|
|
// bios_writeattr((const char *)raw_buf, SCREEN_W, ATTR_TEXT);
|
|
// bios_writeattr_until((const char *)raw_buf, SCREEN_W, ATTR_TEXT, 0);
|
|
bios_write_until((const char *)raw_buf, SCREEN_W, 0);
|
|
}
|
|
|
|
static uint32_t raw_draw_wrap_row(uint32_t off, uint8_t row)
|
|
{
|
|
uint8_t i = 0;
|
|
uint32_t e = off, lim = off + SCREEN_W;
|
|
while (i < SCREEN_W && e < file_size) {
|
|
char c = fb(e);
|
|
if (c == '\n') {
|
|
raw_cell(i, 0);
|
|
break;
|
|
}
|
|
raw_cell(i, (uint8_t)(c == '\t' ? ' ' : c));
|
|
i++; e++;
|
|
}
|
|
raw_flush(row);
|
|
return raw_next_wrap(off);
|
|
}
|
|
|
|
// static uint32_t raw_draw_hscroll_row(uint32_t off, uint8_t row)
|
|
// {
|
|
// uint32_t e = off;
|
|
// while (e < file_size && fb(e) != '\n') e++; /* e = конец строки */
|
|
// uint16_t len = e - off;
|
|
|
|
// uint8_t i = 0;
|
|
// uint32_t p = off + raw_hpan;
|
|
// while (i < SCREEN_W && p < e) {
|
|
// char c = fb(p);
|
|
// raw_cell(i, (uint8_t)(c == '\t' ? ' ' : c));
|
|
// i++; p++;
|
|
// }
|
|
// for (; i < SCREEN_W; i++) raw_buf[i] = ' ';
|
|
|
|
// if (raw_hpan > 0) raw_buf[0] = '<';
|
|
// if (len > (uint16_t)raw_hpan + SCREEN_W) raw_buf[SCREEN_W - 1] = '>';
|
|
// raw_flush(row);
|
|
// return (e < file_size) ? e + 1 : e;
|
|
// }
|
|
|
|
static uint32_t raw_draw_hscroll_row(uint32_t off, uint8_t row)
|
|
{
|
|
uint32_t e = off;
|
|
while (e < file_size && fb(e) != '\n') e++; /* e = конец строки */
|
|
uint16_t len = e - off;
|
|
|
|
uint8_t i = 0;
|
|
uint32_t p = off + raw_hpan;
|
|
while (i < SCREEN_W && p < e) {
|
|
char c = fb(p);
|
|
raw_cell(i, (uint8_t)(c == '\t' ? ' ' : c));
|
|
i++; p++;
|
|
}
|
|
// raw_buf[i] = 0;
|
|
|
|
if (raw_hpan > 0)
|
|
raw_buf[0] = '<';
|
|
if (len > (uint16_t)raw_hpan + SCREEN_W)
|
|
raw_buf[SCREEN_W - 1] = '>';
|
|
if (i < SCREEN_W)
|
|
raw_buf[i] = 0;
|
|
raw_flush(row);
|
|
return (e < file_size) ? e + 1 : e;
|
|
}
|
|
|
|
/* Рисует один ряд от off (по режиму) и возвращает offset следующего ряда. */
|
|
static uint32_t raw_draw_one(uint32_t off, uint8_t row)
|
|
{
|
|
if (off >= file_size) { fill_row(row, ATTR_TEXT); return off; }
|
|
return (g_view == VIEW_RAW_WRAP) ? raw_draw_wrap_row(off, row)
|
|
: raw_draw_hscroll_row(off, row);
|
|
}
|
|
|
|
void raw_draw(void)
|
|
{
|
|
uint32_t off = raw_top;
|
|
for (uint8_t r = 0; r < VIEW_H; r++)
|
|
off = raw_draw_one(off, (uint8_t)(VIEW_TOP_ROW + r));
|
|
}
|
|
|
|
/* Прокрутка на одну строку: аппаратный scroll окна документа + отрисовка
|
|
* ОДНОЙ новой строки (как в MD-режиме). Смещение нижнего ряда вычисляется
|
|
* проходом VIEW_H рядов от raw_top — без отдельного инкрементального счётчика,
|
|
* который рассинхронизировался, когда контент кончается в середине экрана
|
|
* (короче окна после wrap→unwrap у конца файла). */
|
|
static uint32_t raw_next(uint32_t off)
|
|
{
|
|
return (g_view == VIEW_RAW_WRAP) ? raw_next_wrap(off) : raw_next_line(off);
|
|
}
|
|
static uint32_t raw_prev(uint32_t off)
|
|
{
|
|
return (g_view == VIEW_RAW_WRAP) ? raw_prev_wrap(off) : raw_prev_line(off);
|
|
}
|
|
|
|
static void raw_scroll_down1(void)
|
|
{
|
|
/* Скроллим вниз ТОЛЬКО если контент уходит за нижний край. Проходим VIEW_H
|
|
* рядов от raw_top: если контент кончился раньше (экран не полон) — внизу
|
|
* была бы пустая строка, не скроллим; если ровно по нижний ряд (off==EOF) —
|
|
* ниже пусто, тоже не скроллим. Иначе off = ряд сразу под экраном. */
|
|
uint32_t off = raw_top;
|
|
for (uint8_t r = 0; r < VIEW_H; r++) {
|
|
if (off >= file_size) return; /* экран не заполнен контентом */
|
|
off = raw_next(off);
|
|
}
|
|
if (off >= file_size) return; /* контент ровно по экран, ниже пусто */
|
|
|
|
scroll(0, VIEW_TOP_ROW, SCREEN_W, VIEW_H, 1, 0); /* содержимое вверх */
|
|
raw_draw_one(off, (uint8_t)(VIEW_TOP_ROW + VIEW_H - 1)); /* новый нижний ряд */
|
|
raw_top = raw_next(raw_top);
|
|
}
|
|
static void raw_scroll_up1(void)
|
|
{
|
|
if (raw_top == 0) return;
|
|
uint32_t nt = raw_prev(raw_top);
|
|
scroll(0, VIEW_TOP_ROW, SCREEN_W, VIEW_H, 2, 0); /* содержимое вниз */
|
|
(void)raw_draw_one(nt, VIEW_TOP_ROW);
|
|
raw_top = nt;
|
|
}
|
|
|
|
/* ---- статус-бар (без подсчёта строк: процент по байтам + режим) ---- */
|
|
|
|
/* Процент по байтам без 32-битного деления: масштабируем offset'ы в единицы
|
|
* по 1 КБ (>>10), дальше 16-битная арифметика (a*100 ≤ 12800). */
|
|
static uint8_t raw_pct(void)
|
|
{
|
|
uint16_t a = (uint16_t)(raw_top >> 10);
|
|
uint16_t b = (uint16_t)(file_size >> 10);
|
|
if (b == 0) return 0; /* файл < 1 КБ */
|
|
return (uint8_t)(a * 100u / b);
|
|
}
|
|
|
|
void raw_status_numbers(void)
|
|
{
|
|
uint8_t pct = raw_pct();
|
|
textattr(ATTR_BAR);
|
|
gotoxy(47, 0);
|
|
bios_writeattr_until(g_view == VIEW_RAW_WRAP ? "RAW wrap" : "RAW pan",
|
|
20, ATTR_BAR, 0);
|
|
gotoxy(73, 0);
|
|
dec8(pct);
|
|
cputs("% ");
|
|
}
|
|
|
|
/* ---- посев позиции / пересев при смене активного буфера ----------- */
|
|
|
|
void raw_seed_from(uint16_t md_top_line)
|
|
{
|
|
uint32_t off = seg_off(md_top_line);
|
|
if (off > file_size) off = 0;
|
|
raw_top = raw_line_start(off);
|
|
raw_hpan = 0;
|
|
}
|
|
|
|
/* Сброс в начало — при смене активного буфера (F8 в/из UTF-8: размеры/offset'ы
|
|
* разные, старый raw_top невалиден). Без percent-математики. */
|
|
void raw_home(void)
|
|
{
|
|
raw_top = 0;
|
|
raw_hpan = 0;
|
|
}
|
|
|
|
void raw_screen_init(void) {
|
|
bios_clearwin(1, 0, 30, 80, ATTR_TEXT);
|
|
}
|
|
|
|
/* Нормализация позиции при смене под-режима RAW (F3 Wrap/Unwrap): выровнять
|
|
* raw_top на начало физической строки и снять горизонтальный сдвиг. */
|
|
void raw_renorm(void)
|
|
{
|
|
raw_top = raw_line_start(raw_top);
|
|
raw_hpan = 0;
|
|
}
|
|
|
|
/* ---- навигация (вызывается из главного цикла при g_view != VIEW_MD) - */
|
|
|
|
uint8_t raw_key(uint8_t scan)
|
|
{
|
|
uint32_t nt;
|
|
|
|
switch (scan) {
|
|
case KEY_DOWN: raw_scroll_down1(); raw_status_numbers(); return 1;
|
|
case KEY_UP: raw_scroll_up1(); raw_status_numbers(); return 1;
|
|
|
|
case KEY_PGDN:
|
|
nt = raw_top;
|
|
for (uint8_t k = 0; k < VIEW_H; k++) {
|
|
uint32_t n2 = raw_next(nt);
|
|
if (n2 >= file_size) break;
|
|
nt = n2;
|
|
}
|
|
break;
|
|
case KEY_PGUP:
|
|
nt = raw_top;
|
|
for (uint8_t k = 0; k < VIEW_H; k++) nt = raw_prev(nt);
|
|
break;
|
|
case KEY_HOME:
|
|
nt = 0; raw_hpan = 0;
|
|
break;
|
|
case KEY_END:
|
|
nt = file_size; /* отмотать VIEW_H рядов назад */
|
|
for (uint8_t k = 0; k < VIEW_H; k++) nt = raw_prev(nt);
|
|
raw_hpan = 0;
|
|
break;
|
|
|
|
case KEY_LEFT:
|
|
if (g_view == VIEW_RAW_HSCROLL && raw_hpan) {
|
|
raw_hpan = (raw_hpan >= HPAN_STEP) ? (uint16_t)(raw_hpan - HPAN_STEP) : 0;
|
|
raw_draw();
|
|
raw_status_numbers();
|
|
}
|
|
return 1;
|
|
case KEY_RIGHT:
|
|
if (g_view == VIEW_RAW_HSCROLL) {
|
|
if (raw_hpan < 248u) raw_hpan = (uint16_t)(raw_hpan + HPAN_STEP);
|
|
raw_draw();
|
|
raw_status_numbers();
|
|
}
|
|
return 1;
|
|
default:
|
|
return 0; /* не наша клавиша */
|
|
}
|
|
|
|
raw_top = nt;
|
|
raw_draw(); /* PgUp/PgDn/Home/End — полный экран */
|
|
raw_status_numbers();
|
|
return 1;
|
|
}
|
|
|
|
#endif /* WITH_RAW */
|