8 files changed, 226 insertions, 22 deletions

diff --git a/common.mk b/common.mk
index 7cdaa5f74..86518f03f 100644
--- a/common.mk
+++ b/common.mk
@@ -2,6 +2,7 @@ COMMON_DIR = common
 SRC +=  $(COMMON_DIR)/host.c \
         $(COMMON_DIR)/keyboard.c \
         $(COMMON_DIR)/action.c \
+        $(COMMON_DIR)/action_macro.c \
         $(COMMON_DIR)/keymap.c \
         $(COMMON_DIR)/command.c \
         $(COMMON_DIR)/timer.c \
diff --git a/common/action.c b/common/action.c
index cb44e272a..301a9b6a0 100644
--- a/common/action.c
+++ b/common/action.c
@@ -620,7 +620,7 @@ static void process_action(keyrecord_t *record)
             break;
         case ACT_FUNCTION:
             // TODO
-            keymap_call_function(record, action.func.id);
+            keymap_call_function(record, action.func.id, action.func.opt);
             break;
         default:
             break;
diff --git a/common/action.h b/common/action.h
index b657aa540..b1e958a26 100644
--- a/common/action.h
+++ b/common/action.h
@@ -49,27 +49,27 @@ typedef union {
     uint16_t code;
     struct action_kind {
         uint16_t param  :12;
-        uint16_t id     :4;
+        uint8_t  id     :4;
     } kind;
     struct action_key {
-        uint16_t code   :8;
-        uint16_t mods   :4;
-        uint16_t kind   :4;
+        uint8_t  code   :8;
+        uint8_t  mods   :4;
+        uint8_t  kind   :4;
     } key;
     struct action_layer {
-        uint16_t code   :8;
-        uint16_t val    :4;
-        uint16_t kind   :4;
+        uint8_t  code   :8;
+        uint8_t  val    :4;
+        uint8_t  kind   :4;
     } layer;
     struct action_usage {
         uint16_t code   :10;
-        uint16_t page   :2;
-        uint16_t kind   :4;
+        uint8_t  page   :2;
+        uint8_t  kind   :4;
     } usage;
     struct action_command {
-        uint16_t id     :8;
-        uint16_t opt    :4;
-        uint16_t kind   :4;
+        uint8_t  id     :8;
+        uint8_t  opt    :4;
+        uint8_t  kind   :4;
     } command;
     struct action_function {
         uint8_t  id     :8;
diff --git a/common/action_macro.c b/common/action_macro.c
new file mode 100644
index 000000000..72859c0dd
--- /dev/null
+++ b/common/action_macro.c
@@ -0,0 +1,67 @@
+/*
+Copyright 2013 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <util/delay.h>
+#include "debug.h"
+#include "action.h"
+#include "action_macro.h"
+
+
+#define MACRO_READ()  (macro = pgm_read_byte(macro_p++))
+void action_macro_play(const prog_macro_t *macro_p)
+{
+    macro_t macro = END;
+    uint8_t interval = 0;
+
+    if (!macro_p) return;
+    while (true) {
+        switch (MACRO_READ()) {
+            case INTERVAL:
+                interval = MACRO_READ();
+                debug("INTERVAL("); debug_dec(interval); debug(")\n");
+                break;
+            case WAIT:
+                MACRO_READ();
+                debug("WAIT("); debug_dec(macro); debug(")\n");
+                { uint8_t ms = macro; while (ms--) _delay_ms(1); }
+                break;
+            case MODS_DOWN:
+                MACRO_READ();
+                debug("MODS_DOWN("); debug_hex(macro); debug(")\n");
+                debug("MODS_UP("); debug_hex(macro); debug(")\n");
+                add_mods(macro);
+                break;
+            case MODS_UP:
+                MACRO_READ();
+                debug("MODS_UP("); debug_hex(macro); debug(")\n");
+                del_mods(macro);
+                break;
+            case 0x04 ... 0x73:
+                debug("DOWN("); debug_hex(macro); debug(")\n");
+                register_code(macro);
+                break;
+            case 0x84 ... 0xF3:
+                debug("UP("); debug_hex(macro); debug(")\n");
+                unregister_code(macro&0x7F);
+                break;
+            case END:
+            default:
+                return;
+        }
+        // interval
+        { uint8_t ms = interval; while (ms--) _delay_ms(1); }
+    }
+}
diff --git a/common/action_macro.h b/common/action_macro.h
new file mode 100644
index 000000000..3833c7c8a
--- /dev/null
+++ b/common/action_macro.h
@@ -0,0 +1,107 @@
+/*
+Copyright 2013 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef ACTION_MACRO_H
+#define ACTION_MACRO_H
+#include <stdint.h>
+#include <avr/pgmspace.h>
+
+
+typedef uint8_t macro_t;
+typedef macro_t prog_macro_t PROGMEM;
+
+
+void action_macro_play(const prog_macro_t *macro);
+
+
+
+/* TODO: NOT FINISHED 
+normal mode command:
+    key(down):      0x04-7f/73(F24)
+    key(up):        0x84-ff
+command:        0x00-03, 0x80-83(0x74-7f, 0xf4-ff)
+    mods down   0x00
+    mods up     0x01
+    wait        0x02
+    interval    0x03
+    extkey down 0x80
+    extkey up   0x81
+    ext commad  0x82
+    ext mode    0x83
+    end         0xff
+
+extension mode command: NOT IMPLEMENTED
+    key down            0x00
+    key up              0x01
+    key down + wait
+    key up   + wait
+    mods push
+    mods pop
+    wait
+    interval
+    if
+    loop
+    push
+    pop
+    all up
+    end
+*/
+enum macro_command_id{
+    /* 0x00 - 0x03 */
+    END                 = 0x00,
+    MODS_DOWN           = 0x01,
+    MODS_UP             = 0x02,
+    MODS_SET,
+    MODS_PUSH,
+    MODS_POP,
+
+    WAIT                = 0x74,
+    INTERVAL,
+    /* 0x74 - 0x7f */
+    /* 0x80 - 0x84 */
+
+    EXT_DOWN,
+    EXT_UP,
+    EXT_WAIT,
+    EXT_INTERVAL,
+    COMPRESSION_MODE,
+
+    EXTENSION_MODE      = 0xff,
+};
+
+
+/* normal mode */
+#define DOWN(key)       (key)
+#define UP(key)         ((key) | 0x80)
+#define TYPE(key)       (key), (key | 0x80)
+#define MODS_DOWN(mods) MODS_DOWN, (mods)
+#define MODS_UP(mods)   MODS_UP, (mods)
+#define WAIT(ms)        WAIT, (ms)
+#define INTERVAL(ms)    INTERVAL, (ms)
+
+#define D(key)          DOWN(KC_##key)
+#define U(key)          UP(KC_##key)
+#define T(key)          TYPE(KC_##key)
+#define MD(key)         MODS_DOWN(MOD_BIT(KC_##key))
+#define MU(key)         MODS_UP(MOD_BIT(KC_##key))
+#define W(ms)           WAIT(ms)
+#define I(ms)           INTERVAL(ms)
+
+
+/* extension mode */
+
+
+#endif /* ACTION_MACRO_H */
diff --git a/common/keymap.c b/common/keymap.c
index 40d20f684..8302c2704 100644
--- a/common/keymap.c
+++ b/common/keymap.c
@@ -68,6 +68,6 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col)
 #endif
 
 __attribute__ ((weak))
-void keymap_call_function(keyrecord_t *event, uint8_t id)
+void keymap_call_function(keyrecord_t *event, uint8_t id, uint8_t opt)
 {
 }
diff --git a/common/keymap.h b/common/keymap.h
index e0fafeaf2..30d73f797 100644
--- a/common/keymap.h
+++ b/common/keymap.h
@@ -23,6 +23,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "action.h"
 
 
+// TODO: move to action.h?
 /* layer used currently */
 extern uint8_t current_layer;
 /* layer to return or start with */
@@ -34,7 +35,7 @@ extern uint8_t default_layer;
 action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col);
 
 /* user defined special function */
-void keymap_call_function(keyrecord_t *record, uint8_t id);
+void keymap_call_function(keyrecord_t *record, uint8_t id, uint8_t opt);
 
 
 #ifndef NO_LEGACY_KEYMAP_SUPPORT
diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c
index e11b4563a..f2f21e8ce 100644
--- a/keyboard/hhkb/keymap.c
+++ b/keyboard/hhkb/keymap.c
@@ -21,12 +21,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
-#include "host.h"
 #include "keycode.h"
-#include "print.h"
-#include "debug.h"
-#include "util.h"
 #include "action.h"
+#include "action_macro.h"
+#include "host.h"
+#include "debug.h"
 #include "keymap.h"
 
 
@@ -69,7 +68,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
            TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSPC, \
            FN6, A,   S,   D,   F,   G,   H,   J,   K,   L,   FN3, QUOT,FN7, \
            FN8, Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, FN2, FN12,FN10, \
-                LGUI,LALT,          FN5,                RALT,FN4),
+                LGUI,LALT,          FN5,                FN13,FN4),
 
     /* Layer 1: HHKB mode (HHKB Fn)
      * ,-----------------------------------------------------------.
@@ -162,6 +161,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 enum function_id {
     LSHIFT_LPAREN,
     RSHIFT_RPAREN,
+    MACRO                   = 0xff
 };
 
 /*
@@ -172,7 +172,8 @@ static const uint16_t PROGMEM fn_actions[] = {
     ACTION_LAYER_SET(1),                            // FN1
     ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH),          // FN2
     ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN),           // FN3
-    ACTION_LAYER_SET(3),                            // FN4
+    //ACTION_LAYER_SET(3),                            // FN4
+    ACTION_FUNCTION(MACRO, 0),                      // FN4
     ACTION_LAYER_SET_TAP_KEY(5, KC_SPC),            // FN5
     ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC),          // FN6
     ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT),           // FN7
@@ -183,12 +184,36 @@ static const uint16_t PROGMEM fn_actions[] = {
     //ACTION_LAYER_BIT_TAP_TOGGLE(1),               // FN10
     ACTION_FUNCTION_TAP(LSHIFT_LPAREN),             // FN11
     ACTION_FUNCTION_TAP(RSHIFT_RPAREN),             // FN12
+    ACTION_FUNCTION(MACRO, 1),                      // FN13
 };
 
+
+/*
+ * Macro definition
+ */
+#define MACRO(...) ({ static prog_macro_t _m[] PROGMEM = { __VA_ARGS__ }; _m; })
+#define MACRO_NONE  0
+static const prog_macro_t *get_macro(uint8_t id, bool pressed)
+{
+    switch (id) {
+        case 0:
+            return (pressed ?
+                    MACRO( MD(LSHIFT), D(D), END ) :
+                    MACRO( U(D), MU(LSHIFT), END ) );
+        case 1:
+            return (pressed ?
+                    MACRO( I(255), T(H), T(E), T(L), T(L), W(255), T(O), END ) :
+                    MACRO_NONE );
+    }
+    return 0;
+}
+
+
+
 /*
  * user defined action function
  */
-void keymap_call_function(keyrecord_t *record, uint8_t id)
+void keymap_call_function(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
     keyevent_t event = record->event;
     uint8_t tap_count = record->tap_count;
@@ -261,6 +286,9 @@ void keymap_call_function(keyrecord_t *record, uint8_t id)
                 }
             }
             break;
+        case MACRO:
+            action_macro_play(get_macro(opt, event.pressed));
+            break;
     }
 }