Re: Screenshots, frame shots straight from Emacs

[Jean Louis]

* 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. 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.

(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.

> 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.




-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/