re_viewer 0.31.3

The Rerun viewer
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 re_ui::CommandPaletteUrl;
use re_viewer_context::open_url::ViewerOpenUrl;

/// A description of what happens when opening a [`ViewerOpenUrl`].
pub struct ViewerOpenUrlDescription {
    /// The general category of this URL.
    pub category: &'static str,

    /// The specific target of this URL if known.
    ///
    /// This is always shorter than the original URL.
    pub target_short: Option<String>,
}

impl std::fmt::Display for ViewerOpenUrlDescription {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(target) = &self.target_short {
            write!(f, "{}: {target}", self.category)
        } else {
            write!(f, "{}", self.category)
        }
    }
}

impl ViewerOpenUrlDescription {
    pub fn from_url(open_url: &ViewerOpenUrl) -> Self {
        match open_url {
            ViewerOpenUrl::IntraRecordingSelection(item) => Self {
                category: "Selection",
                target_short: item.entity_path().map(|p| p.to_string()),
            },

            ViewerOpenUrl::HttpUrl(url) => {
                let path = url.path();
                let rrd_file_name = path.split('/').next_back().map(|s| s.to_owned());

                Self {
                    category: "From http link",
                    target_short: rrd_file_name,
                }
            }

            #[cfg(not(target_arch = "wasm32"))]
            ViewerOpenUrl::FilePath(path) => Self {
                category: "File",
                target_short: path.file_name().map(|s| s.display().to_string()),
            },

            ViewerOpenUrl::RedapDatasetSegment(uri) => Self {
                category: "Segment",
                target_short: Some(uri.segment_id.clone()),
            },

            ViewerOpenUrl::RedapProxy(_) => Self {
                category: "GRPC proxy",
                target_short: None,
            },

            ViewerOpenUrl::RedapCatalog(uri) => Self {
                category: "Catalog",
                target_short: Some(uri.origin.host.to_string()),
            },

            ViewerOpenUrl::RedapEntry(uri) => Self {
                category: "Redap Entry",
                target_short: Some(uri.entry_id.to_string()),
            },

            ViewerOpenUrl::WebEventListener => Self {
                category: "Web event listener",
                target_short: None,
            },

            ViewerOpenUrl::WebViewerUrl { url_parameters, .. } => {
                if url_parameters.len() == 1 {
                    Self::from_url(url_parameters.first())
                } else {
                    Self {
                        category: "Several URLs",
                        target_short: Some(format!("{} URLs", url_parameters.len())),
                    }
                }
            }

            ViewerOpenUrl::Settings => Self {
                category: "Settings",
                target_short: None,
            },

            ViewerOpenUrl::ChunkStoreBrowser { .. } => Self {
                category: "Chunk store browser",
                target_short: None,
            },
        }
    }
}

pub fn command_palette_parse_url(url: &str) -> Option<CommandPaletteUrl> {
    let open_url = ViewerOpenUrl::parse_with_options(
        url,
        &re_data_source::FromUriOptions {
            accept_extensionless_http: true,
            ..Default::default()
        },
    )
    .ok()?;

    Some(CommandPaletteUrl {
        url: url.to_owned(),
        command_text: format!("Open {}", ViewerOpenUrlDescription::from_url(&open_url)),
    })
}