def activate(self):
self._pages = {}
self._schedule_refresh()
self._update_time_changed_handle = self._gconf_client.notify_add(
self._gconf_key + "/update_time", self._update_time_changed)
self._urls_changed_handle = self._gconf_client.notify_add(
self._gconf_key + "/urls", self._urls_changed)
g15scheduler.schedule("LoadFeeds", 0, self._load_feeds)
def activate(self):
g15plugin.G15Plugin.activate(self)
self._active = True
self._event_days = None
self._calendar_date = None
self._page = None
self._theme = g15theme.G15Theme(os.path.join(os.path.dirname(__file__),
"default"),
auto_dirty=False)
self._loaded = 0
# Backend
self._account_manager = g15accounts.G15AccountManager(
CONFIG_PATH, CONFIG_ITEM_NAME)
# Calendar
self._calendar = Calendar()
# Menu
self._menu = g15theme.Menu("menu")
self._menu.focusable = True
self._menu.focused_component = True
# Page
self._page = g15theme.G15Page(
name,
self.screen,
on_shown=self._on_shown,
on_hidden=self._on_hidden,
theme_properties_callback=self._get_properties,
thumbnail_painter=self._paint_thumbnail,
originating_plugin=self)
self._page.set_title(_("Calendar"))
self._page.set_theme(self._theme)
self._page.focused_component = self._calendar
self._calendar.set_focused(True)
# List for account changes
self._account_manager.add_change_listener(self._accounts_changed)
self.screen.key_handler.action_listeners.append(self)
# Run first load in thread
self._page.add_child(self._menu)
self._page.add_child(self._calendar)
self._page.add_child(
g15theme.MenuScrollbar("viewScrollbar", self._menu))
self.screen.add_page(self._page)
g15scheduler.schedule("CalendarFirstLoad", 0, self._redraw)
# Listen for changes in the network state
self.screen.service.network_manager.listeners.append(
self._network_state_changed)
# Config changes
self.watch("twenty_four_hour_times", self._config_changed)
def paint(self, canvas):
self._paint_video_image(canvas)
canvas.save()
if self._sidebar_offset < 0 and self._sidebar_offset > -(self.theme.bounds[2]):
self._sidebar_offset -= 5
canvas.translate(self._sidebar_offset, 0)
g15theme.G15Page.paint(self, canvas)
canvas.restore()
if self._sidebar_offset < 0 and self._sidebar_offset > -(self.theme.bounds[2]):
g15scheduler.schedule("RepaintVideoOverly", 0.1, self.redraw)
def _mainLoop(self):
"""
Private
=======
Called by timeout in comeToLife. Keeps looping on timeout. This is the heart of the app.
"""
if self.pauseapp: return True
self.owner._tick()
self._screen.redraw()
if not self.stack.quitApp:
g15scheduler.schedule("ThingPaint", self.owner.speed / 1000.0, self._mainLoop)
def _mainLoop(self):
"""
Private
=======
Called by timeout in comeToLife. Keeps looping on timeout. This is the heart of the app.
"""
if self.pauseapp: return True
self.owner._tick()
self._screen.redraw()
if not self.stack.quitApp:
g15scheduler.schedule("ThingPaint", self.owner.speed / 1000.0, self._mainLoop)
def _attempt_connection(self):
try:
if self._raise_timer is not None:
self._raise_timer.cancel()
# For now, TS3 only backend
self.backend = get_backend("teamspeak3").create_backend()
self.set_icon(self.backend.get_icon())
if self.backend.start(self):
self.show_menu()
self._connected = True
else:
self._connection_timer = g15scheduler.schedule("ReconnectVoip", 5, self._attempt_connection)
except Exception as e:
logger.debug("Error connecting. Will retry...", exc_info = e)
self._connection_timer = g15scheduler.schedule("ReconnectVoip", 5, self._attempt_connection)
def _schedule_refresh(self):
"""
When viewing applications, we don't refresh, just rely on BAMF
events when BAMF is available
"""
if not self._mode == "applications" or self.bamf_matcher is None:
self._timer = g15scheduler.schedule("ProcessesRefresh", 5.0, self._refresh)
def _do_redraw(self):
if self._page is not None:
self._do_draw()
self._page.SetThemeProperty("remaining",
str(self._get_remaining()))
self._redraw_timer = g15scheduler.schedule("Notification", 0.1,
self._do_redraw)
def _loc_changed(self, client, connection_id, entry, *args):
if not entry.get_key().endswith(
"/theme") and not entry.get_key().endswith("/enabled"):
if self._config_change_handle is not None:
self._config_change_handle.cancel()
self._config_change_handle = g15scheduler.schedule(
"ApplyConfig", 3.0, self._config_changed)
def _mouse_move(self):
if self.move_x != 0 or self.move_y != 0:
if self.move_x != 0:
g15uinput.emit(g15uinput.MOUSE, g15uinput.REL_X, self.move_x)
if self.move_y != 0:
g15uinput.emit(g15uinput.MOUSE, g15uinput.REL_Y, self.move_y)
self.timer = g15scheduler.schedule("MouseMove", 0.05, self._mouse_move)
def _mouse_move(self):
if self.move_x != 0 or self.move_y != 0:
if self.move_x != 0:
g15uinput.emit(g15uinput.MOUSE, g15uinput.REL_X, self.move_x)
if self.move_y != 0:
g15uinput.emit(g15uinput.MOUSE, g15uinput.REL_Y, self.move_y)
self.timer = g15scheduler.schedule("MouseMove", 0.05, self._mouse_move)
def run(self):
try :
while not self._stop:
if self._poll.poll(5):
if self._stop:
break
g15scheduler.schedule("popupVolume", 0, self._volume._popup)
if not self._open.read():
break
finally:
try :
self._poll.unregister(self._open)
except Exception as e:
logger.debug("Error when unregistering", exc_info = e)
pass
self._open.close()
def activate(self):
g15plugin.G15Plugin.activate(self)
self._active = True
self._event_days = None
self._calendar_date = None
self._page = None
self._theme = g15theme.G15Theme(os.path.join(os.path.dirname(__file__), "default"), auto_dirty = False)
self._loaded = 0
# Backend
self._account_manager = g15accounts.G15AccountManager(CONFIG_PATH, CONFIG_ITEM_NAME)
# Calendar
self._calendar = Calendar()
# Menu
self._menu = g15theme.Menu("menu")
self._menu.focusable = True
self._menu.focused_component = True
# Page
self._page = g15theme.G15Page(name, self.screen, on_shown = self._on_shown, \
on_hidden = self._on_hidden, theme_properties_callback = self._get_properties,
thumbnail_painter = self._paint_thumbnail,
originating_plugin = self)
self._page.set_title(_("Calendar"))
self._page.set_theme(self._theme)
self._page.focused_component = self._calendar
self._calendar.set_focused(True)
# List for account changes
self._account_manager.add_change_listener(self._accounts_changed)
self.screen.key_handler.action_listeners.append(self)
# Run first load in thread
self._page.add_child(self._menu)
self._page.add_child(self._calendar)
self._page.add_child(g15theme.MenuScrollbar("viewScrollbar", self._menu))
self.screen.add_page(self._page)
g15scheduler.schedule("CalendarFirstLoad", 0, self._redraw)
# Listen for changes in the network state
self.screen.service.network_manager.listeners.append(self._network_state_changed)
# Config changes
self.watch("twenty_four_hour_times", self._config_changed)
def _schedule_refresh(self):
"""
When viewing applications, we don't refresh, just rely on BAMF
events when BAMF is available
"""
if not self._mode == "applications" or self.bamf_matcher is None:
self._timer = g15scheduler.schedule("ProcessesRefresh", 5.0,
self._refresh)
def set_status(self, new_status):
if new_status != self.status:
logger.info("Playback status changed to %s", new_status)
self.status = new_status
if self.status == "Playing":
g15scheduler.schedule("playbackStarted", 1.0, self._playback_started)
elif self.status == "Paused":
self.cancel_redraw()
if self.page != None:
logger.info("Paused.")
self.load_song_details()
self.screen.set_priority(self.page, g15screen.PRI_HIGH, revert_after = 3.0)
else:
self.show_page()
elif self.status == "Stopped":
self.cancel_redraw()
self.hide_page()
def run(self):
try:
while not self._stop:
if self._poll.poll(5):
if self._stop:
break
g15scheduler.schedule("popupVolume", 0,
self._volume._popup)
if not self._open.read():
break
finally:
try:
self._poll.unregister(self._open)
except Exception as e:
logger.debug("Error when unregistering", exc_info=e)
pass
self._open.close()
def _schedule_refresh(self):
if self.schedule_on_gobject:
self.timer = GObject.timeout_add(int(self.get_next_tick() * 1000),
self._refresh)
else:
self.timer = g15scheduler.schedule("%s-Redraw" % self.page_id,
self.get_next_tick(),
self._refresh)
def _attempt_connection(self):
try:
if self._raise_timer is not None:
self._raise_timer.cancel()
# For now, TS3 only backend
self.backend = get_backend("teamspeak3").create_backend()
self.set_icon(self.backend.get_icon())
if self.backend.start(self):
self.show_menu()
self._connected = True
else:
self._connection_timer = g15scheduler.schedule(
"ReconnectVoip", 5, self._attempt_connection)
except Exception as e:
logger.debug("Error connecting. Will retry...", exc_info=e)
self._connection_timer = g15scheduler.schedule(
"ReconnectVoip", 5, self._attempt_connection)
def set_status(self, new_status):
if new_status != self.status:
logger.info("Playback status changed to %s", new_status)
self.status = new_status
if self.status == "Playing":
g15scheduler.schedule("playbackStarted", 1.0, self._playback_started)
elif self.status == "Paused":
self.cancel_redraw()
if self.page != None:
logger.info("Paused.")
self.load_song_details()
self.screen.set_priority(self.page, g15screen.PRI_HIGH, revert_after = 3.0)
else:
self.show_page()
elif self.status == "Stopped":
self.cancel_redraw()
self.hide_page()
def _hide_sidebar(self, after = 0.0):
if after == 0.0:
self._sidebar_offset = -1
self._hide_timer = None
else:
self._sidebar_offset = 0
if self._hide_timer != None:
self._hide_timer.cancel()
self._hide_timer = g15scheduler.schedule("HideSidebar", after, self._hide_sidebar)
def _hide_sidebar(self, after = 0.0):
if after == 0.0:
self._sidebar_offset = -1
self._hide_timer = None
self.redraw()
else:
self._sidebar_offset = 0
self._cancel_hide()
self._hide_timer = g15scheduler.schedule("HideSidebar", after, self._hide_sidebar)
def _name_owner_changed(self, name, old_owner, new_owner):
"""
If the change is a telepathy connection, determine if it is
a connection that is to be removed, or a new connection to
be added
"""
if name.startswith("org.freedesktop.Telepathy.Connection"):
logger.info("Telepathy Name owner changed for %s from %s to %s",
name,
old_owner,
new_owner)
connected = self.menu.is_connected(name)
if new_owner == "" and connected:
logger.info("Removing %s", name)
g15scheduler.schedule("RemoveConnection", 5.0, self.menu.remove_connection, name)
elif old_owner == "" and not connected:
logger.info("Adding %s", name)
g15scheduler.schedule("NewConnection", 5.0, self.menu.new_connection, name, self._session_bus)
def _hide_sidebar(self, after=0.0):
if after == 0.0:
self._sidebar_offset = -1
self._hide_timer = None
else:
self._sidebar_offset = 0
if self._hide_timer is not None:
self._hide_timer.cancel()
self._hide_timer = g15scheduler.schedule("HideSidebar", after, self._hide_sidebar)
def _schedule_redraw(self):
if self.screen.is_visible(self._page):
if self._timer is not None:
self._timer.cancel()
"""
Because the calendar page also displays a clock, we want to
redraw at second zero of every minute
"""
self._timer = g15scheduler.schedule("CalRedraw", 60 - time.gmtime().tm_sec, self._redraw)
def _schedule_redraw(self):
if self.screen.is_visible(self._page):
if self._timer is not None:
self._timer.cancel()
"""
Because the calendar page also displays a clock, we want to
redraw at second zero of every minute
"""
self._timer = g15scheduler.schedule("CalRedraw", 60 - time.gmtime().tm_sec, self._redraw)
def _name_owner_changed(self, name, old_owner, new_owner):
"""
If the change is a telepathy connection, determine if it is
a connection that is to be removed, or a new connection to
be added
"""
if name.startswith("org.freedesktop.Telepathy.Connection"):
logger.info("Telepathy Name owner changed for %s from %s to %s",
name, old_owner, new_owner)
connected = self.menu.is_connected(name)
if new_owner == "" and connected:
logger.info("Removing %s", name)
g15scheduler.schedule("RemoveConnection", 5.0,
self.menu.remove_connection, name)
elif old_owner == "" and not connected:
logger.info("Adding %s", name)
g15scheduler.schedule("NewConnection", 5.0,
self.menu.new_connection, name,
self._session_bus)
def properties_changed_handler(self, something, properties, list):
logger.info("Properties changed, '%s' scheduling a reload", str(properties))
if "PlaybackStatus" in properties:
self.set_status(properties["PlaybackStatus"])
# Check if the track has changed
meta = {}
if "Metadata" in properties:
meta = properties["Metadata"]
if ( "xesam:url" in meta and meta["xesam:url"] != self.playing_uri ) or \
( "mpris:trackid" in meta and meta["mpris:trackid"] != self.playing_track_id ) or \
( "xesam:title" in meta and meta["xesam:title"] != self.playing_track_id ) or \
( "xesam:artist" in meta and meta["xesam:artist"] != self.playing_track_id ) or \
( "xesam:album" in meta and meta["xesam:album"] != self.playing_track_id ):
"""
This doesn't seem right, but it stops the hanging problem when notify-lcd is enabled and
tracks change
"""
g15scheduler.schedule("loadMeta", 1.0, self.reset_elapsed)
if "Volume" in properties:
self.volume = int(properties["Volume"] * 100)
if self.last_properties == None:
self.last_properties = dict(properties)
else:
for key in properties:
self.last_properties[key] = properties[key]
if "Metadata" in self.last_properties:
"""
This doesn't seem right, but it stops the hanging problem when notify-lcd is enabled and
tracks change
"""
g15scheduler.schedule("loadMeta", 1.0, self.load_meta)
def properties_changed_handler(self, something, properties, list):
logger.info("Properties changed, '%s' scheduling a reload",
str(properties))
if "PlaybackStatus" in properties:
self.set_status(properties["PlaybackStatus"])
# Check if the track has changed
meta = {}
if "Metadata" in properties:
meta = properties["Metadata"]
if ( "xesam:url" in meta and meta["xesam:url"] != self.playing_uri ) or \
( "mpris:trackid" in meta and meta["mpris:trackid"] != self.playing_track_id ) or \
( "xesam:title" in meta and meta["xesam:title"] != self.playing_track_id ) or \
( "xesam:artist" in meta and meta["xesam:artist"] != self.playing_track_id ) or \
( "xesam:album" in meta and meta["xesam:album"] != self.playing_track_id ):
"""
This doesn't seem right, but it stops the hanging problem when notify-lcd is enabled and
tracks change
"""
g15scheduler.schedule("loadMeta", 1.0, self.reset_elapsed)
if "Volume" in properties:
self.volume = int(properties["Volume"] * 100)
if self.last_properties == None:
self.last_properties = dict(properties)
else:
for key in properties:
self.last_properties[key] = properties[key]
if "Metadata" in self.last_properties:
"""
This doesn't seem right, but it stops the hanging problem when notify-lcd is enabled and
tracks change
"""
g15scheduler.schedule("loadMeta", 1.0, self.load_meta)
def _do_activate(self):
self.volume_monitor = gio.VolumeMonitor()
for mount in self.volume_monitor.get_mounts():
if not mount.is_shadowed():
self._add_mount(mount)
if len(self.menu.get_children()) > 0:
self.menu.add_separator()
for volume in self.volume_monitor.get_volumes():
if volume.get_mount() == None:
self._add_volume(volume)
# Watch for changes
self.volume_monitor.connect("mount_added", self._on_mount_added)
self.volume_monitor.connect("mount_removed", self._on_mount_removed)
# Refresh disk etc space every minute
self._handle = g15scheduler.schedule("DiskRefresh", 60.0, self._refresh)
def _schedule_redraw(self):
if not self.active:
return
'''
Determine when to schedule the next redraw for.
'''
now = datetime.datetime.now()
if self.display_seconds:
next_tick = now + datetime.timedelta(0, 1.0)
next_tick = datetime.datetime(next_tick.year,next_tick.month,next_tick.day,next_tick.hour, next_tick.minute, int(next_tick.second))
else:
next_tick = now + datetime.timedelta(0, 60.0)
next_tick = datetime.datetime(next_tick.year,next_tick.month,next_tick.day,next_tick.hour, next_tick.minute, 0)
delay = g15pythonlang.total_seconds( next_tick - now )
'''
Try not to create threads or timers if possible. Use g15scheduler.schedule) instead
'''
self.timer = g15scheduler.schedule("ClockRedraw", delay, self._redraw)
def _on_key(app, key):
if app == self._app_name:
self._mm_key = None
if key == "Play":
self._mm_key = g15driver.G_KEY_PLAY
self._player_page._play()
elif key == "Stop":
self._mm_key = g15driver.G_KEY_STOP
self._player_page._stop()
elif key == "Next":
self._mm_key = g15driver.G_KEY_NEXT
self._player_page._fwd()
elif key == "Previous":
self._mm_key = g15driver.G_KEY_PREV
self._player_page._rew()
else:
logger.warning("Unsupported media key %s", key)
if self._mm_key_timer is not None:
self._mm_key_timer.cancel()
self._mm_key_timer = None
self._mm_key_timer = g15scheduler.schedule("CancelMMKey", 1.0, self._clear_mm_key)
def _schedule_redraw(self):
if not self.active:
return
'''
Determine when to schedule the next redraw for.
'''
now = datetime.datetime.now()
if self.display_seconds:
next_tick = now + datetime.timedelta(0, 1.0)
next_tick = datetime.datetime(next_tick.year, next_tick.month,
next_tick.day, next_tick.hour,
next_tick.minute,
int(next_tick.second))
else:
next_tick = now + datetime.timedelta(0, 60.0)
next_tick = datetime.datetime(next_tick.year, next_tick.month,
next_tick.day, next_tick.hour,
next_tick.minute, 0)
delay = g15pythonlang.total_seconds(next_tick - now)
'''
Try not to create threads or timers if possible. Use g15scheduler.schedule) instead
'''
self.timer = g15scheduler.schedule("ClockRedraw", delay, self._redraw)
def _schedule_check(self):
if self.active == True:
g15scheduler.schedule("CheckResolution", 10.0, self.load_menu_items)
def _schedule_refresh(self, time):
self._timer = g15scheduler.schedule("AnalyticsRedraw", time,
self._do_refresh)
def _reload_menu(self):
g15scheduler.schedule("ReloadProcesses", 0, self._do_reload_menu)
def _start_timer(self, message):
self._cancel_timer()
self._displayed_notification = time.time()
self._timer = g15scheduler.schedule("Notification", message.timeout,
self._hide_notification)
def _schedule_refresh(self):
schedule_seconds = g15gconf.get_int_or_default(self._gconf_client, "%s/update_time" % self._gconf_key, 60) * 60.0
self._refresh_timer = g15scheduler.schedule("FeedRefreshTimer", schedule_seconds, self._refresh)
def _config_changed(self, client, connection_id, entry, args):
if self.config_change_timer is not None:
self.config_change_timer.cancel()
self.config_change_timer = g15scheduler.schedule(
"ConfigReload", 1, self._do_config_changed)
def _do_redraw(self):
if self._page != None:
self._screen.redraw(self._page)
self._redraw_timer = g15scheduler.schedule(
"Notification", self._screen.service.animation_delay,
self._do_redraw)
def _do_redraw(self):
if self._page != None:
self._do_draw()
self._page.SetThemeProperty("remaining", str(self._get_remaining()))
self._redraw_timer = g15scheduler.schedule("Notification", 0.1, self._do_redraw)
def _start_timer(self, message):
self._cancel_timer()
self._displayed_notification = time.time()
self._timer = g15scheduler.schedule("Notification", message.timeout, self._hide_notification)
def comeToLife(self, owner):
self.owner = owner
g15scheduler.schedule("ThingPaint", self.owner.speed / 1000.0, self._mainLoop)
def _start_timer(self, message):
logger.debug("Starting hide timeout")
self._cancel_timer()
self._displayed_notification = time.time()
self._timer = g15scheduler.schedule("Notification", message.timeout, self._hide_notification)
def _reload_menu(self):
g15scheduler.schedule("ReloadProcesses", 0, self._do_reload_menu)
def config_changed(self, client, connection_id, entry, args):
if self.change_timer != None:
self.change_timer.cancel()
self.change_timer = g15scheduler.schedule("ChangeG15DaemonConfiguration", 3.0, self.update_conf)
def _start_timer(self, message):
logger.debug("Starting hide timeout")
self._cancel_timer()
self._displayed_notification = time.time()
self._timer = g15scheduler.schedule("Notification", message.timeout,
self._hide_notification)
def comeToLife(self, owner):
self.owner = owner
g15scheduler.schedule("ThingPaint", self.owner.speed / 1000.0, self._mainLoop)
def _schedule_next_state(self, when):
self._destroy_state_change_timer()
self._state_change_timer = g15scheduler.schedule("PommodoroTimerStateChange",
when,
self._state_next)
def _schedule_redraw(self):
self.timer = g15scheduler.schedule("MPDRedraw", 1, self._redraw)
def activate(self):
self._pages = {}
self._schedule_refresh()
self._update_time_changed_handle = self._gconf_client.notify_add(self._gconf_key + "/update_time", self._update_time_changed)
self._urls_changed_handle = self._gconf_client.notify_add(self._gconf_key + "/urls", self._urls_changed)
g15scheduler.schedule("LoadFeeds", 0, self._load_feeds)
def _do_redraw(self):
if self._page != None:
self._screen.redraw(self._page)
self._redraw_timer = g15scheduler.schedule("Notification", self._screen.service.animation_delay, self._do_redraw)
def _loc_changed(self, client, connection_id, entry, args):
if not entry.get_key().endswith("/theme") and not entry.get_key().endswith("/enabled"):
if self._config_change_handle is not None:
self._config_change_handle.cancel()
self._config_change_handle = g15scheduler.schedule("ApplyConfig", 3.0, self._config_changed)
def _schedule_refresh(self):
schedule_seconds = get_update_time(self.gconf_client,
self.gconf_key) * 60.0
self.refresh_timer = g15scheduler.schedule("PPARefreshTimer",
schedule_seconds,
self._refresh)
def _on_disconnect(self):
if not self.is_connected():
raise Exception("Not connected")
self._stop_receiving_keys()
if self.on_close != None:
g15scheduler.schedule("Close", 0, self.on_close, self)
def _config_changed(self, client, connection_id, entry, args):
if self.config_change_timer is not None:
self.config_change_timer.cancel()
self.config_change_timer = g15scheduler.schedule("ConfigReload", 1, self._do_config_changed)
def _popup(self):
if not self._activated:
logger.warning("Cannot popup volume when it is deactivated. This suggests the volume thread has not died.")
return
if not self._light_controls:
self._light_controls = self._screen.driver.acquire_control_with_hint(g15driver.HINT_MKEYS)
if self._lights_timer is not None:
self._lights_timer.cancel()
if self._light_controls is not None:
self._lights_timer = g15scheduler.schedule("ReleaseMKeyLights", 3.0, self._release_lights)
page = self._screen.get_page(id)
if page == None:
if self._screen.driver.get_bpp() != 0:
page = g15theme.G15Page(id, self._screen, priority=g15screen.PRI_HIGH, title="Volume", theme = g15theme.G15Theme(self), \
theme_properties_callback = self._get_theme_properties,
originating_plugin = self)
self._screen.delete_after(3.0, page)
self._screen.add_page(page)
else:
self._screen.raise_page(page)
self._screen.delete_after(3.0, page)
vol_mixer = self._open_mixer()
mute_mixer = None
try :
# Handle mute
mute = False
mutes = None
try :
mutes = vol_mixer.getmute()
except alsaaudio.ALSAAudioError as e:
logger.debug("Could note get mute channel. Trying PCM", exc_info = e)
# Some pulse weirdness maybe?
mute_mixer = alsaaudio.Mixer("PCM", cardindex=self.soundcard_index)
try :
mutes = mute_mixer.getmute()
except alsaaudio.ALSAAudioError as e:
logger.warning("No mute switch found", exc_info = e)
if mutes != None:
for ch_mute in mutes:
if ch_mute:
mute = True
# TODO better way than averaging
volumes = vol_mixer.getvolume()
finally :
vol_mixer.close()
if mute_mixer:
mute_mixer.close()
total = 0
for vol in volumes:
total += vol
volume = total / len(volumes)
self._volume = volume
if self._light_controls is not None:
if self._volume > 90:
self._light_controls.set_value(g15driver.MKEY_LIGHT_MR | g15driver.MKEY_LIGHT_1 | g15driver.MKEY_LIGHT_2 | g15driver.MKEY_LIGHT_3)
elif self._volume > 75:
self._light_controls.set_value(g15driver.MKEY_LIGHT_1 | g15driver.MKEY_LIGHT_2 | g15driver.MKEY_LIGHT_3)
elif self._volume > 50:
self._light_controls.set_value(g15driver.MKEY_LIGHT_1 | g15driver.MKEY_LIGHT_2)
elif self._volume > 25:
self._light_controls.set_value(g15driver.MKEY_LIGHT_1)
else:
self._light_controls.set_value(0)
self._mute = mute
self._screen.redraw(page)