Skip to main content

virtuoso_cli/client/
layout_ops.rs

1use crate::client::bridge::escape_skill_string;
2
3#[derive(Default)]
4pub struct LayoutOps;
5
6impl LayoutOps {
7    pub fn new() -> Self {
8        Self
9    }
10
11    pub fn create_rect(&self, layer: &str, purpose: &str, bbox: &[(i64, i64); 4]) -> String {
12        let layer = escape_skill_string(layer);
13        let purpose = escape_skill_string(purpose);
14        format!(r#"rodCreateRect(?layer "{layer}" ?purpose "{purpose}" ?bBox {bbox:?})"#)
15    }
16
17    pub fn create_polygon(&self, layer: &str, purpose: &str, points: &[(i64, i64)]) -> String {
18        let layer = escape_skill_string(layer);
19        let purpose = escape_skill_string(purpose);
20        let pts: String = points
21            .iter()
22            .map(|(x, y)| format!("{x} {y}"))
23            .collect::<Vec<_>>()
24            .join(" ");
25        format!(r#"rodCreatePolygon(?layer "{layer}" ?purpose "{purpose}" ?points list({pts}))"#)
26    }
27
28    pub fn create_path(
29        &self,
30        layer: &str,
31        purpose: &str,
32        width: i64,
33        points: &[(i64, i64)],
34    ) -> String {
35        let layer = escape_skill_string(layer);
36        let purpose = escape_skill_string(purpose);
37        let pts: String = points
38            .iter()
39            .map(|(x, y)| format!("{x} {y}"))
40            .collect::<Vec<_>>()
41            .join(" ");
42        format!(
43            r#"rodCreatePath(?layer "{layer}" ?purpose "{purpose}" ?width {width} ?points list({pts}))"#
44        )
45    }
46
47    pub fn create_via(&self, via_def: &str, origin: (i64, i64)) -> String {
48        let via_def = escape_skill_string(via_def);
49        let (x, y) = origin;
50        format!(r#"rodCreateVia(?viaHeader "{via_def}" ?origin {x}:{y})"#)
51    }
52
53    pub fn create_label(
54        &self,
55        layer: &str,
56        _purpose: &str,
57        text: &str,
58        origin: (i64, i64),
59    ) -> String {
60        let layer = escape_skill_string(layer);
61        let text = escape_skill_string(text);
62        let (x, y) = origin;
63        format!(
64            r#"dbCreateLabel(dbGetCurCellView() dbGetLayerByName(dbGetCurCellView() "{layer}") {x}:{y} "{text}" "centerCenter" "R0" "stick" 0.0625)"#
65        )
66    }
67
68    pub fn create_instance(
69        &self,
70        lib: &str,
71        cell: &str,
72        view: &str,
73        origin: (i64, i64),
74        orient: &str,
75    ) -> String {
76        let lib = escape_skill_string(lib);
77        let cell = escape_skill_string(cell);
78        let view = escape_skill_string(view);
79        let orient = escape_skill_string(orient);
80        let (x, y) = origin;
81        format!(
82            r#"dbCreateInst(dbOpenCellViewByType("{lib}" "{cell}" "{view}" nil "r") nil nil {x}:{y} "{orient}" 1)"#
83        )
84    }
85
86    pub fn set_active_lpp(&self, layer: &str, purpose: &str) -> String {
87        let layer = escape_skill_string(layer);
88        let purpose = escape_skill_string(purpose);
89        format!(r#"leSetEntryLayer(list("{layer}" "{purpose}"))"#)
90    }
91
92    pub fn fit_view(&self) -> String {
93        r#"hiRedraw() hiZoomBox(hiGetCurrentWindow() geGetWindowBox(hiGetCurrentWindow()) geGetEditCellView()~>bBox)"#.into()
94    }
95
96    pub fn read_summary(&self) -> String {
97        r#"let((cv) cv = geGetEditCellView() list(cv~>libName cv~>cellName cv~>viewName cv~>bBox length(cv~>instances) length(cv~>nets)))"#.into()
98    }
99
100    pub fn read_geometry(&self, layer: &str, purpose: &str) -> String {
101        let layer = escape_skill_string(layer);
102        let purpose = escape_skill_string(purpose);
103        format!(
104            r#"let((cv shapes) cv = geGetEditCellView() shapes = nil foreach(shape cv~>shapes when(shape~>lpp == list("{layer}" "{purpose}") shapes = cons(shape~>bBox shapes))) shapes)"#
105        )
106    }
107
108    pub fn delete_shapes_on_layer(&self, layer: &str, purpose: &str) -> String {
109        let layer = escape_skill_string(layer);
110        let purpose = escape_skill_string(purpose);
111        format!(
112            r#"let((cv) cv = geGetEditCellView() foreach(shape cv~>shapes when(shape~>lpp == list("{layer}" "{purpose}") dbDeleteObject(shape))))"#
113        )
114    }
115
116    pub fn highlight_net(&self, net_name: &str) -> String {
117        let net_name = escape_skill_string(net_name);
118        format!(
119            r#"let((cv net) cv = geGetEditCellView() net = dbFindNetByName(cv "{net_name}") when(net hiHighlight(net)))"#
120        )
121    }
122}