Normalise Dynamic Macro keycodes (#18939)

* `DYN_REC_START1` -> `QK_DYNAMIC_MACRO_RECORD_START_1`

* `DYN_REC_START2` -> `QK_DYNAMIC_MACRO_RECORD_START_2`

* `DYN_MACRO_PLAY1` -> `QK_DYNAMIC_MACRO_PLAY_1`

* `DYN_MACRO_PLAY2` -> `QK_DYNAMIC_MACRO_PLAY_2`

* `DYN_REC_STOP` -> `QK_DYNAMIC_MACRO_RECORD_STOP`

* Update docs

1 files changed, 13 insertions, 13 deletions

diff --git a/quantum/process_keycode/process_dynamic_macro.c b/quantum/process_keycode/process_dynamic_macro.c
index 41207092a9..c2e7e7716f 100644
--- a/quantum/process_keycode/process_dynamic_macro.c
+++ b/quantum/process_keycode/process_dynamic_macro.c
@@ -139,7 +139,7 @@ void dynamic_macro_record_end(keyrecord_t *macro_buffer, keyrecord_t *macro_poin
     dynamic_macro_record_end_user(direction);
 
     /* Do not save the keys being held when stopping the recording,
-     * i.e. the keys used to access the layer DYN_REC_STOP is on.
+     * i.e. the keys used to access the layer DM_RSTP is on.
      */
     while (macro_pointer != macro_buffer && (macro_pointer - direction)->event.pressed) {
         dprintln("dynamic macro: trimming a trailing key-down event");
@@ -212,18 +212,18 @@ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) {
         /* No macro recording in progress. */
         if (!record->event.pressed) {
             switch (keycode) {
-                case DYN_REC_START1:
+                case QK_DYNAMIC_MACRO_RECORD_START_1:
                     dynamic_macro_record_start(&macro_pointer, macro_buffer);
                     macro_id = 1;
                     return false;
-                case DYN_REC_START2:
+                case QK_DYNAMIC_MACRO_RECORD_START_2:
                     dynamic_macro_record_start(&macro_pointer, r_macro_buffer);
                     macro_id = 2;
                     return false;
-                case DYN_MACRO_PLAY1:
+                case QK_DYNAMIC_MACRO_PLAY_1:
                     dynamic_macro_play(macro_buffer, macro_end, +1);
                     return false;
-                case DYN_MACRO_PLAY2:
+                case QK_DYNAMIC_MACRO_PLAY_2:
                     dynamic_macro_play(r_macro_buffer, r_macro_end, -1);
                     return false;
             }
@@ -231,13 +231,13 @@ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) {
     } else {
         /* A macro is being recorded right now. */
         switch (keycode) {
-            case DYN_REC_START1:
-            case DYN_REC_START2:
-            case DYN_REC_STOP:
+            case QK_DYNAMIC_MACRO_RECORD_START_1:
+            case QK_DYNAMIC_MACRO_RECORD_START_2:
+            case QK_DYNAMIC_MACRO_RECORD_STOP:
                 /* Stop the macro recording. */
-                if (record->event.pressed ^ (keycode != DYN_REC_STOP)) { /* Ignore the initial release
-                                                                          * just after the recording
-                                                                          * starts for DYN_REC_STOP. */
+                if (record->event.pressed ^ (keycode != QK_DYNAMIC_MACRO_RECORD_STOP)) { /* Ignore the initial release
+                                                                                          * just after the recording
+                                                                                          * starts for DM_RSTP. */
                     switch (macro_id) {
                         case 1:
                             dynamic_macro_record_end(macro_buffer, macro_pointer, +1, &macro_end);
@@ -250,8 +250,8 @@ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) {
                 }
                 return false;
 #ifdef DYNAMIC_MACRO_NO_NESTING
-            case DYN_MACRO_PLAY1:
-            case DYN_MACRO_PLAY2:
+            case QK_DYNAMIC_MACRO_PLAY_1:
+            case QK_DYNAMIC_MACRO_PLAY_2:
                 dprintln("dynamic macro: ignoring macro play key while recording");
                 return false;
 #endif