|
| 1 | +/* jshint laxbreak: true */ |
| 2 | + |
| 3 | +new Object({ |
| 4 | + moduleMeta: { /* Module infos */ |
| 5 | + displayName: 'MuKeyboard', |
| 6 | + version: 1.0, |
| 7 | + author: 'MrMoDDoM' |
| 8 | + }, |
| 9 | + |
| 10 | + functionMap: { /* Functions */ |
| 11 | + REM: function(argList, µ) { |
| 12 | + argList.shift(); |
| 13 | + |
| 14 | + µ.setData('nodelay', true); |
| 15 | + return ' // ' + argList.join(' ') + '\n'; |
| 16 | + }, |
| 17 | + |
| 18 | + TYPE: function(argList, µ) { |
| 19 | + argList.shift(); |
| 20 | + |
| 21 | + if(argList.length < 1) { |
| 22 | + µ.throwError("No argument provided for TYPE"); |
| 23 | + return; |
| 24 | + } |
| 25 | + |
| 26 | + if(µ.keyMap[argList[0]] !== undefined) { |
| 27 | + return ' typeKey(\'' + µ.keyMap[argList[0]] + '\');\n\n'; |
| 28 | + } else { |
| 29 | + µ.throwError("Unknown command or key: '" + argList[0] + "'"); |
| 30 | + return; |
| 31 | + } |
| 32 | + }, |
| 33 | + |
| 34 | + STRING: function(argList, µ) { |
| 35 | + argList.shift(); |
| 36 | + |
| 37 | + if(argList.length < 1) { |
| 38 | + µ.throwError("No argument provided for STRING"); |
| 39 | + return; |
| 40 | + } |
| 41 | + |
| 42 | + var textString = argList.join(' '); |
| 43 | + |
| 44 | + // Replace all '"' by '\"' and all '\' by '\\' |
| 45 | + textString = textString.split('\\').join('\\\\').split('"').join('\\"'); |
| 46 | + |
| 47 | + if(textString !== '') { |
| 48 | + return ' Keyboard.print(F("' + textString + '"));\n\n'; |
| 49 | + } |
| 50 | + }, |
| 51 | + |
| 52 | + DELAY: function(argList, µ) { |
| 53 | + argList.shift(); |
| 54 | + |
| 55 | + if(argList.length < 1) { |
| 56 | + µ.throwError("No argument provided for DELAY"); |
| 57 | + return; |
| 58 | + } |
| 59 | + |
| 60 | + if(!isNaN(argList[0])) { |
| 61 | + µ.setData('nodelay', true); |
| 62 | + |
| 63 | + return ' wait(' + argList[0] + ');\n'; |
| 64 | + } else { |
| 65 | + µ.throwError("Invalid argument, DELAY only acceptes numbers"); |
| 66 | + return; |
| 67 | + } |
| 68 | + }, |
| 69 | + |
| 70 | + DEFAULTDELAY: function(argList, µ) { // Not working .-. |
| 71 | + argList.shift(); |
| 72 | + |
| 73 | + if(argList.length < 1) { |
| 74 | + µ.throwError("No argument provided for DEFAULTDELAY"); |
| 75 | + return; |
| 76 | + } |
| 77 | + |
| 78 | + if(!isNaN(argList[0])) { |
| 79 | + µ.setData('defaultdelay', argList[0]); |
| 80 | + µ.setData('nodelay', true); |
| 81 | + |
| 82 | + return ''; |
| 83 | + } else { |
| 84 | + µ.throwError("Invalid argument, DEFAULTDELAY only acceptes numbers"); |
| 85 | + return; |
| 86 | + } |
| 87 | + }, |
| 88 | + DEFAULT_DELAY: function() {return this.DEFAULTDELAY.apply(this, [].slice.call(arguments));}, |
| 89 | + |
| 90 | + REPEAT: function(argList, µ) { |
| 91 | + argList.shift(); |
| 92 | + |
| 93 | + if(argList.length < 1) { |
| 94 | + µ.throwError("No argument provided for REPLAY"); |
| 95 | + return; |
| 96 | + } |
| 97 | + |
| 98 | + var lastOutput = µ.trimLast(); |
| 99 | + if(lastOutput === '') { |
| 100 | + throwError("Nothing to REPLAY, this is the first line"); |
| 101 | + return; |
| 102 | + } |
| 103 | + |
| 104 | + lastOutput = ' ' + lastOutput.trim() + '\n'; |
| 105 | + lastOutput = lastOutput.replace(/^ /gm,' '); |
| 106 | + |
| 107 | + if(!isNaN(argList[0])) { |
| 108 | + µ.setData('nodelay', true); |
| 109 | + |
| 110 | + return ' for(int i = 0; i < ' + argList[0] + '; i++) {\n' + lastOutput + ' }\n\n'; |
| 111 | + } else { |
| 112 | + µ.throwError("Invalid argument, REPLAY only acceptes numbers"); |
| 113 | + return; |
| 114 | + } |
| 115 | + }, |
| 116 | + REPLAY: function() {return this.REPEAT.apply(this, [].slice.call(arguments));} |
| 117 | + }, |
| 118 | + |
| 119 | + commandMap: { /* Key that can be typed */ |
| 120 | + ESCAPE:'KEY_ESC', |
| 121 | + ESC:'KEY_ESC', |
| 122 | + GUI:'KEY_LEFT_GUI', |
| 123 | + WINDOWS:'KEY_LEFT_GUI', |
| 124 | + COMMAND:'KEY_LEFT_GUI', |
| 125 | + MENU:'229', |
| 126 | + APP:'229', |
| 127 | + END:'KEY_END', |
| 128 | + SPACE:'\' \'', |
| 129 | + TAB:'KEY_TAB', |
| 130 | + PRINTSCREEN:'206', |
| 131 | + ENTER:'KEY_RETURN', |
| 132 | + RETURN:'KEY_RETURN', |
| 133 | + UPARROW:'KEY_UP_ARROW', |
| 134 | + DOWNARROW:'KEY_DOWN_ARROW', |
| 135 | + LEFTARROW:'KEY_LEFT_ARROW', |
| 136 | + RIGHTARROW:'KEY_RIGHT_ARROW', |
| 137 | + UP:'KEY_UP_ARROW', |
| 138 | + DOWN:'KEY_DOWN_ARROW', |
| 139 | + LEFT:'KEY_LEFT_ARROW', |
| 140 | + RIGHT:'KEY_RIGHT_ARROW', |
| 141 | + CAPSLOCK:'KEY_CAPS_LOCK', |
| 142 | + DELETE:'KEY_DELETE', |
| 143 | + DEL:'KEY_DELETE', |
| 144 | + F1:'KEY_F1', |
| 145 | + F2:'KEY_F2', |
| 146 | + F3:'KEY_F3', |
| 147 | + F4:'KEY_F4', |
| 148 | + F5:'KEY_F5', |
| 149 | + F6:'KEY_F6', |
| 150 | + F7:'KEY_F7', |
| 151 | + F8:'KEY_F8', |
| 152 | + F9:'KEY_F9', |
| 153 | + F10:'KEY_F10', |
| 154 | + F11:'KEY_F11', |
| 155 | + F12:'KEY_F12', |
| 156 | + PAGEUP:'KEY_PAGE_UP', |
| 157 | + PAGEDOWN:'KEY_PAGE_DOWN' |
| 158 | + }, |
| 159 | + |
| 160 | + comboMap: { /* Key that can only be used in combos */ |
| 161 | + ALT:'KEY_LEFT_ALT', |
| 162 | + SHIFT:'KEY_LEFT_SHIFT', |
| 163 | + CTRL:'KEY_LEFT_CTRL', |
| 164 | + CONTROL:'KEY_LEFT_CTRL' |
| 165 | + }, |
| 166 | + |
| 167 | + keyMap: { /* Normal keys */ |
| 168 | + a:'a', |
| 169 | + b:'b', |
| 170 | + c:'c', |
| 171 | + d:'d', |
| 172 | + e:'e', |
| 173 | + f:'f', |
| 174 | + g:'g', |
| 175 | + h:'h', |
| 176 | + i:'i', |
| 177 | + j:'j', |
| 178 | + k:'k', |
| 179 | + l:'l', |
| 180 | + m:'m', |
| 181 | + n:'n', |
| 182 | + o:'o', |
| 183 | + p:'p', |
| 184 | + q:'q', |
| 185 | + r:'r', |
| 186 | + s:'s', |
| 187 | + t:'t', |
| 188 | + u:'u', |
| 189 | + v:'v', |
| 190 | + w:'w', |
| 191 | + x:'x', |
| 192 | + y:'y', |
| 193 | + z:'z' |
| 194 | + }, |
| 195 | + |
| 196 | + postLine: function(lineStr, µ) { |
| 197 | + var processedLine = lineStr; |
| 198 | + |
| 199 | + /* If the defaultdelay has been set, push delay to the line start */ |
| 200 | + if(µ.getData('defaultdelay') !== undefined && µ.getData('nodelay') == false) |
| 201 | + processedLine = ' wait(' + µ.getData('defaultdelay') + ');\n' + processedLine; |
| 202 | + |
| 203 | + /* Reset the nodelay statement */ |
| 204 | + µ.setData('nodelay', false); |
| 205 | + |
| 206 | + return processedLine; |
| 207 | + }, |
| 208 | + |
| 209 | + computeKeys: function(keyArray) { /* Function who returns the code for keys combos */ |
| 210 | + var toReturn = ''; |
| 211 | + if(keyArray.length == 1) { |
| 212 | + toReturn = ' typeKey(' + keyArray[0] + ');\n\n'; |
| 213 | + } else { |
| 214 | + for(var i = 0; i < keyArray.length; i++) { |
| 215 | + toReturn += ' Keyboard.press(' + keyArray[i] + ');\n'; |
| 216 | + } |
| 217 | + |
| 218 | + toReturn += ' Keyboard.releaseAll();\n\n'; |
| 219 | + } |
| 220 | + |
| 221 | + return toReturn; |
| 222 | + }, |
| 223 | + |
| 224 | + getFinalCode: function(compiledCode) { /* Function who returns the usable code */ |
| 225 | + return '/**\n' |
| 226 | + + ' * Made for Duckuino with MuKeyboard.\n' |
| 227 | + + ' * Check the Duckuino's license at \'https://github.com/Nurrl/Duckuino/blob/master/LICENSE\'\n' |
| 228 | + + ' * Check the MuKeyboard project at \'https://github.com/MrMoDDoM/MuKeyboard\'\n' |
| 229 | + + ' */\n\n' |
| 230 | + + '#include "MuKeyboard.h"\n\n' |
| 231 | + + 'void typeKey(uint8_t key)\n' |
| 232 | + + '{\n' |
| 233 | + + ' Keyboard.press(key);\n' |
| 234 | + + ' wait(50);\n' |
| 235 | + + ' Keyboard.release(key);\n' |
| 236 | + + '}\n\n' |
| 237 | + + '/* Init function */\n' |
| 238 | + + 'void setup()\n' |
| 239 | + + '{\n' |
| 240 | + + ' // Begining the Keyboard stream\n' |
| 241 | + + ' Keyboard.begin();\n\n' |
| 242 | + + ' // Wait 500ms\n' |
| 243 | + + ' wait(500);\n' |
| 244 | + + '\n' |
| 245 | + + compiledCode |
| 246 | + + ' // Ending stream\n' |
| 247 | + + ' Keyboard.end();\n' |
| 248 | + + '}\n\n' |
| 249 | + + '/* Unused endless loop */\n' |
| 250 | + + 'void loop() {}'; |
| 251 | + } |
| 252 | +}); |
0 commit comments