class GUI:
def __init__(self):
"""Initializes the window and create pointers for all the important widgets.
This function also runs some code to add functionality.
"""
# Initialize the window and several other objects in the instance
self.initialize_window()
# Properties instance to handle the preferences window
self.preferences = Preferences(self.main_window)
# Now setup the variables needed for file access
try:
self.setup_file_access()
except Exception, e:
# In case of error, the user must change the preferences
log(e.__class__.__name__)
log(e)
self.preferences.run()
self.setup_file_access()
self.modified = set() # Store the names of the modified files
# The next variable takes care of each file by holding the choices made for
# it. The values of the dictionary are Annotator objects, where information
# about the annotations made in the file
self.results = {}
# This flag determines whether signal handling should take place. It is True
# when the interface is being adjusted programatically
self.backend = False
def show_preferences(self, widget):
widget.set_sensitive(False)
preferences = Preferences()
response = preferences.run()
if response == Gtk.ResponseType.ACCEPT:
preferences.save()
self.load_preferences()
self.set_icon(self.is_monitoring)
preferences.destroy()
widget.set_sensitive(True)
def show_preferences(self, widget):
widget.set_sensitive(False)
preferences = Preferences()
Keybinder.unbind(self.new_task_keybind)
Keybinder.unbind(self.show_tasks_keybind)
response = preferences.run()
if response == Gtk.ResponseType.ACCEPT:
preferences.save()
self.load_preferences()
self.load_todos()
self.set_icon()
widget.set_sensitive(True)
preferences.destroy()
def show_preferences(self, widget):
widget.set_sensitive(False)
preferences_dialog = Preferences()
response = preferences_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
preferences_dialog.save()
configuration = Configuration()
preferences = configuration.get('preferences')
self.theme_light = preferences['theme-light']
self.application_name = preferences['application_name']
if self.gotify_client is not None and \
self.gotify_client.is_running():
self.stop()
self.start()
preferences_dialog.destroy()
widget.set_sensitive(True)
class IndicatorSysmonitor(object):
SENSORS_DISABLED = False
def __init__(self):
self._preferences_dialog = None
self._help_dialog = None
self.ind = Gtk.Button.new()
self.ind.set_label("Init...")
self._create_menu()
self.alive = Event()
self.alive.set()
self.sensor_mgr = SensorManager()
self.load_settings()
def _create_menu(self):
"""Creates the main menu and shows it."""
# create menu {{{
menu = Gtk.Menu()
# add System Monitor menu item
full_sysmon = Gtk.MenuItem(_('System Monitor'))
full_sysmon.connect('activate', self.on_full_sysmon_activated)
menu.add(full_sysmon)
menu.add(Gtk.SeparatorMenuItem())
# add preferences menu item
pref_menu = Gtk.MenuItem(_('Preferences'))
pref_menu.connect('activate', self.on_preferences_activated)
menu.add(pref_menu)
# add help menu item
help_menu = Gtk.MenuItem(_('Help'))
help_menu.connect('activate', self._on_help)
menu.add(help_menu)
menu.show_all()
self.popup = menu
self.ind.connect('clicked', self.popup_menu)
logging.info("Menu shown")
# }}} menu done!
def popup_menu(self, *args):
self.popup.popup(None, None, None, None, 0,
Gtk.get_current_event_time())
def update_indicator_guide(self):
guide = self.sensor_mgr.get_guide()
def update(self, data):
# data is the dict of all sensors and their values
# { name, label }
# look through data and find out if there are any icons to be set
for sensor in data:
test_str = data[sensor].lower()
if "use_icon" in test_str:
path = data[sensor].split(":")[1]
print(path)
self.ind.set_icon_full(path, "")
# now strip the icon output from data so that it is not displayed
remaining = test_str.split("use_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
if "clear_icon" in test_str:
self.ind.set_icon_full(self.tindicator, "")
remaining = test_str.split("clear_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
label = self.sensor_mgr.get_label(data)
def update_label(label):
self.ind.set_label(label)
return False
if label and self.ind:
GLib.idle_add(update_label, label.strip())
def load_settings(self):
self.sensor_mgr.load_settings()
self.sensor_mgr.initiate_fetcher(self)
self.update_indicator_guide()
# @staticmethod
def save_settings(self):
self.sensor_mgr.save_settings()
def update_settings(self):
self.sensor_mgr.initiate_fetcher(self)
# actions raised from menu
def on_preferences_activated(self, event=None):
"""Raises the preferences dialog. If it's already open, it's
focused"""
if self._preferences_dialog is not None:
self._preferences_dialog.present()
return
self._preferences_dialog = Preferences(self)
self._preferences_dialog.run()
self._preferences_dialog = None
def on_full_sysmon_activated(self, event=None):
os.system('gnome-system-monitor &')
def on_exit(self, event=None, data=None):
"""Action call when the main programs is closed."""
# cleanup temporary indicator icon
os.remove(self.tindicator)
# close the open dialogs
if self._help_dialog is not None:
self._help_dialog.destroy()
if self._preferences_dialog is not None:
self._preferences_dialog.destroy()
logging.info("Terminated")
self.alive.clear() # DM: why bother with Event() ???
try:
Gtk.main_quit()
except RuntimeError:
pass
def _on_help(self, event=None, data=None):
"""Raise a dialog with info about the app."""
if self._help_dialog is not None:
self._help_dialog.present()
return
self._help_dialog = Gtk.MessageDialog(
None, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, None)
self._help_dialog.set_title(_("Help"))
self._help_dialog.set_markup(HELP_MSG)
self._help_dialog.run()
self._help_dialog.destroy()
self._help_dialog = None
class IndicatorSysmonitor(object):
SENSORS_DISABLED = False
def __init__(self):
self._preferences_dialog = None
self._help_dialog = None
#fn, self.tindicator = tempfile.mkstemp(suffix=".svg")
#with open(self.tindicator, "w") as f:
# svg = '<?xml version="1.0" encoding="UTF-8" \
# standalone="no"?><svg id="empty" xmlns="http://www.w3.org/2000/svg" \
# height="22" width="1" version="1.0" \
# xmlns:xlink="http://www.w3.org/1999/xlink"></svg>'
# f.write(svg)
# f.close()
#self.ind = appindicator.Indicator.new("indicator-sysmonitor", self.tindicator, \
# appindicator.IndicatorCategory.SYSTEM_SERVICES)
self.ind = Gtk.Button.new()
#self.ind.set_ordering_index(0)
#self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
self.ind.set_label("Init...")
self._create_menu()
self.alive = Event()
self.alive.set()
self.sensor_mgr = SensorManager()
self.load_settings()
def _create_menu(self):
"""Creates the main menu and shows it."""
# create menu {{{
menu = Gtk.Menu()
# add System Monitor menu item
full_sysmon = Gtk.MenuItem(_('System Monitor'))
full_sysmon.connect('activate', self.on_full_sysmon_activated)
menu.add(full_sysmon)
menu.add(Gtk.SeparatorMenuItem())
# add preferences menu item
pref_menu = Gtk.MenuItem(_('Preferences'))
pref_menu.connect('activate', self.on_preferences_activated)
menu.add(pref_menu)
# add help menu item
help_menu = Gtk.MenuItem(_('Help'))
help_menu.connect('activate', self._on_help)
menu.add(help_menu)
# add preference menu item
#exit_menu = Gtk.MenuItem(_('Quit'))
#exit_menu.connect('activate', self.on_exit)
#menu.add(exit_menu)
menu.show_all()
self.popup = menu
self.ind.connect('clicked', self.popup_menu)
logging.info("Menu shown")
# }}} menu done!
def popup_menu(self, *args):
self.popup.popup(None, None, None, None, 0, Gtk.get_current_event_time())
def update_indicator_guide(self):
guide = self.sensor_mgr.get_guide()
#self.ind.set_property("label-guide", guide)
def update(self, data):
# data is the dict of all sensors and their values
# { name, label }
# look through data and find out if there are any icons to be set
for sensor in data:
test_str = data[sensor].lower()
if "use_icon" in test_str:
path = data[sensor].split(":")[1]
print(path)
self.ind.set_icon_full(path, "")
# now strip the icon output from data so that it is not displayed
remaining = test_str.split("use_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
if "clear_icon" in test_str:
self.ind.set_icon_full(self.tindicator, "")
remaining = test_str.split("clear_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
label = self.sensor_mgr.get_label(data)
Gdk.threads_enter()
self.ind.set_label(label.strip())
Gdk.threads_leave()
#self.ind.set_title(label.strip())
def load_settings(self):
self.sensor_mgr.load_settings()
self.sensor_mgr.initiate_fetcher(self)
self.update_indicator_guide()
# @staticmethod
def save_settings(self):
self.sensor_mgr.save_settings()
# actions raised from menu
def on_preferences_activated(self, event=None):
"""Raises the preferences dialog. If it's already open, it's
focused"""
if self._preferences_dialog is not None:
self._preferences_dialog.present()
return
self._preferences_dialog = Preferences(self)
self._preferences_dialog.run()
self._preferences_dialog = None
def on_full_sysmon_activated(self, event=None):
os.system('gnome-system-monitor &')
def on_exit(self, event=None, data=None):
"""Action call when the main programs is closed."""
# cleanup temporary indicator icon
os.remove(self.tindicator)
# close the open dialogs
if self._help_dialog is not None:
self._help_dialog.destroy()
if self._preferences_dialog is not None:
self._preferences_dialog.destroy()
logging.info("Terminated")
self.alive.clear() # DM: why bother with Event() ???
try:
Gtk.main_quit()
except RuntimeError:
pass
def _on_help(self, event=None, data=None):
"""Raise a dialog with info about the app."""
if self._help_dialog is not None:
self._help_dialog.present()
return
self._help_dialog = Gtk.MessageDialog(
None, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, None)
self._help_dialog.set_title(_("Help"))
self._help_dialog.set_markup(HELP_MSG)
self._help_dialog.run()
self._help_dialog.destroy()
self._help_dialog = None
class IndicatorSysmonitor(object):
SENSORS_DISABLED = False
def __init__(self):
self._preferences_dialog = None
self._help_dialog = None
#fn, self.tindicator = tempfile.mkstemp(suffix=".svg")
#with open(self.tindicator, "w") as f:
# svg = '<?xml version="1.0" encoding="UTF-8" \
# standalone="no"?><svg id="empty" xmlns="http://www.w3.org/2000/svg" \
# height="22" width="1" version="1.0" \
# xmlns:xlink="http://www.w3.org/1999/xlink"></svg>'
# f.write(svg)
# f.close()
#self.ind = appindicator.Indicator.new("indicator-sysmonitor", self.tindicator, \
# appindicator.IndicatorCategory.SYSTEM_SERVICES)
self.ind = Gtk.Button.new()
#self.ind.set_ordering_index(0)
#self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
self.ind.set_label("Init...")
self._create_menu()
self.alive = Event()
self.alive.set()
self.sensor_mgr = SensorManager()
self.load_settings()
def _create_menu(self):
"""Creates the main menu and shows it."""
# create menu {{{
menu = Gtk.Menu()
# add System Monitor menu item
full_sysmon = Gtk.MenuItem(_('System Monitor'))
full_sysmon.connect('activate', self.on_full_sysmon_activated)
menu.add(full_sysmon)
menu.add(Gtk.SeparatorMenuItem())
# add preferences menu item
pref_menu = Gtk.MenuItem(_('Preferences'))
pref_menu.connect('activate', self.on_preferences_activated)
menu.add(pref_menu)
# add help menu item
help_menu = Gtk.MenuItem(_('Help'))
help_menu.connect('activate', self._on_help)
menu.add(help_menu)
# add preference menu item
#exit_menu = Gtk.MenuItem(_('Quit'))
#exit_menu.connect('activate', self.on_exit)
#menu.add(exit_menu)
menu.show_all()
self.popup = menu
self.ind.connect('clicked', self.popup_menu)
logging.info("Menu shown")
# }}} menu done!
def popup_menu(self, *args):
self.popup.popup(None, None, None, None, 0,
Gtk.get_current_event_time())
def update_indicator_guide(self):
guide = self.sensor_mgr.get_guide()
#self.ind.set_property("label-guide", guide)
def update(self, data):
# data is the dict of all sensors and their values
# { name, label }
# look through data and find out if there are any icons to be set
for sensor in data:
test_str = data[sensor].lower()
if "use_icon" in test_str:
path = data[sensor].split(":")[1]
print(path)
self.ind.set_icon_full(path, "")
# now strip the icon output from data so that it is not displayed
remaining = test_str.split("use_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
if "clear_icon" in test_str:
self.ind.set_icon_full(self.tindicator, "")
remaining = test_str.split("clear_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
label = self.sensor_mgr.get_label(data)
Gdk.threads_enter()
self.ind.set_label(label.strip())
Gdk.threads_leave()
#self.ind.set_title(label.strip())
def load_settings(self):
self.sensor_mgr.load_settings()
self.sensor_mgr.initiate_fetcher(self)
self.update_indicator_guide()
# @staticmethod
def save_settings(self):
self.sensor_mgr.save_settings()
# actions raised from menu
def on_preferences_activated(self, event=None):
"""Raises the preferences dialog. If it's already open, it's
focused"""
if self._preferences_dialog is not None:
self._preferences_dialog.present()
return
self._preferences_dialog = Preferences(self)
self._preferences_dialog.run()
self._preferences_dialog = None
def on_full_sysmon_activated(self, event=None):
os.system('gnome-system-monitor &')
def on_exit(self, event=None, data=None):
"""Action call when the main programs is closed."""
# cleanup temporary indicator icon
os.remove(self.tindicator)
# close the open dialogs
if self._help_dialog is not None:
self._help_dialog.destroy()
if self._preferences_dialog is not None:
self._preferences_dialog.destroy()
logging.info("Terminated")
self.alive.clear() # DM: why bother with Event() ???
try:
Gtk.main_quit()
except RuntimeError:
pass
def _on_help(self, event=None, data=None):
"""Raise a dialog with info about the app."""
if self._help_dialog is not None:
self._help_dialog.present()
return
self._help_dialog = Gtk.MessageDialog(
None, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, None)
self._help_dialog.set_title(_("Help"))
self._help_dialog.set_markup(HELP_MSG)
self._help_dialog.run()
self._help_dialog.destroy()
self._help_dialog = None
class IndicatorSysmonitor(object):
SENSORS_DISABLED = False
def __init__(self):
self._preferences_dialog = None
self._help_dialog = None
self.ind = Gtk.Button.new()
self.ind.set_label("Init...")
self._create_menu()
self.alive = Event()
self.alive.set()
self.sensor_mgr = SensorManager()
self.load_settings()
def _create_menu(self):
"""Creates the main menu and shows it."""
# create menu {{{
menu = Gtk.Menu()
# add System Monitor menu item
full_sysmon = Gtk.MenuItem(_('System Monitor'))
full_sysmon.connect('activate', self.on_full_sysmon_activated)
menu.add(full_sysmon)
menu.add(Gtk.SeparatorMenuItem())
# add preferences menu item
pref_menu = Gtk.MenuItem(_('Preferences'))
pref_menu.connect('activate', self.on_preferences_activated)
menu.add(pref_menu)
# add help menu item
help_menu = Gtk.MenuItem(_('Help'))
help_menu.connect('activate', self._on_help)
menu.add(help_menu)
menu.show_all()
self.popup = menu
self.ind.connect('clicked', self.popup_menu)
logging.info("Menu shown")
# }}} menu done!
def popup_menu(self, *args):
self.popup.popup(None, None, None, None, 0, Gtk.get_current_event_time())
def update_indicator_guide(self):
guide = self.sensor_mgr.get_guide()
def update(self, data):
# data is the dict of all sensors and their values
# { name, label }
# look through data and find out if there are any icons to be set
for sensor in data:
test_str = data[sensor].lower()
if "use_icon" in test_str:
path = data[sensor].split(":")[1]
print(path)
self.ind.set_icon_full(path, "")
# now strip the icon output from data so that it is not displayed
remaining = test_str.split("use_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
if "clear_icon" in test_str:
self.ind.set_icon_full(self.tindicator, "")
remaining = test_str.split("clear_icon")[0].strip()
if not remaining:
remaining = " "
data[sensor] = remaining
label = self.sensor_mgr.get_label(data)
def update_label(label):
self.ind.set_label(label)
return False
if label and self.ind:
GLib.idle_add(update_label, label.strip())
def load_settings(self):
self.sensor_mgr.load_settings()
self.sensor_mgr.initiate_fetcher(self)
self.update_indicator_guide()
# @staticmethod
def save_settings(self):
self.sensor_mgr.save_settings()
# actions raised from menu
def on_preferences_activated(self, event=None):
"""Raises the preferences dialog. If it's already open, it's
focused"""
if self._preferences_dialog is not None:
self._preferences_dialog.present()
return
self._preferences_dialog = Preferences(self)
self._preferences_dialog.run()
self._preferences_dialog = None
def on_full_sysmon_activated(self, event=None):
os.system('gnome-system-monitor &')
def on_exit(self, event=None, data=None):
"""Action call when the main programs is closed."""
# cleanup temporary indicator icon
os.remove(self.tindicator)
# close the open dialogs
if self._help_dialog is not None:
self._help_dialog.destroy()
if self._preferences_dialog is not None:
self._preferences_dialog.destroy()
logging.info("Terminated")
self.alive.clear() # DM: why bother with Event() ???
try:
Gtk.main_quit()
except RuntimeError:
pass
def _on_help(self, event=None, data=None):
"""Raise a dialog with info about the app."""
if self._help_dialog is not None:
self._help_dialog.present()
return
self._help_dialog = Gtk.MessageDialog(
None, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, None)
self._help_dialog.set_title(_("Help"))
self._help_dialog.set_markup(HELP_MSG)
self._help_dialog.run()
self._help_dialog.destroy()
self._help_dialog = None
