[Emacs-diffs] Changes to emacs/lisp/calendar/timeclock.el [lexbind]

[Miles Bader]

Index: emacs/lisp/calendar/timeclock.el
diff -c emacs/lisp/calendar/timeclock.el:1.18.4.1 
emacs/lisp/calendar/timeclock.el:1.18.4.2
*** emacs/lisp/calendar/timeclock.el:1.18.4.1   Fri Apr  4 01:20:16 2003
--- emacs/lisp/calendar/timeclock.el    Tue Oct 14 19:42:15 2003
***************
*** 1,6 ****
  ;;; timeclock.el --- mode for keeping track of how much you work
  
! ;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
  
  ;; Author: John Wiegley <address@hidden>
  ;; Created: 25 Mar 1999
--- 1,6 ----
  ;;; timeclock.el --- mode for keeping track of how much you work
  
! ;; Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
  
  ;; Author: John Wiegley <address@hidden>
  ;; Created: 25 Mar 1999
***************
*** 33,43 ****
  ;; Use `timeclock-in' when you start on a project, and `timeclock-out'
  ;; when you're done.  Once you've collected some data, you can use
  ;; `timeclock-workday-remaining' to see how much time is left to be
! ;; worked today (assuming a typical average of 8 hours a day), and
! ;; `timeclock-when-to-leave' which will calculate when you're free.
  
  ;; You'll probably want to bind the timeclock commands to some handy
! ;; keystrokes.  At the moment, C-x t is unused in Emacs 20:
  ;;
  ;;   (require 'timeclock)
  ;;
--- 33,43 ----
  ;; Use `timeclock-in' when you start on a project, and `timeclock-out'
  ;; when you're done.  Once you've collected some data, you can use
  ;; `timeclock-workday-remaining' to see how much time is left to be
! ;; worked today (where `timeclock-workday' specifies the length of the
! ;; working day), and `timeclock-when-to-leave' to calculate when you're free.
  
  ;; You'll probably want to bind the timeclock commands to some handy
! ;; keystrokes.  At the moment, C-x t is unused:
  ;;
  ;;   (require 'timeclock)
  ;;
***************
*** 64,70 ****
  ;; `timeclock-ask-before-exiting' to t using M-x customize (this is
  ;; the default), or by adding the following to your .emacs file:
  ;;
! ;;   (add-hook 'kill-emacs-hook 'timeclock-query-out)
  
  ;; NOTE: If you change your .timelog file without using timeclock's
  ;; functions, or if you change the value of any of timeclock's
--- 64,70 ----
  ;; `timeclock-ask-before-exiting' to t using M-x customize (this is
  ;; the default), or by adding the following to your .emacs file:
  ;;
! ;;   (add-hook 'kill-emacs-query-functions 'timeclock-query-out)
  
  ;; NOTE: If you change your .timelog file without using timeclock's
  ;; functions, or if you change the value of any of timeclock's
***************
*** 99,106 ****
  work four hours on Monday, then the amount of time \"remaining\" on
  Tuesday is twelve hours -- relative to an averaged work period of
  eight hours -- or eight hours, non-relative.  So relative time takes
! into account any discrepancy of time under-worked or overworked on
! previous days."
    :type 'boolean
    :group 'timeclock)
  
--- 99,106 ----
  work four hours on Monday, then the amount of time \"remaining\" on
  Tuesday is twelve hours -- relative to an averaged work period of
  eight hours -- or eight hours, non-relative.  So relative time takes
! into account any discrepancy of time under-worked or over-worked on
! previous days.  This only affects the timeclock modeline display."
    :type 'boolean
    :group 'timeclock)
  
***************
*** 132,142 ****
    :group 'timeclock)
  
  (defcustom timeclock-ask-before-exiting t
!   "*If non-nil, ask if the user wants to clock out before exiting Emacs."
    :set (lambda (symbol value)
         (if value
!            (add-hook 'kill-emacs-hook 'timeclock-query-out)
!          (remove-hook 'kill-emacs-hook 'timeclock-query-out))
         (setq timeclock-ask-before-exiting value))
    :type 'boolean
    :group 'timeclock)
--- 132,143 ----
    :group 'timeclock)
  
  (defcustom timeclock-ask-before-exiting t
!   "*If non-nil, ask if the user wants to clock out before exiting Emacs.
! This variable only has an effect if set with \\[customize]."
    :set (lambda (symbol value)
         (if value
!            (add-hook 'kill-emacs-query-functions 'timeclock-query-out)
!          (remove-hook 'kill-emacs-query-functions 'timeclock-query-out))
         (setq timeclock-ask-before-exiting value))
    :type 'boolean
    :group 'timeclock)
***************
*** 144,158 ****
  (defvar timeclock-update-timer nil
    "The timer used to update `timeclock-mode-string'.")
  
  (defcustom timeclock-use-display-time t
    "*If non-nil, use `display-time-hook' for doing modeline updates.
  The advantage to this is that it means one less timer has to be set
  running amok in Emacs' process space.  The disadvantage is that it
  requires you to have `display-time' running.  If you don't want to use
  `display-time', but still want the modeline to show how much time is
! left, set this variable to nil.  You will need to restart Emacs (or
! toggle the value of `timeclock-modeline-display') for the change to
! take effect."
    :set (lambda (symbol value)
         (let ((currently-displaying
                (and (boundp 'timeclock-modeline-display)
--- 145,164 ----
  (defvar timeclock-update-timer nil
    "The timer used to update `timeclock-mode-string'.")
  
+ ;; For byte-compiler.
+ (defvar display-time-hook)
+ (defvar timeclock-modeline-display)
+ 
  (defcustom timeclock-use-display-time t
    "*If non-nil, use `display-time-hook' for doing modeline updates.
  The advantage to this is that it means one less timer has to be set
  running amok in Emacs' process space.  The disadvantage is that it
  requires you to have `display-time' running.  If you don't want to use
  `display-time', but still want the modeline to show how much time is
! left, set this variable to nil.  Changing the value of this variable
! while timeclock information is being displayed in the modeline has no
! effect.  You should call the function `timeclock-modeline-display' with
! a positive argument to force an update."
    :set (lambda (symbol value)
         (let ((currently-displaying
                (and (boundp 'timeclock-modeline-display)
***************
*** 200,206 ****
  
  (defcustom timeclock-day-over-hook nil
    "*A hook that is run when the workday has been completed.
! This hook is only run if the current time remaining is being display
  in the modeline.  See the variable `timeclock-modeline-display'."
    :type 'hook
    :group 'timeclock)
--- 206,212 ----
  
  (defcustom timeclock-day-over-hook nil
    "*A hook that is run when the workday has been completed.
! This hook is only run if the current time remaining is being displayed
  in the modeline.  See the variable `timeclock-modeline-display'."
    :type 'hook
    :group 'timeclock)
***************
*** 244,250 ****
  This value is not accurate enough to be useful by itself.  Rather,
  call `timeclock-workday-elapsed', to determine how much time has been
  worked so far today.  Also, if `timeclock-relative' is nil, this value
! will be the same as `timeclock-discrepancy'.")
  
  (defvar timeclock-last-period nil
    "Integer representing the number of seconds in the last period.
--- 250,256 ----
  This value is not accurate enough to be useful by itself.  Rather,
  call `timeclock-workday-elapsed', to determine how much time has been
  worked so far today.  Also, if `timeclock-relative' is nil, this value
! will be the same as `timeclock-discrepancy'.") ; ? gm
  
  (defvar timeclock-last-period nil
    "Integer representing the number of seconds in the last period.
***************
*** 252,258 ****
  `timeclock-last-period' instead.")
  
  (defvar timeclock-mode-string nil
!   "The timeclock string (optionally) displayed in the modeline.")
  
  (defvar timeclock-day-over nil
    "The date of the last day when notified \"day over\" for.")
--- 258,265 ----
  `timeclock-last-period' instead.")
  
  (defvar timeclock-mode-string nil
!   "The timeclock string (optionally) displayed in the modeline.
! The time is bracketed by <> if you are clocked in, otherwise by [].")
  
  (defvar timeclock-day-over nil
    "The date of the last day when notified \"day over\" for.")
***************
*** 262,285 ****
  ;;;###autoload
  (defun timeclock-modeline-display (&optional arg)
    "Toggle display of the amount of time left today in the modeline.
! If `timeclock-use-display-time' is non-nil, the modeline will be
! updated whenever the time display is updated.  Otherwise, the
! timeclock will use its own sixty second timer to do its updating.
! With prefix ARG, turn modeline display on if and only if ARG is
! positive.  Returns the new status of timeclock modeline display
! \(non-nil means on)."
    (interactive "P")
    (let ((on-p (if arg
                  (> (prefix-numeric-value arg) 0)
                (not timeclock-modeline-display))))
      (if on-p
!       (let ((list-entry (or (memq 'global-mode-string mode-line-format)
!                             ;; In Emacs 21.3 we must use assq
!                             (assq 'global-mode-string mode-line-format))))
!         (unless (or (null list-entry)
!                     (memq 'timeclock-mode-string mode-line-format))
!           (setcdr list-entry (cons 'timeclock-mode-string
!                                    (cdr list-entry))))
          (unless (memq 'timeclock-update-modeline timeclock-event-hook)
            (add-hook 'timeclock-event-hook 'timeclock-update-modeline))
          (when timeclock-update-timer
--- 269,293 ----
  ;;;###autoload
  (defun timeclock-modeline-display (&optional arg)
    "Toggle display of the amount of time left today in the modeline.
! If `timeclock-use-display-time' is non-nil (the default), then
! the function `display-time-mode' must be active, and the modeline
! will be updated whenever the time display is updated.  Otherwise,
! the timeclock will use its own sixty second timer to do its
! updating.  With prefix ARG, turn modeline display on if and only
! if ARG is positive.  Returns the new status of timeclock modeline
! display (non-nil means on)."
    (interactive "P")
+   ;; cf display-time-mode.
+   (setq timeclock-mode-string "")
+   (or global-mode-string (setq global-mode-string '("")))
    (let ((on-p (if arg
                  (> (prefix-numeric-value arg) 0)
                (not timeclock-modeline-display))))
      (if on-p
!         (progn
!           (or (memq 'timeclock-mode-string global-mode-string)
!               (setq global-mode-string
!                     (append global-mode-string '(timeclock-mode-string))))
          (unless (memq 'timeclock-update-modeline timeclock-event-hook)
            (add-hook 'timeclock-event-hook 'timeclock-update-modeline))
          (when timeclock-update-timer
***************
*** 288,298 ****
          (if (boundp 'display-time-hook)
              (remove-hook 'display-time-hook 'timeclock-update-modeline))
          (if timeclock-use-display-time
!             (add-hook 'display-time-hook 'timeclock-update-modeline)
            (setq timeclock-update-timer
                  (run-at-time nil 60 'timeclock-update-modeline))))
!       (setq mode-line-format
!           (delq 'timeclock-mode-string mode-line-format))
        (remove-hook 'timeclock-event-hook 'timeclock-update-modeline)
        (if (boundp 'display-time-hook)
          (remove-hook 'display-time-hook
--- 296,312 ----
          (if (boundp 'display-time-hook)
              (remove-hook 'display-time-hook 'timeclock-update-modeline))
          (if timeclock-use-display-time
!               (progn
!                 ;; Update immediately so there is a visible change
!                 ;; on calling this function.
!                 (if display-time-mode (timeclock-update-modeline)
!                   (message "Activate `display-time-mode' to see \
! timeclock information"))
!                 (add-hook 'display-time-hook 'timeclock-update-modeline))
            (setq timeclock-update-timer
                  (run-at-time nil 60 'timeclock-update-modeline))))
!       (setq global-mode-string
!           (delq 'timeclock-mode-string global-mode-string))
        (remove-hook 'timeclock-event-hook 'timeclock-update-modeline)
        (if (boundp 'display-time-hook)
          (remove-hook 'display-time-hook
***************
*** 301,307 ****
        (cancel-timer timeclock-update-timer)
        (setq timeclock-update-timer nil)))
      (force-mode-line-update)
!     on-p))
  
  ;; This has to be here so that the function definition of
  ;; `timeclock-modeline-display' is known to the "set" function.
--- 315,321 ----
        (cancel-timer timeclock-update-timer)
        (setq timeclock-update-timer nil)))
      (force-mode-line-update)
!     (setq timeclock-modeline-display on-p)))
  
  ;; This has to be here so that the function definition of
  ;; `timeclock-modeline-display' is known to the "set" function.
***************
*** 315,320 ****
--- 329,338 ----
    :group 'timeclock
    :require 'timeclock)
  
+ (defsubst timeclock-time-to-date (time)
+   "Convert the TIME value to a textual date string."
+   (format-time-string "%Y/%m/%d" time))
+ 
  ;;;###autoload
  (defun timeclock-in (&optional arg project find-project)
    "Clock in, recording the current time moment in the timelog.
***************
*** 386,398 ****
      (if arg
        (run-hooks 'timeclock-done-hook))))
  
  ;;;###autoload
  (defun timeclock-status-string (&optional show-seconds today-only)
!   "Report the overall timeclock status at the present moment."
    (interactive "P")
!   (let* ((remainder (timeclock-workday-remaining))
!        (last-in (equal (car timeclock-last-event) "i"))
!        status)
      (setq status
          (format "Currently %s since %s (%s), %s %s, leave at %s"
                  (if last-in "IN" "OUT")
--- 404,431 ----
      (if arg
        (run-hooks 'timeclock-done-hook))))
  
+ ;; Should today-only be removed in favour of timeclock-relative? - gm
+ (defsubst timeclock-workday-remaining (&optional today-only)
+   "Return the number of seconds until the workday is complete.
+ The amount returned is relative to the value of `timeclock-workday'.
+ If TODAY-ONLY is non-nil, the value returned will be relative only to
+ the time worked today, and not to past time."
+   (let ((discrep (timeclock-find-discrep)))
+     (if discrep
+         (- (if today-only (cadr discrep)
+              (car discrep)))
+       0.0)))
+ 
  ;;;###autoload
  (defun timeclock-status-string (&optional show-seconds today-only)
!   "Report the overall timeclock status at the present moment.
! If SHOW-SECONDS is non-nil, display second resolution.
! If TODAY-ONLY is non-nil, the display will be relative only to time
! worked today, ignoring the time worked on previous days."
    (interactive "P")
!   (let ((remainder (timeclock-workday-remaining)) ; today-only?
!         (last-in (equal (car timeclock-last-event) "i"))
!         status)
      (setq status
          (format "Currently %s since %s (%s), %s %s, leave at %s"
                  (if last-in "IN" "OUT")
***************
*** 424,433 ****
  ;;;###autoload
  (defun timeclock-query-out ()
    "Ask the user before clocking out.
! This is a useful function for adding to `kill-emacs-hook'."
!   (if (and (equal (car timeclock-last-event) "i")
!          (y-or-n-p "You're currently clocking time, clock out? "))
!       (timeclock-out)))
  
  ;;;###autoload
  (defun timeclock-reread-log ()
--- 457,468 ----
  ;;;###autoload
  (defun timeclock-query-out ()
    "Ask the user before clocking out.
! This is a useful function for adding to `kill-emacs-query-functions'."
!   (and (equal (car timeclock-last-event) "i")
!        (y-or-n-p "You're currently clocking time, clock out? ")
!        (timeclock-out))
!   ;; Unconditionally return t for `kill-emacs-query-functions'.
!   t)
  
  ;;;###autoload
  (defun timeclock-reread-log ()
***************
*** 459,477 ****
            (truncate (/ (abs seconds) 60 60))
            (% (truncate (/ (abs seconds) 60)) 60))))
  
- (defsubst timeclock-workday-remaining (&optional today-only)
-   "Return the number of seconds until the workday is complete.
- The amount returned is relative to the value of `timeclock-workday'.
- If TODAY-ONLY is non-nil, the value returned will be relative only to
- the time worked today, and not to past time.  This argument only makes
- a difference if `timeclock-relative' is non-nil."
-   (let ((discrep (timeclock-find-discrep)))
-     (if discrep
-       (if today-only
-           (- (cadr discrep))
-         (- (car discrep)))
-       0.0)))
- 
  (defsubst timeclock-currently-in-p ()
    "Return non-nil if the user is currently clocked in."
    (equal (car timeclock-last-event) "i"))
--- 494,499 ----
***************
*** 514,524 ****
        (message string)
        string)))
  
  (defsubst timeclock-when-to-leave (&optional today-only)
    "Return a time value representing at when the workday ends today.
  If TODAY-ONLY is non-nil, the value returned will be relative only to
! the time worked today, and not to past time.  This argument only makes
! a difference if `timeclock-relative' is non-nil."
    (timeclock-seconds-to-time
     (- (timeclock-time-to-seconds (current-time))
        (let ((discrep (timeclock-find-discrep)))
--- 536,558 ----
        (message string)
        string)))
  
+ (defsubst timeclock-time-to-seconds (time)
+   "Convert TIME to a floating point number."
+   (+ (* (car time) 65536.0)
+      (cadr time)
+      (/ (or (car (cdr (cdr time))) 0) 1000000.0)))
+ 
+ (defsubst timeclock-seconds-to-time (seconds)
+   "Convert SECONDS (a floating point number) to an Emacs time structure."
+   (list (floor seconds 65536)
+       (floor (mod seconds 65536))
+       (floor (* (- seconds (ffloor seconds)) 1000000))))
+ 
+ ;; Should today-only be removed in favour of timeclock-relative? - gm
  (defsubst timeclock-when-to-leave (&optional today-only)
    "Return a time value representing at when the workday ends today.
  If TODAY-ONLY is non-nil, the value returned will be relative only to
! the time worked today, and not to past time."
    (timeclock-seconds-to-time
     (- (timeclock-time-to-seconds (current-time))
        (let ((discrep (timeclock-find-discrep)))
***************
*** 533,544 ****
                                                 today-only)
    "Return a string representing at what time the workday ends today.
  This string is relative to the value of `timeclock-workday'.  If
! NO-MESSAGE is non-nil, no messages will be displayed in the
! minibuffer.  If SHOW-SECONDS is non-nil, the value printed/returned
! will include seconds.  If TODAY-ONLY is non-nil, the value returned
! will be relative only to the time worked today, and not to past time.
! This argument only makes a difference if `timeclock-relative' is
! non-nil."
    (interactive)
    (let* ((then (timeclock-when-to-leave today-only))
         (string
--- 567,576 ----
                                                 today-only)
    "Return a string representing at what time the workday ends today.
  This string is relative to the value of `timeclock-workday'.  If
! SHOW-SECONDS is non-nil, the value printed/returned will include
! seconds.  If TODAY-ONLY is non-nil, the value returned will be
! relative only to the time worked today, and not to past time."
!   ;; Should today-only be removed in favour of timeclock-relative? - gm
    (interactive)
    (let* ((then (timeclock-when-to-leave today-only))
         (string
***************
*** 581,590 ****
                             (mapcar 'list timeclock-reason-list)))
  
  (defun timeclock-update-modeline ()
!   "Update the `timeclock-mode-string' displayed in the modeline."
    (interactive)
!   (let* ((remainder (timeclock-workday-remaining))
!        (last-in (equal (car timeclock-last-event) "i")))
      (when (and (< remainder 0)
               (not (and timeclock-day-over
                         (equal timeclock-day-over
--- 613,624 ----
                             (mapcar 'list timeclock-reason-list)))
  
  (defun timeclock-update-modeline ()
!   "Update the `timeclock-mode-string' displayed in the modeline.
! The value of `timeclock-relative' affects the display as described in
! that variable's documentation."
    (interactive)
!   (let ((remainder (timeclock-workday-remaining (not timeclock-relative)))
!         (last-in (equal (car timeclock-last-event) "i")))
      (when (and (< remainder 0)
               (not (and timeclock-day-over
                         (equal timeclock-day-over
***************
*** 594,603 ****
            (timeclock-time-to-date (current-time)))
        (run-hooks 'timeclock-day-over-hook))
      (setq timeclock-mode-string
!         (format "   %c%s%c"
!                 (if last-in ?< ?[)
!                 (timeclock-seconds-to-string remainder nil t)
!                 (if last-in ?> ?])))))
  
  (defun timeclock-log (code &optional project)
    "Log the event CODE to the timeclock log, at the time of call.
--- 628,641 ----
            (timeclock-time-to-date (current-time)))
        (run-hooks 'timeclock-day-over-hook))
      (setq timeclock-mode-string
!           (propertize
!            (format " %c%s%c "
!                    (if last-in ?< ?[)
!                  (timeclock-seconds-to-string remainder nil t)
!                  (if last-in ?> ?]))
!            'help-echo "timeclock: time remaining"))))
! 
! (put 'timeclock-mode-string 'risky-local-variable t)
  
  (defun timeclock-log (code &optional project)
    "Log the event CODE to the timeclock log, at the time of call.
***************
*** 647,668 ****
            (project (match-string 8)))
        (list code (encode-time sec min hour mday mon year) project))))
  
- (defsubst timeclock-time-to-seconds (time)
-   "Convert TIME to a floating point number."
-   (+ (* (car time) 65536.0)
-      (cadr time)
-      (/ (or (car (cdr (cdr time))) 0) 1000000.0)))
- 
- (defsubst timeclock-seconds-to-time (seconds)
-   "Convert SECONDS (a floating point number) to an Emacs time structure."
-   (list (floor seconds 65536)
-       (floor (mod seconds 65536))
-       (floor (* (- seconds (ffloor seconds)) 1000000))))
- 
- (defsubst timeclock-time-to-date (time)
-   "Convert the TIME value to a textual date string."
-   (format-time-string "%Y/%m/%d" time))
- 
  (defun timeclock-last-period (&optional moment)
    "Return the value of the last event period.
  If the last event was a clock-in, the period will be open ended, and
--- 685,690 ----
***************
*** 811,816 ****
--- 833,843 ----
  
  (defun timeclock-log-data (&optional recent-only filename)
    "Return the contents of the timelog file, in a useful format.
+ If the optional argument RECENT-ONLY is non-nil, only show the contents
+ from the last point where the time debt (see below) was set.
+ If the optional argument FILENAME is non-nil, it is used instead of
+ the file specified by `timeclock-file.'
+ 
  A timelog contains data in the form of a single entry per line.
  Each entry has the form:
  
***************
*** 1005,1011 ****
        log-data)))
  
  (defun timeclock-find-discrep ()
!   "Find overall discrepancy from `timeclock-workday' (in seconds)."
    ;; This is not implemented in terms of the functions above, because
    ;; it's a bit wasteful to read all of that data in, just to throw
    ;; away more than 90% of the information afterwards.
--- 1032,1040 ----
        log-data)))
  
  (defun timeclock-find-discrep ()
!   "Calculate time discrepancies, in seconds.
! The result is a three element list, containing the total time
! discrepancy, today's discrepancy, and the time worked today."
    ;; This is not implemented in terms of the functions above, because
    ;; it's a bit wasteful to read all of that data in, just to throw
    ;; away more than 90% of the information afterwards.
***************
*** 1083,1089 ****
          (setq timeclock-discrepancy accum))))
      (unless timeclock-last-event-workday
        (setq timeclock-last-event-workday timeclock-workday))
!     (setq accum timeclock-discrepancy
          elapsed (or timeclock-elapsed elapsed))
      (if timeclock-last-event
        (if (equal (car timeclock-last-event) "i")
--- 1112,1118 ----
          (setq timeclock-discrepancy accum))))
      (unless timeclock-last-event-workday
        (setq timeclock-last-event-workday timeclock-workday))
!     (setq accum (or timeclock-discrepancy 0)
          elapsed (or timeclock-elapsed elapsed))
      (if timeclock-last-event
        (if (equal (car timeclock-last-event) "i")
***************
*** 1106,1112 ****
           (< (nth 1 t1) (nth 1 t2)))))
  
  (defun timeclock-day-base (&optional time)
!   "Given a time within a day, return 0:0:0 within that day."
    (let ((decoded (decode-time (or time (current-time)))))
      (setcar (nthcdr 0 decoded) 0)
      (setcar (nthcdr 1 decoded) 0)
--- 1135,1142 ----
           (< (nth 1 t1) (nth 1 t2)))))
  
  (defun timeclock-day-base (&optional time)
!   "Given a time within a day, return 0:0:0 within that day.
! If optional argument TIME is non-nil, use that instead of the current time."
    (let ((decoded (decode-time (or time (current-time)))))
      (setcar (nthcdr 0 decoded) 0)
      (setcar (nthcdr 1 decoded) 0)
***************
*** 1126,1132 ****
        0)))
  
  (defun timeclock-generate-report (&optional html-p)
!   "Generate a summary report based on the current timelog file."
    (interactive)
    (let ((log (timeclock-log-data))
        (today (timeclock-day-base)))
--- 1156,1164 ----
        0)))
  
  (defun timeclock-generate-report (&optional html-p)
!   "Generate a summary report based on the current timelog file.
! By default, the report is in plain text, but if the optional argument
! HTML-P is non-nil html markup is added."
    (interactive)
    (let ((log (timeclock-log-data))
        (today (timeclock-day-base)))
***************
*** 1318,1324 ****
  ;;; A helpful little function
  
  (defun timeclock-visit-timelog ()
!   "Open up the .timelog file in another window."
    (interactive)
    (find-file-other-window timeclock-file))
  
--- 1350,1356 ----
  ;;; A helpful little function
  
  (defun timeclock-visit-timelog ()
!   "Open the file named by `timeclock-file' in another window."
    (interactive)
    (find-file-other-window timeclock-file))
  
***************
*** 1331,1334 ****
--- 1363,1367 ----
  (if (file-readable-p timeclock-file)
      (timeclock-reread-log))
  
+ ;;; arch-tag: a0be3377-deb6-44ec-b9a2-a7be28436a40
  ;;; timeclock.el ends here