def translate_img(self, img_path=None):
if img_path is None:
# 读取剪切板
file_path, is_tempfile = Clipboard.paste()
else:
file_path = img_path
is_tempfile = False
if file_path and os.path.isfile(file_path):
# print(file_path)
resource_url = self.__upload_file(file_path)
if resource_url is None:
return None
print(resource_url)
url = self.__translate_url(resource_url)
Clipboard.copy(url) # 写入剪切板
print(url)
if is_tempfile:
os.remove(file_path)
return url
else:
return None
def __init__(self):
"""
Initialises all the components in the user interface.
"""
self.root = tk.Tk()
self.colour_box = tk.Label(self.root)
self.hex_frame = tk.LabelFrame(self.root, text="Hex")
self.hex_label = tk.Label(self.hex_frame, text="Hex: #")
self.hex_input = tk.Entry(self.hex_frame)
self.hex_input.bind("<KeyRelease>", self.update_hex)
self.rgb_frame = tk.LabelFrame(self.root, text="RGB")
self.red_label = tk.Label(self.rgb_frame, text="Red:")
self.red_input = tk.Entry(self.rgb_frame)
self.red_input.bind("<KeyRelease>", self.update_rgb)
self.green_label = tk.Label(self.rgb_frame, text="Green:")
self.green_input = tk.Entry(self.rgb_frame)
self.green_input.bind("<KeyRelease>", self.update_rgb)
self.blue_label = tk.Label(self.rgb_frame, text="Blue:")
self.blue_input = tk.Entry(self.rgb_frame)
self.blue_input.bind("<KeyRelease>", self.update_rgb)
self.clipboard_image = ImageTk.PhotoImage(
Image.open("./clipboard.png").resize((30, 30)), Image.ANTIALIAS)
self.input_boxes = {
"red": self.red_input,
"green": self.green_input,
"blue": self.blue_input,
"hex": self.hex_input
}
self.hex_clipboard_button = tk.Button(
self.hex_frame,
image=self.clipboard_image,
command=lambda: Clipboard().copy_to_clipboard(
self.root, self.input_boxes, "hex"))
self.rgb_clipboard_button = tk.Button(
self.rgb_frame,
image=self.clipboard_image,
command=lambda: Clipboard().copy_to_clipboard(
self.root, self.input_boxes, "rgb"))
self.colours = {
"invalid input": "#FF726F",
"default background": "#1D1D1D",
"secondary": "#FFFFFF",
"colour box": "#FF0000"
}
self.default_font_size = 14
def __init__(self, config, args):
self.config = config
self.ndb = args['ndb']
self.key = args['key']
self.log = args['log']
self.search_string = ''
self.search_mode = 'gstyle'
self.search_direction = ''
self.note = self.ndb.get_note(self.key) if self.key else None
self.old_note = None
self.tabstop = int(self.config.get_config('tabstop'))
self.clipboard = Clipboard()
super(ViewNote, self).__init__(
urwid.SimpleFocusListWalker(self.get_note_content_as_list()))
def __init__(self, parent = None):
QObject.__init__(self, parent = parent)
# フックマネージャーを生成
self.hook_manager = pyHook.HookManager()
# KeyDown, KeyUpで呼ばれる関数を設定
self.hook_manager.KeyDown = self.on_keyboard_event
self.hook_manager.KeyUp= self.on_keyboard_event
self.modifiers_key_state = ModifiersKeyState()
self.timer = QTimer(self)
self.timer.setInterval(800)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.on_timeout)
self.timer_running = False
self.window_dict = dict()
self.candidates = deque()
self.key_sequences = deque()
self.window_id = None
self.clipboard = Clipboard()
self.current_node = None
self.root_node = KeyDictNode(dict())
for mode in Mode:
self.root_node.set_key_dictionary(mode)
for shortcuts_info in shortcuts_tuple:
shortcuts_info.set_mode_shortcuts(self.root_node)
self.current_exe_name = ""
self._mode = Mode.NORMAL
self.set_mode_node()
self.waiting_return_key = ""
self.func_dict = FuncDictDecorator.func_dict()
def _save_record(self):
"""
Save the details of an uploaded file to the history file and send the link to its destination
link - The link to the uploaded file
paths - An array of paths to all the files and folders that were uploaded
share_to - A string describing the intended destination of the link -
either the clipboard, a social network or stdout
"""
if not self.link:
return
# save a record of it to the history,
for path, filename in zip(self.paths, self.filenames):
History().add(path, filename, self.link)
# and then send the link to its destination, be that clipboard or social network.
if self.share_to == 'clipboard':
Clipboard().set(self.link)
elif self.share_to == 'stdout':
import sys
sys.stdout.write(self.link)
else:
url = URLS[self.share_to] % (SHARE_MESSAGE, self.link)
webbrowser.open(url, new=2)
def __init__(self):
# Qt application
self._app = QtWidgets.QApplication([sys.argv[0]])
# Translation engine (will be set by events)
self._gtrans = GTransWeb()
# Clipboard and its handler
self._clipboard = Clipboard(self._app)
self._clip_handler = ClipboardHandler(self._clipboard)
self._clip_handler.set_callback(self._on_clip_changed)
# Main window
self._window = Window(self._translate, self._on_clipmode_changed,
self._on_backendmode_changed,
self._on_headless_changed,
self._clipboard.get_mode_strs(),
GTransWeb.BACKEND_MODES)
# Buffer for selection mode
self._select_buf = CallableBuffer()
# Exit function should be call at exit
atexit.register(self.exit)
def __init__(self, config, args):
self.config = config
self.ndb = args['ndb']
self.key = args['key']
self.log = args['log']
self.search_string = ''
self.search_mode = 'gstyle'
self.search_direction = ''
self.note = self.ndb.get_note(self.key) if self.key else None
self.old_note = None
self.tabstop = int(self.config.get_config('tabstop'))
self.clipboard = Clipboard()
super(ViewNote, self).__init__(
urwid.SimpleFocusListWalker(self.get_note_content_as_list()))
def snippet(args):
"""Upload the contents of the user's clipboard as a text file"""
# Get the contents of the clipboard
clipboard = Clipboard().get()
if clipboard is None:
return
if args.text == 'dropbox':
# Create a unique name for the text file the snippet will be stored in
# With the extension specified by the user
filename = 'text_snippet_%d.%s' % (time(), args.extension)
path = os.path.join(TMP_PATH, filename)
# Save it
f = open(path, 'w')
f.write(clipboard)
f.close()
# Upload it
c.handle_files([path], [filename], args.share)
def do_command(self):
self.__copies = [item.copy() for item in self.items] # pylint: disable=W0201
Clipboard().put(self.__copies, self.list)
def execute(self):
# hide quick-console window before cmd is executed
self.hide()
cmd = self.text()
if not cmd:
cmd = self.lastCmd
logger.info('executing: {}'.format(cmd))
# date time in filename format
if cmd == 'dt':
copyToClipboard(curDatetime('%Y%m%d%H%M%S'))
# date time in readable format
elif cmd == 'dh':
copyToClipboard(curDatetime('%Y-%m-%d %H:%M:%S'))
# open cmd in clipboard
elif cmd == 'cmd':
path = getTextFromClipboard()
if not os.path.exists(path):
path = '.'
if os.path.isfile(path):
path = os.path.dirname(path)
command('start cmd.exe /k cd /d {}'.format(path))
elif cmd == 'te':
cur = Windows().current
if not cur or not cur.path == r'C:\Windows\explorer.exe':
return
path = getTextFromClipboard()
if not os.path.exists(path):
print('path not exists')
return
if os.path.isfile(path):
print('is not directory')
return
command(u'start gvim {}'.format(os.path.join(path, '0txt.txt')))
# open mintty
elif cmd == 'mt':
path = getTextFromClipboard()
try:
if not os.path.exists(path):
raise Exception()
if os.path.isfile(path):
path = os.path.dirname(path)
path = path.replace('\\', '/')
path = path.replace(':', '')
path = '"/cygdrive/{}"'.format(path)
except Exception:
path = '~'
print(path)
command(("mintty --title \"mintty\" /bin/bash -lc 'cd {};"
+ " exec bash'").format(path))
elif cmd == 'ba' or cmd == 'bs':
path = getTextFromClipboard()
try:
if not os.path.exists(path):
raise Exception()
if os.path.isfile(path):
path = os.path.dirname(path)
path = path.replace('\\', '/')
path = path.replace(':', '')
path = '"/cygdrive/{}"'.format(path)
except Exception:
path = '~'
print(path)
s = 'start bash -c \'cd {}; $SHELL\''.format(path)
command(s)
# random music
elif cmd == 'rm':
command('start pythonw rand_music.py')
# secret
elif cmd == 'av':
command('start pythonw rand_movie.py')
elif cmd == 'mav':
command('start pythonw rand_mmd.py')
elif cmd == 'yav':
command('start pythonw rand_av.py')
# put foreground window to right bottom
elif cmd == 'put':
import win32gui
availGeo = QApplication.desktop().availableGeometry()
right, bottom = availGeo.width(), availGeo.height()
hwnd = win32gui.GetForegroundWindow()
x, y, r, b = win32gui.GetWindowRect(hwnd)
w = r - x
h = b - y
x, y = right - w, bottom - h
win32gui.MoveWindow(hwnd, x, y, w, h, True)
elif cmd == 'cl':
logger.info('cl start')
try:
logger.info('cl get_image')
logger.info(repr(Clipboard))
fname = Clipboard.get_image()
if fname:
logger.info('cl: ' + fname)
copyToClipboard(fname)
else:
logger.info('cl nothing')
except:
logger.info(traceback.format_exc())
logger.info('cl end')
elif cmd == 'tm':
run_tmp_script()
# quit
elif cmd == 'quit':
exit()
# execute in hotkeys directory
elif cmd in self.cmds:
logger.info('special cmds: {}'.format(hotkeys))
logger.info('cmd: {}'.format(cmd))
ecmd = 'start {}'.format(os.path.join(hotkeys, cmd))
logger.info('ecmd: {}'.format(ecmd))
command(ecmd)
else:
logger.error('unknown command {}'.format(cmd))
print('oops')
return
self.clear(cmd)
def __putItemsOnClipboard(self):
cb = Clipboard()
self.__previousClipboardContents = cb.get() # pylint: disable=W0201
cb.put(self.itemsToCut(), self.sourceOfItemsToCut())
class ViewNote(urwid.ListBox):
def __init__(self, config, args):
self.config = config
self.ndb = args['ndb']
self.key = args['key']
self.log = args['log']
self.search_string = ''
self.search_mode = 'gstyle'
self.search_direction = ''
self.note = self.ndb.get_note(self.key) if self.key else None
self.old_note = None
self.tabstop = int(self.config.get_config('tabstop'))
self.clipboard = Clipboard()
super(ViewNote, self).__init__(
urwid.SimpleFocusListWalker(self.get_note_content_as_list()))
def get_note_content_as_list(self):
lines = []
if not self.key:
return lines
if self.old_note:
for l in self.old_note['content'].split('\n'):
lines.append(
urwid.AttrMap(
urwid.Text(l.replace('\t', ' ' * self.tabstop)),
'note_content_old', 'note_content_old_focus'))
else:
for l in self.note['content'].split('\n'):
lines.append(
urwid.AttrMap(
urwid.Text(l.replace('\t', ' ' * self.tabstop)),
'note_content', 'note_content_focus'))
lines.append(urwid.AttrMap(urwid.Divider(u'-'), 'default'))
return lines
def update_note_view(self, key=None, version=None):
if key: # setting a new note
self.key = key
self.note = self.ndb.get_note(self.key)
self.old_note = None
if self.key and version:
# verify version is within range
if int(version) <= 0 or int(version) >= self.note['version'] + 1:
self.log(u'Version v{0} is unavailable (key={1})'.format(
version, self.key))
return
if (not version and self.old_note) or \
(self.key and version and version == self.note['version']):
self.log(
u'Displaying latest version v{0} of note (key={1})'.format(
self.note['version'], self.key))
self.old_note = None
elif self.key and version:
# get a previous version of the note
self.log(u'Fetching version v{0} of note (key={1})'.format(
version, self.key))
version_note = self.ndb.get_note_version(self.key, version)
if not version_note:
self.log(
u'Failed to get version v{0} of note (key={1})'.format(
version, self.key))
# don't do anything, keep current note/version
else:
self.old_note = version_note
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
if not self.search_string:
self.focus_position = 0
def lines_after_current_position(self):
lines_after_current_position = range(self.focus_position + 1,
len(self.body.positions()) - 1)
return lines_after_current_position
def lines_before_current_position(self):
lines_before_current_position = range(0, self.focus_position)
lines_before_current_position.reverse()
return lines_before_current_position
def search_note_view_next(self, search_string=None, search_mode=None):
if search_string:
self.search_string = search_string
if search_mode:
self.search_mode = search_mode
note_range = self.lines_after_current_position(
) if self.search_direction == 'forward' else self.lines_before_current_position(
)
self.search_note_range(note_range)
def search_note_view_prev(self, search_string=None, search_mode=None):
if search_string:
self.search_string = search_string
if search_mode:
self.search_mode = search_mode
note_range = self.lines_after_current_position(
) if self.search_direction == 'backward' else self.lines_before_current_position(
)
self.search_note_range(note_range)
def search_note_range(self, note_range):
for line in note_range:
line_content = self.note['content'].split('\n')[line]
if (self.is_match(self.search_string, line_content)):
self.focus_position = line
break
self.update_note_view()
def is_match(self, term, full_text):
if self.search_mode == 'gstyle':
return term in full_text
else:
results = re.search(term, full_text)
return (results is not None)
def get_status_bar(self):
if not self.key:
return \
urwid.AttrMap(urwid.Text(u'No note...'),
'status_bar')
cur = -1
total = 0
if len(self.body.positions()) > 0:
cur = self.focus_position
total = len(self.body.positions())
if self.old_note:
t = time.localtime(float(self.old_note['versiondate']))
title = utils.get_note_title(self.old_note)
version = self.old_note['version']
else:
t = time.localtime(float(self.note['modifydate']))
title = utils.get_note_title(self.note)
flags = utils.get_note_flags(self.note)
tags = utils.get_note_tags(self.note)
version = self.note['version']
mod_time = time.strftime(u'Date: %a, %d %b %Y %H:%M:%S', t)
status_title = \
urwid.AttrMap(urwid.Text(u'Title: ' +
title,
wrap='clip'),
'status_bar')
status_key_index = \
('pack', urwid.AttrMap(urwid.Text(u' [' +
self.key +
u'] ' +
str(cur + 1) +
u'/' +
str(total)),
'status_bar'))
status_date = \
urwid.AttrMap(urwid.Text(mod_time,
wrap='clip'),
'status_bar')
if self.old_note:
status_tags_flags = \
('pack', urwid.AttrMap(urwid.Text(u'[OLD:v' +
str(version) +
u']'),
'status_bar'))
else:
status_tags_flags = \
('pack', urwid.AttrMap(urwid.Text(u'[' +
tags +
u'] [v' +
str(version) +
u'] [' +
flags +
u']'),
'status_bar'))
pile_top = urwid.Columns([status_title, status_key_index])
pile_bottom = urwid.Columns([status_date, status_tags_flags])
if self.old_note or \
not (utils.note_published(self.note) and 'publishkey' in self.note):
return urwid.AttrMap(urwid.Pile([pile_top, pile_bottom]),
'status_bar')
pile_publish = \
urwid.AttrMap(urwid.Text(u'Published: http://simp.ly/publish/' +
self.note['publishkey']),
'status_bar')
return \
urwid.AttrMap(urwid.Pile([ pile_top, pile_bottom, pile_publish ]),
'status_bar')
def copy_note_text(self):
line_content = self.note['content'].split('\n')[self.focus_position]
self.clipboard.copy(line_content)
def keypress(self, size, key):
if key == self.config.get_keybind('tabstop2'):
self.tabstop = 2
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
elif key == self.config.get_keybind('tabstop4'):
self.tabstop = 4
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
elif key == self.config.get_keybind('tabstop8'):
self.tabstop = 8
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
else:
return key
return None
def restoreItemsToPasteToSource(self):
Clipboard().put(self.__itemsToPaste, self.__sourceOfItemsToPaste)
def clearSourceOfItemsToPaste(self):
Clipboard().clear()
kh = KeyHandler(display)
if arguments['copy']:
# Copy from focused window
copy_from_focused()
elif arguments['paste']:
# Paste to focused window
paste_to_focused()
elif arguments['focused']:
# Print focused window id
print(get_focused().id)
elif arguments['daemon']:
# Start daemon
from clipboard import Clipboard
Clipboard().run()
elif arguments['history']:
# print history?
pass
# --------- Automate mouse clicks:
# import time
# from Xlib import X
# from Xlib.display import Display
# from Xlib.ext import xtest
# d=Display()
# def click(b):
# xtest.fake_input(d.get_input_focus().focus, X.ButtonPress, b)
# d.flush()
# d.sync()
# xtest.fake_input(d.get_input_focus().focus, X.ButtonRelease, b)
def getItemsToPaste(self):
return Clipboard().get()
def __removeItemsFromClipboard(self):
cb = Clipboard()
cb.put(*self.__previousClipboardContents)
def getItemsToPaste(self):
items, source = Clipboard().get()
return [item.copy() for item in items], source
def __putItemsOnClipboard(self):
cb = Clipboard()
self.__previousClipboardContents = cb.get() # pylint: disable=W0201
cb.put(self.itemsToCut(), self.sourceOfItemsToCut())
def undo_command(self):
Clipboard().clear()
class GTransWebGui(object):
def __init__(self):
# Qt application
self._app = QtWidgets.QApplication([sys.argv[0]])
# Translation engine (will be set by events)
self._gtrans = GTransWeb()
# Clipboard and its handler
self._clipboard = Clipboard(self._app)
self._clip_handler = ClipboardHandler(self._clipboard)
self._clip_handler.set_callback(self._on_clip_changed)
# Main window
self._window = Window(self._translate, self._on_clipmode_changed,
self._on_backendmode_changed,
self._on_headless_changed,
self._clipboard.get_mode_strs(),
GTransWeb.BACKEND_MODES)
# Buffer for selection mode
self._select_buf = CallableBuffer()
# Exit function should be call at exit
atexit.register(self.exit)
def run(self):
''' Run main application '''
self._app.exec_()
def exit(self):
''' Exit application '''
self._gtrans.exit()
def _translate(self, src_text=None):
''' Translate passed text. If not passed, it will be get from GUI. '''
# Get languages from GUI
src_lang, tgt_lang = self._window.get_langs()
# Source text
if src_text is None:
# Get text from GUI
src_text = self._window.get_src_text()
else:
# Set text to GUI
self._window.set_src_text(src_text)
# Start translation
tgt_text = self._gtrans.translate(src_lang, tgt_lang, src_text)
# Set to GUI
self._window.set_tgt_text(tgt_text)
# Set to clipboard
if self._window.get_overwrite():
self._clip_handler.overwrite_clip(tgt_text)
def _on_clip_changed(self, src_text):
''' When clipboard changed, start to translate. '''
if self._clipboard.get_mode_str() == 'select':
# Postpone by buffering
self._select_buf(self._translate, src_text)
else:
# Translate right now
self._translate(src_text)
def _on_clipmode_changed(self, mode_str):
''' When GUI changed, connect to clipboard'''
self._clipboard.set_mode(mode_str)
def _on_backendmode_changed(self, mode_str):
''' When GUI changed, connect to gtrans '''
# Restart browser
self._gtrans.exit()
headless = self._gtrans.is_headless()
self._gtrans = GTransWeb(backend_mode=mode_str, headless=headless)
def _on_headless_changed(self, checked):
''' When GUI changed, connect to gtrans '''
checked = bool(checked)
# Restart browser
self._gtrans.exit()
backend = self._gtrans.get_backend_mode()
self._gtrans = GTransWeb(backend_mode=backend, headless=checked)
class EnVimKey(QObject):
about_to_quit = pyqtSignal()
changed_mode = pyqtSignal(str, str, int)
about_to_search = pyqtSignal(object)
def __init__(self, parent = None):
QObject.__init__(self, parent = parent)
# フックマネージャーを生成
self.hook_manager = pyHook.HookManager()
# KeyDown, KeyUpで呼ばれる関数を設定
self.hook_manager.KeyDown = self.on_keyboard_event
self.hook_manager.KeyUp= self.on_keyboard_event
self.modifiers_key_state = ModifiersKeyState()
self.timer = QTimer(self)
self.timer.setInterval(800)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.on_timeout)
self.timer_running = False
self.window_dict = dict()
self.candidates = deque()
self.key_sequences = deque()
self.window_id = None
self.clipboard = Clipboard()
self.current_node = None
self.root_node = KeyDictNode(dict())
for mode in Mode:
self.root_node.set_key_dictionary(mode)
for shortcuts_info in shortcuts_tuple:
shortcuts_info.set_mode_shortcuts(self.root_node)
self.current_exe_name = ""
self._mode = Mode.NORMAL
self.set_mode_node()
self.waiting_return_key = ""
self.func_dict = FuncDictDecorator.func_dict()
@FuncDictDecorator.inner_func("insert")
def change_to_insert_mode(self):
self._mode = Mode.INSERT
self.set_mode_node()
self.changed_mode.emit("Mode", "Insert", 500)
print("insert")
@FuncDictDecorator.inner_func("normal")
def change_to_normal_mode(self):
self._mode = Mode.NORMAL
self.set_mode_node()
self.changed_mode.emit("Mode", "Normal", 500)
print("normal")
@FuncDictDecorator.inner_func("visual")
def change_to_visual_mode(self):
self._mode = Mode.VISUAL
self.set_mode_node()
self.changed_mode.emit("Mode", "Visual", 500)
print("visual")
@FuncDictDecorator.inner_func("focus")
def set_window_focus(self, search_window_name):
def match_window_name(window_handle, dummy):
window_title = str(win32gui.GetWindowText(window_handle))
if window_name_pattern.match(window_title):
self.target_window_handle = window_handle
self.target_window_handle = None
window_name_pattern = re.compile(search_window_name)
win32gui.EnumWindows(match_window_name, "")
if self.target_window_handle:
win32gui.SetForegroundWindow(self.target_window_handle)
win32gui.ShowWindow(self.target_window_handle, win32con.SW_MAXIMIZE)
@FuncDictDecorator.inner_func("quit")
def quit_envimkey(self):
self.about_to_quit.emit()
@FuncDictDecorator.inner_func("copy")
def copy_to_clipboard(self,text):
self.before_text = self.clipboard.get()
self.clipboard.set(text)
@FuncDictDecorator.inner_func("rollback")
def rollback_to_clipboard(self):
self.clipboard.set(self.before_text)
def set_mode_node(self):
self.current_node = self.root_node.dictionary[self._mode]
# self.print_dict(self.root_node.dictionary)
def timer_start(self):
print("start")
self.timer_running = True
self.timer.start()
def timer_stop(self):
print("stop")
self.timer.stop()
self.timer_running = False
self.set_mode_node()
if self.waiting_return_key:
self.emulate_keys(self.waiting_return_key)
self.waiting_return_key = None
self.key_sequences.clear()
if self.key_sequences:
self.emulate_keys(KeySequences.from_sequences(self.key_sequences).action_atoms)
self.key_sequences.clear()
def emulate_keys(self, keys):
print(keys)
for action_atom in keys:
if action_atom.type == ActionType.PRESS:
if action_atom.extended:
win32api.keybd_event(action_atom.info, 0, win32con.KEYEVENTF_EXTENDEDKEY | 0, 0)
else:
win32api.keybd_event(action_atom.info, 0, 0, 0)
# win32api.keybd_event(action_atom.info, 0, win32con.KEYEVENTF_EXTENDEDKEY | win32con.KEYEVENTF_KEYUP, 0)
win32api.keybd_event(action_atom.info, 0, win32con.KEYEVENTF_KEYUP, 0)
elif action_atom.type == ActionType.DOWN:
win32api.keybd_event(action_atom.info, 0, 0, 0)
elif action_atom.type == ActionType.UP:
win32api.keybd_event(action_atom.info, 0, win32con.KEYEVENTF_KEYUP, 0)
else:
func_arg = action_atom.info.args
if func_arg is not None:
getattr(self, self.func_dict[action_atom.info.text])(func_arg)
else:
getattr(self, self.func_dict[action_atom.info.text])()
def search(self, key_text, exe_name):
# self.print_dict(self.current_node.dictionary)
print(exe_name)
self.waiting_return_key = ""
if not(self.timer_running):
try:
self.current_node = self.current_node.dictionary[exe_name]
except KeyError:
# マッチする実行ファイル名が登録されていない場合
self.timer_stop()
return
try:
node = self.current_node.dictionary[key_text]
self.current_node = node
# ノードの辞書が空で、結果が確定する場合
if not(node.dictionary):
self.key_sequences.clear()
self.timer_stop()
self.emulate_keys(node.return_key)
return
# 結果の候補が存在し、一定時間待機する必要がある場合
if node.has_return_key:
self.timer_start()
self.waiting_return_key = node.return_key
return
# マッチしたが次の入力がなければ結果が確定しない場合
self.timer_start()
return
# マッチするキーが存在しない場合
except KeyError:
if len(self.key_sequences) == 1:
self.key_sequences.clear()
self.timer_stop()
return SearchResultType.NOT_MATCH_BREAK
self.timer_stop()
return
def on_keyboard_event(self, event):
# 自分でエミュレートしたイベントならそのままイベントを通す
if event.Injected:
# print(event.KeyID)
return True
# デバッグ用にescを押したら終了するようにしておく
if event.KeyID == 27:
self.timer.stop()
self.about_to_quit.emit()
return False
window_id = event.Window
# 前回のイベントとwindow_idが異なれば
if self.window_id != window_id:
self.window_id = window_id
# キーイベントを受け取るアプリケーションのexe名を取得
self.current_exe_name = self.get_exe_name(window_id)
print(self.current_exe_name)
code = event.KeyID
# event.Transitionはpressなら0, releaseなら128
is_press_event = not(event.Transition)
# モディファイアーが押されているかチェックし、modifiers_key_stateの状態を更新する
pressed_modifier = self.modifiers_key_state.pressing(code, is_press_event)
# モディファイアーが押されていれば以降の処理をしない
if pressed_modifier:
print("modifier", code)
return True
# キーがReleaseされるイベントなら以降の処理をしない
if not(is_press_event):
return True
# キーコードとモディファイアーの状態をもとにキーシークエンスを生成
seq = KeySequence.from_code(code, self.modifiers_key_state.presses())
self.key_sequences.append(seq)
search_result = self.search(seq.text, self.current_exe_name)
if search_result == SearchResultType.NOT_MATCH_BREAK:
return True
# Falseを返すとイベントを無視し、Trueを返すとイベントを処理する
return False
def get_exe_name(self, window_id):
try:
base_exe_name = self.window_dict[window_id]
except KeyError:
# プロセスIDを取得
thread_id, process_id = GetWindowThreadProcessId(window_id)
# プロセスハンドルを取得
process_handle = OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION, 0, process_id)
# キーを受け取るアプリケーションのexe名を取得
name = GetModuleFileNameEx(process_handle, 0)
# .exeを除く
base_exe_name = os.path.basename(name)[:-4]
self.window_dict[window_id] = base_exe_name
return base_exe_name
def _window_enum_callback(self, hwnd, wildcard):
is_visible = win32gui.IsWindowVisible(hwnd)
if not(is_visible):
return
title = str(win32gui.GetWindowText(hwnd))
if title != "" and title != "Program Manager":
try:
exe_name = self.get_exe_name(hwnd)
except:
exe_name = ""
self.candidates.append((title, exe_name, hwnd))
def find_window_wildcard(self):
self.candidates.clear()
win32gui.EnumWindows(self._window_enum_callback, "")
@FuncDictDecorator.inner_func("search")
def search_exe(self):
self.find_window_wildcard()
self.about_to_search.emit(self.candidates)
def key_unlock(self):
# キーボードフックを解除する
self.hook_manager.UnhookKeyboard()
self.thread().quit()
def keylock(self):
# キーボードフックを開始する
self.hook_manager.HookKeyboard()
pythoncom.PumpWaitingMessages()
def print_dict(self, d, depth = 0):
def print_indent(depth, *args, **kwargs):
print(" "*8*depth, *args, **kwargs)
for x, y in d.items():
if len(y.dictionary):
print_indent(depth, x)
self.print_dict(y.dictionary, depth + 1)
if y.has_return_key:
print_indent(depth, x, y.return_key)
def on_timeout(self):
print("timeout")
self.timer_stop()
import subprocess
import sys
from clipboard import Clipboard
# def clipboard_test():
# p = subprocess.Popen(['pbcopy'], stdin=subprocess.PIPE)
# p.stdin.write('copy-text!@#$>>?')
# p.stdin.close()
# clipboard_test()
clip = Clipboard()
clip.get_clipboard()
clip.print_items()
def redo_command(self):
Clipboard().put(self.__copies, self.list)
class Wveinterface:
"""
Create a wave user interface based on Tkinterface to read and modify the waves to play on the DPS
"""
def __init__(self, prevroot, datawve):
"""
Create a waveinterface instance.
:param prevroot: is the main window
:param datawve: is the datapoints to play with
:returns: a new instance of wave interface
"""
self.root = maketoplevel(prevroot, True)
self.root.title("Wave editor")
self.datawve = datawve
self.dataclpbrd = []
self.clipboardtime = 0
row = 0
col = 0
self.tablewve = Table(self.root, self.datawve,
('step', 'time [s]', ('voltage [V]', VCOL),
('current [A]', CCOL)), row, col, TABLEROW,
TABLECOL)
SCOPEROWSPAN = 15
self.scope = Scope(self.root,
self.datawve,
TABLEROW + 1 + 1,
0,
rowspan=SCOPEROWSPAN,
showpower=False,
horizontaljoin=True,
buttoncallback=self.buttoncallback)
row = 1
rowspan = 1
colspan = 1
col = TABLECOL + colspan
Button(self.root, text="Pick beg",
command=self.btncmdpckbeg).grid(row=row,
column=col,
sticky=E + W,
padx=8)
col = TABLECOL + colspan
row += rowspan
Button(self.root, text="Pick end",
command=self.btncmdpckend).grid(row=row,
column=col,
sticky=E + W,
padx=8)
Separator(self.root,
orient='horizontal').grid(row=TABLEROW + 1,
column=0,
columnspan=TABLECOL + 2 + 1 + 6,
sticky=E + W,
pady=8)
Separator(self.root, orient='vertical').grid(row=0,
column=6,
rowspan=1 + TABLEROW + 1 +
SCOPEROWSPAN,
sticky=N + S,
padx=8)
row = 0
COL1 = TABLECOL + 2 + 1
col = COL1
colspan = 1
insertlabelrow(self.root, row, col, (None, None, ('voltage [V]', VCOL),
('current [A]', CCOL)))
row += rowspan
insertlabelrow(self.root, row, col, ('time [s]:', ))
self.dvartime = DoubleVar()
self.dvarvoltage = DoubleVar()
self.dvarcurrent = DoubleVar()
insertentryrow(
self.root, row, col,
(None, self.dvartime, self.dvarvoltage, self.dvarcurrent))
col += TABLECOL
Button(self.root, text="Insert",
command=self.butcmdinsert).grid(row=row,
column=col,
sticky=E + W,
padx=8)
row += rowspan
col = COL1
insertlabelrow(self.root, row, col, ('step :', ))
self.ivarstep = IntVar()
insertentryrow(
self.root, row, col,
(None, self.ivarstep, self.dvarvoltage, self.dvarcurrent))
col += TABLECOL
Button(self.root, text="Modify",
command=self.butcmdmodify).grid(row=row,
column=col,
sticky=E + W,
padx=8)
col += colspan
Button(self.root, text="Delete",
command=self.butcmddelete).grid(row=row,
column=col,
sticky=E + W,
padx=8)
row += rowspan
col = COL1
insertlabelrow(self.root, row, col, ('pause [s]:', ))
self.dvarpause = DoubleVar()
insertentryrow(
self.root, row, col,
(None, self.dvarpause, self.dvarvoltage, self.dvarcurrent))
col += TABLECOL
Button(self.root, text="Append",
command=self.butcmdappend).grid(row=row,
column=col,
sticky=E + W,
padx=8)
self.clipboard = Clipboard(self.root, self.datawve, self.updateview,
TABLEROW + 2, COL1)
col = COL1 + TABLECOL
colspan = 1
row = TABLEROW + 1 + SCOPEROWSPAN
Button(self.root, text="Help",
command=self.btncmdhelp).grid(row=row,
column=col,
sticky=E + W,
padx=8)
col += 1
Button(self.root, text="Done",
command=self.butcmddone).grid(row=row,
column=col,
sticky=E + W,
padx=8)
self.scope.update()
self.scope.redraw()
def updateview(self):
"""
Update scope and table views
"""
self.tablewve.updateview()
self.scope.redraw()
def butcmdmodify(self):
"""
Modify and item of the table.
Gets the item to modify and new values from the user interface fields.
"""
i = self.ivarstep.get()
if i < len(self.datawve) and i >= 0:
self.datawve[i] = [self.datawve[self.ivarstep.get()][0]
] + self.getvc(i)
self.tablewve.updateview()
self.scope.redraw()
else:
tkMessageBox.showinfo('Step not found',
'Step index is not in the points interval')
def butcmddelete(self):
"""
Delete a table row.
Read the index to delete by the interface field.
"""
i = self.ivarstep.get()
if i < len(self.datawve) and i >= 0:
del self.datawve[i]
self.tablewve.updateview()
self.scope.redraw()
else:
tkMessageBox.showinfo('Step not found',
'Step index is not in the points interval')
def butcmdinsert(self):
"""
Insert an item on the data table.
Gets the item data from the interface fields.
"""
i = self.tablewve.findtime(self.dvartime.get())
if len(self.datawve) > 0 and i > 0 and abs(
self.datawve[i - 1][TPOS] - self.dvartime.get()
) < 0.01: #if the time is the same the insert becomes a modify
self.datawve[i - 1] = [self.dvartime.get()] + self.getvc(i - 1)
else:
self.datawve.insert(i, [self.dvartime.get()] + self.getvc(i - 1))
self.tablewve.updateview()
self.scope.redraw()
def butcmdappend(self):
"""
Append an item to the data table.
Gets the item to append values from the user interface fields.
"""
if self.dvarpause.get() <= 0:
tkMessageBox.showinfo('Time not monotonic',
'Time pause has to be > 0')
return
if len(self.datawve) > 0:
t0 = self.datawve[-1][TPOS]
else:
t0 = 0
self.datawve.append([self.dvarpause.get() + t0] +
self.getvc(len(self.datawve) - 1))
self.tablewve.updateview()
self.scope.redraw()
def btncmdpckbeg(self):
"""
Gets begin data on the clipboard from the first row visible on the data list.
"""
r = self.tablewve.getfistvisiblerow()
self.ivarstep.set(r)
self.dvartime.set(self.datawve[r][TPOS])
self.dvarvoltage.set(self.datawve[r][VPOS])
self.dvarcurrent.set(self.datawve[r][CPOS])
self.clipboard.setbegin(r)
def btncmdpckend(self):
"""
Gets end data on the clipboard from the second row visible on the data list.
"""
r = self.tablewve.getfistvisiblerow() + 1
if r < len(self.datawve):
self.ivarstep.set(r)
self.dvartime.set(self.datawve[r][TPOS])
self.dvarvoltage.set(self.datawve[r][VPOS])
self.dvarcurrent.set(self.datawve[r][CPOS])
self.clipboard.setend(r)
def butcmddone(self):
"""
Close the window.
"""
self.root.destroy()
def getvc(self, i):
"""
Gets voltage and current from the interface fields.
If they are negative, the voltage/current at the given position are taken.
In case of the first point the value 0 is used.
:param i: the index from which get parameters if something is < 0
:return: a list containing voltage and current
"""
v = self.dvarvoltage.get()
c = self.dvarcurrent.get()
if i >= 0:
if v < 0.: v = self.datawve[i][VPOS]
if c < 0.: c = self.datawve[i][CPOS]
else:
if v < 0.: v = 0.
if c < 0.: c = 0.
return [v, c]
def buttoncallback(self, p, action='insert'):
"""
Insert, modify or delete a point.
That interface is used by the scopetube to edit the table.
:param p: is a list containing the new value for (t, v, c)
if v or c are not updated -1 is returned
:param action: describes the type of action required
"""
self.dvarvoltage.set(p[1])
self.dvarcurrent.set(p[2])
self.dvartime.set(p[0])
self.ivarstep.set(self.tablewve.findtime(p[0]))
if action == 'insert':
self.butcmdinsert()
elif action == 'modify':
self.butcmdmodify()
elif action == 'delete':
self.butcmddelete()
else:
print(
'Internal error: unexpected button call back in wve interface')
def btncmdhelp(self):
"""
Open a window with basic help on the wave interface.
"""
Txtinterface(
self.root, 'Help',
"""Wave editor window is designed to create new waveform to play on the DPS supplier.
The wave is visible on two different output formats:
- top-left is text table showing what voltage and current set at give timing
Every line has its step number useful for editing
- bottom-left is the wave graphical picture representing the table above
The wave data can be entered in three ways:
- graphically with mouse clicking on the bottom-left graph
- textually with the commands on top-right input section
- from clipboard on the bottom-right side
The clipboard can copy/cut and paste from the data section.
Clipboard data can be modified bebore pasting back:
- amplified (or attenuated if the factor is below 1)
- translated (on Y for voltage and current and also on time)
- transformed in a ramp: the give number of steps are inserted between
the first and last data sample
On the graphical section it is possible to manage the enabled waveforms
with the mouse:
- drage with left button pressed to move the waveform(s)
- rotate wheel to zoom/unzoom the time (x)
- press shift while rotating wheel to zoom/unzoom the amplitude (y)
- press ctrl while rotating wheel to change the enabled waveform(s)
- press wheel to fit waveform(s) on time and y scales
- press right button to insert a point (on the enabled variables)
- press shift and right button to modify the amplitude of the point(s) at the right
of the mouse arrow with mouse amplitude on the enabled wave(s)
- press ctrl and right button to delete the point at the right of the mouse pointer
on the enabled wave(s)
- press ctrl and shift to replace the point at the right of the mouse pointer with the
current mouse arrow place on the enabled wave(s)
On the bottom of the screen the scale, translation and enables are available
for manual zooming and moving.
On the top-right side it is possible to add new points:
- insert button adds a new point at given time, use -1 on voltage/current to
keep previous value
- insert button to insert a new point (with absolute time) if the required time
is already present, that point is modified with new values
- modify and delete buttons can be used to edit or delete the given step
- append is used to add a new point to the tail of current waveform known
the delta time between last one
On the clipboard the sample time is stored as delta between adiacent points
while on the main table it is absolute.
On the clipboard are available the following functions:
- Copy and cut from begin/end steps of the data into the clipboard
- Paste clipboard at the given step inserting or overwriteing the data present there
The clipboard can be modified:
- Amplified to stretch in x or y depending on the factors
- Translated on x and y depending on the factors
- Transform the clipboard in a ramp using first and last points as begin
and end values with given number of steps
The clipboard and the data are showed with following buttons:
- Line up/down to move up or down by 1 line
- Page up/down to move up or dosn by all row available minus 1
- Top/bottom to go to the first or last element
- Goto time/step to move the first line at the given step
- Pick begin/end to read the first/second line and put is in begin/end fields
That is useful for edit purpose without copying by hand.
""")
def __removeItemsFromClipboard(self):
cb = Clipboard()
cb.put(*self.__previousClipboardContents)
def __init__(self, prevroot, datawve):
"""
Create a waveinterface instance.
:param prevroot: is the main window
:param datawve: is the datapoints to play with
:returns: a new instance of wave interface
"""
self.root = maketoplevel(prevroot, True)
self.root.title("Wave editor")
self.datawve = datawve
self.dataclpbrd = []
self.clipboardtime = 0
row = 0
col = 0
self.tablewve = Table(self.root, self.datawve,
('step', 'time [s]', ('voltage [V]', VCOL),
('current [A]', CCOL)), row, col, TABLEROW,
TABLECOL)
SCOPEROWSPAN = 15
self.scope = Scope(self.root,
self.datawve,
TABLEROW + 1 + 1,
0,
rowspan=SCOPEROWSPAN,
showpower=False,
horizontaljoin=True,
buttoncallback=self.buttoncallback)
row = 1
rowspan = 1
colspan = 1
col = TABLECOL + colspan
Button(self.root, text="Pick beg",
command=self.btncmdpckbeg).grid(row=row,
column=col,
sticky=E + W,
padx=8)
col = TABLECOL + colspan
row += rowspan
Button(self.root, text="Pick end",
command=self.btncmdpckend).grid(row=row,
column=col,
sticky=E + W,
padx=8)
Separator(self.root,
orient='horizontal').grid(row=TABLEROW + 1,
column=0,
columnspan=TABLECOL + 2 + 1 + 6,
sticky=E + W,
pady=8)
Separator(self.root, orient='vertical').grid(row=0,
column=6,
rowspan=1 + TABLEROW + 1 +
SCOPEROWSPAN,
sticky=N + S,
padx=8)
row = 0
COL1 = TABLECOL + 2 + 1
col = COL1
colspan = 1
insertlabelrow(self.root, row, col, (None, None, ('voltage [V]', VCOL),
('current [A]', CCOL)))
row += rowspan
insertlabelrow(self.root, row, col, ('time [s]:', ))
self.dvartime = DoubleVar()
self.dvarvoltage = DoubleVar()
self.dvarcurrent = DoubleVar()
insertentryrow(
self.root, row, col,
(None, self.dvartime, self.dvarvoltage, self.dvarcurrent))
col += TABLECOL
Button(self.root, text="Insert",
command=self.butcmdinsert).grid(row=row,
column=col,
sticky=E + W,
padx=8)
row += rowspan
col = COL1
insertlabelrow(self.root, row, col, ('step :', ))
self.ivarstep = IntVar()
insertentryrow(
self.root, row, col,
(None, self.ivarstep, self.dvarvoltage, self.dvarcurrent))
col += TABLECOL
Button(self.root, text="Modify",
command=self.butcmdmodify).grid(row=row,
column=col,
sticky=E + W,
padx=8)
col += colspan
Button(self.root, text="Delete",
command=self.butcmddelete).grid(row=row,
column=col,
sticky=E + W,
padx=8)
row += rowspan
col = COL1
insertlabelrow(self.root, row, col, ('pause [s]:', ))
self.dvarpause = DoubleVar()
insertentryrow(
self.root, row, col,
(None, self.dvarpause, self.dvarvoltage, self.dvarcurrent))
col += TABLECOL
Button(self.root, text="Append",
command=self.butcmdappend).grid(row=row,
column=col,
sticky=E + W,
padx=8)
self.clipboard = Clipboard(self.root, self.datawve, self.updateview,
TABLEROW + 2, COL1)
col = COL1 + TABLECOL
colspan = 1
row = TABLEROW + 1 + SCOPEROWSPAN
Button(self.root, text="Help",
command=self.btncmdhelp).grid(row=row,
column=col,
sticky=E + W,
padx=8)
col += 1
Button(self.root, text="Done",
command=self.butcmddone).grid(row=row,
column=col,
sticky=E + W,
padx=8)
self.scope.update()
self.scope.redraw()
def __putItemsOnClipboard(self):
cb = Clipboard()
self.__previousClipboardContents = cb.get() # pylint: disable-msg=W0201
cb.put(self.items, self.list)
class ViewNote(urwid.ListBox):
def __init__(self, config, args):
self.config = config
self.ndb = args['ndb']
self.key = args['key']
self.log = args['log']
self.search_string = ''
self.search_mode = 'gstyle'
self.search_direction = ''
self.note = self.ndb.get_note(self.key) if self.key else None
self.old_note = None
self.tabstop = int(self.config.get_config('tabstop'))
self.clipboard = Clipboard()
super(ViewNote, self).__init__(
urwid.SimpleFocusListWalker(self.get_note_content_as_list()))
def get_note_content_as_list(self):
lines = []
if not self.key:
return lines
if self.old_note:
for l in self.old_note['content'].split('\n'):
lines.append(
urwid.AttrMap(urwid.Text(l.replace('\t', ' ' * self.tabstop)),
'note_content_old',
'note_content_old_focus'))
else:
for l in self.note['content'].split('\n'):
lines.append(
urwid.AttrMap(urwid.Text(l.replace('\t', ' ' * self.tabstop)),
'note_content',
'note_content_focus'))
lines.append(urwid.AttrMap(urwid.Divider(u'-'), 'default'))
return lines
def update_note_view(self, key=None, version=None):
if key: # setting a new note
self.key = key
self.note = self.ndb.get_note(self.key)
self.old_note = None
if self.key and version:
# verify version is within range
if int(version) <= 0 or int(version) >= self.note['version'] + 1:
self.log(u'Version v{0} is unavailable (key={1})'.
format(version, self.key))
return
if (not version and self.old_note) or \
(self.key and version and version == self.note['version']):
self.log(u'Displaying latest version v{0} of note (key={1})'.
format(self.note['version'], self.key))
self.old_note = None
elif self.key and version:
# get a previous version of the note
self.log(u'Fetching version v{0} of note (key={1})'.
format(version, self.key))
version_note = self.ndb.get_note_version(self.key, version)
if not version_note:
self.log(u'Failed to get version v{0} of note (key={1})'.
format(version, self.key))
# don't do anything, keep current note/version
else:
self.old_note = version_note
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
if not self.search_string:
self.focus_position = 0
def lines_after_current_position(self):
lines_after_current_position = range(self.focus_position + 1, len(self.body.positions()) - 1)
return lines_after_current_position
def lines_before_current_position(self):
lines_before_current_position = range(0, self.focus_position)
lines_before_current_position.reverse()
return lines_before_current_position
def search_note_view_next(self, search_string=None, search_mode=None):
if search_string:
self.search_string = search_string
if search_mode:
self.search_mode = search_mode
note_range = self.lines_after_current_position() if self.search_direction == 'forward' else self.lines_before_current_position()
self.search_note_range(note_range)
def search_note_view_prev(self, search_string=None, search_mode=None):
if search_string:
self.search_string = search_string
if search_mode:
self.search_mode = search_mode
note_range = self.lines_after_current_position() if self.search_direction == 'backward' else self.lines_before_current_position()
self.search_note_range(note_range)
def search_note_range(self, note_range):
for line in note_range:
line_content = self.note['content'].split('\n')[line]
if (self.is_match(self.search_string, line_content)):
self.focus_position = line
break
self.update_note_view()
def is_match(self, term, full_text):
if self.search_mode == 'gstyle':
return term in full_text
else:
results = re.search(term, full_text)
return ( results is not None )
def get_status_bar(self):
if not self.key:
return \
urwid.AttrMap(urwid.Text(u'No note...'),
'status_bar')
cur = -1
total = 0
if len(self.body.positions()) > 0:
cur = self.focus_position
total = len(self.body.positions())
if self.old_note:
t = time.localtime(float(self.old_note['versiondate']))
title = utils.get_note_title(self.old_note)
version = self.old_note['version']
else:
t = time.localtime(float(self.note['modifydate']))
title = utils.get_note_title(self.note)
flags = utils.get_note_flags(self.note)
tags = utils.get_note_tags(self.note)
version = self.note['version']
mod_time = time.strftime(u'Date: %a, %d %b %Y %H:%M:%S', t)
status_title = \
urwid.AttrMap(urwid.Text(u'Title: ' +
title,
wrap='clip'),
'status_bar')
status_key_index = \
('pack', urwid.AttrMap(urwid.Text(u' [' +
self.key +
u'] ' +
str(cur + 1) +
u'/' +
str(total)),
'status_bar'))
status_date = \
urwid.AttrMap(urwid.Text(mod_time,
wrap='clip'),
'status_bar')
if self.old_note:
status_tags_flags = \
('pack', urwid.AttrMap(urwid.Text(u'[OLD:v' +
str(version) +
u']'),
'status_bar'))
else:
status_tags_flags = \
('pack', urwid.AttrMap(urwid.Text(u'[' +
tags +
u'] [v' +
str(version) +
u'] [' +
flags +
u']'),
'status_bar'))
pile_top = urwid.Columns([ status_title, status_key_index ])
pile_bottom = urwid.Columns([ status_date, status_tags_flags ])
if self.old_note or \
not (utils.note_published(self.note) and 'publishkey' in self.note):
return urwid.AttrMap(urwid.Pile([ pile_top, pile_bottom ]),
'status_bar')
pile_publish = \
urwid.AttrMap(urwid.Text(u'Published: http://simp.ly/publish/' +
self.note['publishkey']),
'status_bar')
return \
urwid.AttrMap(urwid.Pile([ pile_top, pile_bottom, pile_publish ]),
'status_bar')
def copy_note_text(self):
line_content = self.note['content'].split('\n')[self.focus_position]
self.clipboard.copy(line_content)
def keypress(self, size, key):
if key == self.config.get_keybind('tabstop2'):
self.tabstop = 2
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
elif key == self.config.get_keybind('tabstop4'):
self.tabstop = 4
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
elif key == self.config.get_keybind('tabstop8'):
self.tabstop = 8
self.body[:] = \
urwid.SimpleFocusListWalker(self.get_note_content_as_list())
else:
return key
return None
import cv2
import numpy as np
from vision import Vision
from controller import Controller
from keyboard import Keyboard
from clipboard import Clipboard
from game import Game
vision = Vision()
controller = Controller()
keyboard = Keyboard()
clipboard = Clipboard()
game = Game(vision, controller, keyboard, clipboard)
from pynput.keyboard import Key, Listener
#defining function to print when key is pressed
def on_press(key):
pass
#print('{0} pressed'.format(key))
#defining function to print when key is released
def on_release(key):
#print('{0} release'.format(key))
if key == Key.esc:
# Stop listener
return False
def __putItemsOnClipboard(self):
cb = Clipboard()
self.__previousClipboardContents = cb.get(
) # pylint: disable-msg=W0201
cb.put(self.items, self.list)
