php-kilo/src/Editor.php

972 lines
20 KiB
PHP
Raw Normal View History

2019-10-14 16:21:41 -04:00
<?php declare(strict_types=1);
2019-11-08 16:27:08 -05:00
namespace Aviat\Kilo;
use Aviat\Kilo\Enum\{Color, KeyCode, KeyType, Highlight};
2021-03-03 11:50:29 -05:00
use Aviat\Kilo\Tokens\PHP8;
2019-10-14 16:21:41 -04:00
/**
2019-10-25 16:36:03 -04:00
* // Don't highlight this!
2021-03-03 16:35:58 -05:00
* @property-read int $numRows
*/
2019-10-14 16:21:41 -04:00
class Editor {
2019-11-19 15:57:51 -05:00
use Traits\MagicProperties;
/**
* @var string The screen buffer
*/
2021-03-04 12:03:51 -05:00
private string $outputBuffer = '';
2019-10-14 16:21:41 -04:00
/**
2021-03-09 17:22:49 -05:00
* @var Point The 0-based location of the cursor in the current viewport
*/
2021-03-09 17:22:49 -05:00
protected Point $cursor;
/**
2021-03-09 17:22:49 -05:00
* @var Point The scroll offset of the file in the current viewport
*/
2021-03-09 17:22:49 -05:00
protected Point $offset;
/**
* @var int The rendered cursor position
*/
protected int $renderX = 0;
/**
* @var int The size of the current terminal in rows
*/
2019-10-14 16:21:41 -04:00
protected int $screenRows = 0;
/**
* @var int The size of the current terminal in columns
*/
2019-10-14 16:21:41 -04:00
protected int $screenCols = 0;
2021-03-09 17:22:49 -05:00
/**
* @var int The number of times to confirm you wish to quit
*/
protected int $quitTimes = KILO_QUIT_TIMES;
2019-10-15 13:23:25 -04:00
/**
* Array of Row objects
*/
2019-10-25 16:36:03 -04:00
public array $rows = [];
2019-10-15 13:23:25 -04:00
2021-03-10 22:55:52 -05:00
public bool $dirty = FALSE;
public string $filename = '';
protected string $statusMsg = '';
protected int $statusMsgTime;
2020-01-23 13:41:35 -05:00
public ?Syntax $syntax = NULL;
2019-10-25 10:28:15 -04:00
// Tokens for highlighting PHP
public array $tokens = [];
public static function new(): Editor
2019-10-15 13:23:25 -04:00
{
return new self();
2019-10-15 13:23:25 -04:00
}
private function __construct()
2019-10-14 16:21:41 -04:00
{
$this->statusMsgTime = time();
2021-03-09 17:22:49 -05:00
$this->cursor = Point::new();
$this->offset = Point::new();
2019-10-14 16:21:41 -04:00
[$this->screenRows, $this->screenCols] = Terminal::getWindowSize();
2019-11-19 15:57:51 -05:00
// Remove a row for the status bar, and one for the message bar
$this->screenRows -= 2;
}
2020-12-04 11:18:21 -05:00
public function __get(string $name): ?int
{
if ($name === 'numRows')
{
return count($this->rows);
}
return NULL;
2019-10-14 16:21:41 -04:00
}
2019-11-20 15:03:48 -05:00
public function __debugInfo(): array
{
return [
'cursor' => $this->cursor,
'offset' => $this->offset,
2019-11-20 15:03:48 -05:00
'dirty' => $this->dirty,
'filename' => $this->filename,
'renderX' => $this->renderX,
'rows' => $this->rows,
'screenCols' => $this->screenCols,
'screenRows' => $this->screenRows,
'statusMsg' => $this->statusMsg,
'syntax' => $this->syntax,
'tokens' => $this->tokens,
];
}
2019-10-14 16:21:41 -04:00
// ------------------------------------------------------------------------
// ! Terminal
// ------------------------------------------------------------------------
protected function readKey(): string
{
$c = Terminal::read();
2019-10-14 16:21:41 -04:00
2021-03-03 11:50:29 -05:00
return match($c)
{
2020-02-05 16:32:17 -05:00
// Unambiguous mappings
KeyCode::ARROW_DOWN => KeyType::ARROW_DOWN,
KeyCode::ARROW_LEFT => KeyType::ARROW_LEFT,
KeyCode::ARROW_RIGHT => KeyType::ARROW_RIGHT,
KeyCode::ARROW_UP => KeyType::ARROW_UP,
KeyCode::DEL_KEY => KeyType::DEL_KEY,
KeyCode::ENTER => KeyType::ENTER,
KeyCode::PAGE_DOWN => KeyType::PAGE_DOWN,
KeyCode::PAGE_UP => KeyType::PAGE_UP,
2020-02-05 16:32:17 -05:00
// Backspace
2021-03-03 11:50:29 -05:00
KeyCode::CTRL('h'), KeyCode::BACKSPACE => KeyType::BACKSPACE,
2020-02-05 16:32:17 -05:00
2020-12-04 11:18:21 -05:00
// Escape
2021-03-03 11:50:29 -05:00
KeyCode::CTRL('l'), KeyCode::ESCAPE => KeyType::ESCAPE,
2020-12-04 11:18:21 -05:00
2020-02-05 16:32:17 -05:00
// Home Key
2021-03-03 11:50:29 -05:00
"\eOH", "\e[7~", "\e[1~", ANSI::RESET_CURSOR => KeyType::HOME_KEY,
2019-10-14 16:21:41 -04:00
2020-02-05 16:32:17 -05:00
// End Key
2021-03-03 11:50:29 -05:00
"\eOF", "\e[4~", "\e[8~", "\e[F" => KeyType::END_KEY,
2019-10-14 16:21:41 -04:00
2021-03-03 11:50:29 -05:00
default => $c,
};
2019-10-14 16:21:41 -04:00
}
2019-10-25 10:28:15 -04:00
protected function selectSyntaxHighlight(): void
{
$this->syntax = NULL;
if (empty($this->filename))
{
return;
}
// In PHP, `strchr` and `strstr` are the same function
2020-02-05 14:50:31 -05:00
$ext = (string)strstr(basename($this->filename), '.');
2019-10-25 10:28:15 -04:00
2019-11-08 21:48:46 -05:00
foreach (get_file_syntax_map() as $syntax)
2019-10-25 10:28:15 -04:00
{
2020-02-05 14:50:31 -05:00
if (
in_array($ext, $syntax->filematch, TRUE) ||
in_array(basename($this->filename), $syntax->filematch, TRUE)
) {
$this->syntax = $syntax;
2020-02-05 14:50:31 -05:00
// Pre-tokenize the file
if ($this->syntax->filetype === 'PHP')
{
2021-03-03 11:50:29 -05:00
$this->tokens = PHP8::getFileTokens($this->filename);
2019-10-25 10:28:15 -04:00
}
2020-02-05 14:50:31 -05:00
$this->refreshSyntax();
return;
2019-10-25 10:28:15 -04:00
}
}
}
2019-10-15 13:23:25 -04:00
// ------------------------------------------------------------------------
// ! Row Operations
// ------------------------------------------------------------------------
2021-03-09 13:37:03 -05:00
/**
* Cursor X to Render X
*
* @param Row $row
* @param int $cx
* @return int
*/
protected function rowCxToRx(Row $row, int $cx): int
{
$rx = 0;
for ($i = 0; $i < $cx; $i++)
{
2020-02-05 14:50:31 -05:00
if ($row->chars[$i] === KeyCode::TAB)
{
$rx += (KILO_TAB_STOP - 1) - ($rx % KILO_TAB_STOP);
}
$rx++;
}
return $rx;
}
2021-03-09 13:37:03 -05:00
/**
* Render X to Cursor X
*
* @param Row $row
* @param int $rx
* @return int
*/
protected function rowRxToCx(Row $row, int $rx): int
{
$cur_rx = 0;
for ($cx = 0; $cx < $row->size; $cx++)
{
2020-02-05 14:50:31 -05:00
if ($row->chars[$cx] === KeyCode::TAB)
{
$cur_rx += (KILO_TAB_STOP - 1) - ($cur_rx % KILO_TAB_STOP);
}
$cur_rx++;
if ($cur_rx > $rx)
{
return $cx;
}
}
return $cx;
}
protected function insertRow(int $at, string $s, bool $updateSyntax = TRUE): void
{
2021-03-04 12:03:51 -05:00
if ($at > $this->numRows)
2019-10-22 16:16:28 -04:00
{
return;
}
2019-10-25 16:36:03 -04:00
$row = Row::new($this, $s, $at);
2019-10-22 16:16:28 -04:00
if ($at === $this->numRows)
{
2019-10-22 16:16:28 -04:00
$this->rows[] = $row;
}
else
{
$this->rows = [
...array_slice($this->rows, 0, $at),
$row,
...array_slice($this->rows, $at),
];
// Update indexes of each row so that correct highlighting is done
for ($idx = $at; $idx < $this->numRows; $idx++)
{
$this->rows[$idx]->idx = $idx;
}
}
ksort($this->rows);
2019-11-05 12:28:10 -05:00
$this->rows[$at]->update();
2021-03-10 22:47:57 -05:00
$this->dirty = true;
2019-11-05 12:28:10 -05:00
// Re-tokenize the file
2019-11-19 15:57:51 -05:00
if ($updateSyntax)
{
$this->refreshPHPSyntax();
}
2019-10-22 12:09:11 -04:00
}
protected function deleteRow(int $at): void
{
if ($at < 0 || $at >= $this->numRows)
{
return;
}
// Remove the row
unset($this->rows[$at]);
// Re-index the array of rows
$this->rows = array_values($this->rows);
2019-10-25 16:36:03 -04:00
for ($i = $at; $i < $this->numRows; $i++)
{
$this->rows[$i]->idx = $i;
2019-10-25 16:36:03 -04:00
}
2019-10-22 12:09:11 -04:00
// Re-tokenize the file
2019-11-19 15:57:51 -05:00
$this->refreshPHPSyntax();
2021-03-10 22:47:57 -05:00
$this->dirty = true;
2019-10-22 12:09:11 -04:00
}
// ------------------------------------------------------------------------
// ! Editor Operations
// ------------------------------------------------------------------------
protected function insertChar(string $c): void
{
if ($this->cursor->y === $this->numRows)
2019-10-22 12:09:11 -04:00
{
2019-10-22 16:16:28 -04:00
$this->insertRow($this->numRows, '');
2019-10-22 12:09:11 -04:00
}
$this->rows[$this->cursor->y]->insertChar($this->cursor->x, $c);
2019-10-22 12:09:11 -04:00
// Re-tokenize the file
2019-11-19 15:57:51 -05:00
$this->refreshPHPSyntax();
$this->cursor->x++;
}
protected function insertNewline(): void
{
2020-12-04 11:18:21 -05:00
// @TODO attempt smart indentation on newline?
if ($this->cursor->x === 0)
2019-10-22 16:16:28 -04:00
{
$this->insertRow($this->cursor->y, '');
2019-10-22 16:16:28 -04:00
}
else
{
$row = $this->rows[$this->cursor->y];
$chars = $row->chars;
$newChars = substr($chars, 0, $this->cursor->x);
2019-10-22 16:16:28 -04:00
2019-11-05 12:28:10 -05:00
// Truncate the previous row
$row->chars = $newChars;
2019-10-22 16:16:28 -04:00
2019-11-05 12:28:10 -05:00
// Add a new row, with the contents from the cursor to the end of the line
$this->insertRow($this->cursor->y + 1, substr($chars, $this->cursor->x));
}
$this->cursor->y++;
$this->cursor->x = 0;
2019-11-05 12:28:10 -05:00
// Re-tokenize the file
2019-11-19 15:57:51 -05:00
$this->refreshPHPSyntax();
2019-10-22 16:16:28 -04:00
}
2019-10-22 12:09:11 -04:00
protected function deleteChar(): void
{
if ($this->cursor->y === $this->numRows || ($this->cursor->x === 0 && $this->cursor->y === 0))
2019-10-22 12:09:11 -04:00
{
return;
}
$row = $this->rows[$this->cursor->y];
if ($this->cursor->x > 0)
2019-10-22 12:09:11 -04:00
{
$row->deleteChar($this->cursor->x - 1);
$this->cursor->x--;
2019-10-22 12:09:11 -04:00
}
else
{
$this->cursor->x = $this->rows[$this->cursor->y - 1]->size;
$this->rows[$this->cursor->y -1]->appendString($row->chars);
$this->deleteRow($this->cursor->y);
$this->cursor->y--;
2019-10-22 12:09:11 -04:00
}
// Re-tokenize the file
2019-11-19 15:57:51 -05:00
$this->refreshPHPSyntax();
2019-10-15 13:23:25 -04:00
}
// ------------------------------------------------------------------------
// ! File I/O
// ------------------------------------------------------------------------
2019-10-22 12:09:11 -04:00
protected function rowsToString(): string
2019-10-15 13:23:25 -04:00
{
$lines = array_map(fn (Row $row) => (string)$row, $this->rows);
2019-10-22 12:09:11 -04:00
2019-10-22 16:44:55 -04:00
return implode('', $lines);
2019-10-22 12:09:11 -04:00
}
2019-10-22 12:09:11 -04:00
public function open(string $filename): void
{
2019-10-22 16:44:55 -04:00
// Copy filename for display
$this->filename = $filename;
2019-10-25 10:28:15 -04:00
$this->selectSyntaxHighlight();
2019-10-15 13:23:25 -04:00
2019-10-22 16:44:55 -04:00
$handle = fopen($filename, 'rb');
2019-10-22 16:16:28 -04:00
if ($handle === FALSE)
{
2020-02-05 14:50:31 -05:00
$this->setStatusMessage('Failed to open file: %s', $filename);
return;
2019-10-22 16:16:28 -04:00
}
2019-10-15 13:23:25 -04:00
while (($line = fgets($handle)) !== FALSE)
{
// Remove line endings when reading the file
$this->insertRow($this->numRows, rtrim($line), FALSE);
2019-10-15 13:23:25 -04:00
}
fclose($handle);
2019-10-22 12:09:11 -04:00
2021-03-10 22:47:57 -05:00
$this->dirty = false;
2019-10-22 12:09:11 -04:00
}
protected function save(): void
{
if ($this->filename === '')
{
2019-10-22 16:44:55 -04:00
$newFilename = $this->prompt('Save as: %s');
if ($newFilename === '')
2019-10-22 16:16:28 -04:00
{
$this->setStatusMessage('Save aborted');
return;
}
2019-10-22 16:44:55 -04:00
$this->filename = $newFilename;
2019-10-25 10:28:15 -04:00
$this->selectSyntaxHighlight();
2019-10-22 12:09:11 -04:00
}
$contents = $this->rowsToString();
$res = file_put_contents($this->filename, $contents);
if ($res === strlen($contents))
{
$this->setStatusMessage('%d bytes written to disk', strlen($contents));
2021-03-10 22:47:57 -05:00
$this->dirty = false;
2019-10-22 12:09:11 -04:00
return;
}
$this->setStatusMessage('Failed to save! I/O error: %s', error_get_last()['message']);
2019-10-15 13:23:25 -04:00
}
// ------------------------------------------------------------------------
// ! Find
// ------------------------------------------------------------------------
protected function findCallback(string $query, string $key): void
{
static $lastMatch = -1;
static $direction = 1;
static $savedHlLine = 0;
static $savedHl = [];
if ( ! empty($savedHl))
{
$this->rows[$savedHlLine]->hl = $savedHl;
$savedHl = [];
}
2020-02-05 14:50:31 -05:00
switch ($key)
{
2020-02-05 14:50:31 -05:00
case KeyCode::ENTER:
case KeyCode::ESCAPE:
$lastMatch = -1;
$direction = 1;
return;
2020-02-05 14:50:31 -05:00
case KeyType::ARROW_DOWN:
case KeyType::ARROW_RIGHT:
$direction = 1;
break;
case KeyType::ARROW_UP:
case KeyType::ARROW_LEFT:
$direction = -1;
break;
default:
$lastMatch = -1;
$direction = 1;
}
if ($lastMatch === -1)
{
$direction = 1;
}
2019-10-25 16:36:03 -04:00
$current = $lastMatch;
2020-12-04 11:18:21 -05:00
if (empty($query))
{
return;
}
for ($i = 0; $i < $this->numRows; $i++)
{
$current += $direction;
if ($current === -1)
{
$current = $this->numRows - 1;
}
else if ($current === $this->numRows)
{
$current = 0;
}
2020-02-05 16:32:17 -05:00
$row =& $this->rows[$current];
$match = strpos($row->render, $query);
if ($match !== FALSE)
{
$lastMatch = $current;
$this->cursor->y = (int)$current;
$this->cursor->x = $this->rowRxToCx($row, $match);
$this->offset->y = $this->numRows;
$savedHlLine = $current;
2020-02-05 16:32:17 -05:00
$savedHl = $row->hl;
// Update the highlight array of the relevant row with the 'MATCH' type
2020-02-05 16:32:17 -05:00
array_replace_range($row->hl, $match, strlen($query), Highlight::MATCH);
break;
}
}
}
protected function find(): void
{
2021-03-09 17:22:49 -05:00
$savedCursor = Point::from($this->cursor);
$savedOffset = Point::from($this->offset);
$query = $this->prompt('Search: %s (Use ESC/Arrows/Enter)', [$this, 'findCallback']);
// If they pressed escape, the query will be empty,
// restore original cursor and scroll locations
if ($query === '')
{
2021-03-09 17:22:49 -05:00
$this->cursor = Point::from($savedCursor);
$this->offset = Point::from($savedOffset);
}
}
2019-10-14 16:21:41 -04:00
// ------------------------------------------------------------------------
// ! Output
// ------------------------------------------------------------------------
2019-10-15 13:23:25 -04:00
protected function scroll(): void
{
$this->renderX = 0;
if ($this->cursor->y < $this->numRows)
{
$this->renderX = $this->rowCxToRx($this->rows[$this->cursor->y], $this->cursor->x);
}
// Vertical Scrolling
if ($this->cursor->y < $this->offset->y)
2019-10-15 13:23:25 -04:00
{
$this->offset->y = $this->cursor->y;
}
else if ($this->cursor->y >= ($this->offset->y + $this->screenRows))
{
$this->offset->y = $this->cursor->y - $this->screenRows + 1;
2019-10-15 13:23:25 -04:00
}
// Horizontal Scrolling
if ($this->renderX < $this->offset->x)
{
$this->offset->x = $this->renderX;
}
else if ($this->renderX >= ($this->offset->x + $this->screenCols))
2019-10-15 13:23:25 -04:00
{
$this->offset->x = $this->renderX - $this->screenCols + 1;
2019-10-15 13:23:25 -04:00
}
}
2019-10-14 16:21:41 -04:00
protected function drawRows(): void
{
for ($y = 0; $y < $this->screenRows; $y++)
{
$filerow = $y + $this->offset->y;
2021-03-04 12:03:51 -05:00
2021-03-09 17:22:49 -05:00
$this->outputBuffer .= ANSI::CLEAR_LINE;
2021-03-04 12:03:51 -05:00
($filerow >= $this->numRows)
? $this->drawPlaceholderRow($y)
: $this->drawRow($filerow);
$this->outputBuffer .= "\r\n";
}
}
protected function drawRow(int $rowIdx): void
{
$len = $this->rows[$rowIdx]->rsize - $this->offset->x;
2021-03-04 12:03:51 -05:00
if ($len < 0)
{
$len = 0;
}
if ($len > $this->screenCols)
{
$len = $this->screenCols;
}
$chars = substr($this->rows[$rowIdx]->render, $this->offset->x, (int)$len);
$hl = array_slice($this->rows[$rowIdx]->hl, $this->offset->x, (int)$len);
2021-03-04 12:03:51 -05:00
$currentColor = -1;
for ($i = 0; $i < $len; $i++)
{
$ch = $chars[$i];
// Handle 'non-printable' characters
if (is_ctrl($ch))
2019-10-14 16:21:41 -04:00
{
2021-03-04 12:03:51 -05:00
$sym = (ord($ch) <= 26)
? chr(ord('@') + ord($ch))
: '?';
$this->outputBuffer .= ANSI::color(Color::INVERT);
$this->outputBuffer .= $sym;
$this->outputBuffer .= ANSI::RESET_TEXT;
if ($currentColor !== -1)
2019-10-14 16:21:41 -04:00
{
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::color($currentColor);
2019-10-14 16:21:41 -04:00
}
2021-03-04 12:03:51 -05:00
}
else if ($hl[$i] === Highlight::NORMAL)
{
if ($currentColor !== -1)
2019-10-14 16:21:41 -04:00
{
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::RESET_TEXT;
$this->outputBuffer .= ANSI::color(Color::FG_WHITE);
$currentColor = -1;
2019-10-14 16:21:41 -04:00
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= $ch;
2019-10-14 16:21:41 -04:00
}
else
{
2021-03-04 12:03:51 -05:00
$color = syntax_to_color($hl[$i]);
if ($color !== $currentColor)
2019-10-15 13:23:25 -04:00
{
2021-03-04 12:03:51 -05:00
$currentColor = $color;
$this->outputBuffer .= ANSI::RESET_TEXT;
$this->outputBuffer .= ANSI::color($color);
2019-10-15 13:23:25 -04:00
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= $ch;
}
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::RESET_TEXT;
$this->outputBuffer .= ANSI::color(Color::FG_WHITE);
}
2019-10-23 13:36:16 -04:00
2021-03-04 12:03:51 -05:00
protected function drawPlaceholderRow(int $y): void
{
if ($this->numRows === 0 && $y === (int)($this->screenRows / 2))
{
$welcome = sprintf('PHP Kilo editor -- version %s', KILO_VERSION);
$welcomelen = strlen($welcome);
if ($welcomelen > $this->screenCols)
{
$welcomelen = $this->screenCols;
}
2021-03-04 12:03:51 -05:00
$padding = ($this->screenCols - $welcomelen) / 2;
if ($padding > 0)
{
$this->outputBuffer .= '~';
$padding--;
}
for ($i = 0; $i < $padding; $i++)
{
$this->outputBuffer .= ' ';
2019-10-14 16:21:41 -04:00
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= substr($welcome, 0, $welcomelen);
}
else
{
$this->outputBuffer .= '~';
}
}
protected function drawStatusBar(): void
{
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::color(Color::INVERT);
$statusFilename = $this->filename !== '' ? $this->filename : '[No Name]';
2019-10-25 10:28:15 -04:00
$syntaxType = ($this->syntax !== NULL) ? $this->syntax->filetype : 'no ft';
2021-03-10 22:47:57 -05:00
$isDirty = $this->dirty ? '(modified)' : '';
2019-10-22 12:09:11 -04:00
$status = sprintf('%.20s - %d lines %s', $statusFilename, $this->numRows, $isDirty);
$rstatus = sprintf('%s | %d/%d', $syntaxType, $this->cursor->y + 1, $this->numRows);
$len = strlen($status);
$rlen = strlen($rstatus);
if ($len > $this->screenCols)
{
$len = $this->screenCols;
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= substr($status, 0, $len);
while ($len < $this->screenCols)
{
if ($this->screenCols - $len === $rlen)
2019-10-14 16:21:41 -04:00
{
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= substr($rstatus, 0, $rlen);
break;
2019-10-14 16:21:41 -04:00
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ' ';
$len++;
}
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::RESET_TEXT;
$this->outputBuffer .= "\r\n";
}
protected function drawMessageBar(): void
{
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::CLEAR_LINE;
$len = strlen($this->statusMsg);
if ($len > $this->screenCols)
{
$len = $this->screenCols;
}
if ($len > 0 && (time() - $this->statusMsgTime) < 5)
{
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= substr($this->statusMsg, 0, $len);
2019-10-14 16:21:41 -04:00
}
}
public function refreshScreen(): void
{
2019-10-15 13:23:25 -04:00
$this->scroll();
2021-03-04 12:03:51 -05:00
$this->outputBuffer = '';
2019-10-14 16:21:41 -04:00
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::HIDE_CURSOR;
$this->outputBuffer .= ANSI::RESET_CURSOR;
2019-10-14 16:21:41 -04:00
$this->drawRows();
$this->drawStatusBar();
$this->drawMessageBar();
2019-10-14 16:21:41 -04:00
// Specify the current cursor position
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::moveCursor(
$this->cursor->y - $this->offset->y,
$this->renderX - $this->offset->x
);
2019-10-14 16:21:41 -04:00
2021-03-04 12:03:51 -05:00
$this->outputBuffer .= ANSI::SHOW_CURSOR;
2019-10-14 16:21:41 -04:00
Terminal::write($this->outputBuffer, strlen($this->outputBuffer));
}
2021-03-03 11:50:29 -05:00
public function setStatusMessage(string $fmt, mixed ...$args): void
{
$this->statusMsg = (count($args) > 0)
? sprintf($fmt, ...$args)
: $fmt;
$this->statusMsgTime = time();
2019-10-14 16:21:41 -04:00
}
// ------------------------------------------------------------------------
// ! Input
// ------------------------------------------------------------------------
protected function prompt(string $prompt, ?callable $callback = NULL): string
2019-10-22 16:16:28 -04:00
{
$buffer = '';
$modifiers = KeyType::getConstList();
2019-10-22 16:16:28 -04:00
while (TRUE)
{
$this->setStatusMessage($prompt, $buffer);
$this->refreshScreen();
$c = $this->readKey();
2020-02-05 16:32:17 -05:00
$isModifier = in_array($c, $modifiers, TRUE);
2019-10-22 16:16:28 -04:00
2020-02-05 14:50:31 -05:00
if ($c === KeyType::ESCAPE || ($c === KeyType::ENTER && $buffer !== ''))
2019-10-22 16:16:28 -04:00
{
$this->setStatusMessage('');
if ($callback !== NULL)
{
$callback($buffer, $c);
}
2020-12-04 11:18:21 -05:00
return ($c === KeyType::ENTER) ? $buffer : '';
2019-10-22 16:16:28 -04:00
}
2020-02-05 16:32:17 -05:00
if ($c === KeyType::DEL_KEY || $c === KeyType::BACKSPACE)
2019-10-22 16:16:28 -04:00
{
$buffer = substr($buffer, 0, -1);
}
2020-02-05 16:32:17 -05:00
else if (is_ascii($c) && ( ! (is_ctrl($c) || $isModifier)))
2019-10-22 16:16:28 -04:00
{
$buffer .= $c;
}
if ($callback !== NULL)
{
$callback($buffer, $c);
}
2019-10-22 16:16:28 -04:00
}
}
2019-10-14 16:21:41 -04:00
protected function moveCursor(string $key): void
{
2021-03-09 13:37:03 -05:00
$x = $this->cursor->x;
$y = $this->cursor->y;
$row = $this->rows[$y];
2019-10-14 16:21:41 -04:00
switch ($key)
{
case KeyType::ARROW_LEFT:
2021-03-09 13:37:03 -05:00
if ($x !== 0)
2019-10-14 16:21:41 -04:00
{
2021-03-09 13:37:03 -05:00
$x--;
}
2021-03-09 13:37:03 -05:00
else if ($y > 0)
{
2021-03-09 13:37:03 -05:00
// Beginning of a line, go to end of previous line
$y--;
$x = $this->rows[$y]->size - 1;
2019-10-14 16:21:41 -04:00
}
break;
case KeyType::ARROW_RIGHT:
2021-03-09 13:37:03 -05:00
if ($row && $x < $row->size)
{
2021-03-09 13:37:03 -05:00
$x++;
}
2021-03-09 13:37:03 -05:00
else if ($row && $x === $row->size)
2019-10-14 16:21:41 -04:00
{
2021-03-09 13:37:03 -05:00
$y++;
$x = 0;
2019-10-14 16:21:41 -04:00
}
break;
case KeyType::ARROW_UP:
2021-03-09 13:37:03 -05:00
if ($y !== 0)
2019-10-14 16:21:41 -04:00
{
2021-03-09 13:37:03 -05:00
$y--;
2019-10-14 16:21:41 -04:00
}
break;
case KeyType::ARROW_DOWN:
2021-03-09 13:37:03 -05:00
if ($y < $this->numRows)
2019-10-14 16:21:41 -04:00
{
2021-03-09 13:37:03 -05:00
$y++;
2019-10-14 16:21:41 -04:00
}
break;
case KeyType::PAGE_UP:
2021-03-09 13:37:03 -05:00
$y = ($y > $this->screenRows)
? $y - $this->screenRows
: 0;
break;
case KeyType::PAGE_DOWN:
2021-03-09 13:37:03 -05:00
$y = ($y + $this->screenRows < $this->numRows)
? $y + $this->screenRows
: $this->numRows;
break;
case KeyType::HOME_KEY:
2021-03-09 13:37:03 -05:00
$x = 0;
break;
case KeyType::END_KEY:
2021-03-09 13:37:03 -05:00
if ($y < $this->numRows)
{
2021-03-09 17:22:49 -05:00
$x = $this->rows[$y]->size;
}
break;
default:
// Do nothing
2019-10-14 16:21:41 -04:00
}
2021-03-09 17:22:49 -05:00
// Snap cursor to the end of a row when moving
// from a longer row to a shorter one
$row = $this->rows[$y];
$rowLen = ($row !== NULL) ? $row->size : 0;
if ($x > $rowLen)
{
2021-03-09 17:22:49 -05:00
$x = $rowLen;
}
2021-03-09 13:37:03 -05:00
$this->cursor->x = $x;
$this->cursor->y = $y;
2019-10-14 16:21:41 -04:00
}
2019-10-16 22:14:30 -04:00
public function processKeypress(): ?string
2019-10-14 16:21:41 -04:00
{
$c = $this->readKey();
2019-10-16 22:14:30 -04:00
2020-02-05 14:50:31 -05:00
if ($c === KeyCode::NULL || $c === KeyCode::EMPTY)
2019-10-16 22:14:30 -04:00
{
return '';
}
switch ($c)
2019-10-14 16:21:41 -04:00
{
2021-03-09 17:22:49 -05:00
case KeyCode::CTRL('q'):
return $this->quitAttempt();
case KeyType::ENTER:
2019-10-22 16:16:28 -04:00
$this->insertNewline();
2019-10-22 12:09:11 -04:00
break;
2020-02-05 16:32:17 -05:00
case KeyCode::CTRL('s'):
2019-10-22 12:09:11 -04:00
$this->save();
break;
2020-02-05 16:32:17 -05:00
case KeyCode::CTRL('f'):
$this->find();
break;
case KeyType::BACKSPACE:
case KeyType::DEL_KEY:
if ($c === KeyType::DEL_KEY)
2019-10-22 12:09:11 -04:00
{
$this->moveCursor(KeyType::ARROW_RIGHT);
2019-10-22 12:09:11 -04:00
}
$this->deleteChar();
break;
case KeyType::ARROW_UP:
case KeyType::ARROW_DOWN:
case KeyType::ARROW_LEFT:
case KeyType::ARROW_RIGHT:
case KeyType::PAGE_UP:
case KeyType::PAGE_DOWN:
case KeyType::HOME_KEY:
case KeyType::END_KEY:
2019-10-14 16:21:41 -04:00
$this->moveCursor($c);
break;
2020-02-05 16:32:17 -05:00
case KeyCode::CTRL('l'):
case KeyType::ESCAPE:
2019-10-22 12:09:11 -04:00
// Do nothing
break;
2019-10-18 16:20:34 -04:00
default:
2019-10-22 12:09:11 -04:00
$this->insertChar($c);
break;
2019-10-14 16:21:41 -04:00
}
2021-03-09 17:22:49 -05:00
// Reset quit confirmation timer on different keypress
$this->quitTimes = KILO_QUIT_TIMES;
2019-10-22 12:09:11 -04:00
2019-10-14 16:21:41 -04:00
return $c;
}
2019-10-15 13:23:25 -04:00
2021-03-09 17:22:49 -05:00
protected function quitAttempt(): ?string
{
2021-03-10 22:47:57 -05:00
if ($this->dirty && $this->quitTimes > 0)
2021-03-09 17:22:49 -05:00
{
$this->setStatusMessage(
'WARNING!!! File has unsaved changes. Press Ctrl-Q %d more times to quit.',
$this->quitTimes
);
$this->quitTimes--;
return KeyCode::CTRL('q');
}
Terminal::clear();
return NULL;
}
2020-02-05 14:50:31 -05:00
protected function refreshSyntax(): void
{
// Update the syntax highlighting for all the rows of the file
2021-03-09 17:22:49 -05:00
array_walk($this->rows, static fn (Row $row) => $row->update());
2020-02-05 14:50:31 -05:00
}
private function refreshPHPSyntax(): void
{
2021-03-03 16:35:58 -05:00
if ($this->syntax?->filetype !== 'PHP')
2019-11-19 15:57:51 -05:00
{
return;
}
2021-03-03 11:50:29 -05:00
$this->tokens = PHP8::getTokens($this->rowsToString());
2020-02-05 14:50:31 -05:00
$this->refreshSyntax();
}
2019-10-24 20:21:44 -04:00
}