Re: Screenshots, frame shots straight from Emacs

[Hongyi Zhao]

On Fri, Jul 23, 2021 at 1:55 PM Jean Louis <bugs@gnu.support> wrote:
>
> * Hongyi Zhao <hongyi.zhao@gmail.com> [2021-07-23 03:53]:
> > 1. Have the delay feature, so that I can do some operations before the
> > screenshot is captured, say, click on mouse button, open a dropdown
> > menu, and so on.
>
> This improved function will allow that you invoke for example:
>
> C-5 M-x frameshot to delay for 5 seconds.

Good idea.

> But this Emacs function I think will not allow to get the screenshot of the 
> dropdown, maybe it
> requires using threads, now I don't know how to do it within Emacs.

Anyway, thank you very much for your help.

> (defun frameshot (&optional prefix)
>   "Save Emacs frame as frame shot.
>
> Directory is determined by variable `frameshot-directory' and if
> not defined, it will be saved in the `$HOME' directory."
>   (interactive "p")
>   (let ((delay (or prefix 0)))
>     (run-with-timer
>      delay nil
>      (lambda ()
>        (let* ((image (x-export-frames nil (or frameshot-format 'png)))
>               (base-directory (or frameshot-directory (getenv "HOME")))
>               (directory (concat (file-name-as-directory base-directory) 
> (format-time-string "%Y/%m/%Y-%m-%d/")))
>               (file (concat directory (format-time-string 
> "Screenshot-%Y-%m-%d-%T.") (symbol-name frameshot-format))))
>          (make-directory directory t)
>          (with-temp-file file
>            (insert image))
>          (find-file directory)
>          (message "Frame shot saved as `%s'" file))))))
>
> To capture all screen I am using this external Common Lisp script,
> that invokes maim:
>
> #!/usr/bin/clisp
>
> (load 
> "/home/data1/protected/Programming/git/RCDBusiness/lib/lisp/date-time.lisp")
>
> (defparameter *image-capture-program* "maim")
> (defparameter *image-type* ".png")
> (defparameter *image-directory* 
> "/home/data1/protected/Media/Pictures/Screenshots")
>
> (let* ((filename (concatenate 'string (timestamp-filename) *image-type*))
>        (year (substring filename 0 4))
>        (month (substring filename 5 7))
>        (date (substring filename 0 10))
>        (directory (concatenate 'string *image-directory* "/" year "/" month 
> "/" date "/"))
>        (command (concatenate 'string *image-capture-program* " \"" directory 
> filename "\""))
>        (rox-command (concatenate 'string "rox " directory)))
>   (print directory)
>   (print command)
>   (ensure-directories-exist directory)
>   (shell command)
>   (shell rox-command))
>
> You could install either `maim' or other system screenshot program and
> use that one.

Thank you for recommending `maim' to me. From its official description
[1], it can be seen as an improved scrot, which is the one used by me
now.

[1] https://github.com/naelstrof/maim

> > 2. Have the post-processing feature, which can be used for some
> > touch I am not sure whether the recommended method here has these
> > characteristics.
>
> I am often using few simple functions for processing that invoke
> ImageMagick:
>
> (defvar *image-default-resize-size* 1536)
> (defvar *image-resize-sizes* '())
>
> ;; This function optimizes image for websites to reach the optimum
> ;; Internet speed
>
> (defun optimize-image-jpg (file &optional quality)
>   "Optimizes the JPG image with quality 70%"
>   (if (rcd-which-list '("mogrify"))
>       (let ((extension (file-name-extension file))
>             (quality (or quality "70")))
>         (when (string-match "\\(?:\\(?:jpe?\\|pn\\)g\\)" (downcase extension))
>             (message "Optimizing `%s'" file)
>             (call-process "mogrify" nil  "-sampling-factor" "4:2:0" "-strip" 
> "-interlace" "JPEG" "-colorspace" "RGB" "-format" "jpg" "-quality" quality 
> file)
>             (message "Optimizing FINISHED for `%s'" file)))
>     (rcd-warning-message "RCD ERROR: `mogrify' not found in $PATH")))
>
> ;; Mark files in Dired, optimize images
>
> (defun optimize-jpg-images-dired ()
>   "Optimizes JPG images inside of Dired"
>   (interactive)
>   (let ((files (dired-get-marked-files)))
>     (while files
>       (optimize-image-jpg (pop files)))
>     (revert-buffer)))
>
> (defun image-resize (file &optional size)
>   "Resizes the JPG image with default size"
>   (if (rcd-which-list '("mogrify"))
>       (let ((extension (file-name-extension file)))
>         (when (or (equal (downcase extension) "jpg")
>                   (equal (downcase extension) "png"))
>           (let* ((file (shell-double-quote file))
>                  (command (format "mogrify -resize %s \"%s\"" size file)))
>             (message command)
>             (call-process-shell-command command))))
>     (rcd-warning-message "RCD ERROR: `mogrify' not found in `$PATH'")))
>
> ;; Mark files in dired, resize images
>
> (defun image-resize-dired ()
>   "Resizes images"
>   (interactive)
>   (let ((files (dired-get-marked-files))
>         (size (read-number "Size: " *image-default-resize-size* 
> '*image-resize-sizes*)))
>     (while files
>       (image-resize (pop files) size))
>     (revert-buffer)))
>
> If you know what exactly you wish to do to images then it is possible
> to use same methods and invoke ImageMagick processing.

Other possible processing includes highlighting some regions with
square or circle,  adding some text comments, and drawing some lines
or arrows, and so on. I'm not sure whether all these trivial
operations can be done by the method similar to the above.

Regards,
Hongyi