class MouseListener:
def __init__(self, output_file: str):
self.file = None
try:
self.file = open(output_file, mode='w', encoding='utf-8')
except ValueError:
print('error : text.txt doesn\' exists .', file=sys.stderr)
self.listener = Listener(on_move=self.on_move,
on_click=self.on_click)
def on_move(self, x, y):
self.file.write(f'mouse move: ({x},{y})\n')
def on_click(self, x, y, button, pressed):
if pressed:
self.file.write(f'mouse pressed {button}: ({x},{y})\n')
else:
self.file.write(f'mouse released {button}: ({x},{y})\n')
def start(self):
self.listener.start()
self.listener.join()
def stop(self):
self.listener.stop()
self.file.close()
def listen_event():
def on_click(x, y, button, pressed):
# print('{0} {1} at {1}'.format(
# button,
# 'Pressed' if pressed else 'Released',
# (x, y)))
if f'{button}' == 'Button.middle' and pressed:
print('Button Middle pressed.')
tiles = realtime_shot()
sync(tiles)
# if keyboard.is_pressed('1'):
# return False
def on_press(key):
# print("Key pressed: {0}".format(key))
if key == Key.esc:
print("Key pressed: {0}".format(key))
# return False
KeyboardListener.stop()
MouseListener.stop()
keyboard_listener = KeyboardListener(on_press=on_press)
mouse_listener = MouseListener(on_click=on_click)
keyboard_listener.start()
mouse_listener.start()
keyboard_listener.join()
mouse_listener.join()
def roll_manager(self, area):
x, y, w, h = area
self.mode = 1
def on_click(x, y, button, pressed):
print(x, y, button)
if area[0] < x < area[0] + area[2] and area[1] < y < area[1] + area[3] and not pressed:
self.mode = 1
lis.stop()
def on_scroll(x, y, button, pressed):
self.mode = 0
lis.stop()
self.tips = TipsShower("单击自动滚动;\n或手动下滚;")
if x < QApplication.desktop().width() - x - w:
self.tips.move(x + w, y)
else:
self.tips.move(x - self.tips.width(), y)
self.showrect.setGeometry(x, y, w, h)
self.showrect.show()
QApplication.processEvents()
lis = MouseListenner(on_click=on_click, on_scroll=on_scroll)
lis.start()
print("等待用户开始")
lis.join()
lis.stop()
if self.mode:
print("auto_roll")
self.auto_roll(area)
else:
print("scroll_to_roll")
self.scroll_to_roll(area)
def on_click(x, y, button, pressed):
if pressed:
logging.info ("Mouse clicked at ({1}, {0}) with {2}".format(x, y, button))
def on_scroll(x, y, dx, dy):
logging.info ("Mouse scrolled at ({0}, {1})({2}, {3})".format(x, y, dx, dy))
with Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll) as listener:
Listener.join()
class Recorder:
_filename: str
_listener: Listener
_output: TextIO
_start_time: datetime
_stop_time: datetime
def __init__(self, filename: str):
self._filename = filename
self._listener = Listener(on_click=self._on_click)
signal.signal(signal.SIGINT, self._signal_handler)
self._output = open(self._filename, 'w')
self._write("MACRO macro_name {")
def record(self):
with self._listener:
self._listener.join()
def _signal_handler(self, sig, frame):
print('Exiting...')
self._listener.stop()
self._write("}")
self._output.close()
def _write(self, data: str):
self._output.write(f"{data}\n")
self._output.flush()
def _get_second_delta(self) -> Optional[int]:
try:
return int((self._stop_time - self._start_time).total_seconds())
except (AttributeError, ValueError):
return None
def _on_click(self, x, y, button, pressed):
self._stop_time = datetime.now()
x = int(x)
y = int(y)
if self._get_second_delta() is not None \
and self._get_second_delta() > 0:
print(f"Wait {self._get_second_delta()} seconds")
self._write(f" WAIT {self._get_second_delta()}s")
if pressed:
print(f"Mouse clicked at ({x}, {y})")
self._write(f" CLICK {x},{y}")
self._start_time = datetime.now()
def roll_manager(self, area): # 滚动截屏控制器,控制滚动截屏的模式(自动还是手动滚)
x, y, w, h = area
self.mode = 1
def on_click(x, y, button, pressed): # 用户点击了屏幕说明用户想自动滚
print(x, y, button)
if button == mouse.Button.left:
if area[0] < x < area[0] + area[2] and area[
1] < y < area[1] + area[3] and not pressed:
self.mode = 1
lis.stop()
elif button == mouse.Button.right:
self.mode = 2
lis.stop()
def on_scroll(x, y, button, pressed): # 用户滚动了鼠标说明用户想要手动滚
self.mode = 0
lis.stop()
self.rollermask = roller_mask(area) # 滚动截屏遮罩层初始化
# self.showrect.setGeometry(x, y, w, h)
# self.showrect.show()
pix = QApplication.primaryScreen().grabWindow(
QApplication.desktop().winId(), x, y, w, h) # 先截一张图片
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
QApplication.processEvents()
lis = MouseListenner(on_click=on_click,
on_scroll=on_scroll) # 鼠标监听器初始化并启动
lis.start()
print("等待用户开始")
lis.join()
lis.stop()
if self.mode == 1: # 判断用户选择的模式
print("auto_roll")
self.auto_roll(area)
elif self.mode == 2:
print("exit roller")
return 1
else:
print("scroll_to_roll")
self.scroll_to_roll(area)
self.showm_signal.emit("长截图完成")
self.rollermask.hide()
return 0
def roll_manager(self, area):
x, y, w, h = area
self.mode = 1
def on_click(x, y, button, pressed):
print(x, y, button)
if area[0] < x < area[0] + area[2] and area[
1] < y < area[1] + area[3] and not pressed:
self.mode = 1
lis.stop()
def on_scroll(x, y, button, pressed):
self.mode = 0
lis.stop()
self.rollermask = roller_mask(area)
# self.showrect.setGeometry(x, y, w, h)
# self.showrect.show()
pix = QApplication.primaryScreen().grabWindow(
QApplication.desktop().winId(), x, y, w, h)
newimg = Image.fromqpixmap(pix)
img = cv2.cvtColor(asarray(newimg), cv2.COLOR_RGB2BGR)
self.img_list.append(img)
QApplication.processEvents()
lis = MouseListenner(on_click=on_click, on_scroll=on_scroll)
lis.start()
print("等待用户开始")
lis.join()
lis.stop()
if self.mode:
print("auto_roll")
self.auto_roll(area)
else:
print("scroll_to_roll")
self.scroll_to_roll(area)
self.showm_signal.emit("长截图完成")
self.rollermask.hide()
inputs.append(mouse_scroll)
count += 1
if count >= 10:
count = 0
save(inputs)
inputs = []
def save(keys):
with open("screen_recording.txt", "a") as file:
for key in keys:
_key = str(key).replace("'", "")
if _key.find("space") > 0:
file.write("\n")
elif _key.find("key") == -1:
file.write(_key)
# Setup the listener threads
keyboard_listener = KeyboardListener(on_press=on_press, on_release=on_release)
mouse_listener = MouseListener(on_move=on_move,
on_click=on_click,
on_scroll=on_scroll)
# Start the threads and join them so the script doesn't end early
keyboard_listener.start()
mouse_listener.start()
keyboard_listener.join()
mouse_listener.join()
# see https://pythonhosted.org/pynput/ for details of the library
def set_coordinates(self):
listener = Listener(on_move=self.do_nothing(),
on_click=self.click,
on_scroll=self.do_nothing())
with listener:
listener.join()
from pynput.mouse import Listener
def on_move(x, y):
print('Mouse moved to {0}'.format((x, y))) #something about curley brackets and string exeptions
def on_click(x, y, button, pressed):
print('{0} at {1}'.format('pressed' if pressed else 'released',(x, y)))
click_location = (x,y) #actually prints the location of the mouse when clicked
print('Click location =',click_location)
print('exeted listener')
Listener.stop() #Gotta remember the cap
def on_scroll(x, y, dx, dy ):
print('mouse scrolled {0} at {1}'.format('down' if dy < 0 else 'up',(x, y)))
with Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll) as Listener:
Listener.join()
input('press ENTER to exit')
#############
class DataCollector(MouseListener, KeyboardListener):
def __init__(self, game_object):
self.game_object = game_object
self.events_list_array = []
self.start_time = time.time()
self.interval = 0.1
self.mouse_count = 0
self.mouse = Controller()
self.keyboard_listener = KeyboardListener(on_press=self.on_press,
on_release=self.on_release)
self.mouse_listener = MouseListener(on_move=self.on_move,
on_click=self.on_click,
on_scroll=self.on_scroll)
self.keyboard_listener.start()
self.mouse_listener.start()
self.listener_on(True)
def listener_on(self, statment):
if statment == True:
self.keyboard_listener.join()
self.mouse_listener.join()
elif statment == False:
self.keyboard_listener.stop()
self.mouse_listener.stop()
def _current_time(self):
clock = time.time() - self.start_time
clock = round(clock, 3)
return clock
def _current_day(self):
dt_date = datetime.datetime.now()
return dt_date.strftime("%d_%m_%Y")
def _keyboard_press(self, key):
item = [self._current_time(), str(key), self.mouse.position]
self.events_list_array.append(item)
def _mouse_press(self, x, y, button, pressed):
self.mouse_count += 1
if self.mouse_count % 5 == 0:
self._is_game_over()
self.mouse_count = 0
item = [self._current_time(), str(button), (x, y)]
self.events_list_array.append(item)
def _is_game_over(self):
self.game_object.is_game_still_in_proggress()
if self.game_object.is_game_procces_active == False:
self.listener_on(False)
def save(self):
#check data
if len(self.events_list_array) == 0:
raise Exception("No data recorded")
print(self.events_list_array)
return self.events_list_array, self.start_time
#keyboard
def on_press(self, key):
self._keyboard_press(key)
def on_release(self, key):
pass
#mouse
def on_move(self, x, y):
pass
def on_click(self, x, y, button, pressed):
if pressed:
self._mouse_press(x, y, button, pressed)
else:
pass
def on_scroll(self, x, y, dx, dy):
pass
#===============================def capture rec==============================================
print('INFO: draw rectangle')
rec = [] # xy left upper corner,xy right lower corner
def on_click(x, y, button, pressed):
if pressed:
print ('Mouse clicked at ({0}, {1}) with {2}'.format(x, y, button))
rec.append(x)
rec.append(y)
print('rec:',rec)
if len(rec)==4:
listener.stop()
listener = Listener(on_click=on_click)
listener.start()
listener.join()
#===============================grab image===================================================
def ai():
import tflite_runtime.interpreter as tflite
from imutils.video import FPS
from pycoral.adapters import common
from operator import itemgetter
interpreter = tflite.Interpreter('tflite/w_tflite_model_edgetpu.tflite',
experimental_delegates=[tflite.load_delegate('libedgetpu.so.1')])
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print("INFO: video recording")
# out = cv2.VideoWriter('avcrosetta.avi',cv2.VideoWriter_fourcc(*'XVID'), 25, (240,136))
class EventListener:
def __init__(self, filename):
# Setup the listener threads
self.keyboard_listener = KeyboardListener(on_press=self.on_press,
on_release=self.on_release)
self.mouse_listener = MouseListener(on_move=self.on_move,
on_click=self.on_click,
on_scroll=self.on_scroll)
self.count = 0
self.delay = time.time()
self.events = []
self.filename = filename
def start(self):
self.keyboard_listener.start()
self.mouse_listener.start()
self.keyboard_listener.join()
self.mouse_listener.join()
def get_delay(self):
previousTime = self.delay
self.delay = time.time()
return round(time.time() - previousTime, 3)
def clean_keycode(self, code):
if (code[0] == "'"):
return code[1:-1]
return code
def on_press(self, key):
try:
# Write normal keys
event = {
"id": self.count,
"kind": "key_pressed",
"key": key.char,
"delay": self.get_delay()
}
print("Key pressed: {0}".format(key))
self.events.append(event)
self.count += 1
except AttributeError:
if (key == keyboard.Key.esc
): # save recording and and stop listening
Storage().write(self.events, "../macros/" + self.filename)
self.keyboard_listener.stop()
self.mouse_listener.stop()
# Write Special Keys
print(key)
event = {
"id": self.count,
"kind": "special_key_pressed",
"key": str(key),
"delay": self.get_delay()
}
self.events.append(event)
print('special key {0} pressed'.format(key))
self.count += 1
def on_click(self, x, y, button, pressed):
if pressed:
event = {
"id": self.count,
"kind": "mouse_click_left",
"x": x,
"y": y,
"delay": self.get_delay()
}
self.events.append(event)
self.count += 1
else:
print('Mouse released at ({0}, {1}) with {2}'.format(x, y, button))
def on_scroll(self, x, y, dx, dy):
print('Mouse scrolled at ({0}, {1})({2}, {3})'.format(x, y, dx, dy))
def on_release(self, key):
pass
def on_move(self, x, y):
pass
class Events:
def __init__(self, log_filename):
self.host = '127.0.0.1' # The server's hostname or IP address
self.port = 12001 # The port used by the server
if log_filename != "": self.log = open(log_filename, "w")
else: self.log = None
# Create the key map to match to how keyboard.py to store each key board buttons
# multiple names for one key
key_map = {
KeyCode.from_char('~'): '`',
KeyCode.from_char('`'): '`',
KeyCode.from_char('!'): '1',
KeyCode.from_char('@'): '2',
KeyCode.from_char('#'): '3',
KeyCode.from_char('$'): '4',
KeyCode.from_char('%'): '5',
KeyCode.from_char('^'): '6',
KeyCode.from_char('&'): '7',
KeyCode.from_char('*'): '8',
KeyCode.from_char('('): '9',
KeyCode.from_char(')'): '0',
KeyCode.from_char('-'): '_',
KeyCode.from_char('_'): '_',
KeyCode.from_char('='): '=',
KeyCode.from_char('+'): '=',
KeyCode.from_char('['): '[',
KeyCode.from_char('{'): '[',
KeyCode.from_char(']'): ']',
KeyCode.from_char('}'): ']',
KeyCode.from_char('\\'): '\\',
KeyCode.from_char('|'): '\\',
KeyCode.from_char(';'): ';',
KeyCode.from_char(':'): ';',
KeyCode.from_char("'"): "'",
KeyCode.from_char('"'): "'",
KeyCode.from_char(','): ',',
KeyCode.from_char('<'): ',',
KeyCode.from_char('.'): '.',
KeyCode.from_char('>'): '.',
KeyCode.from_char('/'): '/',
KeyCode.from_char('?'): '/',
}
# letters
for i in range(26):
l = chr(ord('a') + i)
u = chr(ord('A') + i)
ctrl_combo = chr(i + 1)
key_map[KeyCode.from_char(l)] = l
key_map[KeyCode.from_char(u)] = u
key_map[KeyCode.from_char(ctrl_combo)] = u
# CTRL + key
key_map[KeyCode.from_char(chr(27))] = '['
key_map[KeyCode.from_char(chr(28))] = '\\'
key_map[KeyCode.from_char(chr(29))] = ']'
key_map[KeyCode.from_char(chr(30))] = '^'
key_map[KeyCode.from_char(chr(31))] = '-'
# ALT + key - to do
key_map[KeyCode.from_char('¡')] = '1'
key_map[KeyCode.from_char('™')] = '2'
key_map[KeyCode.from_char('£')] = '3'
# Key enum
key_map[Key.esc] = 'esc'
key_map[Key.f1] = 'f1'
key_map[Key.f2] = 'f2'
key_map[Key.f3] = 'f3'
key_map[Key.f4] = 'f4'
key_map[Key.f5] = 'f5'
key_map[Key.f6] = 'f6'
key_map[Key.f7] = 'f7'
key_map[Key.f8] = 'f8'
key_map[Key.f9] = 'f9'
key_map[Key.f10] = 'f10'
key_map[Key.f11] = 'f11'
key_map[Key.f12] = 'f12'
key_map[Key.home] = 'home'
key_map[Key.backspace] = 'backspace'
key_map[Key.tab] = 'tab'
key_map[Key.caps_lock] = 'capslock'
key_map[Key.enter] = 'enter'
key_map[Key.shift] = 'shift'
key_map[Key.shift_r] = 'shift'
key_map[Key.ctrl] = 'ctrl'
key_map[Key.alt] = 'alt'
key_map[Key.cmd] = 'command'
key_map[Key.space] = 'space'
key_map[Key.cmd_r] = 'command'
key_map[Key.alt_r] = 'alt'
key_map[Key.left] = 'left'
key_map[Key.right] = 'right'
key_map[Key.up] = 'up'
key_map[Key.down] = 'down'
# NUMBER
for i in range(10):
c = chr(ord('0') + i)
key_map[KeyCode.from_char(c)] = i
self.key_map = key_map
# get all key values
self.is_pressed = {}
for val in self.key_map.values():
self.is_pressed[val] = False
# get screen and image size
self.screen_width, self.screen_hegiht = pyautogui.size()
im = pyautogui.screenshot()
self.img_width, self.img_height = im.size
self.width_ratio = self.img_width / self.screen_width
self.height_ratio = self.img_height / self.screen_hegiht
self.client = None
self.starting_time = time.time()
def accept_connections(self):
serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv.bind((self.host, self.port))
serv.listen()
while True:
self.client, addr = serv.accept()
print("accept the connection")
serv.close()
def key_map_func(self, key):
if key == None: return "fn"
if key in self.key_map: return self.key_map[key]
return None
def on_press(self, key):
# print("P {} {}".format(key, self.key_map_func(key)))
key = self.key_map_func(key)
if key != None and self.is_pressed[key] == False:
try:
self.is_pressed[key] = True
if self.is_pressed['esc'] and self.is_pressed['ctrl']:
if self.log: self.log.close()
if self.client: self.client.close()
print("Exit successfully", flush=True)
os._exit(1)
return False
self.write_log("PRESS {0} {1:.3f}\n".format(
key,
time.time() - self.starting_time))
if self.client != None:
self.client.send("PRESS-{0}-".format(key).encode('utf-8'))
except Exception:
self.client.close()
self.client = None
def on_release(self, key):
# print("RELEASE {} {}".format(key, self.key_map_func(key)))
key = self.key_map_func(key)
if key != None:
try:
self.is_pressed[key] = False
self.write_log("RELEASE {0} {1:.3f}\n".format(
key,
time.time() - self.starting_time))
if self.client != None:
self.client.send(
"RELEASE-{0}-".format(key).encode('utf-8'))
except Exception:
self.client.close()
self.client = None
def on_move(self, x, y):
try:
self.write_log("POS {0:.1f} {1:.1f} {2:.3f}\n".format(
x, y,
time.time() - self.starting_time))
if self.client != None:
self.client.send("POS-({0:.1f}, {1:.1f})-".format(
x, y).encode('utf-8'))
except Exception:
self.client.close()
self.client = None
def on_click(self, x, y, button, pressed):
if pressed:
actual_x = int(x * self.width_ratio)
actual_y = int(y * self.height_ratio)
if actual_x >= self.img_width: actual_x = self.img_width - 1
if actual_y >= self.img_height: actual_y = self.img_height - 1
p = pyautogui.pixel(actual_x, actual_y)
try:
self.write_log("CLICK {0:.1f} {1:.1f} {2:.3f}\n".format(
x, y,
time.time() - self.starting_time))
if self.client != None:
self.client.send(
"CLICK-({0:.1f}, {1:.1f})-RGB({2}, {3}, {4})-".format(
x, y, p.red, p.green, p.blue).encode('utf-8'))
except Exception:
self.client.close()
self.client = None
def write_log(self, log_content):
if self.log != None:
self.log.write(log_content)
self.log.flush()
def on_scroll(self, x, y, dx, dy):
pass
# print('Mouse scrolled at ({0}, {1})({2}, {3})'.format(x, y, dx, dy))
def listen(self):
self.server = threading.Thread(target=self.accept_connections)
self.keyboard_listener = KeyboardListener(on_press=self.on_press,
on_release=self.on_release)
self.mouse_listener = MouseListener(on_move=self.on_move,
on_click=self.on_click,
on_scroll=self.on_scroll)
self.keyboard_listener.start()
self.mouse_listener.start()
self.server.start()
def join(self):
self.keyboard_listener.join()
self.mouse_listener.join()
self.server.join()
from pynput.mouse import Listener as MouseListener
from pynput.mouse import Button as MouseButton
import pyscreenshot as ImageGrab
from PIL import Image
def checkColor(xy):
im = ImageGrab.grab()
rgbim = im.convert('RGB')
r, g, b = rgbim.getpixel(xy)
print('rgb value: ', (r, g, b))
def onClick(x, y, button, pressed):
if pressed and button == MouseButton.left:
checkColor((x, y))
if pressed and button == MouseButton.right:
return False
m = MouseListener(on_click=onClick)
m.start()
m.join()
img = np.zeros((480, 640, 3))
def on_move(x, y):
print(f"Position : {scaleDown(x,y)}")
global img
m, n = scaleDown(x, y)
img = cv2.circle(img, (int(m), int(n)), 2, (0, 255, 0), 2)
cv2.imshow('img', img)
if cv2.waitKey(1) == 27:
cv2.destroyAllWindows()
def on_click(x, y, button, pressed):
if pressed:
Listener.stop()
m.position = (1366 / 2, 768 / 2)
print(scaleDown(1366, 768))
l = Listener(on_move=on_move)
l.start()
time.sleep(t) # Argument is used here
l.stop()
l.join()
if not l.isAlive():
print("Monitoring Stopped")
