Added macro settings in macro files #69

Optimized settings import

Author: LOUDO56

TUTORIAL.md

@@ -67,6 +67,11 @@ To change, simply click to the one you want to disable.
 Macro are wrote with JSON, and to make the file smaller, I compact everything. But, if do like writing your own lines, you can disable this option so you have a beautiful and readable file (but more bigger in size).
 To enable/disable go to `Options` -> `Settings` -> `Compact macro data`.
 
+### Always import macro settings
+
+If you always want to import macro settings when loading a macro, enable this option in `Options` -> `Settings` -> `Always import macro settings`.
+This will remove the confirmation windows each time you load a macro and automatically import the macro settings.
+
 ### Hotkeys
 
 To change your hotkeys to start, stop, start playback and stop playback, go to `Options` -> `Settings` -> `Hotkeys`.

src/hotkeys/hotkeys_manager.py

@@ -45,7 +45,7 @@ def __win32_event_filter(self, msg, data):
                 return True
 
     def __on_press(self, key):
-        userSettings = self.settings.get_config()
+        userSettings = self.settings.settings_dict
         if self.changeKey:
             keyPressed = getKeyPressed(self.keyboard_listener, key)
             if keyPressed not in self.hotkeys:

src/langs/en.json

@@ -15,7 +15,8 @@
       "confirm_save": "Do you want to save your record?",
       "confirm": "Confirm",
       "information": "Information",
-      "restart_software_text": "You need to restart the software for it to take effect."
+      "restart_software_text": "You need to restart the software for it to take effect.",
+      "load_macro_settings": "Import macro settings too?"
     },
     "new_version": {
       "title": "Software update",
@@ -85,6 +86,7 @@
       "json_compact": "Compact macro data",
       "settings_menu": {
         "settings_text": "Settings",
+        "always_import_macro_settings": "Always import macro settings",
         "lang_text": "Language",
         "lang_settings": {
           "title": "Language settings",

src/langs/fr.json

@@ -15,7 +15,8 @@
       "confirm_save": "Voulez-vous sauvegarder votre enregistrement?",
       "confirm": "Confirmer",
       "information": "Information",
-      "restart_software_text": "Vous devez redémarrer le logiciel pour que cela prenne effet."
+      "restart_software_text": "Vous devez redémarrer le logiciel pour que cela prenne effet.",
+      "load_macro_settings": "Importer les paramètres macro également ?"
     },
     "new_version": {
       "title": "Mise à jour du logiciel",
@@ -85,6 +86,7 @@
       "json_compact": "Données macro compactes",
       "settings_menu": {
         "settings_text": "Paramètres",
+        "always_import_macro_settings": "Toujours importer les paramètres macro",
         "lang_text": "Language",
         "lang_settings": {
           "title": "Réglage du language",

src/macro/macro.py

@@ -24,7 +24,7 @@ def __init__(self, main_app):
         self.keyboardControl = keyboard.Controller()
         self.record = False
         self.playback = False
-        self.macro_events = {"events": []}
+        self.macro_events = {}
         self.main_app = main_app
         self.user_settings = self.main_app.settings
         self.main_menu = self.main_app.menu
@@ -56,7 +56,7 @@ def start_record(self, by_hotkey=False):
         self.record = True
         self.time = time()
         self.event_delta_time=0
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         self.showEventsOnStatusBar = userSettings["Recordings"]["Show_Events_On_Status_Bar"]
         if (
             userSettings["Recordings"]["Mouse_Move"]
@@ -100,7 +100,7 @@ def start_record(self, by_hotkey=False):
     def stop_record(self):
         if not self.record:
             return
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         self.record = False
         if self.mouseBeingListened:
             self.mouse_listener.stop()
@@ -131,7 +131,7 @@ def stop_record(self):
         print("record stopped")
 
     def start_playback(self):
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         self.playback = True
         self.main_app.playBtn.configure(
             image=self.main_app.stopImg, command=lambda: self.stop_playback(True)
@@ -155,7 +155,7 @@ def start_playback(self):
         print("playback started")
 
     def __play_interval(self):
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         if userSettings["Playback"]["Repeat"]["For"] > 0:
             self.__play_for()
         else:
@@ -172,15 +172,15 @@ def __play_interval(self):
 
 
     def __play_for(self):
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         debut = time()
         while self.playback and (time() - debut) < userSettings["Playback"]["Repeat"]["For"]:
             self.__play_events()
         if userSettings["Playback"]["Repeat"]["Interval"] == 0:
             self.stop_playback()
 
     def __play_events(self):
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         click_func = {
             "leftClickEvent": Button.left,
             "rightClickEvent": Button.right,
@@ -302,7 +302,7 @@ def stop_playback(self, playback_stopped_manually=False):
             print("playback stopped")
         else:
             print("playback stopped manually")
-        userSettings = self.user_settings.get_config()
+        userSettings = self.user_settings.settings_dict
         self.main_app.recordBtn.configure(state=NORMAL)
         self.main_app.playBtn.configure(
             image=self.main_app.playImg, command=self.start_playback

src/utils/record_file_management.py

@@ -1,5 +1,6 @@
 from tkinter import *
 from tkinter import filedialog
+from tkinter import messagebox
 from os import path
 from json import load, dumps
 
@@ -34,11 +35,21 @@ def save_macro(self, event=None):
             return
         if self.main_app.current_file is not None:
             with open(self.main_app.current_file, "w") as current_file:
-                compactJson = UserSettings(self.main_app).get_config()["Saving"]["Compact_json"]
+                compactJson = UserSettings(self.main_app).settings_dict["Saving"]["Compact_json"]
+                userSettings = self.main_app.settings.settings_dict
+                macroSettings = {"settings": {
+                    "Playback": userSettings["Playback"],
+                    "Minimization": userSettings["Minimization"],
+                    "After_Playback": userSettings["After_Playback"]
+                }}
+                macroData = {
+                    **macroSettings,
+                    **self.main_app.macro.macro_events
+                }
                 if compactJson:
-                    json_macroEvents = dumps(self.main_app.macro.macro_events, separators=(',', ':'))
+                    json_macroEvents = dumps(macroData, separators=(',', ':'))
                 else:
-                    json_macroEvents = dumps(self.main_app.macro.macro_events, indent=4)
+                    json_macroEvents = dumps(macroData, indent=4)
                 current_file.write(json_macroEvents)
         else:
             self.save_macro_as()
@@ -77,8 +88,15 @@ def load_macro(self, event=None):
             self.main_app.macro_recorded = True
             self.main_app.macro_saved = True
             self.main_app.current_file = macroFile.name
+            if not self.main_app.settings.settings_dict["Loading"]["Always_import_macro_settings"]:
+                if messagebox.askyesno("PyMacroRecord", self.config_text["global"]["load_macro_settings"]):
+                    macro_settings = self.main_app.macro.macro_events["settings"]
+                    self.main_app.settings.settings_dict["Playback"] = macro_settings["Playback"]
+                    self.main_app.settings.settings_dict["Minimization"] = macro_settings["Minimization"]
+                    self.main_app.settings.settings_dict["After_Playback"] = macro_settings["After_Playback"]
         self.main_app.prevent_record = False
 
+
     def new_macro(self, event=None):
         if not self.main_app.macro_recorded or self.main_app.macro.playback:
             return

src/utils/user_settings.py

@@ -24,6 +24,7 @@ def __init__(self, main_app):
             self.first_time = True
             self.init_settings()
 
+        self.settings_dict = self.__get_config()
         self.check_new_options()
 
     def init_settings(self):
@@ -57,6 +58,9 @@ def init_settings(self):
             "Saving": {
                 "Compact_json": True
             },
+            "Loading": {
+                "Always_import_macro_settings": False
+            },
 
             "Hotkeys": {
                 "Record_Start": [],
@@ -94,15 +98,15 @@ def init_settings(self):
         with open(self.user_setting, "w") as settingFile:
             settingFile.write(userSettings_json)
 
-    def get_config(self):
+    def __get_config(self):
         """Get settings of users"""
         with open(self.user_setting, "r") as settingFile:
             settingFile_json = load(settingFile)
         return settingFile_json
 
-    def update_settings(self, updatedValues):
+    def update_settings(self):
         with open(self.user_setting, "w") as settingFile:
-            settingFile.write(updatedValues)
+            settingFile.write(dumps(self.settings_dict, indent=4))
 
     def reset_settings(self):
         if messagebox.askyesno(self.main_app.text_content["global"]["confirm"], self.main_app.text_content["options_menu"]["others_menu"]["reset_settings_confirmation"]):
@@ -113,33 +117,32 @@ def get_path(self):
 
     def change_settings(self, category, option=None, option2=None, newValue=None):
         """Change settings of user"""
-        userSettings = self.get_config()
         if option == "Show_Events_On_Status_Bar":
-            if userSettings[category][option]:
+            if self.settings_dict[category][option]:
                 self.main_app.status_text.pack_forget()
             else:
                 self.main_app.status_text.pack(side=BOTTOM, fill=X)
-        if not category in userSettings:
-            userSettings[category] = ""
+        if not category in self.settings_dict:
+            self.settings_dict[category] = ""
         if newValue is None:
             if option is None:
-                userSettings[category] = not userSettings[category]
+                self.settings_dict[category] = not self.settings_dict[category]
             elif option2 is not None:
-                userSettings[category][option][option2] = not userSettings[category][option][option2]
+                self.settings_dict[category][option][option2] = not self.settings_dict[category][option][option2]
             else:
-                userSettings[category][option] = not userSettings[category][option]
+                self.settings_dict[category][option] = not self.settings_dict[category][option]
 
         elif option is not None and newValue is not None:
             if option2 is not None:
-                userSettings[category][option][option2] = newValue
+                self.settings_dict[category][option][option2] = newValue
             else:
-                userSettings[category][option] = newValue
+                self.settings_dict[category][option] = newValue
         elif option is None and option2 is None:
-            userSettings[category] = newValue
-        self.update_settings(dumps(userSettings, indent=4))
+            self.settings_dict[category] = newValue
+        self.update_settings()
 
     def check_new_options(self):
-        userSettings = self.get_config()
+        userSettings = self.settings_dict
         if "Others" not in userSettings:
             userSettings["Others"] = {"Check_update": True}
         if "Fixed_timestamp" not in userSettings["Others"]:
@@ -161,5 +164,9 @@ def check_new_options(self):
         if "Infinite" not in userSettings["Playback"]["Repeat"]:
             userSettings["Playback"]["Repeat"]["Infinite"] = False
         if "Show_Events_On_Status_Bar" not in userSettings["Recordings"]:
-            userSettings["Recordings"]["Show_Events_On_Status_Bar"]=False
-        self.update_settings(dumps(userSettings, indent=4))
+            userSettings["Recordings"]["Show_Events_On_Status_Bar"] = False
+        if "Loading" not in userSettings:
+            userSettings["Loading"] = {}
+            if "Always_import_macro_settings" not in userSettings["Loading"]:
+                userSettings["Loading"]["Always_import_macro_settings"] = False
+        self.update_settings()

src/windows/main/main_app.py

@@ -53,7 +53,7 @@ def __init__(self):
         self.current_file = None
         self.prevent_record = False
 
-        self.version = Version(self.settings.get_config(), self)
+        self.version = Version(self.settings.settings_dict, self)
 
         self.menu = MenuBar(self)  # Menu Bar
         self.macro = Macro(self)
@@ -63,7 +63,7 @@ def __init__(self):
         self.hotkeyManager = HotkeysManager(self)
 
         self.status_text = Label(self, text='', relief=SUNKEN, anchor=W)
-        if self.settings.get_config()["Recordings"]["Show_Events_On_Status_Bar"]:
+        if self.settings.settings_dict["Recordings"]["Show_Events_On_Status_Bar"]:
             self.status_text.pack(side=BOTTOM, fill=X)
 
         # Main Buttons (Start record, stop record, start playback, stop playback)
@@ -110,14 +110,14 @@ def __init__(self):
         if platform != "win32" and self.settings.first_time:
             NotWindows(self)
 
-        if self.settings.get_config()["Others"]["Check_update"]:
+        if self.settings.settings_dict["Others"]["Check_update"]:
             if self.version.new_version != "" and self.version.version != self.version.new_version:
-                if time() > self.settings.get_config()["Others"]["Remind_new_ver_at"]:
+                if time() > self.settings.settings_dict["Others"]["Remind_new_ver_at"]:
                     NewVerAvailable(self, self.version.new_version)
         self.mainloop()
 
     def load_language(self):
-        self.lang = self.settings.get_config()["Language"]
+        self.lang = self.settings.settings_dict["Language"]
         with open(resource_path(path.join('langs', self.lang + '.json')), encoding='utf-8') as f:
             self.text_content = json.load(f)
         self.text_content = self.text_content["content"]

src/windows/main/menu_bar.py

@@ -13,7 +13,7 @@ def __init__(self, parent):
         super().__init__(parent)
 
         settings = parent.settings
-        userSettings = settings.get_config()
+        userSettings = settings.settings_dict
         self.text_config = parent.text_content
 
 
@@ -71,7 +71,9 @@ def __init__(self, parent):
         # Settings Sub
         self.options_sub = Menu(self.options_menu, tearoff=0)
         self.compactJson = BooleanVar(value=userSettings["Saving"]["Compact_json"])
+        self.always_import_macro_settings = BooleanVar(value=userSettings["Loading"]["Always_import_macro_settings"])
         self.options_sub.add_checkbutton(label=self.text_config["options_menu"]["json_compact"], command=lambda: settings.change_settings("Saving", "Compact_json"), variable=self.compactJson)
+        self.options_sub.add_checkbutton(label=self.text_config["options_menu"]["settings_menu"]["always_import_macro_settings"], command=lambda: settings.change_settings("Loading", "Always_import_macro_settings"), variable=self.always_import_macro_settings)
         self.options_menu.add_cascade(label=self.text_config["options_menu"]["settings_menu"]["settings_text"], menu=self.options_sub)
         self.options_sub.add_command(label=self.text_config["options_menu"]["settings_menu"]["hotkeys_text"], command=lambda: Hotkeys(self, parent))
         self.options_sub.add_command(label=self.text_config["options_menu"]["settings_menu"]["lang_text"], command=lambda: SelectLanguage(self, parent))

src/windows/options/playback/delay.py

@@ -10,7 +10,7 @@ def __init__(self, parent, main_app):
         main_app.prevent_record = True
         self.settings = main_app.settings
         Label(self, text=main_app.text_content["options_menu"]["playback_menu"]["delay_settings"]["sub_text"], font=('Segoe UI', 10)).pack(side=TOP, pady=10)
-        userSettings = main_app.settings.get_config()
+        userSettings = main_app.settings.settings_dict
         setNewDelayInput = Spinbox(self, from_=1, to=100000000, width=7, validate="key",
                               validatecommand=(main_app.validate_cmd, "%d", "%P"))
         setNewDelayInput.insert(0, str(userSettings["Playback"]["Repeat"]["Delay"]))