little-kitty 0.0.3

A low-level interface for the Kitty Graphics Protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use super::super::{command::*, utils::*};

use std::io::*;

// The spec doesn't mention a size limit, but for safety reasons we want one
const MAX_RESPONSE_SIZE: usize = 4096;

const ESC: u8 = b'\x1b';

//
// KittyResponseReader
//

/// Kitty graphics protocol response reader utilities.
pub trait KittyResponseReader {
    /// Read Kitty response.
    fn read_response(&mut self) -> Result<Option<Response>>;

    /// Whether we have a Kitty response followed by a VT100 DA1 query response.
    fn has_kitty_and_device_query_responses(&mut self) -> Result<bool>;
}

impl<ReadT> KittyResponseReader for ReadT
where
    ReadT: Read,
{
    fn read_response(&mut self) -> Result<Option<Response>> {
        if (self.read_byte()? != ESC) || (self.read_byte()? != b'_') || (self.read_byte()? != b'G') {
            return Ok(None);
        }

        let mut response = Vec::default();

        // Keep reading until ESC or at size limit
        let mut size = 0;
        loop {
            match self.read_byte()? {
                ESC => break,

                byte => {
                    if size >= MAX_RESPONSE_SIZE {
                        return Ok(None);
                    }
                    size += 1;
                    response.push(byte);
                }
            }
        }

        if self.read_byte()? != b'\\' {
            return Ok(None);
        }

        Ok(Some(response.as_slice().try_into()?))
    }

    // Checks for either of:
    //
    // * A Kitty response followed by a VT100 device attributes query response = Kitty is supported
    // * Only a VT100 device attributes response = Kitty is not supported
    fn has_kitty_and_device_query_responses(&mut self) -> Result<bool> {
        if self.read_byte()? != ESC {
            return Ok(false);
        }

        match self.read_byte()? {
            // We're in the VT100 response (no Kitty!)
            b'?' => {
                // Keep reading until 'c'
                loop {
                    if self.read_byte()? == b'c' {
                        break;
                    }
                }
                return Ok(false);
            }

            // We're in a Kitty response
            b'_' => {}

            _ => return Ok(false),
        }

        if self.read_byte()? != b'G' {
            return Ok(false);
        }

        // Keep reading until ESC
        loop {
            if self.read_byte()? == ESC {
                break;
            }
        }

        if (self.read_byte()? != b'\\')
            || (self.read_byte()? != ESC)
            || (self.read_byte()? != b'[')
            || (self.read_byte()? != b'?')
        {
            return Ok(false);
        }

        // Keep reading until 'c'
        loop {
            if self.read_byte()? == b'c' {
                break;
            }
        }

        Ok(true)
    }
}