def main(self, view, model):
km = KeyMap()
ac = ActionContext(km, model, self.__stdscr)
while model.checkProgramExecution():
view.update(self.__stdscr)
c = self.__stdscr.getch()
model.echoCommand(str(c))
km.addCommand(ch(c))
demands = km.translate()
ac.do(demands)
class EventHandler(object):
# class list of active handlers - they will be called. Any object here can add another
# object here. So the menu will add or remove the world as it sees fit, and the world will
# remove itself when the game is done
active_handlers = set()
def __init__(self):
self._keymap = KeyMap() # personal keymap
def on_key_down(self, key, mod):
self._keymap.onkey(key, mod)
def on_mouse_down(self):
"""mouse down - reimplement me """
def __init__(self):
threading.Thread.__init__(self)
self.devices = get_devices()
self.keyfile = ".keymap" # Arquivo padrão para o mapa de caracteres
self.keymap = KeyMap(self.devices)
self.listener = Listener(self.devices)
self.history = History()
self.lock = False
self.listen()
self.copy = False
def test_keymap_reverse():
keymap = KeyMap(z_note=48)
for key in KeyMap.KEYBOARD_PRIMARY:
note = keymap.get_note(key)
assert keymap.get_key(note) == key, (key, note)
for key in KeyMap.KEYBOARD_SECONDARY:
note = keymap.get_note(key)
if note is None:
continue
assert keymap.get_key(note) == key, (key, note)
def __init__(
self,
*,
z_note: int,
mode: str,
script: str,
bpm: float,
delay: float,
repeat: bool,
):
super().__init__()
self.midi_config = MidiConfig(velocity=127, )
self.keymap = KeyMap(z_note)
self.keyboard_player: KeyboardPlayer = None
self.mode = mode
assert mode in self.MODES
if mode == self.MODE_AUTO and script is None:
raise ValueError
if script is None:
self.script = None
else:
self.script = Script(script)
self._script_player_params = {
'bpm': bpm,
'delay': delay,
'repeat': repeat,
}
self.script_player: ScriptPlayer = None
self.bg_color = (0, 0, 0) # black
self.font_color = (255, 255, 255) # white
self._script_renderer_params = {
'font_size': 96,
'font_color': self.font_color,
'lead': 2,
'pps': 300,
}
self.script_renderer: ScriptRenderer = None
def setUp(self):
self.model = Model()
self.km = KeyMap()
self.ac = ActionContext(self.km, self.model, None)
class TestSequenceFunctions(unittest.TestCase):
def setUp(self):
self.model = Model()
self.km = KeyMap()
self.ac = ActionContext(self.km, self.model, None)
def test_keymap_sequence(self):
self.km.addCommand('j')
demands = self.km.translate()
self.assertTrue(demands == 'cursor_down')
def test_down(self):
self.km.addCommand('j')
demands = self.km.translate()
self.ac.do(demands)
(x, y) = self.model.getCursor().getCursor()
self.assertTrue(x == 0 and y == 1)
def test_left(self):
self.km.addCommand('l')
demands = self.km.translate()
self.ac.do(demands)
(x, y) = self.model.getCursor().getCursor()
self.assertTrue(x == 1 and y == 0)
def test_looparound(self):
self.km.addCommand('j')
demands = self.km.translate()
self.ac.do(demands)
self.km.addCommand('l')
demands = self.km.translate()
self.ac.do(demands)
self.km.addCommand('k')
demands = self.km.translate()
self.ac.do(demands)
self.km.addCommand('h')
demands = self.km.translate()
self.ac.do(demands)
(x, y) = self.model.getCursor().getCursor()
self.assertTrue(x == 0 and y == 0)
def test_insert(self):
sample_text = "This is sample text"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getRawContent() == sample_text)
def test_discernText(self):
sample_text = "This is sample text"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getType() == "Text")
def test_discernNumeric(self):
sample_text = "3.14159"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getType() == "Numeric")
def test_discernFormula(self):
sample_text = "=sum(A1:A10)"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getType() == "Formula")
curses.start_color() # enable color support
curses.noecho() # don't display pressed KEYS
curses.cbreak() # don't wait for a newline to process input
STDSCR.keypad(1) # enable keypad mode (process special KEYS, like Home)
curses.curs_set(0) # make the cursor invisible
curses.halfdelay(5) # wait only half a second between each getch
# Overload colors to make blocks
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_WHITE)
curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_GREEN)
curses.init_pair(3, curses.COLOR_BLUE, curses.COLOR_BLUE)
curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_YELLOW)
curses.init_pair(5, curses.COLOR_RED, curses.COLOR_RED)
try:
KEYS = KeyMap()
KEYS.load_from_file(CONFIG_FNAME)
GAME_BOARD = Board(STDSCR, [0, 0], [20, 20])
SCORE_BOARD = ScoreBoard(GAME_BOARD.status, 5, 25)
GAME_QUIT = False
LAST_GAME_STEP = time()
while not GAME_QUIT and not GAME_BOARD.game_over():
CURRENT_TIME = time()
if CURRENT_TIME - LAST_GAME_STEP > STEP_TIME:
GAME_BOARD.advance_block()
LAST_GAME_STEP = CURRENT_TIME
USR_INPUT = STDSCR.getch()
if USR_INPUT == KEYS.quit:
def setUp(self):
self.model = Model()
self.km = KeyMap()
self.ac = ActionContext(self.km, self.model, None)
class TestSequenceFunctions(unittest.TestCase):
def setUp(self):
self.model = Model()
self.km = KeyMap()
self.ac = ActionContext(self.km, self.model, None)
def test_keymap_sequence(self):
self.km.addCommand('j')
demands = self.km.translate()
self.assertTrue(demands == 'cursor_down')
def test_down(self):
self.km.addCommand('j')
demands = self.km.translate()
self.ac.do(demands)
(x, y) = self.model.getCursor().getCursor()
self.assertTrue(x == 0 and y == 1)
def test_left(self):
self.km.addCommand('l')
demands = self.km.translate()
self.ac.do(demands)
(x, y) = self.model.getCursor().getCursor()
self.assertTrue(x == 1 and y == 0)
def test_looparound(self):
self.km.addCommand('j')
demands = self.km.translate()
self.ac.do(demands)
self.km.addCommand('l')
demands = self.km.translate()
self.ac.do(demands)
self.km.addCommand('k')
demands = self.km.translate()
self.ac.do(demands)
self.km.addCommand('h')
demands = self.km.translate()
self.ac.do(demands)
(x, y) = self.model.getCursor().getCursor()
self.assertTrue(x == 0 and y == 0)
def test_insert(self):
sample_text = "This is sample text"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getRawContent() == sample_text)
def test_discernText(self):
sample_text = "This is sample text"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getType() == "Text")
def test_discernNumeric(self):
sample_text = "3.14159"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getType() == "Numeric")
def test_discernFormula(self):
sample_text = "=sum(A1:A10)"
sheet = self.model.getSheet()
cursor = self.model.getCursor()
cursor.setCellAtCursor(sheet, sample_text)
cell = cursor.getCell(sheet)
self.assertTrue(cell.getType() == "Formula")
class KMLoger(threading.Thread):
""" Classe principal """
def __init__(self):
threading.Thread.__init__(self)
self.devices = get_devices()
self.keyfile = ".keymap" # Arquivo padrão para o mapa de caracteres
self.keymap = KeyMap(self.devices)
self.listener = Listener(self.devices)
self.history = History()
self.lock = False
self.listen()
self.copy = False
def record(self):
if self.copy:
self.copy = False
print("\rComandos gravados" + " "*80)
self.listener.del_key_sniffer("rec")
# self.listener.del_mouse_sniffer("mouse")
else:
self.copy = True
print("\rIniciando gravação" + " "*80)
self.history.reset()
self.listener.add_key_sniffer("rec", [self.keymap.get_key_by_func("rec")], self.history.append_event)
# self.listener.add_mouse_sniffer("mouse", self.history.append_event)
def pprint(self, *args):
if not self.copy:
print(args)
def listen(self):
""" Inicializando todas as fun """
self.listener.add_listener("redefine", ecodes.EV_KEY, self.keymap.get_key_by_func("redefine"), self.change_keys)
self.listener.add_listener("quit", ecodes.EV_KEY, self.keymap.get_key_by_func("quit"), self.exit)
self.listener.add_listener("copy", ecodes.EV_KEY, self.keymap.get_key_by_func("rec"), self.record)
self.listener.add_listener("run", ecodes.EV_KEY, self.keymap.get_key_by_func("run"), self.play)
# self.listener.add_listener("save", ecodes.EV_KEY, self.keymap.get_key_by_func("save"), self.history.save)
# self.listener.add_listener("load", ecodes.EV_KEY, self.keymap.get_key_by_func("load"), self.history.load)
# self.listener.add_listener("pause", ecodes.EV_KEY, self.keymap.get_key_by_func("pause"), self.history.sleep)
# self.listener.add_listener("stop", ecodes.EV_KEY, self.keymap.get_key_by_func("stop"), self.history.stop)
# self.listener.add_listener("run_forever", ecodes.EV_KEY, self.keymap.get_key_by_func("run_forever"), self.play_forever)
# self.listener.add_key_sniffer("rec", [self.keymap.get_key_by_func("rec")], self.history.append_event)
# self.listener.add_listener("copy", ecodes.EV_KEY, self.keymap.get_key_by_func("rec"), pprint, "record")
self.listener.add_listener("save", ecodes.EV_KEY, self.keymap.get_key_by_func("save"), self.pprint, "save")
self.listener.add_listener("load", ecodes.EV_KEY, self.keymap.get_key_by_func("load"), self.pprint, "load")
self.listener.add_listener("pause", ecodes.EV_KEY, self.keymap.get_key_by_func("pause"), self.pprint, "sleep")
self.listener.add_listener("stop", ecodes.EV_KEY, self.keymap.get_key_by_func("stop"), self.pprint, "stop")
# self.listener.add_listener("run", ecodes.EV_KEY, self.keymap.get_key_by_func("run"), self.pprint, "play")
self.listener.add_listener("run_forever", ecodes.EV_KEY, self.keymap.get_key_by_func("run_forever"), self.pprint, "play_forever")
def play(self):
if not self.copy:
print("\rplay" + " "*80)
self.history.set_n(1)
self.history.play()
def play_forever(self):
if not self.copy:
self.history.set_n(0)
self.history.play()
def run(self):
self.history.start()
self.listener.run()
self.history.join()
def save_key_map(self):
""" Salva o mapa de caracteres no arquivo padrão. """
pickle.dump( self.keymap, open(self.keyfile, 'wb'), -1)
def exit(self):
if not self.copy:
self.history.exit()
self.listener.exit()
flush_input()
print("\nBye!")
def load_key_map(self):
""" Carrega o mapa de caracteres do arquivo padrão. """
try:
self.keymap = pickle.load(open(self.keyfile, 'rb'))
except IOError:
self.save_key_map()
self.listen()
def change_keys(self):
if not self.copy:
self.keymap.setup()
print("\rNovo mapa de teclas salvo.")
self.save_key_map()
print("\rPrograma precisa ser reiniciado")
self.exit()
def print_keys(self):
self.keymap.print_keymap()
def __init__(self):
self._keymap = KeyMap() # personal keymap
