diff options
author | Eitan Isaacson <eitan@monotonous.org> | 2011-01-07 01:17:18 -0800 |
---|---|---|
committer | Eitan Isaacson <eitan@monotonous.org> | 2011-01-07 13:40:37 -0800 |
commit | 7c7bcb7ace2d54b1289301000f60a7112ee6e737 (patch) | |
tree | 61d520f426724f90a3bd806cdf632f512f1b6abd /caribou | |
parent | 42650f8d9f0bcb72b6b0680d6e3486f0c2d58da8 (diff) | |
download | caribou-7c7bcb7ace2d54b1289301000f60a7112ee6e737.tar.gz |
Got most of scanning working. Yay.
Diffstat (limited to 'caribou')
-rw-r--r-- | caribou/common/settings_manager.py | 2 | ||||
-rw-r--r-- | caribou/ui/keyboard.py | 56 | ||||
-rw-r--r-- | caribou/ui/main.py | 77 | ||||
-rw-r--r-- | caribou/ui/scan.py | 515 | ||||
-rw-r--r-- | caribou/ui/window.py | 7 |
5 files changed, 214 insertions, 443 deletions
diff --git a/caribou/common/settings_manager.py b/caribou/common/settings_manager.py index 92b5137..37d178b 100644 --- a/caribou/common/settings_manager.py +++ b/caribou/common/settings_manager.py @@ -19,7 +19,7 @@ class _SettingsManager(object): try: return self._settings_map[name] except KeyError: - raise AttributeError + raise AttributeError, "no setting named '%s'" % name def _map_settings(self, setting): if self._settings_map.has_key(setting.name): diff --git a/caribou/ui/keyboard.py b/caribou/ui/keyboard.py index b6ca509..38bdfc3 100644 --- a/caribou/ui/keyboard.py +++ b/caribou/ui/keyboard.py @@ -145,10 +145,11 @@ class Key(Gtk.Button, BaseKey): return label.modify_font(None) - def set_color(self, normal_color, mouse_over_color): + def set_color(self, normal_color, mouse_over_color=None): self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(normal_color)[1]) - self.modify_bg(Gtk.StateType.PRELIGHT, - Gdk.color_parse(mouse_over_color)[1]) + if mouse_over_color: + self.modify_bg(Gtk.StateType.PRELIGHT, + Gdk.color_parse(mouse_over_color)[1]) def reset_color(self): self.modify_bg(Gtk.StateType.NORMAL, None) @@ -177,6 +178,39 @@ class KeyboardLayout(Gtk.Table): Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, 0, 0) last_col = next_col + + def get_scan_rows(self): + return [filter(lambda x: x.is_sensitive(), row) for row in self.rows] + + def get_scan_blocks(self, optimal_block_size=8): + # TODO: smarter division using optimal block size. + scan_rows = self.get_scan_rows() + col_num = max([len(row) for row in scan_rows]) + blocks = [] + + for row_index in xrange(len(scan_rows)): + for col_index in xrange(max([len(row) for row in scan_rows])): + try: + key = scan_rows[row_index][col_index] + except IndexError: + continue + + try: + group = blocks[row_index/2] + except IndexError: + group = [] + blocks.append(group) + + try: + group[col_index/3].append(key) + except IndexError: + block = [] + block.append(key) + group.append(block) + + return reduce(lambda a, b: a + b, blocks) + + class KbLayoutDeserializer(object): def __init__(self): @@ -307,7 +341,7 @@ class CaribouKeyboard(Gtk.Notebook): self._update_key_style() def _set_layouts(self, layout_list): - self._clear() + self._clear() for layout in layout_list: self.append_page(layout, None) for row in layout.rows: @@ -374,7 +408,7 @@ class CaribouKeyboard(Gtk.Notebook): self.current_mask |= key.value self.vk.latch_mod(self.current_mask) - def show_all(self): + def show_all_(self): self.set_current_page(self.current_page) Gtk.Notebook.show_all(self) @@ -384,11 +418,6 @@ class CaribouKeyboard(Gtk.Notebook): p.run() p.destroy() - def destroy(self): - for id in self._gconf_connections: - self.client.notify_remove(id) - super(Gtk.Notebook, self).destroy() - def _switch_to_layout(self, name): n_pages = self.get_n_pages() for i in range(n_pages): @@ -397,6 +426,13 @@ class CaribouKeyboard(Gtk.Notebook): self.current_page = i break + def get_current_layout(self): + i = self.get_current_page() + return self.get_nth_page(i) + + def get_layouts(self): + return [self.get_nth_page(i) for i in xrange(self.get_n_pages())] + if __name__ == "__main__": import signal signal.signal(signal.SIGINT, signal.SIG_DFL) diff --git a/caribou/ui/main.py b/caribou/ui/main.py index 49058a2..5175bb0 100644 --- a/caribou/ui/main.py +++ b/caribou/ui/main.py @@ -2,12 +2,13 @@ import pyatspi from gi.repository import GConf from gi.repository import Gtk from gi.repository import Gdk -import signal from window import CaribouWindowEntry, Rectangle from keyboard import CaribouKeyboard +from caribou.common.settings_manager import SettingsManager from caribou.ui.i18n import _ import caribou.common.const as const +from scan import ScanMaster debug = False @@ -20,12 +21,19 @@ class Caribou: self.__current_acc = None self.window_factory = window_factory self.kb_factory = kb_factory - self.window = window_factory(kb_factory()) + kb = kb_factory() + self.window = window_factory(kb) self.client = GConf.Client.get_default() self._register_event_listeners() - #self.client.notify_add(const.CARIBOU_GCONF + "/layout", - # self._on_layout_changed) - signal.signal(signal.SIGINT, self.signal_handler) + SettingsManager.layout.connect("value-changed", + self._on_layout_changed) + + # Scanning + self.scan_master = ScanMaster(self.window, kb) + SettingsManager.scan_enabled.connect("value-changed", + self._on_scan_toggled) + if SettingsManager.scan_enabled.value: + self.scan_master.start() def _register_event_listeners(self): pyatspi.Registry.registerEventListener( @@ -33,8 +41,6 @@ class Caribou: pyatspi.Registry.registerEventListener(self.on_focus, "focus") pyatspi.Registry.registerEventListener( self.on_text_caret_moved, "object:text-caret-moved") - pyatspi.Registry.registerKeystrokeListener( - self.on_key_down, mask=0, kind=(pyatspi.KEY_PRESSED_EVENT,)) def _deregister_event_listeners(self): pyatspi.Registry.deregisterEventListener( @@ -42,17 +48,23 @@ class Caribou: pyatspi.Registry.deregisterEventListener(self.on_focus, "focus") pyatspi.Registry.deregisterEventListener( self.on_text_caret_moved, "object:text-caret-moved") - pyatspi.Registry.deregisterKeystrokeListener( - self.on_key_down, mask=0, kind=pyatspi.KEY_PRESSED_EVENT) - def _on_layout_changed(self, client, connection_id, entry, args): + def _on_scan_toggled(self, setting, val): + if val: + self.scan_master.start() + else: + self.scan_master.stop() + + def _on_layout_changed(self, setting, val): self._deregister_event_listeners() self.window.destroy() self._update_window() self._register_event_listeners() def _update_window(self): - self.window = self.window_factory(self.kb_factory()) + kb = self.kb_factory() + self.scan_master.set_keyboard(kb) + self.window = self.window_factory(kb) def _get_a11y_enabled(self): try: @@ -134,7 +146,7 @@ class Caribou: print "leave entry widget in", event.host_application.name else: if debug == True: - print _("WARNING - Caribou: unhandled editable widget:"), event.source + print _("WARNING - Caribou: unhandled editable widget:"), event.source # Firefox does not report leave entry widget events. # This could be a way to get the entry widget leave events. @@ -143,45 +155,8 @@ class Caribou: # self.window.hide() # print "--> LEAVE EDITABLE TEXT <--" - def on_key_down(self, event): - # key binding for controlling the row column scanning - if event.event_string == "Shift_R": - # TODO: implement keyboard scanning - pass - elif event.event_string == "Control_R": - self.clean_exit() - - def signal_handler(self,signal,frame): - # Clean exit pressing Control + C - self.clean_exit() - def clean_exit(self): - if debug == True: - print "quitting ..." - result = pyatspi.Registry.deregisterEventListener(self.on_text_caret_moved, "object:text-caret-moved") - if debug == True: - print "deregisterEventListener - object:text-caret-moved ...", - if result == False: - print "OK" - else: - print "FAIL" - result = pyatspi.Registry.deregisterEventListener(self.on_focus, "object:state-changed:focused") - if debug == True: - print "deregisterEventListener - object:state-changed:focused ...", - if result == False: - print "OK" - else: - print "FAIL" - result = pyatspi.Registry.deregisterEventListener(self.on_focus, "focus") - if debug == True: - print "deregisterEventListener - focus ...", - if result == False: - print "OK" - else: - print "FAIL" - result = pyatspi.Registry.deregisterKeystrokeListener(self.on_key_down, mask=None, kind=pyatspi.KEY_PRESSED_EVENT) - if debug == True: - print "deregisterKeystrokeListener" - Gtk.main_quit() + self.scan_master.stop() + self._deregister_event_listeners() diff --git a/caribou/ui/scan.py b/caribou/ui/scan.py index f845903..55feabf 100644 --- a/caribou/ui/scan.py +++ b/caribou/ui/scan.py @@ -5,7 +5,7 @@ from gi.repository import Gtk import caribou.common.const as const from caribou.common.settings_manager import SettingsManager -# Scan constans +# Scan constants BUTTON = 'button' ROW = 'row' BLOCK = 'block' @@ -27,400 +27,159 @@ DEFAULT_STEP_TIME = 1000 DEFAULT_SCANNING_TYPE = ROW DEFAULT_SWITCH_TYPE = KEYBOARD_SWITCH_TYPE -class ScanService(): - def __init__(self, keyboard, root_window): - self.keyboard = keyboard +class ScanMaster(): + def __init__(self, root_window, keyboard=None): self.root_window = root_window - self.selected_row = None - self.selected_button = None - self.button_index = 0 - self.row_index = 0 - self.index_i = 0 - self.index_j = 0 - self.is_stop = True - self.timerid = None - self.reverse = False - self.selected_block = [] - - # Settings we are interested in. - for name in ["step_time", "reverse_scanning", "scanning_type"]: - getattr(SettingsManager, name).connect("value-changed", - self._on_switch_changed) - - for name in ["switch_type", "mouse_button", "keyboard_key"]: - getattr(SettingsManager, name).connect("value-changed", - self._on_switch_changed) - - for name in ["default_colors", "normal_color", "mouse_over_color", - "row_scanning_color", "button_scanning_color", - "cancel_scanning_color", "block_scanning_color"]: - getattr(SettingsManager, name).connect("value-changed", - self._on_color_changed) - - SettingsManager.scan_enabled.connect("value-changed", - self._on_scan_toggled) - - self._configure_scanning() - self._set_colors() - self._configure_switch() - - def destroy(self): - self.stop() - self.clean() - self._deregister_events() - - - def _configure_switch(self): - self.switch_type = SettingsManager.switch_type.value - if self.switch_type == MOUSE_SWITCH_TYPE: - self.switch_key = SettingsManager.mouse_button.value - elif self.switch_type == KEYBOARD_SWITCH_TYPE: - self.switch_key = SettingsManager.keyboard_key + self._timer = 0 + self._scan_path = None + self.started = False - try: - pyatspi.Registry.registerKeystrokeListener(self._on_key_pressed, - mask=None, kind=(pyatspi.KEY_PRESSED_EVENT,)) - pyatspi.Registry.registerKeystrokeListener(self._on_key_released, - mask=None, kind=(pyatspi.KEY_RELEASED_EVENT,)) - except: - print "Error while registering keyboard events in scan.py" - - def _deregister_events(self): - try: - pyatspi.Registry.deregisterKeystrokeListener(self._on_key_pressed, - mask=None, kind=pyatspi.KEY_PRESSED_EVENT) - pyatspi.Registry.deregisterKeystrokeListener( - self._on_key_released, - mask=None, kind=pyatspi.KEY_RELEASED_EVENT) - except: - print "Error while deregistering keyboard events in scan.py" - - def _on_switch_changed(self, settings, val): - self._deregister_events() - self._configure_switch() - - def _on_scan_toggled(self, settings, val): - if val: - self.start() - else: - self.stop() + SettingsManager.step_time.connect("value-changed", + self._on_step_time_changed) + SettingsManager.scanning_type.connect("value-changed", + self._on_scanning_type_changed) + if keyboard: + self.set_keyboard(keyboard) - def _on_color_changed(self, settings, val): - self._set_colors() + def start(self): + if self.started: return - def _on_scanning_type_changed(self, settings, val): - self._configure_scanning() + if self._timer == 0: + self._timer = gobject.timeout_add( + int(SettingsManager.step_time.value*1000), self._scan) - def _configure_scanning(self): - if not self.is_stop: - self._stop() - self.scanning_type = SettingsManager.scanning_type.value - self.reverse = SettingsManager.reverse_scanning.value - self.step_time = SettingsManager.step_time.value + self._grab_mouse_events() + + pyatspi.Registry.registerKeystrokeListener( + self._on_key_pressed, mask=0, kind=(pyatspi.KEY_PRESSED_EVENT,)) - if self.scanning_type == BLOCK: - self.selected_block = [] - else: - self.selected_block = self.keyboard - self.scanning = self.scanning_type - - def _set_colors(self): - self.default_colors = SettingsManager.default_colors.value - self.normal_color = SettingsManager.normal_color.value - self.mouse_over_color = SettingsManager.mouse_over_color.value - self.row_scanning_color = SettingsManager.row_scanning_color.value - self.button_scanning_color = \ - SettingsManager.button_scanning_color.value - self.cancel_scanning_color = \ - SettingsManager.cancel_scanning_color.value - self.block_scanning_color = SettingsManager.block_scanning_color.value - - # public start - def start(self, scanning=None): - self.scanning = scanning or self.scanning_type - self.clean() - if self.root_window and \ - self.switch_type == MOUSE_SWITCH_TYPE: - self._grab_mouse_events() - - if not self.reverse: - self.reset(self.scanning) - - # public stop def stop(self): - if self.switch_type == MOUSE_SWITCH_TYPE: - self._ungrab_mouse_events() - self.clean() - self._stop() - - #private start - def _start(self, scanning=ROW): - if self.is_stop == True and self.timerid == None: - self.is_stop = False - self.button_index = -1 - self.row_index = -1 - if scanning == ROW: - self.selected_row = [] - self.timerid = gobject.timeout_add( - int(1000*self.step_time), self._scan_row) - elif scanning == BUTTON: - self.selected_button = None - self.timerid = gobject.timeout_add( - int(1000*self.step_time), self._scan_button) - elif scanning == BLOCK: - self.selected_block = [] - self.selected_row = [] - self.clean() - self.index_i = 2 - self.index_j = 1 - self.timerid = gobject.timeout_add( - int(1000*self.step_time), self._scan_block) - - # private stop - def _stop(self): - self.is_stop = True - if self.timerid: - gobject.source_remove(self.timerid) - self.timerid = None - - def reset(self, scanning=ROW): - self._stop() - self._start(scanning) - - def clean(self): - for row in self.keyboard: - for button in row: - self.select_button(button, False) - - - def change_keyboard(self, keyboard): - if not self.is_stop: - self._stop() - self.keyboard = keyboard - self.scanning = self.scanning_type - self.start(self.scanning_type) - if self.scanning == ROW: - self.selected_block = keyboard + if self.started: return + self._ungrab_mouse_events() - def _grab_mouse_events(self): - Gdk.event_handler_set(self._mouse_handler) + if self._last_block is not None: + self._multi_map(lambda x: x.reset_color(), self._last_block) - def _ungrab_mouse_events(self): - Gdk.event_handler_set(Gtk.main_do_event) + if self._timer != 0: + gobject.source_remove(self._timer) + self._timer = 0 - def _mouse_handler(self, event): - if self.root_window.window.is_visible(): - if event.type == Gdk.EventType.BUTTON_PRESS and \ - str(event.button) == self.switch_key.value: - self._handle_press() - elif event.type == Gdk.BUTTON_RELEASE and \ - str(event.button) == self.switch_key.value: - self._handle_release() - elif not event.type == Gdk.ENTER_NOTIFY: - Gtk.main_do_event(event) - else: - Gtk.main_do_event(event) + pyatspi.Registry.deregisterKeystrokeListener( + self._on_key_pressed, mask=0, kind=pyatspi.KEY_PRESSED_EVENT) - def _scan_block(self): - if self.is_stop: - return False - # Clean the previous block - self.select_block(self.selected_block, False) - # Update indexes, three horizontal blocks, and two vertical - if self.index_j < 2: - self.index_j += 1 - elif self.index_i < 1: - self.index_i += 1 - self.index_j = 0 + def _on_scanning_type_changed(self, setting, val): + layout = self.keyboard.get_current_layout() + if SettingsManager.scanning_type.value == ROW: + self._blocks = layout.get_scan_rows() else: - self.index_j = 0 - self.index_i = 0 - - self.selected_block = [] - #width = self.root_window.size_request()[0] - #height = self.root_window.size_request()[1] - root_x = self.root_window.get_position()[0] - root_y = self.root_window.get_position()[1] - offset_w = self.index_j*(width/3) - offset_h = self.index_i*(height/2) - - block_window = (root_x + offset_w, - root_y + offset_h, - width/3, - height/2) - empty_r = () - try: - for row in self.keyboard: - line = [] - for button in row: - abs_b_x = button.get_allocation()[0] + \ - button.window.get_position()[0] - abs_b_y = button.get_allocation()[1] + \ - button.window.get_position()[1] - abs_b_r = (abs_b_x, - abs_b_y, - button.size_request()[0], - button.size_request()[1]) - - # If button rectangle is inside the block: - intersect = block_window.intersect(abs_b_r) - # If the intersected rectangle != empty - if intersect != empty_r: - # If the witdth of intersection is bigger than half - # of button width and height, we append button to line - if (intersect.width > (abs_b_r.width / 2)) and \ - (intersect.height > (abs_b_r.height / 2)): - line.append(button) - - - if len(line) > 0: - self.selected_block.append(line) - - except Exception as e: - self.is_stop = True - return False - - self.select_block(self.selected_block, True, - self.block_scanning_color) - return True - - - - def _scan_row(self): - if self.is_stop: - return False + self._blocks = layout.get_scan_blocks() + def _on_step_time_changed(self, setting, val): + if self._timer != 0: + gobject.source_remove(self._timer) + self._timer = gobject.timeout_add(int(1000*val), self._scan) + + def _on_layout_activated(self, keyboard, layout, num): + if SettingsManager.scanning_type.value == ROW: + self._blocks = layout.get_scan_rows() else: - self.select_row(self.selected_row, - self.scanning_type == BLOCK, - self.block_scanning_color) - self.row_index += 1 - if self.row_index >= len(self.selected_block): - self.row_index = 0 - self.selected_row = self.selected_block[self.row_index] - self.select_row(self.selected_row, True, self.row_scanning_color) - return True - - def _scan_button(self): - if self.scanning == CANCEL: - self.scanning = BUTTON - self.selected_button = None - self.select_row(self.selected_row, True, self.row_scanning_color) - return True + self._blocks = layout.get_scan_blocks() + self._scan_path = [-1] + + def set_keyboard(self, keyboard): + self._last_block = None + keyboard.connect("switch-page", self._on_layout_activated) + self.keyboard = keyboard + + def _multi_map(self, func, array): + if isinstance(array, list): + for item in array: + self._multi_map(func, item) else: - if self.selected_button and self.selected_button in self.selected_row: - self.select_button(self.selected_button, True, self.row_scanning_color) - - if self.is_stop: - return False - - self.button_index += 1 - if self.button_index >= len(self.selected_row): - self.select_row(self.selected_row, True, self.cancel_scanning_color) - self.button_index = -1 - self.scanning = CANCEL - return True - - self.selected_button = self.selected_row[self.button_index] - while self.selected_button.key_type == const.DUMMY_KEY_TYPE: - self.button_index += 1 - if self.button_index >= len(self.selected_row): - self.select_row(self.selected_row, True, self.cancel_scanning_color) - self.button_index = -1 - self.scanning = CANCEL - return True - - self.selected_button = self.selected_row[self.button_index] - self.select_button(self.selected_button, True, self.button_scanning_color) - return True - - def select_block(self, block, state, color=None): - for row in block: - self.select_row(row, state, color) - - def select_row(self, row, state, color=None): - for button in row: - self.select_button(button, state, color) - - def select_button(self, button, state, color=None): - if state: - button.set_color(color, self.mouse_over_color) - elif self.default_colors: - button.reset_color() + func(array) + + def _get_element_at_path(self, array, path): + element = array + for index in path: + element = element[index] + return element + + def _get_next_block(self): + cancel = False + self._scan_path += [self._scan_path.pop() + 1] + try: + block = self._get_element_at_path(self._blocks, + self._scan_path) + except IndexError: + if len(self._scan_path) == 1: + block = self._blocks[0] + self._scan_path = [0] + else: + block = self._get_element_at_path( + self._blocks, self._scan_path[:-1]) + self._scan_path = self._scan_path[:-1] + [-1] + cancel = True + + return cancel, block + + def _scan(self): + if self._scan_path is None: return True + + if self._last_block is not None: + self._multi_map(lambda x: x.reset_color(), + self._last_block) + + self._cancel, next_block = self._get_next_block() + + color = SettingsManager.button_scanning_color.value + + if self._cancel: + color = SettingsManager.cancel_scanning_color.value + elif isinstance(next_block, list): + if SettingsManager.scanning_type.value == ROW: + color = SettingsManager.row_scanning_color.value + else: + color = SettingsManager.block_scanning_color.value + + self._multi_map(lambda x: x.set_color(color, None), next_block) + self._last_block = next_block + return True + + def _do_switch(self): + if self._cancel: + assert(len(self._scan_path) > 1) + self._scan_path.pop() + elif isinstance(self._last_block, list): + assert(len(self._last_block) > 0) + self._scan_path.append(-1) else: - button.set_color(self.normal_color, - self.mouse_over_color) + self._last_block.clicked() - def _on_key_pressed(self, event): - if event.event_string == "Escape": - SettingsManager.scan_enabled.value = False - elif self.switch_type == KEYBOARD_SWITCH_TYPE and \ - self.switch_key.value == event.event_string: - self._handle_press() - - def _on_key_released(self, event): - if self.switch_type == KEYBOARD_SWITCH_TYPE and \ - self.switch_key.value == event.event_string: - self._handle_release() - elif event.event_string != "Escape": - self._stop() - self.start() - - def _handle_press(self): - if self.reverse: - self._start(self.scanning) - - def _handle_release(self): - if self.reverse: - if not self.is_stop: - if self.scanning == ROW and \ - len(self.selected_row) > 0: - self.scanning = BUTTON - elif self.scanning == BLOCK and \ - len(self.selected_block) > 0: - self.scanning = ROW - elif self.scanning == BUTTON and \ - self.selected_button: - self.clean() - if self.selected_button.key_type == const.PREFERENCES_KEY_TYPE: - self.stop() - self.selected_button.clicked() - self.selected_button = None - self.scanning = self.scanning_type - self.reset() - - elif self.scanning == CANCEL: - self.clean() - self.scanning = self.scanning_type - self._stop() + def _grab_mouse_events(self): + Gdk.event_handler_set(self._mouse_handler, None) + + def _ungrab_mouse_events(self): + Gdk.event_handler_set(Gtk.main_do_event, None) + + def _mouse_handler(self, event, user_data): + if SettingsManager.switch_type.value != MOUSE_SWITCH_TYPE or \ + event.type not in (Gdk.EventType.BUTTON_PRESS, + Gdk.EventType.ENTER_NOTIFY): + Gtk.main_do_event(event) + return + if self.root_window.get_window().is_visible(): + if event.type == Gdk.EventType.BUTTON_PRESS and \ + str(event.button.button) == \ + SettingsManager.mouse_button.value: + self._do_switch() + elif event.type != Gdk.EventType.ENTER_NOTIFY: + Gtk.main_do_event(event) else: - if not self.is_stop: - if self.scanning == ROW and \ - len(self.selected_row) > 0: - self.scanning = BUTTON - self.reset(BUTTON) - - elif self.scanning == BLOCK and \ - len(self.selected_block) > 0: - self.scanning = ROW - self.reset(ROW) - elif self.scanning == BUTTON and \ - self.selected_button: - self.selected_button.clicked() - self.scanning = ROW - if self.selected_button.key_type \ - == const.PREFERENCES_KEY_TYPE: - self.selected_button = None - self.stop() - else: - self.selected_button = None - self.scanning = self.scanning_type - - elif self.scanning == CANCEL: - self.scanning = self.scanning_type - self.clean() - self.reset(self.scanning_type) - - + Gtk.main_do_event(event) + + def _on_key_pressed(self, event): + if SettingsManager.switch_type.value == KEYBOARD_SWITCH_TYPE and \ + SettingsManager.keyboard_key.value == event.event_string: + self._do_switch() diff --git a/caribou/ui/window.py b/caribou/ui/window.py index 5e45d13..d6739f1 100644 --- a/caribou/ui/window.py +++ b/caribou/ui/window.py @@ -21,11 +21,13 @@ # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA from caribou import data_path +from opacity import ProximityWindowBase +from caribou.common.settings_manager import SettingsManager + from gi.repository import GConf from gi.repository import Gtk from gi.repository import Gdk from gi.repository import Clutter -from opacity import ProximityWindowBase import os import sys import gobject @@ -204,8 +206,7 @@ class CaribouWindow(Gtk.Window, Clutter.Animatable, ProximityWindowBase): return offset def _get_keyboard_conf(self): - layout = self._gconf_client.get_string(CARIBOU_GCONF_LAYOUT_KEY) \ - or "qwerty" + layout = SettingsManager.layout.value conf_file_path = os.path.join(data_path, CARIBOU_LAYOUT_DIR, layout) if os.path.exists(conf_file_path): |