def test_gtk_schedule_action_absolute(self):
scheduler = GtkScheduler(GLib)
gate = threading.Semaphore(0)
starttime = default_now()
endtime = None
def action(scheduler, state):
nonlocal endtime
endtime = default_now()
due = scheduler.now + timedelta(milliseconds=100)
scheduler.schedule_absolute(due, action)
def done(data):
Gtk.main_quit()
gate.release()
return False
GLib.timeout_add(200, done, None)
Gtk.main()
gate.acquire()
assert endtime is not None
diff = endtime - starttime
assert diff > timedelta(milliseconds=80)
def _get_devices(self) -> None:
self._composite_disposable.add(
self._x52_driver_interactor.get_devices().pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._handle_get_devices_result,
on_error=self._handle_get_devices_result))
def on_power_limit_apply_button_clicked(self, *_: Any) -> None:
self._composite_disposable.add(
self._set_power_limit_interactor.execute(
*self.main_view.get_power_limit()).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._handle_set_power_limit_result,
on_error=self._handle_set_power_limit_result))
def _check_new_version(self) -> None:
self._composite_disposable.add(
self._check_new_version_interactor.execute().pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._handle_new_version_response,
on_error=lambda e: _LOG.exception(
"Check new version error: %s", str(e))))
def _update_mfd_button_line(self, text: str) -> None:
_LOG.debug("update_mfd_button_line")
self._composite_disposable.add(
self._x52_driver_interactor.set_mfd_button_line(
self._driver_list[self._driver_index], text).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_error=lambda e: self._handle_generic_set_result(
e, "MFD Button")))
def on_apply_offsets_button_clicked(self, *_: Any) -> None:
self._composite_disposable.add(
self._set_overclock_interactor.execute(
self._gpu_index, self._overclock.perf_level_max,
self.view.get_gpu_offset(),
self.view.get_memory_offset()).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._handle_set_overclock_result,
on_error=self._handle_set_overclock_result))
def _update_mfd_profile_name(self,
name: str,
clear_mfd: bool = False) -> None:
self._composite_disposable.add(
self._x52_driver_interactor.set_mfd_profile_name_line(
self._driver_list[self._driver_index], name, clear_mfd).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_error=lambda e: self._handle_generic_set_result(
e, "MFD Profile name")))
def _monitor_evdev_events(self) -> None:
_LOG.error("monitor_evdev_events")
self._composite_disposable.add(
self._x52_driver_interactor.get_evdev_events(
self._driver_list[self._driver_index]).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._on_evdev_event,
on_error=lambda e: self._handle_generic_set_result(
e, "Evdev events")))
def _start_periodic_refresh(self) -> None:
_LOG.debug("start refresh")
self._composite_disposable.add(
rx.interval(timedelta(milliseconds=999),
scheduler=self._scheduler).pipe(
operators.start_with(0),
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._on_periodic_refresh_tick,
on_error=lambda e: _LOG.exception(
f"Refresh error: {str(e)}")))
def _set_speed_profile(self, profile: SpeedProfile) -> None:
observable = self._set_speed_profile_interactor \
.execute(profile.channel, self._get_profile_data(profile))
self._composite_disposable.add(
observable.pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(
on_next=lambda _: self._update_current_speed_profile(profile),
on_error=lambda e: self._on_set_speed_profile_error(
e, profile)))
def _start_refresh(self) -> None:
_LOG.debug("start refresh")
refresh_interval = self._settings_interactor.get_int(
'settings_refresh_interval')
self._composite_disposable.add(
rx.interval(refresh_interval, scheduler=self._scheduler).pipe(
operators.start_with(0),
operators.subscribe_on(self._scheduler),
operators.flat_map(lambda _: self._get_status()),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._update_status,
on_error=self._handle_refresh_error))
def test_gtk_schedule_action(self):
scheduler = GtkScheduler(GLib)
gate = threading.Semaphore(0)
ran = False
def action(scheduler, state):
nonlocal ran
ran = True
scheduler.schedule(action)
def done(data):
Gtk.main_quit()
gate.release()
return False
GLib.timeout_add(50, done, None)
Gtk.main()
gate.acquire()
assert ran is True
def _set_fan_speed(self,
gpu_index: int,
speed: int = 100,
manual_control: bool = True) -> None:
self._composite_disposable.add(
self._set_fan_speed_interactor.execute(
gpu_index, speed, manual_control).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_error=lambda e:
(LOG.exception(f"Set cooling error: {str(e)}"),
self.main_view.set_statusbar_text(
'Error applying fan profile!'))))
def _set_speed_profile(self, profile: SpeedProfile) -> None:
observable = self._set_speed_profile_interactor \
.execute(profile.channel, self._get_profile_data(profile))
self._composite_disposable.add(
observable.pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(
on_next=lambda _: self._update_current_speed_profile(profile),
on_error=lambda e:
(_LOG.exception("Set cooling error: %s", str(e)),
self.main_view.set_statusbar_text(
'Error applying %s speed profile!' % profile.channel))))
def test_gtk_schedule_action_cancel(self):
ran = False
scheduler = GtkScheduler(GLib)
gate = threading.Semaphore(0)
def action(scheduler, state):
nonlocal ran
ran = True
d = scheduler.schedule_relative(0.1, action)
d.dispose()
def done(data):
Gtk.main_quit()
gate.release()
return False
GLib.timeout_add(200, done, None)
Gtk.main()
gate.acquire()
assert ran is False
def _schedule_lighting_setting(self, settings: LightingSettings) -> None:
_LOG.info(
"Setting lighting: [ Channel: %s, Mode: %s, Speed: %s, Direction: %s, Colors: %s ]",
settings.channel.value, settings.mode.name,
settings.speed_or_default, settings.direction_or_default,
settings.colors.values())
self._composite_disposable.add(
self._set_lighting_interactor.execute(settings).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(
on_next=lambda _: self._on_lighting_setting_complete(settings),
on_error=lambda e: _LOG.exception("Lighting apply error: %s",
str(e))))
def on_mfd_brightness_value_changed(self, widget: Any, *_: Any) -> None:
brightness = int(widget.get_value())
if brightness != self._last_applied_profile.mfd_brightness:
self._last_applied_profile.mfd_brightness = brightness
self._composite_disposable.add(
self._x52_driver_interactor.set_mfd_brightness(
self._driver_list[self._driver_index], brightness).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(
on_error=lambda e: self._handle_generic_set_result(
e, "LED brightness")))
if brightness != self._profile_selected.mfd_brightness:
self._profile_selected.mfd_brightness = brightness
self._profile_selected.save()
def test_gtk_schedule_action_periodic(self):
scheduler = GtkScheduler(GLib)
gate = threading.Semaphore(0)
period = 0.05
counter = 3
def action(state):
nonlocal counter
if state:
counter -= 1
return state - 1
scheduler.schedule_periodic(period, action, counter)
def done(data):
Gtk.main_quit()
gate.release()
return False
GLib.timeout_add(300, done, None)
Gtk.main()
gate.acquire()
assert counter == 0
def on_overclock_apply_button_clicked(self, *_: Any) -> None:
if self._overclock_profile_selected:
self._overclock_profile_applied = self._overclock_profile_selected
self._refresh_overclock_profile_ui(
profile_id=self._overclock_profile_selected.id)
assert self._latest_status is not None
self._composite_disposable.add(
self._set_overclock_interactor.execute(
self._gpu_index, self._latest_status.gpu_status_list[
self._gpu_index].overclock.perf_level_max,
self._overclock_profile_applied.gpu,
self._overclock_profile_applied.memory).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._handle_set_overclock_result,
on_error=self._handle_set_overclock_result))
def _update_mfd_date_time(self) -> None:
_LOG.debug("update_mfd_date_time")
if self._driver_list:
self._composite_disposable.add(
self._x52_driver_interactor.set_date_time(
self._driver_list[self._driver_index],
self._profile_selected.clock_1_use_local_time,
(self._profile_selected.clock_1_use_24h,
self._profile_selected.clock_2_use_24h,
self._profile_selected.clock_3_use_24h),
timedelta(minutes=self._profile_selected.clock_2_offset),
timedelta(minutes=self._profile_selected.clock_3_offset),
self._profile_selected.date_format).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_error=lambda e: self.
_handle_generic_set_result(e, "Date")))
def main():
scheduler = GtkScheduler(GLib)
scrolled_window = Gtk.ScrolledWindow()
window = Window()
window.connect("delete-event", Gtk.main_quit)
container = Gtk.Fixed()
scrolled_window.add(container)
window.add(scrolled_window)
text = 'TIME FLIES LIKE AN ARROW'
def on_next(info):
label, (x, y), i = info
container.move(label, x + i * 12 + 15, y)
label.show()
def handle_label(label, i):
delayer = ops.delay(i * 0.100)
mapper = ops.map(lambda xy: (label, xy, i))
return window.mousemove.pipe(
delayer,
mapper,
)
def make_label(char):
label = Gtk.Label(label=char)
container.put(label, 0, 0)
label.hide()
return label
mapper = ops.map(make_label)
labeler = ops.flat_map_indexed(handle_label)
rx.from_(text).pipe(
mapper,
labeler,
).subscribe(on_next, on_error=print, scheduler=scheduler)
window.show_all()
Gtk.main()
def on_led_status_selected(self, widget: Any, *_: Any) -> None:
active = widget.get_active()
if active >= 0:
assert self._profile_selected is not None
enum_value = widget.get_model()[active][0]
attr_name = widget.get_model()[active][2]
old_led_status = getattr(self._profile_selected, attr_name)
last_applied_led_status = getattr(self._last_applied_profile,
attr_name)
new_led_status = type(old_led_status)(enum_value)
if last_applied_led_status != new_led_status:
setattr(self._last_applied_profile, attr_name, new_led_status)
self._composite_disposable.add(
self._x52_driver_interactor.set_led_status(
self._driver_list[self._driver_index], new_led_status,
attr_name).pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_error=lambda e: self.
_handle_generic_set_result(e, "LED status")))
new_led_status = type(old_led_status)(enum_value)
if old_led_status != new_led_status:
setattr(self._profile_selected, attr_name, new_led_status)
self._profile_selected.save()
def _check_supported_kraken(self) -> None:
self._composite_disposable.add(
self._has_supported_kraken_interactor.execute().pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
).subscribe(on_next=self._has_supported_kraken_result))
def _get_lighting_modes(self) -> Observable:
return self._get_lighting_modes_interactor.execute().pipe(
operators.subscribe_on(self._scheduler),
operators.observe_on(GtkScheduler(GLib)),
)
def test_gtk_schedule_now(self):
scheduler = GtkScheduler(GLib)
diff = scheduler.now - default_now()
assert abs(diff) < timedelta(milliseconds=1)
def test_gtk_schedule_now_units(self):
scheduler = GtkScheduler(GLib)
diff = scheduler.now
sleep(0.1)
diff = scheduler.now - diff
assert timedelta(milliseconds=80) < diff < timedelta(milliseconds=180)
