359 lines
13 KiB
Scheme
Executable File
359 lines
13 KiB
Scheme
Executable File
#!/usr/bin/env -S csi -s
|
||
|
||
;; Copyright © 2024 Jaidyn Ann <jadedctrl@posteo.at>
|
||
;;
|
||
;; This program is free software: you can redistribute it and/or
|
||
;; modify it under the terms of the GNU General Public License as
|
||
;; published by the Free Software Foundation, either version 3 of
|
||
;; the License, or (at your option) any later version.
|
||
;;
|
||
;; This program is distributed in the hope that it will be useful,
|
||
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
;; GNU General Public License for more details.
|
||
;;
|
||
;; You should have received a copy of the GNU General Public License
|
||
;; along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
(import scheme
|
||
(chicken base)
|
||
(chicken condition)
|
||
(chicken file)
|
||
(chicken pathname)
|
||
(chicken process)
|
||
(chicken io)
|
||
(chicken repl)
|
||
(chicken process-context)
|
||
(chicken string)
|
||
(chicken time)
|
||
(srfi 1)
|
||
(srfi 4)
|
||
(srfi 13)
|
||
(srfi 18)
|
||
(prefix getopt-long getopt:)
|
||
(prefix nrepl nrepl:)
|
||
(prefix uri-common uri:)
|
||
(prefix vcarded vcard:)
|
||
qt-light)
|
||
|
||
|
||
(define *qt-app* #f) ;; The <qt-application> object.
|
||
(define *qt-win* #f) ;; The <qt-window> object.
|
||
(define *vcard-pathname* #f) ;; Path to current vCard file.
|
||
(define *vcard-alist* #f) ;; Parsed alist of current vCard file.
|
||
|
||
|
||
;; Start & run the application.
|
||
(define (init)
|
||
(let [(cli-args (parse-cli-args (command-line-arguments)))]
|
||
;; If --help, then print a usage message and quit.
|
||
(if (alist-ref 'help cli-args)
|
||
(cli-usage))
|
||
;; Otherwise, let’s get our threads started!
|
||
(let [(qt-thread (init-qt cli-args))
|
||
(nrepl-thread (init-nrepl cli-args))
|
||
(repl-thread (thread-start! repl))]
|
||
;; Wait for the QT program, even after stdin is closed off.
|
||
(thread-join! qt-thread))))
|
||
|
||
|
||
;; Set up some global variables (for easier live REPL use), prepare the QT app.
|
||
(define (init-qt cli-args)
|
||
(set! *qt-app* (qt:init))
|
||
(set! *qt-win* (create-window))
|
||
(qt:char-encoding 'utf8)
|
||
(init-window *qt-win*)
|
||
;; Kick off the QT thread, then open the cli free-arg vCard file, if provided.
|
||
;; That is, like `$ contact freeArgFile.vcf`.
|
||
(let [(qt-thread (thread-start! qt-loop))
|
||
(last-free-arg (condition-case (last (car cli-args)) (var () #f)))]
|
||
(when (string? last-free-arg)
|
||
(open-vcard-file *qt-win* last-free-arg))
|
||
qt-thread))
|
||
|
||
|
||
;; Kick off our remote TCP-accessible REPL, if the user enabled it at cli.
|
||
(define (init-nrepl cli-args)
|
||
(if (alist-ref 'repl cli-args)
|
||
(thread-start!
|
||
(lambda ()
|
||
(nrepl:nrepl (string->number (alist-ref 'repl cli-args)))))))
|
||
|
||
|
||
;; Print a “usage” help message, telling the user how to run the program.
|
||
(define (cli-usage)
|
||
(print "usage: " (pathname-file (program-name)) " [-h] [--repl PORT] [VCF_FILE]")
|
||
(print)
|
||
(print (pathname-file (program-name)) " is a simple contacts program for managing")
|
||
(print "vCard-format contacts.")
|
||
(print)
|
||
(print (getopt:usage cli-args-grammar))
|
||
(exit))
|
||
|
||
|
||
;; Parse out command-line args into an alist.
|
||
;; '("dad" "-h" "--repl=12" "mm") → '(("dad" "mm") (help #t) (repl 12))
|
||
(define (parse-cli-args args)
|
||
(handle-exceptions
|
||
exn
|
||
(and
|
||
(print ((condition-property-accessor 'exn 'message) exn))
|
||
'((help . #t)))
|
||
(getopt:getopt-long args cli-args-grammar)))
|
||
|
||
|
||
;; Definition of our command-line arguments, in getopt-long’s format.
|
||
(define cli-args-grammar
|
||
'((help "display this help message"
|
||
(single-char #\h))
|
||
(repl "start a TCP-accesible REPL at the given port"
|
||
(value #t))))
|
||
|
||
|
||
;; Loop through QT’s processing, again and again.
|
||
(define (qt-loop)
|
||
(qt:run #t)
|
||
(qt-loop))
|
||
|
||
|
||
;; Create the application window.
|
||
(define (create-window)
|
||
(qt:widget (window-contents)))
|
||
|
||
|
||
;; Return the UI’s XML, read from “contacts.ui”.
|
||
;; We could generate this XML ourselves, and write a nice s-expr front-end,
|
||
;; maybe… `o`
|
||
(define (window-contents)
|
||
(call-with-input-file
|
||
"contact.ui"
|
||
(lambda (in-port) (read-string #f in-port))))
|
||
|
||
|
||
;; Initialize the window.
|
||
(define (init-window window)
|
||
;; Set the profile-picture label to a default theme icon.
|
||
(let [(default-profile-pic
|
||
(or (qt:theme-icon "person") (qt:theme-icon "contact-new")))]
|
||
(if default-profile-pic
|
||
(set! (qt:property (qt:find window "avatarLabel") "pixmap")
|
||
(qt:icon->pixmap default-profile-pic 100 100))))
|
||
;; Set the window’s title.
|
||
(set-window-title! window "New contact")
|
||
;; Now prepare callbacks and show the window.
|
||
(window-callbacks window)
|
||
(qt:show window))
|
||
|
||
|
||
;; Connect callback functions to widgets’ signals.
|
||
(define (window-callbacks window)
|
||
(menubar-callbacks window))
|
||
|
||
|
||
;; Connect callback functions to menubar items.
|
||
(define (menubar-callbacks window)
|
||
(let* [(menu-file-exit (qt:find window "actionQuit"))
|
||
(menu-file-save (qt:find window "actionSave"))
|
||
(menu-file-open (qt:find window "actionOpen"))
|
||
(menu-file-new (qt:find window "actionNew"))]
|
||
;; We connect to https://doc.qt.io/qt-6/qaction.html#triggered
|
||
;; Simply kill the program.
|
||
(if menu-file-exit
|
||
(qt:connect
|
||
menu-file-exit "triggered()"
|
||
(qt:receiver exit)))
|
||
;; If they try to Save, tell them it’s not supported.
|
||
(if menu-file-save
|
||
(qt:connect
|
||
menu-file-save "triggered()"
|
||
(qt:receiver
|
||
(lambda ()
|
||
(save-vcard-file window)))))
|
||
;; If they want a new contact, create a new, blank, window.
|
||
;; That is, a new process.
|
||
(if menu-file-new
|
||
(qt:connect
|
||
menu-file-new "triggered()"
|
||
(qt:receiver create-new-window)))
|
||
;; If they want to open a contact through the Open… dialogue, we should open
|
||
;; the contact in a new window.
|
||
(if menu-file-open
|
||
(qt:connect
|
||
menu-file-open "triggered()"
|
||
(qt:receiver
|
||
(lambda ()
|
||
(let* [(contacts-dir (conc (get-environment-variable "HOME")
|
||
"/Contacts"))
|
||
(selected-file (qt:get-open-filename
|
||
"Select a contact file to open…"
|
||
contacts-dir))]
|
||
(if (not (string-null? selected-file))
|
||
(if *vcard-pathname*
|
||
(create-new-window selected-file)
|
||
(open-vcard-file window selected-file))))))))))
|
||
|
||
|
||
;; Executes a new instance of the program; optionally, with a contact-file’s
|
||
;; pathname as a new argument.
|
||
;; Functionally, opens a new contacts window.
|
||
(define (create-new-window . pathname)
|
||
(let* [(pathname (optional pathname #f))
|
||
(clean-cli-args
|
||
(drop-right (cdr (argv))
|
||
(length (command-line-arguments))))
|
||
(program-args
|
||
(if pathname
|
||
(append clean-cli-args (list pathname))
|
||
clean-cli-args))]
|
||
(process-run
|
||
(executable-pathname)
|
||
program-args)))
|
||
|
||
|
||
;; Parse a vCard file and populate the window’s forms with its contents.
|
||
(define (open-vcard-file window file)
|
||
(set! *vcard-pathname* file)
|
||
(set-window-title! window (pathname-file file))
|
||
(thread-start!
|
||
(lambda ()
|
||
(condition-case
|
||
;; Parse the vCard, then populate the window’s fields.
|
||
(begin
|
||
(set! *vcard-alist*
|
||
(with-input-from-file file vcard:read-vcard))
|
||
(populate-window-with-vcard window *vcard-alist*))
|
||
;; … if that didn’t work out, complain to the user!
|
||
[(vcard)
|
||
(set! *vcard-pathname* #f)
|
||
(set! *vcard-alist* #f)
|
||
(set-window-title! window "New contact")
|
||
(qt:message
|
||
(string-join (list "This file doesn’t seem to be a valid vCard file."
|
||
"Please make sure you selected the right file, and take a look at it manually."))
|
||
title: "Parsing error" type: 'critical)]
|
||
;; … complain harder, harder!!
|
||
[exn (file)
|
||
(set! *vcard-pathname* #f)
|
||
(set! *vcard-alist* #f)
|
||
(set-window-title! window "New contact")
|
||
(qt:message
|
||
(string-join (list "Failed to open the file."
|
||
((condition-property-accessor 'exn 'message) exn)))
|
||
title: "File error" type: 'critical)]))))
|
||
|
||
|
||
;; Save the window contents to the currently-selected file-path in vCard format.
|
||
(define (save-vcard-file window)
|
||
(thread-start!
|
||
(lambda ()
|
||
(condition-case
|
||
(begin
|
||
(set! *vcard-alist* (populate-vcard-with-window window *vcard-alist*))
|
||
(call-with-output-file *vcard-pathname*
|
||
(lambda (in-port)
|
||
(vcard:write-vcard *vcard-alist*
|
||
in-port))))
|
||
[exn ()
|
||
(qt:message
|
||
(string-join (list "Failed to save the file:"
|
||
((condition-property-accessor 'exn 'message) exn)
|
||
"Try saving to a another location with “File→Save as…”.")
|
||
"\n")
|
||
title: "Saving error")]))))
|
||
|
||
|
||
;; Simply map vCard property-names to their corresponding name in the window’s
|
||
;; fields.
|
||
(define property->formname-alist
|
||
'((FN . "nameLineEdit")
|
||
;; (ADR . "address")
|
||
(TEL . "homePhoneLineEdit")
|
||
(TEL . "workPhoneLineEdit")
|
||
(EMAIL . "eMailLineEdit")
|
||
(URL . "urlLineEdit")
|
||
(NICKNAME . "nicknameLineEdit")))
|
||
|
||
|
||
;; … and likewise, map window fields’ names to vCard properties.
|
||
(define formname-alist->property
|
||
(map (lambda (a) (cons (cdr a) (car a)))
|
||
property->formname-alist))
|
||
|
||
|
||
;; Given a parsed vCard in vcarded’s alist format, populate the window’s fields.
|
||
;; Here’s the format:
|
||
;; ((PROPERTY (ATTRIBUTES) VALUE)
|
||
;; (FN () "A. Dmytryshyn")
|
||
;; (ADR ("TYPE=home") ("" "" "1234 Abc.", "", "", "", "")))
|
||
(define (populate-window-with-vcard window vcard-alist)
|
||
(map (lambda (property)
|
||
(let* [(formname (alist-ref (car property) property->formname-alist))
|
||
(lineEditWidget (if formname (qt:find window formname) #f))]
|
||
(cond
|
||
[lineEditWidget
|
||
(set! (qt:property lineEditWidget "text")
|
||
(cond
|
||
[(string? (last property))
|
||
(last property)]
|
||
[(uri:uri? (last property))
|
||
(uri:uri->string (last property))]
|
||
[#t ""]))]
|
||
[(and (eq? (car property) 'PHOTO)
|
||
(list? (last property)))
|
||
(let* [(avatar (qt:find window "avatarLabel"))
|
||
(old-pixmap
|
||
(if avatar (qt:property avatar "pixmap")))
|
||
[new-pixmap
|
||
(if avatar (u8vector->pixmap (cadr (last property))))]]
|
||
(when avatar
|
||
(set! (qt:property avatar "pixmap") new-pixmap)))])))
|
||
vcard-alist)
|
||
(when (alist-ref 'FN vcard-alist)
|
||
(set-window-title! window (last (alist-ref 'FN vcard-alist)))))
|
||
|
||
|
||
;; Given a Contacts QT window, take its vCard lineEdit widgets and populate a
|
||
;; vcarded-style alist with their values.
|
||
;; Returns a vCard according the window’s textbox values.
|
||
(define (populate-vcard-with-window window vcard-alist)
|
||
(for-each
|
||
(lambda (lineEditName)
|
||
(let* [(widget (if lineEditName (qt:find window lineEditName) #f))
|
||
(widget-value (if widget (qt:property widget "text") #f))
|
||
(property-sym (alist-ref lineEditName formname-alist->property equal?))
|
||
(property-value (alist-ref property-sym vcard-alist))]
|
||
(when (and widget (not (string-null? widget-value)))
|
||
(set! vcard-alist
|
||
(alist-update property-sym
|
||
(list (if (list? property-value) (car property-value) '())
|
||
(qt:property widget "text"))
|
||
vcard-alist)))))
|
||
(map car formname-alist->property))
|
||
vcard-alist)
|
||
|
||
|
||
;; Set a QT window’s title, suffixing with the program name (Contact).
|
||
(define (set-window-title! window title)
|
||
(set! (qt:property window "windowTitle")
|
||
(string-concatenate (list title " - Contact"))))
|
||
|
||
|
||
;; Given a image bytevector (u8vector), create a corresponding pixmap.
|
||
(define (u8vector->pixmap vector)
|
||
(let* ([temp-file (write-temporary-file vector)]
|
||
[pixmap (qt:pixmap temp-file)])
|
||
(delete-file* temp-file)
|
||
pixmap))
|
||
|
||
|
||
;; Given a u8vector for file-contents, create a tempory file and write the
|
||
;; contents to it. Returns the pathname.
|
||
(define (write-temporary-file u8vector-contents)
|
||
(let [(temp-file (create-temporary-file))]
|
||
(with-output-to-file temp-file
|
||
(lambda () (map write-byte (u8vector->list u8vector-contents))))
|
||
temp-file))
|
||
|
||
|
||
(init)
|