]> git.friedersdorff.com Git - max/tmk_keyboard.git/blobdiff - common/action.c
Merge branch 'transparent'
[max/tmk_keyboard.git] / common / action.c
index eb8fc2ce24fb1319669f35e131a68a7725eef77c..710300eb3062bb86c5d62028f758fac126ce8474 100644 (file)
@@ -110,7 +110,7 @@ static bool waiting_buffer_typed(keyevent_t event)
 }
 #endif
 
-static bool waiting_buffer_has_anykey_pressed(void)
+bool waiting_buffer_has_anykey_pressed(void)
 {
     for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) {
         if (waiting_buffer[i].event.pressed) return true;
@@ -201,6 +201,19 @@ void action_exec(keyevent_t event)
     }
 }
 
+static action_t get_action(key_t key)
+{
+    action_t action = keymap_get_action(current_layer, key.pos.row, key.pos.col);
+
+    /* Transparently use default layer */
+    if (action.code == ACTION_TRANSPARENT) {
+        // TODO: layer stacking
+        action = keymap_get_action(default_layer, key.pos.row, key.pos.col);
+        debug("TRNASPARENT: "); debug_hex16(action.code); debug("\n");
+    }
+    return action;
+}
+
 static void process_action(keyrecord_t *record)
 {
     keyevent_t event = record->event;
@@ -208,8 +221,7 @@ static void process_action(keyrecord_t *record)
 
     if (IS_NOEVENT(event)) { return; }
 
-    action_t action = keymap_get_action(current_layer, event.key.pos.row, event.key.pos.col);
-    //debug("action: "); debug_hex16(action.code); if (event.pressed) debug("d\n"); else debug("u\n");
+    action_t action = get_action(event.key);
     debug("ACTION: "); debug_action(action); debug("\n");
 
     switch (action.kind.id) {
@@ -256,7 +268,7 @@ static void process_action(keyrecord_t *record)
                                 debug("MODS_TAP: Oneshot: start\n");
                                 oneshot_start(mods, event.time);
                             }
-                            else if (tap_count == 5) {
+                            else if (tap_count == TAPPING_TOGGLE) {
                                 debug("MODS_TAP: Oneshot: toggle\n");
                                 oneshot_toggle();
                             }
@@ -319,14 +331,14 @@ static void process_action(keyrecord_t *record)
         case ACT_USAGE:
 #ifdef EXTRAKEY_ENABLE
             switch (action.usage.page) {
-                case ACTION_USAGE_PAGE_SYSTEM:
+                case PAGE_SYSTEM:
                     if (event.pressed) {
                         host_system_send(action.usage.code);
                     } else {
                         host_system_send(0);
                     }
                     break;
-                case ACTION_USAGE_PAGE_CONSUMER:
+                case PAGE_CONSUMER:
                     if (event.pressed) {
                         host_consumer_send(action.usage.code);
                     } else {
@@ -351,133 +363,124 @@ static void process_action(keyrecord_t *record)
             break;
 
         /* Layer key */
-        case ACT_LAYER_PRESSED:
-            // layer action when pressed
+        case ACT_LAYER:
             switch (action.layer.code) {
-                case 0x00:
+                case LAYER_MOMENTARY:  /* momentary */
                     if (event.pressed) {
-                        layer_switch(action.layer.opt);
+                        layer_switch(action.layer.val);
+                    }
+                    else {
+                        // NOTE: This is needed by legacy keymap support
+                        layer_switch(default_layer);
                     }
                     break;
-                case 0xF0:
-                    // tap toggle
+                case LAYER_ON_PRESS:
+                    if (event.pressed) {
+                        layer_switch(action.layer.val);
+                    }
+                    break;
+                case LAYER_ON_RELEASE:
+                    if (!event.pressed) {
+                        layer_switch(action.layer.val);
+                    }
+                    break;
+                case LAYER_DEFAULT:  /* default layer */
+                    switch (action.layer.val) {
+                        case DEFAULT_ON_BOTH:
+                            layer_switch(default_layer);
+                            break;
+                        case DEFAULT_ON_PRESS:
+                            if (event.pressed) {
+                                layer_switch(default_layer);
+                            }
+                            break;
+                        case DEFAULT_ON_RELEASE:
+                            if (!event.pressed) {
+                                layer_switch(default_layer);
+                            }
+                            break;
+                    }
+                    break;
+                case LAYER_TAP_TOGGLE:  /* switch on hold and toggle on several taps */
                     if (event.pressed) {
                         if (tap_count < TAPPING_TOGGLE) {
-                            layer_switch(action.layer.opt);
+                            layer_switch(action.layer.val);
                         }
                     } else {
                         if (tap_count >= TAPPING_TOGGLE) {
                             debug("LAYER_PRESSED: tap toggle.\n");
-                            layer_switch(action.layer.opt);
+                            layer_switch(action.layer.val);
                         }
                     }
                     break;
-                case 0xFF:
-                    // change default layer
+                case LAYER_CHANGE_DEFAULT:  /* change default layer */
                     if (event.pressed) {
-                        default_layer = action.layer.opt;
+                        default_layer = action.layer.val;
                         layer_switch(default_layer);
                     }
                     break;
-                default:
-                    // with tap key
+                default:    /* switch layer on hold and key on tap*/
                     if (event.pressed) {
                        if (tap_count > 0) {
                             debug("LAYER_PRESSED: Tap: register_code\n");
                             register_code(action.layer.code);
                        } else {
                             debug("LAYER_PRESSED: No tap: layer_switch\n");
-                            layer_switch(action.layer.opt);
+                            layer_switch(action.layer.val);
                        }
                     } else {
                         if (tap_count > 0) {
                             debug("LAYER_PRESSED: Tap: unregister_code\n");
                             unregister_code(action.layer.code);
                         } else {
-                            debug("LAYER_PRESSED: No tap: NO ACTION\n");
+                            //debug("LAYER_PRESSED: No tap: NO ACTION\n");
+                            // NOTE: This is needed by legacy keymap support
+                            debug("LAYER_PRESSED: No tap: return to default layer\n");
+                            layer_switch(default_layer);
                         }
                     }
                     break;
             }
             break;
-        case ACT_LAYER_RELEASED:
+        case ACT_LAYER_BIT:
             switch (action.layer.code) {
-                case 0x00:
-                    if (!event.pressed) {
-                        layer_switch(action.layer.opt);
-                    }
-                    break;
-                case 0xF0:
-                    // tap toggle
+                case LAYER_MOMENTARY:  /* momentary */
                     if (event.pressed) {
-                        if (tap_count >= TAPPING_TOGGLE) {
-                            debug("LAYER_RELEASED: tap toggle.\n");
-                            layer_switch(action.layer.opt);
-                        }
+                        layer_switch(current_layer ^ action.layer.val);
                     } else {
-                        if (tap_count < TAPPING_TOGGLE) {
-                            layer_switch(action.layer.opt);
-                        }
+                        layer_switch(current_layer ^ action.layer.val);
                     }
                     break;
-                case 0xFF:
-                    // change default layer
-                    if (!event.pressed) {
-                        default_layer = action.layer.opt;
-                        layer_switch(default_layer);
-                    }
-                    break;
-                default:
-                    // with tap key
+                case LAYER_ON_PRESS:
                     if (event.pressed) {
-                       if (tap_count > 0) {
-                            debug("LAYER_RELEASED: Tap: register_code\n");
-                            register_code(action.layer.code);
-                       } else {
-                            debug("LAYER_RELEASED: No tap: NO ACTION\n");
-                       }
-                    } else {
-                        if (tap_count > 0) {
-                            debug("LAYER_RELEASED: Tap: unregister_code\n");
-                            unregister_code(action.layer.code);
-                        } else {
-                            debug("LAYER_RELEASED: No tap: layer_switch\n");
-                            layer_switch(action.layer.opt);
-                        }
+                        layer_switch(current_layer ^ action.layer.val);
                     }
                     break;
-            }
-            break;
-        case ACT_LAYER_BIT:
-            switch (action.layer.code) {
-                case 0x00:
-                    if (event.pressed) {
-                        layer_switch(current_layer ^ action.layer.opt);
-                    } else {
-                        layer_switch(current_layer ^ action.layer.opt);
+                case LAYER_ON_RELEASE:
+                    if (!event.pressed) {
+                        layer_switch(current_layer ^ action.layer.val);
                     }
                     break;
-                case 0xF0:
-                    // tap toggle
+                case LAYER_TAP_TOGGLE:  /* switch on hold and toggle on several taps */
                     if (event.pressed) {
                         if (tap_count < TAPPING_TOGGLE) {
                             debug("LAYER_BIT: tap toggle(press).\n");
-                            layer_switch(current_layer ^ action.layer.opt);
+                            layer_switch(current_layer ^ action.layer.val);
                         }
                     } else {
                         if (tap_count <= TAPPING_TOGGLE) {
                             debug("LAYER_BIT: tap toggle(release).\n");
-                            layer_switch(current_layer ^ action.layer.opt);
+                            layer_switch(current_layer ^ action.layer.val);
                         }
                     }
                     break;
                 case 0xFF:
                     // change default layer
                     if (event.pressed) {
-                        default_layer = current_layer ^ action.layer.opt;
+                        default_layer = current_layer ^ action.layer.val;
                         layer_switch(default_layer);
                     } else {
-                        default_layer = current_layer ^ action.layer.opt;
+                        default_layer = current_layer ^ action.layer.val;
                         layer_switch(default_layer);
                     }
                     break;
@@ -489,7 +492,7 @@ static void process_action(keyrecord_t *record)
                             register_code(action.layer.code);
                         } else {
                             debug("LAYER_BIT: No tap: layer_switch(bit on)\n");
-                            layer_switch(current_layer ^ action.layer.opt);
+                            layer_switch(current_layer ^ action.layer.val);
                         }
                     } else {
                         if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
@@ -497,114 +500,12 @@ static void process_action(keyrecord_t *record)
                             unregister_code(action.layer.code);
                         } else {
                             debug("LAYER_BIT: No tap: layer_switch(bit off)\n");
-                            layer_switch(current_layer ^ action.layer.opt);
+                            layer_switch(current_layer ^ action.layer.val);
                         }
                     }
                     break;
             }
             break;
-        case ACT_LAYER_EXT:
-            switch (action.layer.opt) {
-                case 0x00:
-                    // set default layer when pressed
-                    switch (action.layer.code) {
-                        case 0x00:
-                            if (event.pressed) {
-                                layer_switch(default_layer);
-                            }
-                            break;
-                        case 0xF0:
-                            // tap toggle
-                            if (event.pressed) {
-                                if (tap_count < TAPPING_TOGGLE) {
-                                    layer_switch(default_layer);
-                                }
-                            } else {
-                                if (tap_count >= TAPPING_TOGGLE) {
-                                    debug("LAYER_EXT_PRESSED: tap toggle.\n");
-                                    layer_switch(default_layer);
-                                }
-                            }
-                            break;
-                        case 0xFF:
-                            // change default layer
-                            if (event.pressed) {
-                                default_layer = current_layer;
-                                layer_switch(default_layer);
-                            }
-                            break;
-                        default:
-                            // with tap key
-                            if (event.pressed) {
-                               if (tap_count > 0) {
-                                    debug("LAYER_EXT_PRESSED: Tap: register_code\n");
-                                    register_code(action.layer.code);
-                               } else {
-                                    debug("LAYER_EXT_PRESSED: No tap: layer_switch\n");
-                                    layer_switch(default_layer);
-                               }
-                            } else {
-                                if (tap_count > 0) {
-                                    debug("LAYER_EXT_PRESSED: Tap: unregister_code\n");
-                                    unregister_code(action.layer.code);
-                                } else {
-                                    debug("LAYER_EXT_PRESSED: No tap: NO ACTION\n");
-                                }
-                            }
-                            break;
-                    }
-                    break;
-                case 0x01:
-                    // set default layer when released
-                    switch (action.layer.code) {
-                        case 0x00:
-                            if (!event.pressed) {
-                                layer_switch(default_layer);
-                            }
-                            break;
-                        case 0xF0:
-                            // tap toggle
-                            if (event.pressed) {
-                                if (tap_count >= TAPPING_TOGGLE) {
-                                    debug("LAYER_EXT_RELEASED: tap toggle.\n");
-                                    layer_switch(default_layer);
-                                }
-                            } else {
-                                if (tap_count < TAPPING_TOGGLE) {
-                                    layer_switch(default_layer);
-                                }
-                            }
-                            break;
-                        case 0xFF:
-                            // change default layer
-                            if (!event.pressed) {
-                                default_layer = current_layer;
-                                layer_switch(default_layer);
-                            }
-                            break;
-                        default:
-                            // with tap key
-                            if (event.pressed) {
-                               if (tap_count > 0) {
-                                    debug("LAYER_EXT_RELEASED: Tap: register_code\n");
-                                    register_code(action.layer.code);
-                               } else {
-                                    debug("LAYER_EXT_RELEASED: No tap: NO ACTION\n");
-                               }
-                            } else {
-                                if (tap_count > 0) {
-                                    debug("LAYER_EXT_RELEASED: Tap: unregister_code\n");
-                                    unregister_code(action.layer.code);
-                                } else {
-                                    debug("LAYER_EXT_RELEASED: No tap: layer_switch\n");
-                                    layer_switch(default_layer);
-                                }
-                            }
-                            break;
-                    }
-                    break;
-            }
-            break;
 
         /* Extentions */
         case ACT_MACRO:
@@ -613,7 +514,7 @@ static void process_action(keyrecord_t *record)
             break;
         case ACT_FUNCTION:
             // TODO
-            action_call_function(event, action.func.id);
+            keymap_call_function(record, action.func.id, action.func.opt);
             break;
         default:
             break;
@@ -772,8 +673,7 @@ static bool process_tapping(keyrecord_t *keyp)
             debug_event(event); debug("\n");
             tapping_key = (keyrecord_t){};
             debug_tapping_key();
-            process_action(keyp);
-            return true;
+            return false;
         }
     }
     // not tapping satate
@@ -921,26 +821,27 @@ void layer_switch(uint8_t new_layer)
 
 bool is_tap_key(key_t key)
 {
-    action_t action = keymap_get_action(current_layer, key.pos.row, key.pos.col);
+    action_t action = get_action(key);
+
     switch (action.kind.id) {
         case ACT_LMODS_TAP:
         case ACT_RMODS_TAP:
             return true;
-        case ACT_LAYER_PRESSED:
+        case ACT_LAYER:
         case ACT_LAYER_BIT:
             switch (action.layer.code) {
-                case 0x00:
-                case 0xF1 ... 0xFF:
+                case LAYER_MOMENTARY:
+                case LAYER_ON_PRESS:
+                case LAYER_ON_RELEASE:
+                case LAYER_DEFAULT:
                     return false;
-                case 0xF0:
-                default:
+                case LAYER_TAP_TOGGLE:
+                default:    /* tap key */
                     return true;
             }
             return false;
         case ACT_FUNCTION:
-            if (action.func.opt & 0x1) {
-                return true;
-            }
+            if (action.func.opt & FUNC_TAP) { return true; }
             return false;
     }
     return false;
@@ -969,10 +870,8 @@ static void debug_action(action_t action)
         case ACT_RMODS_TAP:         debug("ACT_RMODS_TAP");         break;
         case ACT_USAGE:             debug("ACT_USAGE");             break;
         case ACT_MOUSEKEY:          debug("ACT_MOUSEKEY");          break;
-        case ACT_LAYER_PRESSED:     debug("ACT_LAYER_PRESSED");     break;
-        case ACT_LAYER_RELEASED:    debug("ACT_LAYER_RELEASED");    break;
+        case ACT_LAYER:             debug("ACT_LAYER");     break;
         case ACT_LAYER_BIT:         debug("ACT_LAYER_BIT");         break;
-        case ACT_LAYER_EXT:         debug("ACT_LAYER_EXT");         break;
         case ACT_MACRO:             debug("ACT_MACRO");             break;
         case ACT_COMMAND:           debug("ACT_COMMAND");           break;
         case ACT_FUNCTION:          debug("ACT_FUNCTION");          break;