nowfocus 0.2.13__py3-none-any.whl → 0.4.0__py3-none-any.whl

nowfocus/task_window.py

@@ -6,6 +6,7 @@ import utils
 from utils import *
 
 from settings import EditAddTargetDialog, EditTaskCommandDialog
+from session_edit_dialog import SessionEditDialog
 
 class TaskWindow(Gtk.Window):
     css_provider = Gtk.CssProvider()
@@ -18,6 +19,8 @@ class TaskWindow(Gtk.Window):
     
     def __init__(self,app,passed_data=None):
 
+        timeit()
+
         if TaskWindow._instance:
             try:
                 if TaskWindow._instance.taskEntry.get_text():
@@ -67,41 +70,56 @@ class TaskWindow(Gtk.Window):
         self.shown_tasks = {}
         
         self.set_border_width(20)
-        self.set_position(position=1) # Works on x11 but not wayland (ubuntu 22.04)
+        self.set_position(position=1)
 
         self.accel_group = Gtk.AccelGroup()
         self.add_accel_group(self.accel_group)
 
-        box = Gtk.VBox(spacing=10)
-        box.set_halign(Gtk.Align.CENTER)
-        # box.set_valign(Gtk.Align.CENTER)
-        
-        self.add(box)
+        self.outer_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0, border_width=0)
+        self.add(self.outer_box)
 
-        self.header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=15, border_width=10)
+        self.l_sidebar = Gtk.VBox(spacing=5)
+        self.l_sidebar.get_style_context().add_class("subtle")
 
-        # self.header.set_halign(Gtk.Align.CENTER)
+        self.outer_box.add(self.l_sidebar)
 
-        box.pack_start(self.header,False, False, 0)
+        self.center_box = Gtk.VBox(spacing=10)
+        self.center_box.set_halign(Gtk.Align.CENTER)
 
+        self.outer_box.add(self.center_box)
+
+        self.header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=15, border_width=10)
+
+        self.center_box.pack_start(self.header,False, False, 0)
+        
         self.recreate_header()
 
+        self.r_sidebar_outer = Gtk.ScrolledWindow()
+        self.r_sidebar_outer.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        self.outer_box.add(self.r_sidebar_outer)
+
+        self.r_sidebar = Gtk.VBox(spacing=5)
+        self.r_sidebar.get_style_context().add_class("subtle")
+
+        self.r_sidebar.add_events(Gdk.EventMask.ENTER_NOTIFY_MASK)
+        self.r_sidebar.add_events(Gdk.EventMask.LEAVE_NOTIFY_MASK)
+        self.r_sidebar.connect("enter-notify-event",self.test)
+
+        self.r_sidebar_outer.add(self.r_sidebar)
+
         self.tick_timer = GLib.timeout_add_seconds(1, self.tick)
 
         self.task_entry_overlay = Gtk.Overlay()
 
-        # Large fuzzy task input
         self.taskEntry = Gtk.Entry() 
-        self.taskEntry.set_name("FuzzyTask") # set css id
-        # self.taskEntry.set_width_chars(59)
+        self.taskEntry.set_name("FuzzyTask")
         self.taskEntry.set_max_width_chars(79)
-
         self.taskEntry.set_placeholder_text("Find Task [Ctrl+F]")
         self.taskEntry.set_property("tooltip-text", "Find Task [Ctrl+F], press Enter to start work on the first task in the list")
 
         self.task_entry_overlay.add(self.taskEntry)
 
-        box.pack_start(self.task_entry_overlay,False, False, 0)
+        self.center_box.pack_start(self.task_entry_overlay,False, False, 0)
 
         self.taskEntry.grab_focus()
 
@@ -126,10 +144,9 @@ class TaskWindow(Gtk.Window):
                 self.taskEntry.set_text(passed_data['task']['label'])
         
 
-
         self.scrolled_window = Gtk.ScrolledWindow()
         self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
-        box.pack_start(self.scrolled_window, True, True, 0)
+        self.center_box.pack_start(self.scrolled_window, True, True, 0)
         self.scrolled_window.set_size_request(-1, 350) 
 
         self.scrolled_window.connect('scroll-event', self.on_scroll) # This doesn't catch scrollbar moves
@@ -142,6 +159,7 @@ class TaskWindow(Gtk.Window):
 
         self.total_duration_label = Gtk.Label()
         self.total_duration_label.set_margin_end(12)
+        self.total_duration_label.get_style_context().add_class('subtle')
         self.total_duration_label.set_halign(Gtk.Align.END)
         self.task_entry_overlay.add_overlay(self.total_duration_label)
 
@@ -156,14 +174,14 @@ class TaskWindow(Gtk.Window):
         # self.timesheet_to_button.connect("clicked",self.timesheet_to_clipboard)
         # self.timesheet_to_button.set_name("Footer")
         # self.timesheet_to_button.set_property("tooltip-text","Click to copy CSV timesheet to clipboard")
-        # box.pack_start(self.timesheet_to_button,False, False, 0)
+        # self.center_box.pack_start(self.timesheet_to_button,False, False, 0)
 
 
         self.buttons_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=20)
         self.buttons_box.set_halign(Gtk.Align.CENTER)
-        self.buttons_box.set_name("Footer")
+        self.buttons_box.get_style_context().add_class("subtle")
 
-        box.pack_start(self.buttons_box,False, False, 0)
+        self.center_box.pack_start(self.buttons_box,False, False, 0)
 
         self.settings_button = Gtk.Button(label="Settings")
         self.settings_button.connect("clicked",self.app.open_settings_window)
@@ -181,7 +199,8 @@ class TaskWindow(Gtk.Window):
                     openable = conf.todo_connectors[todo['type']].launch
                     openable_button = Gtk.Button(label=GLib.markup_escape_text(todo['label']))
                     openable_button.connect("clicked", lambda button_widget,todo=todo, openable=openable: openable(todo))
-                    openable_button.set_property("tooltip-text","Open (new) "+GLib.markup_escape_text(todo['label']))
+                    openable_button.set_property("tooltip-text","Open "+GLib.markup_escape_text(todo['label']))
+
                     self.buttons_box.add(openable_button)
 
                 except Exception as e:
@@ -193,6 +212,8 @@ class TaskWindow(Gtk.Window):
         self.buttons_box.add(self.new_task_button)
 
         self.show_all()
+        timeit()
+
 
         key, mod = Gtk.accelerator_parse('<Control>n')
         self.new_task_button.add_accelerator("clicked", self.accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
@@ -205,11 +226,17 @@ class TaskWindow(Gtk.Window):
         self.connect("window-state-event", self.on_window_state_event)
 
         self.taskEntry.connect("changed",self.task_search)
+        GLib.idle_add(self.refresh_search_cache)
         
-        self.refresh_search_cache()
         self.connect("destroy", self.on_destroy)
 
-        
+    def test(self=None, one=None, two=None, **kwargs):
+        print('task_window test')
+        print(one)
+        print(two)
+        print(kwargs)
+
+
     def on_destroy(self, widget= None):
         TaskWindow._instance = None
         print("¡Adios Task Window!")
@@ -221,11 +248,15 @@ class TaskWindow(Gtk.Window):
         if self.lazy_loadable_tasks:
             print('Tasks to lazy load ', len(self.lazy_loadable_tasks))
             for id, t in self.lazy_loadable_tasks.items():
-                self.add_task_to_list(t)
+                self.add_task_to_window(t)
             self.tasks_box.show_all()
 
             self.lazy_loadable_tasks = {}
 
+    def select_list_callback(self, widget, l):
+        print('widget',widget,'list',l)
+        self.taskEntry.set_text(l['extended_label']+" > ")
+        self.taskEntry.grab_focus()
 
     def refresh_search_cache(self,w = None):
         self.search_cache = {}
@@ -242,13 +273,11 @@ class TaskWindow(Gtk.Window):
 
         self.session_time.set_label(sec_to_time(self.app.session['duration']))
         if self.app.session['label'] != self.header_task:
-            self.recreate_header() 
+            self.recreate_header()
         
         if utils.taskindex_updated_time() > self.search_cache_refresh_time:
             # print("taskindex was updated,  utils.taskindex_updated_time()", utils.taskindex_updated_time(), 'self.search_cache_refresh_time',self.search_cache_refresh_time)
             self.refresh_search_cache()
-        # else:
-        #     print("taskindex was not updated",current_data_version)
 
         return True # This continues the timer
 
@@ -349,12 +378,33 @@ class TaskWindow(Gtk.Window):
             
 
         self.header.show_all()
+        GLib.idle_add(self.create_sidebars)
 
         try:
             self.taskEntry.grab_focus()
         except Exception: 
             pass
-        
+    
+    def create_sidebars(self):
+        timeit()
+        if conf.user['open_task_window_fullscreen'] and conf.user['show_task_window_sidebars']:
+            self.r_sidebar_outer.set_size_request(350, -1)
+            self.l_sidebar.set_size_request(350, -1)
+
+            self.SessionEditDialog = SessionEditDialog # passed to show_sessions
+
+            #show lists on left 
+            self.l_sidebar.foreach(lambda child: child.destroy()) 
+
+            self.l_sidebar.add(choose_from_lists(self.select_list_callback, 'None', None, False))
+
+            #show sessions on right
+            show_sessions(None, self, self.r_sidebar, None, 'start_time', '30',None, 30)
+            self.l_sidebar.show_all()
+            self.r_sidebar.show_all()
+            timeit()
+
+
     def on_notes_changed(self,buffer):
        notes = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), False)
        self.app.session['notes'] = notes
@@ -367,20 +417,18 @@ class TaskWindow(Gtk.Window):
         self.refresh_search_cache()
 
 
-    def task_search(self,widget):
+    def task_search(self,widget = None):
 
         self.tasks_box.foreach(lambda child: child.destroy()) 
-        self.tasks_box.show_all()
         self.shown_tasks.clear()
 
-        self.search_term = i = widget.get_text()
+        self.search_term = self.taskEntry.get_text()
 
-        # utils.dbg({"task search":i},s='taskwindow')
-        if i in self.search_cache:
-            tasks = self.search_cache[i]
+        if self.search_term in self.search_cache:
+            tasks = self.search_cache[self.search_term]
         else:
-            tasks = utils.taskindex_search(i)
-            self.search_cache[i] = tasks
+            tasks = utils.taskindex_search(self.search_term)
+            self.search_cache[self.search_term] = tasks
 
         total_duration = 0
         self.lazy_loadable_tasks = {}
@@ -388,12 +436,12 @@ class TaskWindow(Gtk.Window):
         if tasks:
             count = 0
             for id, t in tasks.items():
-                count = count + 1
+                count += 1
                 if 'duration' in t and t['duration']:
                     total_duration += int(t['duration'])
 
                 if count < self.num_initial_tasks:
-                    self.add_task_to_list(t)
+                    self.add_task_to_window(t)
                 else:
                     self.lazy_loadable_tasks[id] = t
 
@@ -402,34 +450,27 @@ class TaskWindow(Gtk.Window):
         self.total_duration_label.set_markup('<b>'+str(round(total_duration / 60 / 60,1))+'</b> hrs\n'+conf.user['hours_search_timeframe'] )
 
 
-
-    def add_task_to_list(self,t):
+    def add_task_to_window(self,t):
 
         try:
-            search_str = self.search_term
             utils.dbg("add_task_to_list "+ str(t['extended_label']), "status",t['status'], s='taskwindow',l=3)
 
-            # self.shown_tasks[t['id']] = Gtk.Button() # Works but does not accept popovers
             self.shown_tasks[t['id']] = Gtk.MenuButton(popover=self.task_rclick_menu) 
-            self.shown_tasks[t['id']].set_halign(Gtk.Align.START)
-            self.shown_tasks[t['id']].set_hexpand(True)
+            button = self.shown_tasks[t['id']]
+            button.set_halign(Gtk.Align.START)
+            button.set_hexpand(True)
 
             label = Gtk.Label()
 
-            # button_context = self.shown_tasks[t['id']].get_style_context().add_class("large")
             extended_label = GLib.markup_escape_text(t['extended_label'],)
 
-            # Truncate excessively long task labels 
             if len(extended_label) > 110:
                 extended_label = extended_label[:110]+"..." 
             
-            if len(search_str) > 1:
-                
-                # fts5 match highlighting, not that good because it highlights the whole word rather than the matching part...
-                # extended_label = extended_label.replace('[[',"<b>").replace(']]',"</b>")
+            if len(self.search_term) > 1:
 
-                extended_label = extended_label.replace(search_str,"<b>"+search_str+"</b>")
-                extended_label = extended_label.replace(search_str.capitalize(),"<b>"+search_str.capitalize()+"</b>") # Cheesy
+                extended_label = extended_label.replace(self.search_term,"<b>"+self.search_term+"</b>")
+                extended_label = extended_label.replace(self.search_term.capitalize(),"<b>"+self.search_term.capitalize()+"</b>") # Cheesy but kind of works
             
             if "duration" in t and t['duration']:
                 extended_label += " ("+sec_to_time(t['duration'])+")"
@@ -437,28 +478,22 @@ class TaskWindow(Gtk.Window):
             if t['id'] in conf.user['task_commands'] and conf.user['task_commands'][t['id']]['status']:
                 extended_label += " ["+GLib.markup_escape_text(conf.user['task_commands'][t['id']]['command'])+"]"
 
-            if t['priority']:
-                extended_label = str(t['priority']) +" "+ extended_label
 
             if not t['status']:
-                # utils.dbg("add strikethrough to done task "+t['extended_label'],l=3,s="taskwindow")
-                # button_context.add_class("done")
-                label.set_markup('<s>'+extended_label+'</s>')
+                button.get_style_context().add_class("done")
+                extended_label = '<s>'+extended_label+'</s>'
 
             elif t['priority'] > 0:
-                label.set_name('priorityTask')
-                label.set_markup(extended_label)
-            else:
-                label.set_markup(extended_label)
+                extended_label = str(t['priority']) +" "+ extended_label
+                button.get_style_context().add_class("bold")
 
-            self.shown_tasks[t['id']].add(label)
+            label.set_markup(extended_label)
+            button.add(label)
 
-            # self.shown_tasks[t['id']].set_size_request(955, -1)
-            self.shown_tasks[t['id']].connect("button-release-event", self.select_task, t['id'])
-            self.shown_tasks[t['id']].connect("activate", self.select_task, None, t['id']) 
-            self.shown_tasks[t['id']].set_relief(Gtk.ReliefStyle.NONE)
-            self.tasks_box.add(self.shown_tasks[t['id']])
-            self.tasks_box.show_all()
+            button.connect("button-release-event", self.select_task, t['id'])
+            button.connect("activate", self.select_task, None, t['id']) 
+            button.set_relief(Gtk.ReliefStyle.NONE)
+            self.tasks_box.add(button)
 
 
         except Exception as e:
@@ -493,8 +528,12 @@ class TaskWindow(Gtk.Window):
             w.set_halign(Gtk.Align.START)
             w.set_relief(Gtk.ReliefStyle.NONE)
             w.connect('clicked',self.app.mark_done,t)
+
+            w.connect('clicked',lambda button, self: self.task_rclick_menu.hide(),self)
+            w.connect('clicked',lambda button, self, t: self.shown_tasks[t['id']].destroy(),self,t)
             vbox.pack_start(w, True, True, 5)
 
+
             # Reassign session/randomness to be on this task, 
             w = Gtk.Button(label="Reassign last "+ str(round((self.app.session['duration'] / 60),1))+" minutes to this task" )
             w.set_halign(Gtk.Align.START)

nowfocus/user_idle_time.py

@@ -0,0 +1,82 @@
+import os
+import platform
+import subprocess
+
+class UserIdleTime():
+    def __init__(self, platform = None, **kwargs):
+
+        self.getters = {
+            'linux_wayland': self.get_idle_seconds_linux_wayland,
+            'linux_x': self.get_idle_seconds_linux_x,
+            'mac': self.get_idle_seconds_mac,
+            'windows': self.get_idle_seconds_windows,
+        }
+
+        if platform:
+            self.platform = platform
+        else:
+            self.detect_platform()
+
+        print('UserIdleTime platform set to',self.platform)
+
+    def get (self) :
+        ''' Returns int of seconds since user was active '''
+        try:
+            return int(self.getters[self.platform]())
+        except Exception as e:
+            print(' CheckIdleTime failed')
+            print(e)
+            return 0
+    
+
+
+    def detect_platform (self):
+
+        match (platform.system()):
+            case ('Linux'):
+                if os.environ.get('XDG_SESSION_TYPE') == "wayland":
+                    self.platform = "linux_wayland"
+                else:
+                    self.platform = "linux_x"
+
+            case ("Darwin"):
+                self.platform = "mac"
+
+            case ("Windows"):
+                self.platform = "windows"
+ 
+        return self.platform
+
+
+    def get_idle_seconds_linux_wayland (self):
+        # https://askubuntu.com/a/1231995/292055
+
+        command = "dbus-send --print-reply --dest=org.gnome.Mutter.IdleMonitor /org/gnome/Mutter/IdleMonitor/Core org.gnome.Mutter.IdleMonitor.GetIdletime"
+
+        response = subprocess.getoutput(command)
+
+        idle_time = int(int(response.rsplit(None,1)[-1]) / 1000)
+
+        return idle_time
+
+
+    def get_idle_seconds_linux_x (self):
+        idle_time = int(subprocess.getoutput('xprintidle')) / 1000 # Requires xprintidle (sudo apt install xprintidle)
+        return idle_time
+
+
+    def get_idle_seconds_windows (self):
+        # https://stackoverflow.com/a/67091943/4692205
+        import win32api
+
+        idle_time = (win32api.GetTickCount() - win32api.GetLastInputInfo()) / 1000.0
+
+        return idle_time
+
+
+    def get_idle_seconds_mac (self):
+        # https://stackoverflow.com/a/17966890/4692205
+        command = "ioreg -c IOHIDSystem | awk '/HIDIdleTime/ {print $NF/1000000000; exit}'"
+
+        idle_time = int(float(subprocess.getoutput(command)))
+        return idle_time