(use jw32/_winuser)

(use jw32/_uiautomation)

(use jw32/_dwmapi)

(use jw32/_util)

(use jwno/util)

(import jwno/log)

(import jwno/auto-layout)

(import jwno/indicator)

(def {:window-manager window-man

:ui-manager ui-man

:key-manager key-man

:command-manager command-man

:hook-manager hook-man}

jwno/context)

(def current-frame-tooltip (indicator/current-frame-tooltip jwno/context))

(:enable current-frame-tooltip)

(def *auto-close-empty-frame*

(auto-layout/close-empty-frame jwno/context))

(def CONTINUE-KEY "Space")

(def *allowed-commands*

@{:nop true

:quit true

:exec true

:cascade-windows-in-frame true

:retile true})

(var *next-slide-cmd* nil)

(defn enable-command [cmd &opt pred]

(default pred true)

(put *allowed-commands* cmd pred))

(defn disable-command [cmd]

(put *allowed-commands* cmd nil))

(defn disable-continue-key [keymap]

(def [next-key] (:parse-key keymap CONTINUE-KEY))

(def next-slide-binding (:get-key-binding keymap next-key))

(put keymap next-key nil)

[next-key (in next-slide-binding :cmd)])

(defn arm-next-slide-trigger [trigger-cmd next-cmd &opt pred]

(if pred

(set *next-slide-cmd* [next-cmd pred])

(set *next-slide-cmd* [next-cmd (fn [cmd _args] (= cmd trigger-cmd))])))

(defn get-first-frame []

(def cur-frame (:get-current-frame (in window-man :root)))

(def top-frame (:get-top-frame cur-frame))

(:get-first-frame top-frame))

(defn calc-rect-center [rect]

(def [w h] (rect-size rect))

[(math/round (+ (in rect :left) (/ w 2)))

(math/round (+ (in rect :top) (/ h 2)))])

(defn slide-name-to-cmd [name]

(keyword :slide- name))

(defn format-slide-text [slide-id total-slides text &opt show-continue?]

(default show-continue? true)

(string/format "Jwno Tutorial %n/%n\n\n%s%s"

slide-id

total-slides

text

(if show-continue?

(string/format "\n\nPress %s to continue." CONTINUE-KEY)

"")))

(var *mod-key* nil)

(var *dir-keys* {})

(defn $ [str]

(->> str

(peg/replace-all "${MOD}" *mod-key*)

(peg/replace-all "${LEFT}" (in *dir-keys* :left))

(peg/replace-all "${DOWN}" (in *dir-keys* :down))

(peg/replace-all "${UP}" (in *dir-keys* :up))

(peg/replace-all "${RIGHT}" (in *dir-keys* :right))

(string)))

(defn cmd-show-keymap [keymap]

(:show-tooltip

ui-man

:show-keymap

(:format keymap)

nil nil

5000

:center))

(:add-command command-man :show-keymap cmd-show-keymap)

(def *common-keymap* (:new-keymap key-man))

(defn define-common-keys []

(:define-key *common-keymap*

($ "${MOD} + Shift + Q")

:quit

"Stop this tutorial and quit Jwno")

(:define-key *common-keymap*

($ "${MOD} + Enter Enter")

:nop

"Cancel")

(:define-key *common-keymap*

($ "${MOD} + Enter Esc")

:nop

"Cancel")

(:define-key *common-keymap*

($ "${MOD} + Enter R")

[:repl true "127.0.0.1" 9999]

"Launch Jwno REPL")

*common-keymap*)

(def *acc-keymap* (:new-keymap key-man *common-keymap*))

(defn build-slide-keymap []

(:new-keymap key-man *acc-keymap*))

(defn set-slide-keymap [keymap]

(when *mod-key*

(:define-key keymap

($ "${MOD} + Shift + /")

[:show-keymap keymap]

"Show current keymap"))

(:set-keymap key-man keymap)

keymap)

(defn build-slide-list []

(def slide-list @[])

(def env (curenv))

(def slide-defs

(filter (fn[[k v]]

(and (table? v)

(in v :slide)))

(pairs (table/proto-flatten env))))

(sort slide-defs

(fn [[k1 v1] [k2 v2]]

(< (in v1 :slide) (in v2 :slide))))

(def total-slides (length slide-defs))

(def first-keymap (build-slide-keymap))

(var cur-keymap first-keymap)

(for i 0 total-slides

(def cur-slide (in slide-defs i))

(def next-slide (if (>= i (- total-slides 1))

nil

(in slide-defs (+ i 1))))

(def [cur-slide-name

{:slide cur-slide-id

:value cur-slide-fn}]

cur-slide)

# For passing into the command closure below

(def cur-slide-keymap cur-keymap)

(:add-command command-man

(slide-name-to-cmd cur-slide-name)

(fn []

(cur-slide-fn cur-slide-id

total-slides

cur-slide-keymap)))

(enable-command (slide-name-to-cmd cur-slide-name))

(when next-slide

(def [next-slide-name _] next-slide)

(def next-slide-keymap (build-slide-keymap))

(:define-key cur-keymap

CONTINUE-KEY

(slide-name-to-cmd next-slide-name)

"Continue")

(set cur-keymap next-slide-keymap)))

(def [[first-slide-name & _] & _] slide-defs)

[(slide-name-to-cmd first-slide-name) first-keymap slide-defs])

(defn negative-window-filter [&]

false)

(defn show-command-filter [cmd args]

(def show?

(find |(= $ cmd)

[:enum-frame

:adjacent-frame

:retile

:move-window

:resize-frame

:frame-to-window-size

:split-frame

:enum-window-in-frame

:cascade-windows-in-frame]))

(when show?

(:show-tooltip

ui-man

:show-command

(if (and args (> (length args) 0))

(string/format "[%n %s]"

cmd

(string/join (map |(if (function? $)

"..."

(string/format "%n" $)) args)

" "))

(string/format "%n" cmd))

nil nil

5000

:top-left))

true)

(defn demo-command-filter [cmd args]

(def allowed?

(if-let [pred (in *allowed-commands* cmd)]

(if (function? pred)

(pred cmd args)

pred)

false))

(when allowed?

(match *next-slide-cmd*

nil

:noop

[next-cmd pred]

(when (pred cmd args)

(set *next-slide-cmd* nil)

# Put it in the event queue

(ev/spawn

(:call-command command-man next-cmd)))

next-cmd

(do

(set *next-slide-cmd* nil)

# Put it in the event queue

(ev/spawn

(:call-command command-man next-cmd)))))

(unless allowed?

(:show-tooltip ui-man :command-disabled "Command disabled ;)"))

allowed?)

(defn move-window-after-split [frame]

(def all-sub-frames (in frame :children))

(def all-wins (in (first all-sub-frames) :children))

(def move-to-frame (in all-sub-frames 1))

(when (>= (length all-wins) 2)

(:add-child move-to-frame (:get-current-window frame)))

(:activate move-to-frame))

(var *mod-key-selection-hook-fn* nil)

(defn mod-key-selection-hook-cleanup [next-cmd]

(:set-key-mode key-man :command)

(when *mod-key-selection-hook-fn*

(:remove-hook hook-man :key-pressed *mod-key-selection-hook-fn*))

(ev/spawn

(:call-command command-man next-cmd)))

(defn mod-key-selection-hook [key next-cmd]

(def key-code (in key :key))

(cond

(or (= key-code VK_LMENU)

(= key-code VK_RMENU))

(do

(set *mod-key* "Alt")

(set *dir-keys*

{:left "H"

:down "J"

:up "K"

:right "L"})

(mod-key-selection-hook-cleanup next-cmd))

(or (= key-code VK_LWIN)

(= key-code VK_RWIN))

(do

(set *mod-key* "Win")

(set *dir-keys*

{:left "Y"

:down "U"

:up "I"

:right "O"})

(mod-key-selection-hook-cleanup next-cmd))

true

(:show-tooltip ui-man :mod-key-selection "Please press either Win or Alt key." nil nil 1500 :center)))

(defn intro

{:slide 1}

[id total keymap]

(def [_next-key next-cmd] (disable-continue-key keymap))

(set-slide-keymap keymap)

# Pause window management

(:add-hook hook-man :filter-window negative-window-filter)

(set *mod-key-selection-hook-fn*

(:add-hook hook-man :key-pressed

(fn [key]

(mod-key-selection-hook key next-cmd))))

(:set-key-mode key-man :raw)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

false)

nil nil

0

:center))

(defn confirm-mod-key

{:slide 2}

[id total keymap]

(define-common-keys)

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($ "The primary modifier key is set to ${MOD}."))

nil nil

0

:center))

(defn before-cleanup-desktop

{:slide 3}

[id total keymap]

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn cleanup-desktop

{:slide 4}

[id total keymap]

(set-slide-keymap keymap)

# (:filter-hwnd window-man ...) would trap into the event loop,

# so it can't be called directly in the EnumChildWindows callback.

# Work around that by gathering all the HWNDs first.

(def hwnd-list @[])

(EnumChildWindows

nil

(fn [hwnd]

(array/push hwnd-list hwnd)

TRUE))

(each hwnd hwnd-list

(try

(do

(with-uia [uia-win (:get-hwnd-uia-element window-man hwnd)]

(with-uia [win-pat (:GetCurrentPatternAs uia-win

UIA_WindowPatternId

IUIAutomationWindowPattern)]

(when (and (= true (:filter-hwnd window-man hwnd uia-win))

(not= 0 (:get_CurrentCanMinimize win-pat)))

(:SetWindowVisualState win-pat WindowVisualState_Minimized)

(log/info "Minimized window %n" hwnd)))))

((err fib)

(log/info "Failed to minimize window %n: %n\n%s"

hwnd

err

(get-stack-trace fib)))))

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn spawn-windows

{:slide 5}

[id total keymap]

(set-slide-keymap keymap)

# Enable window management

(:remove-hook hook-man :filter-window negative-window-filter)

(for i 0 2

(:call-command command-man :exec true "notepad.exe"))

# ev/spawn so that the event loop has a chance to manage

# spawned windows before the cascade command is called.

(ev/spawn

(ev/sleep 1)

# Wait for the windows we spawned

(while (or (nil? (:get-current-frame (in window-man :root)))

(< (length (:get-all-windows (in window-man :root))) 2))

(ev/sleep 1))

(:call-command command-man :cascade-windows-in-frame)

(def w (:get-top-window (:get-current-frame (in window-man :root))))

(def w-rect (DwmGetWindowAttribute (in w :hwnd) DWMWA_EXTENDED_FRAME_BOUNDS))

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

(+ 100 (in w-rect :left)) (+ 100 (in w-rect :top))

0

:top-left)))

(defn tile-windows-in-top-frame

{:slide 6}

[id total keymap]

# We'll activate the next slide automatically, so disable the continue key

(def [next-key next-cmd] (disable-continue-key keymap))

(:define-key *acc-keymap*

($ "${MOD} + ,")

[:split-frame :horizontal 2 [0.5] move-window-after-split])

(set-slide-keymap keymap)

(:call-command command-man :retile)

(enable-command :split-frame (fn [_cmd [dir & _rest]] (= dir :horizontal)))

# Automatically call the next slide after :split-frame command

(arm-next-slide-trigger :split-frame next-cmd)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

Try Pressing ${MOD} + , (the comma key) on your keyboard ;)```)

false)

nil nil

0

:center))

(defn split-top-frame

{:slide 7}

[id total keymap]

(disable-command :split-frame)

(def [next-key next-cmd] (disable-continue-key keymap))

(:define-key *acc-keymap*

($ "${MOD} + .")

[:split-frame :vertical 2 [0.5] move-window-after-split])

(:set-keymap key-man keymap)

(enable-command :split-frame (fn [_cmd [dir & _rest]] (= dir :vertical)))

(arm-next-slide-trigger :split-frame next-cmd)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

Now try ${MOD} + . (the period key).```)

false)

nil nil

0

:center))

(defn about-vertical-split-and-empty-frames

{:slide 8}

[id total keymap]

(disable-command :split-frame)

(:set-keymap key-man keymap)

(def cur-frame (:get-current-frame (in window-man :root)))

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

;(calc-rect-center (in cur-frame :rect))

0

:center))

(defn spawn-window-into-empty-frame

{:slide 9}

[id total keymap]

(:set-keymap key-man keymap)

(:call-command command-man :exec true "explorer.exe")

# ev/spawn so that the event loop has a chance to manage

# the spawned window.

(ev/spawn

(def cur-frame (:get-current-frame (in window-man :root)))

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

;(calc-rect-center (in cur-frame :rect))

0

:center)))

(defn about-active-frames

{:slide 10}

[id total keymap]

(:set-keymap key-man keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn about-enumerating-frames

{:slide 11}

[id total keymap]

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn enumerating-frames

{:slide 12}

[id total keymap]

(enable-command :enum-frame)

(:define-key *acc-keymap*

($ "${MOD} + ${DOWN}")

[:enum-frame :next])

(:define-key *acc-keymap*

($ "${MOD} + ${UP}")

[:enum-frame :prev])

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

After activating a frame, you can restore your minimized windows, or open new windows, to see how Jwno takes them under management.```)

)

nil nil

0

:center))

(defn about-adjacent-frames

{:slide 13}

[id total keymap]

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn moving-to-adjacent-frames

{:slide 14}

[id total keymap]

(enable-command :show-keymap)

(enable-command :adjacent-frame)

(:define-key *acc-keymap*

($ "${MOD} + Ctrl + ${LEFT}")

[:adjacent-frame :left])

(:define-key *acc-keymap*

($ "${MOD} + Ctrl + ${DOWN}")

[:adjacent-frame :down])

(:define-key *acc-keymap*

($ "${MOD} + Ctrl + ${UP}")

[:adjacent-frame :up])

(:define-key *acc-keymap*

($ "${MOD} + Ctrl + ${RIGHT}")

[:adjacent-frame :right])

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

Now that we have a bunch of keys to remember, you can press ${MOD} + Shift + / (the slash key) to see a list of all defined keys. But some of those commands are now disabled to keep us oriented.```)

)

nil nil

0

:center))

(defn about-multi-monitor-support

{:slide 15}

[id total keymap]

(set-slide-keymap keymap)

(def layout (:get-layout (:get-current-frame (in window-man :root))))

(def text

(if (> (length (in layout :children)) 1)

# else

))

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

text)

nil nil

0

:center))

(defn about-enforcing-window-geometries

{:slide 16}

[id total keymap]

(:set-keymap key-man keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn about-retiling

{:slide 17}

[id total keymap]

(enable-command :retile)

(:define-key *acc-keymap*

($ "${MOD} + R")

:retile)

(:set-keymap key-man keymap)

(:call-command command-man :retile)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

We just called the :retile command. From now on, you can press ${MOD} + R if the window layout got messed up and you want to retile.```)

)

nil nil

0

:center))

(defn about-moving-windows

{:slide 18}

[id total keymap]

(enable-command :move-window)

(:define-key *acc-keymap*

($ "${MOD} + Shift + ${LEFT}")

[:move-window :left])

(:define-key *acc-keymap*

($ "${MOD} + Shift + ${DOWN}")

[:move-window :down])

(:define-key *acc-keymap*

($ "${MOD} + Shift + ${UP}")

[:move-window :up])

(:define-key *acc-keymap*

($ "${MOD} + Shift + ${RIGHT}")

[:move-window :right])

(:set-keymap key-man keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

These keys are now bound to window movement commands. They also work across monitors, like the frame selection commands.```)

)

nil nil

0

:center))

(defn about-overlapping-windows

{:slide 19}

[id total keymap]

(:set-keymap key-man keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

)

nil nil

0

:center))

(defn trying-out-enum-window-in-frame

{:slide 20}

[id total keymap]

(enable-command :enum-window-in-frame)

(:define-key *acc-keymap*

($ "${MOD} + ${RIGHT}")

[:enum-window-in-frame :next])

(:define-key *acc-keymap*

($ "${MOD} + ${LEFT}")

[:enum-window-in-frame :prev])

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

(This book analogy is the main reason these keys are arranged like this. You don't like it? No worries! Jwno is quite customizable, just define your own keys.)```)

)

nil nil

0

:center))

(defn about-cascading-windows-in-frame

{:slide 21}

[id total keymap]

(enable-command :cascade-windows-in-frame)

(:define-key *acc-keymap*

($ "${MOD} + P")

:cascade-windows-in-frame)

(set-slide-keymap keymap)

(:show-tooltip

ui-man

:tutorial

(format-slide-text

id total

($

To fit the windows to their frames again, press ${MOD} + R to :retile.```)

)

nil nil

0

:center))

(defn transient-keymaps-and-resizing-windows

{:slide 22}

[id total keymap]

(enable-command :resize-frame)

(def [next-key next-cmd] (disable-continue-key keymap))

# Special case: go to the next slide when the resize kemap is popped

(var resize-keymap-popped-hook nil)