new icons, and outline

slides/outlines.typ

@@ -0,0 +1,569 @@
+#import "./icons.typ": *
+
+
+#let static_outline(
+  small_icon_size: 100pt,
+  big_icon_size: 200pt,
+) = context {
+  let width = 2 * small_icon_size + big_icon_size * 2
+  let height = big_icon_size
+  let arrow_width = small_icon_size / 10
+  let arrow_gap = small_icon_size / 5
+
+  let app = apk(
+    fill: red,
+    height: small_icon_size
+  )
+  let rprt = report(height: small_icon_size)
+  let analyser = box(
+    height: big_icon_size, 
+    width: big_icon_size, 
+    stroke: black,
+    align(center+horizon, text(fill: red)[TODO])
+  )
+
+  let app_size = measure(app)
+  let app_pos = (
+    0pt,
+    -(height - app_size.height) / 2
+  )
+  let analyser_size = measure(analyser)
+  let analyser_pos = (
+    width / 2 - analyser_size.width / 2,
+    -(height - analyser_size.height) / 2
+  )
+  let rprt_size = measure(rprt)
+  let rprt_pos = (
+    width - rprt_size.width,
+    -(height - rprt_size.height) / 2
+  )
+
+
+  box(
+    width: width,
+    height: height,
+    //stroke: black,
+    {
+      place(
+        left+bottom,
+        dx: app_pos.at(0),
+        dy: app_pos.at(1),
+        app
+      )
+      place(
+        left+bottom,
+        dx: analyser_pos.at(0),
+        dy: analyser_pos.at(1),
+        analyser
+      )
+      place(
+        left+bottom,
+        dx: rprt_pos.at(0),
+        dy: rprt_pos.at(1),
+        rprt
+      )
+      arrow(
+        stroke: (arrow_width + black),
+        (
+          app_pos.at(0) + app_size.width + arrow_gap, 
+          app_pos.at(1) - app_size.height / 2
+        ),
+        (
+          analyser_pos.at(0) - arrow_gap,
+          analyser_pos.at(1) - analyser_size.height / 2,
+        )
+      )
+      arrow(
+        stroke: (arrow_width + black),
+        (
+          analyser_pos.at(0) + analyser_size.width + arrow_gap,
+          analyser_pos.at(1) - analyser_size.height / 2,
+        ),
+        (
+          rprt_pos.at(0) - arrow_gap, 
+          rprt_pos.at(1) - rprt_size.height / 2
+        )
+      )
+    }
+  )
+}
+
+#let dexhunter_outline(
+  small_icon_size: 100pt,
+  big_icon_size: 200pt,
+) = context {
+  let width = small_icon_size * 3 + big_icon_size
+  let height = (3 + 1) * small_icon_size
+  let arrow_width = small_icon_size / 10
+  let arrow_gap = small_icon_size / 5
+
+  let app = apk(
+    fill: red,
+    height: small_icon_size
+  )
+  let dex = apk(
+    fill: green,
+    height: small_icon_size,
+    txt: ".dex"
+  )
+
+  let phone = phone(
+    width: big_icon_size / 2,
+    height: big_icon_size,
+  )
+
+  let app_size = measure(app)
+  let dex_size = measure(dex)
+  let phone_size = measure(phone)
+
+  let app_pos = (
+    0pt,
+    -height / 2 + app_size.height / 2
+  )
+  let dex_pos0 = (
+    width - dex_size.width,
+    0pt
+  )
+  let dex_pos1 = (
+    width - dex_size.width,
+    -height / 2 + dex_size.height / 2
+  )
+  let dex_pos2 = (
+    width - dex_size.width,
+    -height + dex_size.height
+  )
+
+  let phone_pos = (
+    width / 2 - phone_size.width / 2,
+    -height / 2 + phone_size.height / 2
+  )
+
+  let arrow_l_x0 = phone_pos.at(0) + phone_size.width + arrow_gap
+  let arrow_l_x2 = width - dex_size.width - arrow_gap
+  let arrow_l_x1 = (arrow_l_x2 + arrow_l_x0) / 2
+
+  let arrow_l_y0_0 = phone_pos.at(1) - phone_size.height * 1/4
+  let arrow_l_y0_1 = phone_pos.at(1) - phone_size.height * 2/4
+  let arrow_l_y0_2 = phone_pos.at(1) - phone_size.height * 3/4
+  let arrow_l_y1_0 = dex_pos0.at(1) - dex_size.height / 2
+  let arrow_l_y1_1 = dex_pos1.at(1) - dex_size.height / 2
+  let arrow_l_y1_2 = dex_pos2.at(1) - dex_size.height / 2
+
+  box(
+    width: width,
+    height: height,
+    stroke: black,
+    {
+      place(
+        left+bottom,
+        dx: app_pos.at(0),
+        dy: app_pos.at(1),
+        app
+      )
+      place(
+        left+bottom,
+        dx: dex_pos0.at(0),
+        dy: dex_pos0.at(1),
+        dex
+      )
+      place(
+        left+bottom,
+        dx: dex_pos1.at(0),
+        dy: dex_pos1.at(1),
+        dex
+      )
+      place(
+        left+bottom,
+        dx: dex_pos2.at(0),
+        dy: dex_pos2.at(1),
+        dex
+      )
+      place(
+        left+bottom,
+        dx: phone_pos.at(0),
+        dy: phone_pos.at(1),
+        phone
+      )
+
+      arrow(
+        stroke: arrow_width + black,
+        (
+          app_pos.at(0) + app_size.width + arrow_gap,
+          app_pos.at(1) - app_size.height / 2
+        ),
+        (
+          phone_pos.at(0) - arrow_gap,
+          phone_pos.at(1) - phone_size.height / 2,
+        )
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_l_x0, arrow_l_y0_0),
+        (arrow_l_x1, arrow_l_y0_0),
+        (arrow_l_x1, arrow_l_y1_0),
+        (arrow_l_x2, arrow_l_y1_0),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_l_x0, arrow_l_y0_1),
+        (arrow_l_x1, arrow_l_y0_1),
+        (arrow_l_x1, arrow_l_y1_1),
+        (arrow_l_x2, arrow_l_y1_1),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_l_x0, arrow_l_y0_2),
+        (arrow_l_x1, arrow_l_y0_2),
+        (arrow_l_x1, arrow_l_y1_2),
+        (arrow_l_x2, arrow_l_y1_2),
+      )
+    }
+  )
+}
+
+#let theseus_outline(
+  small_icon_size: 60pt,
+  big_icon_size: 90pt,
+) = context {
+  let width = (
+    small_icon_size * 4 + 
+    big_icon_size * 3 + 
+    5 * small_icon_size
+  )
+  let height = 4.5 * small_icon_size + big_icon_size
+  let y0 = (height - big_icon_size) - 2 * small_icon_size
+  let arrow_width = small_icon_size / 10
+  let arrow_gap = small_icon_size / 5
+
+  let app = apk(
+    fill: red,
+    height: small_icon_size
+  )
+  let app2 = apk(
+    fill: blue,
+    height: small_icon_size
+  )
+  let dex = apk(
+    fill: green,
+    height: small_icon_size,
+    txt: ".dex"
+  )
+  let rprt = report(
+    height: small_icon_size,
+  )
+
+  let phone = phone(
+    width: big_icon_size * 0.75,
+    height: big_icon_size * 1.5,
+  )
+
+  let app_size = measure(app)
+  let dex_size = measure(dex)
+  let rprt_size = measure(rprt)
+  let phone_size = measure(phone)
+
+  let app_pos = (
+    0pt,
+    -y0 + app_size.height / 2
+  )
+
+  let dex_pos_x = width * 2/7 - dex_size.width / 2
+  let dex_pos0 = (
+    dex_pos_x,
+    - y0 + 2 * dex_size.height
+  )
+  let dex_pos1 = (
+    dex_pos_x,
+    - y0 + dex_size.height / 2
+  )
+  let rprt_pos2 = (
+     width * 2/7 - rprt_size.width / 2,
+    - y0 - dex_size.height
+  )
+
+  let phone_pos = (
+    width / 7 - phone_size.width / 2,
+    -y0 + phone_size.height / 2
+  )
+
+  let arrow_1_x0 = phone_pos.at(0) + phone_size.width + arrow_gap
+  let arrow_1_x2 = dex_pos_x - arrow_gap
+  let arrow_1_x1 = (arrow_1_x2 + arrow_1_x0) / 2
+
+  let arrow_1_y0_0 = phone_pos.at(1) - phone_size.height * 1/4
+  let arrow_1_y0_1 = phone_pos.at(1) - phone_size.height * 2/4
+  let arrow_1_y0_2 = phone_pos.at(1) - phone_size.height * 3/4
+  let arrow_1_y1_0 = dex_pos0.at(1) - dex_size.height / 2
+  let arrow_1_y1_1 = dex_pos1.at(1) - dex_size.height / 2
+  let arrow_1_y1_2 = rprt_pos2.at(1) - dex_size.height / 2
+
+  let patcher = box(
+    height: big_icon_size, 
+    width: big_icon_size, 
+    stroke: black,
+    align(center+horizon, text(fill: red)[TODO PATCHER])
+  )
+  let patcher_size = measure(patcher)
+  let patcher_pos = (
+    width * 3.3 / 7 - patcher_size.width / 2,
+    -y0 + patcher_size.height / 2
+  )
+
+  let arrow_2_x0 = dex_pos1.at(0) + dex_size.width + arrow_gap
+  let arrow_2_x2 = patcher_pos.at(0) - arrow_gap
+  let arrow_2_x1 = (arrow_2_x2 + arrow_2_x0) / 2
+
+  let arrow_2_y0_0 = dex_pos0.at(1) - dex_size.height / 2
+  let arrow_2_y0_1 = dex_pos1.at(1) - dex_size.height / 2
+  let arrow_2_y0_2 = rprt_pos2.at(1) - dex_size.height / 2
+  let arrow_2_y1_0 = patcher_pos.at(1) - patcher_size.height * 1/4
+  let arrow_2_y1_1 = patcher_pos.at(1) - patcher_size.height * 2/4
+  let arrow_2_y1_2 = patcher_pos.at(1) - patcher_size.height * 3/4
+
+
+  let app2_size = measure(app2)
+  let app2_pos = (
+    width * 4.5 / 7 - app2_size.width / 2,
+    -y0 + app2_size.height / 2
+  )
+
+  let analyser = box(
+    height: big_icon_size, 
+    width: big_icon_size, 
+    stroke: black,
+    align(center+horizon, text(fill: red)[TODO ANALYSER])
+  )
+  let analyser_size = measure(analyser)
+  let analyser_pos = (
+    width * 5.7 / 7 - analyser_size.width / 2,
+    -y0 + analyser_size.height / 2
+  )
+  let analyser_pos2 = (
+    width / 2 - analyser_size.width / 2,
+    -height + analyser_size.height
+  )
+  
+  let rprt2_pos = (
+    width - rprt_size.width,
+    -y0 + rprt_size.height / 2
+  )
+  let rprt3_pos = (
+    analyser_pos2.at(0) + analyser_size.width + 2 * rprt_size.width,
+    analyser_pos2.at(1) - analyser_size.height / 2 + rprt_size.height / 2
+  )
+
+  box(
+    width: width,
+    height: height,
+    //stroke: black,
+    {
+      place(
+        left+bottom,
+        dx: app_pos.at(0),
+        dy: app_pos.at(1),
+        app
+      )
+      place(
+        left+bottom,
+        dx: dex_pos0.at(0),
+        dy: dex_pos0.at(1),
+        dex
+      )
+      place(
+        left+bottom,
+        dx: dex_pos1.at(0),
+        dy: dex_pos1.at(1),
+        dex
+      )
+      place(
+        left+bottom,
+        dx: rprt_pos2.at(0),
+        dy: rprt_pos2.at(1),
+        rprt
+      )
+      place(
+        left+bottom,
+        dx: phone_pos.at(0),
+        dy: phone_pos.at(1),
+        phone
+      )
+
+      arrow(
+        stroke: arrow_width + black,
+        (
+          app_pos.at(0) + app_size.width + arrow_gap,
+          app_pos.at(1) - app_size.height / 2
+        ),
+        (
+          phone_pos.at(0) - arrow_gap,
+          phone_pos.at(1) - phone_size.height / 2,
+        )
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_1_x0, arrow_1_y0_0),
+        (arrow_1_x1, arrow_1_y0_0),
+        (arrow_1_x1, arrow_1_y1_0),
+        (arrow_1_x2, arrow_1_y1_0),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_1_x0, arrow_1_y0_1),
+        (arrow_1_x1, arrow_1_y0_1),
+        (arrow_1_x1, arrow_1_y1_1),
+        (arrow_1_x2, arrow_1_y1_1),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_1_x0, arrow_1_y0_2),
+        (arrow_1_x1, arrow_1_y0_2),
+        (arrow_1_x1, arrow_1_y1_2),
+        (arrow_1_x2, arrow_1_y1_2),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_2_x0, arrow_2_y0_0),
+        (arrow_2_x1, arrow_2_y0_0),
+        (arrow_2_x1, arrow_2_y1_0),
+        (arrow_2_x2, arrow_2_y1_0),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_2_x0, arrow_2_y0_1),
+        (arrow_2_x1, arrow_2_y0_1),
+        (arrow_2_x1, arrow_2_y1_1),
+        (arrow_2_x2, arrow_2_y1_1),
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (arrow_2_x0, arrow_2_y0_2),
+        (arrow_2_x1, arrow_2_y0_2),
+        (arrow_2_x1, arrow_2_y1_2),
+        (arrow_2_x2, arrow_2_y1_2),
+      )
+
+      place(
+        bottom+left,
+        dx: patcher_pos.at(0),
+        dy: patcher_pos.at(1),
+        patcher
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (
+          patcher_pos.at(0) + patcher_size.width + arrow_gap,
+          patcher_pos.at(1) - patcher_size.height / 2
+        ),
+        (
+          app2_pos.at(0) - arrow_gap,
+          app2_pos.at(1) - app2_size.height / 2,
+        )
+      )
+      place(
+        bottom+left,
+        dx: app2_pos.at(0),
+        dy: app2_pos.at(1),
+        app2
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (
+          app2_pos.at(0) + app2_size.width + arrow_gap,
+          app2_pos.at(1) - app2_size.height / 2
+        ),
+        (
+          analyser_pos.at(0) - arrow_gap,
+          analyser_pos.at(1) - analyser_size.height / 2,
+        )
+      )
+      place(
+        bottom+left,
+        dx: analyser_pos.at(0),
+        dy: analyser_pos.at(1),
+        analyser
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (
+          analyser_pos.at(0) + analyser_size.width + arrow_gap,
+          analyser_pos.at(1) - analyser_size.height / 2
+        ),
+        (
+          rprt2_pos.at(0) - arrow_gap,
+          rprt2_pos.at(1) - rprt_size.height / 2,
+        )
+      )
+      place(
+        left+bottom,
+        dx: rprt2_pos.at(0),
+        dy: rprt2_pos.at(1),
+        rprt
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (
+          app_pos.at(0) + app_size.width / 2,
+          app_pos.at(1) + arrow_gap,
+        ),
+        (
+          app_pos.at(0) + app_size.width / 2,
+          -arrow_width
+        ),
+        (
+          patcher_pos.at(0) + patcher_size.width / 2,
+          -arrow_width
+        ),
+        (
+          patcher_pos.at(0) + patcher_size.width / 2,
+          patcher_pos.at(1) + arrow_gap
+        )
+      )
+
+      place(
+        bottom+left,
+        dx: analyser_pos2.at(0),
+        dy: analyser_pos2.at(1),
+        analyser
+      )
+      place(
+        left+bottom,
+        dx: rprt3_pos.at(0),
+        dy: rprt3_pos.at(1),
+        rprt
+      )
+
+      arrow(
+        stroke: arrow_width + black,
+        (
+          analyser_pos2.at(0) + analyser_size.width + arrow_gap,
+          analyser_pos2.at(1) - analyser_size.height / 2,
+        ),
+        (
+          rprt3_pos.at(0) - arrow_gap,
+          rprt3_pos.at(1) - rprt_size.height / 2,
+        )
+      )
+      arrow(
+        stroke: arrow_width + black,
+        (
+          app_pos.at(0) + app_size.width/2,
+          app_pos.at(1) - app_size.height - arrow_gap,
+        ),
+        (
+          app_pos.at(0) + app_size.width/2,
+          analyser_pos2.at(1) - analyser_size.height / 2,
+        ),
+        (
+          analyser_pos2.at(0) - arrow_gap,
+          analyser_pos2.at(1) - analyser_size.height / 2,
+        ),
+      )
+    }
+  )
+}
+
+#set page(flipped: true)
+#set align(center+horizon)
+//#dexhunter_outline()
+//#static_outline()
+#theseus_outline()