// SDL doesn't use callbacks, so we must check the events ourselves
void main_loop() {
SDL_Event event;
SDL_Event prev_event;
int retval;
for(;;) {
// We can wait on an event (as we are doing here), or we can poll for
// events and, if there are no events waiting to be processed, we can
// call our idle function. This allows for a slightly more versatile
// event handler than with a callback-based approach, as with GLUT.
if(!SDL_WaitEvent(&event)) continue;
event_switch:
switch(event.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
mouse_button(event.button.button, event.button.state,
event.button.x, event.button.y);
break;
case SDL_MOUSEMOTION:
// This is a hack to keep the motion from being so jumpy on
// slow cards
do {
prev_event = event;
retval = SDL_PollEvent(&event);
} while(retval != 0 && event.type == SDL_MOUSEMOTION);
if(retval != 0) {
// SDL_PushEvent(&event);
// event = prev_event;
mouse_motion(prev_event.motion.state,
prev_event.motion.x, prev_event.motion.y);
goto event_switch;
}
mouse_motion(event.motion.state,
event.motion.x, event.motion.y);
break;
case SDL_KEYUP:
keyfunc(event.key.keysym.sym);
break;
case SDL_VIDEORESIZE:
set_window_size(event.resize.w, event.resize.h);
break;
case SDL_QUIT:
return;
}
}
}
static int indexer(
Operation *op,
MDB_txn *txn,
struct mdb_attrinfo *ai,
AttributeDescription *ad,
struct berval *atname,
BerVarray vals,
ID id,
int opid,
slap_mask_t mask )
{
int rc = LDAP_OTHER;
struct berval *keys;
MDB_cursor *mc = ai->ai_cursor;
mdb_idl_keyfunc *keyfunc;
char *err __maybe_unused;
assert( mask != 0 );
if ( !mc ) {
err = "c_open";
rc = mdb_cursor_open( txn, ai->ai_dbi, &mc );
if ( rc ) goto done;
if ( slapMode & SLAP_TOOL_QUICK )
ai->ai_cursor = mc;
}
if ( opid == SLAP_INDEX_ADD_OP ) {
#ifdef MDB_TOOL_IDL_CACHING
if (( slapMode & SLAP_TOOL_QUICK ) && slap_tool_thread_max > 2 ) {
keyfunc = mdb_tool_idl_add;
mc = (MDB_cursor *)ai;
} else
#endif
keyfunc = mdb_idl_insert_keys;
} else
keyfunc = mdb_idl_delete_keys;
if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
rc = keyfunc( op->o_bd, mc, presence_key, id );
if( rc ) {
err = "presence";
goto done;
}
}
if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
rc = ad->ad_type->sat_equality->smr_indexer(
LDAP_FILTER_EQUALITY,
mask,
ad->ad_type->sat_syntax,
ad->ad_type->sat_equality,
atname, vals, &keys, op->o_tmpmemctx );
if( rc == LDAP_SUCCESS && keys != NULL ) {
rc = keyfunc( op->o_bd, mc, keys, id );
ber_bvarray_free_x( keys, op->o_tmpmemctx );
if ( rc ) {
err = "equality";
goto done;
}
}
rc = LDAP_SUCCESS;
}
if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
rc = ad->ad_type->sat_approx->smr_indexer(
LDAP_FILTER_APPROX,
mask,
ad->ad_type->sat_syntax,
ad->ad_type->sat_approx,
atname, vals, &keys, op->o_tmpmemctx );
if( rc == LDAP_SUCCESS && keys != NULL ) {
rc = keyfunc( op->o_bd, mc, keys, id );
ber_bvarray_free_x( keys, op->o_tmpmemctx );
if ( rc ) {
err = "approx";
goto done;
}
}
rc = LDAP_SUCCESS;
}
if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
rc = ad->ad_type->sat_substr->smr_indexer(
LDAP_FILTER_SUBSTRINGS,
mask,
ad->ad_type->sat_syntax,
ad->ad_type->sat_substr,
atname, vals, &keys, op->o_tmpmemctx );
if( rc == LDAP_SUCCESS && keys != NULL ) {
rc = keyfunc( op->o_bd, mc, keys, id );
ber_bvarray_free_x( keys, op->o_tmpmemctx );
if( rc ) {
err = "substr";
goto done;
}
}
rc = LDAP_SUCCESS;
}
done:
if ( !(slapMode & SLAP_TOOL_QUICK)) {
if (mc == ai->ai_cursor)
ai->ai_cursor = NULL;
mdb_cursor_close( mc );
}
switch( rc ) {
/* The callers all know how to deal with these results */
case 0:
break;
/* Anything else is bad news */
default:
rc = LDAP_OTHER;
}
return rc;
}
int cmd_key(context_t *context) {
int ret = 0;
int i, j;
int c;
char *cmd = *context->argv;
charcodemap_t *active_mods = NULL;
int active_mods_n;
useconds_t key_delay = 12000;
useconds_t repeat_delay = 0;
int repeat = 1;
const char *window_arg = NULL;
int free_arg = 0;
/* Options */
int clear_modifiers = 0;
static struct option longopts[] = {
{ "clearmodifiers", no_argument, NULL, 'c' },
{ "delay", required_argument, NULL, 'd' },
{ "repeat-delay", required_argument, NULL, 'R' },
{ "help", no_argument, NULL, 'h' },
{ "window", required_argument, NULL, 'w' },
{ "repeat", required_argument, NULL, 'r' },
{ 0, 0, 0, 0 },
};
static const char *usage =
"Usage: %s [options] <keysequence> [keysequence ...]\n"
"--clearmodifiers - clear active keyboard modifiers during keystrokes\n"
"--delay DELAY - Use DELAY milliseconds between keystrokes\n"
"--repeat TIMES - How many times to repeat the key sequence\n"
"--repeat-delay DELAY - DELAY milliseconds between repetitions\n"
"--window WINDOW - send keystrokes to a specific window\n"
"Each keysequence can be any number of modifiers and keys, separated by plus (+)\n"
" For example: alt+r\n"
"\n"
"Any letter or key symbol such as Shift_L, Return, Dollar, a, space are valid,\n"
"including those not currently available on your keyboard.\n"
"\n"
"If no window is given, and there are windows in the stack, %1 is used. Otherwise\n"
"the currently-focused window is used\n"
HELP_CHAINING_ENDS;
int option_index;
while ((c = getopt_long_only(context->argc, context->argv, "+d:hcw:",
longopts, &option_index)) != -1) {
switch (c) {
case 'w':
window_arg = strdup(optarg);
free_arg = 1;
break;
case 'c':
clear_modifiers = 1;
break;
case 'h':
printf(usage, cmd);
consume_args(context, context->argc);
return EXIT_SUCCESS;
break;
case 'd':
/* Argument is in milliseconds, keysequence delay is in microseconds. */
key_delay = strtoul(optarg, NULL, 0) * 1000;
break;
case 'r':
repeat = atoi(optarg);
if (repeat < 1) {
fprintf(stderr, "Invalid '--repeat' value given: %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 'R': // --repeat-delay
/* Argument is in milliseconds, keysequence delay is in microseconds. */
repeat_delay = strtoul(optarg, NULL, 0) * 1000;
break;
default:
fprintf(stderr, usage, cmd);
return EXIT_FAILURE;
}
}
consume_args(context, optind);
if (context->argc == 0) {
fprintf(stderr, "You specified the wrong number of args.\n");
fprintf(stderr, usage, cmd);
return 1;
}
/* use %1 if there is a window stack */
if (window_arg == NULL && context->nwindows > 0) {
window_arg = "%1";
}
int (*keyfunc)(const xdo_t *, Window, const char *, useconds_t) = NULL;
if (!strcmp(cmd, "key")) {
keyfunc = xdo_send_keysequence_window;
} else if (!strcmp(cmd, "keyup")) {
keyfunc = xdo_send_keysequence_window_up;
} else if (!strcmp(cmd, "keydown")) {
keyfunc = xdo_send_keysequence_window_down;
} else {
fprintf(stderr, "Unknown command '%s'\n", cmd);
return 1;
}
int max_arg = context->argc;
window_each(context, window_arg, {
if (clear_modifiers) {
xdo_get_active_modifiers(context->xdo, &active_mods, &active_mods_n);
xdo_clear_active_modifiers(context->xdo, window, active_mods, active_mods_n);
}
for (j = 0; j < repeat; j++) {
for (i = 0; i < context->argc; i++) {
if (is_command(context->argv[i])) {
max_arg = i;
break;
}
int tmp = keyfunc(context->xdo, window, context->argv[i], key_delay);
if (tmp != 0) {
fprintf(stderr,
"xdo_send_keysequence_window reported an error for string '%s'\n",
context->argv[i]);
}
ret += tmp;
} /* each keysequence */
/* Sleep if --repeat-delay given and not on the last repetition */
if (repeat_delay > 0 && j < (repeat-1)) {
usleep(repeat_delay);
}
} /* repeat */
if (clear_modifiers) {
xdo_set_active_modifiers(context->xdo, window, active_mods, active_mods_n);
free(active_mods);
}
}); /* window_each(...) */
