Roger Meier's Forums

roger wrote:I'm afraid CoolTerm will not be able to do exactly what you would like it to do. The plain text display is merely a container that displays the contents of the received buffer in human readable form. New data is always appended to the end of the receive buffer, after which the display is updated. This implementation doesn't lend itself to move the cursor around in the display and thereby changing the point where new data is inserted. The only way to get the cursor (and thus the point where new data is added) to the top left corner is to clear the buffer. In that regard it's very different from the display you would find in a proper terminal emulation application.
So, "clear screen" is something I was able to implement given these constraints. However, "goto 1,1" is not something I'm going to be able to do.

jmuhammad wrote:

roger wrote:New data is always appended to the end of the receive buffer, after which the display is updated. This implementation doesn't lend itself to move the cursor around in the display and thereby changing the point where new data is inserted.

roger wrote:So, you're saying it would suffice if CoolTerm simply scrolled the contents in the plain text window all the way to the top upon receiving a 'ESC[1;1H' (or 'ESC[H' something like that)?

roger wrote:Thanks.

I was actually thinking of replacing ESC[;H with ESC[2J to clear the display. I think that would conform with the standard a bit more. That would free up ESC[;H to home the screen. Intuitively, these would make more sense and do something somewhat related of what they are intended for in proper terminal emulations.

roger wrote:Along those lines, I wonder if perhaps ASCII 2 (Start of Text) would make more sense than ASCII 3 to home the screen?

roger wrote:I should be able to get a proof of concept up and running relatively quickly. I'll reach out via e-mail once I have something ready for testing.

1B 5B 39 32 6D (ESC [ 92 m)

• Handling clear/reset code
  First, CoolTerm handles the reset/clear code ESC[0m correctly.
  
  However, there is an alternative sequence that might be receive: ESC[m which doesn't contain 0. My code is sending this, and CoolTerm doesn't appear to correctly support it.
  
  ChatGPT says the following:
  For the SGR (Select Graphic Rendition) control sequence, the parameter defaults to 0 if omitted per ECMA-48/ISO 6429. So ESC[m is equivalent to ESC[0m and resets all attributes in virtually all ANSI/VT-compatible terminals.
  
  Considering that the alternative sequence is also a valid, expected code that is sent to indicate the same thing, CoolTerm should handle it as well.
  
  So, ESC[m is equivalent to ESC[0m, and it is expected to clear the color as well as remove the bold, italic and underline effects.
  
  Bonus Tip: This is a bit opinionated, but I believe pressing the «× Clear Data» button (in the top toolbar) should also clear the VT-100 effects (such as the text color, and effects such as bold and italic, if supported).
  
  But the current approach, keeps the text color as whatever was set by the last escape code.
  
  If you agree with me, I think it would be better to remove the colors an effects, maybe at least if the connection is currently closed; if that makes sense.
  
  ----
• Bold vs italic effect mismatch
  The ESC[1m sequence is supposed to make the part of the text bold, however it seems that when the unsupported codes are received, it somehow bugs the program, and the italics effect is triggered. I'm not sure exactly how to reproduce this, but it is getting triggered nonetheless.
  
  ----
• Home Display sequence (alternative version)
  Again, it's great to see that the ESC[H ESC[2J sequence is being handled correctly – The options support the "Clear Display" on the ESC[2J code.
  
  However, I'm not sure if you are handling ESC[H the same way you do ESC[;H (notice the missing semicolon).
  
  Again, ChatGPT says the following:
  They’re equivalent.
  
  - ESC[H is CUP (Cursor Position) with both parameters omitted -> row=1, col=1.
  - ESC[;H is CUP with two empty parameters -> both default to 1 as well.
  - Therefore both move the cursor to home (1,1). They’re also equivalent to ESC[1;1H and ESC[f] (and ESC[;f)).
  
  This means that ESC[;H is actually a parametrized sequence code, the other side might supply the row number and column number (e.g. ESC[1;1H), don't supply the default values (e.g. ESC[;H, which is the handled case), or don't supply any values (e.g. ESC[H, which is actually the case in my code).
  
  ----
• Clearing a character (backspace behavior)
  This one might be a little tricky, do to the way the terminal is emulated in CoolTerm, having looked at OpenSimpleTerm's code briefly.
  
  If so, I apologize beforehand for bothering you about it, and understand if it would not be feasible to implement it in CoolTerm.
  
  So, basically, if I press the <- Backspace key, a 0x08 byte is sent to the other side. My code responds like this:
  

  Code: Select all

  Sent: 08                            -> BS
  Recv: 1B 5B 44 1B 5B 4B             -> ESC[D ESC[K
  

  Here’s what those byte sequences mean in a typical terminal:
  
  Hex 08 = character BS (Backspace):
  Moves the cursor one position to the left (without deleting the character on screen in a raw capture). In many terminal contexts a BS followed by a new character is how programs “overwrite” previously printed output.
  
  ESC[D ESC[K:
  This is two ANSI/VT (CSI) control sequences back-to-back:
  
  ESC [ D
  - Name: CUB (Cursor Backward)
  - Meaning: Move cursor backward n columns; n defaults to 1 when omitted. So this moves the cursor left by 1.
  
  ESC [ K
  - Name: EL (Erase in Line)
  - Meaning: Erase part of the current line according to parameter n (which is omitted here, so n = 0 by default). n = 0 means erase from the cursor position to the end of the line (inclusive). It replaces those character cells with the terminal’s erase character (space), without moving the cursor.
  
  Putting them together:
  ESC[D moves cursor one column left.
  ESC[K then clears from that (now earlier) cursor position to end of line.
  
  ChatGPT says the following:
  
  Why a program might do this:
  Often used in dynamic terminal updates (progress bars, status lines) to revise previously printed text without issuing a full carriage return or clearing the whole line.
  
  Notes on defaults (per ECMA-48 / ISO 6429):
  - CSI D with no numeric parameter: n = 1.
  - CSI K with no numeric parameter: n = 0 (cursor to end of line).
  If parameters were present they’d appear as digits before the final letter, e.g. ESC [ 5 D (move left 5), ESC [ 2 K (erase entire line), ESC [ 1 K (erase from start up to cursor).
  
  In summary, when we press the backspace key in CoolTerm (and any other terminal I tested):
  Sent: 08 = Backspace.
  Received:
  ESC [ D = Cursor Backward 1.
  ESC [ K = Erase to end of line.
  Sequence's expected effect: Move cursor left one cell, then blank everything from there to the line’s end.
  
  However, this is not the case in CoolTerm. Can you please detect and handle both ESC[D ESC[K?
  
  For ESC[K, it's simple: Just delete everything from the current location, to the end of the line.
  For ESC[D, I'm not sure how CoolTerm handles the cursor location (if it does), so I'm not sure how trivial it would be to implement it.
  
  -----
• Lastly, I'm making use of other valid VT-100 escape codes, such as ESC[s and ESC[u, which are used to save and restore the current position of the cursor in/from memory.
  
  Codes like this might need the "Disable RX" checkbox to be disabled, so you can keep track of the position of the cursor... I'm not sure, so it might be infeasible to implement such escape codes, although very useful!