class TestKeyboard:
def __init__(self):
self.keyboard = Controller()
def inputKey(self, key):
self.keyboard.press(key)
self.keyboard.release(key)
def inputKeyWithShift(self, key):
with self.keyboard.pressed(Key.shift):
self.keyboard.press(key)
self.keyboard.release(key)
def inputKeyWithControl(self, key):
with self.keyboard.pressed(Key.ctrl):
self.keyboard.press(key)
self.keyboard.release(key)
def inputKeyWith(self, with_key, key):
with self.keyboard.pressed(with_key):
self.keyboard.press(key)
self.keyboard.release(key)
def typeString(self, string):
self.keyboard.type(string)
def sear():
keyboard = Controller()
p = p = subprocess.Popen(["google-chrome", "http://www.google.com"])
time.sleep(3)
while True:
tts.textToSpeech("Speak your search query after the beep").say()
time.sleep(0.5)
os.system("echo '\a'")
time.sleep(0.2)
with keyboard.pressed(Key.ctrl):
with keyboard.pressed(Key.shift):
keyboard.press('.')
keyboard.release('.')
#keyboard.press_and_release('ctrl+shift+.')
time.sleep(15)
tts.textToSpeech("Do you want to search another query").say()
time.sleep(0.2)
os.system("echo '\a'")
time.sleep(0.2)
stt.SpeechToText('./Desktop/major/sound/ask.wav').record(3)
os.system("echo '\a'")
ask = stt.SpeechToText(
'./Desktop/major/sound/ask.wav').speech_to_text()
if ask == "no":
break
p.kill()
def med(self, game):
keyboard = Controller()
gesture = Gesture(game, 480, 480, pnet=self.pnet)
with keyboard.pressed(Key.ctrl):
with keyboard.pressed(Key.alt):
keyboard.press(Key.right)
keyboard.release(Key.right)
self.game_loop(gesture)
def toggle(self, *args):
if not self.cs.running:
self.init_thread(target=self.cs.start_listener)
else:
c = Controller()
with c.pressed(Key.pause):
with c.pressed(Key.end):
c.press(Key.down)
c.release(Key.down)
class RunSim:
def __init__(self, ozone_path, results_path, config_path, sim_name,
hard_rate):
chdir(config_path)
self.ozone_path = ozone_path
self.sim_path = '{}\{}.ozn'.format(results_path, sim_name)
self.keys = Controller()
self.hware_rate = hard_rate # this ratio sets times of waiting for your machine response while running OZone
def open_ozone(self):
popen('{}\OZone.exe'.format(self.ozone_path))
time.sleep(0.5)
self.keys.press(Key.right)
self.keys.press(Key.enter)
time.sleep(7 * self.hware_rate)
print('OZone3 is alive')
def close_ozn(self):
popen('taskkill /im ozone.exe /f') # killing ozone processes
print('OZone3 instance killed')
time.sleep(self.hware_rate)
def run_simulation(self):
keys = self.keys
# open .ozn file
with keys.pressed(Key.ctrl):
keys.press('o')
time.sleep(1)
keys.press(Key.tab)
keys.press(Key.tab)
keys.press(Key.enter) # in case of error: open file 0
keys.type(self.sim_path)
time.sleep(1)
keys.press(Key.enter)
time.sleep(4 * self.hware_rate)
# run "thermal action"
with self.keys.pressed(Key.alt):
self.keys.press('t')
keys.press(Key.enter)
time.sleep(8 * self.hware_rate)
# run "steel temperature"
with self.keys.pressed(Key.alt):
self.keys.press('s')
keys.press(Key.enter)
time.sleep(2 * self.hware_rate)
print('analises has been run')
def new_analysis(self):
with self.keys.pressed(Key.ctrl):
self.keys.press('n')
def modify_font1():
time.sleep(1)
pyautogui.doubleClick()
time.sleep(1)
keyboard = Controller()
with keyboard.pressed(Key.cmd.value):
with keyboard.pressed(Key.shift):
keyboard.press(',')
keyboard.release(',')
pyautogui.click()
keyboard.release(Key.shift)
keyboard.release(Key.cmd.value)
class Keyboard:
def __init__(self, sleep=0):
self.keyboard = Controller()
self.sleep = sleep
def space(self):
# Press and release space
sleep(self.sleep)
self.keyboard.press(Key.space)
self.keyboard.release(Key.space)
def enter(self):
# Press and release enter
sleep(self.sleep)
self.keyboard.press(Key.enter)
self.keyboard.release(Key.enter)
def escape(self):
# Press and release enter
sleep(self.sleep)
self.keyboard.press(Key.esc)
self.keyboard.release(Key.esc)
def key(self, key):
# Type a lower case A; this will work even if no key on the
# physical keyboard is labelled 'A'
sleep(self.sleep)
self.keyboard.press(key)
self.keyboard.release(key)
def shift(self, key):
# Type two upper case As
sleep(self.sleep)
with self.keyboard.pressed(Key.shift):
self.key(key)
def write(self, text):
# Type 'Hello World' using the shortcut type methodQ
sleep(self.sleep)
self.keyboard.type(text)
def quit(self):
with self.keyboard.pressed(Key.alt):
with self.keyboard.pressed(Key.cmd):
self.key("q")
def end(self):
sleep(self.sleep)
self.keyboard.press(Key.end)
self.keyboard.release(Key.end)
def event_cool(self):
checkList = self.coolList[-4:]
event_cool = ["'c'", "'o'", "'o'", "'l'"]
if checkList == event_cool:
print('COOL!!!')
keyboard = Controller()
with keyboard.pressed(Key.shift):
keyboard.press('1')
with keyboard.pressed(Key.shift):
keyboard.press('1')
with keyboard.pressed(Key.shift):
keyboard.press('1')
playsound('cool.wav')
return True
return False
def on_click(x, y, button, pressed):
# 实例化键盘
kb = Controller()
# 使用键盘输入一个字母
kb.press(Key.ctrl)
kb.press(Key.alt)
kb.press('.')
kb.release(Key.ctrl)
kb.release(Key.alt)
kb.release('.')
kb.pressed(Key.ctrl, Key.alt, '.')
if button == Button.right:
print("关闭")
return False
def space_break():
keyboard = Controller()
# keyboard.press(Key.pause)
# keyboard.release(Key.pause)
with keyboard.pressed(Key.control):
keyboard.press('c')
keyboard.release('c')
def trigger_copy():
from pynput.keyboard import Key,Controller
key = Controller()
with key.pressed(Key.ctrl):
key.press('c')
key.release('c')
time.sleep(0.1) # wait for ctrl+c valid
def on_click(x, y, button, pressed):
#print('{0} at {1}'.format('Pressed' if pressed else 'Released', (x, y)))
if not pressed:
# Stop listener
return False
else:
keyboard = Controller()
keyboard.type("python -c 'import pty; pty.spawn(\"/bin/bash\")'")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
keyboard.type("python3 -c 'import pty; pty.spawn(\"/bin/bash\")'")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
with keyboard.pressed(Key.ctrl):
keyboard.press('Z')
keyboard.release('Z')
time.sleep(0.5)
keyboard.type("stty raw -echo")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
keyboard.type("fg")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
#keyboard.type("reset")
#keyboard.press(Key.enter)
#keyboard.release(Key.enter)
#time.sleep(0.5)
keyboard.type("export SHELL=bash")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
keyboard.type("export TERM=xterm-256color")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(0.5)
keyboard.type("stty rows 53 columns 190")
keyboard.press(Key.enter)
keyboard.release(Key.enter)
def _return_proper_right_alt():
keyboard = Controller()
try:
with keyboard.pressed(Key.alt_r):
pass
except X11Error:
return Key.alt_gr
else:
return Key.alt_r
def clear_pycharm():
"""
This is a simple function that resets the terminal/console of PyCharm IDE to help visualize the information.
:return: Returns the command set to reset the IDE terminal.
"""
from pynput.keyboard import Key, Controller
keyb = Controller()
with keyb.pressed(Key.alt):
keyb.press("'")
def _open_logined_tab():
with keyboard.pressed(Key.cmd):
keyboard.press('t')
keyboard.release('t')
time.sleep(1)
keyboard.type('ssh KG')
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(1)
def activateAutoPilot():
print("Activating Auto-Pilot")
keyboard = KeyboardController()
with keyboard.pressed(Key.ctrl_l):
keyboard.press('s')
time.sleep(0.2)
keyboard.release('s')
def retrieveDrones():
print("Retrieving drones to drone bay")
keyboard = KeyboardController()
with keyboard.pressed(Key.shift_l):
keyboard.press('r')
time.sleep(0.3)
keyboard.release('r')
time.sleep(10)
class PresentationWrapper:
def __init__(self, presentation):
self.presentation = presentation
self.zoom = False
self.keyboard = Controller()
def run_slideshow(self):
self.presentation.SlideShowSettings.Run()
def close_slideshow(self):
self.presentation.SlideShowWindow.View.Exit()
def next_slide(self):
self.presentation.SlideShowWindow.View.Next()
def previous_slide(self):
self.presentation.SlideShowWindow.View.Previous()
def start_zoom(self):
# Do nothing if zoom is already running.
if self.zoom:
return
# NOT WORKING? Problem with the WIN + '+' command?
self.zoom = True
with self.keyboard.pressed(Key.cmd):
self.keyboard.press('=')
self.keyboard.release('=')
def stop_zoom(self):
# Do nothing if zoom is not running.
if not self.zoom:
return
# NOT WORKING? Problem with the WIN + '+' command?
self.zoom = False
with self.keyboard.pressed(Key.cmd):
self.keyboard.press('-')
self.keyboard.release('-')
self.keyboard.press('-')
self.keyboard.release('-')
def Italic():
time.sleep(1)
pyautogui.doubleClick()
time.sleep(1)
keyboard = Controller()
with keyboard.pressed(Key.cmd.value):
keyboard.press('i')
keyboard.release('i')
pyautogui.click()
keyboard.release(Key.cmd.value)
def event_what(self):
event_what = [
["'w'", "'h'", "'a'", "'t'"],
["'h'", "'o'", "'w'"],
["'w'", "'h'", "'e'", "'n'"],
["'w'", "'h'", "'e'", "'r'", "'e'"],
["'w'", "'h'", "'y'"]
]
for i in event_what:
length = len(i) * -1
checkList = self.coolList[length:]
if checkList == i:
keyboard = Controller()
with keyboard.pressed(Key.shift):
keyboard.press('/')
with keyboard.pressed(Key.shift):
keyboard.press('/')
with keyboard.pressed(Key.shift):
keyboard.press('/')
playsound('what.wav')
return True
return False
def map_gesture_to_shortcut(self, finger_values, gesture):
keyboard = Controller()
special_keys_list = [
"space", "up", "down", "right", "left", "tab", "esc", "enter",
"page_down", "page_up", "f1", "f4", "f2", "f3", "f4", "f5", "f6",
"f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
"backspace"
]
chord_keys = ["alt", "ctrl", "shift", "cmd"]
if gesture in finger_values:
value = finger_values[gesture]
value = value.replace(" ", "")
if value == "":
return
if "+" in value:
key1 = value[:value.index("+")]
key2 = value[value.index("+") + 1:]
if key1.lower() in chord_keys:
if key2.lower() in special_keys_list:
key1 = eval("Key." + key1.lower())
with keyboard.pressed(key1):
key2 = eval("Key." + key2.lower())
keyboard.press(key2)
keyboard.release(key2)
else:
key1 = eval("Key." + key1.lower())
with keyboard.pressed(key1):
keyboard.press(key2)
keyboard.release(key2)
else:
if value.lower() in special_keys_list:
value = eval("Key." + value.lower())
keyboard.press(value)
keyboard.release(value)
else:
keyboard.press(value)
keyboard.release(value)
def control_keypad():
while True:
time.sleep(60)
keyboard = Controller()
time.sleep(2)
keyboard.press(Key.space)
keyboard.release(Key.space)
time.sleep(2)
keyboard.press('a')
keyboard.release('a')
time.sleep(2)
keyboard.press('A')
keyboard.release('A')
time.sleep(2)
with keyboard.pressed(Key.shift):
keyboard.press('a')
keyboard.release('a')
time.sleep(2)
keyboard.type('Hello World!')
def auto_type(id, password, joinposn):
"""Executes actions on Zoom.exe"""
print("id:", id)
keyboard = KB_Controller()
mouse = Mouse_Controller()
with keyboard.pressed(Key.alt_l):
keyboard.press(Key.tab)
keyboard.release(Key.tab)
time.sleep(0.5) #
mouse.position = joinposn
mouse.click(Button.left)
time.sleep(1) #
keyboard.type(id)
keyboard.press(Key.enter)
keyboard.release(Key.enter)
time.sleep(3.5) #
keyboard.type(password)
keyboard.press(Key.enter)
keyboard.release(Key.enter)
def keyboardControllTest():
cKeyboard = Controller()
# Press and release space
cKeyboard.press(Key.space)
cKeyboard.release(Key.space)
# Type a lower case A; this will work even if no key on the
# physical keyboard is labelled 'A'
cKeyboard.press('a')
cKeyboard.release('a')
# Type two upper case As
cKeyboard.press('A')
cKeyboard.release('A')
with cKeyboard.pressed(Key.shift):
cKeyboard.press('a')
cKeyboard.release('a')
# Type 'Hello World' using the shortcut type method
cKeyboard.type('Hello World')
class Loop:
def __init__(self, flag, time, queue, type=None, dirs=None):
self.flag = flag
self.dirs = dirs
self.time = time
self.queue = queue
self.f**k = F**k(type)
self.k = Controller()
def run(self):
while True:
if self.queue.empty() == False:
return
if self.flag == '网站':
try:
str = self.f**k.run()
except Exception:
return
self.out(str)
sleep(self.time)
elif self.flag == '字典':
self.loop()
def loop(self): #字典
for one in self.dirs:
self.out(one)
sleep(self.time)
def out(self, str):
copy(str)
self.ctrl_v_enter()
def ctrl_v_enter(self):
with self.k.pressed(Key.ctrl):
self.k.press('v')
self.k.release('v')
self.k.press(Key.enter)
self.k.release(Key.enter)
def process_links(self, links: list) -> None:
"""
spams the prepared game links
links passed on from self.process_arguments
:param links: list
:return: None
"""
keyboard = Controller()
for _ in range(random.randint(self.min_spam, self.max_spam)):
for link in links:
pyperclip.copy(link)
keyboard.press(Key.enter)
keyboard.release(Key.enter)
self.timer()
with keyboard.pressed(Key.ctrl_l):
self.timer()
keyboard.press("v")
keyboard.release("v")
self.timer()
keyboard.press(Key.enter)
keyboard.release(Key.enter)
self.timer()
def StartCopy():
import sys
keyboard = Controller()
with keyboard.pressed(Key.ctrl):
keyboard.press('c')
keyboard.release('c')
app = QtGui.QApplication(sys.argv)
window = DictionBox()
mouse = pymouse.PyMouse()
x, y = mouse.position()
if x - 130 >= 0:
x = x - 139
y = y + 20
window.move(x, y)
window.show()
app.quit()
app.exec_()
while True:
keylistener = KeyListener()
keylistener.addKeyListener("L_CTRL+m", StartCopy)
handle = Handler(keylistener)
class Setting():
def __init__(self):
# Collect events until released
self.mouseListener = mouse.Listener(on_click=self.onLongClick)
self.keyboard = Controller()
self.ori_x = 0
self.ori_y = 0
self.t1 = time.time()
self._default_value = {'author': 'Elliott Zheng',
'version': version,
'is_listen': False,
'is_copy': False,
'is_dete': False,
'stay_top': True,
'continus': False,
'smart_dict': True,
'is_main': True,
'pixel_size': 15,
'source': 'english',
'target': 'chinese (simplified)',
'last_ask': 0
}
self.value = self._default_value
self.filepath = os.path.expanduser('~/copytranslator.json')
self.load()
self.taskbar = TaskBarIcon(self)
self.mainFrame = MainFrame(self)
self.subFrame = SubFrame(self)
self.mainFrame.Centre()
# self.mainFrame.Show()
self.state = MyPanel.NOT_LISTEN
self.translator = Translator(service_urls=['translate.google.cn'])
self.youdao_dict = YoudaoSpider()
self.src = ''
self.last_append = ''
self.result = ''
self.patterns = [re.compile(r'([?!.])[ ]?\n'), re.compile(r'([？！。])[ \n]')] # 前面一个处理英语语系的，后面一个可以处理汉语系。
self.pattern2 = re.compile(r'\$([?？！!.。])\$')
self.is_word = False
self.stored_source = self.source
self.initialize()
UpdateThread(self).start()
def RefreshState(self):
if self.continus and self.is_listen and self.is_copy:
self.state = MyPanel.INCERMENT_COPY
elif self.continus and self.is_listen:
self.state = MyPanel.INCERMENT_LISTEN
elif self.is_listen and self.is_copy:
self.state = MyPanel.LISTEN_COPY
elif self.is_listen:
self.state = MyPanel.LISTEN
else:
self.state = MyPanel.NOT_LISTEN
self.subFrame.panel.SetState(self.state)
return self.state
def initialize(self):
self.continus = self.continus
self.stay_top = self.stay_top
self.is_listen = self.is_listen
self.is_dete = self.is_dete
self.is_copy = self.is_copy
self.is_main = self.is_main
self.is_dict = self.is_dict
@property
def source(self):
return self.value['source']
@property
def target(self):
return self.value['target']
def save_config(self):
self.value['source'] = self.mainFrame.tochoice.GetString(self.mainFrame.fromchoice.GetSelection())
self.value['target'] = self.mainFrame.tochoice.GetString(self.mainFrame.tochoice.GetSelection())
self.save_to(self.filepath)
def get_normalized_append(self, src):
src = src.replace('\r\n', '\n')
src = src.replace('-\n', '')
for pattern in self.patterns:
src = pattern.sub(r'$\1$', src)
src = src.replace('\n', ' ')
src = self.pattern2.sub(r'\1\n', src)
return src
def get_normalized_src(self, append):
if self.continus and self.src != '':
return self.src + ' ' + append
else:
return append
def OnExit(self, event):
self.save_config()
self.mainFrame.Destroy()
self.subFrame.Destroy()
self.taskbar.Destroy()
def paste(self, event):
self.setSrc(self.last_append)
def setSrc(self, append):
self.src = self.get_normalized_src(append)
self.mainFrame.srcText.SetValue(self.src)
self.subFrame.destText.Clear()
self.mainFrame.destText.Clear()
def setResult(self, string, show=True):
self.result = "" + string.replace('\n', '\r\n') + '\r\n'
self.mainFrame.destText.SetValue(self.result)
if show:
self.subFrame.destText.SetValue(self.result)
def getTgtLang(self):
return LANGCODES[self.mainFrame.tochoice.GetString(self.mainFrame.tochoice.GetSelection())]
def getSrcLang(self):
return LANGCODES[self.mainFrame.fromchoice.GetString(self.mainFrame.fromchoice.GetSelection())]
def getExpSrc(self):
return self.mainFrame.srcText.GetValue()
def getResult(self):
return self.result
def smart_translate(self, event):
show = (event != False)
src = self.translator.detect(self.src).lang.lower()
dest = self.getTgtLang()
should_src = src
if self.is_dete:
self.mainFrame.fromchoice.SetSelection(self.mainFrame.fromchoice.FindString(LANGUAGES[src]))
else:
should_src = self.getSrcLang()
if src == dest:
src, dest = dest, should_src
else:
src = should_src
if self.result != self.src:
self.setResult(self.translator.translate(self.src, src=src, dest=dest).text, show)
def youdao_smart_dict(self, event):
if self.result != self.src:
result = self.youdao_dict.get_result(self.src)
self.set_word_result(result)
def set_word_result(self, result):
self.subFrame.destText.show_result(result)
self.mainFrame.destText.SetValue(self.result)
def translateCtrl(self, event):
self.setSrc(self.getExpSrc())
TranslateThread(self, True).start()
def check_valid(self):
string = smart_clipboard.paste()
if self.result == string or self.src == string or string == '':
return False
append = self.get_normalized_append(string)
if self.last_append != append:
self.is_word = self.is_dict and (len(append.split()) <= 3) and not check_contain_chinese(
append) and not self.continus
return True
return False
def translateCopy(self, event):
if self.check_valid():
self.last_append = self.get_normalized_append(smart_clipboard.paste())
self.paste(event)
if not self.is_word:
TranslateThread(self, True).start()
else:
TranslateThread(self, False).start()
DictThread(self).start()
def Copy(self, event):
smart_clipboard.copy(self.result)
def OnTimer(self, event):
self.translateCopy(event)
def ChangeMode(self, event):
if event.Id == self.taskbar.ID_Main:
self.is_main = True
elif event.Id == self.taskbar.ID_Focus:
self.is_main = False
else:
self.is_main = not self.is_main
self.subFrame.Show(not self.is_main)
self.mainFrame.Show(self.is_main)
def clear(self, event=None):
self.setSrc('')
self.setResult('')
smart_clipboard.copy('')
self.last_append = ''
def SwitchMode(self, event):
self.is_main = not self.is_main
def OnTaskBarLeftDClick(self, event):
if self.is_main:
frame = self.mainFrame
else:
frame = self.subFrame
if frame.IsIconized():
frame.Iconize(False)
if not frame.IsShown():
frame.Show(True)
frame.Raise()
def BossKey(self, evt):
if self.is_main:
frame = self.mainFrame
else:
frame = self.subFrame
frame.Iconize(not frame.IsIconized())
if not frame.IsIconized():
frame.Show(True)
frame.Raise()
def simulateCopy(self):
with self.keyboard.pressed(Key.ctrl):
self.keyboard.press('c')
self.keyboard.release('c')
def onLongClick(self, x, y, button, pressed):
if pressed:
self.t1 = time.time()
self.ori_x = x
self.ori_y = y
else:
if time.time() - self.t1 > 0.3 and abs(self.ori_y - y) < 3 and abs(self.ori_x - x) < 3:
self.simulateCopy()
def load(self):
if not os.path.exists(self.filepath):
self.save_to(self.filepath)
return self
myfile = open(self.filepath, 'r')
value = json.load(myfile)
myfile.close()
if value['version'] < self['version']:
os.remove(self.filepath)
self.save_to(self.filepath)
return self
self.value = value
return self
def save_to(self, filepath):
myfile = open(filepath, 'w')
json.dump(self.value, myfile, indent=4)
myfile.close()
def __getitem__(self, item):
return self.value[item]
def __setitem__(self, key, value):
self.value[key] = value
@property
def is_listen(self):
return self['is_listen']
@is_listen.setter
def is_listen(self, value):
self['is_listen'] = value
self.mainFrame.listenCheck.SetValue(value)
if value:
self.mainFrame.timer.Start(2000) # 设定时间间隔为1000毫秒,并启动定时器
self.mouseListener = mouse.Listener(on_click=self.onLongClick)
self.mouseListener.start()
else:
self.mainFrame.timer.Stop()
self.mouseListener.stop()
self.RefreshState()
def ReverseListen(self, event):
self.is_listen = not self.is_listen
@property
def is_copy(self):
return self['is_copy']
@is_copy.setter
def is_copy(self, value):
self['is_copy'] = value
self.mainFrame.copyCheck.SetValue(self.is_copy)
self.RefreshState()
def ReverseCopy(self, event):
self.is_copy = not self.is_copy
@property
def is_dete(self):
return self['is_dete']
@is_dete.setter
def is_dete(self, value):
self['is_dete'] = value
self.mainFrame.detectCheck.SetValue(value)
if value:
self.stored_source = self.mainFrame.tochoice.GetString(self.mainFrame.fromchoice.GetSelection())
self.mainFrame.fromchoice.Disable()
self.mainFrame.fromlabel.SetLabel("Detected Language")
else:
self.mainFrame.fromchoice.SetSelection(self.mainFrame.fromchoice.FindString(self.stored_source))
self.mainFrame.fromchoice.Enable()
self.mainFrame.fromlabel.SetLabel("Source Language")
def ReverseDete(self, event):
self.is_dete = not self.is_dete
@property
def stay_top(self):
return self['stay_top']
@stay_top.setter
def stay_top(self, value):
self['stay_top'] = value
self.mainFrame.topCheck.SetValue(value)
if value:
self.subFrame.SetWindowStyle(wx.STAY_ON_TOP | SubFrame.subStyle)
self.mainFrame.SetWindowStyle(wx.STAY_ON_TOP | MainFrame.mainStyle)
else:
self.subFrame.SetWindowStyle(SubFrame.subStyle)
self.mainFrame.SetWindowStyle(MainFrame.mainStyle)
def ReverseStayTop(self, event):
self.stay_top = not self.stay_top
@property
def continus(self):
return self['continus']
@continus.setter
def continus(self, value):
self['continus'] = value
self.mainFrame.continusCheck.SetValue(value)
self.RefreshState()
def ReverseContinus(self, event):
self.clear()
self.continus = not self.continus
@property
def is_main(self):
return self['is_main']
@is_main.setter
def is_main(self, value):
self['is_main'] = value
self.subFrame.Show(not value)
self.mainFrame.Show(value)
@property
def pixel_size(self):
return self['pixel_size']
@pixel_size.setter
def pixel_size(self, value):
self['pixel_size'] = value
@property
def is_dict(self):
return self['smart_dict']
@is_dict.setter
def is_dict(self, value):
self['smart_dict'] = value
self.mainFrame.dictCheck.SetValue(value)
def ReverseDict(self, event):
self.is_dict = not self.is_dict
class VirtualMouse:
def __init__(self, eeg: EEG, model: MLModel, mouse_actions: List[str]):
self.mouse = Controller_mouse()
self.keyboard = Controller_keyboard()
self.actions = {'right click': self.right_click, 'left click': self.left_click,
'double click': self.double_click, 'ctrl + c': self.ctrl_c, 'ctrl + v': self.ctrl_v,
'left press': self.left_press, 'left release': self.left_release,
'scroll up': self.scroll_up, 'scroll down': self.scroll_down}
self.eeg: EEG = eeg
self.model: MLModel = model
# Assert all actions from the config object exist in the virtual mouse object
self.assert_actions(mouse_actions)
def assert_actions(self, config_actions: List[str]):
"""
The method assert all the action in ConfigMouse exist in VirtualMouse
:param config_actions: list with all the actions which represent to user
:return:
"""
for a in config_actions:
if (a is not 'None') and (a.lower() not in self.actions.keys()):
raise ValueError(f'The action `{a}` is in ConfigMouse but not implemented in VirtualMouse')
def monitor(self, r: float, counter_limit: int, interval: float) -> bool:
x_center, y_center = self.mouse.position
counter = 0
while counter < counter_limit:
x, y = self.mouse.position
if ((x - x_center) ** 2) + ((y - y_center) ** 2) < r ** 2:
counter += 1
# print(f'Counter: {counter}')
else:
x_center, y_center = x, y
counter = 0
time.sleep(interval)
print('No movement monitored...')
return True
def predict(self, buffer_time: int) -> int:
"""
Predict the label the user imagined.
:param buffer_time: time of data acquisition in seconds
:return:
"""
# todo: what about the threshold? predict according the first label?
# Sleep in order to get EEG data
print('Predicting label...')
time.sleep(buffer_time)
# Data Acquisition
data = self.eeg.get_channels_data()
# Predict label
prediction = self.model.online_predict(data, eeg=self.eeg)
return prediction
def execute(self, action: str):
"""
The method execute the given action
:param action: the action to execute as str
:return:
"""
# Debug
print(f'Executing action: {action}')
if action is not None:
self.actions[action.lower()]()
def right_click(self):
self.mouse.press(Button.right)
self.mouse.release(Button.right)
def left_click(self):
self.mouse.press(Button.left)
self.mouse.release(Button.left)
def double_click(self):
self.mouse.click(Button.left, 2)
def left_press(self):
self.mouse.press(Button.right)
def left_release(self):
self.mouse.release(Button.left)
def scroll_up(self):
self.mouse.scroll(0, 2)
def scroll_down(self):
self.mouse.scroll(0, -2)
def ctrl_c(self):
# Choose the file under the cursor
self.mouse.press(Button.left)
self.mouse.release(Button.left)
# ctrl+c it!
with self.keyboard.pressed(Key.ctrl):
self.keyboard.press('c')
self.keyboard.release('c')
def ctrl_v(self):
# Choose the file under the cursor
self.mouse.press(Button.left)
self.mouse.release(Button.left)
# ctrl+v it!
with self.keyboard.pressed(Key.ctrl):
self.keyboard.press('v')
self.keyboard.release('v')
class Setting():
def __init__(self):
# Collect events until released
self.mouseListener = mouse.Listener(on_click=self.onLongClick)
self.keyboard = Controller()
self.IsListen = False
self.IsCopy = False
self.IsDete = False
self.StayTop = False
self.mainFrame = MainFrame(self)
self.subFrame = SubFrame(self)
self.taskbar = TaskBarIcon(self)
self.IsMain = True
self.mainFrame.Centre()
self.mainFrame.Show()
self.valid = False
self.translator = Translator(service_urls=['translate.google.cn'])
self.src = ''
self.result = ''
self.patterns = [
re.compile(r'([?!.])[ ]?\n'),
re.compile(r'([？！。])[ \n]')
] #前面一个处理英语语系的，后面一个可以处理汉语系。
self.pattern2 = re.compile(r'\$([?？！!.。])\$')
def normalize(self, src):
src = src.replace('\r\n', '\n')
src = src.replace('-\n', '')
for pattern in self.patterns:
src = pattern.sub(r'$\1$', src)
src = src.replace('\n', ' ')
src = self.pattern2.sub(r'\1\n', src)
return src
def paste(self, event):
self.setSrc(pyperclip.paste())
def ReverseListen(self, event):
self.IsListen = not self.IsListen
self.mainFrame.listenCheck.SetValue(self.IsListen)
if self.IsListen:
self.mainFrame.timer.Start(3000) # 设定时间间隔为1000毫秒,并启动定时器
self.mouseListener.start()
else:
self.mainFrame.timer.Stop()
def ReverseCopy(self, event):
self.IsCopy = not self.IsCopy
self.mainFrame.copyCheck.SetValue(self.IsCopy)
def ReverseDete(self, event):
self.IsDete = not self.IsDete
self.mainFrame.detectCheck.SetValue(self.IsDete)
if self.IsDete:
self.mainFrame.fromchoice.Disable()
self.mainFrame.fromlabel.SetLabel("Detected language")
else:
self.mainFrame.fromchoice.Enable()
self.mainFrame.fromlabel.SetLabel("Source language")
def ReverseStayTop(self, event):
self.StayTop = not self.StayTop
if self.StayTop:
self.subFrame.SetWindowStyle(wx.STAY_ON_TOP | SubFrame.subStyle)
self.mainFrame.SetWindowStyle(wx.STAY_ON_TOP | MainFrame.mainStyle)
else:
self.subFrame.SetWindowStyle(SubFrame.subStyle)
self.mainFrame.SetWindowStyle(MainFrame.mainStyle)
def setSrc(self, string):
self.src = self.normalize(string)
self.mainFrame.srcText.SetValue(self.src)
def setResult(self, string):
self.result = "" + string.replace('\n', '\r\n') + '\r\n'
self.mainFrame.destText.SetValue(self.result)
self.subFrame.destText.SetValue(self.result)
def getTgtLang(self):
return LANGCODES[self.mainFrame.tochoice.GetString(
self.mainFrame.tochoice.GetSelection())]
def getSrcLang(self):
return LANGCODES[self.mainFrame.fromchoice.GetString(
self.mainFrame.fromchoice.GetSelection())]
def getExpSrc(self):
return self.mainFrame.srcText.GetValue()
def getResult(self):
return self.result
def translate(self, event):
src = self.translator.detect(self.src).lang
if self.IsDete:
self.mainFrame.fromchoice.SetSelection(
self.mainFrame.fromchoice.FindString(LANGUAGES[src.lower()]))
else:
src = self.getSrcLang()
dest = self.getTgtLang()
if self.result != self.src:
self.setResult(
self.translator.translate(self.src, src=src, dest=dest).text)
self.valid = True
else:
self.valid = False
def translateCtrl(self, event):
self.setSrc(self.getExpSrc())
self.translate(event)
def translateCopy(self, event):
if self.result != pyperclip.paste() and self.src != self.normalize(
pyperclip.paste()):
self.paste(event)
self.translate(event)
else:
self.valid = False
def Copy(self, event):
pyperclip.copy(self.result)
def OnTimer(self, event):
self.translateCopy(event)
if self.valid and self.IsCopy:
self.Copy(event)
def ChangeMode(self, event):
if event.Id == self.taskbar.ID_Main:
self.IsMain = True
elif event.Id == self.taskbar.ID_Focus:
self.IsMain = False
else:
self.IsMain = not self.IsMain
self.subFrame.Show(not self.IsMain)
self.mainFrame.Show(self.IsMain)
def SwitchMode(self, event):
self.IsMain = not self.IsMain
self.subFrame.Show(not self.IsMain)
self.mainFrame.Show(self.IsMain)
def OnTaskBarLeftDClick(self, event):
if self.IsMain:
frame = self.mainFrame
else:
frame = self.subFrame
if frame.IsIconized():
frame.Iconize(False)
if not frame.IsShown():
frame.Show(True)
frame.Raise()
def BossKey(self, evt):
if self.IsMain:
frame = self.mainFrame
else:
frame = self.subFrame
frame.Iconize(not frame.IsIconized())
if not frame.IsIconized():
frame.Show(True)
frame.Raise()
def simulateCopy(self):
with self.keyboard.pressed(Key.ctrl):
self.keyboard.press('c')
self.keyboard.release('c')
def onLongClick(self, x, y, button, pressed):
global t1, ori_x, ori_y
if pressed:
t1 = time.time()
ori_x = x
ori_y = y
else:
if time.time() - t1 > 0.1 and abs(ori_y - y) < 3 and abs(ori_x -
x) < 3:
self.simulateCopy()
