[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Screenshots, frame shots straight from Emacs

From: Jean Louis
Subject: Re: Screenshots, frame shots straight from Emacs
Date: Fri, 23 Jul 2021 08:51:15 +0300
User-agent: Mutt/2.0.7+183 (3d24855) (2021-05-28)

* Hongyi Zhao <> [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)))
     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:



(defparameter *image-capture-program* "maim")
(defparameter *image-type* ".png")
(defparameter *image-directory* 

(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

(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"
  (let ((files (dired-get-marked-files)))
    (while files
      (optimize-image-jpg (pop files)))

(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"
  (let ((files (dired-get-marked-files))
        (size (read-number "Size: " *image-default-resize-size* 
    (while files
      (image-resize (pop files) size))

If you know what exactly you wish to do to images then it is possible
to use same methods and invoke ImageMagick processing.


Take action in Free Software Foundation campaigns:

In support of Richard M. Stallman

reply via email to

[Prev in Thread] Current Thread [Next in Thread]