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

nowfocus/settings.py

@@ -64,60 +64,19 @@ def after_todo_settings_change(app, todo = None):
     if todo:
         todo = utils.get_todo_by_id(todo)
         if todo['status']:
-
             app.async_refresh(todo)
-            utils.stop_todo_file_watchers(todo)
-            utils.start_todo_file_watchers(todo)
-
         else:
             utils.db_deactivate_todo(todo['id'])
             utils.reindex()
-            utils.stop_todo_file_watchers(todo)
             app.update_menu()
             
     else:
         app.async_refresh()
-        utils.stop_todo_file_watchers()
-        utils.start_todo_file_watchers()
 
 
 class SettingsWindow(Gtk.Window):
 
 
-    def show_sessions(self, widget = None, label_text = "Most Recent Sessions", order_by = 'start_time', limit = 35, passed_sessions = None):
-
-        self.sessions_box.foreach(lambda child: child.destroy()) 
-    
-        if passed_sessions:
-            dbg("using Passed_sessions",passed_sessions,s='settings')
-            sessions = passed_sessions
-        else:
-            dbg("show_sessions: order_by:",order_by, 'limit',limit, s='settings')
-            sessions = db_query(" SELECT * FROM sessions WHERE "+sessions_timeframe_sql()+" ORDER BY "+order_by+" DESC LIMIT ? ",(limit,)) 
-        
-        # print('sessions')
-        # print(sessions)
-
-        label = Gtk.Label()
-        if passed_sessions:
-            label.set_markup('<b>'+label_text+'</b>')
-        else:
-            label.set_markup('<b>'+str(limit)+' '+label_text+' of '+conf.user['hours_search_timeframe']+'</b>')
-        self.sessions_box.add(label)
-
-        for ls in sessions:
-            dbg('Add session to session_box',ls['extended_label'],s='settings')
-            btn = Gtk.Button(label=ls['extended_label']+' '+str(ls['duration'] / 60 / 60)[:4]+' hr on '+ls['start_time'][:10])
-
-            btn.set_halign(Gtk.Align.START)
-            btn.set_relief(Gtk.ReliefStyle.NONE)
-
-            btn.connect('clicked', lambda button_widget, ls: SessionEditDialog(None, self, ls),ls )
-            
-            self.sessions_box.add(btn)
-
-        self.sessions_box.show_all()
-
     def scroll_box(self, parent_widget = None, height = 300):
 
         # print('parent_widget')
@@ -136,7 +95,7 @@ class SettingsWindow(Gtk.Window):
 
 
     def __init__(self, parent=None, **kwargs):
-        self.app = parent #NOTE: This doens't look like it will work when called from task_window...
+        self.app = parent #NOTE: This doesn't look like it will work when called from task_window...
         Gtk.Window.__init__(self, title="Settings")
         self.set_border_width(15)
         self.set_position(position=1) 
@@ -241,6 +200,7 @@ class SettingsWindow(Gtk.Window):
         grid.attach(self.settings_updater('default_text','What am I Doing?','Entry'),0,(row:=row+1),5,1)
 
         grid.attach(self.settings_updater('open_task_window_fullscreen',True,'Switch'),0,(row:=row+1),5,1)
+        grid.attach(self.settings_updater('show_task_window_sidebars',True,'Switch'),0,(row:=row+1),5,1)
 
         grid.attach(self.settings_updater('pomodoro_interval',25,'SpinButton',"(minutes)"),0,(row:=row+1),5,1)
 
@@ -248,8 +208,7 @@ class SettingsWindow(Gtk.Window):
 
         grid.attach(self.settings_updater('todolist_refresh_interval', 3, 'SpinButton',"(hours)"),0,(row:=row+1),5,1)
         
-        # grid.attach(self.settings_updater('tick_interval', 18, 'SpinButton',"\nMust be an even number fraction of 60. (requires restart)"),0,(row:=row+1),5,1)
-
+    
         # grid.attach(self.settings_updater('invoice_hourly_rate', 33, 'SpinButton',""),0,(row:=row+1),5,1)
         
         grid.attach(self.settings_updater('hours_search_timeframe', 'auto', 'ComboBoxText',"\nDefault timetracking range for hours shown in main window and invoicing", options = list(hours_search_timeframes().keys())),0,(row:=row+1),5,1)
@@ -360,11 +319,9 @@ class SettingsWindow(Gtk.Window):
         self.sessions_page.add(print_time_totals_button)
 
         show_recent_sessions_button = Gtk.Button(label="Show recent sessions")
-        show_recent_sessions_button.connect("clicked", self.show_sessions, 'Recent Sessions', 'start_time')
         self.sessions_page.add(show_recent_sessions_button)
 
         show_long_sessions_button = Gtk.Button(label="Show long sessions")
-        show_long_sessions_button.connect("clicked", self.show_sessions, 'Longest Sessions', 'duration')
         self.sessions_page.add(show_long_sessions_button)
 
         self.sessions_scroller = self.scroll_box(self.sessions_page)
@@ -372,7 +329,12 @@ class SettingsWindow(Gtk.Window):
         self.sessions_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5)
         self.sessions_scroller.add(self.sessions_box)
 
-        self.show_sessions()
+        show_sessions(None, self, self.sessions_box)
+        show_recent_sessions_button.connect("clicked", show_sessions, self, self.sessions_box, 'Recent Sessions', 'start_time')
+        show_long_sessions_button.connect("clicked", show_sessions, self, self.sessions_box, 'Longest Sessions', 'duration')
+
+        self.SessionEditDialog = SessionEditDialog # passed to show_sessions
+
 
         self.show_all()
 
@@ -585,7 +547,6 @@ class SettingsWindow(Gtk.Window):
             db_query("DELETE FROM tasks WHERE todolist = ? AND id NOT IN (SELECT task_id FROM sessions)",(id,))
             db_query("DELETE FROM lists WHERE todolist = ?",(id,))
             utils.reindex()
-            utils.stop_todo_file_watchers(connector)
             self.app.update_menu()
 
         del conf.user[connector_category][id]
@@ -1040,9 +1001,7 @@ class EditAddConnectorDialog(Gtk.Dialog):
             if connector_category == 'todolists':
 
                 conf.todo_connectors[new['type']] = importlib.import_module('connectors.'+new['type'])
-
-                utils.stop_todo_file_watchers(new)
-                utils.start_todo_file_watchers(new)
+                
                 self.app.async_refresh(new)
 
 

nowfocus/styles.css

@@ -1,9 +1,3 @@
-/* *{
-    font-size:18px;
-} */
-
-
-/* #TaskWindow{ */
 .large{
     font-size:25px;
 }
@@ -11,23 +5,25 @@
 #FuzzyTask{
     font-size:30px;
     padding:12px;
-
 }
 
 #RelevantQuestion{
     font-weight: 100;
-    font-size:35px;
+    font-size: 35px;
     opacity: .3;
 }
 
-#Footer{
+.subtle{
     font-weight: 100;
     font-size:16px;
-    opacity: .5;
+    opacity: .4;
 }
 
-#priorityTask{
+.subtle:hover{
+    opacity: .7;
+}
 
+#priorityTask{
     font-weight: bold;
 }
 
@@ -38,6 +34,8 @@
 .done{
     text-decoration-line: line-through;
     text-decoration:line-through;
+    opacity: .5;
+    font-weight: 100;
 }
 
 #task_rclick_menu{

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,48 @@ 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.outer_box.add(self.l_sidebar)
 
-        # self.header.set_halign(Gtk.Align.CENTER)
+        self.center_box = Gtk.VBox(spacing=10)
+        self.center_box.set_halign(Gtk.Align.CENTER)
 
-        box.pack_start(self.header,False, False, 0)
+        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 = Gtk.VBox(spacing=5)
+        self.r_sidebar.get_style_context().add_class("subtle")
+        self.outer_box.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 +136,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 +151,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 +166,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 +191,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 +204,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 +218,18 @@ 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 +241,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 +266,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 +371,57 @@ 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()
         
+        self.l_sidebar.foreach(lambda child: child.destroy()) 
+        self.r_sidebar.foreach(lambda child: child.destroy()) 
+
+        if conf.user['open_task_window_fullscreen'] and conf.user['show_task_window_sidebars']:
+            self.l_sidebar.set_size_request(350, -1)
+            self.r_sidebar.set_size_request(350, -1)
+
+            focus_percent_label = Gtk.Label()
+            focus_percent_label.set_markup("<b>Focus: "+str(utils.get_percent_time_focused())+"%</b>")
+            self.r_sidebar.pack_start(focus_percent_label, False, True, 25)
+
+            self.sessions_scrolledwindow = Gtk.ScrolledWindow()
+            self.sessions_scrolledwindow.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+            self.r_sidebar.pack_start(self.sessions_scrolledwindow, True, True, 0)
+
+            self.sessions_box = Gtk.VBox(spacing=5)
+            # self.sessions_box.get_style_context().add_class("subtle")
+            self.sessions_scrolledwindow.add(self.sessions_box)
+
+            # 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.l_sidebar.add(choose_from_lists(self.select_list_callback, 'None', None, False))
+
+            self.SessionEditDialog = SessionEditDialog # passed to show_sessions
+            show_sessions(None, self, self.sessions_box, None, 'start_time', '30',None, 30)
+
+            self.l_sidebar.show_all()
+            self.r_sidebar.show_all()
+        else:
+            self.r_sidebar.set_size_request(-1, -1)
+            self.l_sidebar.set_size_request(-1, -1)
+
+            self.l_sidebar.hide()
+            self.r_sidebar.hide()
+        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 +434,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 +453,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 +467,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 +495,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 +545,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)
@@ -589,11 +645,14 @@ class TaskWindow(Gtk.Window):
             self.unfullscreen()
             self.get_style_context().remove_class("large")
             conf.user['open_task_window_fullscreen'] = False
+            self.create_sidebars()
 
         else:
             self.fullscreen()
             self.get_style_context().add_class("large")
             conf.user['open_task_window_fullscreen'] = True
+            self.create_sidebars()
+
 
         utils.save_user_settings()
 

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