code.delx.au - gnu-emacs/blob - lisp/calendar/timeclock.el

   1 ;;; timeclock.el --- mode for keeping track of how much you work
   2
   3 ;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
   4
   5 ;; Author: John Wiegley <johnw@gnu.org>
   6 ;; Created: 25 Mar 1999
   7 ;; Version: 2.6
   8 ;; Keywords: calendar data
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software; you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation; either version 2, or (at your option)
  15 ;; any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25 ;; Boston, MA 02111-1307, USA.
  26
  27 ;;; Commentary:
  28
  29 ;; This mode is for keeping track of time intervals.  You can use it
  30 ;; for whatever purpose you like, but the typical scenario is to keep
  31 ;; track of how much time you spend working on certain projects.
  32 ;;
  33 ;; Use `timeclock-in' when you start on a project, and `timeclock-out'
  34 ;; when you're done.  Once you've collected some data, you can use
  35 ;; `timeclock-workday-remaining' to see how much time is left to be
  36 ;; worked today (assuming a typical average of 8 hours a day), and
  37 ;; `timeclock-when-to-leave' which will calculate when you're free.
  38
  39 ;; You'll probably want to bind the timeclock commands to some handy
  40 ;; keystrokes.  At the moment, C-x t is unused in Emacs 20:
  41 ;;
  42 ;;   (require 'timeclock)
  43 ;;
  44 ;;   (define-key ctl-x-map "ti" 'timeclock-in)
  45 ;;   (define-key ctl-x-map "to" 'timeclock-out)
  46 ;;   (define-key ctl-x-map "tc" 'timeclock-change)
  47 ;;   (define-key ctl-x-map "tr" 'timeclock-reread-log)
  48 ;;   (define-key ctl-x-map "tu" 'timeclock-update-modeline)
  49 ;;   (define-key ctl-x-map "tw" 'timeclock-when-to-leave-string)
  50
  51 ;; If you want Emacs to display the amount of time "left" to your
  52 ;; workday in the modeline, you can either set the value of
  53 ;; `timeclock-modeline-display' to t using M-x customize, or you
  54 ;; can add this code to your .emacs file:
  55 ;;
  56 ;;   (require 'timeclock)
  57 ;;   (timeclock-modeline-display)
  58 ;;
  59 ;; To cancel this modeline display at any time, just call
  60 ;; `timeclock-modeline-display' again.
  61
  62 ;; You may also want Emacs to ask you before exiting, if you are
  63 ;; current working on a project.  This can be done either by setting
  64 ;; `timeclock-ask-before-exiting' to t using M-x customize (this is
  65 ;; the default), or by adding the following to your .emacs file:
  66 ;;
  67 ;;   (add-hook 'kill-emacs-hook 'timeclock-query-out)
  68
  69 ;; NOTE: If you change your .timelog file without using timeclock's
  70 ;; functions, or if you change the value of any of timeclock's
  71 ;; customizable variables, you should run the command
  72 ;; `timeclock-reread-log'.  This will recompute any discrepancies in
  73 ;; your average working time, and will make sure that the various
  74 ;; display functions return the correct value.
  75
  76 ;;; History:
  77
  78 ;;; Code:
  79
  80 (defgroup timeclock nil
  81   "Keeping track time of the time that gets spent."
  82   :group 'data)
  83
  84 ;;; User Variables:
  85
  86 (defcustom timeclock-file (convert-standard-filename "~/.timelog")
  87   "*The file used to store timeclock data in."
  88   :type 'file
  89   :group 'timeclock)
  90
  91 (defcustom timeclock-workday (* 8 60 60)
  92   "*The length of a work period."
  93   :type 'integer
  94   :group 'timeclock)
  95
  96 (defcustom timeclock-relative t
  97   "*When reporting time, make it relative to `timeclock-workday'?
  98 For example, if the length of a normal workday is eight hours, and you
  99 work four hours on Monday, then the amount of time \"remaining\" on
 100 Tuesday is twelve hours -- relative to an averaged work period of
 101 eight hours -- or eight hours, non-relative.  So relative time takes
 102 into account any discrepancy of time under-worked or overworked on
 103 previous days."
 104   :type 'boolean
 105   :group 'timeclock)
 106
 107 (defcustom timeclock-get-project-function 'timeclock-ask-for-project
 108   "*The function used to determine the name of the current project.
 109 When clocking in, and no project is specified, this function will be
 110 called to determine what the current project to be worked on is.
 111 If this variable is nil, no questions will be asked."
 112   :type 'function
 113   :group 'timeclock)
 114
 115 (defcustom timeclock-get-reason-function 'timeclock-ask-for-reason
 116   "*A function used to determine the reason for clocking out.
 117 When clocking out, and no reason is specified, this function will be
 118 called to determine what the reason is.
 119 If this variable is nil, no questions will be asked."
 120   :type 'function
 121   :group 'timeclock)
 122
 123 (defcustom timeclock-get-workday-function nil
 124   "*A function used to determine the length of today's workday.
 125 The first time that a user clocks in each day, this function will be
 126 called to determine what the length of the current workday is.  If
 127 nil, or equal to `timeclock-workday', nothing special will be done.
 128 If it is a quantity different from `timeclock-workday', however, a
 129 record will be output to the timelog file to note the fact that that
 130 day has a different length from the norm."
 131   :type '(choice (const nil) (function-item timeclock-workday) function)
 132   :group 'timeclock)
 133
 134 (defcustom timeclock-ask-before-exiting t
 135   "*If non-nil, ask if the user wants to clock out before exiting Emacs."
 136   :set (lambda (symbol value)
 137          (if value
 138              (add-hook 'kill-emacs-hook 'timeclock-query-out)
 139            (remove-hook 'kill-emacs-hook 'timeclock-query-out))
 140          (setq timeclock-ask-before-exiting value))
 141   :type 'boolean
 142   :group 'timeclock)
 143
 144 (defvar timeclock-update-timer nil
 145   "The timer used to update `timeclock-mode-string'.")
 146
 147 (defcustom timeclock-use-display-time t
 148   "*If non-nil, use `display-time-hook' for doing modeline updates.
 149 The advantage to this is that it means one less timer has to be set
 150 running amok in Emacs' process space.  The disadvantage is that it
 151 requires you to have `display-time' running.  If you don't want to use
 152 `display-time', but still want the modeline to show how much time is
 153 left, set this variable to nil.  You will need to restart Emacs (or
 154 toggle the value of `timeclock-modeline-display') for the change to
 155 take effect."
 156   :set (lambda (symbol value)
 157          (let ((currently-displaying
 158                 (and (boundp 'timeclock-modeline-display)
 159                      timeclock-modeline-display)))
 160            ;; if we're changing to the state that
 161            ;; `timeclock-modeline-display' is already using, don't
 162            ;; bother toggling it.  This happens on the initial loading
 163            ;; of timeclock.el.
 164            (if (and currently-displaying
 165                     (or (and value
 166                              (boundp 'display-time-hook)
 167                              (memq 'timeclock-update-modeline
 168                                    display-time-hook))
 169                         (and (not value)
 170                              timeclock-update-timer)))
 171                (setq currently-displaying nil))
 172            (and currently-displaying
 173                 (set-variable 'timeclock-modeline-display nil))
 174            (setq timeclock-use-display-time value)
 175            (and currently-displaying
 176                 (set-variable 'timeclock-modeline-display t))
 177            timeclock-use-display-time))
 178   :type 'boolean
 179   :group 'timeclock
 180   :require 'time)
 181
 182 (defcustom timeclock-first-in-hook nil
 183   "*A hook run for the first \"in\" event each day.
 184 Note that this hook is run before recording any events.  Thus the
 185 value of `timeclock-hours-today', `timeclock-last-event' and the
 186 return value of function `timeclock-last-period' are relative previous
 187 to today."
 188   :type 'hook
 189   :group 'timeclock)
 190
 191 (defcustom timeclock-load-hook nil
 192   "*Hook that gets run after timeclock has been loaded."
 193   :type 'hook
 194   :group 'timeclock)
 195
 196 (defcustom timeclock-in-hook nil
 197   "*A hook run every time an \"in\" event is recorded."
 198   :type 'hook
 199   :group 'timeclock)
 200
 201 (defcustom timeclock-day-over-hook nil
 202   "*A hook that is run when the workday has been completed.
 203 This hook is only run if the current time remaining is being display
 204 in the modeline.  See the variable `timeclock-modeline-display'."
 205   :type 'hook
 206   :group 'timeclock)
 207
 208 (defcustom timeclock-out-hook nil
 209   "*A hook run every time an \"out\" event is recorded."
 210   :type 'hook
 211   :group 'timeclock)
 212
 213 (defcustom timeclock-done-hook nil
 214   "*A hook run every time a project is marked as completed."
 215   :type 'hook
 216   :group 'timeclock)
 217
 218 (defcustom timeclock-event-hook nil
 219   "*A hook run every time any event is recorded."
 220   :type 'hook
 221   :group 'timeclock)
 222
 223 (defvar timeclock-last-event nil
 224   "A list containing the last event that was recorded.
 225 The format of this list is (CODE TIME PROJECT).")
 226
 227 (defvar timeclock-last-event-workday nil
 228   "The number of seconds in the workday of `timeclock-last-event'.")
 229
 230 ;;; Internal Variables:
 231
 232 (defvar timeclock-discrepancy nil
 233   "A variable containing the time discrepancy before the last event.
 234 Normally, timeclock assumes that you intend to work for
 235 `timeclock-workday' seconds every day.  Any days in which you work
 236 more or less than this amount is considered either a positive or
 237 negative discrepancy.  If you work in such a manner that the
 238 discrepancy is always brought back to zero, then you will by
 239 definition have worked an average amount equal to `timeclock-workday'
 240 each day.")
 241
 242 (defvar timeclock-elapsed nil
 243   "A variable containing the time elapsed for complete periods today.
 244 This value is not accurate enough to be useful by itself.  Rather,
 245 call `timeclock-workday-elapsed', to determine how much time has been
 246 worked so far today.  Also, if `timeclock-relative' is nil, this value
 247 will be the same as `timeclock-discrepancy'.")
 248
 249 (defvar timeclock-last-period nil
 250   "Integer representing the number of seconds in the last period.
 251 Note that you shouldn't access this value, but should use the function
 252 `timeclock-last-period' instead.")
 253
 254 (defvar timeclock-mode-string nil
 255   "The timeclock string (optionally) displayed in the modeline.")
 256
 257 (defvar timeclock-day-over nil
 258   "The date of the last day when notified \"day over\" for.")
 259
 260 ;;; User Functions:
 261
 262 ;;;###autoload
 263 (defun timeclock-modeline-display (&optional arg)
 264   "Toggle display of the amount of time left today in the modeline.
 265 If `timeclock-use-display-time' is non-nil, the modeline will be
 266 updated whenever the time display is updated.  Otherwise, the
 267 timeclock will use its own sixty second timer to do its updating.
 268 With prefix ARG, turn modeline display on if and only if ARG is
 269 positive.  Returns the new status of timeclock modeline display
 270 \(non-nil means on)."
 271   (interactive "P")
 272   (let ((on-p (if arg
 273                   (> (prefix-numeric-value arg) 0)
 274                 (not timeclock-modeline-display))))
 275     (if on-p
 276         (let ((list-entry (memq 'global-mode-string
 277                                 mode-line-format)))
 278           (unless (or (null list-entry)
 279                       (memq 'timeclock-mode-string mode-line-format))
 280             (setcdr list-entry
 281                     (cons 'timeclock-mode-string
 282                           (cdr list-entry))))
 283           (unless (memq 'timeclock-update-modeline timeclock-event-hook)
 284             (add-hook 'timeclock-event-hook 'timeclock-update-modeline))
 285           (when timeclock-update-timer
 286             (cancel-timer timeclock-update-timer)
 287             (setq timeclock-update-timer nil))
 288           (if (boundp 'display-time-hook)
 289               (remove-hook 'display-time-hook 'timeclock-update-modeline))
 290           (if timeclock-use-display-time
 291               (add-hook 'display-time-hook 'timeclock-update-modeline)
 292             (setq timeclock-update-timer
 293                   (run-at-time nil 60 'timeclock-update-modeline))))
 294       (setq mode-line-format
 295             (delq 'timeclock-mode-string mode-line-format))
 296       (remove-hook 'timeclock-event-hook 'timeclock-update-modeline)
 297       (if (boundp 'display-time-hook)
 298           (remove-hook 'display-time-hook
 299                        'timeclock-update-modeline))
 300       (when timeclock-update-timer
 301         (cancel-timer timeclock-update-timer)
 302         (setq timeclock-update-timer nil)))
 303     (force-mode-line-update)
 304     on-p))
 305
 306 ;; This has to be here so that the function definition of
 307 ;; `timeclock-modeline-display' is known to the "set" function.
 308 (defcustom timeclock-modeline-display nil
 309   "Toggle modeline display of time remaining.
 310 You must modify via \\[customize] for this variable to have an effect."
 311   :set (lambda (symbol value)
 312          (setq timeclock-modeline-display
 313                (timeclock-modeline-display (or value 0))))
 314   :type 'boolean
 315   :group 'timeclock
 316   :require 'timeclock)
 317
 318 ;;;###autoload
 319 (defun timeclock-in (&optional arg project find-project)
 320   "Clock in, recording the current time moment in the timelog.
 321 With a numeric prefix ARG, record the fact that today has only that
 322 many hours in it to be worked.  If arg is a non-numeric prefix arg
 323 \(non-nil, but not a number), 0 is assumed (working on a holiday or
 324 weekend).  *If not called interactively, ARG should be the number of
 325 _seconds_ worked today*.  This feature only has effect the first time
 326 this function is called within a day.
 327
 328 PROJECT as the project being clocked into.  If PROJECT is nil, and
 329 FIND-PROJECT is non-nil -- or the user calls `timeclock-in'
 330 interactively -- call the function `timeclock-get-project-function' to
 331 discover the name of the project."
 332   (interactive
 333    (list (and current-prefix-arg
 334               (if (numberp current-prefix-arg)
 335                   (* current-prefix-arg 60 60)
 336                 0))))
 337   (if (equal (car timeclock-last-event) "i")
 338       (error "You've already clocked in!")
 339     (unless timeclock-last-event
 340       (timeclock-reread-log))
 341     (unless (equal (timeclock-time-to-date
 342                     (cadr timeclock-last-event))
 343                    (timeclock-time-to-date (current-time)))
 344       (let ((workday (or (and (numberp arg) arg)
 345                          (and arg 0)
 346                          (and timeclock-get-workday-function
 347                               (funcall timeclock-get-workday-function))
 348                          timeclock-workday)))
 349         (run-hooks 'timeclock-first-in-hook)
 350         ;; settle the discrepancy for the new day
 351         (setq timeclock-discrepancy
 352               (- timeclock-discrepancy workday))
 353         (if (not (= workday timeclock-workday))
 354             (timeclock-log "h" (and (numberp arg)
 355                                     (number-to-string arg))))))
 356     (timeclock-log "i" (or project
 357                            (and timeclock-get-project-function
 358                                 (or find-project (interactive-p))
 359                                 (funcall timeclock-get-project-function))))
 360     (run-hooks 'timeclock-in-hook)))
 361
 362 ;;;###autoload
 363 (defun timeclock-out (&optional arg reason find-reason)
 364   "Clock out, recording the current time moment in the timelog.
 365 If a prefix ARG is given, the user has completed the project that was
 366 begun during the last time segment.
 367
 368 REASON is the user's reason for clocking out.  If REASON is nil, and
 369 FIND-REASON is non-nil -- or the user calls `timeclock-out'
 370 interactively -- call the function `timeclock-get-reason-function' to
 371 discover the reason."
 372   (interactive "P")
 373   (or timeclock-last-event
 374       (error "You haven't clocked in!"))
 375   (if (equal (downcase (car timeclock-last-event)) "o")
 376       (error "You've already clocked out!")
 377     (timeclock-log
 378      (if arg "O" "o")
 379      (or reason
 380          (and timeclock-get-reason-function
 381               (or find-reason (interactive-p))
 382               (funcall timeclock-get-reason-function))))
 383     (run-hooks 'timeclock-out-hook)
 384     (if arg
 385         (run-hooks 'timeclock-done-hook))))
 386
 387 ;;;###autoload
 388 (defun timeclock-status-string (&optional show-seconds today-only)
 389   "Report the overall timeclock status at the present moment."
 390   (interactive "P")
 391   (let* ((remainder (timeclock-workday-remaining))
 392          (last-in (equal (car timeclock-last-event) "i"))
 393          status)
 394     (setq status
 395           (format "Currently %s since %s (%s), %s %s, leave at %s"
 396                   (if last-in "IN" "OUT")
 397                   (if show-seconds
 398                       (format-time-string "%-I:%M:%S %p"
 399                                           (nth 1 timeclock-last-event))
 400                     (format-time-string "%-I:%M %p"
 401                                         (nth 1 timeclock-last-event)))
 402                   (or (nth 2 timeclock-last-event)
 403                       (if last-in "**UNKNOWN**" "workday over"))
 404                   (timeclock-seconds-to-string remainder show-seconds t)
 405                   (if (> remainder 0)
 406                       "remaining" "over")
 407                   (timeclock-when-to-leave-string show-seconds today-only)))
 408     (if (interactive-p)
 409         (message status)
 410       status)))
 411
 412 ;;;###autoload
 413 (defun timeclock-change (&optional arg project)
 414   "Change to working on a different project, by clocking in then out.
 415 With a prefix ARG, consider the previous project as having been
 416 finished at the time of changeover.  PROJECT is the name of the last
 417 project you were working on."
 418   (interactive "P")
 419   (timeclock-out arg)
 420   (timeclock-in nil project (interactive-p)))
 421
 422 ;;;###autoload
 423 (defun timeclock-query-out ()
 424   "Ask the user before clocking out.
 425 This is a useful function for adding to `kill-emacs-hook'."
 426   (if (and (equal (car timeclock-last-event) "i")
 427            (y-or-n-p "You're currently clocking time, clock out? "))
 428       (timeclock-out)))
 429
 430 ;;;###autoload
 431 (defun timeclock-reread-log ()
 432   "Re-read the timeclock, to account for external changes.
 433 Returns the new value of `timeclock-discrepancy'."
 434   (interactive)
 435   (setq timeclock-discrepancy nil)
 436   (timeclock-find-discrep)
 437   (if (and timeclock-discrepancy timeclock-modeline-display)
 438       (timeclock-update-modeline))
 439   timeclock-discrepancy)
 440
 441 (defun timeclock-seconds-to-string (seconds &optional show-seconds
 442                                             reverse-leader)
 443   "Convert SECONDS into a compact time string.
 444 If SHOW-SECONDS is non-nil, make the resolution of the return string
 445 include the second count.  If REVERSE-LEADER is non-nil, it means to
 446 output a \"+\" if the time value is negative, rather than a \"-\".
 447 This is used when negative time values have an inverted meaning (such
 448 as with time remaining, where negative time really means overtime)."
 449   (if show-seconds
 450       (format "%s%d:%02d:%02d"
 451               (if (< seconds 0) (if reverse-leader "+" "-") "")
 452               (truncate (/ (abs seconds) 60 60))
 453               (% (truncate (/ (abs seconds) 60)) 60)
 454               (% (truncate (abs seconds)) 60))
 455     (format "%s%d:%02d"
 456             (if (< seconds 0) (if reverse-leader "+" "-") "")
 457             (truncate (/ (abs seconds) 60 60))
 458             (% (truncate (/ (abs seconds) 60)) 60))))
 459
 460 (defsubst timeclock-workday-remaining (&optional today-only)
 461   "Return the number of seconds until the workday is complete.
 462 The amount returned is relative to the value of `timeclock-workday'.
 463 If TODAY-ONLY is non-nil, the value returned will be relative only to
 464 the time worked today, and not to past time.  This argument only makes
 465 a difference if `timeclock-relative' is non-nil."
 466   (let ((discrep (timeclock-find-discrep)))
 467     (if discrep
 468         (if today-only
 469             (- (cadr discrep))
 470           (- (car discrep)))
 471       0.0)))
 472
 473 (defsubst timeclock-currently-in-p ()
 474   "Return non-nil if the user is currently clocked in."
 475   (equal (car timeclock-last-event) "i"))
 476
 477 ;;;###autoload
 478 (defun timeclock-workday-remaining-string (&optional show-seconds
 479                                                      today-only)
 480   "Return a string representing the amount of time left today.
 481 Display second resolution if SHOW-SECONDS is non-nil.  If TODAY-ONLY
 482 is non-nil, the display will be relative only to time worked today.
 483 See `timeclock-relative' for more information about the meaning of
 484 \"relative to today\"."
 485   (interactive)
 486   (let ((string (timeclock-seconds-to-string
 487                  (timeclock-workday-remaining today-only)
 488                  show-seconds t)))
 489     (if (interactive-p)
 490         (message string)
 491       string)))
 492
 493 (defsubst timeclock-workday-elapsed ()
 494   "Return the number of seconds worked so far today.
 495 If RELATIVE is non-nil, the amount returned will be relative to past
 496 time worked.  The default is to return only the time that has elapsed
 497 so far today."
 498   (let ((discrep (timeclock-find-discrep)))
 499     (if discrep
 500         (nth 2 discrep)
 501       0.0)))
 502
 503 ;;;###autoload
 504 (defun timeclock-workday-elapsed-string (&optional show-seconds)
 505   "Return a string representing the amount of time worked today.
 506 Display seconds resolution if SHOW-SECONDS is non-nil.  If RELATIVE is
 507 non-nil, the amount returned will be relative to past time worked."
 508   (interactive)
 509   (let ((string (timeclock-seconds-to-string (timeclock-workday-elapsed)
 510                                              show-seconds)))
 511     (if (interactive-p)
 512         (message string)
 513       string)))
 514
 515 (defsubst timeclock-when-to-leave (&optional today-only)
 516   "Return a time value representing at when the workday ends today.
 517 If TODAY-ONLY is non-nil, the value returned will be relative only to
 518 the time worked today, and not to past time.  This argument only makes
 519 a difference if `timeclock-relative' is non-nil."
 520   (timeclock-seconds-to-time
 521    (- (timeclock-time-to-seconds (current-time))
 522       (let ((discrep (timeclock-find-discrep)))
 523         (if discrep
 524             (if today-only
 525                 (cadr discrep)
 526               (car discrep))
 527           0.0)))))
 528
 529 ;;;###autoload
 530 (defun timeclock-when-to-leave-string (&optional show-seconds
 531                                                  today-only)
 532   "Return a string representing at what time the workday ends today.
 533 This string is relative to the value of `timeclock-workday'.  If
 534 NO-MESSAGE is non-nil, no messages will be displayed in the
 535 minibuffer.  If SHOW-SECONDS is non-nil, the value printed/returned
 536 will include seconds.  If TODAY-ONLY is non-nil, the value returned
 537 will be relative only to the time worked today, and not to past time.
 538 This argument only makes a difference if `timeclock-relative' is
 539 non-nil."
 540   (interactive)
 541   (let* ((then (timeclock-when-to-leave today-only))
 542          (string
 543           (if show-seconds
 544               (format-time-string "%-I:%M:%S %p" then)
 545             (format-time-string "%-I:%M %p" then))))
 546     (if (interactive-p)
 547         (message string)
 548       string)))
 549
 550 ;;; Internal Functions:
 551
 552 (defvar timeclock-project-list nil)
 553 (defvar timeclock-last-project nil)
 554
 555 (defun timeclock-completing-read (prompt alist &optional default)
 556   "A version of `completing-read' that works on both Emacs and XEmacs."
 557   (if (featurep 'xemacs)
 558       (let ((str (completing-read prompt alist)))
 559         (if (or (null str) (= (length str) 0))
 560             default
 561           str))
 562     (completing-read prompt alist nil nil nil nil default)))
 563
 564 (defun timeclock-ask-for-project ()
 565   "Ask the user for the project they are clocking into."
 566   (timeclock-completing-read
 567    (format "Clock into which project (default \"%s\"): "
 568            (or timeclock-last-project
 569                (car timeclock-project-list)))
 570    (mapcar 'list timeclock-project-list)
 571    (or timeclock-last-project
 572        (car timeclock-project-list))))
 573
 574 (defvar timeclock-reason-list nil)
 575
 576 (defun timeclock-ask-for-reason ()
 577   "Ask the user for the reason they are clocking out."
 578   (timeclock-completing-read "Reason for clocking out: "
 579                              (mapcar 'list timeclock-reason-list)))
 580
 581 (defun timeclock-update-modeline ()
 582   "Update the `timeclock-mode-string' displayed in the modeline."
 583   (interactive)
 584   (let* ((remainder (timeclock-workday-remaining))
 585          (last-in (equal (car timeclock-last-event) "i")))
 586     (when (and (< remainder 0)
 587                (not (and timeclock-day-over
 588                          (equal timeclock-day-over
 589                                 (timeclock-time-to-date
 590                                  (current-time))))))
 591       (setq timeclock-day-over
 592             (timeclock-time-to-date (current-time)))
 593       (run-hooks 'timeclock-day-over-hook))
 594     (setq timeclock-mode-string
 595           (format "   %c%s%c"
 596                   (if last-in ?< ?[)
 597                   (timeclock-seconds-to-string remainder nil t)
 598                   (if last-in ?> ?])))))
 599
 600 (defun timeclock-log (code &optional project)
 601   "Log the event CODE to the timeclock log, at the time of call.
 602 If PROJECT is a string, it represents the project which the event is
 603 being logged for.  Normally only \"in\" events specify a project."
 604   (with-current-buffer (find-file-noselect timeclock-file)
 605     (goto-char (point-max))
 606     (if (not (bolp))
 607         (insert "\n"))
 608     (let ((now (current-time)))
 609       (insert code " "
 610               (format-time-string "%Y/%m/%d %H:%M:%S" now)
 611               (or (and project
 612                        (stringp project)
 613                        (> (length project) 0)
 614                        (concat " " project))
 615                   "")
 616               "\n")
 617       (if (equal (downcase code) "o")
 618           (setq timeclock-last-period
 619                 (- (timeclock-time-to-seconds now)
 620                    (timeclock-time-to-seconds
 621                     (cadr timeclock-last-event)))
 622                 timeclock-discrepancy
 623                 (+ timeclock-discrepancy
 624                    timeclock-last-period)))
 625       (setq timeclock-last-event (list code now project)))
 626     (save-buffer)
 627     (run-hooks 'timeclock-event-hook)
 628     (kill-buffer (current-buffer))))
 629
 630 (defvar timeclock-moment-regexp
 631   (concat "\\([bhioO]\\)\\s-+"
 632           "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)\\s-+"
 633           "\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\)[ \t]*" "\\([^\n]*\\)"))
 634
 635 (defsubst timeclock-read-moment ()
 636   "Read the moment under point from the timelog."
 637   (if (looking-at timeclock-moment-regexp)
 638       (let ((code (match-string 1))
 639             (year (string-to-number (match-string 2)))
 640             (mon  (string-to-number (match-string 3)))
 641             (mday (string-to-number (match-string 4)))
 642             (hour (string-to-number (match-string 5)))
 643             (min  (string-to-number (match-string 6)))
 644             (sec  (string-to-number (match-string 7)))
 645             (project (match-string 8)))
 646         (list code (encode-time sec min hour mday mon year) project))))
 647
 648 (defsubst timeclock-time-to-seconds (time)
 649   "Convert TIME to a floating point number."
 650   (+ (* (car time) 65536.0)
 651      (cadr time)
 652      (/ (or (car (cdr (cdr time))) 0) 1000000.0)))
 653
 654 (defsubst timeclock-seconds-to-time (seconds)
 655   "Convert SECONDS (a floating point number) to an Emacs time structure."
 656   (list (floor seconds 65536)
 657         (floor (mod seconds 65536))
 658         (floor (* (- seconds (ffloor seconds)) 1000000))))
 659
 660 (defsubst timeclock-time-to-date (time)
 661   "Convert the TIME value to a textual date string."
 662   (format-time-string "%Y/%m/%d" time))
 663
 664 (defun timeclock-last-period (&optional moment)
 665   "Return the value of the last event period.
 666 If the last event was a clock-in, the period will be open ended, and
 667 growing every second.  Otherwise, it is a fixed amount which has been
 668 recorded to disk.  If MOMENT is non-nil, use that as the current time.
 669 This is only provided for coherency when used by
 670 `timeclock-discrepancy'."
 671   (if (equal (car timeclock-last-event) "i")
 672       (- (timeclock-time-to-seconds (or moment (current-time)))
 673          (timeclock-time-to-seconds
 674           (cadr timeclock-last-event)))
 675     timeclock-last-period))
 676
 677 (defsubst timeclock-entry-length (entry)
 678   (- (timeclock-time-to-seconds (cadr entry))
 679      (timeclock-time-to-seconds (car entry))))
 680
 681 (defsubst timeclock-entry-begin (entry)
 682   (car entry))
 683
 684 (defsubst timeclock-entry-end (entry)
 685   (cadr entry))
 686
 687 (defsubst timeclock-entry-project (entry)
 688   (nth 2 entry))
 689
 690 (defsubst timeclock-entry-comment (entry)
 691   (nth 3 entry))
 692
 693
 694 (defsubst timeclock-entry-list-length (entry-list)
 695   (let ((length 0))
 696     (while entry-list
 697       (setq length (+ length (timeclock-entry-length (car entry-list))))
 698       (setq entry-list (cdr entry-list)))
 699     length))
 700
 701 (defsubst timeclock-entry-list-begin (entry-list)
 702   (timeclock-entry-begin (car entry-list)))
 703
 704 (defsubst timeclock-entry-list-end (entry-list)
 705   (timeclock-entry-end (car (last entry-list))))
 706
 707 (defsubst timeclock-entry-list-span (entry-list)
 708   (- (timeclock-time-to-seconds (timeclock-entry-list-end entry-list))
 709      (timeclock-time-to-seconds (timeclock-entry-list-begin entry-list))))
 710
 711 (defsubst timeclock-entry-list-break (entry-list)
 712   (- (timeclock-entry-list-span entry-list)
 713      (timeclock-entry-list-length entry-list)))
 714
 715 (defsubst timeclock-entry-list-projects (entry-list)
 716   (let (projects)
 717     (while entry-list
 718       (let ((project (timeclock-entry-project (car entry-list))))
 719         (if projects
 720             (add-to-list 'projects project)
 721           (setq projects (list project))))
 722       (setq entry-list (cdr entry-list)))
 723     projects))
 724
 725
 726 (defsubst timeclock-day-required (day)
 727   (or (car day) timeclock-workday))
 728
 729 (defsubst timeclock-day-length (day)
 730   (timeclock-entry-list-length (cdr day)))
 731
 732 (defsubst timeclock-day-debt (day)
 733   (- (timeclock-day-required day)
 734      (timeclock-day-length day)))
 735
 736 (defsubst timeclock-day-begin (day)
 737   (timeclock-entry-list-begin (cdr day)))
 738
 739 (defsubst timeclock-day-end (day)
 740   (timeclock-entry-list-end (cdr day)))
 741
 742 (defsubst timeclock-day-span (day)
 743   (timeclock-entry-list-span (cdr day)))
 744
 745 (defsubst timeclock-day-break (day)
 746   (timeclock-entry-list-break (cdr day)))
 747
 748 (defsubst timeclock-day-projects (day)
 749   (timeclock-entry-list-projects (cdr day)))
 750
 751 (defmacro timeclock-day-list-template (func)
 752   `(let ((length 0))
 753      (while day-list
 754        (setq length (+ length (,(eval func) (car day-list))))
 755        (setq day-list (cdr day-list)))
 756      length))
 757
 758 (defun timeclock-day-list-required (day-list)
 759   (timeclock-day-list-template 'timeclock-day-required))
 760
 761 (defun timeclock-day-list-length (day-list)
 762   (timeclock-day-list-template 'timeclock-day-length))
 763
 764 (defun timeclock-day-list-debt (day-list)
 765   (timeclock-day-list-template 'timeclock-day-debt))
 766
 767 (defsubst timeclock-day-list-begin (day-list)
 768   (timeclock-day-begin (car day-list)))
 769
 770 (defsubst timeclock-day-list-end (day-list)
 771   (timeclock-day-end (car (last day-list))))
 772
 773 (defun timeclock-day-list-span (day-list)
 774   (timeclock-day-list-template 'timeclock-day-span))
 775
 776 (defun timeclock-day-list-break (day-list)
 777   (timeclock-day-list-template 'timeclock-day-break))
 778
 779 (defun timeclock-day-list-projects (day-list)
 780   (let (projects)
 781     (while day-list
 782       (let ((projs (timeclock-day-projects (car day-list))))
 783         (while projs
 784           (if projects
 785               (add-to-list 'projects (car projs))
 786             (setq projects (list (car projs))))
 787           (setq projs (cdr projs))))
 788       (setq day-list (cdr day-list)))
 789     projects))
 790
 791
 792 (defsubst timeclock-current-debt (&optional log-data)
 793   (nth 0 (or log-data (timeclock-log-data))))
 794
 795 (defsubst timeclock-day-alist (&optional log-data)
 796   (nth 1 (or log-data (timeclock-log-data))))
 797
 798 (defun timeclock-day-list (&optional log-data)
 799   (let ((alist (timeclock-day-alist log-data))
 800         day-list)
 801     (while alist
 802       (setq day-list (cons (cdar alist) day-list)
 803             alist (cdr alist)))
 804     day-list))
 805
 806 (defsubst timeclock-project-alist (&optional log-data)
 807   (nth 2 (or log-data (timeclock-log-data))))
 808
 809
 810 (defun timeclock-log-data (&optional recent-only filename)
 811   "Return the contents of the timelog file, in a useful format.
 812 A timelog contains data in the form of a single entry per line.
 813 Each entry has the form:
 814
 815   CODE YYYY/MM/DD HH:MM:SS [COMMENT]
 816
 817 CODE is one of: b, h, i, o or O.  COMMENT is optional when the code is
 818 i, o or O.  The meanings of the codes are:
 819
 820   b  Set the current time balance, or \"time debt\".  Useful when
 821      archiving old log data, when a debt must be carried forward.
 822      The COMMENT here is the number of seconds of debt.
 823
 824   h  Set the required working time for the given day.  This must
 825      be the first entry for that day.  The COMMENT in this case is
 826      the number of hours that must be worked.  Floating point
 827      amounts are allowed.
 828
 829   i  Clock in.  The COMMENT in this case should be the name of the
 830      project worked on.
 831
 832   o  Clock out.  COMMENT is unnecessary, but can be used to provide
 833      a description of how the period went, for example.
 834
 835   O  Final clock out.  Whatever project was being worked on, it is
 836      now finished.  Useful for creating summary reports.
 837
 838 When this function is called, it will return a data structure with the
 839 following format:
 840
 841   (DEBT ENTRIES-BY-DAY ENTRIES-BY-PROJECT)
 842
 843 DEBT is a floating point number representing the number of seconds
 844 \"owed\" before any work was done.  For a new file (one without a 'b'
 845 entry), this is always zero.
 846
 847 The two entries lists have similar formats.  They are both alists,
 848 where the CAR is the index, and the CDR is a list of time entries.
 849 For ENTRIES-BY-DAY, the CAR is a textual date string, of the form
 850 YYYY/MM/DD.  For ENTRIES-BY-PROJECT, it is the name of the project
 851 worked on, or t for the default project.
 852
 853 The CDR for ENTRIES-BY-DAY is slightly different than for
 854 ENTRIES-BY-PROJECT.  It has the following form:
 855
 856   (DAY-LENGTH TIME-ENTRIES...)
 857
 858 For ENTRIES-BY-PROJECT, there is no DAY-LENGTH member.  It is simply a
 859 list of TIME-ENTRIES.  Note that if DAY-LENGTH is nil, it means
 860 whatever is the default should be used.
 861
 862 A TIME-ENTRY is a recorded time interval.  It has the following format
 863 \(although generally one does not have to manipulate these entries
 864 directly; see below):
 865
 866   (BEGIN-TIME END-TIME PROJECT [COMMENT] [FINAL-P])
 867
 868 Anyway, suffice it to say there are a lot of structures.  Typically
 869 the user is expected to manipulate to the day(s) or project(s) that he
 870 or she wants, at which point the following helper functions may be
 871 used:
 872
 873   timeclock-day-required
 874   timeclock-day-length
 875   timeclock-day-debt
 876   timeclock-day-begin
 877   timeclock-day-end
 878   timeclock-day-span
 879   timeclock-day-break
 880   timeclock-day-projects
 881
 882   timeclock-day-list-required
 883   timeclock-day-list-length
 884   timeclock-day-list-debt
 885   timeclock-day-list-begin
 886   timeclock-day-list-end
 887   timeclock-day-list-span
 888   timeclock-day-list-break
 889   timeclock-day-list-projects
 890
 891   timeclock-entry-length
 892   timeclock-entry-begin
 893   timeclock-entry-end
 894   timeclock-entry-project
 895   timeclock-entry-comment
 896
 897   timeclock-entry-list-length
 898   timeclock-entry-list-begin
 899   timeclock-entry-list-end
 900   timeclock-entry-list-span
 901   timeclock-entry-list-break
 902   timeclock-entry-list-projects
 903
 904 A few comments should make the use of the above functions obvious:
 905
 906   `required' is the amount of time that must be spent during a day, or
 907   sequence of days, in order to have no debt.
 908
 909   `length' is the actual amount of time that was spent.
 910
 911   `debt' is the difference between required time and length.  A
 912   negative debt signifies overtime.
 913
 914   `begin' is the earliest moment at which work began.
 915
 916   `end' is the final moment work was done.
 917
 918   `span' is the difference between begin and end.
 919
 920   `break' is the difference between span and length.
 921
 922   `project' is the project that was worked on, and `projects' is a
 923   list of all the projects that were worked on during a given period.
 924
 925   `comment', where it applies, could mean anything.
 926
 927 There are a few more functions available, for locating day and entry
 928 lists:
 929
 930   timeclock-day-alist LOG-DATA
 931   timeclock-project-alist LOG-DATA
 932   timeclock-current-debt LOG-DATA
 933
 934 See the documentation for the given function if more info is needed."
 935   (let* ((log-data (list 0.0 nil nil))
 936          (now (current-time))
 937          (todays-date (timeclock-time-to-date now))
 938          last-date-limited last-date-seconds last-date
 939          (line 0) last beg day entry event)
 940     (with-temp-buffer
 941       (insert-file-contents (or filename timeclock-file))
 942       (when recent-only
 943         (goto-char (point-max))
 944         (unless (re-search-backward "^b\\s-+" nil t)
 945           (goto-char (point-min))))
 946       (while (or (setq event (timeclock-read-moment))
 947                  (and beg (not last)
 948                       (setq last t event (list "o" now))))
 949         (setq line (1+ line))
 950         (cond ((equal (car event) "b")
 951                (setcar log-data (string-to-number (nth 2 event))))
 952               ((equal (car event) "h")
 953                (setq last-date-limited (timeclock-time-to-date (cadr event))
 954                      last-date-seconds (* (string-to-number (nth 2 event))
 955                                           3600.0)))
 956               ((equal (car event) "i")
 957                (if beg
 958                    (error "Error in format of timelog file, line %d" line)
 959                  (setq beg t))
 960                (setq entry (list (cadr event) nil
 961                                  (and (> (length (nth 2 event)) 0)
 962                                       (nth 2 event))))
 963                (let ((date (timeclock-time-to-date (cadr event))))
 964                  (if (and last-date
 965                           (not (equal date last-date)))
 966                      (progn
 967                        (setcar (cdr log-data)
 968                                (cons (cons last-date day)
 969                                      (cadr log-data)))
 970                        (setq day (list (and last-date-limited
 971                                             last-date-seconds))))
 972                    (unless day
 973                      (setq day (list (and last-date-limited
 974                                           last-date-seconds)))))
 975                  (setq last-date date
 976                        last-date-limited nil)))
 977               ((equal (downcase (car event)) "o")
 978                (if (not beg)
 979                    (error "Error in format of timelog file, line %d" line)
 980                  (setq beg nil))
 981                (setcar (cdr entry) (cadr event))
 982                (let ((desc (and (> (length (nth 2 event)) 0)
 983                                 (nth 2 event))))
 984                  (if desc
 985                      (nconc entry (list (nth 2 event))))
 986                  (if (equal (car event) "O")
 987                      (nconc entry (if desc
 988                                       (list t)
 989                                     (list nil t))))
 990                  (nconc day (list entry))
 991                  (setq desc (nth 2 entry))
 992                  (let ((proj (assoc desc (nth 2 log-data))))
 993                    (if (null proj)
 994                        (setcar (cddr log-data)
 995                                (cons (cons desc (list entry))
 996                                      (car (cddr log-data))))
 997                      (nconc (cdr proj) (list entry)))))))
 998         (forward-line))
 999       (if day
1000           (setcar (cdr log-data)
1001                   (cons (cons last-date day)
1002                         (cadr log-data))))
1003       log-data)))
1004
1005 (defun timeclock-find-discrep ()
1006   "Find overall discrepancy from `timeclock-workday' (in seconds)."
1007   ;; This is not implemented in terms of the functions above, because
1008   ;; it's a bit wasteful to read all of that data in, just to throw
1009   ;; away more than 90% of the information afterwards.
1010   ;;
1011   ;; If it were implemented using those functions, it would look
1012   ;; something like this:
1013   ;;  (let ((days (timeclock-day-alist (timeclock-log-data)))
1014   ;;        (total 0.0))
1015   ;;    (while days
1016   ;;      (setq total (+ total (- (timeclock-day-length (cdar days))
1017   ;;                              (timeclock-day-required (cdar days))))
1018   ;;            days (cdr days)))
1019   ;;    total)
1020   (let* ((now (current-time))
1021          (todays-date (timeclock-time-to-date now))
1022          (first t) (accum 0) (elapsed 0)
1023          event beg last-date avg
1024          last-date-limited last-date-seconds)
1025     (unless timeclock-discrepancy
1026       (when (file-readable-p timeclock-file)
1027         (setq timeclock-project-list nil
1028               timeclock-last-project nil
1029               timeclock-reason-list nil
1030               timeclock-elapsed 0)
1031         (with-temp-buffer
1032           (insert-file-contents timeclock-file)
1033           (goto-char (point-max))
1034           (unless (re-search-backward "^b\\s-+" nil t)
1035             (goto-char (point-min)))
1036           (while (setq event (timeclock-read-moment))
1037             (cond ((equal (car event) "b")
1038                    (setq accum (string-to-number (nth 2 event))))
1039                   ((equal (car event) "h")
1040                    (setq last-date-limited
1041                          (timeclock-time-to-date (cadr event))
1042                          last-date-seconds
1043                          (* (string-to-number (nth 2 event)) 3600.0)))
1044                   ((equal (car event) "i")
1045                    (when (and (nth 2 event)
1046                               (> (length (nth 2 event)) 0))
1047                      (add-to-list 'timeclock-project-list (nth 2 event))
1048                      (setq timeclock-last-project (nth 2 event)))
1049                    (let ((date (timeclock-time-to-date (cadr event))))
1050                      (if (if last-date
1051                              (not (equal date last-date))
1052                            first)
1053                          (setq first nil
1054                                accum (- accum (if last-date-limited
1055                                                   last-date-seconds
1056                                                 timeclock-workday))))
1057                      (setq last-date date
1058                            last-date-limited nil)
1059                      (if beg
1060                          (error "Error in format of timelog file!")
1061                        (setq beg (timeclock-time-to-seconds (cadr event))))))
1062                   ((equal (downcase (car event)) "o")
1063                    (if (and (nth 2 event)
1064                             (> (length (nth 2 event)) 0))
1065                        (add-to-list 'timeclock-reason-list (nth 2 event)))
1066                    (if (not beg)
1067                        (error "Error in format of timelog file!")
1068                      (setq timeclock-last-period
1069                            (- (timeclock-time-to-seconds (cadr event)) beg)
1070                            accum (+ timeclock-last-period accum)
1071                            beg nil))
1072                    (if (equal last-date todays-date)
1073                        (setq timeclock-elapsed
1074                              (+ timeclock-last-period timeclock-elapsed)))))
1075             (setq timeclock-last-event event
1076                   timeclock-last-event-workday
1077                   (if (equal (timeclock-time-to-date now) last-date-limited)
1078                       last-date-seconds
1079                     timeclock-workday))
1080             (forward-line))
1081           (setq timeclock-discrepancy accum))))
1082     (unless timeclock-last-event-workday
1083       (setq timeclock-last-event-workday timeclock-workday))
1084     (setq accum timeclock-discrepancy
1085           elapsed (or timeclock-elapsed elapsed))
1086     (if timeclock-last-event
1087         (if (equal (car timeclock-last-event) "i")
1088             (let ((last-period (timeclock-last-period now)))
1089               (setq accum (+ accum last-period)
1090                     elapsed (+ elapsed last-period)))
1091           (if (not (equal (timeclock-time-to-date
1092                            (cadr timeclock-last-event))
1093                           (timeclock-time-to-date now)))
1094               (setq accum (- accum timeclock-last-event-workday)))))
1095     (list accum (- elapsed timeclock-last-event-workday)
1096           elapsed)))
1097
1098 ;;; A reporting function that uses timeclock-log-data
1099
1100 (defun timeclock-time-less-p (t1 t2)
1101   "Say whether time T1 is less than time T2."
1102   (or (< (car t1) (car t2))
1103       (and (= (car t1) (car t2))
1104            (< (nth 1 t1) (nth 1 t2)))))
1105
1106 (defun timeclock-day-base (&optional time)
1107   "Given a time within a day, return 0:0:0 within that day."
1108   (let ((decoded (decode-time (or time (current-time)))))
1109     (setcar (nthcdr 0 decoded) 0)
1110     (setcar (nthcdr 1 decoded) 0)
1111     (setcar (nthcdr 2 decoded) 0)
1112     (apply 'encode-time decoded)))
1113
1114 (defun timeclock-geometric-mean (l)
1115   "Compute the geometric mean of the list L."
1116   (let ((total 0)
1117         (count 0))
1118     (while l
1119       (setq total (+ total (car l))
1120             count (1+ count)
1121             l (cdr l)))
1122     (if (> count 0)
1123         (/ total count)
1124       0)))
1125
1126 (defun timeclock-generate-report (&optional html-p)
1127   "Generate a summary report based on the current timelog file."
1128   (interactive)
1129   (let ((log (timeclock-log-data))
1130         (today (timeclock-day-base)))
1131     (if html-p (insert "<p>"))
1132     (insert "Currently ")
1133     (let ((project (nth 2 timeclock-last-event))
1134           (begin (nth 1 timeclock-last-event))
1135           done)
1136       (if (timeclock-currently-in-p)
1137           (insert "IN")
1138         (if (or (null project) (= (length project) 0))
1139             (progn (insert "Done Working Today")
1140                    (setq done t))
1141           (insert "OUT")))
1142       (unless done
1143         (insert " since " (format-time-string "%Y/%m/%d %-I:%M %p" begin))
1144         (if html-p
1145             (insert "<br>\n<b>")
1146           (insert "\n*"))
1147         (if (timeclock-currently-in-p)
1148             (insert "Working on "))
1149         (if html-p
1150             (insert project "</b><br>\n")
1151           (insert project "*\n"))
1152         (let ((proj-data (cdr (assoc project (timeclock-project-alist log))))
1153               (two-weeks-ago (timeclock-seconds-to-time
1154                               (- (timeclock-time-to-seconds today)
1155                                  (* 2 7 24 60 60))))
1156               two-week-len today-len)
1157           (while proj-data
1158             (if (not (timeclock-time-less-p
1159                       (timeclock-entry-begin (car proj-data)) today))
1160                 (setq today-len (timeclock-entry-list-length proj-data)
1161                       proj-data nil)
1162               (if (and (null two-week-len)
1163                        (not (timeclock-time-less-p
1164                              (timeclock-entry-begin (car proj-data))
1165                              two-weeks-ago)))
1166                   (setq two-week-len (timeclock-entry-list-length proj-data)))
1167               (setq proj-data (cdr proj-data))))
1168           (if (null two-week-len)
1169               (setq two-week-len today-len))
1170           (if html-p (insert "<p>"))
1171           (if today-len
1172               (insert "\nTime spent on this task today: "
1173                       (timeclock-seconds-to-string today-len)
1174                       ".  In the last two weeks: "
1175                       (timeclock-seconds-to-string two-week-len))
1176             (if two-week-len
1177                 (insert "\nTime spent on this task in the last two weeks: "
1178                         (timeclock-seconds-to-string two-week-len))))
1179           (if html-p (insert "<br>"))
1180           (insert "\n"
1181                   (timeclock-seconds-to-string (timeclock-workday-elapsed))
1182                   " worked today, "
1183                   (timeclock-seconds-to-string (timeclock-workday-remaining))
1184                   " remaining, done at "
1185                   (timeclock-when-to-leave-string) "\n")))
1186       (if html-p (insert "<p>"))
1187       (insert "\nThere have been "
1188               (number-to-string
1189                (length (timeclock-day-alist log)))
1190               " days of activity, starting "
1191               (caar (last (timeclock-day-alist log))))
1192       (if html-p (insert "</p>"))
1193       (when html-p
1194         (insert "<p>
1195 <table>
1196 <td width=\"25\"><br></td><td>
1197 <table border=1 cellpadding=3>
1198 <tr><th><i>Statistics</i></th>
1199     <th>Entire</th>
1200     <th>-30 days</th>
1201     <th>-3 mons</th>
1202     <th>-6 mons</th>
1203     <th>-1 year</th>
1204 </tr>")
1205         (let* ((day-list (timeclock-day-list))
1206                (thirty-days-ago (timeclock-seconds-to-time
1207                                  (- (timeclock-time-to-seconds today)
1208                                     (* 30 24 60 60))))
1209                (three-months-ago (timeclock-seconds-to-time
1210                                   (- (timeclock-time-to-seconds today)
1211                                      (* 90 24 60 60))))
1212                (six-months-ago (timeclock-seconds-to-time
1213                                 (- (timeclock-time-to-seconds today)
1214                                    (* 180 24 60 60))))
1215                (one-year-ago (timeclock-seconds-to-time
1216                               (- (timeclock-time-to-seconds today)
1217                                  (* 365 24 60 60))))
1218                (time-in  (vector (list t) (list t) (list t) (list t) (list t)))
1219                (time-out (vector (list t) (list t) (list t) (list t) (list t)))
1220                (breaks   (vector (list t) (list t) (list t) (list t) (list t)))
1221                (workday  (vector (list t) (list t) (list t) (list t) (list t)))
1222                (lengths  (vector '(0 0) thirty-days-ago three-months-ago
1223                                  six-months-ago one-year-ago)))
1224           ;; collect statistics from complete timelog
1225           (while day-list
1226             (let ((i 0) (l 5))
1227               (while (< i l)
1228                 (unless (timeclock-time-less-p
1229                          (timeclock-day-begin (car day-list))
1230                          (aref lengths i))
1231                   (let ((base (timeclock-time-to-seconds
1232                                (timeclock-day-base
1233                                 (timeclock-day-begin (car day-list))))))
1234                     (nconc (aref time-in i)
1235                            (list (- (timeclock-time-to-seconds
1236                                      (timeclock-day-begin (car day-list)))
1237                                     base)))
1238                     (let ((span (timeclock-day-span (car day-list)))
1239                           (len (timeclock-day-length (car day-list)))
1240                           (req (timeclock-day-required (car day-list))))
1241                       ;; If the day's actual work length is less than
1242                       ;; 70% of its span, then likely the exit time
1243                       ;; and break amount are not worthwhile adding to
1244                       ;; the statistic
1245                       (when (and (> span 0)
1246                                  (> (/ (float len) (float span)) 0.70))
1247                         (nconc (aref time-out i)
1248                                (list (- (timeclock-time-to-seconds
1249                                          (timeclock-day-end (car day-list)))
1250                                         base)))
1251                         (nconc (aref breaks i) (list (- span len))))
1252                       (if req
1253                           (setq len (+ len (- timeclock-workday req))))
1254                       (nconc (aref workday i) (list len)))))
1255                 (setq i (1+ i))))
1256             (setq day-list (cdr day-list)))
1257           ;; average statistics
1258           (let ((i 0) (l 5))
1259             (while (< i l)
1260               (aset time-in i (timeclock-geometric-mean
1261                                (cdr (aref time-in i))))
1262               (aset time-out i (timeclock-geometric-mean
1263                                 (cdr (aref time-out i))))
1264               (aset breaks i (timeclock-geometric-mean
1265                               (cdr (aref breaks i))))
1266               (aset workday i (timeclock-geometric-mean
1267                                (cdr (aref workday i))))
1268               (setq i (1+ i))))
1269           ;; Output the HTML table
1270           (insert "<tr>\n")
1271           (insert "<td align=\"center\">Time in</td>\n")
1272           (let ((i 0) (l 5))
1273             (while (< i l)
1274               (insert "<td align=\"right\">"
1275                       (timeclock-seconds-to-string (aref time-in i))
1276                       "</td>\n")
1277               (setq i (1+ i))))
1278           (insert "</tr>\n")
1279
1280           (insert "<tr>\n")
1281           (insert "<td align=\"center\">Time out</td>\n")
1282           (let ((i 0) (l 5))
1283             (while (< i l)
1284               (insert "<td align=\"right\">"
1285                       (timeclock-seconds-to-string (aref time-out i))
1286                       "</td>\n")
1287               (setq i (1+ i))))
1288           (insert "</tr>\n")
1289
1290           (insert "<tr>\n")
1291           (insert "<td align=\"center\">Break</td>\n")
1292           (let ((i 0) (l 5))
1293             (while (< i l)
1294               (insert "<td align=\"right\">"
1295                       (timeclock-seconds-to-string (aref breaks i))
1296                       "</td>\n")
1297               (setq i (1+ i))))
1298           (insert "</tr>\n")
1299
1300           (insert "<tr>\n")
1301           (insert "<td align=\"center\">Workday</td>\n")
1302           (let ((i 0) (l 5))
1303             (while (< i l)
1304               (insert "<td align=\"right\">"
1305                       (timeclock-seconds-to-string (aref workday i))
1306                       "</td>\n")
1307               (setq i (1+ i))))
1308           (insert "</tr>\n"))
1309         (insert "<tfoot>
1310 <td colspan=\"6\" align=\"center\">
1311   <i>These are approximate figures</i></td>
1312 </tfoot>
1313 </table>
1314 </td></table>")))))
1315
1316 ;;; A helpful little function
1317
1318 (defun timeclock-visit-timelog ()
1319   "Open up the .timelog file in another window."
1320   (interactive)
1321   (find-file-other-window timeclock-file))
1322
1323 (provide 'timeclock)
1324
1325 (run-hooks 'timeclock-load-hook)
1326
1327 ;; make sure we know the list of reasons, projects, and have computed
1328 ;; the last event and current discrepancy.
1329 (if (file-readable-p timeclock-file)
1330     (timeclock-reread-log))
1331
1332 ;;; timeclock.el ends here