Archived
1
0
Fork 0

add pomodoro

This commit is contained in:
KemoNine 2024-08-14 12:06:51 -04:00
parent 114349cb47
commit f8b2182c7b
8 changed files with 1063 additions and 181 deletions

File diff suppressed because it is too large Load diff

Binary file not shown.

View file

@ -0,0 +1,30 @@
;;; pomidor-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*-
;; Generated by the `loaddefs-generate' function.
;; This file is part of GNU Emacs.
;;; Code:
(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
;;; Generated autoloads from pomidor.el
(autoload 'pomidor "pomidor" "\
A simple and cool pomodoro technique timer." t)
(register-definition-prefixes "pomidor" '("pomidor-"))
;;; End of scraped data
(provide 'pomidor-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; no-native-compile: t
;; coding: utf-8-emacs-unix
;; End:
;;; pomidor-autoloads.el ends here

View file

@ -0,0 +1,16 @@
(define-package "pomidor" "20240601.1617" "Simple and cool pomodoro timer"
'((emacs "24.3")
(alert "1.2")
(dash "2.17.0"))
:commit "de71c34a1a9aff745181107094d3389816dbeca5" :authors
'(("TatriX" . "tatrics@gmail.com"))
:maintainers
'(("TatriX" . "tatrics@gmail.com"))
:maintainer
'("TatriX" . "tatrics@gmail.com")
:keywords
'("tools" "time" "applications" "pomodoro technique")
:url "https://github.com/TatriX/pomidor")
;; Local Variables:
;; no-byte-compile: t
;; End:

View file

@ -0,0 +1,715 @@
;;; pomidor.el --- Simple and cool pomodoro timer
;; Author: TatriX <tatrics@gmail.com>
;; URL: https://github.com/TatriX/pomidor
;; Keywords: tools, time, applications, pomodoro technique
;; Version: 0.6.2
;; Package-Requires: ((emacs "24.3") (alert "1.2") (dash "2.17.0"))
;; 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; pomidor is a simple and cool
;; [[http://www.pomodorotechnique.com/][pomodoro technique]] timer.
;;; Code:
(require 'cl-lib)
(require 'alert)
(require 'dash)
(require 'json)
(require 'parse-time)
;;; Customs
(defgroup pomidor nil
"Customs for `pomidor'"
:group 'productivity)
(defcustom pomidor-buffer-name "*pomidor*"
"Name of the pomidor buffer."
:type 'string :group 'pomidor)
(defcustom pomidor-history-buffer-name "*pomidor-history*"
"Name of the pomidor history buffer."
:type 'string :group 'pomidor)
(defcustom pomidor-seconds (* 25 60)
"Time length of a Podomoro round."
:type 'integer :group 'pomidor)
(defcustom pomidor-break-seconds (* 5 60)
"Time length of a Podomoro break."
:type 'integer :group 'pomidor)
(defcustom pomidor-update-interval 60
"Interval in seconds when pomidor should run hooks and play overwork sounds."
:type 'integer :group 'pomidor)
(defcustom pomidor-confirm-end-break t
"If t ask for confirmation before ending a break and starting new a pomodoro."
:type 'boolean :group 'pomidor)
;;; Vars
(defcustom pomidor-time-format "%H:%M:%S"
"Time format for podomoro clock."
:type 'string :group 'pomidor)
(defcustom pomidor-history-date-format "%Y-%m-%dT%H:%M:%S"
"Date format used to save the session ended value."
:type 'string :group 'pomidor)
(defcustom pomidor-duration-format "%H:%M:%S"
"Time format for duration intervals."
:type 'string :group 'pomidor)
(defconst pomidor-dir (file-name-directory (or load-file-name buffer-file-name))
"Pomidor directory in which sounds store.")
(defcustom pomidor-sound-tick (expand-file-name (concat pomidor-dir "tick.wav"))
"Tick sound during a pomoro run."
:type '(file :must-match t)
:group 'pomidor)
(defcustom pomidor-sound-tack (expand-file-name (concat pomidor-dir "tack.wav"))
"Tick sound during a pomoro run."
:type '(file :must-match t)
:group 'pomidor)
(defcustom pomidor-sound-overwork (expand-file-name (concat pomidor-dir "overwork.wav"))
"Overwork sound."
:type '(file :must-match t)
:group 'pomidor)
(defcustom pomidor-sound-break-over (expand-file-name (concat pomidor-dir "overwork.wav"))
"Break over sound."
:type '(file :must-match t)
:group 'pomidor)
(defcustom pomidor-save-session-file (expand-file-name "pomidor-session.json" user-emacs-directory)
"Pomidor session store file."
:type '(file :must-match t)
:group 'pomidor)
(defcustom pomidor-breaks-before-long 4
"How many short breaks before the long break."
:type 'integer :group 'pomidor)
(defcustom pomidor-long-break-seconds (* 20 60)
"Time length of a Podomoro long break."
:type 'integer :group 'pomidor)
;; libnotify for some reason can't display svg
(defvar pomidor-icon (concat data-directory "images/icons/hicolor/16x16/apps/emacs.png")
"Default pomidor icon.")
(defun pomidor-default-alert-message ()
"Default pomidor alert message if any."
(cond
((and (pomidor-overwork-p) (pomidor-should-long-break-p))
(format "Take a long break!\nOverwork: [%s]"
(format-time-string "%H:%M:%S" (pomidor-overwork-duration) t)))
((pomidor-overwork-p)
(format "Take a break!\nOverwork: [%s]"
(format-time-string "%H:%M:%S" (pomidor-overwork-duration) t)))
((pomidor-break-over-notify-p)
(format "Go back to work!\nBreak: [%s]"
(format-time-string "%H:%M:%S" (pomidor-break-duration) t)))))
(defun pomidor-default-alert ()
"Default pomidor alert."
(let ((message (pomidor-default-alert-message)))
(when message
(alert message
:severity 'normal
:icon pomidor-icon
:title "Pomidor"
:category 'pomidor))))
(defcustom pomidor-alert #'pomidor-default-alert
"Pomidor alert function.
To disable alerts, set to nil."
:type '(choice (const nil)
function)
:group 'pomidor)
(defun pomidor-play-sound-file-emacs (file)
"Play FILE by starting new Emacs process."
(if (fboundp 'play-sound-internal)
(start-process "pomidor-play-sound-file-emacs"
nil
(car command-line-args)
"-Q"
"--batch"
"--eval" (format "(play-sound-file \"%s\")" file))
(warn "This Emacs binary lacks sound support")))
(defcustom pomidor-play-sound-file #'pomidor-play-sound-file-emacs
"Function to play sounds (preferably async).
To disable sounds, set to nil."
:type '(choice (const nil)
function)
:group 'pomidor)
(defvar pomidor-update-hook nil)
;;; Faces
(defface pomidor-time-face
'((t (:height 4.0)))
"pomidor face for time"
:group 'pomidor)
(defface pomidor-date-face
'((t (:height 4.0)))
"pomidor face for date"
:group 'pomidor)
(defface pomidor-timer-face
'((t (:height 5.0)))
"pomidor face for timer"
:group 'pomidor)
(defface pomidor-work-face
'((t (:inherit success)))
"pomidor face for work"
:group 'pomidor)
(defface pomidor-overwork-face
'((t (:inherit warning)))
"pomidor face for overwork"
:group 'pomidor)
(defface pomidor-break-face
'((t (:inherit font-lock-keyword-face)))
"pomidor face for break"
:group 'pomidor)
(defface pomidor-skip-face
'((t (:inherit font-lock-comment-face)))
"pomidor face for skip"
:group 'pomidor)
;;; Vars
(defvar pomidor-timer nil
"Pomidor timer.")
(defvar pomidor-global-state nil
"Pomidor global state.")
(defvar pomidor-graph-char ?█
"Pomidor char for displaying tubes.")
(defvar pomidor-header-separator ""
"Pomidor string to separate time and duration in header.")
(defvar pomidor-header-session-name-separator " : "
"Pomidor string to separate the regular header from the session name in history mode.")
(defvar pomidor--current-history-session nil
"Hold the current visible pomidor history snapshot.")
(defvar pomidor--count-short-breaks 0
"Pomidor integer of how many short breaks we have before a long break.")
(defvar pomidor--system-on-hold-p nil
"Pomidor control of hold in system.")
;;; Private
(defun pomidor--current-state ()
"Return current state."
(car (last pomidor-global-state)))
(defun pomidor--reset ()
"Delete current global state."
(setq pomidor-global-state (list (pomidor--make-state))))
(defun pomidor--make-state ()
"Make pomidor state."
(list :started (current-time)
:break nil
:stopped nil
:snooze nil))
(defun pomidor--started (state)
"Return started time for STATE."
(plist-get state :started))
(defun pomidor--break (state)
"Return break time for STATE."
(plist-get state :break))
(defun pomidor--stopped (state)
"Return stopped time for STATE.
It's a time when user started a new timer after this one."
(plist-get state :stopped))
(defun pomidor--ended (state)
"Return ended time for STATE.
It's either stopped time or current time."
(or (pomidor--stopped state) (current-time)))
(defun pomidor--work-duration (state)
"Return work time for STATE."
(let* ((started (pomidor--started state))
(ended (or (pomidor--break state) (pomidor--ended state)))
(work (time-subtract ended started))
(max (seconds-to-time pomidor-seconds)))
(if (time-less-p work max)
work
max)))
(defun pomidor--overwork-duration (state)
"Return overwork time for STATE or nil."
;; (cur - started) - (cur - break) - max
(let* ((started (pomidor--started state))
(break (or (pomidor--break state) (pomidor--ended state)))
(work (pomidor--work-duration state))
(ended (pomidor--ended state))
(max (seconds-to-time pomidor-seconds))
(overwork (time-subtract (time-subtract (time-subtract ended started)
(time-subtract ended break))
max)))
(when (> (time-to-seconds overwork) 0)
overwork)))
(defun pomidor-running-p ()
"Return t if pomidor is running right now."
(timerp pomidor-timer))
(defun pomidor-overwork-p ()
"Return t if current state is overwork."
(let* ((state (pomidor--current-state))
(overwork (pomidor--overwork-duration state)))
(and overwork (null (pomidor--break state)))))
(defun pomidor-should-long-break-p ()
"Return t if current state should take a long break."
(cl-equalp pomidor--count-short-breaks (1+ pomidor-breaks-before-long)))
(defun pomidor-break-over-notify-p ()
"Return t if current break is over and user should be notified about it.
To snooze the notification use `pomidor-break'."
(and (pomidor-break-over-p) (not (pomidor-snooze-p))))
(defun pomidor-break-over-p ()
"Return t if current break is over."
(let* ((state (pomidor--current-state))
(break (pomidor--break-duration state))
(expected-break-seconds (if (pomidor-should-long-break-p)
pomidor-long-break-seconds
pomidor-break-seconds)))
(and break (> (time-to-seconds break) expected-break-seconds))))
(defun pomidor-snooze-p ()
"Return t if user snooze end of break alarm."
(plist-get (pomidor--current-state) :snooze))
(defun pomidor--total-duration (state)
"Return total time for STATE."
(time-subtract (pomidor--ended state) (pomidor--started state)))
(defun pomidor--break-duration (state)
"Return break time for STATE."
(let ((break (pomidor--break state)))
(and break (time-subtract (pomidor--ended state) break))))
(defun pomidor--format-header (time state face)
"Return formated header for TIME with FACE."
(let ((freezed-time (plist-get state :session-ended)))
(concat (pomidor--with-face (concat (pomidor--format-time (or freezed-time (current-time)))
pomidor-header-separator)
'pomidor-time-face)
(propertize (pomidor--format-duration time)
'face `(:inherit (,face pomidor-timer-face)))
(when (eq major-mode 'pomidor-history-mode)
(pomidor--with-face (concat pomidor-header-session-name-separator
(format-time-string "%Y-%m-%d" freezed-time))
'pomidor-date-face)))))
(defun pomidor--header (state)
"Return header."
(let* ((break (pomidor--break-duration state))
(overwork (pomidor--overwork-duration state))
(work (pomidor--work-duration state)))
(cond
(break (pomidor--format-header break state 'pomidor-break-face))
(overwork (pomidor--format-header overwork state 'pomidor-overwork-face))
(work (pomidor--format-header work state 'pomidor-work-face)))))
(defun pomidor--format-time (time)
"Format TIME as of `pomidor-time-format'."
(format-time-string pomidor-time-format time))
(defun pomidor--format-duration (time)
"Format TIME as of `pomidor-duration-format'.
TIME may be nil."
(format-time-string pomidor-duration-format (or time (seconds-to-time 0)) t))
(defun pomidor--window-width ()
"Return pomidor buffer width in chars."
(window-total-width (get-buffer-window (pomidor--get-buffer-create))))
(defun pomidor--with-face (string face)
"Retrun STRING with FACE."
(propertize string 'font-lock-face face))
(defun pomidor--format-time-string (time face)
"Format graph string for TIME with FACE."
(pomidor--with-face (make-string (round (/ (time-to-seconds time)
(/ (float pomidor-seconds) (/ (pomidor--window-width) 2))))
pomidor-graph-char)
face))
(defun pomidor--graph (work overwork break)
"Format graph based on WORK, OVERWORK and BREAK time."
(concat
(pomidor--format-time-string work 'pomidor-work-face)
(let ((skip (- pomidor-seconds (time-to-seconds work))))
(when (> skip 0)
(pomidor--format-time-string (seconds-to-time skip) 'pomidor-skip-face)))
(and overwork (pomidor--format-time-string overwork 'pomidor-overwork-face))
(and break (pomidor--format-time-string break 'pomidor-break-face))))
(defun pomidor--play-sound-file (file)
"Play FILE using `pomidor-play-sound-file' function if any."
(when (and file (functionp pomidor-play-sound-file))
(funcall pomidor-play-sound-file file)))
(defun pomidor--tick-tack (ellapsed)
"Play tick or tack based on ELLAPSED."
(pomidor--play-sound-file
(if (zerop (mod ellapsed 2))
pomidor-sound-tick
pomidor-sound-tack)))
(defun pomidor--update ()
"Update pomidor state."
(let* ((state (pomidor--current-state))
(total (pomidor--total-duration state))
(ellapsed (round (time-to-seconds total))))
(pomidor--tick-tack ellapsed)
(when (zerop (mod ellapsed pomidor-update-interval))
(when (functionp pomidor-alert)
(funcall pomidor-alert))
(run-hooks 'pomidor-update-hook)
(cond
((pomidor-overwork-p)
(pomidor--play-sound-file pomidor-sound-overwork))
((pomidor-break-over-notify-p)
(pomidor--play-sound-file pomidor-sound-break-over)))))
(pomidor--render (pomidor--get-buffer-create) pomidor-global-state))
(defun pomidor--render (buffer states)
"Render pomidor state."
(when (get-buffer-window buffer t)
(with-current-buffer buffer
(read-only-mode -1)
(erase-buffer)
(insert (pomidor--header (car (last states)))
"\n")
(cl-loop
for i from 1
for state in states
as work = (pomidor--work-duration state)
as overwork = (pomidor--overwork-duration state)
as break = (pomidor--break-duration state)
as total = (pomidor--total-duration state)
with sum-work = (seconds-to-time 0)
with sum-overwork = (seconds-to-time 0)
with sum-break = (seconds-to-time 0)
with sum-total = (seconds-to-time 0)
do (progn
(setq sum-work (time-add sum-work work)
sum-total (time-add sum-total total))
(when overwork
(setq sum-overwork (time-add sum-overwork overwork)))
(when break
(setq sum-break (time-add sum-break break)))
(insert
"\n "
(make-string 79 ?-)
"\n"
(format "%3d) [%s] | [%s] | [%s] | [%s]\t\t %s → %s"
i
(pomidor--with-face (pomidor--format-duration work) 'pomidor-work-face)
(pomidor--with-face (pomidor--format-duration overwork) 'pomidor-overwork-face)
(pomidor--with-face (pomidor--format-duration break) 'pomidor-break-face)
(pomidor--format-duration total)
(pomidor--format-time (pomidor--started state))
(pomidor--format-time (pomidor--ended state)))
"\n "
(pomidor--graph work overwork break)))
finally
(insert "\n "
(make-string 79 ?-)
"\n\n"
(format " Work\t[%s]\n"
(pomidor--with-face (pomidor--format-duration sum-work) 'pomidor-work-face))
(format " Overwork\t[%s]\n"
(pomidor--with-face (pomidor--format-duration sum-overwork) 'pomidor-overwork-face))
(format " Break\t[%s]\n"
(pomidor--with-face (pomidor--format-duration sum-break) 'pomidor-break-face))
(format " Total\t[%s]\n"
(pomidor--format-duration sum-total)))
)
(read-only-mode +1))))
(defun pomidor--get-buffer-create ()
"Return a pomidor buffer."
(get-buffer-create pomidor-buffer-name))
(defun pomidor--get-history-buffer-create ()
"Create a history pomidor buffer."
(get-buffer-create pomidor-history-buffer-name))
(defun pomidor--cancel-timer ()
"Cancel pomidor timer."
(when (timerp pomidor-timer)
(cancel-timer pomidor-timer)
(setq pomidor-timer nil)))
(defun pomidor--read-session (preserve-timestamp?)
"Read the saved sessions."
(let* ((json-object-type 'plist)
(json-array-type 'list)
(data (json-read-file pomidor-save-session-file)))
(if preserve-timestamp?
data
(-map (lambda (pomidor)
(-map (lambda (v) (if (stringp v)
(parse-iso8601-time-string v)
v))
pomidor))
data))))
(defun pomidor--valid-sessions-dates (session-dates direction)
"Get valid date of SESSION-DATES from history data to move in correct DIRECTION."
(let ((fun (lambda (v)
(if (cl-equalp direction :backward)
(time-less-p v pomidor--current-history-session)
(time-less-p pomidor--current-history-session v)))))
(if pomidor--current-history-session
(-filter (lambda (dt) (funcall fun dt)) session-dates)
session-dates)))
;;; Public
(defvar pomidor-mode-map
(let ((map (make-keymap)))
(define-key map (kbd "q") #'quit-window)
(define-key map (kbd "Q") #'pomidor-quit)
(define-key map (kbd "R") #'pomidor-reset)
(define-key map (kbd "h") #'pomidor-hold)
(define-key map (kbd "H") #'pomidor-unhold)
(define-key map (kbd "RET") #'pomidor-stop)
(define-key map (kbd "SPC") #'pomidor-break)
(suppress-keymap map)
map))
(defun pomidor-work-duration ()
"Return current work duration."
(pomidor--work-duration (pomidor--current-state)))
(defun pomidor-overwork-duration ()
"Return current overwork duration."
(pomidor--overwork-duration (pomidor--current-state)))
(defun pomidor-break-duration ()
"Return current break duration."
(pomidor--break-duration (pomidor--current-state)))
(defun pomidor-total-duration ()
"Return current total duration."
(pomidor--total-duration (pomidor--current-state)))
(defun pomidor-quit ()
"Turn off Pomidor."
(interactive)
(when (y-or-n-p "Are you sure you want to turn off pomidor? ")
(kill-buffer (pomidor--get-buffer-create))))
(defun pomidor--reset-long-break-counter ()
"Reset the pomidor counter after `pomidor-breaks-before-long' short breaks."
(when (pomidor-should-long-break-p)
(setq pomidor--count-short-breaks 0)))
(defun pomidor-break ()
"Break current working pomidor."
(interactive)
(let ((state (pomidor--current-state)))
(if (pomidor--break state)
(progn
(plist-put state :snooze t)
(when (or (not pomidor-confirm-end-break)
(yes-or-no-p "Stop break and start new pomidor?"))
(pomidor-stop))
(pomidor--reset-long-break-counter))
(progn
(plist-put state :break (current-time))
(setq pomidor--count-short-breaks (1+ pomidor--count-short-breaks))))))
(defun pomidor-reset ()
"Delete current global state."
(interactive)
(when (y-or-n-p "Are you sure you want reset pomidors? ")
(setq pomidor--count-short-breaks 0)
(pomidor--reset)))
(defun pomidor-stop ()
"Stop current working pomidor."
(interactive)
(let ((state (pomidor--current-state)))
(plist-put state :stopped (current-time)))
(pomidor--reset-long-break-counter)
(nconc pomidor-global-state (list (pomidor--make-state))))
(defun pomidor-hold ()
"Stop the current working pomidor and puts the system on hold."
(interactive)
(let ((state (pomidor--current-state)))
(plist-put state :stopped (current-time)))
(setq pomidor--system-on-hold-p t)
(pomidor--cancel-timer))
(defun pomidor-unhold ()
"Unhold and start a new pomidor."
(interactive)
(when pomidor--system-on-hold-p
(nconc pomidor-global-state (list (pomidor--make-state)))
(setq pomidor--system-on-hold-p nil)
(setq pomidor-timer (run-at-time nil 1 #'pomidor--update))))
(defun pomidor-save-session ()
"Save the current session in a file."
(interactive)
(let ((time-asked-to-save (current-time)))
(pomidor-quit)
(plist-put (pomidor--current-state) :stopped time-asked-to-save)
(let* ((fmt-time (lambda (time) (when time (format-time-string pomidor-history-date-format time))))
(history-state (if (file-exists-p pomidor-save-session-file)
(pomidor--read-session :preserve-iso-timestamp)
(list)))
(global-state (-map (lambda (pomidor)
(list :started (funcall fmt-time (plist-get pomidor :started))
:break (funcall fmt-time (plist-get pomidor :break))
:stopped (funcall fmt-time (plist-get pomidor :stopped))
:snooze (plist-get pomidor :snooze)
:session-ended (funcall fmt-time time-asked-to-save)))
pomidor-global-state))
(new-history (append history-state global-state))
(new-history (-filter (lambda (pomidor) (or (plist-get pomidor :stopped)
(plist-get pomidor :break)
(plist-get pomidor :snooze)))
new-history)))
(with-temp-file pomidor-save-session-file
(insert (json-encode (vconcat new-history))))))
(message "Pomidor session saved!"))
(defun pomidor-history-previous ()
"Move backward in your pomidor history."
(interactive)
(let* ((session-data (pomidor--read-session nil))
(session-dates (-map (lambda (pomidor)
(plist-get pomidor :session-ended))
session-data)))
(if (= (length session-dates) 0)
(message "You have no session saved.")
(let* ((valid-session-dates (pomidor--valid-sessions-dates session-dates :backward)))
(if valid-session-dates
(progn
(setq pomidor--current-history-session (car (last valid-session-dates)))
(pomidor--render
(pomidor--get-history-buffer-create)
(-filter (lambda (pomidor)
(equal (car (last valid-session-dates))
(plist-get pomidor :session-ended)))
session-data)))
(message "History is over, go forward."))))))
(defun pomidor-history-next ()
"Move forward in your pomidor history."
(interactive)
(let* ((session-data (pomidor--read-session nil))
(session-dates (-map (lambda (pomidor)
(plist-get pomidor :session-ended))
session-data)))
(if (= (length session-dates) 0)
(message "You have no sessions saved.")
(let* ((valid-session-dates (pomidor--valid-sessions-dates session-dates :forward)))
(if valid-session-dates
(progn
(setq pomidor--current-history-session (car valid-session-dates))
(pomidor--render
(pomidor--get-history-buffer-create)
(-filter (lambda (pomidor)
(equal (car valid-session-dates)
(plist-get pomidor :session-ended)))
session-data)))
(message "History is over, go backward."))))))
(defun pomidor-history ()
"A simple pomodoro history feature. Compare your work over time."
(interactive)
(if (not (file-exists-p pomidor-save-session-file))
(message "You should save at least one session first.")
(switch-to-buffer (pomidor--get-history-buffer-create))
(unless (eq major-mode 'pomidor-history-mode)
(pomidor-history-mode))
(pomidor-history-previous)))
(defvar pomidor-history-mode-map
(let ((map (make-keymap)))
(define-key map (kbd "q") #'quit-window)
(define-key map (kbd "n") #'pomidor-history-next)
(define-key map (kbd "p") #'pomidor-history-previous)
(suppress-keymap map)
map))
(define-derived-mode pomidor-history-mode special-mode "pomidor-history"
"Major mode for Pomidor History.
\\{pomidor-history-mode-map}"
(setq pomidor-timer nil)
(setq pomidor--current-history-session nil))
(define-derived-mode pomidor-mode special-mode "pomidor"
"Major mode for Pomidor.
\\{pomidor-mode-map}"
(setq pomidor-timer (run-at-time nil 1 #'pomidor--update))
(setq-local tab-width 8)
(add-hook 'kill-buffer-hook #'pomidor--cancel-timer nil t)
(pomidor--reset))
;;;###autoload
(defun pomidor ()
"A simple and cool pomodoro technique timer."
(interactive)
(switch-to-buffer (pomidor--get-buffer-create))
(unless (eq major-mode 'pomidor-mode)
(setq pomidor--count-short-breaks 0)
(pomidor-mode))
(pomidor--update))
(provide 'pomidor)
;;; pomidor.el ends here

Binary file not shown.

Binary file not shown.

View file

@ -70,6 +70,7 @@
(load "~/.emacs.d.profiles/common/_global.el")
(load "~/.emacs.d.profiles/common/generic_functions.el")
(load "~/.emacs.d.profiles/common/workspaces.el")
(tool-bar-mode -1)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; compile bytecode for this profile
@ -328,6 +329,122 @@
(when kmn/is-termux
(load "~/.emacs.d.profiles/org/config-org-mobile.el"))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; pomidor
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package pomidor
:bind (("C-w P" . pomidor))
:config (setq pomidor-update-interval 30
pomidor-save-session-file "~/org/pomidor-sessions.json"
pomidor-alert nil
pomidor-sound-tick nil
pomidor-sound-tack nil
pomidor-sound-overwork nil
pomidor-sound-break-over nil)
:hook (pomidor-mode . (lambda ()
(display-line-numbers-mode -1) ; Emacs 26.1+
(setq left-fringe-width 0 right-fringe-width 0)
(setq left-margin-width 2 right-margin-width 0)
;; force fringe update
(set-window-buffer nil (current-buffer)))))
; setup 6 pomodoros for 8 hr work day
; 7 hours of work, with 1 hr of long breaks
; each pomodor is:
; warm up of 15 mins
; work of 45 mins
; total work period: 60 mins
; 10 min break
; total interval period: 70 mins
; long break is 30 mins
; every 3rd pomodoro give 30 minute break
(setq pomidor-seconds (* 60 60)) ; total work period
(setq pomidor-warmup-seconds (* 15 60)) ; warmup time
(setq pomidor-break-seconds (* 10 60))
(setq pomidor-breaks-before-long 3)
(setq pomidor-long-break-seconds (* 30 60))
; setup 'warmup period' functionality
(defun my-pomidor-update-hook ()
(let* ((state (pomidor--current-state))
(total (pomidor--total-duration state))
(ellapsed (round (time-to-seconds total))))
(if (<= ellapsed pomidor-warmup-seconds)
(setq pomidor-header-separator " 🌡️↑ ")
(setq pomidor-header-separator "")
)
)
)
(add-hook 'pomidor-update-hook #'my-pomidor-update-hook)
; position cursor @ top of pomidor buffer after rendering
(defun my-pomidor-beginning-of-buffer (buffer states)
(interactive)
(with-current-buffer (get-buffer pomidor-buffer-name)
(goto-char (point-min))
)
)
(advice-add #'pomidor--render :after #'my-pomidor-beginning-of-buffer)
; safely run pomidor in a buffer programatically
; doesnt mung or reset state
(defun my-pomidor-run-safe ()
; make sure pomidor is running + active w/o resetting the current state
(when (or (not (boundp 'pomidor-buffer-name))
(not (get-buffer pomidor-buffer-name)))
(pomidor)
(previous-buffer) ; pomidor switches buffers -- go back to orig buffer
)
)
; frame for pomidor, just the main timer text visible
; centered at bottom of the screen
(defun my-pomidor-frame ()
(interactive)
(select-frame (make-frame '(
(name . "Pomidor")
(menu-bar-lines 0)
(tool-bar-lines 0)
(width . (text-pixels . 818))
(height . (text-pixels . 144))
)))
; single monitor / main monitor positing
(let* ((dw (display-pixel-width))
(dh (display-pixel-height))
(f (selected-frame))
(fw (frame-pixel-width f))
(fh (frame-pixel-height f))
; handle multi-monitor goofy (main panel is /left/ of first panel)
; assumes a 1440p multi-monitor setup with monitor 1 'to the right of' monitor 2
; remove the (- [stuff] 2506) to undo this workaround
(x (- (- (/ dw 2) (/ fw 2)) 2560))
(y (- (- dh fh ) 100)))
(set-frame-position f x y)
)
; ensure pomidor is running & do /not/ reset state
(my-pomidor-run-safe)
; switch to pomidor buffer
(switch-to-buffer pomidor-buffer-name)
)
(global-set-key (kbd "C-M-p") 'my-pomidor-frame)
; pop win pomidor setup
; main way to invoke
; ensure pomidor is running before trying to open the buffer
; use global buffer name for pomidor
; make the popwin window 'sticky'
; position sticky popwin @ top
(push '(pomidor-mode :position top :stick t) popwin:special-display-config)
(global-set-key (kbd "C-w p")
(lambda () (interactive)
(my-pomidor-run-safe)
; open pomidor in popwin
(popwin:display-buffer (get-buffer pomidor-buffer-name))
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; origami + super agenda config
(defvar ap/org-super-agenda-auto-hide-groups
@ -372,7 +489,8 @@
'(custom-safe-themes
'("dde643b0efb339c0de5645a2bc2e8b4176976d5298065b8e6ca45bc4ddf188b7" "bfc0b9c3de0382e452a878a1fb4726e1302bf9da20e69d6ec1cd1d5d82f61e3d" default))
'(package-selected-packages
'((org-tidy org-auto-expand ox-pandoc ox-hugo org-super-agenda org-alert burnt-toast alert)
'(pomidor
(org-tidy org-auto-expand ox-pandoc ox-hugo org-super-agenda org-alert burnt-toast alert)
(devdocs devdocs-browser magit helm-ls-git xclip)
(which-key all-the-icons revert-buffer-all centaur-tabs scratch persistent-scratch persp-mode rainbow-mode rainbow-delimiters markdown-mode focus zoom popwin dired-single diredfl doominhibitinhibit-modeline helpful helm helm-org dired-rainbow dired-rainbow-listing dired-single dash s origami modus-themes use-package)))
'(safe-local-variable-values