884 lines
31 KiB
Python
884 lines
31 KiB
Python
import json
|
|
import os
|
|
from pathlib import Path
|
|
from typing import List
|
|
|
|
import cairo
|
|
import gi
|
|
from fabric.widgets.centerbox import CenterBox
|
|
from fabric.widgets.label import Label
|
|
from fabric.widgets.scrolledwindow import ScrolledWindow
|
|
from gi.repository import Gdk, GLib, GObject, Gtk
|
|
|
|
import utils.icons as icons
|
|
from modules.launcher.plugin_base import PluginBase
|
|
from modules.launcher.result import Result
|
|
|
|
gi.require_version("Gtk", "3.0")
|
|
|
|
|
|
def createSurfaceFromWidget(widget: Gtk.Widget) -> cairo.ImageSurface:
|
|
alloc = widget.get_allocation()
|
|
surface = cairo.ImageSurface(cairo.Format.ARGB32, alloc.width, alloc.height)
|
|
cr = cairo.Context(surface)
|
|
|
|
cr.set_source_rgba(0, 0, 0, 0)
|
|
cr.rectangle(0, 0, alloc.width, alloc.height)
|
|
cr.fill()
|
|
widget.draw(cr)
|
|
return surface
|
|
|
|
|
|
class InlineEditor(Gtk.Box):
|
|
__gsignals__ = {
|
|
"confirmed": (GObject.SignalFlags.RUN_LAST, None, (str,)),
|
|
"canceled": (GObject.SignalFlags.RUN_LAST, None, ()),
|
|
}
|
|
|
|
def __init__(self, initial_text=""):
|
|
super().__init__(name="inline-editor", spacing=4)
|
|
|
|
self.text_view = Gtk.TextView()
|
|
self.text_view.set_wrap_mode(Gtk.WrapMode.WORD)
|
|
buffer = self.text_view.get_buffer()
|
|
buffer.set_text(initial_text)
|
|
|
|
self.text_view.connect("key-press-event", self.on_key_press)
|
|
|
|
# Create labels for buttons
|
|
confirm_label = Gtk.Label()
|
|
confirm_label.set_markup(icons.accept)
|
|
confirm_label.set_name("kanban-btn-label")
|
|
|
|
cancel_label = Gtk.Label()
|
|
cancel_label.set_markup(icons.cancel)
|
|
cancel_label.set_name("kanban-btn-neg")
|
|
|
|
confirm_btn = Gtk.Button()
|
|
confirm_btn.set_name("kanban-btn")
|
|
confirm_btn.add(confirm_label)
|
|
confirm_btn.connect("clicked", self.on_confirm)
|
|
confirm_btn.get_style_context().add_class("flat")
|
|
|
|
cancel_btn = Gtk.Button()
|
|
cancel_btn.set_name("kanban-btn")
|
|
cancel_btn.add(cancel_label)
|
|
cancel_btn.connect("clicked", self.on_cancel)
|
|
cancel_btn.get_style_context().add_class("flat")
|
|
|
|
sw = Gtk.ScrolledWindow()
|
|
sw.set_name("scrolled-window")
|
|
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
|
|
sw.set_min_content_height(50)
|
|
sw.add(self.text_view)
|
|
|
|
self.button_box = Gtk.Box(spacing=4)
|
|
self.button_box.pack_start(confirm_btn, False, False, 0)
|
|
self.button_box.pack_start(cancel_btn, False, False, 0)
|
|
|
|
self.center_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
|
|
self.center_box.set_halign(Gtk.Align.CENTER)
|
|
self.center_box.pack_start(self.button_box, False, False, 0)
|
|
|
|
self.pack_start(sw, True, True, 0)
|
|
self.pack_start(self.center_box, False, False, 0)
|
|
self.show_all()
|
|
|
|
def on_confirm(self, widget):
|
|
buffer = self.text_view.get_buffer()
|
|
start, end = buffer.get_bounds()
|
|
text = buffer.get_text(start, end, True).strip()
|
|
if text:
|
|
self.emit("confirmed", text)
|
|
else:
|
|
self.emit("canceled")
|
|
|
|
def on_cancel(self, widget):
|
|
self.emit("canceled")
|
|
|
|
def on_key_press(self, widget, event):
|
|
if event.keyval == Gdk.KEY_Escape:
|
|
self.emit("canceled")
|
|
return True
|
|
|
|
if event.keyval in (Gdk.KEY_Return, Gdk.KEY_KP_Enter):
|
|
state = event.get_state()
|
|
if state & Gdk.ModifierType.SHIFT_MASK:
|
|
buffer = self.text_view.get_buffer()
|
|
cursor_iter = buffer.get_iter_at_mark(buffer.get_insert())
|
|
buffer.insert(cursor_iter, "\n")
|
|
return True
|
|
else:
|
|
self.on_confirm(widget)
|
|
return True
|
|
return False
|
|
|
|
|
|
class KanbanNote(Gtk.EventBox):
|
|
__gsignals__ = {
|
|
"changed": (GObject.SignalFlags.RUN_LAST, None, ()),
|
|
}
|
|
|
|
def __init__(self, text):
|
|
super().__init__()
|
|
self.text = text
|
|
|
|
# Make focusable for keyboard events
|
|
self.set_can_focus(True)
|
|
|
|
self.setup_ui()
|
|
self.setup_dnd()
|
|
self.connect("button-press-event", self.on_button_press)
|
|
self.connect("key-press-event", self.on_key_press)
|
|
|
|
def setup_ui(self):
|
|
self.box = Gtk.Box(name="kanban-note", spacing=4)
|
|
self.label = Gtk.Label(label=self.text)
|
|
self.label.set_line_wrap(True)
|
|
|
|
self.label.set_line_wrap_mode(Gtk.WrapMode.WORD)
|
|
|
|
self.delete_btn = Gtk.Button(
|
|
name="kanban-btn", child=Label(name="kanban-btn-neg", markup=icons.trash)
|
|
)
|
|
self.delete_btn.connect("clicked", self.on_delete_clicked)
|
|
|
|
self.center_btn = CenterBox(orientation="v", start_children=[self.delete_btn])
|
|
|
|
self.box.pack_start(self.label, True, True, 0)
|
|
self.box.pack_start(self.center_btn, False, False, 0)
|
|
self.add(self.box)
|
|
self.show_all()
|
|
|
|
def setup_dnd(self):
|
|
self.drag_source_set(
|
|
Gdk.ModifierType.BUTTON1_MASK,
|
|
[Gtk.TargetEntry.new("UTF8_STRING", Gtk.TargetFlags.SAME_APP, 0)],
|
|
Gdk.DragAction.MOVE,
|
|
)
|
|
self.connect("drag-data-get", self.on_drag_data_get)
|
|
self.connect("drag-data-delete", self.on_drag_data_delete)
|
|
|
|
self.connect("drag-begin", self.on_drag_begin)
|
|
|
|
def on_button_press(self, widget, event):
|
|
if event.type != Gdk.EventType._2BUTTON_PRESS:
|
|
return True
|
|
self.start_edit()
|
|
return False
|
|
|
|
def on_key_press(self, widget, event):
|
|
"""Handle keyboard events for kanban notes."""
|
|
from gi.repository import Gdk
|
|
|
|
keyval = event.keyval
|
|
|
|
# Enter or F2 - start editing
|
|
if keyval in (Gdk.KEY_Return, Gdk.KEY_F2):
|
|
self.start_edit()
|
|
return True
|
|
|
|
# Delete - remove note
|
|
if keyval == Gdk.KEY_Delete:
|
|
self.get_parent().destroy()
|
|
return True
|
|
|
|
return False
|
|
|
|
def on_drag_begin(self, widget, context):
|
|
surface = createSurfaceFromWidget(self)
|
|
Gtk.drag_set_icon_surface(context, surface)
|
|
|
|
def on_drag_data_get(self, widget, drag_context, data, info, time):
|
|
data.set_text(self.label.get_text(), -1)
|
|
|
|
def on_drag_data_delete(self, widget, drag_context):
|
|
self.get_parent().destroy()
|
|
|
|
def on_delete_clicked(self, button):
|
|
self.get_parent().destroy()
|
|
|
|
def start_edit(self):
|
|
row = self.get_parent()
|
|
editor = InlineEditor(self.label.get_text())
|
|
|
|
def on_confirmed(editor, text):
|
|
self.label.set_text(text)
|
|
# Ensure editor is properly removed before adding self back
|
|
if editor.get_parent():
|
|
editor.get_parent().remove(editor)
|
|
if not self.get_parent():
|
|
row.add(self)
|
|
row.show_all()
|
|
self.emit("changed")
|
|
|
|
def on_canceled(editor):
|
|
# Ensure editor is properly removed before adding self back
|
|
if editor.get_parent():
|
|
editor.get_parent().remove(editor)
|
|
if not self.get_parent():
|
|
row.add(self)
|
|
row.show_all()
|
|
|
|
editor.connect("confirmed", on_confirmed)
|
|
editor.connect("canceled", on_canceled)
|
|
|
|
# Only remove self if it has a parent
|
|
if self.get_parent():
|
|
row.remove(self)
|
|
row.add(editor)
|
|
row.show_all()
|
|
|
|
GLib.timeout_add(50, lambda: (editor.text_view.grab_focus(), False))
|
|
|
|
|
|
class KanbanColumn(Gtk.Frame):
|
|
__gsignals__ = {
|
|
"changed": (GObject.SignalFlags.RUN_LAST, None, ()),
|
|
}
|
|
|
|
def __init__(self, title):
|
|
super().__init__(name="kanban-column")
|
|
self.title = title
|
|
self.setup_ui()
|
|
self.setup_dnd()
|
|
self.set_hexpand(True)
|
|
self.set_vexpand(True)
|
|
# Set size constraints for launcher compatibility
|
|
self.set_size_request(-1, 150) # Fixed height per column
|
|
|
|
def setup_ui(self):
|
|
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
|
|
self.listbox = Gtk.ListBox()
|
|
self.listbox.set_selection_mode(Gtk.SelectionMode.NONE)
|
|
|
|
self.add_btn = Gtk.Button(
|
|
name="kanban-btn-add",
|
|
child=Label(name="kanban-btn-label", markup=icons.add),
|
|
)
|
|
header = CenterBox(
|
|
name="kanban-header",
|
|
center_children=[Label(name="column-header", label=self.title)],
|
|
end_children=[self.add_btn],
|
|
)
|
|
self.box.pack_start(header, False, False, 0)
|
|
|
|
self.add_btn.connect("clicked", self.on_add_clicked)
|
|
|
|
self.scroller = ScrolledWindow(
|
|
name="scrolled-window", propagate_height=False, propagate_width=False
|
|
)
|
|
self.scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
|
|
self.scroller.add(self.listbox)
|
|
self.scroller.set_vexpand(True)
|
|
|
|
self.box.pack_start(self.scroller, True, True, 0)
|
|
self.box.pack_start(self.add_btn, False, False, 0)
|
|
self.add(self.box)
|
|
self.show_all()
|
|
|
|
def setup_dnd(self):
|
|
self.listbox.drag_dest_set(
|
|
Gtk.DestDefaults.ALL,
|
|
[Gtk.TargetEntry.new("UTF8_STRING", Gtk.TargetFlags.SAME_APP, 0)],
|
|
Gdk.DragAction.MOVE,
|
|
)
|
|
|
|
self.listbox.connect("drag-data-received", self.on_drag_data_received)
|
|
self.listbox.connect("drag-motion", self.on_drag_motion)
|
|
self.listbox.connect("drag-leave", self.on_drag_leave)
|
|
|
|
def on_add_clicked(self, button):
|
|
editor = InlineEditor()
|
|
row = Gtk.ListBoxRow(name="kanban-row")
|
|
row.add(editor)
|
|
self.listbox.add(row)
|
|
self.listbox.show_all()
|
|
editor.text_view.grab_focus()
|
|
|
|
def on_confirmed(editor, text):
|
|
note = KanbanNote(text)
|
|
note.connect("changed", lambda x: self.emit("changed"))
|
|
# Ensure editor is properly removed before adding note
|
|
if editor.get_parent():
|
|
editor.get_parent().remove(editor)
|
|
row.add(note)
|
|
self.listbox.show_all()
|
|
self.emit("changed")
|
|
|
|
def on_canceled(editor):
|
|
row.destroy()
|
|
|
|
def scroll_to_bottom():
|
|
adj = self.scroller.get_vadjustment()
|
|
adj.set_value(adj.get_upper())
|
|
|
|
editor.connect("confirmed", on_confirmed)
|
|
editor.connect("canceled", on_canceled)
|
|
|
|
# ensure this is called after row is loaded
|
|
GLib.idle_add(scroll_to_bottom)
|
|
|
|
def add_note(self, text, suppress_signal=False):
|
|
note = KanbanNote(text)
|
|
note.connect("changed", lambda x: self.emit("changed"))
|
|
row = Gtk.ListBoxRow(name="kanban-row")
|
|
row.add(note)
|
|
row.connect("destroy", lambda x: self.emit("changed"))
|
|
self.listbox.add(row)
|
|
self.listbox.show_all()
|
|
if not suppress_signal:
|
|
self.emit("changed")
|
|
|
|
def get_notes(self):
|
|
return [
|
|
row.get_children()[0].label.get_text()
|
|
for row in self.listbox.get_children()
|
|
if isinstance(row.get_children()[0], KanbanNote)
|
|
]
|
|
|
|
def clear_notes(self, suppress_signal=False):
|
|
for row in self.listbox.get_children():
|
|
row.destroy()
|
|
if not suppress_signal:
|
|
self.emit("changed")
|
|
|
|
def on_drag_data_received(self, widget, drag_context, x, y, data, info, time):
|
|
text = data.get_text()
|
|
if text:
|
|
row = self.listbox.get_row_at_y(y)
|
|
new_note = KanbanNote(text)
|
|
new_note.connect("changed", lambda x: self.emit("changed"))
|
|
new_row = Gtk.ListBoxRow(name="kanban-row")
|
|
new_row.add(new_note)
|
|
new_row.connect("destroy", lambda x: self.emit("changed"))
|
|
|
|
if row:
|
|
self.listbox.insert(new_row, row.get_index())
|
|
else:
|
|
self.listbox.add(new_row)
|
|
|
|
self.listbox.show_all()
|
|
drag_context.finish(True, False, time)
|
|
self.emit("changed")
|
|
|
|
def on_drag_motion(self, widget, drag_context, x, y, time):
|
|
Gdk.drag_status(drag_context, Gdk.DragAction.MOVE, time)
|
|
return True
|
|
|
|
def on_drag_leave(self, widget, drag_context, time):
|
|
widget.get_parent().get_parent().drag_unhighlight()
|
|
|
|
|
|
class Kanban(Gtk.Box):
|
|
STATE_FILE = Path(os.path.expanduser("~/.kanban.json"))
|
|
|
|
__gsignals__ = {
|
|
"todo-added": (GObject.SignalFlags.RUN_LAST, None, ()),
|
|
}
|
|
|
|
def __init__(self):
|
|
super().__init__(name="kanban", orientation=Gtk.Orientation.VERTICAL)
|
|
|
|
# Set size constraints to fit within launcher
|
|
self.set_size_request(-1, 500) # Fixed height to fit in launcher
|
|
self.set_vexpand(False)
|
|
self.set_hexpand(True)
|
|
|
|
# Make the widget focusable so it can receive key events
|
|
self.set_can_focus(True)
|
|
self.connect("key-press-event", self.on_key_press)
|
|
|
|
# Store pending add text for Enter key handling
|
|
self.pending_add_text = None
|
|
# Store pending command for Enter key handling
|
|
self.pending_command = None
|
|
|
|
# Add a hidden Entry widget so the launcher will let us handle Enter events
|
|
from fabric.widgets.entry import Entry
|
|
|
|
self.hidden_entry = Entry(name="kanban-hidden-entry")
|
|
self.hidden_entry.set_size_request(1, 1) # Make it tiny
|
|
self.hidden_entry.set_opacity(0.0) # Make it invisible
|
|
self.hidden_entry.connect("activate", self.on_hidden_entry_activate)
|
|
self.add(self.hidden_entry)
|
|
|
|
self.grid = Gtk.Grid(
|
|
column_spacing=4,
|
|
column_homogeneous=True,
|
|
row_spacing=4,
|
|
row_homogeneous=True,
|
|
)
|
|
self.grid.set_vexpand(True)
|
|
self.grid.set_hexpand(True)
|
|
self.add(self.grid)
|
|
|
|
self.columns = [
|
|
KanbanColumn("To Do"),
|
|
KanbanColumn("In Progress"),
|
|
KanbanColumn("Done"),
|
|
]
|
|
|
|
# Always use vertical layout (columns stacked vertically)
|
|
for i, column in enumerate(self.columns):
|
|
# Vertical layout - columns stacked on top of each other
|
|
self.grid.attach(column, 0, i, 1, 1)
|
|
column.connect("changed", lambda x: self.save_state())
|
|
|
|
self.load_state()
|
|
self.show_all()
|
|
|
|
def on_key_press(self, widget, event):
|
|
"""Handle key press events for the kanban widget."""
|
|
from gi.repository import Gdk
|
|
|
|
keyval = event.keyval
|
|
|
|
# Enter - handle pending commands
|
|
if keyval == Gdk.KEY_Return:
|
|
if self.pending_command:
|
|
command, text = self.pending_command
|
|
if command == "add":
|
|
self.columns[0].add_note(text)
|
|
self.save_state()
|
|
|
|
elif command == "move":
|
|
success = self._execute_move_command(text)
|
|
if success:
|
|
self.save_state()
|
|
elif command == "done":
|
|
success = self._execute_done_command(text)
|
|
if success:
|
|
self.save_state()
|
|
|
|
# Clear pending command and notify plugin to reset
|
|
self.pending_command = None
|
|
self.pending_add_text = None
|
|
self.emit("todo-added") # Reuse this signal for all commands
|
|
return True
|
|
elif self.pending_add_text:
|
|
# Fallback for old add system
|
|
self.columns[0].add_note(self.pending_add_text)
|
|
self.save_state()
|
|
self.pending_add_text = None
|
|
# Notify plugin to reset to trigger
|
|
self.emit("todo-added")
|
|
return True
|
|
|
|
# Ctrl+N - add new note to first column
|
|
if keyval == Gdk.KEY_n and event.state & Gdk.ModifierType.CONTROL_MASK:
|
|
self.columns[0].on_add_clicked(None)
|
|
return True
|
|
|
|
# Ctrl+1, Ctrl+2, Ctrl+3 - add note to specific column
|
|
if event.state & Gdk.ModifierType.CONTROL_MASK:
|
|
if keyval == Gdk.KEY_1 and len(self.columns) > 0:
|
|
self.columns[0].on_add_clicked(None)
|
|
return True
|
|
elif keyval == Gdk.KEY_2 and len(self.columns) > 1:
|
|
self.columns[1].on_add_clicked(None)
|
|
return True
|
|
elif keyval == Gdk.KEY_3 and len(self.columns) > 2:
|
|
self.columns[2].on_add_clicked(None)
|
|
return True
|
|
|
|
return False
|
|
|
|
def on_hidden_entry_activate(self, entry):
|
|
"""Handle activation of the hidden entry (Enter key from launcher)."""
|
|
if self.pending_command:
|
|
command, text = self.pending_command
|
|
if command == "add":
|
|
self.columns[0].add_note(text)
|
|
self.save_state()
|
|
elif command == "move":
|
|
success = self._execute_move_command(text)
|
|
if success:
|
|
self.save_state()
|
|
elif command == "done":
|
|
success = self._execute_done_command(text)
|
|
if success:
|
|
self.save_state()
|
|
|
|
# Clear pending command and notify plugin to reset
|
|
self.pending_command = None
|
|
self.pending_add_text = None
|
|
self.emit("todo-added") # Reuse this signal for all commands
|
|
elif self.pending_add_text:
|
|
# Fallback for old add system
|
|
self.columns[0].add_note(self.pending_add_text)
|
|
self.save_state()
|
|
self.pending_add_text = None
|
|
# Notify plugin to reset to trigger
|
|
self.emit("todo-added")
|
|
|
|
def set_pending_add_text(self, text):
|
|
"""Set the pending add text for Enter key handling."""
|
|
self.pending_add_text = text
|
|
# Don't grab focus - let the launcher manage focus
|
|
# The launcher will find our hidden entry when Enter is pressed
|
|
|
|
def _execute_move_command(self, todo_text: str) -> bool:
|
|
"""Execute move command within the widget."""
|
|
search_text = todo_text.lower().strip()
|
|
|
|
# Find todo across all columns
|
|
for col_idx, column in enumerate(self.columns):
|
|
notes = column.get_notes()
|
|
for note_text in notes:
|
|
if search_text in note_text.lower():
|
|
# Determine next column
|
|
if col_idx == 0: # To Do -> In Progress
|
|
next_col_idx = 1
|
|
next_state = "In Progress"
|
|
elif col_idx == 1: # In Progress -> Done
|
|
next_col_idx = 2
|
|
next_state = "Done"
|
|
else: # Already in Done
|
|
return False
|
|
|
|
# Remove from current column
|
|
for row in column.listbox.get_children():
|
|
note_widget = row.get_children()[0]
|
|
if (
|
|
isinstance(note_widget, KanbanNote)
|
|
and note_widget.label.get_text() == note_text
|
|
):
|
|
row.destroy()
|
|
break
|
|
|
|
# Add to next column
|
|
next_column = self.columns[next_col_idx]
|
|
next_column.add_note(note_text)
|
|
return True
|
|
|
|
return False
|
|
|
|
def _execute_done_command(self, todo_text: str) -> bool:
|
|
"""Execute done command within the widget."""
|
|
search_text = todo_text.lower().strip()
|
|
|
|
# Find todo across all columns (except Done)
|
|
# Only To Do and In Progress
|
|
for col_idx, column in enumerate(self.columns[:2]):
|
|
notes = column.get_notes()
|
|
for note_text in notes:
|
|
if search_text in note_text.lower():
|
|
# Remove from current column
|
|
for row in column.listbox.get_children():
|
|
note_widget = row.get_children()[0]
|
|
if (
|
|
isinstance(note_widget, KanbanNote)
|
|
and note_widget.label.get_text() == note_text
|
|
):
|
|
row.destroy()
|
|
break
|
|
|
|
# Add to Done column
|
|
done_column = self.columns[2]
|
|
done_column.add_note(note_text)
|
|
|
|
return True
|
|
|
|
# Check if already in Done column
|
|
done_notes = self.columns[2].get_notes()
|
|
for note_text in done_notes:
|
|
if search_text in note_text.lower():
|
|
return False
|
|
|
|
return False
|
|
|
|
def save_state(self):
|
|
state = {
|
|
"columns": [
|
|
{"title": col.title, "notes": col.get_notes()} for col in self.columns
|
|
]
|
|
}
|
|
try:
|
|
with open(self.STATE_FILE, "w") as f:
|
|
json.dump(state, f, indent=2)
|
|
except Exception as e:
|
|
print(f"Error saving state: {e}")
|
|
|
|
def load_state(self):
|
|
try:
|
|
with open(self.STATE_FILE, "r") as f:
|
|
state = json.load(f)
|
|
for col_data in state["columns"]:
|
|
for column in self.columns:
|
|
if column.title == col_data["title"]:
|
|
column.clear_notes(suppress_signal=True)
|
|
for note_text in col_data["notes"]:
|
|
column.add_note(note_text, suppress_signal=True)
|
|
break
|
|
except FileNotFoundError:
|
|
pass
|
|
except Exception as e:
|
|
print(f"Error loading state: {e}")
|
|
|
|
|
|
class KanbanPlugin(PluginBase):
|
|
"""
|
|
Kanban board plugin for the launcher.
|
|
Provides a kanban-style task management interface.
|
|
"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.display_name = "Kanban"
|
|
self.description = "Kanban board for task management"
|
|
self._current_widget = None
|
|
self._pending_add_text = None
|
|
self._launcher_instance = None
|
|
|
|
def initialize(self):
|
|
"""Initialize the Kanban plugin."""
|
|
self.set_triggers(["kanban"])
|
|
self.description = "Kanban board for task management. Use 'kanban add <text>' to add tasks, 'kanban move <text>' to move to next state. Keyboard: Enter/F2 to edit, Del to delete, Ctrl+N to add new note"
|
|
self._setup_launcher_hooks()
|
|
|
|
def cleanup(self):
|
|
"""Cleanup the Kanban plugin."""
|
|
if self._current_widget:
|
|
# Properly destroy the current widget
|
|
if self._current_widget.get_parent():
|
|
self._current_widget.get_parent().remove(self._current_widget)
|
|
self._current_widget.destroy()
|
|
self._current_widget = None
|
|
self._pending_add_text = None
|
|
self._cleanup_launcher_hooks()
|
|
|
|
def _setup_launcher_hooks(self):
|
|
"""Setup hooks to monitor launcher state."""
|
|
try:
|
|
# Try to find the launcher instance using garbage collection (like bookmarks plugin)
|
|
import gc
|
|
|
|
for obj in gc.get_objects():
|
|
if (
|
|
hasattr(obj, "__class__")
|
|
and obj.__class__.__name__ == "Launcher"
|
|
and hasattr(obj, "close_launcher")
|
|
):
|
|
self._launcher_instance = obj
|
|
break
|
|
except Exception as e:
|
|
print(f"Warning: Could not setup launcher hooks: {e}")
|
|
|
|
def _cleanup_launcher_hooks(self):
|
|
"""Cleanup launcher hooks."""
|
|
try:
|
|
self._launcher_instance = None
|
|
except Exception as e:
|
|
print(f"Warning: Could not cleanup launcher hooks: {e}")
|
|
|
|
def _reset_to_trigger(self):
|
|
"""Reset launcher to trigger word and refresh."""
|
|
try:
|
|
if self._launcher_instance and hasattr(
|
|
self._launcher_instance, "search_entry"
|
|
):
|
|
# Get the current trigger
|
|
trigger = "kanban "
|
|
|
|
# Reset to trigger word with space
|
|
try:
|
|
|
|
def reset_and_refresh():
|
|
# Set text to trigger word
|
|
self._launcher_instance.search_entry.set_text(trigger)
|
|
# Position cursor at end
|
|
self._launcher_instance.search_entry.set_position(-1)
|
|
# Trigger search to show default kanban view
|
|
self._launcher_instance._perform_search(trigger)
|
|
return False
|
|
|
|
GLib.timeout_add(50, reset_and_refresh)
|
|
except ImportError:
|
|
# Fallback: direct call if GLib not available
|
|
self._launcher_instance.search_entry.set_text(trigger)
|
|
self._launcher_instance.search_entry.set_position(-1)
|
|
self._launcher_instance._perform_search(trigger)
|
|
except Exception as e:
|
|
print(f"Could not reset to trigger: {e}")
|
|
|
|
def _delayed_reset_for_add(self):
|
|
"""Reset to trigger with minimal delay for add operations."""
|
|
try:
|
|
GLib.timeout_add(50, lambda: (self._reset_to_trigger(), False))
|
|
except ImportError:
|
|
self._reset_to_trigger()
|
|
|
|
def _find_todo_in_columns(self, search_text: str):
|
|
"""Find a todo by partial text match across all columns."""
|
|
search_text = search_text.lower().strip()
|
|
|
|
# Load current state to get fresh data
|
|
if self._current_widget:
|
|
for col_idx, column in enumerate(self._current_widget.columns):
|
|
notes = column.get_notes()
|
|
for note_text in notes:
|
|
if search_text in note_text.lower():
|
|
return col_idx, note_text
|
|
return None, None
|
|
|
|
def _move_todo_to_next_state(self, todo_text: str):
|
|
"""Move a todo to the next state (To Do -> In Progress -> Done)."""
|
|
if not self._current_widget:
|
|
return False, "Kanban board not initialized"
|
|
|
|
col_idx, found_text = self._find_todo_in_columns(todo_text)
|
|
if col_idx is None:
|
|
return False, f"Todo '{todo_text}' not found"
|
|
|
|
# Determine next column
|
|
if col_idx == 0: # To Do -> In Progress
|
|
next_col_idx = 1
|
|
next_state = "In Progress"
|
|
elif col_idx == 1: # In Progress -> Done
|
|
next_col_idx = 2
|
|
next_state = "Done"
|
|
else: # Already in Done
|
|
return False, f"Todo '{found_text}' is already completed"
|
|
|
|
# Remove from current column
|
|
current_column = self._current_widget.columns[col_idx]
|
|
for row in current_column.listbox.get_children():
|
|
note_widget = row.get_children()[0]
|
|
if (
|
|
isinstance(note_widget, KanbanNote)
|
|
and note_widget.label.get_text() == found_text
|
|
):
|
|
row.destroy()
|
|
break
|
|
|
|
# Add to next column
|
|
next_column = self._current_widget.columns[next_col_idx]
|
|
next_column.add_note(found_text)
|
|
|
|
# Save state
|
|
self._current_widget.save_state()
|
|
|
|
return True, f"Moved '{found_text}' to {next_state}"
|
|
|
|
def _execute_move_action(self, todo_text: str):
|
|
"""Execute the move action and reset to trigger."""
|
|
|
|
try:
|
|
GLib.timeout_add(50, lambda: (self._reset_to_trigger(), False))
|
|
except ImportError:
|
|
self._reset_to_trigger()
|
|
|
|
def _execute_complete_action(self, todo_text: str):
|
|
"""Execute the complete action (move directly to Done) and reset to trigger."""
|
|
if not self._current_widget:
|
|
return
|
|
|
|
col_idx, found_text = self._find_todo_in_columns(todo_text)
|
|
if col_idx is None:
|
|
return
|
|
|
|
if col_idx == 2: # Already in Done
|
|
return
|
|
|
|
# Remove from current column
|
|
current_column = self._current_widget.columns[col_idx]
|
|
for row in current_column.listbox.get_children():
|
|
note_widget = row.get_children()[0]
|
|
if (
|
|
isinstance(note_widget, KanbanNote)
|
|
and note_widget.label.get_text() == found_text
|
|
):
|
|
row.destroy()
|
|
break
|
|
|
|
# Add to Done column
|
|
done_column = self._current_widget.columns[2]
|
|
done_column.add_note(found_text)
|
|
|
|
# Save state
|
|
self._current_widget.save_state()
|
|
|
|
# Reset to trigger word with minimal delay (like bookmarks plugin)
|
|
try:
|
|
GLib.timeout_add(50, lambda: (self._reset_to_trigger(), False))
|
|
except ImportError:
|
|
self._reset_to_trigger()
|
|
|
|
def _execute_add_action(self, todo_text: str):
|
|
"""Execute the add action and reset to trigger."""
|
|
if not self._current_widget:
|
|
return
|
|
|
|
# Add to To Do column
|
|
self._current_widget.columns[0].add_note(todo_text)
|
|
self._current_widget.save_state()
|
|
|
|
# Reset to trigger word with minimal delay
|
|
try:
|
|
GLib.timeout_add(50, lambda: (self._reset_to_trigger(), False))
|
|
except ImportError:
|
|
self._reset_to_trigger()
|
|
|
|
def query(self, query_string: str) -> List[Result]:
|
|
"""Process Kanban queries."""
|
|
results = []
|
|
query = query_string.strip()
|
|
|
|
# Only create a new widget if we don't have one
|
|
if not self._current_widget:
|
|
kanban_widget = Kanban()
|
|
kanban_widget.connect("todo-added", lambda _: self._delayed_reset_for_add())
|
|
self._current_widget = kanban_widget
|
|
else:
|
|
kanban_widget = self._current_widget
|
|
|
|
# Store pending command for Enter key handling (no preview results)
|
|
if query.startswith("add "):
|
|
note_text = query[4:].strip()
|
|
if note_text:
|
|
kanban_widget.set_pending_add_text(note_text)
|
|
kanban_widget.pending_command = ("add", note_text)
|
|
else:
|
|
kanban_widget.set_pending_add_text(None)
|
|
kanban_widget.pending_command = None
|
|
elif query.startswith(("move ", "progress ")):
|
|
command_parts = query.split(" ", 1)
|
|
if len(command_parts) > 1:
|
|
todo_text = command_parts[1].strip()
|
|
if todo_text:
|
|
kanban_widget.pending_command = ("move", todo_text)
|
|
else:
|
|
kanban_widget.pending_command = None
|
|
else:
|
|
kanban_widget.pending_command = None
|
|
elif query.startswith(("done ", "complete ")):
|
|
command_parts = query.split(" ", 1)
|
|
if len(command_parts) > 1:
|
|
todo_text = command_parts[1].strip()
|
|
if todo_text:
|
|
kanban_widget.pending_command = ("done", todo_text)
|
|
else:
|
|
kanban_widget.pending_command = None
|
|
else:
|
|
kanban_widget.pending_command = None
|
|
else:
|
|
kanban_widget.set_pending_add_text(None)
|
|
kanban_widget.pending_command = None
|
|
|
|
# Always show the kanban board widget
|
|
results.append(
|
|
Result(
|
|
title="Kanban Board",
|
|
subtitle="Task management with kanban-style columns",
|
|
icon_markup=icons.kanban,
|
|
action=lambda: None, # No action needed, widget handles Enter
|
|
relevance=1.0,
|
|
plugin_name=self.display_name,
|
|
custom_widget=kanban_widget,
|
|
data={"type": "kanban_board", "keep_launcher_open": True},
|
|
)
|
|
)
|
|
|
|
return results
|