Mercurial > emacs
annotate lisp/calendar/timeclock.el @ 89409:3d8025f863d3
Register CDAC fonts in
face-font-rescale-alist instead of face-resizing-fonts.
author | Kenichi Handa <handa@m17n.org> |
---|---|
date | Sat, 12 Apr 2003 02:39:22 +0000 |
parents | 526c9b7941f5 |
children | b88409633904 |
rev | line source |
---|---|
30781 | 1 ;;; timeclock.el --- mode for keeping track of how much you work |
2 | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
3 ;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc. |
30781 | 4 |
5 ;; Author: John Wiegley <johnw@gnu.org> | |
6 ;; Created: 25 Mar 1999 | |
37651
db867aae3c66
*** empty log message ***
John Wiegley <johnw@newartisans.com>
parents:
37650
diff
changeset
|
7 ;; Version: 2.6 |
30781 | 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 | |
30795
5b4027fef808
(timeclock-file): Run .timelog through convert-standard-filename.
Eli Zaretskii <eliz@gnu.org>
parents:
30781
diff
changeset
|
86 (defcustom timeclock-file (convert-standard-filename "~/.timelog") |
30781 | 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." | |
36091 | 131 :type '(choice (const nil) (function-item timeclock-workday) function) |
30781 | 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 | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
173 (set-variable 'timeclock-modeline-display nil)) |
30781 | 174 (setq timeclock-use-display-time value) |
175 (and currently-displaying | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
176 (set-variable 'timeclock-modeline-display t)) |
30781 | 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. | |
33020 | 225 The format of this list is (CODE TIME PROJECT).") |
30781 | 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))) | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
278 (unless (or (null list-entry) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
279 (memq 'timeclock-mode-string mode-line-format)) |
30781 | 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") | |
40671
526c9b7941f5
(timeclock-out): Signal an error if timeclock-last-event is nil.
Eli Zaretskii <eliz@gnu.org>
parents:
37652
diff
changeset
|
373 (or timeclock-last-event |
526c9b7941f5
(timeclock-out): Signal an error if timeclock-last-event is nil.
Eli Zaretskii <eliz@gnu.org>
parents:
37652
diff
changeset
|
374 (error "You haven't clocked in!")) |
30781 | 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) | |
36851 | 437 (if (and timeclock-discrepancy timeclock-modeline-display) |
30781 | 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 | |
33020 | 460 (defsubst timeclock-workday-remaining (&optional today-only) |
30781 | 461 "Return a 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." | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
466 (let ((discrep (timeclock-find-discrep))) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
467 (if discrep |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
468 (if today-only |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
469 (- (cadr discrep)) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
470 (- (car discrep))) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
471 0.0))) |
30781 | 472 |
33020 | 473 (defsubst timeclock-currently-in-p () |
30781 | 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 | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
493 (defsubst timeclock-workday-elapsed () |
30781 | 494 "Return a 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." | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
498 (let ((discrep (timeclock-find-discrep))) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
499 (if discrep |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
500 (nth 2 discrep) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
501 0.0))) |
30781 | 502 |
503 ;;;###autoload | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
504 (defun timeclock-workday-elapsed-string (&optional show-seconds) |
30781 | 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) | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
509 (let ((string (timeclock-seconds-to-string (timeclock-workday-elapsed) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
510 show-seconds))) |
30781 | 511 (if (interactive-p) |
512 (message string) | |
513 string))) | |
514 | |
33020 | 515 (defsubst timeclock-when-to-leave (&optional today-only) |
30781 | 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)) | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
522 (let ((discrep (timeclock-find-discrep))) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
523 (if discrep |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
524 (if today-only |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
525 (cadr discrep) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
526 (car discrep)) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
527 0.0))))) |
30781 | 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 | |
37324
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
555 (defun timeclock-completing-read (prompt alist &optional default) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
556 "A version of `completing-read' that works on both Emacs and XEmacs." |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
557 (if (featurep 'xemacs) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
558 (let ((str (completing-read prompt alist))) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
559 (if (or (null str) (= (length str) 0)) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
560 default |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
561 str)) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
562 (completing-read prompt alist nil nil nil nil default))) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
563 |
30781 | 564 (defun timeclock-ask-for-project () |
565 "Ask the user for the project they are clocking into." | |
37324
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
566 (timeclock-completing-read |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
567 (format "Clock into which project (default \"%s\"): " |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
568 (or timeclock-last-project |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
569 (car timeclock-project-list))) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
570 (mapcar 'list timeclock-project-list) |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
571 (or timeclock-last-project |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
572 (car timeclock-project-list)))) |
30781 | 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." | |
37324
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
578 (timeclock-completing-read "Reason for clocking out: " |
570c667b4d1c
(timeclock-completing-read): new function.
John Wiegley <johnw@newartisans.com>
parents:
37282
diff
changeset
|
579 (mapcar 'list timeclock-reason-list))) |
30781 | 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 | |
33020 | 603 being logged for. Normally only \"in\" events specify a project." |
604 (with-current-buffer (find-file-noselect timeclock-file) | |
30781 | 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) | |
33020 | 627 (run-hooks 'timeclock-event-hook) |
628 (kill-buffer (current-buffer)))) | |
30781 | 629 |
33020 | 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 () | |
30781 | 636 "Read the moment under point from the timelog." |
33020 | 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)))) | |
30781 | 647 |
33020 | 648 (defsubst timeclock-time-to-seconds (time) |
30781 | 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 | |
33020 | 654 (defsubst timeclock-seconds-to-time (seconds) |
30781 | 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 | |
33020 | 660 (defsubst timeclock-time-to-date (time) |
30781 | 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 | |
33020 | 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) | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
727 (or (car day) timeclock-workday)) |
33020 | 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 | |
36851 | 939 (line 0) last beg day entry event) |
33020 | 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))) | |
36851 | 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))))) | |
33020 | 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)))) | |
36851 | 993 (if (null proj) |
33020 | 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 | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1005 (defun timeclock-find-discrep () |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1006 "Find overall discrepancy from `timeclock-workday' (in seconds)." |
33020 | 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. | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1010 ;; |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1011 ;; If it were implemented using those functions, it would look |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1012 ;; something like this: |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1013 ;; (let ((days (timeclock-day-alist (timeclock-log-data))) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1014 ;; (total 0.0)) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1015 ;; (while days |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1016 ;; (setq total (+ total (- (timeclock-day-length (cdar days)) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1017 ;; (timeclock-day-required (cdar days)))) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1018 ;; days (cdr days))) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1019 ;; total) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1020 (let* ((now (current-time)) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1021 (todays-date (timeclock-time-to-date now)) |
37648
9baaf32f355a
(timeclock-find-discrep): Initialize `elapsed' to 0.
John Wiegley <johnw@newartisans.com>
parents:
37625
diff
changeset
|
1022 (first t) (accum 0) (elapsed 0) |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1023 event beg last-date avg |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1024 last-date-limited last-date-seconds) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1025 (unless timeclock-discrepancy |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1026 (when (file-readable-p timeclock-file) |
36851 | 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)))) | |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1050 (if (if last-date |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1051 (not (equal date last-date)) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1052 first) |
36851 | 1053 (setq first nil |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1054 accum (- accum (if last-date-limited |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1055 last-date-seconds |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1056 timeclock-workday)))) |
36851 | 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) | |
30781 | 1064 (> (length (nth 2 event)) 0)) |
36851 | 1065 (add-to-list 'timeclock-reason-list (nth 2 event))) |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1066 (if (not beg) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1067 (error "Error in format of timelog file!") |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1068 (setq timeclock-last-period |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1069 (- (timeclock-time-to-seconds (cadr event)) beg) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1070 accum (+ timeclock-last-period accum) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1071 beg nil)) |
36851 | 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 | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1077 (if (equal (timeclock-time-to-date now) last-date-limited) |
36851 | 1078 last-date-seconds |
1079 timeclock-workday)) | |
1080 (forward-line)) | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1081 (setq timeclock-discrepancy accum)))) |
37650
061ef023b0af
(timeclock-find-discrep): Set `timeclock-last-event-workday' if it's
John Wiegley <johnw@newartisans.com>
parents:
37648
diff
changeset
|
1082 (unless timeclock-last-event-workday |
061ef023b0af
(timeclock-find-discrep): Set `timeclock-last-event-workday' if it's
John Wiegley <johnw@newartisans.com>
parents:
37648
diff
changeset
|
1083 (setq timeclock-last-event-workday timeclock-workday)) |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1084 (setq accum timeclock-discrepancy |
37652
7fb1a7ce4a40
One more variable coming up nil on the first time around, needing
John Wiegley <johnw@newartisans.com>
parents:
37651
diff
changeset
|
1085 elapsed (or timeclock-elapsed elapsed)) |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1086 (if timeclock-last-event |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1087 (if (equal (car timeclock-last-event) "i") |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1088 (let ((last-period (timeclock-last-period now))) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1089 (setq accum (+ accum last-period) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1090 elapsed (+ elapsed last-period))) |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1091 (if (not (equal (timeclock-time-to-date |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1092 (cadr timeclock-last-event)) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1093 (timeclock-time-to-date now))) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1094 (setq accum (- accum timeclock-last-event-workday))))) |
37625
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1095 (list accum (- elapsed timeclock-last-event-workday) |
53351976477e
(timeclock-workday-remaining): Changed logic for determining how much
John Wiegley <johnw@newartisans.com>
parents:
37437
diff
changeset
|
1096 elapsed))) |
36851 | 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 | |
37282
d30baa39a3b4
(timeclock-generate-report): Added a missing insert of the project
John Wiegley <johnw@newartisans.com>
parents:
36854
diff
changeset
|
1150 (insert project "</b><br>\n") |
36851 | 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>")) | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1171 (if today-len |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1172 (insert "\nTime spent on this task today: " |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1173 (timeclock-seconds-to-string today-len) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1174 ". In the last two weeks: " |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1175 (timeclock-seconds-to-string two-week-len)) |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1176 (if two-week-len |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1177 (insert "\nTime spent on this task in the last two weeks: " |
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1178 (timeclock-seconds-to-string two-week-len)))) |
36851 | 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") | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1279 |
36851 | 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") | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1289 |
36851 | 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") | |
37437
ed485de91fcf
(timeclock-day-required): If the time required for a particular day is
John Wiegley <johnw@newartisans.com>
parents:
37324
diff
changeset
|
1299 |
36851 | 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)) | |
30781 | 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 |