fn osc_dispatch()

in crates/alacritty_terminal/src/ansi.rs [1050:1275]


    fn osc_dispatch(&mut self, params: &[&[u8]], bell_terminated: bool) {
        macro_rules! unhandled {
            () => {{
                if self.handler.unhandled_osc_dispatch(params, bell_terminated) == HandledStatus::Unhandled {
                    let mut buf = String::new();
                    for items in params {
                        buf.push('[');
                        for item in *items {
                            write!(buf, "{:?},", *item as char).ok();
                        }
                        buf.push_str("],");
                    }
                    debug!("[unhandled osc_dispatch]: [{}] at line {}", &buf, line!());
                }
            }};
        }

        if params.is_empty() || params[0].is_empty() {
            return;
        }

        match params[0] {
            // Set window title.
            b"0" | b"2" => {
                if params.len() >= 2 {
                    let title = params[1..]
                        .iter()
                        .flat_map(|x| str::from_utf8(x))
                        .collect::<Vec<&str>>()
                        .join(";")
                        .trim()
                        .to_owned();
                    self.handler.set_title(Some(title));
                    return;
                }
                unhandled!();
            },

            // Set color index.
            b"4" => {
                if params.len() > 1 && params.len() % 2 != 0 {
                    for chunk in params[1..].chunks(2) {
                        let index = parse_number(chunk[0]);
                        let color = xparse_color(chunk[1]);
                        if let (Some(i), Some(c)) = (index, color) {
                            self.handler.set_color(i as usize, c);
                            return;
                        }
                    }
                }
                unhandled!();
            },

            // Get/set Foreground, Background, Cursor colors.
            b"10" | b"11" | b"12" => {
                if params.len() >= 2 {
                    if let Some(mut dynamic_code) = parse_number(params[0]) {
                        for param in &params[1..] {
                            // 10 is the first dynamic color, also the foreground.
                            let offset = dynamic_code as usize - 10;
                            let index = NamedColor::Foreground as usize + offset;

                            // End of setting dynamic colors.
                            if index > NamedColor::Cursor as usize {
                                unhandled!();
                                break;
                            }

                            if let Some(color) = xparse_color(param) {
                                self.handler.set_color(index, color);
                            } else {
                                unhandled!();
                            }
                            dynamic_code += 1;
                        }
                        return;
                    }
                }
                unhandled!();
            },

            // Set cursor style.
            b"50" => {
                if params.len() >= 2 && params[1].len() >= 13 && params[1][0..12] == *b"CursorShape=" {
                    let shape = match params[1][12] as char {
                        '0' => CursorShape::Block,
                        '1' => CursorShape::Beam,
                        '2' => CursorShape::Underline,
                        _ => return unhandled!(),
                    };
                    self.handler.set_cursor_shape(shape);
                    return;
                }
                unhandled!();
            },

            // Reset color index.
            b"104" => {
                // Reset all color indexes when no parameters are given.
                if params.len() == 1 {
                    for i in 0..256 {
                        self.handler.reset_color(i);
                    }
                    return;
                }

                // Reset color indexes given as parameters.
                for param in &params[1..] {
                    match parse_number(param) {
                        Some(index) => self.handler.reset_color(index as usize),
                        None => unhandled!(),
                    }
                }
            },

            // Reset foreground color.
            b"110" => self.handler.reset_color(NamedColor::Foreground as usize),

            // Reset background color.
            b"111" => self.handler.reset_color(NamedColor::Background as usize),

            // Reset text cursor color.
            b"112" => self.handler.reset_color(NamedColor::Cursor as usize),

            // feeg
            b"697" => {
                if let Some(fig_osc) = params.get(1) {
                    match *fig_osc {
                        b"NewCmd" => self.handler.new_cmd(""),
                        b"StartPrompt" => self.handler.start_prompt(),
                        b"EndPrompt" => self.handler.end_prompt(),
                        b"PreExec" => self.handler.pre_exec(),
                        param => {
                            let eq_pos = param.iter().position(|b| *b == b'=');
                            if let Some(eq_index) = eq_pos {
                                let (key, val) = param.split_at(eq_index);

                                if val.len() <= 1 {
                                    return unhandled!();
                                }

                                match key {
                                    b"Dir" => match str::from_utf8(val[1..].as_ref()) {
                                        Ok(path_str) => self.handler.dir(Path::new(path_str)),
                                        Err(err) => error!("Failed to parse path: {err}"),
                                    },
                                    b"ShellPath" => match str::from_utf8(val[1..].as_ref()) {
                                        Ok(path_str) => self.handler.shell_path(Path::new(path_str)),
                                        Err(err) => error!("Failed to parse path: {err}"),
                                    },
                                    b"WSLDistro" => match str::from_utf8(val[1..].as_ref()) {
                                        Ok(s) => self.handler.wsl_distro(s),
                                        Err(err) => error!("Error decoding WSL Distro: {err}"),
                                    },
                                    b"ExitCode" => match str::from_utf8(&val[1..]) {
                                        Ok(code) => match code.parse::<i32>() {
                                            Ok(code) => self.handler.exit_code(code),
                                            Err(err) => error!("Error parsing ExitCode: {err}"),
                                        },
                                        Err(err) => error!("Error decoding ExitCode: {err}"),
                                    },
                                    b"Shell" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.shell(s),
                                        Err(err) => error!("Error decoding Shell: {err}"),
                                    },
                                    b"FishSuggestionColor" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.fish_suggestion_color(s),
                                        Err(err) => error!("Error decoding FishSuggestionColor: {err}"),
                                    },
                                    b"ZshAutosuggestionColor" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.zsh_suggestion_color(s),
                                        Err(err) => error!("Error decoding ZshAutosuggestionColor: {err}"),
                                    },
                                    b"FigAutosuggestionColor" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.fig_suggestion_color(s),
                                        Err(err) => error!("Error decoding FigAutosuggestionColor: {err}"),
                                    },
                                    b"NuHintColor" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.nu_hint_color(s),
                                        Err(err) => error!("Error decoding NuHintColor: {err}"),
                                    },
                                    b"TTY" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.tty(s),
                                        Err(err) => error!("Error decoding TTY: {err}"),
                                    },
                                    b"PID" => match str::from_utf8(&val[1..]) {
                                        Ok(code) => match code.parse::<i32>() {
                                            Ok(pid) => self.handler.pid(pid),
                                            Err(err) => error!("Error parsing ExitCode: {err}"),
                                        },
                                        Err(err) => error!("Error decoding ExitCode: {err}"),
                                    },
                                    // b"Hostname" => match str::from_utf8(&val[1..]) {
                                    //     Ok(s) => self.handler.hostname(s),
                                    //     Err(err) => tracing::error!("Error decoding Hostname: {err}"),
                                    // },
                                    b"User" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.username(s),
                                        Err(err) => error!("Error decoding Username: {err}"),
                                    },
                                    b"Log" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.log(s),
                                        Err(err) => error!("Error decoding Log: {err}"),
                                    },
                                    b"NewCmd" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.new_cmd(s),
                                        Err(err) => error!("Error decoding NewCmd: {err}"),
                                    },
                                    b"OSCLock" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.osc_lock(s),
                                        Err(err) => error!("Error decoding OSCLock: {err}"),
                                    },
                                    b"OSCUnlock" => match str::from_utf8(&val[1..]) {
                                        Ok(s) => self.handler.osc_unlock(s),
                                        Err(err) => error!("Error decoding OSCUnlock: {err}"),
                                    },
                                    _ => unhandled!(),
                                }
                            }
                        },
                    }
                }
            },
            _ => unhandled!(),
        }
    }