Merge pull request #1890 from contour-terminal/feature/97-complete-deccir

Complete DECCIR (Cursor Information Report) response

Author: christianparpart

.github/actions/spelling/allow/terminal-terms.txt

@@ -3,6 +3,7 @@ ANSISYSSC
 APC
 APPCURSOR
 APPKEYPAD
+BBBB
 BSU
 CELLBACKGROUND
 CELLFOREGROUND
@@ -101,7 +102,9 @@ MODIFYOTHERKEYS
 NEL
 OSC
 Pgl
+pgl
 Pgr
+pgr
 RCOLORBG
 RCOLORCURSOR
 RCOLORFG
@@ -126,6 +129,7 @@ Setulc
 Satt
 satt
 Sdesig
+sdesig
 Sflag
 sflag
 Sixel

metainfo.xml

@@ -142,6 +142,7 @@
           <li>Adds kitty's unscroll extension (CSI n + T) to restore scrolled-off content from scrollback history</li>
           <li>Adds natural momentum scrolling for touchpad gestures with configurable falloff via momentum_scrolling profile setting</li>
           <li>Adds Kitty OSC 99 desktop notification protocol with D-Bus backend on Linux, supporting structured metadata, chunked payloads, base64 encoding, urgency levels, display occasion filtering, bidirectional close/activation events, and query/alive responses</li>
+          <li>Adds complete DECCIR (Cursor Information Report) response including character set designations, GL/GR mappings, and wrap-pending state (#97)</li>
         </ul>
       </description>
     </release>

src/vtbackend/Charset.h

@@ -34,9 +34,33 @@ enum class CharsetTable : std::uint8_t
     G3 = 3
 };
 
-/// @returns the charset
+/// @returns the charset mapping table for the given charset identifier.
 CharsetMap const* charsetMap(CharsetId id) noexcept;
 
+/// @returns the SCS (Select Character Set) final character for the given charset identifier.
+///
+/// This is the final byte used in SCS escape sequences (e.g., 'B' for USASCII, '0' for Special).
+/// Used by DECCIR (Cursor Information Report) to encode the Sdesig field.
+constexpr char charsetDesignation(CharsetId id) noexcept
+{
+    switch (id)
+    {
+        case CharsetId::Special: return '0';
+        case CharsetId::British: return 'A';
+        case CharsetId::Dutch: return '4';
+        case CharsetId::Finnish: return 'C';
+        case CharsetId::French: return 'R';
+        case CharsetId::FrenchCanadian: return 'Q';
+        case CharsetId::German: return 'K';
+        case CharsetId::NorwegianDanish: return 'E';
+        case CharsetId::Spanish: return 'Z';
+        case CharsetId::Swedish: return 'H';
+        case CharsetId::Swiss: return '=';
+        case CharsetId::USASCII: return 'B';
+    }
+    return 'B'; // fallback to USASCII
+}
+
 /// Charset mapping API for tables G0, G1, G2, and G3.
 ///
 /// Relevant VT sequences are: SCS, SS2, SS3.
@@ -95,10 +119,24 @@ class CharsetMapping
         return isSelected(_tableForNextGraphic, id);
     }
 
-    // Selects a given designated character set into the table G0, G1, G2, or G3.
+    /// Selects a given designated character set into the table G0, G1, G2, or G3.
     void select(CharsetTable table, CharsetId id) noexcept
     {
         _tables[static_cast<std::size_t>(table)] = charsetMap(id);
+        _charsetIds[static_cast<std::size_t>(table)] = id;
+    }
+
+    /// @returns the G-set table currently mapped to GL (the active locking shift).
+    [[nodiscard]] constexpr CharsetTable selectedTable() const noexcept { return _selectedTable; }
+
+    /// @returns the G-set table used for the next graphic character (differs from selectedTable() after
+    /// SS2/SS3).
+    [[nodiscard]] constexpr CharsetTable tableForNextGraphic() const noexcept { return _tableForNextGraphic; }
+
+    /// @returns the CharsetId designated for the given G-set table.
+    [[nodiscard]] constexpr CharsetId charsetIdOf(CharsetTable table) const noexcept
+    {
+        return _charsetIds[static_cast<std::size_t>(table)];
     }
 
   private:
@@ -107,6 +145,9 @@ class CharsetMapping
 
     using Tables = std::array<CharsetMap const*, 4>;
     Tables _tables;
+    std::array<CharsetId, 4> _charsetIds = {
+        CharsetId::USASCII, CharsetId::USASCII, CharsetId::USASCII, CharsetId::USASCII
+    };
 };
 
 } // namespace vtbackend

src/vtbackend/Screen.cpp

@@ -2766,13 +2766,15 @@ namespace impl
             else if (seq.param(0) == 1)
             {
                 // DECCIR — Cursor Information Report
-                // Response: DCS 1 $ u <Pr>;<Pc>;<Pp>;<Srend>;<Satt>;<Sflag>;<Pgl>;<Pgr>;<Scss>;<Sdesig> ST
+                // Response: DCS 1 $ u Pr;Pc;Pp;Srend;Satt;Sflag;Pgl;Pgr;Scss;Sdesig ST
+                // See: https://vt100.net/docs/vt510-rm/DECCIR.html
                 auto const& cursor = screen.cursor();
                 auto const line = *cursor.position.line + 1;
                 auto const column = *cursor.position.column + 1;
                 auto const page = 1; // We only support one page
 
-                // Encode SGR flags as a bitmask character (0x40 base)
+                // Srend: visual attributes bitmask (0x40 base)
+                // Bit 1=Bold, Bit 2=Underline, Bit 3=Blinking, Bit 4=Inverse
                 auto const& flags = cursor.graphicsRendition.flags;
                 int srendBits = 0;
                 if (flags.test(CellFlag::Bold))
@@ -2785,19 +2787,54 @@ namespace impl
                     srendBits |= 8;
                 auto const srend = static_cast<char>(0x40 + srendBits);
 
-                // Protection attribute
+                // Satt: protection attribute (Bit 1 = DECSCA protection)
                 auto const satt = flags.test(CellFlag::CharacterProtected) ? static_cast<char>(0x41)
                                                                            : static_cast<char>(0x40);
 
-                // Flags: origin mode, auto-wrap, selective erase
+                // Sflag: Bit 1=DECOM, Bit 2=SS2, Bit 3=SS3, Bit 4=wrap pending
+                auto const& charsets = cursor.charsets;
                 int sflagBits = 0;
                 if (cursor.originMode)
                     sflagBits |= 1;
-                if (cursor.autoWrap)
+                if (charsets.tableForNextGraphic() != charsets.selectedTable())
+                {
+                    if (charsets.tableForNextGraphic() == CharsetTable::G2)
+                        sflagBits |= 2; // SS2 active
+                    else if (charsets.tableForNextGraphic() == CharsetTable::G3)
+                        sflagBits |= 4; // SS3 active
+                }
+                if (cursor.wrapPending)
                     sflagBits |= 8;
                 auto const sflag = static_cast<char>(0x40 + sflagBits);
 
-                screen.reply("\033P1$u{};{};{};{};{};{}\033\\", line, column, page, srend, satt, sflag);
+                // Pgl: GL charset table index (0=G0, 1=G1, 2=G2, 3=G3)
+                auto const pgl = static_cast<int>(charsets.selectedTable());
+
+                // Pgr: GR charset table index (GR not tracked; default to G2 per VT standard)
+                auto const pgr = 2;
+
+                // Scss: character set size for each G-set (0x40 base)
+                // Bit N = G(N-1) size: 0=94-char, 1=96-char. All supported charsets are 94-char.
+                auto const scss = static_cast<char>(0x40);
+
+                // Sdesig: SCS designation final characters for G0 through G3
+                auto const sdesig =
+                    std::string { charsetDesignation(charsets.charsetIdOf(CharsetTable::G0)),
+                                  charsetDesignation(charsets.charsetIdOf(CharsetTable::G1)),
+                                  charsetDesignation(charsets.charsetIdOf(CharsetTable::G2)),
+                                  charsetDesignation(charsets.charsetIdOf(CharsetTable::G3)) };
+
+                screen.reply("\033P1$u{};{};{};{};{};{};{};{};{};{}\033\\",
+                             line,
+                             column,
+                             page,
+                             srend,
+                             satt,
+                             sflag,
+                             pgl,
+                             pgr,
+                             scss,
+                             sdesig);
                 return ApplyResult::Ok;
             }
             else if (seq.param(0) == 2)

src/vtbackend/Screen_test.cpp

@@ -4050,6 +4050,158 @@ TEST_CASE("HorizontalTab.AfterScreenClear", "[screen]")
     CHECK("X       Y           \n                    \n" == screen.renderMainPageText());
 }
 
+// {{{ DECCIR — Cursor Information Report
+
+TEST_CASE("DECCIR.default_state", "[screen]")
+{
+    // Verify DECCIR response with all defaults: cursor at (1,1), no attributes, no wrap pending,
+    // GL=G0, GR=G2, all charsets USASCII.
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Expected: DCS 1 $ u 1;1;1;@;@;@;0;2;@;BBBB ST
+    //   Pr=1, Pc=1, Pp=1
+    //   Srend='@' (0x40, no attributes)
+    //   Satt='@' (0x40, no protection)
+    //   Sflag='@' (0x40, no flags)
+    //   Pgl=0 (G0 in GL)
+    //   Pgr=2 (G2 in GR, default)
+    //   Scss='@' (0x40, all 94-char sets)
+    //   Sdesig="BBBB" (all USASCII)
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;@;@;@;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.cursor_position", "[screen]")
+{
+    // Verify DECCIR correctly reports cursor position after movement.
+    auto mock = MockTerm { PageSize { LineCount(5), ColumnCount(10) } };
+
+    mock.writeToScreen(CUP(3, 7)); // Move to line 3, column 7
+
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Pr=3, Pc=7
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u3;7;1;@;@;@;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.bold_and_underline", "[screen]")
+{
+    // Verify Srend field encodes bold (bit 1) and underline (bit 2).
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(SGR(1)); // Bold
+    mock.writeToScreen(SGR(4)); // Underline
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Srend = 0x40 + 0x01 (bold) + 0x02 (underline) = 0x43 = 'C'
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;C;@;@;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.blinking_and_inverse", "[screen]")
+{
+    // Verify Srend field encodes blinking (bit 3) and inverse (bit 4).
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(SGR(5)); // Blinking
+    mock.writeToScreen(SGR(7)); // Inverse
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Srend = 0x40 + 0x04 (blink) + 0x08 (inverse) = 0x4C = 'L'
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;L;@;@;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.all_rendition_attributes", "[screen]")
+{
+    // Verify Srend field with all attributes enabled: bold+underline+blink+inverse.
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(SGR(1)); // Bold
+    mock.writeToScreen(SGR(4)); // Underline
+    mock.writeToScreen(SGR(5)); // Blinking
+    mock.writeToScreen(SGR(7)); // Inverse
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Srend = 0x40 + 0x01 + 0x02 + 0x04 + 0x08 = 0x4F = 'O'
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;O;@;@;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.character_protection", "[screen]")
+{
+    // Verify Satt field reports DECSCA character protection attribute.
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(DECSCA(1)); // Enable character protection
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Satt = 0x41 = 'A' (bit 1 set for protection)
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;@;A;@;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.origin_mode", "[screen]")
+{
+    // Verify Sflag bit 1 reports origin mode (DECOM).
+    auto mock = MockTerm { PageSize { LineCount(5), ColumnCount(10) } };
+
+    mock.writeToScreen(DECSM(toDECModeNum(DECMode::Origin)));
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Sflag = 0x40 + 0x01 = 0x41 = 'A' (origin mode set)
+    // Note: cursor is at (1,1) because origin mode homes the cursor.
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;@;@;A;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.wrap_pending", "[screen]")
+{
+    // Verify Sflag bit 4 reports wrap-pending state.
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(5) } };
+
+    // Write exactly enough characters to reach the right margin and trigger wrap pending.
+    mock.writeToScreen("ABCDE");
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Cursor is at column 5, wrap pending. Sflag = 0x40 + 0x08 = 0x48 = 'H'
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;5;1;@;@;H;0;2;@;BBBB\033\\"));
+}
+
+TEST_CASE("DECCIR.charset_designation_special", "[screen]")
+{
+    // Verify Sdesig reports DEC Special charset when designated into G0.
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(SCS_G0_SPECIAL()); // Designate G0 = DEC Special
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Sdesig: G0='0' (Special), G1-G3='B' (USASCII)
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;@;@;@;0;2;@;0BBB\033\\"));
+}
+
+TEST_CASE("DECCIR.charset_designation_g1", "[screen]")
+{
+    // Verify Sdesig reports charset designated into G1.
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen(SCS_G1_SPECIAL()); // Designate G1 = DEC Special
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Sdesig: G0='B', G1='0' (Special), G2-G3='B'
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;@;@;@;0;2;@;B0BB\033\\"));
+}
+
+TEST_CASE("DECCIR.gl_charset_after_locking_shift", "[screen]")
+{
+    // Verify Pgl reports G1 after a locking shift (SO → LS1 maps G1 into GL).
+    auto mock = MockTerm { PageSize { LineCount(3), ColumnCount(10) } };
+
+    mock.writeToScreen("\x0E"); // SO (Shift Out) = LS1 → map G1 into GL
+    mock.writeToScreen(DECRQPSR(1));
+
+    // Pgl=1 (G1 in GL)
+    CHECK(e(mock.terminal.peekInput()) == e("\033P1$u1;1;1;@;@;@;1;2;@;BBBB\033\\"));
+}
+
+// }}} DECCIR
+
 // NOLINTEND(misc-const-correctness,readability-function-cognitive-complexity)
 
 // NOLINTBEGIN(misc-const-correctness)