Merge pull request #34 from srang/feature/macros

Feature/macros

config-serializer/config-items/DelayMacroAction.ts

@@ -0,0 +1,33 @@
+class DelayMacroAction extends MacroAction {
+
+    // @assertUInt16
+    delay: number;
+
+    _fromJsObject(jsObject: any): DelayMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.delay = jsObject.delay;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): DelayMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.delay = buffer.readUInt16();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.DelayMacroAction,
+            delay: this.delay
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.DelayMacroAction);
+        buffer.writeUInt16(this.delay);
+    }
+
+    toString(): string {
+        return `<DelayMacroAction delay="${this.delay}">`;
+    }
+}

config-serializer/config-items/HoldKeyMacroAction.ts

@@ -0,0 +1,33 @@
+class HoldKeyMacroAction extends MacroAction {
+
+    // @assertUInt8
+    scancode: number;
+
+    _fromJsObject(jsObject: any): HoldKeyMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.scancode = jsObject.scancode;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): HoldKeyMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.scancode = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.HoldKeyMacroAction,
+            scancode: this.scancode
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.HoldKeyMacroAction);
+        buffer.writeUInt8(this.scancode);
+    }
+
+    toString(): string {
+        return `<HoldKeyMacroAction scancode="${this.scancode}">`;
+    }
+}

config-serializer/config-items/HoldModifiersMacroAction.ts

@@ -0,0 +1,33 @@
+class HoldModifiersMacroAction extends MacroAction {
+
+    // @assertUInt8
+    modifierMask: number;
+
+    _fromJsObject(jsObject: any): HoldModifiersMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.modifierMask = jsObject.modifierMask;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): HoldModifiersMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.modifierMask = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.HoldModifiersMacroAction,
+            modifierMask: this.modifierMask
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.HoldModifiersMacroAction);
+        buffer.writeUInt8(this.modifierMask);
+    }
+
+    toString(): string {
+        return `<HoldModifiersMacroAction modifierMask="${this.modifierMask}">`;
+    }
+}

config-serializer/config-items/HoldMouseButtonsMacroAction.ts

@@ -0,0 +1,33 @@
+class HoldMouseButtonsMacroAction extends MacroAction {
+
+    // @assertUInt8
+    mouseButtonsMask: number;
+
+    _fromJsObject(jsObject: any): HoldMouseButtonsMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.mouseButtonsMask = jsObject.mouseButtonsMask;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): HoldMouseButtonsMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.mouseButtonsMask = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.HoldMouseButtonsMacroAction,
+            mouseButtonsMask: this.mouseButtonsMask
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.HoldMouseButtonsMacroAction);
+        buffer.writeUInt8(this.mouseButtonsMask);
+    }
+
+    toString(): string {
+        return `<HoldMouseButtonsMacroAction mouseButtonsMask="${this.mouseButtonsMask}">`;
+    }
+}

config-serializer/config-items/Macro.ts

@@ -0,0 +1,65 @@
+class Macro extends Serializable<Macro> {
+
+    static loopedFlag  = 0x80;
+    static privateFlag = 0x08;
+
+    // @assertUInt8
+    id: number;
+
+    isLooped: boolean;
+
+    isPrivate: boolean;
+
+    name: string;
+
+    macroActions: Serializable<MacroActions>;
+
+    _fromJsObject(jsObject: any): Macro {
+        this.id = jsObject.id;
+        this.isLooped = jsObject.isLooped;
+        this.isPrivate = jsObject.isPrivate;
+        this.name = jsObject.name;
+        this.macroActions = new MacroActions().fromJsObject(jsObject.macroActions);
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): Macro {
+        this.id = buffer.readUInt8();
+        let bools = buffer.readUInt8();
+        /* saves almost a byte but limits number of keymaps... */
+        this.isLooped = (bools & Macro.loopedFlag) !== 0;
+        this.isPrivate = (bools & Macro.privateFlag) !== 0;
+        this.name = buffer.readString();
+        this.macroActions = new MacroActions().fromBinary(buffer);
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            id: this.id,
+            isLooped: this.isLooped,
+            isPrivate: this.isPrivate,
+            name: this.name,
+            macroActions: this.macroActions.toJsObject()
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer): void {
+        buffer.writeUInt8(this.id);
+        buffer.writeUInt8(this.getLoopedFlag() | this.getPrivateFlag());
+        buffer.writeString(this.name);
+        this.macroActions.toBinary(buffer);
+    }
+
+    toString(): string {
+        return `<Macro id="${this.id}" name="${this.name}">`;
+    }
+
+    private getLoopedFlag() {
+        return this.isLooped ? Macro.loopedFlag : 0;
+    }
+
+    private getPrivateFlag() {
+        return this.isPrivate ? Macro.privateFlag : 0;
+    }
+}

config-serializer/config-items/MacroAction.ts

@@ -0,0 +1,55 @@
+enum MacroActionId {
+    PressKeyMacroAction              =  0,
+    HoldKeyMacroAction               =  1,
+    ReleaseKeyMacroAction            =  2,
+    PressModifiersMacroAction        =  3,
+    HoldModifiersMacroAction         =  4,
+    ReleaseModifiersMacroAction      =  5,
+    PressMouseButtonsMacroAction     =  6,
+    HoldMouseButtonsMacroAction      =  7,
+    ReleaseMouseButtonsMacroAction   =  8,
+    MoveMouseMacroAction             =  9,
+    ScrollMouseMacroAction           = 10,
+    DelayMacroAction                 = 11,
+    TextMacroAction                  = 12
+}
+
+let macroActionType = {
+    PressKeyMacroAction              : 'pressKey',
+    HoldKeyMacroAction               : 'holdKey',
+    ReleaseKeyMacroAction            : 'releaseKey',
+    PressModifiersMacroAction        : 'pressModifiers',
+    HoldModifiersMacroAction         : 'holdModifiers',
+    ReleaseModifiersMacroAction      : 'releaseModifiers',
+    PressMouseButtonsMacroAction     : 'pressMouseButtons',
+    HoldMouseButtonsMacroAction      : 'holdMouseButtons',
+    ReleaseMouseButtonsMacroAction   : 'releaseMouseButtons',
+    MoveMouseMacroAction             : 'moveMouse',
+    ScrollMouseMacroAction           : 'scrollMouse',
+    DelayMacroAction                 : 'delay',
+    TextMacroAction                  : 'text'
+};
+
+abstract class MacroAction extends Serializable<MacroAction> {
+    assertMacroActionType(jsObject: any) {
+        let macroActionClassname = this.constructor.name;
+        let macroActionTypeString = macroActionType[macroActionClassname];
+        if (jsObject.macroActionType !== macroActionTypeString) {
+            throw `Invalid ${macroActionClassname}.macroActionType: ${jsObject.macroActionType}`;
+        }
+    }
+
+    readAndAssertMacroActionId(buffer: UhkBuffer) {
+        let classname = this.constructor.name;
+        let readMacroActionId = buffer.readUInt8();
+        let macroActionId = MacroActionId[<string> classname];
+        if (readMacroActionId !== macroActionId) {
+            throw `Invalid ${classname} first byte: ${readMacroActionId}`;
+        }
+    }
+
+    abstract _fromJsObject(jsObject: any): MacroAction;
+    abstract _fromBinary(buffer: UhkBuffer): MacroAction;
+    abstract _toJsObject(): any;
+    abstract _toBinary(buffer: UhkBuffer): void;
+}

config-serializer/config-items/MacroActions.ts

@@ -0,0 +1,76 @@
+class MacroActions extends ClassArray<MacroAction> {
+
+    jsObjectToClass(jsObject: any): Serializable<MacroAction> {
+        switch (jsObject.macroActionType) {
+            case macroActionType.PressKeyMacroAction:
+                return new PressKeyMacroAction().fromJsObject(jsObject);
+            case macroActionType.HoldKeyMacroAction:
+                return new HoldKeyMacroAction().fromJsObject(jsObject);
+            case macroActionType.ReleaseKeyMacroAction:
+                return new ReleaseKeyMacroAction().fromJsObject(jsObject);
+            case macroActionType.PressModifiersMacroAction:
+                return new PressModifiersMacroAction().fromJsObject(jsObject);
+            case macroActionType.HoldModifiersMacroAction:
+                return new HoldModifiersMacroAction().fromJsObject(jsObject);
+            case macroActionType.ReleaseModifiersMacroAction:
+                return new ReleaseModifiersMacroAction().fromJsObject(jsObject);
+            case macroActionType.PressMouseButtonsMacroAction:
+                return new PressMouseButtonsMacroAction().fromJsObject(jsObject);
+            case macroActionType.HoldMouseButtonsMacroAction:
+                return new HoldMouseButtonsMacroAction().fromJsObject(jsObject);
+            case macroActionType.ReleaseMouseButtonsMacroAction:
+                return new ReleaseMouseButtonsMacroAction().fromJsObject(jsObject);
+            case macroActionType.MoveMouseMacroAction:
+                return new MoveMouseMacroAction().fromJsObject(jsObject);
+            case macroActionType.ScrollMouseMacroAction:
+                return new ScrollMouseMacroAction().fromJsObject(jsObject);
+            case macroActionType.DelayMacroAction:
+                return new DelayMacroAction().fromJsObject(jsObject);
+            case macroActionType.TextMacroAction:
+                return new TextMacroAction().fromJsObject(jsObject);
+            default:
+                throw `Invalid MacroAction.macroActionType: "${jsObject.macroActionType}"`;
+        }
+    }
+
+    binaryToClass(buffer: UhkBuffer): Serializable<MacroAction> {
+        let macroActionFirstByte = buffer.readUInt8();
+        buffer.backtrack();
+
+        if (buffer.enableDump) {
+            process.stdout.write(']\n');
+            buffer.enableDump = false;
+        }
+
+        switch (macroActionFirstByte) {
+            case MacroActionId.PressKeyMacroAction:
+                return new PressKeyMacroAction().fromBinary(buffer);
+            case MacroActionId.HoldKeyMacroAction:
+                return new HoldKeyMacroAction().fromBinary(buffer);
+            case MacroActionId.ReleaseKeyMacroAction:
+                return new ReleaseKeyMacroAction().fromBinary(buffer);
+            case MacroActionId.PressModifiersMacroAction:
+                return new PressModifiersMacroAction().fromBinary(buffer);
+            case MacroActionId.HoldModifiersMacroAction:
+                return new HoldModifiersMacroAction().fromBinary(buffer);
+            case MacroActionId.ReleaseModifiersMacroAction:
+                return new ReleaseModifiersMacroAction().fromBinary(buffer);
+            case MacroActionId.PressMouseButtonsMacroAction:
+                return new PressMouseButtonsMacroAction().fromBinary(buffer);
+            case MacroActionId.HoldMouseButtonsMacroAction:
+                return new HoldMouseButtonsMacroAction().fromBinary(buffer);
+            case MacroActionId.ReleaseMouseButtonsMacroAction:
+                return new ReleaseMouseButtonsMacroAction().fromBinary(buffer);
+            case MacroActionId.MoveMouseMacroAction:
+                return new MoveMouseMacroAction().fromBinary(buffer);
+            case MacroActionId.ScrollMouseMacroAction:
+                return new ScrollMouseMacroAction().fromBinary(buffer);
+            case MacroActionId.DelayMacroAction:
+                return new DelayMacroAction().fromBinary(buffer);
+            case MacroActionId.TextMacroAction:
+                return new TextMacroAction().fromBinary(buffer);
+            default:
+                throw `Invalid MacroAction first byte: ${macroActionFirstByte}`;
+        }
+    }
+}

config-serializer/config-items/Macros.ts

@@ -0,0 +1,11 @@
+class Macros extends ClassArray<Macro> {
+
+    jsObjectToClass(jsObject: any): Serializable<Macro> {
+        return new Macro().fromJsObject(jsObject);
+    }
+
+    binaryToClass(buffer: UhkBuffer): Serializable<Macro> {
+        return new Macro().fromBinary(buffer);
+    }
+
+}

config-serializer/config-items/MoveMouseMacroAction.ts

@@ -0,0 +1,40 @@
+class MoveMouseMacroAction extends MacroAction {
+
+    // @assertInt16
+    x: number;
+
+    // @assertInt16
+    y: number;
+
+    _fromJsObject(jsObject: any): MoveMouseMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.x = jsObject.x;
+        this.y = jsObject.y;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): MoveMouseMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.x = buffer.readInt16();
+        this.y = buffer.readInt16();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.MoveMouseMacroAction,
+            x: this.x,
+            y: this.y
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.MoveMouseMacroAction);
+        buffer.writeInt16(this.x);
+        buffer.writeInt16(this.y);
+    }
+
+    toString(): string {
+        return `<MoveMouseMacroAction pos="(${this.x},${this.y})">`;
+    }
+}

config-serializer/config-items/PressKeyMacroAction.ts

@@ -0,0 +1,33 @@
+class PressKeyMacroAction extends MacroAction {
+
+    // @assertUInt8
+    scancode: number;
+
+    _fromJsObject(jsObject: any): PressKeyMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.scancode = jsObject.scancode;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): PressKeyMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.scancode = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.PressKeyMacroAction,
+            scancode: this.scancode
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.PressKeyMacroAction);
+        buffer.writeUInt8(this.scancode);
+    }
+
+    toString(): string {
+        return `<PressKeyMacroAction scancode="${this.scancode}">`;
+    }
+}

config-serializer/config-items/PressModifiersMacroAction.ts

@@ -0,0 +1,33 @@
+class PressModifiersMacroAction extends MacroAction {
+
+    // @assertUInt8
+    modifierMask: number;
+
+    _fromJsObject(jsObject: any): PressModifiersMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.modifierMask = jsObject.modifierMask;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): PressModifiersMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.modifierMask = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.PressModifiersMacroAction,
+            modifierMask: this.modifierMask
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.PressModifiersMacroAction);
+        buffer.writeUInt8(this.modifierMask);
+    }
+
+    toString(): string {
+        return `<PressModifiersMacroAction modifierMask="${this.modifierMask}">`;
+    }
+}

config-serializer/config-items/PressMouseButtonsMacroAction.ts

@@ -0,0 +1,33 @@
+class PressMouseButtonsMacroAction extends MacroAction {
+
+    // @assertUInt8
+    mouseButtonsMask: number;
+
+    _fromJsObject(jsObject: any): PressMouseButtonsMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.mouseButtonsMask = jsObject.mouseButtonsMask;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): PressMouseButtonsMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.mouseButtonsMask = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.PressMouseButtonsMacroAction,
+            mouseButtonsMask: this.mouseButtonsMask
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.PressMouseButtonsMacroAction);
+        buffer.writeUInt8(this.mouseButtonsMask);
+    }
+
+    toString(): string {
+        return `<PressMouseButtonsMacroAction mouseButtonsMask="${this.mouseButtonsMask}">`;
+    }
+}

config-serializer/config-items/ReleaseKeyMacroAction.ts

@@ -0,0 +1,33 @@
+class ReleaseKeyMacroAction extends MacroAction {
+
+    // @assertUInt8
+    scancode: number;
+
+    _fromJsObject(jsObject: any): ReleaseKeyMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.scancode = jsObject.scancode;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): ReleaseKeyMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.scancode = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.ReleaseKeyMacroAction,
+            scancode: this.scancode
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.ReleaseKeyMacroAction);
+        buffer.writeUInt8(this.scancode);
+    }
+
+    toString(): string {
+        return `<ReleaseKeyMacroAction scancode="${this.scancode}">`;
+    }
+}

config-serializer/config-items/ReleaseModifiersMacroAction.ts

@@ -0,0 +1,33 @@
+class ReleaseModifiersMacroAction extends MacroAction {
+
+    // @assertUInt8
+    modifierMask: number;
+
+    _fromJsObject(jsObject: any): ReleaseModifiersMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.modifierMask = jsObject.modifierMask;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): ReleaseModifiersMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.modifierMask = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.ReleaseModifiersMacroAction,
+            modifierMask: this.modifierMask
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.ReleaseModifiersMacroAction);
+        buffer.writeUInt8(this.modifierMask);
+    }
+
+    toString(): string {
+        return `<ReleaseModifiersMacroAction modifierMask="${this.modifierMask}">`;
+    }
+}

config-serializer/config-items/ReleaseMouseButtonsMacroAction.ts

@@ -0,0 +1,33 @@
+class ReleaseMouseButtonsMacroAction extends MacroAction {
+
+    // @assertUInt8
+    mouseButtonsMask: number;
+
+    _fromJsObject(jsObject: any): ReleaseMouseButtonsMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.mouseButtonsMask = jsObject.mouseButtonsMask;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): ReleaseMouseButtonsMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.mouseButtonsMask = buffer.readUInt8();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.ReleaseMouseButtonsMacroAction,
+            mouseButtonsMask: this.mouseButtonsMask
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.ReleaseMouseButtonsMacroAction);
+        buffer.writeUInt8(this.mouseButtonsMask);
+    }
+
+    toString(): string {
+        return `<ReleaseMouseButtonsMacroAction mouseButtonsMask="${this.mouseButtonsMask}">`;
+    }
+}

config-serializer/config-items/ScrollMouseMacroAction.ts

@@ -0,0 +1,40 @@
+class ScrollMouseMacroAction extends MacroAction {
+
+    // @assertInt16
+    x: number;
+
+    // @assertInt16
+    y: number;
+
+    _fromJsObject(jsObject: any): ScrollMouseMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.x = jsObject.x;
+        this.y = jsObject.y;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): ScrollMouseMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.x = buffer.readInt16();
+        this.y = buffer.readInt16();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.ScrollMouseMacroAction,
+            x: this.x,
+            y: this.y
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.ScrollMouseMacroAction);
+        buffer.writeInt16(this.x);
+        buffer.writeInt16(this.y);
+    }
+
+    toString(): string {
+        return `<ScrollMouseMacroAction pos="(${this.x},${this.y})">`;
+    }
+}

config-serializer/config-items/TextMacroAction.ts

@@ -0,0 +1,32 @@
+class TextMacroAction extends MacroAction {
+
+    text: string;
+
+    _fromJsObject(jsObject: any): TextMacroAction {
+        this.assertMacroActionType(jsObject);
+        this.text = jsObject.text;
+        return this;
+    }
+
+    _fromBinary(buffer: UhkBuffer): TextMacroAction {
+        this.readAndAssertMacroActionId(buffer);
+        this.text = buffer.readString();
+        return this;
+    }
+
+    _toJsObject(): any {
+        return {
+            macroActionType: macroActionType.TextMacroAction,
+            text: this.text
+        };
+    }
+
+    _toBinary(buffer: UhkBuffer) {
+        buffer.writeUInt8(MacroActionId.TextMacroAction);
+        buffer.writeString(this.text);
+    }
+
+    toString(): string {
+        return `<TextMacroAction text="${this.text}">`;
+    }
+}

config-serializer/config-items/config-items.ts

@@ -15,3 +15,20 @@
 /// <reference path="Layers.ts" />
 /// <reference path="KeyMap.ts" />
 /// <reference path="KeyMaps.ts" />
+/// <reference path="Macro.ts" />
+/// <reference path="Macros.ts" />
+/// <reference path="MacroAction.ts" />
+/// <reference path="MacroActions.ts" />
+/// <reference path="PressKeyMacroAction.ts" />
+/// <reference path="HoldKeyMacroAction.ts" />
+/// <reference path="ReleaseKeyMacroAction.ts" />
+/// <reference path="PressModifiersMacroAction.ts" />
+/// <reference path="HoldModifiersMacroAction.ts" />
+/// <reference path="ReleaseModifiersMacroAction.ts" />
+/// <reference path="PressMouseButtonsMacroAction.ts" />
+/// <reference path="HoldMouseButtonsMacroAction.ts" />
+/// <reference path="ReleaseMouseButtonsMacroAction.ts" />
+/// <reference path="MoveMouseMacroAction.ts" />
+/// <reference path="ScrollMouseMacroAction.ts" />
+/// <reference path="DelayMacroAction.ts" />
+/// <reference path="TextMacroAction.ts" />

config-serializer/test-serializer.ts

@@ -10,8 +10,8 @@ let fs = require('fs');
 
 let uhkConfig = JSON.parse(fs.readFileSync('uhk-config.json'));
 
-let config1Js = uhkConfig.keymaps;
-let config1Ts: Serializable<KeyMaps> = new KeyMaps().fromJsObject(config1Js);
+let config1Js = uhkConfig.macros;
+let config1Ts: Serializable<Macros> = new Macros().fromJsObject(config1Js);
 let config1Buffer = new UhkBuffer();
 config1Ts.toBinary(config1Buffer);
 let config1BufferContent = config1Buffer.getBufferContent();
@@ -19,7 +19,7 @@ fs.writeFileSync('uhk-config.bin', config1BufferContent);
 
 config1Buffer.offset = 0;
 console.log();
-let config2Ts = new KeyMaps().fromBinary(config1Buffer);
+let config2Ts = new Macros().fromBinary(config1Buffer);
 console.log('\n');
 let config2Js = config2Ts.toJsObject();
 let config2Buffer = new UhkBuffer();

config-serializer/uhk-config.json

@@ -205,23 +205,23 @@
                 },
                 {
                     "macroActionType": "holdKey",
-                    "scancode": 111
+                    "scancode": 83
                 },
                 {
                     "macroActionType": "releaseKey",
-                    "scancode": 111
+                    "scancode": 112
                 },
                 {
                     "macroActionType": "pressModifiers",
-                    "modifierMask": 111
+                    "modifierMask": 93
                 },
                 {
                     "macroActionType": "holdModifiers",
-                    "modifierMask": 111
+                    "modifierMask": 101
                 },
                 {
                     "macroActionType": "releaseModifiers",
-                    "modifierMask": 111
+                    "modifierMask": 133
                 },
                 {
                     "macroActionType": "pressMouseButtons",
@@ -229,31 +229,60 @@
                 },
                 {
                     "macroActionType": "holdMouseButtons",
-                    "mouseButtonsMask": 9
+                    "mouseButtonsMask": 12
                 },
                 {
                     "macroActionType": "releaseMouseButtons",
-                    "mouseButtonsMask": 9
+                    "mouseButtonsMask": 104
                 },
                 {
                     "macroActionType": "moveMouse",
-                    "x": 123,
-                    "y": 123
+                    "x": -1920,
+                    "y": 220
                 },
                 {
                     "macroActionType": "scrollMouse",
-                    "x": 123,
-                    "y": 123
+                    "x": 0,
+                    "y": 20000
                 },
                 {
                     "macroActionType": "delay",
-                    "delay": "1000"
+                    "delay": 40000
                 },
                 {
                     "macroActionType": "text",
                     "text": "this is a text"
                 }
             ]
+        },
+        {
+            "id": 1,
+            "isLooped": true,
+            "isPrivate": true,
+            "name": "Blah Blah blah",
+            "macroActions": [
+                {
+                    "macroActionType": "pressKey",
+                    "scancode": 111
+                },
+                {
+                    "macroActionType": "releaseMouseButtons",
+                    "mouseButtonsMask": 104
+                },
+                {
+                    "macroActionType": "scrollMouse",
+                    "x": 0,
+                    "y": -20000
+                },
+                {
+                    "macroActionType": "delay",
+                    "delay": 40000
+                },
+                {
+                    "macroActionType": "text",
+                    "text": "blahhhhhhh"
+                }
+            ]
         }
     ],
     "epilogue": 1234678