cliphist-0.5.5.tar

cliphist-0.5.5/0000755000175000017500000000000013257704132011076 5ustar  cbcbcliphist-0.5.5/cliphist.el0000644000175000017500000002063213257704132013242 0ustar  cbcb;;; cliphist.el --- Read data from clipboard managers at Linux and Mac

;; Copyright (C) 2015-2017 Chen Bin
;;
;; Version: 0.5.5
;; Package-Requires: ((emacs "24.3") (ivy "0.9.0"))
;; Keywords: clipboard manager history
;; Author: Chen Bin <chenin DOT sh AT gmail DOT com>
;; URL: http://github.com/redguardtoo/cliphist

;; This file is not part of GNU Emacs.

;; 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 2, 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, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

;;; Commentary:

;; Read clipboard items from following clipboard managers,
;;   - Parcellite (http://parcellite.sourceforge.net) at Linux
;;   - ClipIt (http://clipit.sourceforge.net) at Linux
;;   - Flycut (https://github.com/TermiT/Flycut) on OSX
;;
;; Usage:
;;   Make sure clipboard manager is running.
;;   `M-x cliphist-paste-item' to paste item from history
;;   `C-u M-x cliphist-paste-item' rectangle paste item
;;   `M-x cliphist-select-item' to select item
;;
;; You can customize the behavior of cliphist-select-item,
;;     (setq cliphist-select-item-callback
;;        (lambda (num str) (cliphist-copy-to-clipboard str)))
;;
;;   If `cliphist-cc-kill-ring' is true, the selected/pasted string
;;   will be inserted into kill-ring
;;
;; You can tweak =cliphist-linux-clipboard-managers= to tell cliphist
;; how to detect clipboard manager:
;;   `(setq cliphist-linux-clipboard-managers '("clipit" "parcellite"))'

;;; Code:

(require 'ivy)

(defvar cliphist-linux-clipboard-managers
  '("parcellite" "clipit")
  "We will try to detect the clipboard manager one by one.")

(defvar cliphist-cc-kill-ring nil
  "Copy the selected/pasted item into kill ring.")

(defvar cliphist-select-item-callback nil
  "The callback of `cliphist-select-item'.
If nil, selected item is copied to clipboard when `cliphist-select-item' called.
Or else the `(funcall cliphist-select-item num item)' will be executed.")

(defvar cliphist-items nil
  "Item list extracted from clipboard manager.  Internal variable.")

(autoload 'cliphist-flycut-read-items "cliphist-flycut" nil)
(autoload 'cliphist-parcellite-read-items "cliphist-parcellite" nil)
(autoload 'cliphist-clipit-read-items "cliphist-clipit" nil)

(defun cliphist--posn-col-row (posn)
  (let* ((col (car (posn-col-row posn)))
         ;; `posn-col-row' doesn't work well with lines of different height.
         ;; `posn-actual-col-row' doesn't handle multiple-width characters.
         (row (cdr (posn-actual-col-row posn))))
    (when (and header-line-format (version< emacs-version "24.3.93.3"))
      ;; http://debbugs.gnu.org/18384
      (cl-decf row))
    (cons (+ col (window-hscroll)) row)))

(defun cliphist--strip (str)
  (replace-regexp-in-string "\\(^[ \t\n\r]+\\|[ \t\n\r]+$\\)" "" str))

(defun cliphist-row (&optional pos)
  "The row position of cursort in current window"
  (interactive)
  (cdr (cliphist--posn-col-row (posn-at-point pos))))

(defun cliphist-create-stripped-summary (str)
  (cliphist-create-summary (cliphist--strip str)))

(defun cliphist-create-summary (stripped)
  (let* ((summary-width (- (frame-width) 3)) ; "summary.."
         (rlt (substring-no-properties stripped 0 (min (length stripped) summary-width)))
         ;; friendly hint in summary that actual value is longer
         (need-hint (< (length rlt) (length stripped))))
    ;; remove cr&lf inside summary
    (setq rlt (replace-regexp-in-string "[ \t\n]+" " " rlt))
    (if need-hint (setq rlt (concat rlt "..")))
    rlt))

(defun cliphist-add-item-to-cache (item-list str)
  (let* ((stripped (cliphist--strip str)))
    ;; don't paste item containing only white spaces
    (if (> (length stripped) 0)
        (add-to-list item-list str t))))

;;;###autoload
(defun cliphist-version ()
  (message "0.5.5"))

;;;###autoload
(defun cliphist-read-items ()
  (interactive)
  (let* (rlt i)
    (cond
     ((eq system-type 'darwin)
      ;; if nothing in clipboard, avoid purging the cache in Emacs
      (if (setq rlt (cliphist-flycut-read-items 'cliphist-add-item-to-cache))
          (setq cliphist-items rlt)))
     ((or (eq system-type 'gnu/linux) (eq system-type 'linux))
      ;; if nothing in clipboard, avoid purging the cache in Emacs
      (setq i 0)
      (while (and (not rlt)
                  (< i (length cliphist-linux-clipboard-managers)))
        (setq rlt (funcall (intern (format "cliphist-%s-read-items"
                                           (nth i cliphist-linux-clipboard-managers)))
                           'cliphist-add-item-to-cache))
        (setq i (+ 1 i)))
      (if rlt (setq cliphist-items rlt)))
     (t (message "Sorry, only Linux and Mac are supported.")))
    rlt))

(defmacro cliphist-do-item (num fn)
  "Select a item and do something.  Utility used by other commands.
FN do the thing."
  `(let (pseudo-height)
    (cliphist-read-items)
    (cond
     ((and cliphist-items (> (length cliphist-items) 0))
      (let* ((ivy-format-function (lambda (cands)
                                    (ivy--format-function-generic
                                     (lambda (str)
                                       (ivy--add-face (cliphist-create-stripped-summary str) 'ivy-current-match))
                                     #'cliphist-create-stripped-summary
                                     cands
                                     "\n"))))
        (ivy-read "Clipboard items:"
                  cliphist-items
                  :action (lambda (item)
                            (funcall ,fn ,num item)
                            (if cliphist-cc-kill-ring (kill-new item))))))
     (t
      (message "Nothing in clipboard yet!")))))

;;;###autoload
(defun cliphist-copy-to-clipboard (str)
  "Copy STR into clipboard."
  (condition-case nil
      (cond
       ((fboundp 'ns-set-pasteboard)
        (ns-set-pasteboard str))
       ((fboundp 'x-set-selection)
        (x-set-selection 'CLIPBOARD str))
       (t
        (error "Clipboard support not available")))
    (error
     (condition-case nil
         (cond
          ((eq system-type 'darwin)
           (with-temp-buffer
             (insert str)
             (call-process-region (point-min) (point-max) "pbcopy")))
          ((memq system-type '(gnu gnu/linux gnu/kfreebsd))
           (with-temp-buffer
             (insert str)
             (if (file-executable-p "xsel")
                 (call-process-region (point-min) (point-max) "xsel" nil nil nil "--clipboard" "--input")
               (call-process-region (point-min) (point-max) "xclip" nil nil nil "-selection clipboard" "--input"))
             ))
          (t
           (error "Clipboard support not available")))
       (error
        (error "Clipboard support not available"))))))

(defun cliphist-routine-before-insert ()
  "Make string insertion in `evil-normal-state' work."
  (when (and (functionp 'evil-normal-state-p)
             (functionp 'evil-move-cursor-back)
             (evil-normal-state-p)
             (not (eolp))
             (not (eobp)))
    (forward-char)))

;;;###autoload
(defun cliphist-paste-item (&optional rect-paste)
  "Paste selected item into current buffer.
Rectangle paste the item if arg RECT-PASTE is non-nil."
  (interactive "P")
  (cliphist-do-item 1 `(lambda (num str)
                         ;; evil-mode?
                         (cliphist-routine-before-insert)
                         ;; insert now
                         (if ,rect-paste
                             (insert-rectangle (split-string str "[\r]?\n"))
                           (insert str)))))

;;;###autoload
(defun cliphist-select-item (&optional num)
  "Select one item from clipboard history.
NUM is passed to `cliphist-select-item-callback'."
  (interactive "P")
  (cliphist-do-item num (lambda (num str)
                          ;; (message "num=%s str=%s" num str)
                          (if cliphist-select-item-callback
                              (funcall cliphist-select-item-callback num str)
                           (cliphist-copy-to-clipboard str)))))

(provide 'cliphist)
;;; cliphist.el ends here
cliphist-0.5.5/cliphist-pkg.el0000644000175000017500000000042013257704132014012 0ustar  cbcb(define-package "cliphist" "0.5.5" "Read data from clipboard managers at Linux and Mac"
  '((emacs "24.3")
    (ivy "0.9.0"))
  :url "http://github.com/redguardtoo/cliphist" :keywords
  '("clipboard" "manager" "history"))
;; Local Variables:
;; no-byte-compile: t
;; End:
cliphist-0.5.5/cliphist-parcellite.el0000644000175000017500000000736313257704132015372 0ustar  cbcb;;; cliphist-parcellite.el --- read parcelllite data file

;; Copyright (C) 2015-2017 Chen Bin

;; Author: Chen Bin <chenin DOT sh AT gmail DOT com>

;; This file is not part of GNU Emacs.

;; 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, 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 <http://www.gnu.org/licenses/>.

;;; Commentary:

;; Read "~/.local/share/parcellite/history" on Linux

;;; Code:

(defun cliphist-parcellite-get-item-size (str len beg &optional short-int)
  "Scan STR whose length is LEN.  Start scanning from position BEG.
If SHORT-INT is t, read 2 bytes.  Or else read 4 bytes."
  (let* (size)
    ;; read 4 bytes in little endian order
    (if (< (+ beg 3) len)
        (setq size (+ (elt str beg)
                      (* 256 (elt str (+ 1 beg)))
                      (if short-int 0
                        (+ (* 256 256 (elt str (+ 2 beg)))
                           (* 256 256 256 (elt str (+ 3 beg))))))))
    size))

(defun cliphist-parcellite-read-item (str len item &optional is-new-version)
  "Parcellite binary data STR with length LEN is analyzed.
ITEM is the previous item extracted whose data useful for current extraction.
If IS-NEW-VERSION is t, it's Parcellite v1.0+."
  (let (rlt
        index
        beg
        type
        size)
    (if item (setq beg (nth 1 item))
      (setq beg (if is-new-version 32 0)))
    ;; read 4 bytes to get the item length
    (setq size (cliphist-parcellite-get-item-size str len beg))

    ;; read string
    (if (and size (> size 0))
        (cond
         (is-new-version
          ;; type has two bytes
          (setq type (cliphist-parcellite-get-item-size str len (+ 8 beg) 2))
          ;; 1 means STRING type
          (if (= 1 type)
              ;; Just fetch the content, I don't care about the summary of item
              (setq rlt (list (substring str (+ 36 beg) (+ beg size)) (+ beg size)))))
         (t
          ;; Old version of parcellite is much simpler
          (setq rlt (list (substring str (+ 4 beg) (+ 4 beg size)) (+ 4 beg size))))))
    rlt))

(defun cliphist-parcellite-read-items (fn-insert)
  "For each item, First 4 bytes specify the size of content.
It ends with 4 byte zeroed.  Please note byte are stored in little endian way.
Extracted item will be passed to FN-INSERT."
  (let* ((path (file-truename "~/.local/share/parcellite/history"))
         str
         str-len
         is-new-version
         item
         rlt)
    (when (file-exists-p path)
      (setq str (with-temp-buffer
                  (set-buffer-multibyte nil)
                  (setq buffer-file-coding-system 'binary)
                  (insert-file-contents-literally path)
                  (buffer-substring-no-properties (point-min) (point-max))))
      (setq str-len (length str))
      ;; first 3 characters is "1.0"
      (setq is-new-version (and (= (elt str 0) 49)
                                (= (elt str 1) 46)
                                (= (elt str 2) 48)))
      ;; read clipboard items into cache
      (while (setq item (cliphist-parcellite-read-item str str-len item is-new-version))
        ;; filter out short strings
        (unless (< (length (car item)) 3)
          (funcall fn-insert 'rlt (decode-coding-string (car item) 'utf-8)))))
    rlt))

(provide 'cliphist-parcellite)
;;; cliphist-parcellite.el ends here
cliphist-0.5.5/cliphist-autoloads.el0000644000175000017500000000217713257704132015237 0ustar  cbcb;;; cliphist-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))

;;;### (autoloads nil "cliphist" "cliphist.el" (23231 34906 0 0))
;;; Generated autoloads from cliphist.el

(autoload 'cliphist-version "cliphist" "\


\(fn)" nil nil)

(autoload 'cliphist-read-items "cliphist" "\


\(fn)" t nil)

(autoload 'cliphist-copy-to-clipboard "cliphist" "\
Copy STR into clipboard.

\(fn STR)" nil nil)

(autoload 'cliphist-paste-item "cliphist" "\
Paste selected item into current buffer.
Rectangle paste the item if arg RECT-PASTE is non-nil.

\(fn &optional RECT-PASTE)" t nil)

(autoload 'cliphist-select-item "cliphist" "\
Select one item from clipboard history.
NUM is passed to `cliphist-select-item-callback'.

\(fn &optional NUM)" t nil)

;;;***

;;;### (autoloads nil nil ("cliphist-clipit.el" "cliphist-flycut.el"
;;;;;;  "cliphist-parcellite.el" "cliphist-pkg.el") (23231 34906
;;;;;;  0 0))

;;;***

;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; End:
;;; cliphist-autoloads.el ends here
cliphist-0.5.5/cliphist-flycut.el0000644000175000017500000000531713257704132014551 0ustar  cbcb;;; cliphist-flycut.el --- read flycut data file

;; Copyright (C) 2015-2017 Chen Bin

;; Author: Chen Bin <chenin DOT sh AT gmail DOT com>

;; This file is not part of GNU Emacs.

;; 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, 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 <http://www.gnu.org/licenses/>.

;;; Commentary:

;; Read "~/Library/Application Support/Flycut/com.generalarcade.flycut.plist" on OSX

;;; Code:

(require 'xml)

(defun cliphist-find-xml-node-containting-items (items)
  "We need node type is `key' and value is `displayLen'."
  (let* (rlt
         child
         (i 0))
    (while (and (not rlt)
                (< i (length items)))
      (setq child (nth 0 (xml-get-children (nth i items) 'key)))
      (if (and (eq (car child) 'key)
               (string= (nth 2 child) "displayLen"))
          (setq rlt (xml-get-children (car (xml-get-children (nth i items) 'array))
                                      'dict)))
      (setq i (+ i 1)))
    rlt))

(defun cliphist-flycut-guess-preference-path ()
  (let* ((rlt (file-truename "~/Library/Preferences/com.generalarcade.flycut.plist")))
    (unless (file-exists-p rlt)
      (setq rlt (file-truename "~/Library/Application Support/Flycut/com.generalarcade.flycut.plist")))
    rlt))

(defun cliphist-flycut-read-items (&optional fn-insert)
  "Flycut store the data in xml file.
We use regex to extract the clipboard item.
Then call FN-INSERT to insert the item into the list which returned by this function."
  (let* (rlt
         (path (cliphist-flycut-guess-preference-path))
         ;; (path (file-truename "~/projs/cliphist/data/flycut/com.generalarcade.flycut.plist"))
         (xml-tree (cadr (xml-node-children (car (xml-parse-file path)))))
         (arr (cliphist-find-xml-node-containting-items (xml-get-children xml-tree 'dict))))
    (when arr
      (dolist (item arr)
        (let* ((strs (xml-get-children item 'string)))
          ;; strs is two xml node:
          ;;   (string nil calculate)
          ;;   (string nil NSStringPboardType)
          (if (and (string= "NSStringPboardType" (nth 2 (cadr strs)))
                   fn-insert)
              (funcall fn-insert 'rlt (nth 2 (car strs)))))))
    rlt))

(provide 'cliphist-flycut)
;;; cliphist-flycut.el ends herecliphist-0.5.5/cliphist-clipit.el0000644000175000017500000000611513257704132014524 0ustar  cbcb;;; cliphist-clipit.el --- read parcelllite data file

;; Copyright (C) 2015-2017 Chen Bin

;; Author: Chen Bin <chenin DOT sh AT gmail DOT com>

;; This file is not part of GNU Emacs.

;; 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, 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 <http://www.gnu.org/licenses/>.

;;; Commentary:

;; Read "~/.local/share/clipit/history" on Linux

;;; Code:

(defun cliphist-clipit-get-item-size (str len beg)
  "Scan STR whose length is LEN.  Start scanning from position BEG.
If SHORT-INT is t, read 2 bytes.  Or else read 4 bytes."
  (let* (size)
    ;; read 4 bytes in little endian order
    (if (< (+ beg 3) len)
        (setq size (+ (elt str beg)
                      (* 256 (elt str (+ 1 beg)))
                      (+ (* 256 256 (elt str (+ 2 beg)))
                         (* 256 256 256 (elt str (+ 3 beg)))))))
    size))

(defun cliphist-clipit-read-item (str len item)
  "Clipit binary data STR with length LEN is analyzed.
ITEM is the previous item extracted whose data useful for current extraction."
  (let* (rlt
         (beg (if item (+ 12 (nth 1 item))  68))
         (str-beg (+ beg 8))
         ;; read 4 bytes to get the item length
         (size (cliphist-clipit-get-item-size str len beg)))
    ;; read string
    (when (and size (> size 0))
      (setq rlt (list (substring str str-beg (+ str-beg size)) (+ str-beg size))))
    rlt))

(defun cliphist-clipit-read-items (fn-insert)
  "Check save_history defined in ClipIt history.c.
68 bytes rubbish at the beginning of file plus the item list.

For each item in the item list, First 4 bytes specify the size of content.
Then is number 1, content of item, number 4, number 2, and boolean flage is_static.

Please note bytes are stored in little endian way.
Number and boolean flag takes 4 bytes.
Extracted item will be passed to FN-INSERT."
  (let* ((path (file-truename "~/.local/share/clipit/history"))
         str
         str-len
         item
         rlt)
    (when (file-exists-p path)
      (setq str (with-temp-buffer
                  (set-buffer-multibyte nil)
                  (setq buffer-file-coding-system 'binary)
                  (insert-file-contents-literally path)
                  (buffer-substring-no-properties (point-min) (point-max))))
      (setq str-len (length str))
      ;; read clipboard items into cache
      (while (setq item (cliphist-clipit-read-item str str-len item))
        ;; filter out short strings
        (unless (< (length (car item)) 3)
          (funcall fn-insert 'rlt (decode-coding-string (car item) 'utf-8)))))
    rlt))

(provide 'cliphist-clipit)
;;; cliphist-clipit.el ends here