Tkinter ToDo: edición, colores y ordenación de tareas

El artículo describe la ampliación de la aplicación Tkinter ToDo con nuevas funciones: edición de tareas mediante ventanas modales, indicación de color de prioridades, ordenación de tareas sin terminar y almacenamiento de fechas de creación. Se proporciona código completo con compatibilidad hacia atrás de datos JSON y técnicas de estilos de Listbox.

By Sudonull Editorial Team • Published 2026-04-14 • Updated 2026-04-14

Tkinter ToDo: colores, ordenación y ventanas modales de edición

Extendiendo una App Tkinter de Tareas: Edición, Colores, Ordenación y Fechas

Extender la funcionalidad requiere actualizar la estructura de las tareas. Cada tarea ahora incluye los campos: id, text, completed, created_at (cadena ISO) y priority (alta/media/baja). Para mantener la compatibilidad con versiones anteriores, se implementa la migración de datos antiguos con valores por defecto.

Las funciones de carga y guardado aseguran una integración sin problemas:

import json
import os
from datetime import datetime

TASKS_FILE = "tasks.json"

def load_tasks():
    """Carga las tareas desde un archivo JSON con compatibilidad hacia atrás"""
    if not os.path.exists(TASKS_FILE):
        return []
    with open(TASKS_FILE, "r", encoding="utf-8") as f:
        try:
            tasks = json.load(f)
            # Migrar tareas antiguas (añadir created_at y priority si faltan)
            for task in tasks:
                if "created_at" not in task:
                    task["created_at"] = datetime.now().isoformat()
                if "priority" not in task:
                    task["priority"] = "media"
            return tasks
        except json.JSONDecodeError:
            return []

def save_tasks(tasks):
    """Guarda las tareas en un archivo JSON"""
    with open(TASKS_FILE, "w", encoding="utf-8") as f:
        json.dump(tasks, f, ensure_ascii=False, indent=2)

def get_next_id(tasks):
    """Devuelve el siguiente ID disponible para una nueva tarea"""
    if not tasks:
        return 1
    return max(task["id"] for task in tasks) + 1

datetime.now().isoformat() genera una cadena ordenable en el formato 2025-03-22T15:30:45.123456.

Ordenación e Indicadores Visuales

La ordenación se implementa sin alterar el orden original de las tareas en self.tasks. El método get_sorted_tasks devuelve una copia:

Primero, tareas incompletas (completed == False)
Luego, tareas completadas
Dentro de los grupos — por id

class TodoApp:
    
    def get_sorted_tasks(self):
        """Devuelve las tareas ordenadas para mostrar: activas primero, luego completadas"""
        active_tasks = [task for task in self.tasks if not task["completed"]]
        completed_tasks = [task for task in self.tasks if task["completed"]]
        active_tasks.sort(key=lambda x: x["id"])
        completed_tasks.sort(key=lambda x: x["id"])
        return active_tasks + completed_tasks

    def refresh_task_list(self):
        """Actualiza la visualización de la lista de tareas con ordenación e indicadores de color"""
        self.task_listbox.delete(0, tk.END)
        sorted_tasks = self.get_sorted_tasks()

        for task in sorted_tasks:
            status = "✓" if task["completed"] else "○"
            try:
                created = datetime.fromisoformat(task["created_at"])
                date_str = created.strftime("%d/%m/%y %H:%M")
            except:
                date_str = "fecha desconocida"

            display_text = f"{status} [{date_str}] {task['id']}. {task['text']}"

            self.task_listbox.insert(tk.END, display_text)

            bg_color = "white"
            fg_color = "black"

            if task["completed"]:
                fg_color = "green"
                bg_color = "light gray"
            else:
                if task["priority"] == "alta":
                    fg_color = "red"
                    bg_color = "#ffe6e6"
                elif task["priority"] == "media":
                    fg_color = "orange"
                    bg_color = "#fff0e6"

            index = tk.END
            self.task_listbox.itemconfig(tk.END, bg=bg_color, fg=fg_color)

Técnicas clave:

itemconfig(index, bg=..., fg=...) para estilizar filas del Listbox
strftime("%d/%m/%y %H:%M") para formato de fecha localizado
Ordenación perezosa solo durante refresh_task_list

Ventana Modal de Edición

La edición abre una ventana Toplevel con grab_set() para modalidad. La lógica encuentra la tarea por id desde la lista ordenada:

class TodoApp:
   def edit_task(self):
        selection = self.task_listbox.curselection()
        if not selection:
            messagebox.showwarning("Advertencia", "Selecciona una tarea para editar")
            return

        selected_index = selection[0]
        sorted_tasks = self.get_sorted_tasks()
        selected_task = sorted_tasks[selected_index]
        task_id = selected_task["id"]

        task_to_edit = None
        task_index = None
        for i, task in enumerate(self.tasks):
            if task["id"] == task_id:
                task_to_edit = task
                task_index = i
                break

        if not task_to_edit:
            return

        edit_window = tk.Toplevel(self.root)
        edit_window.title(f"Editando Tarea #{task_id}")
        edit_window.geometry("450x250")
        edit_window.resizable(False, False)
        edit_window.grab_set()

        tk.Label(edit_window, text="Texto de la Tarea:").pack(pady=(10, 0), anchor=tk.W, padx=10)
        text_entry = tk.Text(edit_window, height=4, width=50, font=("Arial", 10))
        text_entry.pack(pady=5, padx=10, fill=tk.BOTH, expand=True)
        text_entry.insert("1.0", task_to_edit["text"])

        tk.Label(edit_window, text="Prioridad:").pack(pady=(5, 0), anchor=tk.W, padx=10)
        priority_var = tk.StringVar(value=task_to_edit["priority"])
        priority_frame = tk.Frame(edit_window)
        priority_frame.pack(pady=5, padx=10, anchor=tk.W)

        tk.Radiobutton(priority_frame, text="Alta", variable=priority_var, value="alta", fg="red").pack(side=tk.LEFT, padx=5)
        tk.Radiobutton(priority_frame, text="Media", variable=priority_var, value="media", fg="orange").pack(side=tk.LEFT, padx=5)
        tk.Radiobutton(priority_frame, text="Baja", variable=priority_var, value="baja").pack(side=tk.LEFT, padx=5)

        button_frame = tk.Frame(edit_window)
        button_frame.pack(pady=15)

        def save_edit():
            new_text = text_entry.get("1.0", "end-1c").strip()
            if not new_text:
                messagebox.showwarning("Advertencia", "El texto de la tarea no puede estar vacío", parent=edit_window)
                return

            task_to_edit["text"] = new_text
            task_to_edit["priority"] = priority_var.get()
            save_tasks(self.tasks)
            self.refresh_task_list()
            edit_window.destroy()
            messagebox.showinfo("Éxito", f"Tarea #{task_id} actualizada")

        tk.Button(button_frame, text="Guardar", command=save_edit, bg="light green", width=10).pack(side=tk.LEFT, padx=5)
        tk.Button(button_frame, text="Cancelar", command=edit_window.destroy, bg="light gray", width=10).pack(side=tk.LEFT, padx=5)

Integración: Añadir self.edit_button = tk.Button(bottom_frame, text="✏ Editar", command=self.edit_task) a create_widgets.

Diálogo para Añadir Tarea con Prioridad

El método add_task usa una estructura Toplevel similar con enfoque en Entry y botones de radio:

text_entry.focus() para UX
Validación con strip() y comprobación de vacío
Auto-generación de id, created_at, completed=False

El código completo del método asegura consistencia con la edición.

Puntos Clave

Compatibilidad hacia atrás: Migración automática de created_at y priority al cargar
Rendimiento: Ordenación de una copia de la lista, dejando los datos persistentes intactos
Estilización del Listbox: itemconfig(tk.END, bg=..., fg=...) para colores dinámicos
Ventanas Modales: Toplevel + grab_set() + resizable(False, False)
Formato de Fechas: strftime para visualización legible de cadenas ISO