Mostra i blocchi di tempo gratuiti nell'agenda della modalità org

Vorrei semplificare la ricerca dei blocchi di tempo gratuiti nella mia agenda in modalità organizzazione.

Ad esempio, se ho due appuntamenti uno dalle 9:30 alle 10:30 e un altro dalle 11:15 alle 12:30, vorrei vedere a colpo d'occhio che il blocco 10:30 - 11:15 è gratuito.

In altre parole, voglio essere in grado di distinguere il tempo libero con la stessa facilità con cui viene fatto in un'agenda grafica come Google Calendar.

C'è un modo per rendere visibili i blocchi di tempo vuoti? Forse per colorare i blocchi vuoti che sono più lunghi di un determinato numero di minuti?

A causa di questa mia domanda, ho esaminato la funzione org-agenda-add-time-grid-maybeche crea la griglia temporale. Il codice pubblicato lì (che non è stato scritto da me) rimuove una linea di griglia se il tempo è occupato come richiesto nel commento del PO.

Come te, volevo creare un blocco visivo in qualche modo. Mischiando il codice originale di org-agenda-add-time-grid-maybee il defadvice di Michael Ekstrand pubblicato nell'altra discussione, ho trovato il seguente codice per org-agenda-add-time-grid-maybe. Produrrà le linee della griglia in un colore diverso (per il momento uso la faccia org-archived) e i tempi saranno seguiti da una stringa diversa. Entrambi possono essere modificati a proprio piacimento.

(defun org-agenda-add-time-grid-maybe (list ndays todayp)
  "Add a time-grid for agenda items which need it.

LIST is the list of agenda items formatted by `org-agenda-list'.
NDAYS is the span of the current agenda view.
TODAYP is t when the current agenda view is on today."

  (catch 'exit
   (cond ((not org-agenda-use-time-grid) (throw 'exit list))
         ((and todayp (member 'today (car org-agenda-time-grid))))
         ((and (= ndays 1) (member 'daily (car org-agenda-time-grid))))
         ((member 'weekly (car org-agenda-time-grid)))
         (t (throw 'exit list)))
   (let* ((blocks (mapcar (lambda (x)
                            (let ((start (get-text-property 1 'time-of-day x))
                                  (dur (get-text-property 1 'duration x)))
                              (cond
                               ((and start dur) (cons start
                                                      (org-time-from-minutes
                                                       (truncate
                                                        (+ dur (org-time-to-minutes start))))))
                               (start start)
                               (t nil))))
                          list))
          (have (delq nil (mapcar
                           (lambda (x) (get-text-property 1 'time-of-day x))
                           list)))
          (string (nth 3 org-agenda-time-grid))
          (gridtimes (nth 1 org-agenda-time-grid))
          (req (car org-agenda-time-grid))
          (remove (member 'remove-match req))
          new time)
     (if (and (member 'require-timed req) (not have))
         ;; don't show empty grid
         (throw 'exit list))

     (while (setq time (pop gridtimes))
       (unless (and remove (member time have))
         (let* ((windows (delq nil blocks))
                (hit nil))
           (dolist (busy windows)
             (unless hit
               (when (and (>= time (car busy))
                          (< time (cdr busy)))
                 (setq hit t))))
           (setq time (replace-regexp-in-string " " "0" (format "%04s" time)))
           (if hit
               (progn
                 (push (org-agenda-format-item
                        (concat string " dito") string nil "" nil
                        (concat (substring time 0 -2) ":" (substring time -2)))
                       new)
                 (put-text-property 2 (length (car new)) 'face 'org-archived (car new)))
             (progn
               (push (org-agenda-format-item
                      nil string nil "" nil
                      (concat (substring time 0 -2) ":" (substring time -2)))
                     new)
               (put-text-property 2 (length (car new)) 'face 'org-time-grid (car new))))
           (setq hit nil))))

     (when (and todayp org-agenda-show-current-time-in-grid)
       (push (org-agenda-format-item
              nil org-agenda-current-time-string nil "" nil
              (format-time-string "%H:%M "))
             new)
       (put-text-property
        2 (length (car new)) 'face 'org-agenda-current-time (car new)))

     (if (member 'time-up org-agenda-sorting-strategy-selected)
         (append new list)
       (append list new)))))

(defun org-time-to-minutes (time)
  "Convert an HHMM TIME to minutes."
  (+ (* (/ time 100) 60) (% time 100)))

(defun org-time-from-minutes (minutes)
  "Convert a number of MINUTES to an HHMM time."
  (+ (* (/ minutes 60) 100) (% minutes 60)))

Ovviamente, sarebbe più elegante usare defadvice, ma non sono riuscito a capire esattamente dove intervenire. La stessa funzione passa attraverso ogni tempo della griglia (impostato in org-agenda-time-grid) e crea un nuovo elenco con la griglia finale includendo le facce (nuove).