Merge pull request 'feature: added guided wire style' (#14) from Shmerlard/circuiteria:dev into dev

Reviewed-on: HEL/circuiteria#14
Reviewed-by: Louis Heredero <louis@herdac.ch>

doc/examples.typ

@@ -56,7 +56,7 @@ for i in range(3) {
 ```)
 
 #let wires = example(```
-for i in range(3) {
+for i in range(4) {
   draw.circle((i * 3, 0), radius: .1, name: "p" + str(i * 2))
   draw.circle((i * 3 + 2, 1), radius: .1, name: "p" + str(i * 2 + 1))
   draw.content((i * 3 + 1, -1), raw(wire.wire-styles.at(i)))
@@ -65,6 +65,10 @@ wire.wire("w1", ("p0", "p1"), style: "direct")
 wire.wire("w2", ("p2", "p3"), style: "zigzag")
 wire.wire("w3", ("p4", "p5"), style: "dodge",
           dodge-y: -0.5, dodge-margins: (0.5, 0.5))
+wire.wire("w4", ("p6","p7"), style: "guided",
+          guided-center:(20%, 40%), guided-margins: (90%,87%),
+          guided-sides: ("north","south"))
+
 ```, vertical: true)
 
 #let stub = example(```
@@ -187,4 +191,4 @@ wire.wire("w1", ((0, 0), (1, 1)), style: "zigzag")
 wire.wire("w2", ((0, 0), (1, -.5)),
           style: "zigzag", zigzag-ratio: 80%)
 wire.intersection("w1.zig")
-```)
+```)

src/circuit.typ

@@ -9,6 +9,5 @@
 /// - length (length, ratio): Optional base unit
 /// -> none
 #let circuit(body, length: 2em) = {
-  set text(font: "Source Sans 3")
   canvas(length: length, body)
-}
+}

src/elements/alu.typ

@@ -1,6 +1,6 @@
 #import "@preview/cetz:0.3.2": draw
 #import "element.typ"
-#import "ports.typ": add-ports, add-port
+#import "ports.typ": add-port
 
 #let draw-shape(id, tl, tr, br, bl, fill, stroke) = {
   let p0 = tl
@@ -31,15 +31,15 @@
     draw.anchor("name", (p5, 50%, (p1, 50%, p2)))
   })
 
-  // let f2 = add-port(id, "west", (id: "in1"), (p0, 50%, p6))
+  let f2 = add-port(id, "west", (id: "in1"), (p0, 50%, p6))
-  // let f3 = add-port(id, "west", (id: "in2"), (p3, 50%, p4))
+  let f3 = add-port(id, "west", (id: "in2"), (p3, 50%, p4))
-  // let f4 = add-port(id, "east", (id: "out"), (p1, 50%, p2))
+  let f4 = add-port(id, "east", (id: "out"), (p1, 50%, p2))
 
-  // let f = {
+  let f = {
-  //   f1; f2; f3; f4
+    f1; f2; f3; f4
-  // }
+  }
 
-  return (f1, tl, tr, br, bl)
+  return (f, tl, tr, br, bl)
 }
 
 /// Draws an ALU with two inputs
@@ -53,16 +53,6 @@
   h: none,
   name: none,
   name-anchor: "center",
-  ports: (
-    west: (
-      (id: "in1"),
-      (id: "in2"),
-    ),
-    east: (
-      (id: "out"),
-    )
-  ),
-  ports-margins: (west: (-30%, -30%)),
   fill: none,
   stroke: black + 1pt,
   id: "",
@@ -70,6 +60,16 @@
     ports: false
   )
 ) = {
+  let ports = (
+    west: (
+      (id: "in1"),
+      (id: "in2"),
+    ),
+    east: (
+      (id: "out"),
+    )
+  )
+  
   element.elmt(
     draw-shape: draw-shape,
     x: x,
@@ -79,16 +79,15 @@
     name: name,
     name-anchor: name-anchor,
     ports: ports,
-    ports-margins: ports-margins,
     fill: fill,
     stroke: stroke,
     id: id,
-    // auto-ports: false,
+    auto-ports: false,
-    // ports-y: (
+    ports-y: (
-    //   in1: (h) => {h * 0.225},
+      in1: (h) => {h * 0.225},
-    //   in2: (h) => {h * 0.775},
+      in2: (h) => {h * 0.775},
-    //   out: (h) => {h * 0.5}
+      out: (h) => {h * 0.5}
-    // ),
+    ),
     debug: debug
   )
 }

src/elements/block.typ

@@ -1,9 +1,9 @@
 #import "@preview/cetz:0.3.2": draw
 #import "element.typ"
 
-#let draw-shape(id, tl, tr, br, bl, fill, stroke) = {
+#let draw-shape(id, tl, tr, br, bl, fill, stroke, radius: 0.5em) = {
   let f = draw.rect(
-    radius: 0.5em,
+    radius: radius,
     inset: 0.5em,
     fill: fill,
     stroke: stroke,
@@ -27,13 +27,14 @@
   ports: (),
   ports-margins: (),
   fill: none,
+  radius: 0.5em,
   stroke: black + 1pt,
   id: "",
   debug: (
     ports: false
   )
 ) = element.elmt(
-  draw-shape: draw-shape,
+  draw-shape: draw-shape.with(radius: radius),
   x: x,
   y: y,
   w: w,
@@ -46,4 +47,4 @@
   stroke: stroke,
   id: id,
   debug: debug
-)
+)

src/elements/ports.typ

@@ -24,10 +24,8 @@
 
     let pos1 = (rel: offset, to: pos)
 
-    let clock-line-style = port.at("clock-line-style", default: (:))
-
     // TODO: use context or vectors to have the height relative to the width
-    draw.line(prev, pos1, next, ..clock-line-style)
+    draw.line(prev, pos1, next)
   }
   draw.content(
     pos,

src/wire.typ

@@ -3,7 +3,7 @@
 
 /// List of valid wire styles
 /// #examples.wires
-#let wire-styles = ("direct", "zigzag", "dodge")
+#let wire-styles = ("direct", "zigzag", "dodge", "guided")
 #let signal-width = 1pt
 #let bus-width = 1.5pt
 
@@ -109,6 +109,88 @@
   return (points, anchors)
 }
 
+#let get-guided-wire(pts, margins, sides, center-guides, ctx) = {
+  let start = pts.first()
+  let end = pts.last()
+  let (margin-start, margin-end) = margins
+  let (side-start, side-end) = sides
+  let (center_horizontal, center_vertical) = center-guides
+
+  let (ctx, p0) = coordinate.resolve(ctx, start)
+  let (ctx, p6) = coordinate.resolve(ctx, end)
+  p0 = (x: p0.first(), y: p0.at(1))
+  p6 = (x: p6.first(), y: p6.at(1))
+
+  let box_width = calc.abs(p6.x - p0.x)
+  let box_height = calc.abs(p6.y - p0.y)
+
+  // finding correct dx and dy
+  let dx1 = box_width * margin-start / 100%
+  if side-start == "west" {
+    dx1 *= -1
+  } else if side-start == "north" or side-start == "south" { dx1 = 0}
+
+  let dx2 = box_width * margin-end / 100%
+  if side-end == "west" {
+    dx2 *= -1
+  } else if side-end == "north" or side-end == "south" { dx2 = 0}
+
+  let dy1 = box_height * margin-start / 100%
+  if side-start == "south" {
+    dy1 *= -1
+  } else if side-start == "west" or side-start == "east" { dy1 = 0}
+
+  let dy2 = box_height * margin-end / 100%
+  if side-end == "south" {
+    dy2 *= -1
+  } else if side-end == "west" or side-end == "east" { dy2 = 0}
+
+
+  // points that are closest to the edge points
+  let p1 = (p0.x + dx1, p0.y + dy1)
+  let p5 = (p6.x + dx2, p6.y + dy2)
+
+
+  // middle point
+  let center_x = p0.x + box_width * center_horizontal / 100%
+  let center_y = p0.y + box_height * center_vertical / 100%
+  let p3 = (center_x, center_y)
+
+  // setting up the points for that touch the guides
+  let p2 = (0,0)
+  let p4 = (0,0)
+  if side-start in ("north", "south") {
+    p2 = (horizontal: p3, vertical: p1)
+  } else {
+    p2 = (horizontal: p1, vertical: p3)
+  }
+  if side-end in ("north", "south") {
+    p4 = (horizontal: p3, vertical: p5)
+  } else if side-end in ("east", "west") {
+    p4 = (horizontal: p5, vertical: p3)
+  }
+
+  // returning
+  let points = (
+    start,
+    p1,
+    p2,
+    p3,
+    p4,
+    p5,
+    end
+  )
+  let anchors = (
+    "start": start,
+    "start2": points.at(1),
+    "guide-start": points.at(2),
+    "center": points.at(3),
+    "guide-end": points.at(4),
+    "end2": points.at(5),
+    "end": end
+  )
+  return (points, anchors)
+}
 /// Draws a wire between two points
 /// - id (str): The wire's id, for future reference (anchors)
 /// - pts (array): The two points (as CeTZ compatible coordinates, i.e. XY, relative positions, ids, etc.)
@@ -127,6 +209,9 @@
 /// - dodge-y (number): Y position to dodge the wire to (only with style "dodge")
 /// - dodge-sides (array): The start and end sides (going out of the connected element) of the wire (only with style "dodge")
 /// - dodge-margins (array): The start and end margins (i.e. space before dodging) of the wire (only with style "dodge")
+/// - guided-center (array): the horizontal and vertical guides of the center guides (only with style "guided")
+/// - guided-margins (array): the start and end of guided margins of the wire (only with style "guided")
+/// - guided-sides (array): the side of start and end array (must be either "north", "south", "west", "east") (only work with style "guided")
 #let wire(
   id, pts,
   bus: false,
@@ -137,6 +222,9 @@
   dashed: false,
   style: "direct",
   reverse: false,
+  guided-center: (50%, 50%),
+  guided-margins: (5%, 5%),
+  guided-sides: ("east", "west"),
   directed: false,
   rotate-name: true,
   zigzag-ratio: 50%,
@@ -178,6 +266,14 @@
       dodge-sides,
       ctx
     )
+  } else if style == "guided" {
+    (points, anchors) = get-guided-wire(
+      pts,
+      guided-margins,
+      guided-sides,
+      guided-center,
+      ctx
+    )
   }
 
   let mark = (fill: color)
@@ -215,7 +311,7 @@
   if name != none {
     let names = ()
     
-    if type(name) == str or type(name) == content {
+    if type(name) == str {
       names = ((name, name-pos),)
       
     } else if type(name) == array {
@@ -267,9 +363,7 @@
 /// - vertical (bool): Whether the name should be displayed vertically
 /// - length (number): The length of the stub
 /// - name-offset (number): The name offset, perpendicular to the stub
-#let stub(port-id, side, name: none, vertical: false, length: none, name-offset: 0, directed: false) = {
+#let stub(port-id, side, name: none, vertical: false, length: 1em, name-offset: 0) = {
-  let length = if length != none { length } else if directed { 1.5em } else { 1em }
-
   let end-offset = (
     north: (0, length),
     east: (length, 0),
@@ -284,15 +378,9 @@
     west: (-length, name-offset)
   ).at(side)
 
-  let mark = (:)
-  if directed {
-    mark = (end: ">", fill: black)
-  }
-
   draw.line(
-    (rel: end-offset, to: port-id),
     port-id,
-    mark: mark
+    (rel: end-offset, to: port-id)
   )
   if name != none {
     let text-anchor = if vertical {
@@ -311,4 +399,4 @@
       name
     )
   }
-}
+}