lisp/selection.scm @@ -119,6 +119,17 @@ (define (buffer-erase buf) (gb-erase! (buffer-text buf))) + +(define (buffer-end buf) + (gb-point-max (buffer-text buf))) + +(define (buffer-start buf) + (gb-point-min (buffer-text buf))) + +(define (buffer-range-to-string buf from length) + (gb->substring (buffer-text buf) + from + length)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Buffer Variables @@ -143,6 +154,13 @@ (assoc-ref (buffer-variables buffer) name)) +;; Get buffer variable, creating it if it doesn't exist + +(define (ensure-buffer-variable buffer name) + (assoc-ref (buffer-variables buffer) + name)) + + ;; Remove buffer variable (define (kill-buffer-variable! buffer name) @@ -162,6 +180,13 @@ ;; since it was last cached. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; So code located in the current buffer can get buffer variables, for example. + +(define %current-buffer nil) + +(define (current-buffer) + %current-buffer) + ;; Redraw the buffer (just run the cache if no timestamp variation) (define (draw-buffer cb) @@ -173,9 +198,11 @@ ;; Otherwise, generate the cache and update the cache timestamp (let ((c (buffer-cache cb))) (cache-record-begin c) + (set! %current-buffer cb) (eval-string (buffer-to-string cb)) - (cache-record-end c) - (update-timestamp! (buffer-cache cb))))) + (set! %current-buffer #f) + (cache-record-end c) + (update-timestamp! (buffer-cache cb))))) ;; Flag the buffer to be drawn when the window next redraws lisp/buffer.scm @@ -47,3 +47,14 @@ (keymap-add-fun %global-keymap reload-dot-minara-file "d" "d") + + + +;; Edit minara file + +(define (external-edit-current-window) + (external-edit-file "~/.minara")) + +;; Register keys for editing a window + +(keymap-add-fun %global-keymap external-edit-current-window "x" "d") lisp/development.scm @@ -36,11 +36,11 @@ (define event-stack #f) (define (call-with-backtrace call-me) - (call-me)) - ;; (set! event-stack (make-stack #t)) - ;;(catch #t - ;;call-me - ;;event-error-handler)) +;; (call-me)) + (set! event-stack (make-stack #t)) + (catch #t + call-me + event-error-handler)) (define (event-error-handler . args) (if (= (length args) 5) lisp/events.scm @@ -75,6 +75,8 @@ "picking" "tool" "undo" + "selection" + "cut-and-paste" "minibuffer" "development")) @@ -120,11 +122,11 @@ (bind-event-hooks)) (define $minara-lisp-dir - (if (string=? (utsname:machine (uname)) - "Power Macintosh") - "../Resources/lisp/" - "../lisp/")) - + ;; (if (string=? (utsname:machine (uname)) + ;; "Power Macintosh") + ;;"../Resources/lisp/" + "../lisp/") +;;) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Our main startup routine lisp/minara-bootstrap.scm @@ -151,7 +151,7 @@ ;; Will need fixing for multi-window operation ;; How should window & global event handlers interact? -;; Tools must ensure their buffers on mouse-down rather than create on install!! +;; Tools must ensure their buffers on mouse-down rather than create on install? (define previous-key-handlers #f) lisp/minibuffer.scm @@ -22,6 +22,8 @@ ;; It should be renamed "scribble" and replaced with a real pen tool. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(define $path-end "(path-end)\n") +(define $path-end-length (string-length $path-end)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Keep track of the mouse button state @@ -32,21 +34,21 @@ ;; When the button is pressed, make and initialise the pen drawing buffers (define (begin-drawing window x y) - (let ((pen-buffer (buffer-text (make-window-buffer window - "pen"))) - (close-buffer (buffer-text (make-window-buffer window - "pen-close")))) - (gb-goto-char pen-buffer (gb-point-max pen-buffer)) - (write-current-colour (window-buffer window - "pen")) - (gb-insert-string! pen-buffer - (format #f - "(path-begin)~%(move-to ~a ~a)~%" - (window-view-x window x) - (window-view-y window y))) - (gb-insert-string! close-buffer "(path-end)\n") - (window-undo-stack-push window - pen-buffer))) + (let ((pen-buffer (make-window-buffer window + "pen"))) + (window-undo-stack-push window + pen-buffer) + (write-current-colour pen-buffer) + (buffer-insert-undoable pen-buffer + #f + (format #f + "(path-begin)~%(move-to ~a ~a)~%" + (window-view-x window x) + (window-view-y window y))) + (buffer-insert-undoable pen-buffer + #f + $path-end) + (buffer-undo-mark pen-buffer))) (define (pen-mouse-down win button x y) (begin-drawing win x y) @@ -57,19 +59,23 @@ (define (draw-point window x y) (let ((pen-buffer (window-buffer window - "pen")) - ;;(pen-text (buffer-text pen-buffer)) - (pen-close-buffer (window-buffer window - "pen-close"))) + "pen"))) + ;; Remove the previous path-end + (buffer-delete-undoable pen-buffer + (- (buffer-end pen-buffer) + $path-end-length) + $path-end-length) (buffer-insert-undoable pen-buffer #f (format #f "(line-to ~a ~a)~%" (window-view-x window x) (window-view-y window y))) + (buffer-insert-undoable pen-buffer + #f + $path-end) (buffer-undo-mark pen-buffer) - (buffer-invalidate pen-buffer) - (buffer-invalidate pen-close-buffer) + (buffer-invalidate pen-buffer) (window-redraw window))) (define (pen-mouse-move win x y) @@ -82,22 +88,15 @@ (define (end-drawing window) (let ((buff (window-buffer window "pen")) - (close-buffer (window-buffer window - "pen-close")) (main-buff (window-buffer-main window))) (buffer-insert-undoable main-buff #f (buffer-to-string buff)) - (buffer-insert-undoable main-buff - #f - (buffer-to-string close-buffer)) (buffer-undo-mark main-buff) (window-undo-stack-pop window) ;; Clean up and redraw (remove-window-buffer window "pen") - (remove-window-buffer window - "pen-close") (buffer-invalidate (window-buffer-main window)) (window-redraw window))) lisp/pen-tool.scm @@ -23,8 +23,8 @@ ;; How does this work? ;; ;; Precis: -;; Count the shapes, hit-test the shapes, store the counts that hit, -;; find the s-expressions that contain those counts. +;; Count the shapes, hit-test the shapes, store the buffer positions that hit, +;; find the s-expressions that contain those buffer positions. ;; ;; Details: ;; We install a rendering protocol that counts the number of @@ -51,11 +51,11 @@ ;; ;; Area-based selection will also be required and can be implemented similarly. ;; A point and a rectangle (or other shape eg pen-drawing based selection) are -;; just gemoetries to check for intersection or containment after all. +;; just geometries to check for intersection or containment after all. ;; -;; This is all very single threaded. +;; This is all very single threaded. Attach the vars to the buffer being picked. ;; -;; And inefficient, having no optimization for bounding boxes for example +;; And it's inefficient, having no optimization for bounding boxes for example ;; It is possible to generate, cache and update bounding boxes and other ;; optimizations (hashed to object counts) when editing the text, but this will ;; be done once the basic functionality is implemented. @@ -86,9 +86,17 @@ (define previous-x #f) (define previous-y #f) +;; Keep track of the matrix so we can translate the points & co-ords to check + ;; Keep track of which colour we're currently using (define current-colour #f) +;; Keep track of the current transformations +(define current-translate #f) +(define current-rotate #f) +(define current-scale #f) +;; Need to do push-matrix, pop-matrix, etc. + ;; Keep track of which polygon we're currently drawing (define current-polygon #f) @@ -101,6 +109,8 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Picking "render" protocol +;; Hang on, I thought we were meant to evaluate in a different environment, +;; not rebind? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (define (install-picking-rendering-protocol) @@ -110,7 +120,15 @@ (set! path-end picking-path-end) (set! move-to picking-move-to) (set! line-to picking-line-to) - (set! curve-to picking-curve-to)) + (set! curve-to picking-curve-to) + (set! push-matrix picking-push-matrix) + (set! pop-matrix picking-pop-matrix) + (set! concatenate-matrix picking-concatenate-matrix) + (set! set-matrix picking-set-matrix) + (set! identity-matrix picking-identity-matrix) + (set! translate picking-translate) + (set! rotate picking-rotate) + (set! scale picking-scale)) ;; Reset the picking state (define (reset-picking-rendering-protocol) @@ -121,20 +139,51 @@ (set! current-colour 0) (set! current-polygon 0) (set! intersections 0) + (set! current-translate 0) + (set! current-rotate 0) + (set! current-scale 0) (set! picked-polygons '())) ;; Keep track of the colour -(define (picking-set-colour r g b) +(define (picking-set-colour r g b a) (set! current-colour (+ current-colour 1))) +;; Keep track of the transforms +;; TODO: do it. + +(define (picking-push-matrix) + #f) + +(define (picking-pop-matrix) + #f) + +(define (picking-concatenate-matrix a b c d e f) + #f) + +(define (picking-set-matrix a b c d e f) + #f) + +(define (picking-identity-matrix) + #f) + +(define (picking-translate x y) + (set! current-translate (+ current-translate 1))) + +(define (picking-scale x y) + (set! current-scale (+ current-scale 1))) + +(define (picking-rotate theta) + (set! current-rotate (+ current-rotate 1))) + ;; Start a new pick pass (define (picking-path-begin) - (set! intersections 0)) + (set! intersections 0) + (set! current-polygon (+ current-polygon 1))) ;; Check the intersections. Even = inside, Odd = oustide ;; Store the colour and anything else in a list with the polygon number? (define (picking-path-end) - (if (and (odd intersections) + (if (and (odd? intersections) (not (= intersections 0))) (set! picked-polygons @@ -147,18 +196,17 @@ (set! previous-x x) (set! previous-y y)) -;; Where to send the ray -uh- line to. Oh, the horror. Fixme! +;; Where to send the ray -uh- line to. Oh, the horror! Fixme. (define %ray-x 65535.0) ;; Line segment hit test (define (picking-line-to x y) - (if - (lines-intersect-vertices - previous-x previous-y x y pick-x pick-y %ray-x pick-y) - (set! intersections (+ intersections - 1))) + (if (lines-intersect-vertices previous-x previous-y x y pick-x pick-y + %ray-x pick-y) + (set! intersections (+ intersections + 1))) (set! previous-x x) (set! previous-y y)) @@ -189,8 +237,7 @@ (if (or (= target count) ;; Catch the error condition (not position)) - ;; Move back one so substring gets (... - (- position 1) + position ;; Otherwise search forward (nth-occurrence-aux buffer phrase target (+ count 1) ;; +1 so we don't re-match the same string @@ -230,8 +277,8 @@ ;; Get the nth path in the buffer (define (get-nth-path buffer nth) (let ((buffer-string (gb->string buffer))) - (list (nth-occurrence buffer-string "(path-begin)" nth) - ;; 10 to add length of "path-end" + (cons (nth-occurrence buffer-string "(path-begin)" nth) + ;; 10 to move past "path-end" (+ (nth-occurrence buffer-string "(path-end)" nth) 10)))) ;; Get the colour before the nth (path-end) @@ -249,6 +296,35 @@ ;; Or find the bounds (sexp-bounds buffer colour-start)))) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Picking in the main window buffer. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(define (set-picking-point x y) + ;; Translate? + (set! pick-x x) + (set! pick-y y)) + +(define (pick-paths buf x y) + (install-picking-rendering-protocol) + (set-picking-point x y) ;; Translate? + (eval-string (buffer-to-string buf)) + (if (eq? picked-polygons '()) + #f + picked-polygons)) + +(define (pick-paths-window win x y) + (pick-paths (window-buffer-main win) x y)) + +(define (pick-path buf x y) + (let ((picks (pick-paths buf x y))) + (if picks + ;; Return the range + (get-nth-path (buffer-text buf) (last picks)) + #f))) + +(define (pick-path-window win x y) + (pick-path (window-buffer-main win) x y)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; tests lisp/picking.scm @@ -31,8 +31,6 @@ ;; so it makes sense to allow them to be called from code. ;; Graphics toolkits without them can simulate them. -(define write-header #f) -(define write-footer #f) (define set-colour #f) (define path-begin #f) (define path-end #f) lisp/rendering.scm @@ -71,6 +71,7 @@ (bottom (- circle-tool-mouse-down-y radius))) (buffer-erase circle-buffer) + (write-current-colour circle-buffer) (buffer-insert-undoable circle-buffer #f "(path-begin)\n") lisp/shape-tools.scm @@ -1,3 +1,4 @@ + ;; view-tools.scm : tools for viewing windows for minara ;; ;; Copyright (c) 2004 Rob Myers, rob@robmyers.org lisp/view-tools.scm @@ -190,6 +190,11 @@ (add-window-buffer window buffer-name buf) buf)) +(define (ensure-window-buffer window buffer-name) + (let ((maybe-buffer (window-buffer window buffer-name))) + (or maybe-buffer + (make-window-buffer window buffer-name)))) + ;; Remove window buffer (define (remove-window-buffer window name) @@ -213,7 +218,7 @@ path-timestamp) (begin (buffer-file-reload main) - (window-redraw (window-id window)))))) + (window-redraw window))))) ;;(window-status-temporary window ;; "Buffer changed, not reloaded!" ;; 2)))) @@ -347,14 +352,17 @@ (define $external-edit-command %$default-external-edit-command) -(define (external-edit-window window) - ;; TODO: Warn user if unsaved!!!!! - (save-window window) +(define (external-edit-file path) (system (string-append $external-edit-command " " - (window-buffer-path window) + path " &"))) +(define (external-edit-window window) + ;; TODO: Warn user if unsaved!!!!! + (save-window window) + (external-edit-file (window-buffer-path window))) + ;; Edit the current frontmost window (define (external-edit-current-window) lisp/window.scm @@ -160,7 +160,7 @@ PBXFileDataSource_Warnings_ColumnID, ); }; - PBXPerProjectTemplateStateSaveDate = 153907038; + PBXPerProjectTemplateStateSaveDate = 154040534; PBXPrepackagedSmartGroups_v2 = ( { PBXTransientLocationAtTop = bottom; @@ -580,16 +580,7 @@ Frame = "{{0, 0}, {745, 366}}"; RubberWindowFrame = "255 124 745 408 0 0 1024 746 "; }; - PBXWorkspaceStateSaveDate = 153907038; - }; - perUserProjectItems = { - 8F3C8D2F092C6F7B00B6DE85 = 8F3C8D2F092C6F7B00B6DE85; - 8F3C8D30092C702100B6DE85 = 8F3C8D30092C702100B6DE85; - 8F3C8D35092C706100B6DE85 = 8F3C8D35092C706100B6DE85; - 8F3C8D3C092C70CB00B6DE85 = 8F3C8D3C092C70CB00B6DE85; - 8F3C8D3F092C70CB00B6DE85 = 8F3C8D3F092C70CB00B6DE85; - 8F3C8D42092C70CB00B6DE85 = 8F3C8D42092C70CB00B6DE85; - 8F3C8D4C092C719F00B6DE85 = 8F3C8D4C092C719F00B6DE85; + PBXWorkspaceStateSaveDate = 154040534; }; sourceControlManager = 8F7B9C1C05A717AE0097257C; userBuildSettings = { @@ -609,71 +600,27 @@ sepNavWindowFrame = "{{130, 78}, {750, 558}}"; }; }; - 8F3C8D2F092C6F7B00B6DE85 = { - fRef = 8F70A416092BCB2A00EEDD40; - isa = PBXBookmark; - }; - 8F3C8D30092C702100B6DE85 = { - fRef = 8F55AE6B0901911500028490; - isa = PBXBookmark; - }; - 8F3C8D35092C706100B6DE85 = { - fRef = 8FB597B105A8C5CB00E06CEA; - isa = PBXBookmark; - }; - 8F3C8D3C092C70CB00B6DE85 = { - fRef = 8FB597B105A8C5CB00E06CEA; - isa = PBXTextBookmark; - name = "minara_rendering.c: 395"; - rLen = 0; - rLoc = 12025; - rType = 0; - vrLen = 1568; - vrLoc = 10912; - }; - 8F3C8D3F092C70CB00B6DE85 = { - fRef = 8F55AE6B0901911500028490; - isa = PBXTextBookmark; - name = "view-tools.scm: 1"; - rLen = 0; - rLoc = 0; - rType = 0; - vrLen = 1339; - vrLoc = 10674; - }; - 8F3C8D42092C70CB00B6DE85 = { - fRef = 8F70A416092BCB2A00EEDD40; - isa = PBXTextBookmark; - name = "colour-tools.scm: 102"; - rLen = 0; - rLoc = 2687; - rType = 0; - vrLen = 1269; - vrLoc = 2138; - }; - 8F3C8D4C092C719F00B6DE85 = { - fRef = 8F55AE6B0901911500028490; - isa = PBXTextBookmark; - name = "view-tools.scm: 1"; - rLen = 0; - rLoc = 0; - rType = 0; - vrLen = 1339; - vrLoc = 10674; + 8F5284160922B9FB008384AA = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {901, 9212}}"; + sepNavSelRange = "{2530, 0}"; + sepNavVisRect = "{{0, 839}, {901, 437}}"; + sepNavWindowFrame = "{{223, 180}, {940, 566}}"; + }; }; 8F55AE540901911500028490 = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {740, 2450}}"; - sepNavSelRange = "{992, 0}"; - sepNavVisRect = "{{0, 253}, {740, 180}}"; - sepNavWindowFrame = "{{272, -15}, {776, 737}}"; + sepNavIntBoundsRect = "{{0, 0}, {737, 2674}}"; + sepNavSelRange = "{5524, 0}"; + sepNavVisRect = "{{0, 2013}, {737, 608}}"; + sepNavWindowFrame = "{{49, 9}, {776, 737}}"; }; }; 8F55AE560901911500028490 = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {737, 4732}}"; - sepNavSelRange = "{1668, 0}"; - sepNavVisRect = "{{0, 397}, {737, 608}}"; + sepNavIntBoundsRect = "{{0, 0}, {737, 4746}}"; + sepNavSelRange = "{1715, 0}"; + sepNavVisRect = "{{0, 331}, {737, 608}}"; sepNavWindowFrame = "{{93, 9}, {776, 737}}"; }; }; @@ -701,6 +648,14 @@ sepNavWindowFrame = "{{15, 4}, {776, 737}}"; }; }; + 8F55AE610901911500028490 = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {901, 2856}}"; + sepNavSelRange = "{1939, 0}"; + sepNavVisRect = "{{0, 447}, {901, 437}}"; + sepNavWindowFrame = "{{61, 133}, {940, 566}}"; + }; + }; 8F55AE630901911500028490 = { uiCtxt = { sepNavIntBoundsRect = "{{0, 0}, {737, 1008}}"; @@ -719,8 +674,8 @@ 8F55AE6A0901911500028490 = { uiCtxt = { sepNavIntBoundsRect = "{{0, 0}, {737, 3878}}"; - sepNavSelRange = "{8228, 0}"; - sepNavVisRect = "{{0, 3270}, {737, 608}}"; + sepNavSelRange = "{7769, 0}"; + sepNavVisRect = "{{0, 3048}, {737, 608}}"; sepNavWindowFrame = "{{178, 9}, {776, 737}}"; }; }; @@ -729,15 +684,15 @@ sepNavIntBoundsRect = "{{0, 0}, {737, 6678}}"; sepNavSelRange = "{0, 0}"; sepNavVisRect = "{{0, 6070}, {737, 608}}"; - sepNavWindowFrame = "{{15, 4}, {776, 737}}"; + sepNavWindowFrame = "{{308, -35}, {776, 737}}"; }; }; 8F55AE6C0901911500028490 = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {737, 5446}}"; - sepNavSelRange = "{6569, 10}"; - sepNavVisRect = "{{0, 2965}, {737, 608}}"; - sepNavWindowFrame = "{{177, 9}, {776, 737}}"; + sepNavIntBoundsRect = "{{0, 0}, {737, 5488}}"; + sepNavSelRange = "{1503, 0}"; + sepNavVisRect = "{{0, 346}, {737, 445}}"; + sepNavWindowFrame = "{{17, 4}, {776, 574}}"; }; }; 8F55AE6D0901911500028490 = { @@ -908,10 +863,10 @@ }; 8FB597B505A8C5CB00E06CEA = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {896, 2212}}"; - sepNavSelRange = "{4107, 0}"; - sepNavVisRect = "{{0, 0}, {711, 429}}"; - sepNavWindowFrame = "{{84, 188}, {750, 558}}"; + sepNavIntBoundsRect = "{{0, 0}, {920, 2226}}"; + sepNavSelRange = "{2875, 0}"; + sepNavVisRect = "{{0, 1789}, {901, 437}}"; + sepNavWindowFrame = "{{84, 180}, {940, 566}}"; }; }; 8FB597B605A8C5CB00E06CEA = { macosx/minara.xcode/robmyers.pbxuser @@ -33,7 +33,6 @@ (set-colour 0.0 0.828 0.387 1.0) (push-matrix) -(translate 145 125) ;; Centre on a 600 x 400 window (path-begin) (move-to 130.9441 79.3721) (curve-to 125.2566 77.5049 131.3196 69.6743 125.5374 63.8911) @@ -151,4 +150,4 @@ (curve-to 106.6765 84.874 110.8728 89.0703 116.0027 89.0703) (line-to 116.0027 70.4224) (path-end) -(pop-matrix) \ No newline at end of file +(pop-matrix) minara.minara @@ -53,6 +53,7 @@ char *guile_do_nothinevent_handlers = \ (define %mouse-up-hook (lambda (win button x y) (write-line \"mouse-up-hook\" (current-error-port)) (force-output (current-error-port)))) \ (define %mouse-move-hook (lambda (win x y) (write-line \"mouse-move-hook\" (current-error-port)) (force-output (current-error-port)))) \ (define %key-press-hook (lambda (win key modifiers) (write-line \"key-press-hook\" (current-error-port)) (force-output (current-error-port)))) \ + (define %key-release-hook (lambda (win key modifiers) (write-line \"key-release-hook\" (current-error-port)) (force-output (current-error-port)))) \ (define %menu-select-hook (lambda (win menu-id) (write-line \"menu-select-hook\" (current-error-port)) (force-output (current-error-port))))"; src/minara_guile.c @@ -61,7 +61,7 @@ ---------------------------------------------------------------------------*/ static const char *bootstrap_file = -#ifdef __APPLE__ +#if 0 //def __APPLE__ "../Resources/lisp/minara-bootstrap.scm"; #else "../lisp/minara-bootstrap.scm"; src/minara_main.c bdc2259fb16c3af548504d3a3cb46b0df647ec6e Rob Myers rob@robmyers.org http://github.com/robmyers/minara-scheme/commit/3f7791e39de0fdbd441b2ba95300751a82958de5 3f7791e39de0fdbd441b2ba95300751a82958de5 2006-05-30T11:53:33-07:00 2006-05-30T11:53:33-07:00 Selection tool in progress. 5a1e689abd0a20b1c65b6b3ac4d25163a62add5a Rob Myers rob@robmyers.org