def __init__(self, **kwargs):
super(IcarusTouchWidget,
self).__init__(**kwargs) # don't know if this is necessary?
# add background image (and add it in the BACKGROUND! --> index modification)
self.background = Background(
source=self.app.config.get('Graphics', 'Background'))
self.float_layout.add_widget(self.background,
index=len(self.float_layout.children))
# add feedback wall image
self.feedback_wall = Feedback(source='images/feedbackwall.png',
transparency=0)
self.float_layout.add_widget(self.feedback_wall)
# add the keyboard itself
my_key_width = KEY_WIDTH
self.keyboard = Keyboard(
source=self.app.config.get('Graphics', 'Keyboard'),
pos=(-540, 366),
size=(
12 * 5 * my_key_width, 468
), # optimization for small screens (e.g. smartphones): 468 if self.get_parent_window().height > (468 + self.get_parent_window().height * 0.3) else self.get_parent_window().height * 0.7
border_width=BORDER_WIDTH,
key_width=my_key_width)
self.add_widget(self.keyboard)
# initialize the midi device
pygame.midi.init()
self.set_midi_device()
# initialize the settings_panel (I'm doing this here, otherwise opening it in real-time takes ages...)
self.my_settings_panel = MySettingsPanel()
def build(self):
self.layout.add_widget(self.control_panel)
self.layout.add_widget(self.screen)
self.screen.difficulty.text = self.difficulty
self.keyboard = Keyboard(self.screen.output, self.key_callback)
self.layout.add_widget(self.keyboard)
return self.layout
def __init__(self, master=None, **kwargs):
tk.Frame.__init__(self, master, **kwargs)
master.title("Hangman")
master.geometry("1000x800")
master.resizable(False, False)
self.word = master.word # get the value from the first screen
self.score = 7
self.display = list(len(self.word) * '_')
# Place the hangman
# TODO
# Display the keyboard
keyboard = Keyboard(self)
keyboard.pack()
# Place box for keeping track of word and sample word below
word_box = tk.Frame(master, height=80, width=600, bd=5, bg='white')
self.label = tk.Label(word_box, text=self.display)
self.label.config(font=(None, 25))
self.label.pack()
lbl_txt = tk.Label(word_box, text=self.word)
lbl_txt.pack()
word_box.place(relx=0.5, y=700, anchor='n')
def test_part_key_presses(self, inp, res):
res = res.format(**key)
kb = Keyboard('US')
i = random.randint(0, len(res))
pre_word, shift, caps = kb.part_key_press_string(res[:i])
post_word, shift, caps = kb.part_key_press_string(res[i:], shift, caps)
assert inp == pre_word + post_word
def input_wifi_password():
global current_screen, screen_type
current_screen = "wifi_password"
screen_type = "keyboard"
print("input_wifi_password")
kb = Keyboard(oled, kb_callback)
kb.show()
def test_word_to_key_press(self, inp, res):
key = {'c': CAPS_KEY,
's': SHIFT_KEY}
KB = Keyboard('US')
t1 = KB.word_to_key_presses(inp)
t2 = res.format(**key)
assert t1 == t2, "{!r} <--> {!r}".format(t1, t2)
def test_key_prox_keys(self):
kb = Keyboard('US')
for inp, res in [('a', 'aqwsxz'),
('t', 'tr456yhgf'),
(';', ";lop['/.")]:
ret = kb.keyboard_prox_key(inp)
assert set(ret) == set(res)
def test_keyboard_dist(self):
inp_res_map = [(('t', 't'), (0)), (('t', 'T'), (0.8)),
(('a', 'S'), (1.8)), (('a', 'w'), (2)),
(('w', '$'), (3.8)), (('<', '>'), (1))]
kb = Keyboard('US')
for q, r in inp_res_map:
assert kb.keyboard_dist(*q) == r
def test_part_key_presses(self, inp, res):
res = res.format(**key)
kb = Keyboard('US')
i = random.randint(0, len(res))
pre_word, shift, caps = kb.part_key_press_string(res[:i])
post_word, shift, caps = kb.part_key_press_string(res[i:], shift, caps)
assert inp == pre_word + post_word
def test_key_press_insert_edits(self, inp, res):
inp_res_map = [(
('{s}pa'.format(**key), [CAPS_KEY, SHIFT_KEY,
'a'], [CAPS_KEY, 't']),
(
'pA',
'Pa',
'aPa',
'pa',
'PA',
'tpa', # j=0
'pA',
'Pa',
'Apa',
'A',
'a',
'Ta', # j=1
'PA',
'PA',
'Paa',
'P',
'P',
'Pt', # j=2
'Paa'))]
kb = Keyboard('US')
for inp, res in inp_res_map:
for i, r in enumerate(kb.key_press_insert_edits(*inp)):
print i, r, res[i]
assert r == res[i]
def test_loc(self):
inp_res_map = [(('t'), (1, 5, 0)), (('T'), (1, 5, 1)),
(('a'), (2, 1, 0)), (('('), (0, 9, 1)),
(('M'), (3, 7, 1))]
kb = Keyboard('US')
for q, r in inp_res_map:
assert kb.loc(*q) == r
def write_msg(user_id, *messages, keyboard_type=None, logging=True):
"""
Отправляет сообщения из поля messages пользователю
:param user_id: id пользователя вконтакте
:param messages: str
:param keyboard_type: str принимает параметр 'reg' если нужно отправить клавиатуру для регистрации
"""
buttons = list()
if keyboard_type == 'reg':
buttons.append(Keyboard.get_buttons('negative', 'Отмена'))
else:
buttons.append(Keyboard.get_buttons('positive', 'Оценки'))
buttons.append(
Keyboard.get_buttons('primary', 'Дз на завтра',
'Дз на сегодня'))
buttons.append(
Keyboard.get_buttons('secondary', 'Посчитать', 'Помощь',
"Авторизация"))
# buttons.append(Keyboard.get_buttons('primary', 'Дз: сегодня'))
keyboard = Keyboard.get_keyboard(False, buttons)
for message in messages:
random_id = random.randint(10, 100000)
vk_session.messages.send(user_id=user_id,
message=message,
random_id=random_id,
keyboard=keyboard)
if logging: print("Ответил", message)
def __init__(self, master=None, **kwargs):
tk.Frame.__init__(self, master, **kwargs)
master.title("Hangman")
master.geometry("900x550")
master.resizable(False, False)
self.word = master.word # get the value from the first screen
self.chosen_list = []
self.score = 7
self.display = list(len(self.word) * '_')
self.image = f'images/hangman{self.score}.png'
# Place the hangman
hangman_draw = tk.Frame(master, height=580, width=600)
self.photo = tk.PhotoImage(file=self.image)
photo_label = tk.Label(hangman_draw, image=self.photo)
photo_label.pack()
hangman_draw.place(relx=0.5, y=100, anchor='n')
# Display the keyboard
keyboard = Keyboard(self)
keyboard.pack()
# Place box for keeping track of word and sample word below
word_box = tk.Frame(master, height=80, width=600, bd=5)
self.label = tk.Label(word_box, text=self.display)
self.label.config(font=(None, 25))
self.label.pack()
self.lbl_txt = tk.Label(word_box, text=self.chosen_list)
self.lbl_txt.pack()
word_box.place(relx=0.5, y=425, anchor='n')
def __init__(self):
Gtk.DrawingArea.__init__(self)
self.caret = Gdk.Rectangle()
self.connect("draw", self.on_draw)
self.connect("key-press-event", self.on_key_press)
self.connect("key-release-event", self.on_key_release)
self.connect("focus-in-event", self.on_focus_in)
self.connect("focus-out-event", self.on_focus_out)
self.im_context = Gtk.IMMulticontext()
self.im_context.set_client_window(self.get_window())
self.im_context.connect("commit", self.on_commit)
self.im_context.connect("delete-surrounding",
self.on_delete_surrounding)
self.im_context.connect("retrieve-surrounding",
self.on_retrieve_surrounding)
self.im_context.connect("preedit-changed", self.on_preedit_changed)
self.im_context.connect("preedit-end", self.on_preedit_end)
self.im_context.connect("preedit-start", self.on_preedit_start)
self.set_can_focus(True)
self.roomazi = Roomazi()
self.keyboard = Keyboard(self.roomazi)
self.engine = Engine(self.roomazi)
def dispense_and_scan(self, author_selection):
j = 0
#f = open(self.dispenserDevices[0], "wb")
f = open("/dev/ttyUSB0", "wb")
f.write("020180000380".decode("hex"))
f.flush()
f.close()
#k = Keyboard(self.scannerKeyDev[0])
k = Keyboard("/dev/input/event0")
k.flush()
code = ""
i = 0
#return code
start_time = time.time()
while i < 8:
key = k.readKey()
#print key
if key is not None:
code += key
i += 1
end_time = time.time() - start_time
#self.write_log("end time = "+str(end_time))
if(end_time > 4):
self.write_log("reader time out!!")
break;
self.write_log("Dispensing from card dispenser " + str(0))
self.write_log("device = "+str(self.dispenserDevices[0]))
self.write_log("scanner device = "+str(self.scannerKeyDev[0]))
return code
class Nestopia():
def __init__(self):
self.workspace = NSWorkspace.sharedWorkspace()
self.keyboard = Keyboard()
def show(self):
for app in self.workspace.runningApplications():
if app.localizedName() == 'Nestopia':
app.unhide()
app.activateWithOptions_(
NSApplicationActivateIgnoringOtherApps)
time.sleep(0.05)
def pause(self):
self.keyboard.KeyPress('enter')
def rotate(self):
self.keyboard.KeyPress('shift')
def left(self):
self.keyboard.KeyPress('left')
def right(self):
self.keyboard.KeyPress('right')
def down(self):
self.keyboard.KeyPress('down')
def full_restart(self):
"""Fully restart the game, clearing all history, etc."""
# Initialize real and virtual keyboards.
self.keyboard = Keyboard()
self.virtual_keyboards = []
# Initialize game objects
self.players = [Ship(self.keyboard, self.view_size / 2.0)]
self.bullets = []
self.rand_state = random.getstate()
self.asteroids = [Asteroid(self, clear_zone = self.view_size / 2.0,
seed = random.random())
for i in range(self.num_asteroids)]
self.DEBUG = DataToggle(source = self.keyboard[sf.Key.NUM0],
initVal = False)
# self.RECORDING = Toggle(source = self.keyboard[sf.Key.T],
# initVal = False)
self.won = False
# Start the system running
self.running = DataToggle(
source = DataOr(self.keyboard[sf.Key.ESCAPE],
DataAnd(self.keyboard[sf.Key.Q],
DataOr(self.keyboard[sf.Key.L_SYSTEM],
self.keyboard[sf.Key.R_SYSTEM]))),
initVal = True)
def setup_network_connection(self):
Keyboard.show(layout=[])
from subprocess import Popen
if self.wicd is not None:
if self.wicd.poll() is None:
return
self.wicd = Popen(['xterm', '-maximized', '-e', 'wicd-curses'])
def __init__(self, tv=None):
self._tv = tv
self._gamepad = None
self._gamepad_connected = threading.Event()
self._last_activity_ts = time.time()
self._locked = False
self._kbd = Keyboard()
self._stop = threading.Event()
def test_other_key_presses_to_word(self, inp, res):
key = {'c': CAPS_KEY,
's': SHIFT_KEY}
KB = Keyboard('US')
kw = KB.key_presses_to_word('{c}asdf{s}1{c}sdf'.format(**key))
assert 'ASDFasdf' == KB.key_presses_to_word('{c}asdf{s}a{c}sdf'.format(**key))
assert 'ASDF!sdf' == KB.key_presses_to_word('{c}asdf{s}1{c}sdf'.format(**key))
assert KB.key_presses_to_word('{s}apa'.format(**key)) == 'Apa'
def volume_down():
"""
Decrease system volume
Done by triggering a fake VK_VOLUME_DOWN key event
:return: void
"""
Sound.__track()
Sound.__set_current_volume(Sound.current_volume() - 2)
Keyboard.key(Keyboard.VK_VOLUME_DOWN)
def mute():
"""
Mute or un-mute the system sounds
Done by triggering a fake VK_VOLUME_MUTE key event
:return: void
"""
Sound.__track()
Sound.__is_muted = (not Sound.__is_muted)
Keyboard.key(Keyboard.VK_VOLUME_MUTE)
def test_loc(self):
inp_res_map = [(('t'), (1,5,0)),
(('T'), (1,5,1)),
(('a'), (2,1,0)),
(('('), (0,9,1)),
(('M'), (3,7,1))]
kb = Keyboard('US')
for q, r in inp_res_map:
assert kb.loc(*q) == r
def volume_up():
"""
Increase system volume
Done by triggering a fake VK_VOLUME_UP key event
:return: void
"""
Key.__track()
Key.__set_current_volume(Key.current_volume() + 2)
Keyboard.key(Keyboard.VK_VOLUME_UP)
def __init__(self, ratio=1):
self.RUN = True
self.TOGGLE = False
self.vision = Vision(ratio=ratio)
self.keyboard = Keyboard(sleep=1)
self.KEYCODES = {1: 18, 2: 19, 3: 20, 4: 21, 5: 23}
self.potions_box = {"top": 850, "left": 1920, "width": 500, "height": 200}
self.menu_box = {"top": 300, "left": 1920 + 680, "width": 320, "height": 260}
self.mouse = Mouse()
def run():
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW:
print('\n' + get_name(event.user_id) + ' (id: ' +
str(event.user_id) + ')')
print('Сообщение пришло в: ' +
str(datetime.strftime(datetime.now(), "%H:%M:%S")))
print('Текст сообщения: ' + str(event.text))
print("---------------------------------\n")
response = event.text.lower()
keyboard = Keyboard()
if event.from_user and event.to_me:
if found_user(event.user_id) == False:
print(event.user_id)
print(type(event.user_id))
send = {
'lang': '',
'level': '',
'format': '',
'discus': ''
}
steps = {
'1': False,
'2': False,
'3': False,
'4': False,
'5': False
}
bot = VkBot(event.user_id, send, steps)
add_into_user_bot(event.user_id, send, steps, bot)
else:
if 'vkbot' not in users_bot[event.user_id].keys():
user = users_bot[event.user_id]
bot = VkBot(event.user_id, user['send'], user['steps'])
add_into_user_bot(event.user_id, user['send'],
user['steps'], bot)
bot_Object = users_bot[event.user_id]['vkbot']
keyboard = keyboard.create_keyboard(response,
bot_Object.get_step())
bb = bot_Object.message(response, keyboard)
add_into_user_bot(event.user_id, bot_Object.send,
bot_Object.STEPS, bot_Object)
print(bb)
print(users_bot)
print(bot_Object.send)
print(bot_Object.STEPS)
add_data_in_json(event.user_id)
if bb == None:
continue
elif len(bb) == 4:
send_message(vk,
bb[0],
bb[1],
message=bb[2],
keyboard=bb[3])
elif len(bb) == 3:
send_message(vk, bb[0], bb[1], message=bb[2])
def test_sub_word_table(self, inp, res):
kb = Keyboard('US')
res = res.format(**key)
A = kb.sub_word_table(res)
print '\n'.join(str(x) for x in A)
for i in xrange(len(res)):
pre_w, shift, caps = A[i][0]
post_w = A[i][2 * shift + caps + 1][0]
assert pre_w + post_w == inp
def volume_up():
"""
Increase system volume
Done by triggering a fake VK_VOLUME_UP key event
:return: void
"""
Sound.__track()
Sound.__set_current_volume(Sound.current_volume() + 2)
Keyboard.key(Keyboard.VK_VOLUME_UP)
def volume_down():
"""
Decrease system volume
Done by triggering a fake VK_VOLUME_DOWN key event
:return: void
"""
Key.__track()
Key.__set_current_volume(Key.current_volume() - 2)
Keyboard.key(Keyboard.VK_VOLUME_DOWN)
def test_sub_word_table(self, inp, res):
kb = Keyboard('US')
res = res.format(**key)
A = kb.sub_word_table(res)
print '\n'.join(str(x) for x in A)
for i in xrange(len(res)):
pre_w, shift, caps = A[i][0]
post_w = A[i][2*shift + caps + 1][0]
assert pre_w + post_w == inp
def mute():
"""
Mute or un-mute the system sounds
Done by triggering a fake VK_VOLUME_MUTE key event
:return: void
"""
Key.__track()
Key.__is_muted = (not Key.__is_muted)
Keyboard.key(Keyboard.VK_VOLUME_MUTE)
def typeString(desString):
desString = desString.replace('type ', '')
numOfChars = len(desString)
for i in range(numOfChars):
keyCode = desString[i].upper()
if keyCode == ' ':
keyCode = 'SPACE'
keyCode = "VK_" + str(keyCode)
method_to_call = getattr(Keyboard, keyCode)
Keyboard.key(method_to_call, 0.2)
def on_focus(self, instance, value):
print('instance:', instance)
if value:
if instance == self.username:
self.u_kb = Keyboard("text", instance)
elif instance == self.password:
self.p_kb = Keyboard("text", instance)
else:
instance.release()
return False
class Channel(wx.Panel):
def __init__(self, parent, writer, doc, log, color=(0, 0, 0)):
wx.Panel.__init__(self, parent, style=wx.SUNKEN_BORDER)
self.writer = writer
self.color = color
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.SetSizer(self.sizer)
self.doc = doc
self.corpus = Corpus([doc])
self.log = log
self.active = False
context = self.log.GetValue().split()[-2:]
suggestions = self.corpus.suggest(context, 20)
self.keyboard = Keyboard(self, self.doc.name, suggestions, self.log)
self.sizer.Add(self.keyboard)
#self.sizer.Add(wx.StaticLine(self, -1, wx.Point(10, 30), wx.Size(200, 30)))
#self.inspector = Inspector(self, doc)
#self.inspector.SetBackgroundColour((150,150,150))
#self.sizer.Add(self.inspector)
def suggest(self):
context = self.log.GetValue().split()[-2:]
return self.corpus.suggest(context, 20)
def weighted_choice(self, choices):
total = sum(w for (c, w) in choices)
r = random.uniform(0, total)
upto = 0
for c, w in choices:
if upto + w >= r:
return c
upto += w
assert False, "Shouldn't get here"
def refresh(self):
context = self.log.before().split()[-2:]
suggestions = self.corpus.suggest(context, 20)
#print self.weighted_choice(suggestions)
self.keyboard.Hide()
self.keyboard = Keyboard(self, self.doc.name, suggestions, self.log)
if self.active:
self.keyboard.SetForegroundColour(self.color)
self.keyboard.header.SetForegroundColour(self.color)
#if sum(self.color) > 500:
# self.keyboard.header.SetForegroundColour("Black")
#else:
# self.keyboard.header.SetForegroundColour("White")
self.keyboard.Layout()
else:
#self.keyboard.SetForegroundColour((80,80,80))
self.keyboard.header.SetBackgroundColour((0, 0, 0))
self.sizer.Prepend(self.keyboard)
self.Layout()
def test_keyboard_dist(self):
inp_res_map = [(('t', 't'), (0)),
(('t', 'T'), (0.8)),
(('a', 'S'), (1.8)),
(('a', 'w'), (2)),
(('w', '$'), (3.8)),
(('<', '>'), (1))
]
kb = Keyboard('US')
for q, r in inp_res_map:
assert kb.keyboard_dist(*q) == r
def __init__(self):
super().__init__()
self.keyboard = Keyboard()
self.screen = Screen()
self.poller = Timer(-1)
self.poll_ref = self.poll
self.schedule_poll_ref = self.schedule_poll
self.screen_write_ref = self.screen.write
def __init__(self):
pygame.mixer.init(22050, -16, 2, 64)
pygame.init()
self.keyboard = Keyboard(VISABLE_FEEDBACK=Keyboard.VISABLE_NO,
WORD_CORRECTION=Keyboard.CORRECT_WORD)
self.frame_id = 0
self.save_folder = save_folder = 'data-baseline/' + sys.argv[1] + '/'
if not os.path.exists(save_folder):
os.makedirs(save_folder)
else:
print('\033[1;31;40m[Warning]\033[0m Folder exists')
def __init__(self, config, original_speed, fps, no_ui):
self.config = config
self.original_speed = original_speed
self.fps = fps
self.no_ui = no_ui
self.ram = RAM()
self.keyboard = Keyboard(self.ram)
self.z80 = Z80(self.ram)
self.cmd = CMD(self.ram)
self.entry_addr = self.cmd.load(config["cmd"])
self.ram.backup()
self.reset()
def __init__(self):
super(Window, self).__init__()
self.player1 = Keyboard()
self.player2 = Keyboard()
# self.x = 128*3
# self.y = 120*3
# self.dx = 1*3
# self.dy = 1*3
self.x = 128
self.y = 120
self.dx = 1
self.dy = 1
def main():
sio = serial.Serial('COM10', baudrate=9600)
kb = Keyboard(sio)
m = Mouse(sio)
while True:
m.click()
m.release()
kb.press(KEY_RETURN)
kb.release(KEY_RETURN)
kb.press(KEY_RETURN)
kb.release(KEY_RETURN)
time.sleep(0.8)
def test_key_press_insert_edits(self, inp, res):
inp_res_map = [(('{s}pa'.format(**key), [CAPS_KEY, SHIFT_KEY, 'a'], [CAPS_KEY, 't']),
('pA', 'Pa', 'aPa', 'pa', 'PA', 'tpa', # j=0
'pA', 'Pa', 'Apa', 'A', 'a', 'Ta', # j=1
'PA', 'PA', 'Paa', 'P', 'P', 'Pt', # j=2
'Paa'))
]
kb = Keyboard('US')
for inp, res in inp_res_map:
for i,r in enumerate(kb.key_press_insert_edits(*inp)):
print i,r,res[i]
assert r == res[i]
def test_keypress():
keyboard = Keyboard("NO")
keyboard.press_key("n")
assert len(keyboard.pressed_keys) == 1
assert keyboard.last_pressed() == "n"
assert keyboard.currently_pressed() == ["n"]
keyboard.release_key("n")
assert keyboard.currently_pressed() == []
assert len(keyboard.pressed_keys) == 0
def __init__(self, connector):
PyQGLViewer.QGLViewer.__init__(self)
self.U, self.V = np.meshgrid(np.arange(0, 640, SAMPLE_STRIDE),
np.arange(0, 480, SAMPLE_STRIDE))
self.points = np.zeros((3, 1))
self.connector = connector
self.keyboards = [Keyboard(Keyboard.TYPE_FORWARD, 4, 1, 1, 0.001, 0,"keyboard1.npy" , connector), \
Keyboard(Keyboard.TYPE_REVERSE, 4, 1, 1, 0.001, -8, "keyboard2.npy", connector), \
Keyboard(Keyboard.TYPE_SELECT, 1, 2, 2, 0.01, -16, "keyboard3.npy", connector),\
Keyboard(Keyboard.TYPE_DIRECTION_TOGGLE,1,2,2,0.01,8, "keyboard4.npy", connector) ]
self.num_keyboard = 4
self.keyboard = self.keyboards[0]
class Gui:
def __init__(self, navdb):
splash.show()
self.keyb = Keyboard() # processes input from keyboard & mouse
self.scr = Screen() # screen output object
def update(self, sim):
self.keyb.update(sim, sim.stack, self.scr, sim.traf) # Check for keys & mouse
self.scr.update(sim, sim.traf) # GUI update
def reset(self):
self.scr.objdel() # Delete user defined objects
def close(self):
pg.quit()
def main():
win = Window(fullscreen=True, visible=False)
camera = Camera(win.width, win.height, (0, 0), 100)
renderer = Renderer()
maze = Maze()
maze.create(50, 30, 300)
keyboard = Keyboard()
keyboard.key_handlers[key.ESCAPE] = win.close
keyboard.key_handlers.update(camera.key_handlers)
clock.schedule(maze.update)
win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
win.on_key_press = keyboard.on_key_press
keyboard.print_handlers()
win.set_visible()
app.run()
def __init__(self, **kwargs):
super(IcarusTouchWidget, self).__init__(**kwargs) # don't know if this is necessary?
# add background image (and add it in the BACKGROUND! --> index modification)
self.background = Background(source=self.app.config.get('Graphics', 'Background'))
self.float_layout.add_widget(self.background, index=len(self.float_layout.children))
# add feedback wall image
self.feedback_wall = Feedback(
source='images/feedbackwall.png',
transparency=0)
self.float_layout.add_widget(self.feedback_wall)
# add the keyboard itself
my_key_width = KEY_WIDTH
self.keyboard = Keyboard(
source=self.app.config.get('Graphics', 'Keyboard'),
pos=(-540, 230), # 366
size=(12*5*my_key_width, 468), # optimization for small screens (e.g. smartphones): 468 if self.get_parent_window().height > (468 + self.get_parent_window().height * 0.3) else self.get_parent_window().height * 0.7
border_width=BORDER_WIDTH,
key_width=my_key_width)
self.add_widget(self.keyboard)
# initialize the midi device
pygame.midi.init()
self.set_midi_device()
# initialize the settings_panel (I'm doing this here, otherwise opening it in real-time takes ages...)
self.my_settings_panel = MySettingsPanel()
def prepare(self):
"""
Prepare incoming request for handler
"""
self.keyboard = Keyboard()
logger.debug("KEYBOARD - Request\n%s", self.request.body)
super(KeyboardHandler, self).prepare()
def setup(self, terminals, payment):
self.terminals = terminals
self.payment = payment
self.ui.setTime.clicked.connect(self.set_time)
self.ui.showKeyboard.clicked.connect(lambda: Keyboard.show())
self.ui.setDBIP.clicked.connect(self.set_db_ip)
self.ui.testDisplay.clicked.connect(self.test_display)
def is_triggered(self, obj):
directions = []
for direction in obj.steering :
if(Keyboard.is_down(obj.steering[direction])) :
directions.append(direction)
if Direction.FORWARD in directions or Direction.BACKWARD in directions :
self.additionalInfo = directions
return True
return False
class ScoreBuilder(MidiOutStream):
def __init__(self):
MidiOutStream.__init__(self)
self._last_time = 0
self.keyboard = Keyboard()
self._last_status = None
self.score = []
def note_on(self, channel=0, note=0x40, velocity=0x40):
# print ("note_on: %s" % note)
self.keyboard.note_on(note)
def note_off(self, channel=0, note=0x40, velocity=0x40):
# print ("note_off: %s" % note)
self.keyboard.note_off(note)
def update_time(self, new_time=0, relative=1):
# print ("new_time: %s" % new_time)
MidiOutStream.update_time(self, new_time, relative)
if self._absolute_time != self._last_time:
diff = self._absolute_time - self._last_time
# print keyboard.format(self.keyboard.snapshot())
self.score.append(self.keyboard.snapshot())
self._last_status = [continued(x) for x in self.keyboard.snapshot()]
for tick in range((diff / eighth_note) - 1):
# print keyboard.format(self._last_status)
self.score.append(self._last_status)
self._last_time = self._absolute_time
def is_triggered(self, obj):
directions = []
for direction in obj.steering :
if(Keyboard.is_down(obj.steering[direction])) :
directions.append(direction)
finalDirection = self.map_directions(directions)
if finalDirection != None :
self.additionalInfo = finalDirection
return True
return False
def main():
app = QtGui.QApplication(sys.argv)
controller = Leap.Controller()
controller.set_policy_flags(Leap.Controller.POLICY_BACKGROUND_FRAMES)
kb = Keyboard()
#kb.pressKey((0.97, 0, 0.1))
kb.pressKey((0.03, 0, 0.1))
timer = QtCore.QTimer()
timer.start(33) # 30 cb per sec
timer.timeout.connect(functools.partial(timer_cb, kb))
listener = KeyListener(kb)
controller.add_listener(listener)
signal.signal(signal.SIGINT, functools.partial(sigint_handler, controller, listener, kb))
retcode = app.exec_()
controller.remove_listener(listener)
sys.exit(retcode)
def is_triggered(self, obj):
directions = []
for direction in obj.steering :
if(Keyboard.is_down(obj.steering[direction])) :
directions.append(direction)
if Direction.LEFT in directions or Direction.RIGHT in directions or\
(directions.__len__() == 0 and obj.previous_actions_empty()) or\
(directions.__len__() == 0 and obj.was_invoked_previously(BasicRotatingCharacter.ROTATE_STOP_ACTION)) :
self.additionalInfo = directions
return True
return False
class KeyboardHandler(JsonHandler):
"""
Handle requests
"""
def prepare(self):
"""
Prepare incoming request for handler
"""
self.keyboard = Keyboard()
logger.debug("KEYBOARD - Request\n%s", self.request.body)
super(KeyboardHandler, self).prepare()
@tornado.web.asynchronous
def post(self, *args, **kwargs):
# 1 - Find operation
try:
operation = self.json_data['operation']
name = self.json_data['name']
except Exception as e:
logger.debug("KEYBOARD VIEW - Error\n%s", e)
self.write_error(500, message=e)
self.finish()
# 2 - Execute operation
method = getattr(self, operation)
result = method(name)
def lock(self, name):
"""
Lock keyboard
"""
self.keyboard.lock(name)
self.response = {}
self.write_json()
self.finish()
def __init__(self, parent=None):
super(Widget, self).__init__(parent, Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowFlags(self.windowFlags() | Qt.Tool)
self.resize(300, 30)
self.cmd = []
self.lastCmd = ''
self.cmds = [
'!yx', '!quit', 'dt', 'dh', 'cmd', 'av', 'put',
'rm', 'mt', 'bs', 'ba', 'te',
]
self.cmds += [f.split('.')[0] for f in os.listdir(hotkeys)]
print 'cmds: '
print self.cmds
self.keyboard = Keyboard()
self.keyboard.on('ctrl ;', self.toggle_active)
self.keyboard.on('print', self.screenshot)
def is_triggered(self, obj):
directions = []
for direction in obj.steering :
if(Keyboard.is_down(obj.steering[direction])) :
directions.append(direction)
if directions.__len__() != 0 :
return False
if obj.previous_actions_empty() or not obj.was_invoked_previously(BasicMovingCharacter.STOP_ACTION):
self.additionalInfo = Side.FRONT
return True
else :
return False
return False
def start_game(self):
while 1 :
if self.toSetGameScreen != None :
self.currGameScreen = self.toSetGameScreen
self.toSetGameScreen = None
if self.currGameScreen == None :
raise Exception("currGameScreen for game is not set")
for event in pygame.event.get() :
if event.type == pygame.QUIT:
FileDirHelper.delete_dir(self.GAME_DIRECTORY + Default.TMP_FOLDER)
sys.exit()
Keyboard.get_pressed()
if Keyboard.is_down(pygame.K_LCTRL) and Keyboard.is_down(pygame.K_d) :
DebugHelper.run_debugger()
if Keyboard.is_down(pygame.K_LCTRL) and Keyboard.is_down(pygame.K_s) :
MainMenuHelper.save_game(self)
Keyboard.get_pressed()
for gameObject in self.currGameScreen.activeObjects.values() :
gameObject.analyze_state()
for gameObject in self.currGameScreen.activeObjects.values() :
gameObject.interpret_state()
self.currGameScreen.refreshScreen()
#obj1 = Game.currGameScreen.activeObjects[2]
#obj2 = Game.currGameScreen.activeObjects[4]
#DebugHelper.draw_borders(Game.currGameScreen.surface, obj1)
#DebugHelper.draw_borders(Game.currGameScreen.surface, obj2)
def __init__(self, display=None, desktops=None, loop=None):
self.log = Log("WM")
# INIT SOME BASIC STUFF
self.hook = Hook()
self.windows = {} # mapping between window id and Window
self.win2desk = {}
if not display:
display = os.environ.get("DISPLAY")
try:
self._conn = xcffib.connect(display=display)
except xcffib.ConnectionException:
sys.exit("cannot connect to %s" % display)
self.atoms = AtomVault(self._conn)
self.desktops = desktops or [Desktop()]
self.cur_desktop = self.desktops[0]
self.cur_desktop.show()
# CREATE ROOT WINDOW
xcb_setup = self._conn.get_setup()
xcb_screens = [i for i in xcb_setup.roots]
self.xcb_default_screen = xcb_screens[self._conn.pref_screen]
root_wid = self.xcb_default_screen.root
self.root = Window(self, wid=root_wid, atoms=self.atoms, mapped=True)
self.windows[root_wid] = self.root
# for desktop in self.desktops:
# desktop.windows.append(self.root)
self.root.set_attr(
eventmask=(
EventMask.StructureNotify
| EventMask.SubstructureNotify
| EventMask.FocusChange
# | EventMask.SubstructureRedirect
| EventMask.EnterWindow
# | EventMask.LeaveWindow
# | EventMask.PropertyChange
| EventMask.OwnerGrabButton
)
)
# INFORM X WHICH FEATURES WE SUPPORT
self.root.props[self.atoms._NET_SUPPORTED] = [self.atoms[a] for a in SUPPORTED_ATOMS]
# PRETEND TO BE A WINDOW MANAGER
supporting_wm_check_window = self.create_window(-1, -1, 1, 1)
supporting_wm_check_window.props['_NET_WM_NAME'] = "SWM"
self.root.props['_NET_SUPPORTING_WM_CHECK'] = supporting_wm_check_window.wid
self.root.props['_NET_NUMBER_OF_DESKTOPS'] = len(self.desktops)
self.root.props['_NET_CURRENT_DESKTOP'] = 0
# TODO: set cursor
# EVENTS THAT HAVE LITTLE USE FOR US...
self.ignoreEvents = {
"KeyRelease",
"ReparentNotify",
# "CreateNotify",
# DWM handles this to help "broken focusing windows".
# "MapNotify",
"ConfigureNotify",
"LeaveNotify",
"FocusOut",
"FocusIn",
"NoExposure",
}
# KEYBOARD
self.kbd = Keyboard(xcb_setup, self._conn)
self.mouse = Mouse(conn=self._conn, root=self.root)
# FLUSH XCB BUFFER
self.xsync() # apply settings
# the event loop is not yet there, but we might have some pending
# events...
self._xpoll()
# TODO: self.grabMouse
# NOW IT'S TIME TO GET PHYSICAL SCREEN CONFIGURATION
self.xrandr = Xrandr(root=self.root, conn=self._conn)
# TODO: self.update_net_desktops()
# SETUP EVENT LOOP
if not loop:
loop = asyncio.new_event_loop()
self._eventloop = loop
self._eventloop.add_signal_handler(signal.SIGINT, self.stop)
self._eventloop.add_signal_handler(signal.SIGTERM, self.stop)
self._eventloop.add_signal_handler(signal.SIGCHLD, self.on_sigchld)
self._eventloop.set_exception_handler(
lambda loop, ctx: self.log.error(
"Got an exception in {}: {}".format(loop, ctx))
)
fd = self._conn.get_file_descriptor()
self._eventloop.add_reader(fd, self._xpoll)
# HANDLE STANDARD EVENTS
self.hook.register("MapRequest", self.on_map_request)
self.hook.register("MapNotify", self.on_map_notify)
self.hook.register("UnmapNotify", self.on_window_unmap)
self.hook.register("KeyPress", self.on_key_press)
# self.hook.register("KeyRelease", self.on_key_release)
# self.hook.register("CreateNotify", self.on_window_create)
self.hook.register("PropertyNotify", self.on_property_notify)
self.hook.register("ClientMessage", self.on_client_message)
self.hook.register("DestroyNotify", self.on_window_destroy)
self.hook.register("EnterNotify", self.on_window_enter)
self.hook.register("ConfigureRequest", self.on_configure_window)
self.hook.register("MotionNotify", self.on_mouse_event)
self.hook.register("ButtonPress", self.on_mouse_event)
self.hook.register("ButtonRelease", self.on_mouse_event)
class WM:
"""
Provides basic building blocks to make a window manager.
It hides many dirty details about XCB. It was intended
to provide minimum functionality, the rest supposed to
be implemented by user in configuration file.
"""
root = None # type: Window
atoms = None # type: AtomVault
def __init__(self, display=None, desktops=None, loop=None):
self.log = Log("WM")
# INIT SOME BASIC STUFF
self.hook = Hook()
self.windows = {} # mapping between window id and Window
self.win2desk = {}
if not display:
display = os.environ.get("DISPLAY")
try:
self._conn = xcffib.connect(display=display)
except xcffib.ConnectionException:
sys.exit("cannot connect to %s" % display)
self.atoms = AtomVault(self._conn)
self.desktops = desktops or [Desktop()]
self.cur_desktop = self.desktops[0]
self.cur_desktop.show()
# CREATE ROOT WINDOW
xcb_setup = self._conn.get_setup()
xcb_screens = [i for i in xcb_setup.roots]
self.xcb_default_screen = xcb_screens[self._conn.pref_screen]
root_wid = self.xcb_default_screen.root
self.root = Window(self, wid=root_wid, atoms=self.atoms, mapped=True)
self.windows[root_wid] = self.root
# for desktop in self.desktops:
# desktop.windows.append(self.root)
self.root.set_attr(
eventmask=(
EventMask.StructureNotify
| EventMask.SubstructureNotify
| EventMask.FocusChange
# | EventMask.SubstructureRedirect
| EventMask.EnterWindow
# | EventMask.LeaveWindow
# | EventMask.PropertyChange
| EventMask.OwnerGrabButton
)
)
# INFORM X WHICH FEATURES WE SUPPORT
self.root.props[self.atoms._NET_SUPPORTED] = [self.atoms[a] for a in SUPPORTED_ATOMS]
# PRETEND TO BE A WINDOW MANAGER
supporting_wm_check_window = self.create_window(-1, -1, 1, 1)
supporting_wm_check_window.props['_NET_WM_NAME'] = "SWM"
self.root.props['_NET_SUPPORTING_WM_CHECK'] = supporting_wm_check_window.wid
self.root.props['_NET_NUMBER_OF_DESKTOPS'] = len(self.desktops)
self.root.props['_NET_CURRENT_DESKTOP'] = 0
# TODO: set cursor
# EVENTS THAT HAVE LITTLE USE FOR US...
self.ignoreEvents = {
"KeyRelease",
"ReparentNotify",
# "CreateNotify",
# DWM handles this to help "broken focusing windows".
# "MapNotify",
"ConfigureNotify",
"LeaveNotify",
"FocusOut",
"FocusIn",
"NoExposure",
}
# KEYBOARD
self.kbd = Keyboard(xcb_setup, self._conn)
self.mouse = Mouse(conn=self._conn, root=self.root)
# FLUSH XCB BUFFER
self.xsync() # apply settings
# the event loop is not yet there, but we might have some pending
# events...
self._xpoll()
# TODO: self.grabMouse
# NOW IT'S TIME TO GET PHYSICAL SCREEN CONFIGURATION
self.xrandr = Xrandr(root=self.root, conn=self._conn)
# TODO: self.update_net_desktops()
# SETUP EVENT LOOP
if not loop:
loop = asyncio.new_event_loop()
self._eventloop = loop
self._eventloop.add_signal_handler(signal.SIGINT, self.stop)
self._eventloop.add_signal_handler(signal.SIGTERM, self.stop)
self._eventloop.add_signal_handler(signal.SIGCHLD, self.on_sigchld)
self._eventloop.set_exception_handler(
lambda loop, ctx: self.log.error(
"Got an exception in {}: {}".format(loop, ctx))
)
fd = self._conn.get_file_descriptor()
self._eventloop.add_reader(fd, self._xpoll)
# HANDLE STANDARD EVENTS
self.hook.register("MapRequest", self.on_map_request)
self.hook.register("MapNotify", self.on_map_notify)
self.hook.register("UnmapNotify", self.on_window_unmap)
self.hook.register("KeyPress", self.on_key_press)
# self.hook.register("KeyRelease", self.on_key_release)
# self.hook.register("CreateNotify", self.on_window_create)
self.hook.register("PropertyNotify", self.on_property_notify)
self.hook.register("ClientMessage", self.on_client_message)
self.hook.register("DestroyNotify", self.on_window_destroy)
self.hook.register("EnterNotify", self.on_window_enter)
self.hook.register("ConfigureRequest", self.on_configure_window)
self.hook.register("MotionNotify", self.on_mouse_event)
self.hook.register("ButtonPress", self.on_mouse_event)
self.hook.register("ButtonRelease", self.on_mouse_event)
def on_property_notify(self, evname, xcb_event):
# TODO: messy ugly code
wid = xcb_event.window
atom = self.atoms.get_name(xcb_event.atom)
# window = self.windows.get(wid, Window(wm=self, wid=wid, mapped=True))
self.log.error("PropertyNotify: %s" % atom)
run_("xprop -id %s %s" % (wid, atom))
# TODO: dirty code, relocate to config
def on_client_message(self, evname, xcb_event):
self.log.error(dir(xcb_event))
data = xcb_event.data
resp_type = self.atoms.get_name(xcb_event.response_type)
type = self.atoms.get_name(xcb_event.type)
wid = xcb_event.window
self.log.error("client message: resp_type={resp_type} window={wid} type={type} data={data}" \
.format(**locals()))
# 'bufsize', 'data', 'format', 'pack', 'response_type', 'sequence', 'synthetic', 'type', 'window']
if type == '_NET_ACTIVE_WINDOW':
window = self.windows[wid]
window.rise()
self.focus_on(window)
def on_sigchld(self):
""" Rip orphans. """
while True:
try:
pid, status = os.waitpid(-1, os.WNOHANG)
if (pid, status) == (0, 0):
# no child to rip
break
self.log.notice("ripped child PID=%s" % pid)
except ChildProcessError:
break
def on_map_request(self, evname, xcb_event):
""" Map request is a request to draw the window on screen. """
wid = xcb_event.window
if wid not in self.windows:
window = self.on_new_window(wid)
else:
window = self.windows[wid]
self.log.on_map_request.debug("map request for %s" % window)
window.show()
if window.above_all:
window.rise()
if window.can_focus:
window.focus()
def on_new_window(self, wid):
""" Registers new window. """
window = Window(wm=self, wid=wid, atoms=self.atoms, mapped=True)
# call configuration hood first
# to setup attributes like 'sticky'
self.hook.fire("new_window", window)
self.log.on_new_window.debug(
"new window is ready: %s" % window)
self.windows[wid] = window
self.win2desk[window] = self.cur_desktop
if window.sticky:
for desktop in self.desktops:
desktop.add(window)
else:
self.cur_desktop.windows.append(window)
return window
def on_map_notify(self, evname, xcb_event):
wid = xcb_event.window
if wid not in self.windows:
window = self.on_new_window(wid)
else:
window = self.windows[wid]
window.mapped = True
if window.above_all:
window.rise()
# if window.can_focus:
# window.focus()
self.log.on_map_notify.debug("map notify for %s" % window)
def on_window_unmap(self, evname, xcb_event):
wid = xcb_event.window
if wid not in self.windows:
return
window = self.windows[wid]
window.mapped = False
self.hook.fire("window_unmap", window)
def on_window_destroy(self, evname, xcb_event):
wid = xcb_event.window
if wid not in self.windows:
return
window = self.windows[wid]
assert isinstance(window, Window), "it's not a window: %s (%s)" % (
window, type(window))
for desktop in self.desktops:
try:
desktop.windows.remove(window)
self.log.debug("%s removed from %s" % (self, desktop))
except ValueError:
pass
del self.windows[wid]
if window in self.win2desk:
del self.win2desk[window]
def on_window_enter(self, evname, xcb_event):
wid = xcb_event.event
if wid not in self.windows:
# self.log.on_window_enter.error("no window with wid=%s" % wid)
self.hook.fire("unknown_window", wid)
return
window = self.windows[wid]
# self.log.on_window_enter("window_enter: %s %s" % (wid, window))
self.hook.fire("window_enter", window)
def grab_key(self, modifiers, key, owner_events=False, window=None):
""" Intercept this key when it is pressed. If owner_events=False then
the window in focus will not receive it. This is useful from WM hotkeys.
"""
# TODO: check if key already grabbed?
# Here is how X works with keys:
# key => keysym => keycode
# where `key' is something like 'a', 'b' or 'Enter',
# `keysum' is what should be written on they key cap (physical keyboard)
# and `keycode' is a number reported by the keyboard when the key is pressed.
# Modifiers are keys like Shift, Alt, Win and some other buttons.
self.log.grab_key.debug("intercept keys: %s %s" % (modifiers, key))
if window is None:
window = self.root
keycode = self.kbd.key_to_code(key)
modmask = get_modmask(modifiers) # TODO: move to Keyboard
event = ("on_key_press", modmask, keycode)
pointer_mode = xproto.GrabMode.Async
keyboard_mode = xproto.GrabMode.Async
self._conn.core.GrabKey(
owner_events,
window.wid,
modmask,
keycode,
pointer_mode,
keyboard_mode
)
self.flush() # TODO: do we need this?
return event
def on_key_press(self, evname, xcb_event):
# TODO: ignore capslock, scrolllock and other modifiers?
modmap = xcb_event.state
keycode = xcb_event.detail
event = ("on_key_press", modmap, keycode)
self.hook.fire(event)
def on_key_release(self, evname, xcb_event):
modmap = xcb_event.state
keycode = xcb_event.detail
event = ("on_key_release", modmap, keycode)
self.hook.fire(event)
def grab_mouse(self, modifiers, button, owner_events=False, window=None):
# http://www.x.org/archive/X11R7.7/doc/man/man3/xcb_grab_button.3.xhtml
wid = (window or self.root).wid
event_mask = xcffib.xproto.EventMask.ButtonPress | \
xcffib.xproto.EventMask.ButtonRelease | \
xcffib.xproto.EventMask.Button1Motion
modmask = get_modmask(modifiers)
pointer_mode = xproto.GrabMode.Async # I don't know what it is
keyboard_mode = xproto.GrabMode.Async # do not block other keyboard events
confine_to = xcffib.xproto.Atom._None # do not restrict cursor movements
cursor = xcffib.xproto.Atom._None # do not change cursor
event = ("on_mouse", modmask, button) # event to be used in hooks
self._conn.core.GrabButton(
owner_events,
wid,
event_mask,
pointer_mode,
keyboard_mode,
confine_to,
cursor,
button,
modmask,
)
self.flush() # TODO: do we need this?
return event
def hotkey(self, keys, cmd):
""" Setup hook to launch a command on specific hotkeys. """
@self.hook(self.grab_key(*keys))
def cb(event):
run_(cmd)
def focus_on(self, window, warp=False):
""" Focuses on given window. """
self.cur_desktop.focus_on(window, warp)
self.root.set_prop('_NET_ACTIVE_WINDOW', window.wid)
def switch_to(self, desktop: Desktop):
""" Switches to another desktop. """
if isinstance(desktop, int):
desktop = self.desktops[desktop]
if self.cur_desktop == desktop:
self.log.notice("attempt to switch to the same desktop")
return
self.log.debug("switching from {} to {}".format(
self.cur_desktop, desktop))
self.cur_desktop.hide()
self.cur_desktop = desktop
self.cur_desktop.show()
# TODO: move this code to Desktop.show()
self.root.props[self.atom._NET_CURRENT_DESKTOP] = desktop.id
def relocate_to(self, window: Window, to_desktop: Desktop):
""" Relocates window to a specific desktop. """
if window.sticky:
self.log.debug(
"%s is meant to be on all desktops, cannot relocate to specific one" % window)
return
from_desktop = self.cur_desktop
if from_desktop == to_desktop:
self.log.debug(
"no need to relocate %s because remains on the same desktop" % window)
return
from_desktop.remove(window)
to_desktop.add(window)
def on_mouse_event(self, evname, xcb_event):
"""evname is one of ButtonPress, ButtonRelease or MotionNotify."""
# l = [(attr, getattr(xcb_event, attr)) for attr in sorted(dir(xcb_event)) if not attr.startswith('_')]
# print(evname)
# print(l)
modmask = xcb_event.state & 0xff # TODO: is the mask correct?
if evname == 'MotionNotify':
button = 1 # TODO
else:
button = xcb_event.detail
event = ('on_mouse', modmask, button)
# print(event)
self.hook.fire(event, evname, xcb_event)
def on_configure_window(self, _, event):
# This code is so trivial that I just took it from fpwm as is :)
values = []
if event.value_mask & ConfigWindow.X:
values.append(event.x)
if event.value_mask & ConfigWindow.Y:
values.append(event.y)
if event.value_mask & ConfigWindow.Width:
values.append(event.width)
if event.value_mask & ConfigWindow.Height:
values.append(event.height)
if event.value_mask & ConfigWindow.BorderWidth:
values.append(event.border_width)
if event.value_mask & ConfigWindow.Sibling:
values.append(event.sibling)
if event.value_mask & ConfigWindow.StackMode:
values.append(event.stack_mode)
self._conn.core.ConfigureWindow(event.window, event.value_mask, values)
def create_window(self, x, y, width, height):
""" Create a window. Right now only used for initialization, see __init__. """
wid = self._conn.generate_id()
self._conn.core.CreateWindow(
self.xcb_default_screen.root_depth,
wid,
self.xcb_default_screen.root,
x, y, width, height, 0,
WindowClass.InputOutput,
self.xcb_default_screen.root_visual,
CW.BackPixel | CW.EventMask,
[
self.xcb_default_screen.black_pixel,
EventMask.StructureNotify | EventMask.Exposure
]
)
return Window(self, wid=wid, atoms=self.atoms)
def scan(self, focus=True):
""" Gets all windows in the system. """
self.log.debug("performing scan of all mapped windows")
q = self._conn.core.QueryTree(self.root.wid).reply()
for wid in q.children:
# attrs=self._conn.core.GetWindowAttributes(wid).reply()
# print(attrs, type(attrs))
# if attrs.map_state == xproto.MapState.Unmapped:
# self.log.scan.debug(
# "window %s is not mapped, skipping" % wid) # TODO
# continue
if wid not in self.windows:
self.on_new_window(wid)
self.log.scan.info("the following windows are active: %s" %
sorted(self.windows.values()))
if focus:
windows = sorted(self.windows.values())
windows = list(filter(lambda w: w != self.root and not w.skip, windows))
if windows:
# on empty desktop there is nothing to focus on
self.cur_desktop.focus_on(windows[-1], warp=True)
def finalize(self):
""" This code is run when event loop is terminated. """
pass # currently nothing to do here
def flush(self):
""" Force pending X request to be sent.
By default XCB aggressevly buffers for performance reasons. """
return self._conn.flush()
def xsync(self):
""" Flush XCB queue and wait till it is processed by X server. """
# The idea here is that pushing an innocuous request through the queue
# and waiting for a response "syncs" the connection, since requests are
# serviced in order.
self._conn.core.GetInputFocus().reply()
def stop(self, xserver_dead=False):
""" Stop WM to quit. """
self.hook.fire("on_exit")
# display all hidden windows
try:
if not xserver_dead:
for window in self.windows.values():
window.show()
self.xsync()
except Exception as err:
self.log.stop.error("error on stop: %s" % err)
self.log.stop.debug("stopping event loop")
self._eventloop.stop()
def replace(self, execv_args):
self.log.notice("replacing current process with %s" % (execv_args,))
self.stop()
import os
os.execv(*execv_args)
def loop(self):
""" DITTO """
self.scan()
try:
self._eventloop.run_forever()
finally:
self.finalize()
def _xpoll(self):
""" Fetch incomming events (if any) and call hooks. """
# OK, kids, today I'll teach you how to write reliable enterprise
# software! You just catch all the exceptions in the top-level loop
# and ignore them. No, I'm kidding, these exceptions are no use
# for us because we don't care if a window cannot be drawn or something.
# We actually only need to handle just a few events and ignore the rest.
# Exceptions happen because of the async nature of X.
while True:
try:
xcb_event = self._conn.poll_for_event()
if not xcb_event:
break
evname = xcb_event.__class__.__name__
if evname.endswith("Event"):
evname = evname[:-5]
if evname in self.ignoreEvents:
self.log._xpoll.info("ignoring %s" % xcb_event)
continue
self.log._xpoll.critical("got %s %s" % (evname, xcb_event))
self.hook.fire(evname, xcb_event)
self.flush() # xcb doesn't flush implicitly
except (WindowError, AccessError, DrawableError):
self.log.debug("(minor exception)")
except Exception as e:
self.log._xpoll.error(traceback.format_exc())
error_code = self._conn.has_error()
if error_code:
error_string = XCB_CONN_ERRORS[error_code]
self.log.critical("Shutting down due to X connection error %s (%s)" %
(error_string, error_code))
self.stop(xserver_dead=True)
break
