int load_prefs(buffer *const b, const char *const name)
{
if (!b || !name)
{
return ERROR;
}
assert_buffer(b);
b->exec_only_options = 1;
int error = OK;
char_stream *const cs = load_stream(NULL, name, false, false);
if (cs)
{
error = play_macro(b, cs);
free_char_stream(cs);
}
else
{
error = ERROR;
}
b->exec_only_options = 0;
return error;
}
void EditBoxCollection::Dispatcher(KeyInfo& k, int iMode)
{
lock();
track_beg();
if((k.skey & 0x00FF) == kbEnter && !(k.skey & (shAlt | shCtrl | shShift)))
k.skey &= ~shIsCtrl;
keydef_pair* pre_key = (iMode) ? keys.GetDef("kbBeforeKey"):0;
keydef_pair* post_key = (iMode) ? keys.GetDef("kbAfterKey"):0;
if(pre_key)
{
pre_key = keydef_pair::copy(pre_key); //create a copy of the def
play_macro(pre_key->prog);
track_recording(pre_key, 0);
}
if(k.skey & shIsCtrl)
{
keydef_pair* prog = keys.GetDef(k.KeyName);
if(prog)
{
prog = keydef_pair::copy(prog); //create a copy of the def
play_macro(prog->prog);
track_recording(prog, 0);
}
}
else
{
track_recording(0, (char)k.key);
usual_key(k);
doFlashBracket(*this, 0);
}
if(post_key)
{
post_key = keydef_pair::copy(post_key); //create a copy of the def
play_macro(post_key->prog);
track_recording(post_key, 0);
}
track_end();
unlock();
}
void qrepeat_macro(void)
{
SHORT reps;
if((icb.macro_mode|MACRO_OK) == USE_MACRO)
return;
reps = flix.hdr.frame_count-1;
if(!soft_qreq_number(&reps,1,100,"macro_repeat"))
return;
softerr(play_macro(reps),"macro_use");
}
int8 master_macro_aws(int16 step){
int16 addr;
int8 macro_cmd[2];
int16 macro_arg[2];
int8 macro_end;
--step;
addr = macro_address[0] + (step*6);
init_ext_eeprom();
// port
macro_cmd[0] = read_ext_eeprom(addr);
++addr;
macro_arg[0] = read16_ext_eeprom(addr);
++addr;
++addr;
// macro
macro_cmd[1] = read_ext_eeprom(addr);
++addr;
macro_arg[1] = read16_ext_eeprom(addr);
++addr;
++addr;
macro_end = read_ext_eeprom(addr);
// check basic structure
if (macro_cmd[0] == 'P' && macro_cmd[1] == 'M') {
RTC_read();
RTC_display();
fprintf(COM_A, "%c%Lu,%c%Lu\r\n",
macro_cmd[0], macro_arg[0], // port
macro_cmd[1], macro_arg[1]); // macro
if (macro_arg[1] > 0 && macro_arg[1] < 17) {
play_macro(macro_arg[1], macro_arg[0]); // [1] casts to int8 / [0] = port
}
}
else {
cmd_err();
macro_end = 59;
}
return (macro_end);
}
void quse_macro(void)
{
if((icb.macro_mode|MACRO_OK) == USE_MACRO)
return;
softerr(play_macro(1),"macro_use");
}
Errcode get_macro_input(void)
/* read and process macro into input stream */
{
int readsize;
Errcode err;
USHORT oflags;
if((err = poll_macro_abort()) < Success)
goto error;
if(Mcb.macbuf == NULL) /* no input record in buffer read one in */
{
if(Mcb.sizeleft <= 0) /* end of macro file stream */
{
if(--Mcb.repeats > 0)
{
if((err = play_macro(Mcb.repeats)) < Success)
goto error;
}
else
{
err = Err_abort;
goto error;
}
}
if(Mcb.next.b[0] & MACRO_REC) /* not an input record */
goto reuse_last;
/* retrieve record head and calculate record size to read */
Mcb.ioflags = Mcb.next.flags;
readsize = sizeof(USHORT); /* short for prefetch of next record head */
if(Mcb.ioflags & HAS_CCOUNT) /* get previous io state and count */
{
if((err = ffread(Mcb.fp,&oflags,sizeof(USHORT))) < Success)
goto error;
Mcb.sizeleft -= sizeof(USHORT);
if(oflags & CCOUNT_SHORT)
readsize += sizeof(USHORT);
else if(oflags & CCOUNT_LONG)
readsize += sizeof(ULONG);
else
readsize += sizeof(UBYTE);
if(oflags & HAS_MOUSEX)
readsize += sizeof(SHORT);
if(oflags & HAS_MOUSEY)
readsize += sizeof(SHORT);
if(oflags & HAS_HISTATE)
readsize += sizeof(USHORT);
}
if(Mcb.ioflags & KEYHIT)
readsize += sizeof(USHORT);
if(Mcb.ioflags & HAS_PRESSURE)
readsize += sizeof(UBYTE);
if(Mcb.ioflags & HAS_MOUSEX)
readsize += sizeof(SHORT);
if(Mcb.ioflags & HAS_MOUSEY)
readsize += sizeof(SHORT);
if(Mcb.ioflags & HAS_HISTATE)
readsize += sizeof(USHORT);
if((Mcb.sizeleft -= readsize) < 0)
readsize -= sizeof(USHORT); /* end of file, NO next record */
if( readsize != 0
&& (err = ffread(Mcb.fp,Mcb.mbuf,readsize)) < Success)
{
goto error;
}
/* get last short in buffer, this is head of next rec or garbage if
* end of file (previous short before buffer) */
Mcb.next.flags = *(USHORT *)&(Mcb.mbuf[readsize-sizeof(USHORT)]);
Mcb.macbuf = Mcb.mbuf; /* flag record present, at start of buffer */
if(Mcb.ioflags & HAS_CCOUNT)
{
/* add count to possibly decremented value and get count of
* polls left to do before using this record */
if(oflags & CCOUNT_SHORT)
{
Mcb.iocount += VGETVAL(Mcb.macbuf,USHORT);
}
else if(oflags & CCOUNT_LONG)
{
Mcb.iocount += VGETVAL(Mcb.macbuf,ULONG);
}
else
{
Mcb.iocount += VGETVAL(Mcb.macbuf,UBYTE);
}
if((LONG)Mcb.iocount < 0)
/* oops, file corrupt or program outta sync */
{
err = Err_macrosync;
goto error;
}
/* item with poll count has to provide previous input state
* to re-create recorded conditions in _poll_input() */
icb.state = oflags & MACSTATE;
if(oflags & HAS_MOUSEX)
{
icb.sx = VGETVAL(Mcb.macbuf,SHORT);
}
if(oflags & HAS_MOUSEY)
{
icb.sy = VGETVAL(Mcb.macbuf,SHORT);
}
if(oflags & HAS_HISTATE)
{
HISTATE_WORD(icb.state) |= VGETVAL(Mcb.macbuf,USHORT);
}
if(Mcb.iocount == 0) /* if count is zero we must put this
* iostate into the previous state
* otherwise next poll will do this
* in poll input */
{
SET_BUPBITS(icb.state);
icb.ostate = icb.state & ALL_BSTATES;
get_menucursorxy(); /* recalc previous values as current */
ICB_COPYTO_LAST(); /* put them in last buffer */
}
}
}
if(Mcb.iocount > 0) /* we have record, but keep polling */
goto reuse_last;
/* count satisfied, let user have recorded input */
icb.state = Mcb.ioflags & MACSTATE;
if(icb.state & KEYHIT)
{
icb.inkey = VGETVAL(Mcb.macbuf,USHORT);
}
else
icb.inkey = 0;
if(Mcb.ioflags & HAS_PRESSURE)
{
icb.pressure = VGETVAL(Mcb.macbuf,UBYTE);
}
else
icb.pressure = PRESSURE_MAX;
if(Mcb.ioflags & HAS_MOUSEX)
{
Mcb.lastmouse.x = VGETVAL(Mcb.macbuf,SHORT);
}
if(Mcb.ioflags & HAS_MOUSEY)
{
Mcb.lastmouse.y = VGETVAL(Mcb.macbuf,SHORT);
}
*((Short_xy *)&icb.sx) = Mcb.lastmouse;
if(Mcb.ioflags & HAS_HISTATE)
{
Mcb.last_histate = VGETVAL(Mcb.macbuf,USHORT);
}
HISTATE_WORD(icb.state) |= Mcb.last_histate;
Mcb.macbuf = NULL; /* flag macro consumed no longer present */
return(Success);
reuse_last:
--Mcb.iocount; /* decrement input poll counter */
icb.state &= ALL_BSTATES; /* clear changed _poll_input() unique flags */
return(Success);
error:
return(macro_read_error(err));
}
void handle_code_actuate(const uint8_t code, const uint8_t action, const uint8_t tapkey)
{
const uint8_t modaction = (action & MOD_ACTION_MASK);
if (modaction)
{
g_autokey_modifier = modaction;
}
switch(code)
{
case HID_KEYBOARD_SC_A:
case HID_KEYBOARD_SC_B:
case HID_KEYBOARD_SC_C:
case HID_KEYBOARD_SC_D:
case HID_KEYBOARD_SC_E:
case HID_KEYBOARD_SC_F:
case HID_KEYBOARD_SC_G:
case HID_KEYBOARD_SC_H:
case HID_KEYBOARD_SC_I:
case HID_KEYBOARD_SC_J:
case HID_KEYBOARD_SC_K:
case HID_KEYBOARD_SC_L:
case HID_KEYBOARD_SC_M:
case HID_KEYBOARD_SC_N:
case HID_KEYBOARD_SC_O:
case HID_KEYBOARD_SC_P:
case HID_KEYBOARD_SC_Q:
case HID_KEYBOARD_SC_R:
case HID_KEYBOARD_SC_S:
case HID_KEYBOARD_SC_T:
case HID_KEYBOARD_SC_U:
case HID_KEYBOARD_SC_V:
case HID_KEYBOARD_SC_W:
case HID_KEYBOARD_SC_X:
case HID_KEYBOARD_SC_Y:
case HID_KEYBOARD_SC_Z:
case HID_KEYBOARD_SC_1_AND_EXCLAMATION:
case HID_KEYBOARD_SC_2_AND_AT:
case HID_KEYBOARD_SC_3_AND_HASHMARK:
case HID_KEYBOARD_SC_4_AND_DOLLAR:
case HID_KEYBOARD_SC_5_AND_PERCENTAGE:
case HID_KEYBOARD_SC_6_AND_CARET:
case HID_KEYBOARD_SC_7_AND_AMPERSAND:
case HID_KEYBOARD_SC_8_AND_ASTERISK:
case HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS:
case HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS:
case HID_KEYBOARD_SC_ENTER:
case HID_KEYBOARD_SC_ESCAPE:
case HID_KEYBOARD_SC_BACKSPACE:
case HID_KEYBOARD_SC_TAB:
case HID_KEYBOARD_SC_SPACE:
case HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE:
case HID_KEYBOARD_SC_EQUAL_AND_PLUS:
case HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE:
case HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE:
case HID_KEYBOARD_SC_BACKSLASH_AND_PIPE:
case HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE:
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON:
case HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE:
case HID_KEYBOARD_SC_GRAVE_ACCENT_AND_TILDE:
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN:
case HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN:
case HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK:
case HID_KEYBOARD_SC_CAPS_LOCK:
case HID_KEYBOARD_SC_F1:
case HID_KEYBOARD_SC_F2:
case HID_KEYBOARD_SC_F3:
case HID_KEYBOARD_SC_F4:
case HID_KEYBOARD_SC_F5:
case HID_KEYBOARD_SC_F6:
case HID_KEYBOARD_SC_F7:
case HID_KEYBOARD_SC_F8:
case HID_KEYBOARD_SC_F9:
case HID_KEYBOARD_SC_F10:
case HID_KEYBOARD_SC_F11:
case HID_KEYBOARD_SC_F12:
case HID_KEYBOARD_SC_PRINT_SCREEN:
case HID_KEYBOARD_SC_SCROLL_LOCK:
case HID_KEYBOARD_SC_PAUSE:
case HID_KEYBOARD_SC_INSERT:
case HID_KEYBOARD_SC_HOME:
case HID_KEYBOARD_SC_PAGE_UP:
case HID_KEYBOARD_SC_DELETE:
case HID_KEYBOARD_SC_END:
case HID_KEYBOARD_SC_PAGE_DOWN:
case HID_KEYBOARD_SC_RIGHT_ARROW:
case HID_KEYBOARD_SC_LEFT_ARROW:
case HID_KEYBOARD_SC_DOWN_ARROW:
case HID_KEYBOARD_SC_UP_ARROW:
case HID_KEYBOARD_SC_NUM_LOCK:
case HID_KEYBOARD_SC_KEYPAD_SLASH:
case HID_KEYBOARD_SC_KEYPAD_ASTERISK:
case HID_KEYBOARD_SC_KEYPAD_MINUS:
case HID_KEYBOARD_SC_KEYPAD_PLUS:
case HID_KEYBOARD_SC_KEYPAD_ENTER:
case HID_KEYBOARD_SC_KEYPAD_1_AND_END:
case HID_KEYBOARD_SC_KEYPAD_2_AND_DOWN_ARROW:
case HID_KEYBOARD_SC_KEYPAD_3_AND_PAGE_DOWN:
case HID_KEYBOARD_SC_KEYPAD_4_AND_LEFT_ARROW:
case HID_KEYBOARD_SC_KEYPAD_5:
case HID_KEYBOARD_SC_KEYPAD_6_AND_RIGHT_ARROW:
case HID_KEYBOARD_SC_KEYPAD_7_AND_HOME:
case HID_KEYBOARD_SC_KEYPAD_8_AND_UP_ARROW:
case HID_KEYBOARD_SC_KEYPAD_9_AND_PAGE_UP:
case HID_KEYBOARD_SC_KEYPAD_0_AND_INSERT:
case HID_KEYBOARD_SC_KEYPAD_DOT_AND_DELETE:
case HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE:
case HID_KEYBOARD_SC_APPLICATION:
case HID_KEYBOARD_SC_POWER:
case HID_KEYBOARD_SC_KEYPAD_EQUAL_SIGN:
case HID_KEYBOARD_SC_F13:
case HID_KEYBOARD_SC_F14:
case HID_KEYBOARD_SC_F15:
case HID_KEYBOARD_SC_F16:
case HID_KEYBOARD_SC_F17:
case HID_KEYBOARD_SC_F18:
case HID_KEYBOARD_SC_F19:
case HID_KEYBOARD_SC_F20:
case HID_KEYBOARD_SC_F21:
case HID_KEYBOARD_SC_F22:
case HID_KEYBOARD_SC_F23:
case HID_KEYBOARD_SC_F24:
#ifdef MACRO_RAM_SIZE
if (g_recording_macro)
record_stroke(code);
#endif /* MACRO_RAM_SIZE */
alpha_down(code, action);
break;
case HID_KEYBOARD_SC_LOCKING_CAPS_LOCK:
queue_autokeys(HID_KEYBOARD_SC_CAPS_LOCK, g_modifier_state);
break;
case HID_KEYBOARD_SC_LOCKING_NUM_LOCK:
queue_autokeys(HID_KEYBOARD_SC_NUM_LOCK, g_modifier_state);
break;
case HID_KEYBOARD_SC_LOCKING_SCROLL_LOCK:
queue_autokeys(HID_KEYBOARD_SC_SCROLL_LOCK, g_modifier_state);
break;
#ifdef MAX_NUMBER_OF_BACKLIGHTS
case SCANCODE_BL_DIMMER:
backlight_dimmer();
break;
case SCANCODE_BL_MODE:
backlight_mode();
break;
case SCANCODE_BL_ENABLE:
backlight_enable();
break;
#else
case SCANCODE_BL_DIMMER:
led_dimmer();
break;
#endif /* MAX_NUMBER_OF_BACKLIGHTS */
#ifdef MACRO_RAM_SIZE
case SCANCODE_PASSWORD1:
case SCANCODE_PASSWORD2:
case SCANCODE_PASSWORD3:
case SCANCODE_PASSWORD4:
if (!g_recording_macro)
start_password_record(code);
break;
#endif /* MACRO_RAM_SIZE */
case SCANCODE_KEYLOCK:
g_keylock_flag ^= 1;
break;
case SCANCODE_WINLOCK:
g_winlock_flag ^= 1;
if (g_winlock_flag == 0)
led_host_off(LED_WIN_LOCK);
else
led_host_on(LED_WIN_LOCK);
break;
case SCANCODE_ESCGRAVE:
break;
case SCANCODE_BOOT:
g_reset_requested = RESET_TO_BOOT;
break;
case SCANCODE_CONFIG:
if (g_console_state == CONSOLE_IDLE)
g_console_state = CONSOLE_MENU_MAIN;
break;
case SCANCODE_MUTE:
case SCANCODE_VOL_INC:
case SCANCODE_VOL_DEC:
case SCANCODE_BASS_BOOST:
case SCANCODE_NEXT_TRACK:
case SCANCODE_PREV_TRACK:
case SCANCODE_STOP:
case SCANCODE_PLAY_PAUSE:
case SCANCODE_BACK:
case SCANCODE_FORWARD:
case SCANCODE_MEDIA:
case SCANCODE_MAIL:
case SCANCODE_CALC:
case SCANCODE_MYCOMP:
case SCANCODE_SEARCH:
case SCANCODE_BROWSER:
set_media(code);
break;
#ifdef ENABLE_MOUSE
case SCANCODE_MOUSE1:
case SCANCODE_MOUSE2:
case SCANCODE_MOUSE3:
case SCANCODE_MOUSE4:
case SCANCODE_MOUSE5:
set_mousebutton(code);
break;
case SCANCODE_MOUSEXR:
g_mouse_req_X++;
goto mousemove;
case SCANCODE_MOUSEXL:
g_mouse_req_X--;
goto mousemove;
case SCANCODE_MOUSEYU:
g_mouse_req_Y--;
goto mousemove;
case SCANCODE_MOUSEYD:
g_mouse_req_Y++;
mousemove:
if ((g_mouse_active == 0) || (g_mouse_multiply < g_double_tap_repeat))
g_mouse_multiply = g_double_tap_repeat;
break;
#endif /* ENABLE_MOUSE */
case SCANCODE_M1:
case SCANCODE_M2:
case SCANCODE_M3:
case SCANCODE_M4:
case SCANCODE_M5:
case SCANCODE_M6:
case SCANCODE_M7:
case SCANCODE_M8:
case SCANCODE_M9:
case SCANCODE_M10:
case SCANCODE_M11:
case SCANCODE_M12:
case SCANCODE_M13:
case SCANCODE_M14:
play_macro(code);
break;
#ifdef MACRO_RAM_SIZE
case SCANCODE_MRAM_RECORD:
toggle_macro_record();
break;
case SCANCODE_MRAM_PLAY:
if (!g_recording_macro)
queue_ram_macro(g_ram_macro, g_ram_macro_length);
break;
#endif /* MACRO_RAM_SIZE */
case HID_KEYBOARD_SC_LEFT_CONTROL:
case HID_KEYBOARD_SC_LEFT_SHIFT:
case HID_KEYBOARD_SC_LEFT_ALT:
case HID_KEYBOARD_SC_LEFT_GUI:
case HID_KEYBOARD_SC_RIGHT_CONTROL:
case HID_KEYBOARD_SC_RIGHT_SHIFT:
case HID_KEYBOARD_SC_RIGHT_ALT:
case HID_KEYBOARD_SC_RIGHT_GUI:
mod_down(code, action);
break;
case SCANCODE_FN:
case SCANCODE_FN2:
case SCANCODE_FN3:
case SCANCODE_FN4:
case SCANCODE_FN5:
case SCANCODE_FN6:
case SCANCODE_FN7:
case SCANCODE_FN8:
case SCANCODE_FN9:
fn_down(code, action);
break;
default:
report_event(EVENT_CODE_KEYMAP_INVALID_CODE, code, MODE_UPDATE);
break;
}
g_last_keypress = code;
}
