emacs-orgmode@gnu.org archives
 help / color / mirror / code / Atom feed
* A much simpler way of handling dependent tasks
@ 2009-01-26 21:16 John Wiegley
  2009-01-26 23:48 ` Oliver Charles
                   ` (4 more replies)
  0 siblings, 5 replies; 12+ messages in thread
From: John Wiegley @ 2009-01-26 21:16 UTC (permalink / raw)
  To: Carsten Dominik; +Cc: emacs-orgmode Org-Mode

[-- Attachment #1: Type: text/plain, Size: 553 bytes --]

I've been wanting a simple method for managing dependent tasks for  
some time now, and only now did it occur to me that I could just  
implement a much simpler method using your current blocking mechanism.

The attached file, confusingly named org-depends.el, implements the  
following scheme:

  1. Any TODO which has incomplete child TODOs is blocked.

  2. If a parent TODO has the ORDERED property, it's children must be
     completed in order.  Undone siblings block later siblings.

  3. Blocked items are greyed out in the agenda list.

John


[-- Attachment #2: org-depends.el --]
[-- Type: application/octet-stream, Size: 4353 bytes --]

;;; org-depends.el --- Hierarchical TODO dependencies for Org-mode
;; Copyright (C) 2008 Free Software Foundation, Inc.
;;
;; Author: John Wiegley <johnw at newartisans dot com>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://www.newartisans.com/
;; Version: 0.01
;;
;; This file is not part of GNU Emacs.
;;
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;

(require 'org)

(defun org-depends-block-todo (change-plist)
  "Block turning an entry into a TODO.
This checks whether the current task should be blocked from state
changes.  Such blocking occurs when:

  1. The task has children which are not all in a completed state.

  2. A task has a parent with the property :ORDERED:, and there
     are siblings prior to the current task with incomplete
     status."
  (catch 'dont-block
    ;; If this task has children, and any are undone, it's blocked
    (save-excursion
      (outline-back-to-heading)
      (let ((this-level (funcall outline-level)))
	(outline-next-heading)
	(let ((child-level (funcall outline-level)))
	  (while (and (not (eobp))
		      (> child-level this-level))
	    ;; this todo has children, check whether they are all
	    ;; completed
	    (if (and (not (org-entry-is-done-p))
		     (org-entry-is-todo-p))
		(throw 'dont-block nil))
	    (outline-next-heading)
	    (setq child-level (funcall outline-level))))))
    ;; Otherwise, if the task's parent has the :ORDERED: property, and
    ;; any previous siblings are undone, it's blocked
    (save-excursion
      (outline-back-to-heading)
      (when (save-excursion
	      (outline-up-heading 1)
	      (org-entry-get (point) "ORDERED"))
	(let* ((this-level (funcall outline-level))
	       (current-level this-level))
	  (while (and (not (bobp))
		      (= current-level this-level))
	    (outline-previous-heading)
	    (setq current-level (funcall outline-level))
	    (if (= current-level this-level)
		;; this todo has children, check whether they are all
		;; completed
		(if (and (not (org-entry-is-done-p))
			 (org-entry-is-todo-p))
		    (throw 'dont-block nil)))))))
    t))					; don't block

(add-hook 'org-blocker-hook 'org-depends-block-todo)

(defface org-depends-dimmed-todo-face
  '((((background light)) (:foreground "grey50"))
    (((background dark)) (:foreground "grey50")))
  "Face used to hide leading stars in headlines.
The foreground color of this face should be equal to the background
color of the frame."
  :group 'org-depends)

(defun org-depends-dim-blocked-todos ()
  "Dim currently blocked TODO's in the agenda display."
  (interactive)
  (mapc (lambda (o) (if (eq (org-overlay-get o 'org-type) 'org-blocked-todo)
		   (org-delete-overlay o)))
	(org-overlays-in (point-min) (point-max)))
  (save-excursion
    (let ((inhibit-read-only t)
	  b e p ov h l)
      (goto-char (point-min))
      (while (let ((pos (next-single-property-change (point) 'todo-state)))
	       (and pos (goto-char (1+ pos))))
	(let ((marker (get-text-property (point) 'org-hd-marker)))
	  (when (and marker
		     (not (with-current-buffer (marker-buffer marker)
			    (save-excursion
			      (goto-char marker)
			      (org-depends-block-todo (list :type 'todo-state-change
							   :position marker
							   :from "TODO"
							   :to "DONE"))))))
	    (setq b (point) e (point-at-eol)
		  ov (org-make-overlay b e))
	    (org-overlay-put ov 'face 'org-depends-dimmed-todo-face)
	    (org-overlay-put ov 'org-type 'org-blocked-todo)))))))

(add-hook 'org-finalize-agenda-hook 'org-depends-dim-blocked-todos)

(provide 'org-depends)

;;; org-depends.el ends here

[-- Attachment #3: Type: text/plain, Size: 1 bytes --]



[-- Attachment #4: Type: text/plain, Size: 204 bytes --]

_______________________________________________
Emacs-orgmode mailing list
Remember: use `Reply All' to send replies to the list.
Emacs-orgmode@gnu.org
http://lists.gnu.org/mailman/listinfo/emacs-orgmode

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-26 21:16 A much simpler way of handling dependent tasks John Wiegley
@ 2009-01-26 23:48 ` Oliver Charles
  2009-01-27  1:18   ` Jesse Alama
  2009-01-27  6:47 ` John Wiegley
                   ` (3 subsequent siblings)
  4 siblings, 1 reply; 12+ messages in thread
From: Oliver Charles @ 2009-01-26 23:48 UTC (permalink / raw)
  To: John Wiegley; +Cc: emacs-orgmode Org-Mode

On Mon, Jan 26, 2009 at 05:16:17PM -0400, John Wiegley wrote:
> I've been wanting a simple method for managing dependent tasks for some 
> time now, and only now did it occur to me that I could just implement a 
> much simpler method using your current blocking mechanism.
>
> The attached file, confusingly named org-depends.el, implements the  
> following scheme:
>
> [ ... ]

This is very cool and I'm immediately in love with it! I'll let you
know if I have any problems, but it seems like it just works. Neat.

-- 
        Oliver Charles / aCiD2

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-26 23:48 ` Oliver Charles
@ 2009-01-27  1:18   ` Jesse Alama
  2009-01-27  6:46     ` Carsten Dominik
  0 siblings, 1 reply; 12+ messages in thread
From: Jesse Alama @ 2009-01-27  1:18 UTC (permalink / raw)
  To: emacs-orgmode

Oliver Charles <oliver.g.charles@googlemail.com> writes:

> On Mon, Jan 26, 2009 at 05:16:17PM -0400, John Wiegley wrote:
>> I've been wanting a simple method for managing dependent tasks for some 
>> time now, and only now did it occur to me that I could just implement a 
>> much simpler method using your current blocking mechanism.
>>
>> The attached file, confusingly named org-depends.el, implements the  
>> following scheme:
>>
>> [ ... ]
>
> This is very cool and I'm immediately in love with it! I'll let you
> know if I have any problems, but it seems like it just works. Neat.

Any chance of putting this into the org codebase (if not as one of the
core modules, then as a contrib module)?

Jesse

-- 
Jesse Alama (alama@stanford.edu)

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: Re: A much simpler way of handling dependent tasks
  2009-01-27  1:18   ` Jesse Alama
@ 2009-01-27  6:46     ` Carsten Dominik
  0 siblings, 0 replies; 12+ messages in thread
From: Carsten Dominik @ 2009-01-27  6:46 UTC (permalink / raw)
  To: Jesse Alama; +Cc: John Wiegley, Org Mode List


On Jan 27, 2009, at 2:18 AM, Jesse Alama wrote:

> Oliver Charles <oliver.g.charles@googlemail.com> writes:
>
>> On Mon, Jan 26, 2009 at 05:16:17PM -0400, John Wiegley wrote:
>>> I've been wanting a simple method for managing dependent tasks for  
>>> some
>>> time now, and only now did it occur to me that I could just  
>>> implement a
>>> much simpler method using your current blocking mechanism.
>>>
>>> The attached file, confusingly named org-depends.el, implements the
>>> following scheme:
>>>
>>> [ ... ]
>>
>> This is very cool and I'm immediately in love with it! I'll let you
>> know if I have any problems, but it seems like it just works. Neat.
>
> Any chance of putting this into the org codebase (if not as one of the
> core modules, then as a contrib module)?

Anything John sends my way gets a pretty good chance at that :-)

- Carsten

>
>
> Jesse
>
> -- 
> Jesse Alama (alama@stanford.edu)
>
>
>
> _______________________________________________
> Emacs-orgmode mailing list
> Remember: use `Reply All' to send replies to the list.
> Emacs-orgmode@gnu.org
> http://lists.gnu.org/mailman/listinfo/emacs-orgmode

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-26 21:16 A much simpler way of handling dependent tasks John Wiegley
  2009-01-26 23:48 ` Oliver Charles
@ 2009-01-27  6:47 ` John Wiegley
  2009-01-27  6:47 ` Carsten Dominik
                   ` (2 subsequent siblings)
  4 siblings, 0 replies; 12+ messages in thread
From: John Wiegley @ 2009-01-27  6:47 UTC (permalink / raw)
  To: Carsten Dominik; +Cc: emacs-orgmode Org-Mode

[-- Attachment #1: Type: text/plain, Size: 300 bytes --]

On Jan 26, 2009, at 5:16 PM, John Wiegley wrote:

> The attached file, confusingly named org-depends.el, implements the  
> following scheme:

I found a bug which would cause a Lisp error when trying to change the  
state of top-level TODO items.  The attached version (now 1.0) fixes  
this.

John


[-- Attachment #2: org-depends.el --]
[-- Type: application/octet-stream, Size: 4365 bytes --]

;;; org-depends.el --- Hierarchical TODO dependencies for Org-mode
;; Copyright (C) 2008 Free Software Foundation, Inc.
;;
;; Author: John Wiegley <johnw at newartisans dot com>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://www.newartisans.com/
;; Version: 1.0
;;
;; This file is not part of GNU Emacs.
;;
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;

(require 'org)

(defun org-depends-block-todo (change-plist)
  "Block turning an entry into a TODO.
This checks whether the current task should be blocked from state
changes.  Such blocking occurs when:

  1. The task has children which are not all in a completed state.

  2. A task has a parent with the property :ORDERED:, and there
     are siblings prior to the current task with incomplete
     status."
  (catch 'dont-block
    ;; If this task has children, and any are undone, it's blocked
    (save-excursion
      (outline-back-to-heading)
      (let ((this-level (funcall outline-level)))
	(outline-next-heading)
	(let ((child-level (funcall outline-level)))
	  (while (and (not (eobp))
		      (> child-level this-level))
	    ;; this todo has children, check whether they are all
	    ;; completed
	    (if (and (not (org-entry-is-done-p))
		     (org-entry-is-todo-p))
		(throw 'dont-block nil))
	    (outline-next-heading)
	    (setq child-level (funcall outline-level))))))
    ;; Otherwise, if the task's parent has the :ORDERED: property, and
    ;; any previous siblings are undone, it's blocked
    (save-excursion
      (outline-back-to-heading)
      (when (save-excursion
	      (ignore-errors
		(outline-up-heading 1)
		(org-entry-get (point) "ORDERED")))
	(let* ((this-level (funcall outline-level))
	       (current-level this-level))
	  (while (and (not (bobp))
		      (= current-level this-level))
	    (outline-previous-heading)
	    (setq current-level (funcall outline-level))
	    (if (= current-level this-level)
		;; this todo has children, check whether they are all
		;; completed
		(if (and (not (org-entry-is-done-p))
			 (org-entry-is-todo-p))
		    (throw 'dont-block nil)))))))
    t))					; don't block

(add-hook 'org-blocker-hook 'org-depends-block-todo)

(defface org-depends-dimmed-todo-face
  '((((background light)) (:foreground "grey50"))
    (((background dark)) (:foreground "grey50")))
  "Face used to hide leading stars in headlines.
The foreground color of this face should be equal to the background
color of the frame."
  :group 'org-depends)

(defun org-depends-dim-blocked-todos ()
  "Dim currently blocked TODO's in the agenda display."
  (interactive)
  (mapc (lambda (o) (if (eq (org-overlay-get o 'org-type) 'org-blocked-todo)
		   (org-delete-overlay o)))
	(org-overlays-in (point-min) (point-max)))
  (save-excursion
    (let ((inhibit-read-only t)
	  b e p ov h l)
      (goto-char (point-min))
      (while (let ((pos (next-single-property-change (point) 'todo-state)))
	       (and pos (goto-char (1+ pos))))
	(let ((marker (get-text-property (point) 'org-hd-marker)))
	  (when (and marker
		     (not (with-current-buffer (marker-buffer marker)
			    (save-excursion
			      (goto-char marker)
			      (org-depends-block-todo (list :type 'todo-state-change
							   :position marker
							   :from "TODO"
							   :to "DONE"))))))
	    (setq b (point) e (point-at-eol)
		  ov (org-make-overlay b e))
	    (org-overlay-put ov 'face 'org-depends-dimmed-todo-face)
	    (org-overlay-put ov 'org-type 'org-blocked-todo)))))))

(add-hook 'org-finalize-agenda-hook 'org-depends-dim-blocked-todos)

(provide 'org-depends)

;;; org-depends.el ends here

[-- Attachment #3: Type: text/plain, Size: 2 bytes --]




[-- Attachment #4: Type: text/plain, Size: 204 bytes --]

_______________________________________________
Emacs-orgmode mailing list
Remember: use `Reply All' to send replies to the list.
Emacs-orgmode@gnu.org
http://lists.gnu.org/mailman/listinfo/emacs-orgmode

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-26 21:16 A much simpler way of handling dependent tasks John Wiegley
  2009-01-26 23:48 ` Oliver Charles
  2009-01-27  6:47 ` John Wiegley
@ 2009-01-27  6:47 ` Carsten Dominik
  2009-01-27  7:31   ` John Wiegley
  2009-01-27 22:51 ` Mike Newman
  2009-01-30 15:02 ` Rainer Stengele
  4 siblings, 1 reply; 12+ messages in thread
From: Carsten Dominik @ 2009-01-27  6:47 UTC (permalink / raw)
  To: John Wiegley; +Cc: emacs-orgmode Org-Mode

Do you think it makes sense to integrate this code into org-depend.el?

- Carsten

On Jan 26, 2009, at 10:16 PM, John Wiegley wrote:

> I've been wanting a simple method for managing dependent tasks for  
> some time now, and only now did it occur to me that I could just  
> implement a much simpler method using your current blocking mechanism.
>
> The attached file, confusingly named org-depends.el, implements the  
> following scheme:
>
> 1. Any TODO which has incomplete child TODOs is blocked.
>
> 2. If a parent TODO has the ORDERED property, it's children must be
>    completed in order.  Undone siblings block later siblings.
>
> 3. Blocked items are greyed out in the agenda list.
>
> John
>
> <org-depends.el>

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-27  6:47 ` Carsten Dominik
@ 2009-01-27  7:31   ` John Wiegley
  2009-01-27  7:43     ` Carsten Dominik
  0 siblings, 1 reply; 12+ messages in thread
From: John Wiegley @ 2009-01-27  7:31 UTC (permalink / raw)
  To: Carsten Dominik; +Cc: emacs-orgmode Org-Mode

On Jan 27, 2009, at 2:47 AM, Carsten Dominik wrote:

> Do you think it makes sense to integrate this code into org-depend.el?

Actually, I don't, since it's a completely different approach.  org- 
depend.el as it stands now is based on a programmatic methodology,  
which more complex blocking schemes could be built on top of.

I think this module represents something much simpler, which should be  
toggled by a single global boolean to indicate "on" or "off".  My  
preference would be to see it mainlined, if that meets with your  
approval, Carsten.

John

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-27  7:31   ` John Wiegley
@ 2009-01-27  7:43     ` Carsten Dominik
  0 siblings, 0 replies; 12+ messages in thread
From: Carsten Dominik @ 2009-01-27  7:43 UTC (permalink / raw)
  To: John Wiegley; +Cc: emacs-orgmode Org-Mode

Hi John,

I realize now that you do not make use of the code in
org-depend.el at all, which is what I thought at first.

Two options:

- I can add the file, but then under a different name - org-depend
   and org-depends are not different in the first 8 characters.
- I can move the code to org-agenda.el and create a variable to
   turn this behavior on and off.

- Carsten

On Jan 27, 2009, at 8:31 AM, John Wiegley wrote:

> On Jan 27, 2009, at 2:47 AM, Carsten Dominik wrote:
>
>> Do you think it makes sense to integrate this code into org- 
>> depend.el?
>
> Actually, I don't, since it's a completely different approach.  org- 
> depend.el as it stands now is based on a programmatic methodology,  
> which more complex blocking schemes could be built on top of.
>
> I think this module represents something much simpler, which should  
> be toggled by a single global boolean to indicate "on" or "off".  My  
> preference would be to see it mainlined, if that meets with your  
> approval, Carsten.
>
> John
>

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-26 21:16 A much simpler way of handling dependent tasks John Wiegley
                   ` (2 preceding siblings ...)
  2009-01-27  6:47 ` Carsten Dominik
@ 2009-01-27 22:51 ` Mike Newman
  2009-01-30 15:02 ` Rainer Stengele
  4 siblings, 0 replies; 12+ messages in thread
From: Mike Newman @ 2009-01-27 22:51 UTC (permalink / raw)
  To: emacs-orgmode



On Mon, 26 Jan 2009 17:16:17 -0400
John Wiegley <johnw@newartisans.com> wrote:

> I've been wanting a simple method for managing dependent tasks for  
> some time now, and only now did it occur to me that I could just  
> implement a much simpler method using your current blocking mechanism.
> 
> The attached file, confusingly named org-depends.el, implements the  
> following scheme:
> 
>   1. Any TODO which has incomplete child TODOs is blocked.
> 
>   2. If a parent TODO has the ORDERED property, it's children must be
>      completed in order.  Undone siblings block later siblings.
> 
>   3. Blocked items are greyed out in the agenda list.
> 
> John
> 

This sounds like a sensible approach that would cover most my needs for
dependencies between TODOs
-- 
Mike

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-26 21:16 A much simpler way of handling dependent tasks John Wiegley
                   ` (3 preceding siblings ...)
  2009-01-27 22:51 ` Mike Newman
@ 2009-01-30 15:02 ` Rainer Stengele
  2009-01-30 17:37   ` Carsten Dominik
  4 siblings, 1 reply; 12+ messages in thread
From: Rainer Stengele @ 2009-01-30 15:02 UTC (permalink / raw)
  To: John Wiegley; +Cc: emacs-orgmode Org-Mode

John Wiegley schrieb:
> I've been wanting a simple method for managing dependent tasks for some
> time now, and only now did it occur to me that I could just implement a
> much simpler method using your current blocking mechanism.
> 
> The attached file, confusingly named org-depends.el, implements the
> following scheme:
> 
>  1. Any TODO which has incomplete child TODOs is blocked.
> 
>  2. If a parent TODO has the ORDERED property, it's children must be
>     completed in order.  Undone siblings block later siblings.
> 
>  3. Blocked items are greyed out in the agenda list.
> 
> John
> 
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Emacs-orgmode mailing list
> Remember: use `Reply All' to send replies to the list.
> Emacs-orgmode@gnu.org
> http://lists.gnu.org/mailman/listinfo/emacs-orgmode

John Wiegley schrieb:
> I've been wanting a simple method for managing dependent tasks for some
> time now, and only now did it occur to me that I could just implement a
> much simpler method using your current blocking mechanism.
>
> The attached file, confusingly named org-depends.el, implements the
> following scheme:
>
>  1. Any TODO which has incomplete child TODOs is blocked.
>
>  2. If a parent TODO has the ORDERED property, it's children must be
>     completed in order.  Undone siblings block later siblings.
>
>  3. Blocked items are greyed out in the agenda list.
>
> John
>
>
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> Emacs-orgmode mailing list
> Remember: use `Reply All' to send replies to the list.
> Emacs-orgmode@gnu.org
> http://lists.gnu.org/mailman/listinfo/emacs-orgmode

Excellent feature! Thanks a lot!
Unfortunately most of the times I do use this approach:

* TODO something [0/3]
  - [ ] part 1
  - [ ] part 2
  - [ ] part 3

I would like to get the blocking behavior for the checklist also.

"Any TODO which has incomplete child items is blocked."

Even better would additionally be something like:

"Any TODO having at least one item checked is allows the TODO to be set to the
next possible state, for me it would be 'INWORK'."

Any chance to get at least the blocker feature - the order feature would at
least for me be lower priority?


Rainer

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-30 15:02 ` Rainer Stengele
@ 2009-01-30 17:37   ` Carsten Dominik
  2009-01-30 20:07     ` John Wiegley
  0 siblings, 1 reply; 12+ messages in thread
From: Carsten Dominik @ 2009-01-30 17:37 UTC (permalink / raw)
  To: Rainer Stengele; +Cc: John Wiegley, emacs-orgmode Org-Mode

Hi Rainer,

On Jan 30, 2009, at 4:02 PM, Rainer Stengele wrote:

> John Wiegley schrieb:
>> I've been wanting a simple method for managing dependent tasks for  
>> some
>> time now, and only now did it occur to me that I could just  
>> implement a
>> much simpler method using your current blocking mechanism.
>>
>> The attached file, confusingly named org-depends.el, implements the
>> following scheme:
>>
>> 1. Any TODO which has incomplete child TODOs is blocked.
>>
>> 2. If a parent TODO has the ORDERED property, it's children must be
>>    completed in order.  Undone siblings block later siblings.
>>
>> 3. Blocked items are greyed out in the agenda list.
>>
>> John
>>
>>
>>
>> ------------------------------------------------------------------------
>>
>> _______________________________________________
>> Emacs-orgmode mailing list
>> Remember: use `Reply All' to send replies to the list.
>> Emacs-orgmode@gnu.org
>> http://lists.gnu.org/mailman/listinfo/emacs-orgmode
>
> John Wiegley schrieb:
>> I've been wanting a simple method for managing dependent tasks for  
>> some
>> time now, and only now did it occur to me that I could just  
>> implement a
>> much simpler method using your current blocking mechanism.
>>
>> The attached file, confusingly named org-depends.el, implements the
>> following scheme:
>>
>> 1. Any TODO which has incomplete child TODOs is blocked.
>>
>> 2. If a parent TODO has the ORDERED property, it's children must be
>>    completed in order.  Undone siblings block later siblings.
>>
>> 3. Blocked items are greyed out in the agenda list.
>>
>> John
>>
>>
>>
>> ------------------------------------------------------------------------
>>
>> _______________________________________________
>> Emacs-orgmode mailing list
>> Remember: use `Reply All' to send replies to the list.
>> Emacs-orgmode@gnu.org
>> http://lists.gnu.org/mailman/listinfo/emacs-orgmode
>
> Excellent feature! Thanks a lot!
> Unfortunately most of the times I do use this approach:
>
> * TODO something [0/3]
>  - [ ] part 1
>  - [ ] part 2
>  - [ ] part 3
>
> I would like to get the blocking behavior for the checklist also.
>
> "Any TODO which has incomplete child items is blocked."

Yes, this is an obvious extension, and I was implementing this already.
It is now present in the git repo, dependent on the variable
org-enforce-todo-checkbox-dependencies.

> Even better would additionally be something like:
>
> "Any TODO having at least one item checked is allows the TODO to be  
> set to the
> next possible state, for me it would be 'INWORK'."

I think is is too special.  You may want to switch such an entry
to INWORK even before the first checkbox can be checked off.
Or you may want to switch to WAITING because you are waiting
for an email that will allow you to check off the first item...

So my feeling is that switching from one not-done state to
another not-done state should not be blocked at all.
In fact, I feel the same for the straight TODO dependencies.

I have now adapted John's mechanism in the following way:

- You are free to change between the different non-done states

- Entries that cannot be switched to DONE will be greyed in
   the agenda, but you can still use the agenda to switch them
   between not-done states.

- If you call `C-c C-t' (or `t' in the agenda) with a
   tripple C-u prefix, any blocking will be circumvented
   for the upcoming state change.  This is good if you
   want to cancel such a tree, before all subitems are done.

I think this is good, and I hope that John agrees.

> Any chance to get at least the blocker feature - the order feature  
> would at
> least for me be lower priority?

No plans to make an ORDER feature for checkboxes.
Checkboxes should be light.

Thanks for your input!

- Carsten
>

> Rainer
>

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: A much simpler way of handling dependent tasks
  2009-01-30 17:37   ` Carsten Dominik
@ 2009-01-30 20:07     ` John Wiegley
  0 siblings, 0 replies; 12+ messages in thread
From: John Wiegley @ 2009-01-30 20:07 UTC (permalink / raw)
  To: Carsten Dominik; +Cc: emacs-orgmode Org-Mode, Rainer Stengele

On Jan 30, 2009, at 1:37 PM, Carsten Dominik wrote:

> So my feeling is that switching from one not-done state to
> another not-done state should not be blocked at all.
> In fact, I feel the same for the straight TODO dependencies.
>
> I have now adapted John's mechanism in the following way:
>
> - You are free to change between the different non-done states
>
> - Entries that cannot be switched to DONE will be greyed in
>  the agenda, but you can still use the agenda to switch them
>  between not-done states.
>
> - If you call `C-c C-t' (or `t' in the agenda) with a
>  tripple C-u prefix, any blocking will be circumvented
>  for the upcoming state change.  This is good if you
>  want to cancel such a tree, before all subitems are done.
>
> I think this is good, and I hope that John agrees.

Very much so, that's a great extension.  I use checkboxes like Rainer  
does constantly, for "lightweight dependent" tasks.  I'll make use of  
this extension a great deal.

John

^ permalink raw reply	[flat|nested] 12+ messages in thread

end of thread, other threads:[~2009-01-30 20:07 UTC | newest]

Thread overview: 12+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2009-01-26 21:16 A much simpler way of handling dependent tasks John Wiegley
2009-01-26 23:48 ` Oliver Charles
2009-01-27  1:18   ` Jesse Alama
2009-01-27  6:46     ` Carsten Dominik
2009-01-27  6:47 ` John Wiegley
2009-01-27  6:47 ` Carsten Dominik
2009-01-27  7:31   ` John Wiegley
2009-01-27  7:43     ` Carsten Dominik
2009-01-27 22:51 ` Mike Newman
2009-01-30 15:02 ` Rainer Stengele
2009-01-30 17:37   ` Carsten Dominik
2009-01-30 20:07     ` John Wiegley

Code repositories for project(s) associated with this inbox:

	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).