diff --git a/new/ClickRecorderReproducer-0-4.py b/new/ClickRecorderReproducer-0-4.py new file mode 100644 index 0000000..de9a88c --- /dev/null +++ b/new/ClickRecorderReproducer-0-4.py @@ -0,0 +1,268 @@ +import tkinter as tk +from tkinter import filedialog, messagebox +from PIL import Image, ImageTk +from pynput import mouse, keyboard +import threading +import time +import os + +class ClickRecorderReproducer: + def __init__(self, root): + # Inicializa a janela principal + self.root = root + self.root.title("Gravador e Reprodutor de Cliques") + self.root.geometry("640x640") + + # Estado inicial das variáveis + self.recording = False + self.paused = False + self.playing = False + self.filepath = "" + self.events = [] + + # Carregar imagens dos botões de movimento + self.load_images() + + # Criação dos botões + self.create_widgets() + + # Listeners de mouse e teclado + self.mouse_listener = mouse.Listener(on_click=self.on_click, on_move=self.on_move) + self.keyboard_listener = keyboard.Listener(on_press=self.on_press, on_release=self.on_release) + + self.playback_thread = None + + def load_images(self): + # Carregar as imagens dos botões + self.images = {} + directions = ['up', 'down', 'left', 'right', 'up_left', 'up_right', 'down_left', 'down_right'] + for direction in directions: + image_path = os.path.join(os.path.dirname(__file__), f'teclas-movimento-{direction}.jpg') + if os.path.exists(image_path): + image = Image.open(image_path) + self.images[direction] = ImageTk.PhotoImage(image) + else: + print(f"Imagem {image_path} não encontrada") + + def create_widgets(self): + # Cria o botão Ligar + self.start_button = tk.Button(self.root, text="Ligar", command=self.start_recording) + self.start_button.pack(pady=10) + + # Cria o botão Pausa + self.pause_button = tk.Button(self.root, text="Pausa", command=self.pause_recording) + self.pause_button.pack(pady=10) + + # Cria o botão Parar + self.stop_button = tk.Button(self.root, text="Parar", command=self.stop_recording) + self.stop_button.pack(pady=10) + + # Cria o botão Escolher Caminho do Arquivo + self.choose_path_button = tk.Button(self.root, text="Escolher Caminho para Gravação", command=self.choose_path) + self.choose_path_button.pack(pady=10) + + # Cria o botão Escolher Arquivo para Reprodução + self.choose_file_button = tk.Button(self.root, text="Escolher Arquivo para Reprodução", command=self.choose_file) + self.choose_file_button.pack(pady=10) + + # Cria o botão Reproduzir + self.play_button = tk.Button(self.root, text="Reproduzir", command=self.start_playback) + self.play_button.pack(pady=10) + + # Cria o botão Sair + self.exit_button = tk.Button(self.root, text="Sair", command=self.exit_application) + self.exit_button.pack(pady=10) + + # Cria os botões de movimento do mouse + self.create_movement_buttons() + + def create_movement_buttons(self): + # Cria botões de movimento do mouse usando as imagens carregadas + movement_frame = tk.Frame(self.root) + movement_frame.pack(pady=20) + + directions = [ + ('up_left', 0, 0), ('up', 0, 1), ('up_right', 0, 2), + ('left', 1, 0), ('right', 1, 2), + ('down_left', 2, 0), ('down', 2, 1), ('down_right', 2, 2) + ] + functions = { + 'up': self.move_up, 'down': self.move_down, 'left': self.move_left, 'right': self.move_right, + 'up_left': self.move_up_left, 'up_right': self.move_up_right, 'down_left': self.move_down_left, 'down_right': self.move_down_right + } + + for direction, row, col in directions: + if direction in self.images: + button = tk.Button(movement_frame, image=self.images[direction], command=functions[direction]) + button.grid(row=row, column=col, padx=5, pady=5) + + def move_up(self): + mouse.Controller().move(0, -10) + + def move_down(self): + mouse.Controller().move(0, 10) + + def move_left(self): + mouse.Controller().move(-10, 0) + + def move_right(self): + mouse.Controller().move(10, 0) + + def move_up_left(self): + mouse.Controller().move(-10, -10) + + def move_up_right(self): + mouse.Controller().move(10, -10) + + def move_down_left(self): + mouse.Controller().move(-10, 10) + + def move_down_right(self): + mouse.Controller().move(10, 10) + + def start_recording(self): + # Inicia a gravação de eventos + if not self.recording: + self.recording = True + self.paused = False + self.events.clear() # Limpa eventos anteriores + self.mouse_listener.start() + self.keyboard_listener.start() + self.update_status("Gravação iniciada") + + def pause_recording(self): + # Pausa ou retoma a gravação + if self.recording: + self.paused = not self.paused + status = "Pausado" if self.paused else "Retomado" + self.update_status(status) + + def stop_recording(self): + # Para a gravação e salva os eventos + if self.recording: + self.recording = False + self.mouse_listener.stop() + self.keyboard_listener.stop() + self.save_recording() + self.update_status("Gravação parada e salva") + + def choose_path(self): + # Escolhe o caminho do arquivo para salvar + self.filepath = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt"), ("All files", "*.*")]) + if self.filepath: + self.update_status(f"Caminho selecionado: {self.filepath}") + + def choose_file(self): + # Escolhe o arquivo para reprodução + self.filepath = filedialog.askopenfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt"), ("All files", "*.*")]) + if self.filepath: + self.update_status(f"Arquivo selecionado: {self.filepath}") + + def save_recording(self): + # Salva os eventos gravados no arquivo escolhido + if self.filepath: + with open(self.filepath, 'w') as f: + for event in self.events: + f.write(f"{event}\n") + self.update_status("Gravação salva") + else: + messagebox.showwarning("Aviso", "Escolha um caminho para salvar o arquivo") + + def start_playback(self): + # Inicia a reprodução dos eventos gravados + if self.filepath: + self.playing = True + self.playback_thread = threading.Thread(target=self.playback_events) + self.playback_thread.start() + else: + messagebox.showwarning("Aviso", "Escolha um arquivo para reprodução") + + def playback_events(self): + # Lê os eventos do arquivo e os reproduz + with open(self.filepath, 'r') as f: + lines = f.readlines() + + mouse_controller = mouse.Controller() + keyboard_controller = keyboard.Controller() + + for line in lines: + if not self.playing: + break + parts = line.strip().split() + event_type = parts[0] + if event_type == "Movimento": + x, y = int(parts[2]), int(parts[3]) + mouse_controller.position = (x, y) + elif event_type == "Pressionado": + button = self.get_mouse_button(parts[2]) + mouse_controller.press(button) + elif event_type == "Liberado": + button = self.get_mouse_button(parts[2]) + mouse_controller.release(button) + elif event_type == "Tecla": + key_action = parts[2] + key = self.get_key(parts[1]) + if key_action == "pressionada": + keyboard_controller.press(key) + elif key_action == "liberada": + keyboard_controller.release(key) + time.sleep(0.01) # Pequeno atraso para simular o tempo entre os eventos + + def stop_playback(self): + # Para a reprodução dos eventos + self.playing = False + + def exit_application(self): + # Sai da aplicação + self.stop_playback() # Garante que a reprodução é parada antes de sair + self.root.quit() + + def update_status(self, message): + # Atualiza o status atual (neste exemplo, apenas imprime) + print(message) + + def on_click(self, x, y, button, pressed): + # Manipulador de eventos de clique do mouse + if self.recording and not self.paused: + action = "Pressionado" if pressed else "Liberado" + self.events.append(f"{action} {button.name} em {x} {y}") + self.update_status(f"{action} {button.name} em {x} {y}") + + def on_move(self, x, y): + # Manipulador de eventos de movimento do mouse + if self.recording and not self.paused: + self.events.append(f"Movimento em {x} {y}") + self.update_status(f"Movimento em {x} {y}") + + def on_press(self, key): + # Manipulador de eventos de pressionamento de teclas + if self.recording and not self.paused: + key_name = key.name if isinstance(key, keyboard.Key) else str(key) + self.events.append(f"Tecla {key_name} pressionada") + self.update_status(f"Tecla {key_name} pressionada") + + def on_release(self, key): + # Manipulador de eventos de liberação de teclas + if self.recording and not self.paused: + key_name = key.name if isinstance(key, keyboard.Key) else str(key) + self.events.append(f"Tecla {key_name} liberada") + self.update_status(f"Tecla {key_name} liberada") + + def get_mouse_button(self, button_name): + # Obtém o botão do mouse a partir do nome + try: + return mouse.Button[button_name.lower()] + except KeyError: + return mouse.Button.left # Padrão para o botão esquerdo + + def get_key(self, key_name): + # Obtém a tecla do teclado a partir do nome + try: + return keyboard.Key[key_name] + except KeyError: + return key_name # Caso contrário, retorna o nome original + +if __name__ == "__main__": + root = tk.Tk() + app = ClickRecorderReproducer(root) + root.mainloop()